@abide/abide 0.58.0 → 0.100.0

package/src/lib/cli/runCli.ts

@@ -1,188 +0,0 @@
-import { clearLastConnection } from '../shared/clearLastConnection.ts'
-import { loadEnvFromDataDir } from '../shared/loadEnvFromDataDir.ts'
-import { messageFromError } from '../shared/messageFromError.ts'
-import { completeCli } from './completeCli.ts'
-import { connectToServer } from './connectToServer.ts'
-import { dispatchCommand } from './dispatchCommand.ts'
-import { loadEnvFromBinaryDir } from './loadEnvFromBinaryDir.ts'
-import { printCommandHelp } from './printCommandHelp.ts'
-import { printTopLevelHelp } from './printTopLevelHelp.ts'
-import { printTrimmed } from './printTrimmed.ts'
-import { renderCliCompletions } from './renderCliCompletions.ts'
-import { resolveCliTarget } from './resolveCliTarget.ts'
-import { runSession } from './runSession.ts'
-import { startLocalInstance } from './startLocalInstance.ts'
-import { tokenizeArgvFlags } from './tokenizeArgvFlags.ts'
-import type { CliManifest } from './types/CliManifest.ts'
-import type { CliTarget } from './types/CliTarget.ts'
-
-const isHelpFlag = (arg: string): boolean => arg === '--help' || arg === '-h'
-
-/*
-Whether a command's argv tail genuinely requests help, i.e. a help flag appears
-at a flag position rather than as the value of a value-expecting flag. Shares
-tokenizeArgvFlags' grammar with parseArgvForRpc so the two can't drift: the
-tokenizer applies the flag-consumption rule (boolean / `--name=…` / `--json`
-consume their value), so a `--help` that was a flag's value is already swallowed
-and never surfaces as a help token — `--title --help` passes `--help` as the
-title value, not a help request.
-*/
-function commandArgvRequestsHelp(
-    argvTail: string[],
-    jsonSchema: Record<string, unknown> | undefined,
-): boolean {
-    for (const token of tokenizeArgvFlags(argvTail, jsonSchema)) {
-        if (token.isHelp) {
-            return true
-        }
-    }
-    return false
-}
-
-/*
-Top-level CLI driver for the standalone binary. The binary is a thin remote client
-— it carries no handler code, so it always talks to a running server over HTTP, but
-it can boot one: the full binary ships the server beside it, so `/start` spawns a
-local instance. One rule governs the first positional — `/` manages the connection,
-a bare word runs a command:
-
-  --help / -h                     → top-level help
-  /help [cmd]                     → help (per-command with an arg)
-  (none) + TTY                    → interactive session, resuming the saved connection
-  (none) + non-TTY                → top-level help (scripts use `<cmd>` one-shot)
-  /connect <url>                  → connect to a remote server, open a session
-  /start                          → boot a local instance, open a session
-  /disconnect                     → forget the saved connection, exit
-  /completions <shell>            → print a bash/zsh/fish completion script (local, no connection)
-  <cmd> [--flags]                 → one-shot RPC against the resumed target
-
-The connection rpcs are `/`-prefixed only — no bare aliases — so a bare word is
-always an RPC command and never collides. Env layers ABIDE_APP_URL/ABIDE_APP_TOKEN (shell >
-data-dir > binary-dir) supply the baked default a fresh download resumes against.
-*/
-export async function runCli({
-    programName,
-    manifest,
-    banner = '',
-    footer = '',
-    argv,
-}: {
-    programName: string
-    manifest: CliManifest
-    banner?: string
-    footer?: string
-    argv: string[]
-}): Promise<number> {
-    await loadEnvFromDataDir(programName)
-    await loadEnvFromBinaryDir()
-
-    const first = argv[0]
-
-    // Explicit help, top-level and per-command.
-    if (first && isHelpFlag(first)) {
-        printTopLevelHelp(programName, manifest, banner, footer)
-        return 0
-    }
-    if (first === '/help') {
-        if (argv[1]) {
-            printCommandHelp(programName, argv[1], manifest)
-        } else {
-            printTopLevelHelp(programName, manifest, banner, footer)
-        }
-        return 0
-    }
-    if (first && commandArgvRequestsHelp(argv.slice(1), manifest[first]?.jsonSchema)) {
-        printCommandHelp(programName, first, manifest)
-        return 0
-    }
-
-    // Shell completion: `--query` answers a live tab (candidates from the baked
-    // manifest, no server needed), otherwise emit the wrapper script for a shell.
-    if (first === '/completions') {
-        if (argv[1] === '--query') {
-            const cword = Number(argv[2] ?? '1')
-            const command = argv[3]
-            for (const candidate of completeCli(
-                manifest,
-                Number.isNaN(cword) ? 1 : cword,
-                command,
-            )) {
-                console.log(candidate)
-            }
-            return 0
-        }
-        const script = renderCliCompletions(programName, argv[1])
-        if (!script) {
-            console.error(`${programName}: /completions requires a shell — bash, zsh, or fish`)
-            return 1
-        }
-        process.stdout.write(script)
-        return 0
-    }
-
-    // No command: interactive session on a TTY, help otherwise (scripts/pipes).
-    if (!first) {
-        if (!process.stdin.isTTY) {
-            printTopLevelHelp(programName, manifest, banner, footer)
-            return 0
-        }
-        printTrimmed(banner)
-        const target = await resolveCliTarget(programName)
-        return runSession({ programName, manifest, footer, target })
-    }
-
-    // Disconnect (reset): clear the saved connection and exit.
-    if (first === '/disconnect') {
-        await clearLastConnection(programName)
-        console.log('disconnected')
-        return 0
-    }
-
-    // Connect to a remote server, then open a session.
-    if (first === '/connect') {
-        const url = argv[1]
-        if (!url) {
-            console.error(`${programName}: /connect requires a url`)
-            return 1
-        }
-        printTrimmed(banner)
-        const target = await connectToServer(programName, url)
-        if (!target) {
-            return 1
-        }
-        return runSession({ programName, manifest, footer, target })
-    }
-
-    // Start a local instance, then open a session.
-    if (first === '/start') {
-        printTrimmed(banner)
-        let target: CliTarget
-        try {
-            target = await startLocalInstance(programName)
-        } catch (error) {
-            console.error(`${programName}: ${messageFromError(error)}`)
-            return 1
-        }
-        return runSession({ programName, manifest, footer, target })
-    }
-
-    // One-shot RPC dispatch (scripting): resolve the target without a session.
-    const target = await resolveCliTarget(programName)
-    if (!target) {
-        console.error(
-            `${programName}: not connected — run \`${programName} /connect <url>\` or \`${programName} /start\``,
-        )
-        return 1
-    }
-    const code = await dispatchCommand({
-        programName,
-        manifest,
-        command: first,
-        argvTail: argv.slice(1),
-        url: target.url,
-        token: target.token,
-    })
-    // Reap any local instance booted just to resolve the target.
-    target.child?.kill()
-    return code
-}

