@fungi.computer/truffle 0.0.0-stage → 0.1.1

package/dist/private-local-shiitake-host.js

@@ -0,0 +1,143 @@
+import { logEvent } from "./log-event.js";
+import { Hono } from "hono";
+import * as Schema from "effect/Schema";
+import { createShiitakeClient } from "@fungi.computer/shiitake/client";
+import { createShiitakeHttpRoutes } from "@fungi.computer/shiitake/http";
+import { openPrivateLocalRuntimeHost, } from "./private-local-runtime-host.js";
+function asPrivateShiitakeFailure(cause, message) {
+    return cause instanceof Error ? cause : new Error(message, { cause });
+}
+function aggregatePrivateShiitakeFailures(failures, message) {
+    if (failures.length === 1) {
+        const [failure] = failures;
+        if (failure === undefined)
+            throw new Error("Missing private Shiitake failure");
+        return failure;
+    }
+    return new AggregateError(failures, message);
+}
+async function capturePrivateShiitakeCloseFailure(failures, close, message) {
+    try {
+        await close();
+    }
+    catch (cause) {
+        logEvent(message, cause);
+        failures.push(asPrivateShiitakeFailure(cause, message));
+    }
+}
+async function closePrivateShiitakeResources(failures, client, server, owner) {
+    if (client !== undefined)
+        await capturePrivateShiitakeCloseFailure(failures, client.close, "Private Shiitake client close failed");
+    if (server !== undefined)
+        await capturePrivateShiitakeCloseFailure(failures, server.close, "Private Shiitake server close failed");
+    await capturePrivateShiitakeCloseFailure(failures, owner.close, "Private Shiitake owner close failed");
+}
+/** Open one bounded private local Hono host on a loopback-only ephemeral port. */
+export async function openPrivateLocalShiitakeHost(input, openServer, openHost = openPrivateLocalRuntimeHost, eventSource) {
+    const owner = await openHost(input);
+    const routes = createShiitakeHttpRoutes(owner.getSession, owner.listSessions, owner.createSession, owner.deleteSession, () => owner.extensions);
+    const fetch = (request) => routes.fetch(request);
+    let server;
+    let client;
+    try {
+        server = openServer(fetch);
+        const mountedServer = server;
+        const clientOptions = eventSource === undefined
+            ? { baseUrl: mountedServer.baseUrl }
+            : { baseUrl: mountedServer.baseUrl, eventSource };
+        const mountedClient = createShiitakeClient(clientOptions);
+        client = mountedClient;
+        let closing;
+        return Object.freeze({
+            agentId: owner.agentId,
+            databasePath: owner.databasePath,
+            baseUrl: mountedServer.baseUrl,
+            client: mountedClient,
+            session: mountedClient.session("main"),
+            close: () => {
+                closing ??= (async () => {
+                    const failures = [];
+                    await closePrivateShiitakeResources(failures, mountedClient, mountedServer, owner);
+                    if (failures.length > 0)
+                        throw aggregatePrivateShiitakeFailures(failures, "Private Shiitake host close failed");
+                })();
+                return closing;
+            },
+        });
+    }
+    catch (cause) {
+        const failures = [
+            asPrivateShiitakeFailure(cause, "Private Shiitake host initialization failed"),
+        ];
+        await closePrivateShiitakeResources(failures, client, server, owner);
+        throw aggregatePrivateShiitakeFailures(failures, "Private Shiitake host initialization failed");
+    }
+}
+const localWorkerNameSchema = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9_-]*$/u)));
+const decodeLocalWorkerName = Schema.decodeUnknownResult(localWorkerNameSchema);
+function validateLocalWorkerInputs(inputs) {
+    if (inputs.length === 0)
+        throw new Error("Private local Shiitake worker batch cannot be empty");
+    const names = new Set();
+    return inputs.map((input) => {
+        const decoded = decodeLocalWorkerName(input.name);
+        if (decoded._tag === "Failure")
+            throw new Error("Invalid private local Shiitake worker route identity: " + input.name);
+        if (names.has(decoded.success))
+            throw new Error("Duplicate private local Shiitake worker route identity: " +
+                decoded.success);
+        names.add(decoded.success);
+        return Object.freeze({ ...input, name: decoded.success });
+    });
+}
+async function closePrivateLocalWorkerBatch(failures, server, owners) {
+    if (server !== undefined)
+        await capturePrivateShiitakeCloseFailure(failures, server.close, "Private Shiitake worker server close failed");
+    for (const { owner } of owners)
+        await capturePrivateShiitakeCloseFailure(failures, owner.close, "Private Shiitake worker owner close failed");
+}
+/** Mount a static batch of Local Agents behind exactly one maintained Hono server. */
+export async function openPrivateLocalShiitakeWorkerBatch(inputs, openServer, openHost = openPrivateLocalRuntimeHost) {
+    const validated = validateLocalWorkerInputs(inputs);
+    const owners = [];
+    let server;
+    try {
+        const app = new Hono();
+        const workers = [];
+        for (const input of validated) {
+            const owner = await openHost(input.owner);
+            owners.push({ name: input.name, owner });
+            const routes = createShiitakeHttpRoutes(owner.getSession, owner.listSessions, owner.createSession, owner.deleteSession, () => owner.extensions);
+            const routePath = "/workers/" + input.name;
+            app.route(routePath, routes);
+            workers.push(Object.freeze({
+                name: input.name,
+                routePath,
+                databasePath: owner.databasePath,
+            }));
+        }
+        server = openServer((request) => app.fetch(request));
+        const mountedServer = server;
+        let closing;
+        return Object.freeze({
+            baseUrl: mountedServer.baseUrl,
+            workers: Object.freeze(workers),
+            close: () => {
+                closing ??= (async () => {
+                    const failures = [];
+                    await closePrivateLocalWorkerBatch(failures, mountedServer, owners);
+                    if (failures.length > 0)
+                        throw aggregatePrivateShiitakeFailures(failures, "Private Shiitake worker batch close failed");
+                })();
+                return closing;
+            },
+        });
+    }
+    catch (cause) {
+        const failures = [
+            asPrivateShiitakeFailure(cause, "Private Shiitake worker batch initialization failed"),
+        ];
+        await closePrivateLocalWorkerBatch(failures, server, owners);
+        throw aggregatePrivateShiitakeFailures(failures, "Private Shiitake worker batch initialization failed");
+    }
+}

