@fungi.computer/truffle 0.0.0-stage → 0.1.1

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);
+            }
+        },
+    });
+}

package/dist/team-apps.d.ts

@@ -0,0 +1,24 @@
+import { type ShiitakeSession } from "@fungi.computer/shiitake/client";
+import type { FetchLike } from "@modelcontextprotocol/client";
+import { type AppDirectory } from "@fungi.computer/oyster/shell/app-directory";
+import { type GillRequest, type GillReply } from "@fungi.computer/gills";
+import { type FungiAccountTeam } from "./private-fungi-account.js";
+/** A selected Team's App reads. Credentials and selectors remain Local-owned. */
+export type LocalTeamApps = Readonly<{
+    team: FungiAccountTeam;
+    openSession: (target: Readonly<{
+        agentId: string;
+        sessionId: string;
+    }>, signal: AbortSignal) => Promise<Readonly<{
+        session: ShiitakeSession;
+        close: () => Promise<void>;
+    }>>;
+    surfaceUrl: (surfaceId: string, signal?: AbortSignal) => Promise<URL>;
+    read: (signal?: AbortSignal) => Promise<AppDirectory>;
+    requestGill: (surfaceId: string, selectors: GillRequest, signal?: AbortSignal) => Promise<GillReply>;
+}>;
+/** Pin this view to the saved account and Team; a later switch retires it. */
+export declare function openLocalTeamApps(options?: Readonly<{
+    credentialPath?: string;
+    fetch?: FetchLike;
+}>): Promise<LocalTeamApps>;

package/dist/team-apps.js