package/src/lib/cli/runSession.ts

@@ -1,107 +0,0 @@
-import { clearLastConnection } from '../shared/clearLastConnection.ts'
-import { messageFromError } from '../shared/messageFromError.ts'
-import { connectToServer } from './connectToServer.ts'
-import { dispatchCommand } from './dispatchCommand.ts'
-import { printSessionHelp } from './printSessionHelp.ts'
-import { printSessionStatus } from './printSessionStatus.ts'
-import { printTrimmed } from './printTrimmed.ts'
-import { startLocalInstance } from './startLocalInstance.ts'
-import { tokenizeLine } from './tokenizeLine.ts'
-import type { CliManifest } from './types/CliManifest.ts'
-import type { CliTarget } from './types/CliTarget.ts'
-
-/*
-Interactive session (REPL). The banner is printed once by the caller; this prints
-the status line, then loops reading stdin lines via Bun's async-iterable console:
-  - bare words   → dispatch the RPC against the current target
-  - /connect <url>, /start, /disconnect, /help, /clear, /exit → meta commands
-The session owns the current target's child (a local instance) and reaps it when
-the connection is swapped or the loop ends — including on SIGINT.
-*/
-export async function runSession({
-    programName,
-    manifest,
-    footer,
-    target,
-}: {
-    programName: string
-    manifest: CliManifest
-    footer: string
-    target: CliTarget | undefined
-}): Promise<number> {
-    let current = target
-    // Reap any local instance on Ctrl+C — the closure reads the latest `current`.
-    // Named + removed on exit so repeated sessions in one process don't accumulate listeners.
-    const onSigint = () => {
-        current?.child?.kill()
-        process.exit(0)
-    }
-    process.on('SIGINT', onSigint)
-
-    // Swap the active connection: reap the previous local instance (only one runs
-    // at a time), adopt the next target, and reprint the status line.
-    async function swap(next: CliTarget | undefined): Promise<void> {
-        current?.child?.kill()
-        current = next
-        await printSessionStatus(current)
-    }
-
-    await printSessionStatus(current)
-    const promptText = `${programName}> `
-    process.stdout.write(promptText)
-
-    for await (const line of console) {
-        const tokens = tokenizeLine(line.trim())
-        const head = tokens[0]
-        if (head === undefined) {
-            process.stdout.write(promptText)
-            continue
-        }
-        if (head === '/exit' || head === '/quit') {
-            break
-        }
-        if (head === '/clear') {
-            console.clear()
-        } else if (head === '/help') {
-            printSessionHelp(programName, manifest, tokens[1])
-        } else if (head === '/connect') {
-            const url = tokens[1]
-            if (!url) {
-                console.error('/connect requires a url')
-            } else {
-                const next = await connectToServer(programName, url)
-                if (next) {
-                    await swap(next)
-                }
-            }
-        } else if (head === '/start') {
-            try {
-                await swap(await startLocalInstance(programName))
-            } catch (error) {
-                console.error(`could not start local instance: ${messageFromError(error)}`)
-            }
-        } else if (head === '/disconnect') {
-            await clearLastConnection(programName)
-            await swap(undefined)
-        } else if (head.startsWith('/')) {
-            console.error(`unknown command "${head}" — /help for the list`)
-        } else if (!current) {
-            console.error('not connected — /connect <url> or /start')
-        } else {
-            await dispatchCommand({
-                programName,
-                manifest,
-                command: head,
-                argvTail: tokens.slice(1),
-                url: current.url,
-                token: current.token,
-            })
-        }
-        process.stdout.write(promptText)
-    }
-
-    process.removeListener('SIGINT', onSigint)
-    current?.child?.kill()
-    printTrimmed(footer)
-    return 0
-}