package/dist/private-local-subagents.d.ts

@@ -0,0 +1,27 @@
+import { type AgentControlDirectory } from "@fungi.computer/shiitake/agent-control";
+import type { DatabaseSync } from "node:sqlite";
+/**
+ * One Local Agent's own record of the Agents each of its Sessions created or
+ * sent work to. This host writes it as its Agent-control directory accepts a
+ * create or a send. It feeds the read-only sub-agent view and is not a managed
+ * parent/child relationship.
+ */
+export declare function createPrivateLocalSubagents(input: Readonly<{
+    database: DatabaseSync;
+    directory: AgentControlDirectory;
+}>): {
+    control: Readonly<{
+        id: string;
+        acquire: (context: import("@fungi.computer/mycelium").CapabilitySourceContext) => Promise<import("@fungi.computer/mycelium").CapabilitySourceAcquisition>;
+    }>;
+    source: Readonly<{
+        read: (sessionId: string, limit: number) => Promise<Readonly<{
+            agents: readonly import("@fungi.computer/shiitake-extensions/subagents/host").SubagentRecord[];
+            more: number;
+        }>>;
+        open: (agentId: string, signal: AbortSignal) => Promise<Readonly<{
+            agent: import("@fungi.computer/shiitake-extensions/subagents/host").SubagentAgent;
+            release: () => Promise<void>;
+        }>>;
+    }>;
+};

