@fungi.computer/computer 0.0.1 → 0.2.0

package/dist/internet-access.d.ts

@@ -0,0 +1,4 @@
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+/** This Computer's durable public-internet switch. Absence means on.
+ * Global and Team policy still override it at the egress gateway. */
+export declare function computerInternetAccess(sql: WatchdogSqliteOwner["sql"], enabled?: boolean): boolean;

package/dist/internet-access.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+/** This Computer's durable public-internet switch. Absence means on.
+ * Global and Team policy still override it at the egress gateway. */
+export function computerInternetAccess(sql, enabled) {
+    sql.exec("CREATE TABLE IF NOT EXISTS computer_internet_access (singleton INTEGER PRIMARY KEY CHECK (singleton=1), enabled INTEGER NOT NULL CHECK (enabled IN (0,1))) STRICT");
+    if (enabled !== undefined)
+        sql.exec("INSERT INTO computer_internet_access (singleton,enabled) VALUES (1,?) ON CONFLICT (singleton) DO UPDATE SET enabled=excluded.enabled", enabled ? 1 : 0);
+    const row = sql
+        .exec("SELECT enabled FROM computer_internet_access WHERE singleton=1")
+        .toArray()[0];
+    return row === undefined
+        ? true
+        : z.union([z.literal(0), z.literal(1)]).parse(row.enabled) === 1;
+}

package/dist/local-backend-replay.d.ts

@@ -0,0 +1,10 @@
+import type { SeamReplayStore } from "@fungi.computer/seam";
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+/** Private receiver-local storage ceiling, not a Team or attachment quota. */
+export declare const maximumLocalDialReplayRecords = 4096;
+/**
+ * One Computer's local-dial receiver history, in its existing owner database.
+ * Reconstruct with the same owner, never a process-generation namespace.
+ * Native SQLite owns atomicity and commit; there is no in-memory fallback.
+ */
+export declare function createLocalBackendReplayStore(owner: WatchdogSqliteOwner): SeamReplayStore;

package/dist/local-backend-replay.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+/** Private receiver-local storage ceiling, not a Team or attachment quota. */
+export const maximumLocalDialReplayRecords = 4096;
+const countSchema = z.number().int().nonnegative();
+/**
+ * One Computer's local-dial receiver history, in its existing owner database.
+ * Reconstruct with the same owner, never a process-generation namespace.
+ * Native SQLite owns atomicity and commit; there is no in-memory fallback.
+ */
+export function createLocalBackendReplayStore(owner) {
+    return {
+        admit({ nonce, now, expiresAt }) {
+            try {
+                return owner.transactionSync(() => {
+                    owner.sql
+                        .exec(`CREATE TABLE IF NOT EXISTS computer_local_dial_replay (
+            nonce TEXT PRIMARY KEY,
+            expires_at INTEGER NOT NULL
+          ) STRICT`);
+                    // Seam's last fresh instant is inclusive. Do not renew duplicate
+                    // deadlines, assume expiry order, or discard any still-live record.
+                    owner.sql.exec("DELETE FROM computer_local_dial_replay WHERE expires_at < ?", now);
+                    if (owner.sql
+                        .exec("SELECT nonce FROM computer_local_dial_replay WHERE nonce = ?", nonce)
+                        .toArray().length > 0)
+                        return "replayed";
+                    const count = countSchema.parse(owner.sql
+                        .exec("SELECT COUNT(*) AS count FROM computer_local_dial_replay")
+                        .toArray()[0]?.count);
+                    if (count >= maximumLocalDialReplayRecords)
+                        return "at-capacity";
+                    owner.sql.exec("INSERT INTO computer_local_dial_replay (nonce, expires_at) VALUES (?, ?)", nonce, expiresAt);
+                    return "admitted";
+                });
+            }
+            catch {
+                // Covers schema, decoding, statement and commit failures. SQLite rolls
+                // back a failed transaction; no successful admission escapes it.
+                return "unavailable";
+            }
+        },
+    };
+}

package/dist/local-backend.d.ts

@@ -1,4 +1,5 @@
 import type { BackendHandle, WorkspaceBackend } from "@fungi.computer/cloudflare-computer";
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 import { type LocalBackend } from "./computer-backends.js";
 /**
  * A member's machine as a Workspace backend.
@@ -44,7 +45,7 @@ export declare function localBackendAudience(computerName: string, backendId: st
  * pinned. The WebSocket upgrade carries no body, so it signs an unsigned
  * payload over the exact path.
  */