package/src/lib/cli/startLocalInstance.ts

@@ -1,14 +0,0 @@
-import { spawnEmbeddedServer } from '../bundle/spawnEmbeddedServer.ts'
-import { writeLastConnection } from '../shared/writeLastConnection.ts'
-import type { CliTarget } from './types/CliTarget.ts'
-
-/*
-Boots a local (embedded) instance for this session and records the intent so the
-next bare run resumes a local instance. The caller owns the returned child and
-reaps it on disconnect/exit. Throws if the server crashes before binding.
-*/
-export async function startLocalInstance(programName: string): Promise<CliTarget> {
-    const { url, child } = await spawnEmbeddedServer({ programName })
-    await writeLastConnection(programName, { kind: 'embedded' })
-    return { url, child }
-}

package/src/lib/cli/tokenizeArgvFlags.ts

@@ -1,86 +0,0 @@
-/*
-The single argv-tail flag grammar shared by help-detection (runCli) and RPC arg
-parsing (parseArgvForRpc) so the two can never drift. Walks the tail and yields
-one token per flag occurrence, honouring the schema-driven consumption rule:
-
-  - `--help` / `-h`               → { isHelp: true }, consumes no following token
-  - `--json <blob>`               → { isJson: true, value }, consumes the next token
-                                     (the value is the verbatim JSON args bag)
-  - boolean props (and `--no-x`)  → { name, value: undefined }, consumes no token
-  - `--name=value`                → { name, value }, inline, consumes no token
-  - everything else               → { name, value }, consumes the next token
-
-`--no-x` negates only a known boolean property x; otherwise the literal `no-…`
-name is kept so a property legitimately named `no-…` stays reachable. Reports
-`negated` and `missingValue` so the parser can apply boolean/coercion semantics
-and throw precise errors. A bare positional (no leading `--`) yields
-{ positional: token } so each consumer rejects or ignores it as it sees fit.
-
-Pure; reads the schema's `properties` only to classify boolean props.
-*/
-export function* tokenizeArgvFlags(
-    argvTail: string[],
-    jsonSchema: Record<string, unknown> | undefined,
-): Generator<{
-    isHelp?: boolean
-    isJson?: boolean
-    positional?: string
-    name?: string
-    value?: string
-    negated?: boolean
-    missingValue?: boolean
-}> {
-    const properties =
-        (jsonSchema?.properties as Record<string, { type?: string }> | undefined) ?? {}
-    for (let index = 0; index < argvTail.length; index += 1) {
-        const token = argvTail[index] as string
-        if (token === '--help' || token === '-h') {
-            yield { isHelp: true }
-            continue
-        }
-        if (!token.startsWith('--')) {
-            yield { positional: token }
-            continue
-        }
-        // `--json <blob>`: the next token is the verbatim JSON args bag.
-        if (token === '--json') {
-            const value = argvTail[index + 1]
-            if (value === undefined) {
-                yield { isJson: true, missingValue: true }
-            } else {
-                index += 1
-                yield { isJson: true, value }
-            }
-            continue
-        }
-        const stripped = token.slice('--'.length)
-        const [literalName, inlineValue] = stripped.includes('=')
-            ? [stripped.slice(0, stripped.indexOf('=')), stripped.slice(stripped.indexOf('=') + 1)]
-            : [stripped, undefined]
-        /* `--no-x` negates only a known boolean property x; otherwise the literal
-           name wins, so a property legitimately named `no-…` stays reachable. */
-        const negatedName = literalName.startsWith('no-')
-            ? literalName.slice('no-'.length)
-            : undefined
-        const negated = negatedName !== undefined && properties[negatedName]?.type === 'boolean'
-        const name = negated ? (negatedName as string) : literalName
-        // Boolean props and inline `--name=value` consume no following token. Pass any
-        // inline value through (`--flag=false`) so the parser can honour the RHS instead
-        // of the boolean always resolving to true.
-        if (properties[name]?.type === 'boolean') {
-            yield { name, negated, value: inlineValue }
-            continue
-        }
-        if (inlineValue !== undefined) {
-            yield { name, value: inlineValue }
-            continue
-        }
-        const value = argvTail[index + 1]
-        if (value === undefined) {
-            yield { name, missingValue: true }
-        } else {
-            index += 1
-            yield { name, value }
-        }
-    }
-}