package/dist/private-local-subagents.js

@@ -0,0 +1,77 @@
+import { createAgentControlSource, } from "@fungi.computer/shiitake/agent-control";
+import { z } from "zod";
+const subagentRow = z.lazy(() => z.strictObject({
+    agent_id: z.string().min(1).max(256),
+    session_id: z.string().min(1).max(256).nullable(),
+    total: z.number().int().nonnegative(),
+}));
+/**
+ * One Local Agent's own record of the Agents each of its Sessions created or
+ * sent work to. This host writes it as its Agent-control directory accepts a
+ * create or a send. It feeds the read-only sub-agent view and is not a managed
+ * parent/child relationship.
+ */
+export function createPrivateLocalSubagents(input) {
+    input.database.exec(`CREATE TABLE IF NOT EXISTS private_local_subagents (
+    parent_session_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    session_id TEXT,
+    at INTEGER NOT NULL,
+    PRIMARY KEY (parent_session_id, agent_id)
+  ) STRICT`);
+    input.database.exec("CREATE INDEX IF NOT EXISTS idx_private_local_subagents_parent ON private_local_subagents(parent_session_id, at)");
+    // A retried create keeps its first row.
+    const created = input.database.prepare("INSERT OR IGNORE INTO private_local_subagents(parent_session_id, agent_id, session_id, at) VALUES (?, ?, NULL, ?)");
+    // A send names the conversation to open and moves the row to the front.
+    const sent = input.database.prepare("INSERT INTO private_local_subagents(parent_session_id, agent_id, session_id, at) VALUES (?, ?, ?, ?) ON CONFLICT(parent_session_id, agent_id) DO UPDATE SET session_id = excluded.session_id, at = excluded.at");
+    const page = input.database.prepare("SELECT agent_id, session_id, COUNT(*) OVER () AS total FROM private_local_subagents WHERE parent_session_id = ? ORDER BY at DESC, agent_id LIMIT ?");
+    /** One Session's directory: its accepted creates and sends are recorded. */
+    function recording(parentSessionId) {
+        const { create, send } = input.directory;
+        let directory = input.directory;
+        if (create !== undefined && parentSessionId !== undefined)
+            directory = {
+                ...directory,
+                create: async (request, signal) => {
+                    const agent = await create(request, signal);
+                    created.run(parentSessionId, agent.agentId, Date.now());
+                    return agent;
+                },
+            };
+        if (send !== undefined)
+            directory = {
+                ...directory,
+                send: async (task, sourceSessionId, signal, invocation) => {
+                    const accepted = await send(task, sourceSessionId, signal, invocation);
+                    sent.run(sourceSessionId, task.agentId, task.sessionId, Date.now());
+                    return accepted;
+                },
+            };
+        return directory;
+    }
+    /**
+     * The ordinary Agent-control tools, bound to the Session that acquires them
+     * for one run, so a create is recorded against that Session.
+     */
+    const control = {
+        id: createAgentControlSource(input.directory).id,
+        acquire: (context) => createAgentControlSource(recording(context.session?.sessionId)).acquire(context),
+    };
+    const source = {
+        read: (sessionId, limit) => {
+            const rows = page
+                .all(sessionId, limit)
+                .map((row) => subagentRow.parse(row));
+            return Promise.resolve({
+                agents: rows.map((row) => ({
+                    agentId: row.agent_id,
+                    name: row.agent_id,
+                    sessionId: row.session_id,
+                })),
+                more: Math.max(0, (rows[0]?.total ?? 0) - rows.length),
+            });
+        },
+        open: input.directory.open,
+    };
+    return { control, source };
+}

package/dist/private-local-worker-server.d.ts