@@ -0,0 +1,123 @@
+import { decodeGillRefusal } from "@fungi.computer/agar/gills";
+import { EventSource } from "eventsource";
+import { createShiitakeClient, } from "@fungi.computer/shiitake/client";
+import { appDirectoryResponseSchema, } from "@fungi.computer/oyster/shell/app-directory";
+import { createGillClient, } from "@fungi.computer/gills";
+import { fungiAccountFetch, readFungiAccountStatus, } from "./private-fungi-account.js";
+/** Pin this view to the saved account and Team; a later switch retires it. */
+export async function openLocalTeamApps(options = {}) {
+    const account = await readFungiAccountStatus(options);
+    if (account?.team === undefined)
+        throw new Error("Sign in to Fungi and choose a Team to view its Apps");
+    const team = account.team;
+    const selectedIssuer = account.issuer;
+    const issuer = new URL(account.issuer).origin;
+    const prefix = `/api/teams/${encodeURIComponent(team.teamId)}`;
+    const transport = fungiAccountFetch(issuer, options);
+    async function stillSelected() {
+        const current = await readFungiAccountStatus(options);
+        if (current?.issuer !== selectedIssuer ||
+            current.team?.teamId !== team.teamId)
+            throw new Error("The selected Fungi Team changed; reopen the App pane");
+    }
+    async function read(signal) {
+        await stillSelected();
+        const response = await transport(`${issuer}${prefix}/local/apps`, {
+            signal: signal ?? null,
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error(`App directory refused with HTTP ${String(response.status)}`);
+        }
+        const raw = await response.json();
+        await stillSelected();
+        signal?.throwIfAborted();
+        return appDirectoryResponseSchema.parse(raw);
+    }
+    return {
+        team,
+        read,
+        async surfaceUrl(surfaceId, signal) {
+            const directory = await read(signal);
+            const app = directory.apps.find((item) => item.surfaceId === surfaceId);
+            if (app?.availability !== "available" ||
+                app.surface === null ||
+                app.releaseId === null)
+                throw new Error("That App is not available in the selected Team");
+            const url = new URL(app.surfacePath, issuer);
+            if (url.origin !== issuer)
+                throw new Error("The App surface is not on the selected Hub");
+            url.searchParams.set("authorityVersion", String(app.authorityVersion));
+            url.searchParams.set("releaseId", app.releaseId);
+            url.searchParams.set("surfaceRoute", app.surface.stableRoute);
+            await stillSelected();
+            return url;
+        },
+        async openSession(target, signal) {
+            await stillSelected();
+            signal.throwIfAborted();
+            const fetch = Object.assign(async (input, init) => {
+                await stillSelected();
+                signal.throwIfAborted();
+                return transport(input, {
+                    ...init,
+                    signal: AbortSignal.any([
+                        signal,
+                        ...(init?.signal ? [init.signal] : []),
+                    ]),
+                });
+            }, { preconnect: globalThis.fetch.preconnect });
+            class AccountEvents extends EventSource {
+                constructor(url) {
+                    super(url, { fetch });
+                }
+            }
+            const agent = createShiitakeClient({
+                baseUrl: `${issuer}${prefix}/local/agents/${encodeURIComponent(target.agentId)}`,
+                fetch,
+                eventSource: AccountEvents,
+            });
+            try {
+                const session = agent.session(target.sessionId);
+                await session.read();
+                await stillSelected();
+                signal.throwIfAborted();
+                return { session, close: agent.close };
+            }
+            catch (cause) {
+                await agent.close();
+                throw new Error("The selected Team Session could not be opened", {
+                    cause,
+                });
+            }
+        },
+        async requestGill(surfaceId, selectors, signal) {
+            const directory = await read(signal);
+            const app = directory.apps.find((item) => item.surfaceId === surfaceId);
+            const declaration = app?.gills.find((item) => item.id === selectors.viewId);
+            if (app === undefined ||
+                declaration === undefined ||
+                app.availability !== "available" ||
+                app.releaseId === null)
+                throw new Error("That Gill is not available in the selected Team");
+            const address = app.address.kind === "default"
+                ? `default/${encodeURIComponent(app.address.appId)}`
+                : encodeURIComponent(app.address.installationId);
+            const endpoint = new URL(`${prefix}/apps/${address}/gills`, issuer);
+            endpoint.searchParams.set("authorityVersion", String(app.authorityVersion));
+            endpoint.searchParams.set("releaseId", app.releaseId);
+            if (app.surface !== null)
+                endpoint.searchParams.set("surfaceRoute", app.surface.stableRoute);
+            await stillSelected();
+            const response = await createGillClient({
+                decodeRefusal: decodeGillRefusal,
+                endpoint: endpoint.href,
+                fetch: transport,
+                declaration,
+            }).request(selectors, signal);
+            await stillSelected();
+            signal?.throwIfAborted();
+            return response;
+        },
+    };
+}

package/dist/tracker-git-credential.d.ts

@@ -0,0 +1,15 @@
+import { freshFungiAccess } from "./private-fungi-account.js";
+/** Git's get/store/erase protocol. Only the existing Botanical login is stored;
+ * a minted capability lives in this call and Git's credential response. */
+export declare function runTrackerGitCredential(input: Readonly<{
+    action: string;
+    hub: string;
+    teamId: string;
+    stdin: AsyncIterable<Uint8Array>;
+    stdout: {
+        write(value: string): void;
+    };
+}>, owners?: {
+    access?: typeof freshFungiAccess;
+    fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+}): Promise<void>;

package/dist/tracker-git-credential.js

@@ -0,0 +1,87 @@
+import { parse } from "node:querystring";
+import { z } from "zod";
+import { freshFungiAccess } from "./private-fungi-account.js";
+const fields = z.object({
+    protocol: z.literal("https"),
+    host: z.string().min(1),
+    path: z.string().min(1),
+});
+const lease = z.strictObject({
+    remote: z.url({ protocol: /^https$/ }),
+    capability: z.string().regex(/^fgit_[0-9a-f]{64}$/u),
+    expiresAt: z.number().int().positive(),
+    permission: z.enum(["read", "write"]),
+});
+async function readBounded(input) {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let text = "";
+    let bytes = 0;
+    for await (const chunk of input) {
+        bytes += chunk.byteLength;
+        if (bytes > 8192)
+            throw new Error("Credential input too large");
+        text += decoder.decode(chunk, { stream: true });
+        const end = text.indexOf("\n\n");
+        if (end !== -1)
+            return text.slice(0, end);
+    }
+    return text + decoder.decode();
+}
+/** Git's get/store/erase protocol. Only the existing Botanical login is stored;
+ * a minted capability lives in this call and Git's credential response. */
+export async function runTrackerGitCredential(input, owners = {}) {
+    try {
+        if (!["get", "store", "erase", "remote"].includes(input.action))
+            throw new Error("Invalid action");
+        // Store and erase are intentionally silent: this helper has no Git cache.
+        if (input.action === "store" || input.action === "erase")
+            return;
+        const values = input.action === "remote"
+            ? null
+            : fields.parse(parse(await readBounded(input.stdin), "\n", "=", {
+                maxKeys: 32,
+                decodeURIComponent: (value) => value,
+            }));
+        const hub = new URL(input.hub);
+        if (hub.protocol !== "https:" ||
+            hub.username ||
+            hub.password ||
+            hub.search ||
+            hub.hash ||
+            hub.pathname !== "/")
+            throw new Error("Invalid Hub origin");
+        const teamId = z.string().min(1).max(256).parse(input.teamId);
+        const signal = AbortSignal.timeout(30_000);
+        const access = await (owners.access ?? freshFungiAccess)(hub, { signal });
+        const response = await (owners.fetch ?? fetch)(new URL(`/api/teams/${encodeURIComponent(teamId)}/git/tracker/credential`, hub), {
+            method: "POST",
+            headers: { Authorization: `Bearer ${access}` },
+            redirect: "error",
+            signal,
+        });
+        if (!response.ok || response.body === null)
+            throw new Error("Credential exchange refused");
+        const granted = lease.parse(JSON.parse(await readBounded(response.body)));
+        const remote = new URL(granted.remote);
+        if (remote.username ||
+            remote.password ||
+            remote.search ||
+            remote.hash ||
+            granted.expiresAt <= Date.now())
+            return;
+        if (values === null) {
+            // Discover the configured remote through the same admitted exchange;
+            // the unused five-minute capability is never emitted or cached.
+            input.stdout.write(`${remote.href}\n`);
+            return;
+        }
+        if (remote.host !== values.host || remote.pathname !== `/${values.path}`)
+            return;
+        input.stdout.write(`username=fungi\npassword=${granted.capability}\npassword_expiry_utc=${String(Math.floor(granted.expiresAt / 1000))}\n\n`);
+    }
+    catch {
+        // Neither schema-decode details, OAuth failures nor transport text may
+        // expose supplied credentials through the CLI's top-level error boundary.
+        throw new Error("Tracker Git unavailable. Check the remote, Team consent and Fungi login with git:tracker access.");
+    }
+}