package/src/lib/cli/tokenizeLine.ts

@@ -1,51 +0,0 @@
-/*
-Splits a session input line into argv tokens, honouring single and double quotes
-so values with spaces survive (e.g. `post --title "hello world"`). Quotes group;
-a backslash escapes the next character (outside single quotes). Unterminated
-quotes consume to end of line. Pure; no shell features beyond quoting — no
-globbing, no variable expansion.
-*/
-export function tokenizeLine(line: string): string[] {
-    const tokens: string[] = []
-    let current = ''
-    let hasToken = false
-    let quote: '"' | "'" | undefined
-    for (let index = 0; index < line.length; index++) {
-        const char = line[index]
-        if (char === '\\' && quote !== "'") {
-            const next = line[++index]
-            if (next !== undefined) {
-                current += next
-                hasToken = true
-            }
-            continue
-        }
-        if (quote) {
-            if (char === quote) {
-                quote = undefined
-            } else {
-                current += char
-            }
-            continue
-        }
-        if (char === '"' || char === "'") {
-            quote = char
-            hasToken = true
-            continue
-        }
-        if (char === ' ' || char === '\t') {
-            if (hasToken) {
-                tokens.push(current)
-                current = ''
-                hasToken = false
-            }
-            continue
-        }
-        current += char
-        hasToken = true
-    }
-    if (hasToken) {
-        tokens.push(current)
-    }
-    return tokens
-}

package/src/lib/cli/types/CliManifest.ts

@@ -1,11 +0,0 @@
-import type { CliManifestEntry } from './CliManifestEntry.ts'
-
-/*
-Map from command name (URL-derived via commandNameForUrl, e.g. "getReport"
-or "users-list") to its manifest entry. Built by the bundler from
-rpcRegistry and socketRegistry; entries are emitted for rpcs and sockets
-with `clients.cli: true`. Sockets produce `<base>-tail` (and `-publish`
-when `allowClientPublish` is set). The CLI binary and any programmatic
-createClient caller read this to dispatch calls.
-*/
-export type CliManifest = Record<string, CliManifestEntry>