-export declare function verifyLocalBackendDial(request: Request, computerName: string, backend: LocalBackend): Promise<boolean>;
+export declare function verifyLocalBackendDial(request: Request, computerName: string, backend: LocalBackend, owner: WatchdogSqliteOwner): Promise<boolean>;
 /**
  * The public dial path: `/api/teams/:team/computers/:computer/backends/:id/connect`.
  * The Hub forwards it unchanged so the signature covers what the machine sent.

package/dist/local-backend.js

@@ -1,7 +1,8 @@
 import { workspaceStream } from "./workspace-stream.js";
 import { newWebSocketRpcSession } from "@fungi.computer/capnweb";
-import { SeamReplayGuard, importSeamVerifiers, seamHeader, verifySeamRequest, } from "@fungi.computer/seam";
+import { importSeamVerifiers, seamHeader, verifySeamRequest, } from "@fungi.computer/seam";
 import { attachedBackendId } from "./computer-backends.js";
+import { createLocalBackendReplayStore } from "./local-backend-replay.js";
 /**
  * A member's machine as a Workspace backend.
  *
@@ -120,15 +121,14 @@ export class LocalWorkspaceBackend {
 export function localBackendAudience(computerName, backendId) {
     return `fungi-local-backend:${computerName}:${backendId}`;
 }
-const dialReplay = new SeamReplayGuard();
 /**
  * Verify a machine's signed dial-in against the public key its attachment
  * pinned. The WebSocket upgrade carries no body, so it signs an unsigned
  * payload over the exact path.
  */
