Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import Foundation
struct MobileWebShellAsset {
let file: URL
let contentType: String
}
enum MobileWebShellGenerationError: Error {
case unreadable
}
/// Serve only a prebuilt manifest path map, never request-time path joins. TypeScript verifies bytes before activation; native uses an app-owned directory.
struct MobileWebShellGeneration {
static let manifestName = "manifest.json"
static let manifestContentType = "application/json"
static let schemaVersion = 1
static let entrypoint = "index.html"
static let maxAssets = 256
static let maxAssetPathLength = 255
static let maxContentTypeLength = 128
let entries: [String: MobileWebShellAsset]
static func load(directoryPath: String) throws -> MobileWebShellGeneration {
guard directoryPath.hasPrefix("/") else { throw MobileWebShellGenerationError.unreadable }
let directory = URL(fileURLWithPath: directoryPath, isDirectory: true)
guard
let data = try? Data(contentsOf: directory.appendingPathComponent(manifestName))
else { throw MobileWebShellGenerationError.unreadable }
return try make(manifestData: data, directory: directory)
}
static func make(manifestData: Data, directory: URL) throws -> MobileWebShellGeneration {
let parsed = try? JSONSerialization.jsonObject(with: manifestData)
guard
let root = parsed as? [String: Any],
isPinnedSchemaVersion(root["schemaVersion"]),
let declaredEntrypoint = root["entrypoint"] as? String,
declaredEntrypoint == entrypoint,
let assets = root["assets"] as? [[String: Any]],
!assets.isEmpty,
assets.count <= maxAssets
else { throw MobileWebShellGenerationError.unreadable }
var entries: [String: MobileWebShellAsset] = [:]
for asset in assets {
guard
let path = asset["path"] as? String,
isServableAssetPath(path),
let contentType = asset["contentType"] as? String,
isServableContentType(contentType)
else { throw MobileWebShellGenerationError.unreadable }
entries["/\(path)"] = MobileWebShellAsset(
file: directory.appendingPathComponent(path, isDirectory: false),
contentType: contentType
)
}
// Remove the entrypoint alias: only / may serve document bytes with the CSP header.
guard let document = entries.removeValue(forKey: "/\(entrypoint)") else {
throw MobileWebShellGenerationError.unreadable
}
entries["/"] = document
// Bootstrap reads the last-written manifest, which is excluded from the content hash/assets.
entries["/\(manifestName)"] = MobileWebShellAsset(
file: directory.appendingPathComponent(manifestName, isDirectory: false),
contentType: manifestContentType
)
return MobileWebShellGeneration(entries: entries)
}
/// NSNumber bridges true and 1.0 to Int; check JSON’s written number type to require integer 1.
static func isPinnedSchemaVersion(_ value: Any?) -> Bool {
guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() else {
return false
}
let numberType = String(cString: number.objCType)
guard numberType != "d", numberType != "f" else { return false }
return number.intValue == schemaVersion
}
/// Revalidate the schema across the TypeScript/native file boundary.
static func isServableAssetPath(_ path: String) -> Bool {
guard !path.isEmpty, path.utf8.count <= maxAssetPathLength else { return false }
for segment in path.split(separator: "/", omittingEmptySubsequences: false) {
guard !segment.isEmpty, segment != ".", segment != ".." else { return false }
let valid = segment.allSatisfy { character in
character.isASCII &&
(character.isLetter || character.isNumber || character == "." || character == "_" ||
character == "-")
}
guard valid else { return false }
}
return true
}
/// Accept one lowercase MIME type and optional charset to prevent header/parameter injection.
static func isServableContentType(_ contentType: String) -> Bool {
guard !contentType.isEmpty, contentType.utf8.count <= maxContentTypeLength else { return false }
var type = Substring(contentType)
if let separator = contentType.range(of: "; charset=") {
let charset = contentType[separator.upperBound...]
let validCharset = !charset.isEmpty && charset.allSatisfy { character in
character.isASCII &&
(("a"..."z").contains(character) || ("0"..."9").contains(character) || character == "-")
}
guard validCharset else { return false }
type = contentType[contentType.startIndex..<separator.lowerBound]
}
let halves = type.split(separator: "/", omittingEmptySubsequences: false)
guard halves.count == 2 else { return false }
return halves.allSatisfy(isMimeToken)
}
private static func isMimeToken(_ token: Substring) -> Bool {
guard
let first = token.first,
first.isASCII,
("a"..."z").contains(first) || ("0"..."9").contains(first)
else { return false }
return token.allSatisfy { character in
character.isASCII &&
(("a"..."z").contains(character) || ("0"..."9").contains(character) ||
character == "." || character == "+" || character == "-")
}
}
}