@@ -0,0 +1,15 @@
+import type { openPrivateLocalBunShiitakeWorkerBatch } from "./private-bun-shiitake-host.js";
+export type ShutdownSignal = "SIGINT" | "SIGTERM";
+export type Signals = Readonly<{
+    on: (signal: ShutdownSignal, listener: () => void) => void;
+    off: (signal: ShutdownSignal, listener: () => void) => void;
+}>;
+export type Output = Pick<NodeJS.WritableStream, "write">;
+export type OpenWorkerBatch = typeof openPrivateLocalBunShiitakeWorkerBatch;
+export type PrivateLocalWorkerServerIo = Readonly<{
+    cwd: string;
+    stdout?: Output | undefined;
+    signals?: Signals | undefined;
+}>;
+/** Retained explicit static worker batch; ordinary clients use the persistent manager. */
+export declare function runPrivateLocalWorkerServer(workersFile: string, listen: string, io: PrivateLocalWorkerServerIo, openBatch?: OpenWorkerBatch): Promise<void>;

package/dist/private-local-worker-server.js

@@ -0,0 +1,136 @@
+import { logEvent } from "./log-event.js";
+import { fungiMcpSelectionSchema, readFungiMcpSelection, } from "./private-fungi-mcp-selection.js";
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import { dirname, resolve } from "node:path";
+import { z } from "zod";
+const reasoningSchema = z.enum([
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]);
+const ownerSchema = z.strictObject({
+    invocationRoot: z.string().min(1),
+    databasePath: z.string().min(1).optional(),
+    modelId: z.string().min(1).optional(),
+    reasoning: reasoningSchema.optional(),
+    fungiMcp: fungiMcpSelectionSchema.optional(),
+});
+const workerSchema = z.strictObject({
+    name: z.string(),
+    owner: ownerSchema,
+});
+const workersSchema = z.array(workerSchema).min(1);
+function parseWorkers(value, filePath) {
+    const decoded = workersSchema.safeParse(value);
+    if (!decoded.success)
+        throw new Error("Invalid workers file: " + filePath);
+    const root = dirname(filePath);
+    return decoded.data.map(({ name, owner }) => ({
+        name,
+        owner: {
+            ...owner,
+            invocationRoot: resolve(root, owner.invocationRoot),
+        },
+    }));
+}
+async function readWorkers(filePath, cwd) {
+    const absolutePath = resolve(cwd, filePath);
+    let value;
+    try {
+        value = JSON.parse(await readFile(absolutePath, "utf8"));
+    }
+    catch (cause) {
+        throw new Error("Could not read workers file: " + absolutePath, { cause });
+    }
+    const workers = [];
+    for (const { name, owner } of parseWorkers(value, absolutePath)) {
+        const { fungiMcp, ...local } = owner;
+        let configured = local;
+        if (fungiMcp !== undefined)
+            configured = {
+                ...configured,
+                fungiMcp: readFungiMcpSelection(fungiMcp),
+            };
+        workers.push({ name, owner: configured });
+    }
+    return workers;
+}
+function asFailure(cause, message) {
+    return cause instanceof Error ? cause : new Error(message, { cause });
+}
+function readyRecord(batch) {
+    return JSON.stringify({
+        status: "ready",
+        baseUrl: batch.baseUrl,
+        workers: batch.workers.map(({ name, routePath, databasePath }) => ({
+            name,
+            routePath,
+            databasePath,
+        })),
+    });
+}
+/** Retained explicit static worker batch; ordinary clients use the persistent manager. */
+export async function runPrivateLocalWorkerServer(workersFile, listen, io, openBatch = async (...args) => {
+    const { openPrivateLocalBunShiitakeWorkerBatch } = await import("./private-bun-shiitake-host.js");
+    return openPrivateLocalBunShiitakeWorkerBatch(...args);
+}) {
+    const workers = await readWorkers(workersFile, io.cwd);
+    const stdout = io.stdout ?? process.stdout;
+    const signals = io.signals ?? process;
+    const stopped = Promise.withResolvers();
+    const stop = { requested: false };
+    let batch;
+    let initiating;
+    let closeFailure;
+    const onSignal = () => {
+        if (stop.requested)
+            return;
+        stop.requested = true;
+        stopped.resolve(undefined);
+    };
+    signals.on("SIGINT", onSignal);
+    signals.on("SIGTERM", onSignal);
+    try {
+        try {
+            batch = await openBatch(workers, listen);
+            if (!stop.requested) {
+                try {
+                    stdout.write(readyRecord(batch) + "\n");
+                }
+                catch (cause) {
+                    logEvent("worker-server.ready-output", cause);
+                    initiating = asFailure(cause, "Worker server ready output failed");
+                }
+            }
+            if (initiating === undefined)
+                await stopped.promise;
+        }
+        catch (cause) {
+            logEvent("worker-server.opening", cause);
+            initiating = asFailure(cause, "Worker server opening failed");
+        }
+        if (batch !== undefined) {
+            try {
+                await batch.close();
+            }
+            catch (cause) {
+                logEvent("worker-server.close", cause);
+                closeFailure = asFailure(cause, "Worker server close failed");
+            }
+        }
+    }
+    finally {
+        signals.off("SIGINT", onSignal);
+        signals.off("SIGTERM", onSignal);
+    }
+    if (initiating !== undefined && closeFailure !== undefined)
+        throw new AggregateError([initiating, closeFailure], "Worker server startup and close failed");
+    if (initiating !== undefined)
+        throw initiating;
+    if (closeFailure !== undefined)
+        throw closeFailure;
+}

