@fungi.computer/truffle 0.0.0-stage → 0.2.0

package/dist/private-sqlite-owner.js

@@ -0,0 +1,169 @@
+import * as Schema from "effect/Schema";
+import { sqliteRowSchema } from "@fungi.computer/shiitake";
+import { DatabaseSync } from "node:sqlite";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { z } from "zod";
+const decodeSqliteRow = Schema.decodeUnknownSync(sqliteRowSchema);
+const bunSqlite = Object.hasOwn(process.versions, "bun")
+    ? await import("bun:sqlite")
+    : undefined;
+/**
+ * A listing owns this database until its existing finally close. Bun's
+ * node:sqlite prepare/close leaves native statements alive until GC. Native
+ * close(true) on the native Bun driver explicitly finalizes every statement
+ * before releasing the connection, including when a read or decoding fails.
+ */
+export function openPrivateReadOnlySqliteDatabase(path) {
+    return openPrivateSqliteDatabase(path, true, 0);
+}
+/** Writable connections own their statements through deterministic close. */
+export function openPrivateWritableSqliteDatabase(path, timeout) {
+    return openPrivateSqliteDatabase(path, false, timeout);
+}
+function openPrivateSqliteDatabase(path, readOnly, timeout) {
+    if (bunSqlite === undefined)
+        return new DatabaseSync(path, { readOnly, timeout });
+    const database = new bunSqlite.Database(path, {
+        readonly: readOnly,
+        create: !readOnly,
+        strict: true,
+    });
+    try {
+        database.run(`PRAGMA busy_timeout = ${String(timeout)}`);
+        if (!readOnly)
+            database.run("PRAGMA foreign_keys = ON");
+    }
+    catch (cause) {
+        database.close(true);
+        throw cause;
+    }
+    return {
+        get isTransaction() {
+            return database.inTransaction;
+        },
+        exec: (statement) => {
+            database.run(statement);
+        },
+        prepare: (statement) => {
+            const query = database.prepare(statement);
+            return {
+                all: (...bindings) => query.all(...bindings),
+                get: (...bindings) => query.get(...bindings) ?? undefined,
+                run: (...bindings) => query.run(...bindings),
+            };
+        },
+        transactionSync: (operation) => database.transaction(operation)(),
+        close: () => {
+            database.close(true);
+        },
+    };
+}
+const sqliteFailureSchema = z.union([
+    z
+        .object({
+        code: z.literal("ERR_SQLITE_ERROR"),
+        errcode: z.number().int(),
+    })
+        .transform((failure) => failure.errcode),
+    z
+        .object({
+        code: z.string().startsWith("SQLITE_"),
+        errno: z.number().int(),
+    })
+        .transform((failure) => failure.errno),
+]);
+const sqlitePrimaryCodeMask = 0xff;
+/** Decode the maintained drivers' structured result codes before sanitizing. */
+export function privateSqliteFailureCode(cause) {
+    const parsed = sqliteFailureSchema.safeParse(cause);
+    if (!parsed.success)
+        return undefined;
+    switch (parsed.data & 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)]));
+}
+/**
+ * Keep Local's native failure reporting around a host-supplied SQL owner.
+ * The supplied owner retains transaction mechanics and connection lifetime.
+ */
+export function observePrivateSqliteOwner(owner, onFailure) {
+    const observeFailure = (cause) => {
+        const code = privateSqliteFailureCode(cause);
+        if (code !== undefined)
+            onFailure?.(code);
+        throw cause;
+    };
+    return Object.freeze({
+        sql: Object.freeze({
+            exec: (statement, ...bindings) => {
+                try {
+                    return owner.sql.exec(statement, ...bindings);
+                }
+                catch (cause) {
+                    return observeFailure(cause);
+                }
+            },
+        }),
+        transactionSync: (operation) => {
+            try {
+                return owner.transactionSync(operation);
+            }
+            catch (cause) {
+                return observeFailure(cause);
+            }
+        },
+    });
+}
+/** Adapt one synchronous native database to Shiitake's public owner shape. */
+export function createPrivateSqliteOwner(database, onFailure) {
+    if (database instanceof DatabaseSync)
+        return observePrivateSqliteOwner(fromNodeSqlite(database), onFailure);
+    return observePrivateSqliteOwner({
+        sql: {
+            exec: (statement, ...bindings) => {
+                const prepared = database.prepare(statement);
+                const values = bindings.map(nativeInput);
+                const rows = readerStatement.test(statement)
+                    ? prepared.all(...values).map(nativeRow)
+                    : (prepared.run(...values), []);
+                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: database.transactionSync,
+    }, onFailure);
+}

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";
+        starting: "starting";
+        sleeping: "sleeping";
+    }>;
+}, 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, input?: Options): Promise<({
+    state: "running" | "starting" | "sleeping";
+    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, input: Options & Readonly<{
+    onState: (state: ComputerState) => void;
+}>): Promise<{
+    [x: string]: unknown;
+    computerId: string;
+    name: string;
+}>;
+export {};

package/dist/private-team-computers.js

@@ -0,0 +1,110 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { z } from "zod";
+import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
+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, input = {}) {
+    const options = {
+        ...input,
+        credentialPath: input.credentialPath ?? capturePrivateLocalConfigRoot().credentialPath,
+    };
+    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, input) {
+    const options = {
+        ...input,
+        credentialPath: input.credentialPath ?? capturePrivateLocalConfigRoot().credentialPath,
+    };
+    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;

package/dist/private-workerd-sandbox.js

@@ -0,0 +1,347 @@
+import { sandboxBindingNames } from "@fungi.computer/mycelium/sandbox-guest";
+import { recoverSandboxFailure, sandboxTransportMessage, sandboxCapabilityFailure, sandboxTransportErrno, } from "@fungi.computer/mycelium/sandbox-boundary";
+import { nanoid } from "@fungi.computer/cairn";
+import { readFile } from "node:fs/promises";
+import { request as httpRequest } from "node:http";
+import { SandboxCrashed, DispatchLost, BadResponse, Cancelled, sandboxFailure, } from "@fungi.computer/mycelium";
+import { FilesEditError } from "@fungi.computer/knapsack";
+import { convertV4MiniflareOptions, Miniflare, Response as MiniflareResponse, } from "miniflare";
+import { z } from "zod";
+import { sandboxWireSchema, sandboxWireFailure, } from "@fungi.computer/mycelium/sandbox-wire";
+import { FilesPathError } from "./private-invocation-files.js";
+const jsonValueSchema = z.json();
+const bindingCallSchema = z.strictObject({
+    namespace: z.string().max(160),
+    operation: z.string().max(160),
+    input: jsonValueSchema,
+});
+const bindingErrorSchema = z.discriminatedUnion("code", [
+    z.strictObject({
+        code: z.literal("no_such_operation"),
+        path: z.string().max(321),
+        suggestions: z.array(z.string().max(160)).max(3),
+    }),
+    z.strictObject({
+        code: z.enum(["invalid_input", "operation_failed", "closing"]),
+        message: z.string().max(512),
+    }),
+]);
+const bindingResponseSchema = z.discriminatedUnion("ok", [
+    z.strictObject({ ok: z.literal(true), value: jsonValueSchema }),
+    z.strictObject({ ok: z.literal(false), error: bindingErrorSchema }),
+]);
+const workerBundle = readFile(new URL("./internal/private-workerd-sandbox-worker.mjs", import.meta.url), "utf8");
+// Files owns admission of its diagnostics; the shared boundary alone decodes rejections.
+const filesDiagnosticSchema = z
+    .union([z.instanceof(FilesPathError), z.instanceof(FilesEditError)])
+    .transform((error) => ({ kind: "Files", message: error.message }));
+function operationTokens(path) {
+    return path
+        .toLowerCase()
+        .split(/[^a-z0-9]+/u)
+        .filter(Boolean);
+}
+function commonPrefixLength(left, right) {
+    let index = 0;
+    while (index < left.length &&
+        index < right.length &&
+        left[index] === right[index])
+        index += 1;
+    return index;
+}
+function oneEditApart(left, right) {
+    if (Math.abs(left.length - right.length) > 1)
+        return false;
+    let leftIndex = 0;
+    let rightIndex = 0;
+    let changed = false;
+    while (leftIndex < left.length && rightIndex < right.length) {
+        if (left[leftIndex] === right[rightIndex]) {
+            leftIndex += 1;
+            rightIndex += 1;
+            continue;
+        }
+        if (changed)
+            return false;
+        changed = true;
+        if (left.length >= right.length)
+            leftIndex += 1;
+        if (right.length >= left.length)
+            rightIndex += 1;
+    }
+    return changed || left.length !== right.length;
+}
+function operationSuggestions(request, operation) {
+    const requestedTokens = operationTokens(operation);
+    const scored = Object.entries(request.bindings).flatMap(([namespace, methods]) => Object.keys(methods).map((method) => {
+        const path = `${namespace}.${method}`;
+        const candidateTokens = operationTokens(path);
+        const score = requestedTokens.reduce((total, requested) => total +
+            Math.max(0, ...candidateTokens.map((candidate) => candidate === requested
+                ? 4
+                : oneEditApart(candidate, requested)
+                    ? 3
+                    : commonPrefixLength(candidate, requested) >= 3
+                        ? 2
+                        : 0)), 0);
+        return { path, score };
+    }));
+    return scored
+        .filter(({ score }) => score > 0)
+        .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))
+        .slice(0, 3)
+        .map(({ path }) => path);
+}
+function jsonResponse(value, status = 200) {
+    return new MiniflareResponse(JSON.stringify(bindingResponseSchema.parse(value)), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+async function invokeBinding(request, bindingRequest, failures) {
+    let call;
+    try {
+        call = bindingCallSchema.parse(await bindingRequest.json());
+    }
+    catch {
+        return jsonResponse({
+            ok: false,
+            error: { code: "invalid_input", message: "Invalid binding call" },
+        }, 400);
+    }
+    const operation = request.bindings[call.namespace]?.[call.operation];
+    if (operation === undefined) {
+        return jsonResponse({
+            ok: false,
+            error: {
+                code: "no_such_operation",
+                path: `${call.namespace}.${call.operation}`,
+                suggestions: operationSuggestions(request, call.operation),
+            },
+        }, 404);
+    }
+    try {
+        const value = jsonValueSchema.parse(await operation(call.input));
+        return jsonResponse({ ok: true, value });
+    }
+    catch (cause) {
+        const failure = sandboxCapabilityFailure(cause, call.namespace, call.operation, filesDiagnosticSchema);
+        const ref = nanoid();
+        if (failures.size === 128)
+            failures.delete(failures.keys().next().value ?? "");
+        failures.set(ref, failure);
+        return jsonResponse({
+            ok: false,
+            error: {
+                code: failure._tag === "CapabilityFailed" &&
+                    failure.cause.kind === "InvalidInput"
+                    ? "invalid_input"
+                    : "operation_failed",
+                message: sandboxTransportMessage(failure, ref),
+            },
+        }, 400);
+    }
+}
+function createInvocationCallbacks(request) {
+    const failures = new Map();
+    const activeCallbacks = new Set();
+    let acceptingCallbacks = true;
+    const fetch = (bindingRequest) => {
+        if (!acceptingCallbacks) {
+            return Promise.resolve(jsonResponse({
+                ok: false,
+                error: { code: "closing", message: "Invocation is closing" },
+            }, 503));
+        }
+        const callback = invokeBinding(request, bindingRequest, failures);
+        activeCallbacks.add(callback);
+        void callback.then(() => activeCallbacks.delete(callback), () => activeCallbacks.delete(callback));
+        return callback;
+    };
+    return Object.freeze({
+        failures,
+        fetch,
+        closeAdmission: () => {
+            acceptingCallbacks = false;
+        },
+        drain: async () => {
+            await Promise.allSettled(activeCallbacks);
+        },
+    });
+}
+function createInvocationMiniflare(bundle, serviceBinding) {
+    return new Miniflare(convertV4MiniflareOptions({
+        modules: [
+            {
+                type: "ESModule",
+                path: "private-workerd-sandbox-worker.mjs",
+                contents: bundle,
+            },
+        ],
+        compatibilityDate: "2026-09-02",
+        compatibilityFlags: ["nodejs_compat"],
+        workerLoaders: { LOADER: {} },
+        serviceBindings: { INVOCATION: serviceBinding },
+    }));
+}
+async function dispatchInvocation(miniflare, request, signal) {
+    let response;
+    const startedAt = performance.now();
+    let startedDispatch = false;
+    try {
+        // Bun's built-in undici Pool ignores Miniflare's zero-timeout settings;
+        // dispatchFetch inherits Bun.fetch's 300 s idle timer. Use the public
+        // workerd listener with node:http, whose request has no implicit deadline.
+        // Mycelium's signal remains the invocation's cancellation authority.
+        const url = new URL("/execute", await miniflare.ready);
+        startedDispatch = true;
+        response = await new Promise((resolve, reject) => {
+            const outgoing = httpRequest(url, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                agent: false,
+                signal,
+            }, (incoming) => {
+                resolve(new MiniflareResponse(incoming, {
+                    status: incoming.statusCode ?? 500,
+                }));
+            });
+            outgoing.on("error", reject);
+            outgoing.end(JSON.stringify({
+                code: request.code,
+                timeoutMs: request.timeoutMs,
+                bindings: sandboxBindingNames(request.bindings),
+                namespacePaths: request.namespacePaths ?? {},
+            }));
+        });
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            cause: signal.aborted
+                ? new Cancelled({ by: "caller" })
+                : startedDispatch
+                    ? new DispatchLost({
+                        elapsedMs: Math.round(performance.now() - startedAt),
+                        transport: "node:http",
+                        errno: sandboxTransportErrno(cause),
+                        rawCause: cause,
+                    })
+                    : new SandboxCrashed({ rawCause: cause }),
+        };
+    }
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            cause: new BadResponse({
+                reason: "response is not JSON",
+                rawCause: cause,
+            }),
+        };
+    }
+    const parsed = sandboxWireSchema.safeParse(payload);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            cause: new BadResponse({
+                reason: "response does not match sandbox envelope",
+                rawCause: parsed.error,
+            }),
+        };
+    }
+    const envelope = parsed.data;
+    return envelope.ok
+        ? { ok: true, value: envelope.value }
+        : {
+            ok: false,
+            cause: sandboxWireFailure(envelope.error),
+        };
+}
+function createDisposal(miniflare, callbacks) {
+    let disposal;
+    return () => {
+        callbacks.closeAdmission();
+        disposal ??= miniflare.dispose();
+        return disposal;
+    };
+}
+async function awaitCleanup(disposal, callbacks) {
+    const [disposed] = await Promise.allSettled([disposal, callbacks.drain()]);
+    if (disposed.status === "rejected")
+        throw disposed.reason;
+}
+async function executeInvocation(request, signal) {
+    signal.throwIfAborted();
+    let bundle;
+    try {
+        bundle = await workerBundle;
+    }
+    catch (rawCause) {
+        throw new SandboxCrashed({ rawCause });
+    }
+    signal.throwIfAborted();
+    const callbacks = createInvocationCallbacks(request);
+    let miniflare;
+    try {
+        miniflare = createInvocationMiniflare(bundle, callbacks.fetch);
+    }
+    catch (rawCause) {
+        throw new SandboxCrashed({ rawCause });
+    }
+    const beginDisposal = createDisposal(miniflare, callbacks);
+    const onAbort = () => {
+        void beginDisposal().catch((cause) => {
+            console.error("Local workerd disposal failed", cause);
+            return undefined;
+        });
+    };
+    if (signal.aborted)
+        onAbort();
+    else
+        signal.addEventListener("abort", onAbort, { once: true });
+    let result;
+    try {
+        signal.throwIfAborted();
+        result = await dispatchInvocation(miniflare, request, signal);
+    }
+    catch (cause) {
+        result = { ok: false, cause: sandboxFailure(cause) };
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+    }
+    try {
+        await awaitCleanup(beginDisposal(), callbacks);
+    }
+    catch (cause) {
+        // Disposal is an operator annotation. Keep the original guest/transport outcome.
+        console.error("sandbox_cleanup_failure", {
+            executionId: request.executionId,
+            rawCause: cause,
+        });
+    }
+    if (!result.ok) {
+        throw recoverSandboxFailure(result.cause, callbacks.failures);
+    }
+    return result.value;
+}
+/** Construct the private per-invocation workerd Sandbox. */
+export function createPrivateWorkerdSandbox() {
+    return Object.freeze({
+        adapter: "local-workerd",
+        execute: async (request, signal) => {
+            try {
+                return await executeInvocation(request, signal);
+            }
+            catch (cause) {
+                throw signal.aborted
+                    ? new Cancelled({ by: "caller" })
+                    : sandboxFailure(cause);
+            }
+        },
+    });
+}