package/src/lib/cli/types/CliManifestEntry.ts

@@ -1,17 +0,0 @@
-import type { HttpMethod } from '../../shared/types/HttpMethod.ts'
-
-/*
-Per-command manifest entry baked into the standalone CLI binary by the
-bundler. Carries enough info to make the right HTTP request without
-importing the handler module (which the thin build doesn't ship). Covers
-both rpcs and socket commands — a socket `tail` is a GET against
-`/__abide/sockets/<name>` with `accept: text/event-stream` so the CLI
-streams it live; a socket `publish` is a POST to the same path.
-*/
-export type CliManifestEntry = {
-    method: HttpMethod
-    url: string
-    jsonSchema?: Record<string, unknown>
-    // Request Accept header. Socket tail sets text/event-stream to stream live frames.
-    accept?: string
-}

package/src/lib/cli/types/CliTarget.ts

@@ -1,13 +0,0 @@
-/*
-A resolved CLI connection: the server URL plus an optional bearer token, and the
-child process when this is a locally-spawned instance — the session owns that
-child and reaps it on disconnect/exit.
-*/
-export type CliTarget = {
-    url: string
-    token?: string
-    child?: ReturnType<typeof Bun.spawn>
-    // The app's name from its identity probe, when already fetched while resolving
-    // the target — lets the status line print it without re-probing.
-    name?: string
-}

package/src/lib/mcp/annotationsForMethod.ts

