@fungi.computer/computer 0.0.1 → 0.2.0

package/dist/operation-contract.d.ts

@@ -1,456 +0,0 @@
-import * as z from "zod";
-export declare const maximumFileBytes: number;
-export declare const maximumListEntries = 256;
-export declare const maximumPatternCharacters = 512;
-export declare const maximumCommandCharacters: number;
-export declare const maximumStreamBytes: number;
-/** The bound for ordinary Computer commands; hosts own any admitted job budget. */
-export declare const maximumExecutionTimeMs = 120000;
-/** Host-owned policy, never supplied in a Computer request body. */
-export type ComputerExecutionBudget = Readonly<{
-    maximumTimeMs: number;
-}>;
-export declare const genericComputerExecutionBudget: ComputerExecutionBudget;
-export declare const computerValueSchema: z.ZodJSONSchema;
-export type ComputerValue = z.output<typeof computerValueSchema>;
-export declare const capabilityNameSchema: z.ZodString;
-/** One valid TCP port number, used only with this Computer's container. */
-export declare const computerPortSchema: z.ZodNumber;
-export declare const maximumExposedPorts = 64;
-/** computerd's Workspace RPC port, pinned by the Cloudflare container backend. */
-export declare const computerDaemonPort = 8080;
-/** The Computer-owned terminal server inside the container image. */
-export declare const computerTerminalPort = 7681;
-/**
- * Ports served by the Computer's own in-container daemons. An admitted
- * preview must never reach a control plane.
- */
-export declare const computerReservedPorts: ReadonlySet<number>;
-export declare function isComputerReservedPort(port: number): boolean;
-export declare const computerPortInputSchema: z.ZodObject<{
-    port: z.ZodNumber;
-}, z.core.$strict>;
-export declare const computerPortOutputSchema: z.ZodObject<{
-    port: z.ZodNumber;
-    exposed: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const computerPortRemovalOutputSchema: z.ZodObject<{
-    port: z.ZodNumber;
-    removed: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const computerPortsOutputSchema: z.ZodObject<{
-    ports: z.ZodArray<z.ZodNumber>;
-}, z.core.$strict>;
-/** The port belongs to a Computer daemon and cannot be admitted for preview. */
-export declare class ComputerPortReservedError extends Error {
-    constructor(port: number);
-}
-/** A requested port cannot be reserved; no other process identity is disclosed. */
-export declare class ComputerPortConflictError extends Error {
-    constructor();
-}
-/** This Computer already admits the maximum number of preview ports. */
-export declare class ComputerPortLimitError extends Error {
-    constructor();
-}
-/** Native operation descriptions shared by discovery and its OpenAPI document. */
-export declare const computerCapabilitiesSchema: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    kind: z.ZodString;
-    description: z.ZodString;
-    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>>;
-export declare const pathSchema: z.ZodString;
-export declare const boundedTextSchema: (minimumLength?: number) => z.ZodString;
-/** Complete bounded UTF-8 text reads. Binary reads use the same path input. */
-export declare const readInputSchema: z.ZodObject<{
-    path: z.ZodString;
-}, z.core.$strict>;
-export type ComputerFileReadInput = z.output<typeof readInputSchema>;
-export declare const readOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    content: z.ZodString;
-}, z.core.$strict>;
-export type ComputerFileReadOutput = z.output<typeof readOutputSchema>;
-/** Optional byte window; text reads remain complete and independently bounded. */
-export declare const readBytesInputSchema: z.ZodObject<{
-    path: z.ZodString;
-    byteOffset: z.ZodOptional<z.ZodNumber>;
-    byteLength: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-export type ComputerFileByteReadInput = z.output<typeof readBytesInputSchema>;
-/** Finite byte-read reply used by admitted App frame bindings. */
-export declare const computerByteReadReplySchema: z.ZodObject<{
-    path: z.ZodString;
-    byteOffset: z.ZodNumber;
-    content: z.ZodString;
-    encoding: z.ZodLiteral<"base64">;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-/** Host-admitted App method preview; parsing does not grant port access. */
-export declare const appMethodPreviewResultSchema: z.ZodObject<{
-    previewUrl: z.ZodURL;
-    expiresAt: z.ZodNumber;
-}, z.core.$strict>;
-export declare const listLimitSchema: z.ZodDefault<z.ZodNumber>;
-export declare const listOffsetSchema: z.ZodDefault<z.ZodNumber>;
-export declare const listInputSchema: z.ZodObject<{
-    path: z.ZodDefault<z.ZodString>;
-    limit: z.ZodDefault<z.ZodNumber>;
-    offset: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
-export declare const listOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    entries: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        size: z.ZodNumber;
-        modifiedAt: z.ZodNumber;
-        type: z.ZodEnum<{
-            file: "file";
-            directory: "directory";
-            symlink: "symlink";
-        }>;
-    }, z.core.$strict>>;
-    nextOffset: z.ZodNullable<z.ZodNumber>;
-}, z.core.$strict>;
-export type ComputerFileListInput = z.output<typeof listInputSchema>;
-export type ComputerFileListOutput = z.output<typeof listOutputSchema>;
-export declare const fileContentSchema: z.ZodString;
-export declare const writeInputSchema: z.ZodObject<{
-    path: z.ZodString;
-    content: z.ZodString;
-}, z.core.$strict>;
-export declare const writeOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    bytes: z.ZodNumber;
-}, z.core.$strict>;
-export type ComputerFileWriteInput = z.output<typeof writeInputSchema>;
-export type ComputerFileWriteOutput = z.output<typeof writeOutputSchema>;
-export declare const writeBytesInputSchema: z.ZodObject<{
-    path: z.ZodString;
-}, z.core.$strict>;
-export declare const replaceInputSchema: z.ZodObject<{
-    path: z.ZodString;
-    expectedContent: z.ZodString;
-    content: z.ZodString;
-}, z.core.$strict>;
-export declare const replaceOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    bytes: z.ZodNumber;
-}, z.core.$strict>;
-export declare const globInputSchema: z.ZodObject<{
-    path: z.ZodString;
-    pattern: z.ZodString;
-    limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
-export declare const globOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    matches: z.ZodArray<z.ZodString>;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const grepInputSchema: z.ZodObject<{
-    path: z.ZodString;
-    pattern: z.ZodString;
-    regex: z.ZodDefault<z.ZodBoolean>;
-    ignoreCase: z.ZodDefault<z.ZodBoolean>;
-    limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
-export declare const grepOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    matches: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        line: z.ZodNumber;
-        text: z.ZodString;
-    }, z.core.$strict>>;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const editInputSchema: z.ZodObject<{
-    path: z.ZodString;
-    oldText: z.ZodString;
-    newText: z.ZodString;
-}, z.core.$strict>;
-export declare const editOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    bytes: z.ZodNumber;
-    diff: z.ZodString;
-    firstChangedLine: z.ZodNullable<z.ZodNumber>;
-}, z.core.$strict>;
-export { patchInputSchema, patchOutputSchema, } from "@fungi.computer/knapsack/files-patch";
-export declare const mkdirInputSchema: z.ZodObject<{
-    path: z.ZodString;
-    recursive: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const mkdirOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-}, z.core.$strict>;
-/**
- * Host-owned idempotency key for one `exec` or `bash` tool invocation. The
- * host mints it once per invocation and keeps it across its own retries of that
- * invocation; the model never sees or supplies it.
- */
-export declare const computerRequestIdSchema: z.ZodUUID;
-export type ComputerRequestId = z.output<typeof computerRequestIdSchema>;
-/** Mint the request ID for one host tool invocation. */
-export declare function mintComputerRequestId(): ComputerRequestId;
-export declare const execInputSchema: z.ZodObject<{
-    command: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-    backend: z.ZodOptional<z.ZodString>;
-    timeoutMs: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
-/** Resource hosts select a budget only after admitting their job principal. */
-export declare function computerExecutionRequestSchema(budget: ComputerExecutionBudget): z.ZodObject<{
-    command: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-    backend: z.ZodOptional<z.ZodString>;
-    timeoutMs: z.ZodDefault<z.ZodNumber>;
-    requestId: z.ZodUUID;
-}, z.core.$strict>;
-/** Host-to-Computer command request: the model input plus the host's ID. */
-export declare const execRequestSchema: z.ZodObject<{
-    command: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-    backend: z.ZodOptional<z.ZodString>;
-    timeoutMs: z.ZodDefault<z.ZodNumber>;
-    requestId: z.ZodUUID;
-}, z.core.$strict>;
-export declare const execOutputSchema: z.ZodObject<{
-    status: z.ZodEnum<{
-        completed: "completed";
-        failed: "failed";
-        cancelled: "cancelled";
-    }>;
-    exitCode: z.ZodNumber;
-    stdout: z.ZodString;
-    stderr: z.ZodString;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const computerProcessIdSchema: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>;
-export type ComputerProcessId = z.output<typeof computerProcessIdSchema>;
-/** At most this many processes may be running in one host scope at once. */
-export declare const maximumRunningProcesses = 16;
-/** At most this many process records, running or exited, are kept per host scope. */
-export declare const maximumProcessRecords = 64;
-/** Mint the durable identity of one started process. */
-export declare function mintComputerProcessId(): ComputerProcessId;
-export declare const processStartInputSchema: z.ZodObject<{
-    requestId: z.ZodString;
-    requestScope: z.ZodString;
-    port: z.ZodOptional<z.ZodNumber>;
-    command: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-/** Model input excludes the host's replay identity and authority scope. */
-export declare const processStartToolInputSchema: z.ZodObject<{
-    port: z.ZodOptional<z.ZodNumber>;
-    command: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-/** A trusted App host binds replay identity to its admitted installation and caller. */
-export declare function installationProcessScope(installation: string, method: string, actor: Readonly<{
-    kind: "member" | "agent" | "team-key";
-    id: string;
-}>): string;
-export declare const processIdInputSchema: z.ZodObject<{
-    id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>;
-}, z.core.$strict>;
-/**
- * `running`: computerd still reports the execution live. `exited`: it ended;
- * `exitCode` is null when the runtime that ran it was replaced or its record
- * expired before the exit code was observed. `uncertain`: the Computer could
- * not reach its container to check, so neither is claimed.
- */
-export declare const computerProcessStateSchema: z.ZodEnum<{
-    running: "running";
-    exited: "exited";
-    uncertain: "uncertain";
-}>;
-/**
- * `synced`: the drain that recorded this exit read all the way to EOF,
- * which is also the read that runs computerd's post-command pull.
- * `pending`: that drain gave up waiting at its own deadline (a
- * backgrounded child, for example `node server.js &`, can hold the
- * transport open long after its parent exits) -- a background
- * continuation keeps watching and upgrades this row to `synced` once it
- * reaches that real EOF, so `pending` rows stay updatable. `unknown`:
- * this exit was recorded with no pull evidence at all (a replaced
- * runtime, an expired record, or any other exit path that never drained
- * for one). Never claim `synced` without the specific evidence for this
- * exit; default to `unknown`, not `synced`.
- */
-export declare const computerProcessSyncSchema: z.ZodEnum<{
-    unknown: "unknown";
-    synced: "synced";
-    pending: "pending";
-}>;
-export type ComputerProcessSync = z.output<typeof computerProcessSyncSchema>;
-export declare const computerProcessSchema: z.ZodObject<{
-    id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>;
-    port: z.ZodNullable<z.ZodNumber>;
-    command: z.ZodString;
-    cwd: z.ZodNullable<z.ZodString>;
-    state: z.ZodEnum<{
-        running: "running";
-        exited: "exited";
-        uncertain: "uncertain";
-    }>;
-    exitCode: z.ZodNullable<z.ZodNumber>;
-    sync: z.ZodEnum<{
-        unknown: "unknown";
-        synced: "synced";
-        pending: "pending";
-    }>;
-    startedAt: z.ZodNumber;
-    endedAt: z.ZodNullable<z.ZodNumber>;
-}, z.core.$strict>;
-export type ComputerProcess = z.output<typeof computerProcessSchema>;
-export declare const processListOutputSchema: z.ZodObject<{
-    processes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>;
-        port: z.ZodNullable<z.ZodNumber>;
-        command: z.ZodString;
-        cwd: z.ZodNullable<z.ZodString>;
-        state: z.ZodEnum<{
-            running: "running";
-            exited: "exited";
-            uncertain: "uncertain";
-        }>;
-        exitCode: z.ZodNullable<z.ZodNumber>;
-        sync: z.ZodEnum<{
-            unknown: "unknown";
-            synced: "synced";
-            pending: "pending";
-        }>;
-        startedAt: z.ZodNumber;
-        endedAt: z.ZodNullable<z.ZodNumber>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const processKillOutputSchema: z.ZodObject<{
-    process: z.ZodObject<{
-        id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>;
-        port: z.ZodNullable<z.ZodNumber>;
-        command: z.ZodString;
-        cwd: z.ZodNullable<z.ZodString>;
-        state: z.ZodEnum<{
-            running: "running";
-            exited: "exited";
-            uncertain: "uncertain";
-        }>;
-        exitCode: z.ZodNullable<z.ZodNumber>;
-        sync: z.ZodEnum<{
-            unknown: "unknown";
-            synced: "synced";
-            pending: "pending";
-        }>;
-        startedAt: z.ZodNumber;
-        endedAt: z.ZodNullable<z.ZodNumber>;
-    }, z.core.$strict>;
-    signalled: z.ZodBoolean;
-}, z.core.$strict>;
-/** No process with this id was started on this Computer. */
-export declare class ComputerProcessNotFoundError extends Error {
-    constructor(id: string);
-}
-/** Every process slot is occupied by a running process. */
-export declare class ComputerProcessLimitError extends Error {
-    constructor();
-}
-export type ComputerExecInput = z.output<typeof execInputSchema>;
-export type ComputerExecRequest = z.output<typeof execRequestSchema>;
-export type ComputerExecOutput = z.output<typeof execOutputSchema>;
-export declare const computerOperationStatusSchema: z.ZodEnum<{
-    unknown: "unknown";
-    running: "running";
-    failed: "failed";
-    accepted: "accepted";
-    succeeded: "succeeded";
-    expired: "expired";
-}>;
-/** Durable operation status returned to the host that owns the request ID. */
-export declare const computerOperationResultSchema: z.ZodObject<{
-    requestId: z.ZodUUID;
-    status: z.ZodEnum<{
-        unknown: "unknown";
-        running: "running";
-        failed: "failed";
-        accepted: "accepted";
-        succeeded: "succeeded";
-        expired: "expired";
-    }>;
-    output: z.ZodNullable<z.ZodObject<{
-        status: z.ZodEnum<{
-            completed: "completed";
-            failed: "failed";
-            cancelled: "cancelled";
-        }>;
-        exitCode: z.ZodNumber;
-        stdout: z.ZodString;
-        stderr: z.ZodString;
-        truncated: z.ZodBoolean;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ComputerOperationResult = z.output<typeof computerOperationResultSchema>;
-/** Model-facing command result: the durable status without the host's ID. */
-export declare const computerToolResultSchema: z.ZodObject<{
-    output: z.ZodNullable<z.ZodObject<{
-        status: z.ZodEnum<{
-            completed: "completed";
-            failed: "failed";
-            cancelled: "cancelled";
-        }>;
-        exitCode: z.ZodNumber;
-        stdout: z.ZodString;
-        stderr: z.ZodString;
-        truncated: z.ZodBoolean;
-    }, z.core.$strict>>;
-    status: z.ZodEnum<{
-        unknown: "unknown";
-        running: "running";
-        failed: "failed";
-        accepted: "accepted";
-        succeeded: "succeeded";
-        expired: "expired";
-    }>;
-}, z.core.$strict>;
-export type ComputerToolResult = z.output<typeof computerToolResultSchema>;
-/** Project one host operation result onto the model-facing tool result. */
-export declare function computerToolResult(result: ComputerOperationResult): ComputerToolResult;
-/** Public operation vocabulary; transport adapters map these to routes. */
-export declare const computerOperationSchema: z.ZodEnum<{
-    exec: "exec";
-    "files.read": "files.read";
-    "files.readBytes": "files.readBytes";
-    "files.write": "files.write";
-    "files.writeBytes": "files.writeBytes";
-    "files.list": "files.list";
-    "files.glob": "files.glob";
-    "files.grep": "files.grep";
-    "files.edit": "files.edit";
-    "files.patch": "files.patch";
-    mkdir: "mkdir";
-    bash: "bash";
-}>;
-export type ComputerOperation = z.output<typeof computerOperationSchema>;
-export type ComputerFileReplacement = z.output<typeof replaceInputSchema>;
-export type ComputerFileReplacementResult = z.output<typeof replaceOutputSchema>;
-/** The expected file contents no longer match at atomic replacement. */
-export declare class ComputerFileConflict extends Error {
-    constructor();
-}
-/** A byte window starts beyond the current file extent. */
-export declare class ComputerFileRangeError extends Error {
-    readonly size: number;
-    constructor(size: number);
-}
-/** The requested file bytes exceed the admitted read bound. */
-export declare class ComputerFileTooLargeError extends Error {
-    constructor();
-}
-/**
- * The operations every Computer advertises; static, so hosts can describe them
- * without a call. Built on first read: deriving JSON Schema for every operation
- * is real work that a Worker should not pay at startup.
- */
-export declare function computerCapabilities(): z.output<typeof computerCapabilitiesSchema>;