package/dist/private-sqlite-owner.d.ts

@@ -0,0 +1,7 @@
+import { DatabaseSync } from "node:sqlite";
+import type { SqliteOwner } from "@fungi.computer/shiitake";
+export type PrivateSqliteFailureCode = "busy" | "locked" | "corrupt" | "not_a_database" | "other";
+/** Decode Node SQLite's structured result code before higher owners sanitize it. */
+export declare function privateSqliteFailureCode(cause: unknown): PrivateSqliteFailureCode | undefined;
+/** Adapt one synchronous native database to Shiitake's public owner shape. */
+export declare function createPrivateSqliteOwner(database: DatabaseSync, onFailure?: (code: PrivateSqliteFailureCode) => void): SqliteOwner;

package/dist/private-sqlite-owner.js

@@ -0,0 +1,103 @@
+import * as Schema from "effect/Schema";
+import { sqliteRowSchema } from "@fungi.computer/shiitake";
+import { DatabaseSync } from "node:sqlite";
+import { z } from "zod";
+const decodeSqliteRow = Schema.decodeUnknownSync(sqliteRowSchema);
+const sqliteFailureSchema = z.object({
+    code: z.literal("ERR_SQLITE_ERROR"),
+    errcode: z.number().int(),
+});
+const sqlitePrimaryCodeMask = 0xff;
+/** Decode Node SQLite's structured result code before higher owners sanitize it. */
+export function privateSqliteFailureCode(cause) {
+    const parsed = sqliteFailureSchema.safeParse(cause);
+    if (!parsed.success)
+        return undefined;
+    switch (parsed.data.errcode & sqlitePrimaryCodeMask) {
+        case 5:
+            return "busy";
+        case 6:
+            return "locked";
+        case 11:
+            return "corrupt";
+        case 26:
+            return "not_a_database";
+        default:
+            return "other";
+    }
+}
+const readerStatement = /^\s*(?:SELECT|PRAGMA|WITH)\b/iu;
+function nativeInput(value) {
+    return value instanceof ArrayBuffer ? new Uint8Array(value) : value;
+}
+function nativeOutput(value) {
+    if (value === null)
+        return value;
+    if (value instanceof Uint8Array)
+        return new Uint8Array(value).slice().buffer;
+    if (Object.prototype.toString.call(value) === "[object Number]")
+        return Number(value);
+    if (Object.prototype.toString.call(value) === "[object String]")
+        return String(value);
+    return Number(value);
+}
+function nativeRow(row) {
+    return Object.fromEntries(Object.entries(row).map(([key, value]) => [key, nativeOutput(value)]));
+}
+/** Adapt one synchronous native database to Shiitake's public owner shape. */
+export function createPrivateSqliteOwner(database, onFailure) {
+    const observeFailure = (cause) => {
+        const code = privateSqliteFailureCode(cause);
+        if (code !== undefined)
+            onFailure?.(code);
+        throw cause;
+    };
+    return Object.freeze({
+        sql: Object.freeze({
+            exec: (statement, ...bindings) => {
+                let rows;
+                try {
+                    const prepared = database.prepare(statement);
+                    const values = bindings.map(nativeInput);
+                    rows = readerStatement.test(statement)
+                        ? prepared.all(...values).map(nativeRow)
+                        : (prepared.run(...values), []);
+                }
+                catch (cause) {
+                    return observeFailure(cause);
+                }
+                return Object.freeze({
+                    toArray: () => rows.map((row) => decodeSqliteRow(row)),
+                    one: () => {
+                        const row = rows[0];
+                        if (row === undefined)
+                            throw new Error("Expected one SQLite row");
+                        return decodeSqliteRow(row);
+                    },
+                });
+            },
+        }),
+        transactionSync: (operation) => {
+            try {
+                database.exec("BEGIN");
+            }
+            catch (cause) {
+                return observeFailure(cause);
+            }
+            try {
+                const value = operation();
+                database.exec("COMMIT");
+                return value;
+            }
+            catch (cause) {
+                try {
+                    database.exec("ROLLBACK");
+                }
+                catch (rollbackCause) {
+                    observeFailure(rollbackCause);
+                }
+                return observeFailure(cause);
+            }
+        },
+    });
+}