@@ -1,29 +0,0 @@
-import type { HttpMethod } from '../shared/types/HttpMethod.ts'
-
-/*
-Maps an HTTP method to MCP tool annotations so a model can tell a read from
-a write before calling. Abide derives these from the HTTP method the RPC was
-declared with rather than asking the author to repeat the intent:
-  - GET / HEAD  → read-only, non-destructive
-  - POST        → creates; not idempotent, not (necessarily) destructive
-  - PUT         → replaces; idempotent + destructive
-  - PATCH       → modifies; destructive, not idempotent
-  - DELETE      → removes; idempotent + destructive
-The shape matches MCP's ToolAnnotations (readOnlyHint / destructiveHint /
-idempotentHint); fields a rpc doesn't imply are left off.
-*/
-export function annotationsForMethod(method: HttpMethod): Record<string, boolean> {
-    switch (method) {
-        case 'GET':
-        case 'HEAD':
-            return { readOnlyHint: true, destructiveHint: false }
-        case 'POST':
-            return { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
-        case 'PUT':
-            return { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
-        case 'PATCH':
-            return { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
-        case 'DELETE':
-            return { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
-    }
-}

package/src/lib/mcp/buildPrompts.ts

@@ -1,25 +0,0 @@
-import { promptRegistry } from '../server/prompts/promptRegistry.ts'
-import type { PromptDescriptor } from './types/PromptDescriptor.ts'
-
-/*
-MCP prompts derived from src/mcp/prompts. Arguments come from the JSON
-Schema the resolver built from each prompt's frontmatter `arguments` list
-(top-level properties + required flags); the model fills them in and the
-framework interpolates them into the body on getPrompt.
-*/
-export function buildPrompts(): PromptDescriptor[] {
-    return Array.from(promptRegistry.values()).map((entry) => {
-        const jsonSchema = entry.jsonSchema ?? {}
-        const properties = (jsonSchema.properties ?? {}) as Record<string, { description?: string }>
-        const required = new Set((jsonSchema.required as string[] | undefined) ?? [])
-        return {
-            name: entry.prompt.name,
-            ...(entry.prompt.description ? { description: entry.prompt.description } : {}),
-            arguments: Object.entries(properties).map(([argName, prop]) => ({
-                name: argName,
-                ...(prop?.description ? { description: prop.description } : {}),
-                required: required.has(argName),
-            })),
-        }
-    })
-}

package/src/lib/mcp/createMcpResourceServer.ts

@@ -1,113 +0,0 @@
-// node:fs existsSync — cheap sync presence check, mirrors createPublicAssetServer
-import { existsSync } from 'node:fs'
-import { resolve, sep } from 'node:path'
-import { Glob } from 'bun'
-import { mimeForExtension } from '../server/runtime/mimeForExtension.ts'
-import type { Assets } from '../server/runtime/types/Assets.ts'
-import type { McpResourceContents } from './types/McpResourceContents.ts'
-import type { McpResourceDescriptor } from './types/McpResourceDescriptor.ts'
-import type { McpResourceServer } from './types/McpResourceServer.ts'
-
-/*
-The abide:// URI namespace for file-based resources. A resource's URI is this
-prefix followed by its path relative to src/mcp/resources.
-*/
-const URI_PREFIX = 'abide://resources/'
-
-/*
-MIME essences returned inline as UTF-8 `text` in resources/read; everything
-else is returned as a base64 `blob`. The essence is taken before any `;charset`
-parameter that Bun.file().type appends.
-*/
-function isTextMime(mime: string): boolean {
-    // split() always yields a first element; the '' default exists for noUncheckedIndexedAccess in consumer tsconfigs.
-    const essence = (mime.split(';')[0] ?? '').trim()
-    return (
-        essence.startsWith('text/') ||
-        essence === 'application/json' ||
-        essence === 'application/xml' ||
-        essence === 'image/svg+xml' ||
-        essence.endsWith('+json') ||
-        essence.endsWith('+xml')
-    )
-}
-
-function descriptorFor(relativePath: string): McpResourceDescriptor {
-    return {
-        uri: `${URI_PREFIX}${relativePath}`,
-        name: relativePath,
-        mimeType: mimeForExtension(relativePath),
-    }
-}
-
-function contentsFor(relativePath: string, bytes: Uint8Array): McpResourceContents {
-    const mimeType = mimeForExtension(relativePath)
-    const uri = `${URI_PREFIX}${relativePath}`
-    if (isTextMime(mimeType)) {
-        return { uri, mimeType, text: new TextDecoder().decode(bytes) }
-    }
-    return { uri, mimeType, blob: bytes.toBase64() }
-}
-
-/*
-Serves files under src/mcp/resources as MCP resources. Two sources, picked at
-construction (mirrors createPublicAssetServer):
-  - `mcpResources` (standalone compile): a map of relative-path → gzip bytes
-    embedded into the binary.
-  - `resourcesDir` on disk (dev + `abide start`): files read straight from
-    `${cwd}/src/mcp/resources`.
-*/
-export function createMcpResourceServer({
-    resourcesDir,
-    mcpResources,
-}: {
-    resourcesDir: string
-    mcpResources?: Assets
-}): McpResourceServer {
-    return {
-        async list(): Promise<McpResourceDescriptor[]> {
-            if (mcpResources) {
-                return Object.keys(mcpResources).map(descriptorFor)
-            }
-            if (!existsSync(resourcesDir)) {
-                return []
-            }
-            const files = await Array.fromAsync(
-                new Glob('**/*').scan({ cwd: resourcesDir, onlyFiles: true }),
-            )
-            return files.map(descriptorFor)
-        },
-        async read(uri: string): Promise<McpResourceContents | undefined> {
-            if (!uri.startsWith(URI_PREFIX)) {
-                return undefined
-            }
-            const relativePath = uri.slice(URI_PREFIX.length)
-            // reject `..` traversal on EITHER separator — a backslash-joined `..\` escapes
-            // resourcesDir on Windows (its OS layer treats `\` as a separator regardless of
-            // how the JS string was built), so a `/`-only split lets it through.
-            if (relativePath.split(/[\\/]/).includes('..')) {
-                return undefined
-            }
-            if (mcpResources) {
-                const compressed = mcpResources[relativePath]
-                if (!compressed) {
-                    return undefined
-                }
-                return contentsFor(relativePath, Bun.gunzipSync(compressed))
-            }
-            // Belt-and-braces for the on-disk branch: resolve the target and confirm it
-            // stays inside resourcesDir, catching any traversal the segment check missed
-            // (absolute paths, platform separator quirks).
-            const root = resolve(resourcesDir)
-            const target = resolve(root, relativePath)
-            if (target !== root && !target.startsWith(root + sep)) {
-                return undefined
-            }
-            const file = Bun.file(`${resourcesDir}/${relativePath}`)
-            if (!(await file.exists())) {
-                return undefined
-            }
-            return contentsFor(relativePath, await file.bytes())
-        },
-    }
-}