-export async function verifyLocalBackendDial(request, computerName, backend) {
+export async function verifyLocalBackendDial(request, computerName, backend, owner) {
     try {
-        await verifySeamRequest(await importSeamVerifiers({ [backend.deviceId]: backend.publicKey }), localBackendAudience(computerName, attachedBackendId(backend)), request.method, request.url, request.headers.get(seamHeader), null, dialReplay);
+        await verifySeamRequest(await importSeamVerifiers({ [backend.deviceId]: backend.publicKey }), localBackendAudience(computerName, attachedBackendId(backend)), request.method, request.url, request.headers.get(seamHeader), null, createLocalBackendReplayStore(owner));
         return true;
     }
     catch (cause) {

package/dist/on-box-vm.d.ts

@@ -42,24 +42,35 @@ export declare function onBoxVmPlacement(env: OnBoxVmEnv, hostId: string | undef
 declare const vmStateSchema: z.ZodObject<{
     running: z.ZodBoolean;
     runtimeId: z.ZodNullable<z.ZodString>;
-    exit: z.ZodNullable<z.ZodObject<{
+    exit: z.ZodNullable<z.ZodLazy<z.ZodObject<{
         reason: z.ZodString;
         exitedAt: z.ZodNumber;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type OnBoxVmState = z.infer<typeof vmStateSchema>;
 declare const vmInventorySchema: z.ZodArray<z.ZodObject<{
     running: z.ZodBoolean;
     runtimeId: z.ZodNullable<z.ZodString>;
-    exit: z.ZodNullable<z.ZodObject<{
+    exit: z.ZodNullable<z.ZodLazy<z.ZodObject<{
         reason: z.ZodString;
         exitedAt: z.ZodNumber;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     id: z.ZodString;
     name: z.ZodString;
     lastActive: z.ZodNumber;
 }, z.core.$strict>>;
 export type OnBoxVmInventory = z.infer<typeof vmInventorySchema>;
+export type OnBoxVmOperation = "status" | "start" | "restart" | "destroy" | "intercept" | "inventory";
+declare const OnBoxVmTimeoutError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "OnBoxVmTimeoutError";
+} & Readonly<A>;
+/** The host's outcome is unknown after a timeout; this is not evidence of offline. */
+export declare class OnBoxVmTimeoutError extends OnBoxVmTimeoutError_base<{
+    readonly operation: OnBoxVmOperation;
+    readonly timeoutMs: number;
+}> {
+    get message(): string;
+}
 /** One Durable Object's view of its microVM through the host service. */
 export declare class OnBoxVmContainerHost implements IWorkspaceContainerAPI {
     #private;

package/dist/on-box-vm.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import * as Data from "effect/Data";
 import { SeamReplayGuard, importSeamSigner, importSeamVerifiers, seamBodyDigest, seamHeader, signSeamRequest, unsignedPayload, verifySeamRequest, } from "@fungi.computer/seam";
 function accessHeaders(env) {
     const id = env.COMPUTER_VM_ACCESS_CLIENT_ID;
@@ -13,13 +14,13 @@ function accessHeaders(env) {
         "CF-Access-Client-Secret": pair.data[1],
     };
 }
-const hostIdSchema = z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/);
-const hostRegistrySchema = z.record(hostIdSchema, z.strictObject({
+const hostIdSchema = z.lazy(() => z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/));
+const hostRegistrySchema = z.lazy(() => z.record(hostIdSchema, z.strictObject({
     origin: z
         .url({ protocol: /^https?$/ })
         .transform((value) => new URL(value).origin),
     publicKey: z.base64().length(44),
-}));
+})));
 const registries = new Map();
 function hostRegistry(env) {
     const raw = env.COMPUTER_VM_HOSTS ?? "{}";
@@ -72,10 +73,10 @@ function hostVerifiers(env) {
 const vmHostAudience = (hostId) => `computer-vm-host:${hostId}`;
 /** The audience this Worker's ingress door verifies. */
 const vmIngressAudience = "computer-vm-ingress";
-const exitSchema = z.strictObject({
+const exitSchema = z.lazy(() => z.strictObject({
     reason: z.string().max(1_024),
     exitedAt: z.number().int().nonnegative(),
-});
+}));
 const vmStateSchema = z.strictObject({
     running: z.boolean(),
     runtimeId: z.string().min(1).max(128).nullable(),
@@ -86,9 +87,17 @@ const vmInventorySchema = z.array(vmStateSchema.extend({
     name: z.string(),
     lastActive: z.number().int().nonnegative(),
 }));
-const vmStartSchema = z.strictObject({
+const vmStartSchema = z.lazy(() => z.strictObject({
     runtimeId: z.string().min(1).max(128),
-});
+}));
+/** A bounded control-plane wait, not the VM's execution or allocation lifetime. */
+const vmControlTimeoutMs = 60_000;
+/** The host's outcome is unknown after a timeout; this is not evidence of offline. */
+export class OnBoxVmTimeoutError extends Data.TaggedError("OnBoxVmTimeoutError") {
+    get message() {
+        return `On-box Computer VM ${this.operation} timed out after ${String(this.timeoutMs)} ms; host outcome unknown`;
+    }
+}
 function vmBodyBytes(body) {
     return new Uint8Array(new TextEncoder().encode(body === undefined ? "" : JSON.stringify(body)));
 }
@@ -121,14 +130,32 @@ export class OnBoxVmContainerHost {
         this.#sleepAfterMs = sleepAfterMs;
     }
     async #call(operation, schema, body) {
-        const path = operation === "status" ? "" : `/${operation}`;
-        const url = `${this.#placement.origin}/vms/${this.#vmId}${path}`;
-        const response = await fetch(url, await signedVmRequest(this.#env, this.#placement, url, body));
-        if (!response.ok) {
-            const detail = (await response.text()).slice(0, 200);
-            throw new OnBoxVmUnavailableError(operation, response.status, detail);
+        let path = `/vms/${this.#vmId}`;
+        if (operation === "inventory")
+            path = "/vms";
+        else if (operation !== "status")
+            path += `/${operation}`;
+        const url = `${this.#placement.origin}${path}`;
+        const signal = AbortSignal.timeout(vmControlTimeoutMs);
+        try {
+            const response = await fetch(url, {
+                ...(await signedVmRequest(this.#env, this.#placement, url, body)),
+                signal,
+            });
+            if (!response.ok) {
+                const detail = (await response.text()).slice(0, 200);
+                throw new OnBoxVmUnavailableError(operation, response.status, detail);
+            }
+            return schema.parse(await response.json());
+        }
+        catch (cause) {
+            if (signal.aborted)
+                throw new OnBoxVmTimeoutError({
+                    operation,
+                    timeoutMs: vmControlTimeoutMs,
+                });
+            throw cause;
         }
-        return schema.parse(await response.json());
     }
     async #boot(operation, env, enableInternet) {
         const started = await this.#call(operation, vmStartSchema, {
@@ -139,12 +166,8 @@ export class OnBoxVmContainerHost {
         return { runtimeId: started.runtimeId };
     }
     /** Signed host-wide inventory; includes VMs outside this Hub's directory. */
-    async inventory() {
-        const url = `${this.#placement.origin}/vms`;
-        const response = await fetch(url, await signedVmRequest(this.#env, this.#placement, url, undefined));
-        if (!response.ok)
-            throw new OnBoxVmUnavailableError("inventory", response.status);
-        return vmInventorySchema.parse(await response.json());
+    inventory() {
+        return this.#call("inventory", vmInventorySchema);
     }
     start(env, enableInternet) {
         return this.#boot("start", env, enableInternet);

package/dist/operation-record.d.ts

@@ -1,4 +1,4 @@
-import { type ComputerExecOutput, type ComputerOperationResult, type ComputerRequestId } from "./operation-contract.js";
+import { type ComputerExecOutput, type ComputerOperationResult, type ComputerRequestId } from "@fungi.computer/computer-contract";
 /** Terminal status records are retained for 7 days. */
 export declare const operationRetentionMs: number;
 /** Command output may contain secrets, so it is cleared after 24 hours. */

package/dist/operation-record.js

@@ -1,4 +1,4 @@
-import { computerOperationResultSchema, computerRequestIdSchema, execOutputSchema, } from "./operation-contract.js";
+import { computerOperationResultSchema, computerRequestIdSchema, execOutputSchema, } from "@fungi.computer/computer-contract";
 /** Terminal status records are retained for 7 days. */
 export const operationRetentionMs = 7 * 24 * 60 * 60 * 1_000;
 /** Command output may contain secrets, so it is cleared after 24 hours. */

package/dist/process-inventory.d.ts

@@ -1,6 +1,6 @@
 import type { WorkspaceRuntimeEvent, WorkspaceRuntimeExecHandle } from "@fungi.computer/cloudflare-computer";
 import { z } from "zod";
-import { processStartInputSchema, type ComputerProcess, type ComputerProcessId, type ComputerProcessSync } from "./operation-contract.js";
+import { processStartInputSchema, type ComputerProcess, type ComputerProcessId, type ComputerProcessSync } from "@fungi.computer/computer-contract";
 /** The durable SQLite surface owned by processes and their port exposures. */
 export type ComputerProcessStorage = Pick<DurableObjectStorage, "sql" | "transactionSync">;
 /** Computer-owned replay identities; computerd owns execution and exit observations. */
@@ -54,6 +54,8 @@ export type ProcessRuntime = Readonly<{
 }>;
 /** How long a tail read may stay silent before the process counts as live. */
 export declare const liveProbeMs = 750;
+/** Classify a failed attach: busy is live, lost is gone, anything else is unknown. */
+export declare function failedObservation(error: Error | undefined): ProcessObservation;
 /**
  * How long a drain may keep waiting for EOF once an exit has already been
  * observed, before giving up: a backgrounded child (for example

package/dist/process-inventory.js

@@ -51,7 +51,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { z } from "zod";
-import { computerProcessSchema, processStartInputSchema, mintComputerProcessId, ComputerProcessLimitError, ComputerPortReservedError, ComputerPortConflictError, ComputerPortLimitError, isComputerReservedPort, maximumExposedPorts, maximumProcessRecords, maximumRunningProcesses, } from "./operation-contract.js";
+import { computerProcessSchema, processStartInputSchema, mintComputerProcessId, ComputerProcessLimitError, ComputerPortReservedError, ComputerPortConflictError, ComputerPortLimitError, isComputerReservedPort, maximumExposedPorts, maximumProcessRecords, maximumRunningProcesses, } from "@fungi.computer/computer-contract";
 import { ComputerOperationConflictError } from "./operation-record.js";
 function toProcess(row) {
     return computerProcessSchema.parse({
@@ -211,7 +211,7 @@ function lostExecution(error) {
     return lostCodeSchema.safeParse(error).success;
 }
 /** Classify a failed attach: busy is live, lost is gone, anything else is unknown. */
-function failedObservation(error) {
+export function failedObservation(error) {
     if (error === undefined)
         return { state: "uncertain" };
     // computerd admits one live subscriber; the Computer's own watcher holding