package/dist/private-team-computers.d.ts

@@ -0,0 +1,38 @@
+import type { FetchLike } from "@modelcontextprotocol/client";
+import { z } from "zod";
+declare const stateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    state: z.ZodEnum<{
+        running: "running";
+        sleeping: "sleeping";
+        starting: "starting";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    state: z.ZodLiteral<"queued">;
+    position: z.ZodNumber;
+}, z.core.$strict>], "state">;
+export type ComputerState = z.output<typeof stateSchema>;
+export type Options = Readonly<{
+    credentialPath?: string;
+    fetch?: FetchLike;
+    signal?: AbortSignal;
+}>;
+/** Team directory and real runtime liveness, using Local's existing authenticated MCP transport. */
+export declare function listPrivateTeamComputers(rawEndpoint: string, options?: Options): Promise<({
+    state: "running" | "sleeping" | "starting";
+    computerId: string;
+    name: string;
+} | {
+    state: "queued";
+    position: number;
+    computerId: string;
+    name: string;
+})[]>;
+/** Await admission while reporting live queue positions. Ctrl-C stops the local wait. */
+export declare function startPrivateTeamComputer(rawEndpoint: string, name: string, options: Options & Readonly<{
+    onState: (state: ComputerState) => void;
+}>): Promise<{
+    [x: string]: unknown;
+    computerId: string;
+    name: string;
+}>;
+export {};

package/dist/private-team-computers.js

@@ -0,0 +1,101 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { z } from "zod";
+import { callFungiMcpTeamControl, fungiMcpTeamEndpoint, } from "./private-fungi-account.js";
+const stateSchema = z.discriminatedUnion("state", [
+    z.strictObject({ state: z.enum(["running", "sleeping", "starting"]) }),
+    z.strictObject({
+        state: z.literal("queued"),
+        position: z.number().int().positive(),
+    }),
+]);
+const computerSchema = z.looseObject({
+    computerId: z.string().min(1).max(256),
+    name: z.string().min(1).max(256),
+});
+const pageSchema = z.looseObject({
+    computers: z.array(computerSchema).max(100),
+    nextOffset: z.number().int().nonnegative().nullable(),
+});
+async function control(endpoint, operation, input, schema, options) {
+    options.signal?.throwIfAborted();
+    const text = await callFungiMcpTeamControl(endpoint, `return await computers.${operation}(${JSON.stringify(input)});`, { ...options, timeoutMs: operation === "start" ? 30 * 60 * 1_000 : 60_000 });
+    options.signal?.throwIfAborted();
+    if (text === undefined)
+        throw new Error("The Hub did not complete Computer control. Check your Team login and access, then retry.");
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw new Error("The Hub returned an invalid Computer response.");
+    }
+    const result = schema.safeParse(value);
+    if (!result.success)
+        throw new Error("The Hub returned an invalid Computer response.");
+    return result.data;
+}
+async function directory(endpoint, options) {
+    const computers = [];
+    let offset = 0;
+    for (let pageNumber = 0; pageNumber < 100; pageNumber++) {
+        const page = await control(endpoint, "list", { limit: 100, offset }, pageSchema, options);
+        computers.push(...page.computers);
+        if (page.nextOffset === null)
+            return computers;
+        if (page.nextOffset <= offset)
+            throw new Error("The Hub returned an invalid Computer page cursor.");
+        offset = page.nextOffset;
+    }
+    throw new Error("This Team has too many Computer pages to list in one command.");
+}
+/** Team directory and real runtime liveness, using Local's existing authenticated MCP transport. */
+export async function listPrivateTeamComputers(rawEndpoint, options = {}) {
+    const { endpoint } = fungiMcpTeamEndpoint(rawEndpoint);
+    const computers = await directory(endpoint, options);
+    const rows = [];
+    for (const computer of computers)
+        rows.push({
+            ...computer,
+            ...(await control(endpoint, "state", { computerId: computer.computerId }, stateSchema, options)),
+        });
+    return rows;
+}
+/** Await admission while reporting live queue positions. Ctrl-C stops the local wait. */
+export async function startPrivateTeamComputer(rawEndpoint, name, options) {
+    const { endpoint } = fungiMcpTeamEndpoint(rawEndpoint);
+    const computers = await directory(endpoint, options);
+    const matches = computers.filter((computer) => computer.computerId === name || computer.name === name);
+    const computer = matches[0];
+    if (computer === undefined || matches.length !== 1)
+        throw new Error(matches.length === 0
+            ? `No Computer named ${name} in this Team.`
+            : `Computer ${name} is ambiguous; use its id.`);
+    options.onState({ state: "starting" });
+    const polling = new AbortController();
+    const signal = options.signal === undefined
+        ? polling.signal
+        : AbortSignal.any([options.signal, polling.signal]);
+    const request = control(endpoint, "start", { computerId: computer.computerId }, stateSchema, { ...options, signal });
+    // Observe rejection immediately while the independently authenticated status call is in flight.
+    const completion = request.then((state) => ({ state }), (error) => ({ error }));
+    try {
+        for (;;) {
+            const outcome = await Promise.race([
+                completion,
+                delay(1_000, undefined, { signal }).then(() => undefined),
+            ]);
+            if (outcome !== undefined) {
+                if ("error" in outcome)
+                    throw outcome.error;
+                if (outcome.state.state !== "running")
+                    throw new Error("The Hub did not confirm that the Computer started.");
+                options.onState(outcome.state);
+                return computer;
+            }
+            options.onState(await control(endpoint, "state", { computerId: computer.computerId }, stateSchema, { ...options, signal }));
+        }
+    }
+    finally {
+        polling.abort();
+    }
+}

package/dist/private-workerd-sandbox.d.ts

@@ -0,0 +1,3 @@
+import { type Sandbox } from "@fungi.computer/mycelium";
+/** Construct the private per-invocation workerd Sandbox. */
+export declare function createPrivateWorkerdSandbox(): Sandbox;