@fungi.computer/truffle 0.0.0-stage → 0.1.1

package/dist/private-local-auth-rpc.js

@@ -0,0 +1,273 @@
+import { RpcTarget } from "@fungi.computer/capnweb";
+import { z } from "zod";
+import { localAuthInputLimit, runLocalAuthCli, } from "./auth-cli.js";
+const requestSchema = z.object({
+    command: z.enum(["login", "logout", "status"]),
+    provider: z.string().optional(),
+    authType: z.enum(["oauth", "api_key"]).optional(),
+    method: z.string().optional(),
+});
+const authStatusSchema = z.discriminatedUnion("state", [
+    z.object({
+        providerId: z.string(),
+        providerName: z.string(),
+        state: z.literal("unconfigured"),
+    }),
+    z.object({
+        providerId: z.string(),
+        providerName: z.string(),
+        state: z.literal("configured"),
+        type: z.enum(["oauth", "api_key"]),
+    }),
+]);
+const authResultSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("completed") }),
+    z.object({
+        kind: z.literal("status"),
+        providers: z.array(authStatusSchema),
+    }),
+]);
+// Only Pi's serializable presentation crosses RPC; AbortSignals stay local.
+const promptSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("text"),
+        message: z.string(),
+        placeholder: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("secret"),
+        message: z.string(),
+        placeholder: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("manual_code"),
+        message: z.string(),
+        placeholder: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("select"),
+        message: z.string(),
+        options: z.array(z.object({
+            id: z.string(),
+            label: z.string(),
+            description: z.string().optional(),
+        })),
+    }),
+]);
+const linkSchema = z.object({ url: z.string(), label: z.string().optional() });
+const eventSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("info"),
+        message: z.string(),
+        links: z.array(linkSchema).optional(),
+    }),
+    z.object({ type: z.literal("progress"), message: z.string() }),
+    z.object({
+        type: z.literal("auth_url"),
+        url: z.string(),
+        instructions: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("device_code"),
+        userCode: z.string(),
+        verificationUri: z.string(),
+        intervalSeconds: z.number().optional(),
+        expiresInSeconds: z.number().optional(),
+    }),
+]);
+const answerSchema = z.string().max(localAuthInputLimit);
+class AuthPromptTarget extends RpcTarget {
+    #controller = new AbortController();
+    #result;
+    constructor(prompt, interaction) {
+        super();
+        const signal = interaction.signal === undefined
+            ? this.#controller.signal
+            : AbortSignal.any([this.#controller.signal, interaction.signal]);
+        this.#result = Promise.resolve()
+            .then(() => {
+            signal.throwIfAborted();
+            const request = prompt.type === "select"
+                ? {
+                    type: "select",
+                    message: prompt.message,
+                    signal,
+                    options: prompt.options.map((option) => option.description === undefined
+                        ? { id: option.id, label: option.label }
+                        : {
+                            id: option.id,
+                            label: option.label,
+                            description: option.description,
+                        }),
+                }
+                : { type: prompt.type, message: prompt.message, signal };
+            if (request.type !== "select" &&
+                prompt.type !== "select" &&
+                prompt.placeholder !== undefined)
+                request.placeholder = prompt.placeholder;
+            return interaction.prompt(request);
+        })
+            .then((value) => ({ value: answerSchema.parse(value) }), (cause) => ({ failed: true, cause }));
+    }
+    async result() {
+        const result = await this.#result;
+        if ("failed" in result)
+            throw new Error("Authentication prompt cancelled or failed", {
+                cause: result.cause,
+            });
+        return result.value;
+    }
+    cancel() {
+        this.#controller.abort();
+    }
+    [Symbol.dispose]() {
+        this.cancel();
+    }
+}
+class AuthPresenterTarget extends RpcTarget {
+    #interaction;
+    constructor(interaction) {
+        super();
+        this.#interaction = interaction;
+    }
+    openPrompt(request) {
+        return new AuthPromptTarget(promptSchema.parse(request), this.#interaction);
+    }
+    notify(event) {
+        const parsed = eventSchema.parse(event);
+        let decoded;
+        switch (parsed.type) {
+            case "info":
+                decoded = { type: parsed.type, message: parsed.message };
+                if (parsed.links !== undefined)
+                    decoded.links = parsed.links.map((link) => link.label === undefined
+                        ? { url: link.url }
+                        : { url: link.url, label: link.label });
+                break;
+            case "progress":
+                decoded = parsed;
+                break;
+            case "auth_url":
+                decoded = { type: parsed.type, url: parsed.url };
+                if (parsed.instructions !== undefined)
+                    decoded.instructions = parsed.instructions;
+                break;
+            case "device_code":
+                decoded = {
+                    type: parsed.type,
+                    userCode: parsed.userCode,
+                    verificationUri: parsed.verificationUri,
+                };
+                if (parsed.intervalSeconds !== undefined)
+                    decoded.intervalSeconds = parsed.intervalSeconds;
+                if (parsed.expiresInSeconds !== undefined)
+                    decoded.expiresInSeconds = parsed.expiresInSeconds;
+                break;
+        }
+        this.#interaction.notify(decoded);
+    }
+}
+/** One transient connection runs one operation through the existing Pi owner. */
+export class PrivateLocalAuthTarget extends RpcTarget {
+    #controller = new AbortController();
+    #used = false;
+    #run;
+    constructor(run = runLocalAuthCli) {
+        super();
+        this.#run = run;
+    }
+    cancel() {
+        this.#controller.abort();
+    }
+    [Symbol.dispose]() {
+        this.cancel();
+    }
+    async run(input, presenter) {
+        if (this.#used)
+            throw new Error("Authentication connection already used");
+        this.#used = true;
+        presenter.onRpcBroken(() => {
+            this.cancel();
+        });
+        const request = requestSchema.parse(input);
+        const args = [request.command];
+        if (request.provider !== undefined)
+            args.push("--provider", request.provider);
+        if (request.authType !== undefined)
+            args.push("--auth-type", request.authType);
+        if (request.method !== undefined)
+            args.push("--method", request.method);
+        const signal = this.#controller.signal;
+        try {
+            const result = await this.#run(args, {
+                interaction: {
+                    signal,
+                    notify: (event) => {
+                        void presenter.notify(event).catch((cause) => {
+                            console.warn("Local authentication presenter notification failed", cause instanceof Error ? cause.name : "NonError");
+                            this.cancel();
+                        });
+                    },
+                    prompt: async (request) => {
+                        const promptSignal = request.signal === undefined
+                            ? signal
+                            : AbortSignal.any([signal, request.signal]);
+                        promptSignal.throwIfAborted();
+                        const pending = presenter.openPrompt(promptSchema.parse(request));
+                        const cancel = () => {
+                            void pending.cancel().catch((cause) => {
+                                console.warn("Local authentication prompt cancellation failed", cause instanceof Error ? cause.name : "NonError");
+                                this.cancel();
+                            });
+                        };
+                        promptSignal.addEventListener("abort", cancel, { once: true });
+                        try {
+                            if (promptSignal.aborted)
+                                cancel();
+                            return answerSchema.parse(await pending.result());
+                        }
+                        finally {
+                            promptSignal.removeEventListener("abort", cancel);
+                            pending[Symbol.dispose]();
+                        }
+                    },
+                },
+            });
+            return authResultSchema.parse(result);
+        }
+        catch {
+            // Provider errors can contain credential material; do not serialize them.
+            throw new Error(signal.aborted
+                ? "Authentication cancelled"
+                : "Local authentication failed");
+        }
+        finally {
+            this.cancel();
+        }
+    }
+}
+/** Takes ownership of a dedicated auth RPC connection, never the Session client. */
+export async function runPrivateLocalAuthRemote(remote, request, interaction) {
+    const controller = new AbortController();
+    const signal = interaction.signal === undefined
+        ? controller.signal
+        : AbortSignal.any([controller.signal, interaction.signal]);
+    const presenter = new AuthPresenterTarget({ ...interaction, signal });
+    const cancel = () => {
+        void remote.cancel().catch((cause) => {
+            console.warn("Local authentication cancellation failed", cause instanceof Error ? cause.name : "NonError");
+            remote[Symbol.dispose]();
+        });
+    };
+    signal.addEventListener("abort", cancel, { once: true });
+    try {
+        signal.throwIfAborted();
+        const result = await remote.run(request, presenter);
+        return authResultSchema.parse(result);
+    }
+    finally {
+        signal.removeEventListener("abort", cancel);
+        controller.abort();
+        remote[Symbol.dispose]();
+    }
+}

package/dist/private-local-computer-attach.d.ts

@@ -0,0 +1,49 @@
+import type { FetchLike } from "@modelcontextprotocol/client";
+import { type LocalBackendStatus } from "./private-local-computer-backend.js";
+export type ControlOptions = Readonly<{
+    credentialPath?: string;
+    fetch?: FetchLike;
+}>;
+export type PrivateLocalComputerAttachResult = Readonly<{
+    kind: "attached";
+    computerId: string;
+    computerName: string;
+    backendId: string;
+    rootPath: string;
+}> | Readonly<{
+    kind: "not-found" | "uncertain" | "denied" | "conflict" | "invalid";
+}>;
+/** Attach `folderPath` to a Team Computer, or return the existing attachment. */
+export declare function attachPrivateLocalComputer(rawEndpoint: string | URL, input: Readonly<{
+    computer: string;
+    folderPath: string;
+    hostLabel?: string;
+}>, options?: ControlOptions): Promise<PrivateLocalComputerAttachResult>;
+export type PrivateLocalComputerDetachResult = Readonly<{
+    kind: "detached" | "not-attached" | "uncertain" | "denied";
+}>;
+/**
+ * Detach a Computer's attachment on the Hub, then forget it here. A pending
+ * attach is replayed first so the Hub never keeps an attachment Local forgot.
+ */
+export declare function detachPrivateLocalComputer(rawEndpoint: string | URL, computer: string, options?: ControlOptions): Promise<PrivateLocalComputerDetachResult>;
+/** What `fungi computer status` shows: never a key. */
+export declare function listPrivateLocalComputers(options?: Readonly<{
+    credentialPath?: string;
+}>): Promise<readonly Readonly<{
+    teamId: string;
+    computerId: string;
+    computerName: string;
+    rootPath: string;
+    backendId: string | null;
+}>[]>;
+export type PrivateLocalComputerRunOptions = {
+    credentialPath?: string;
+    signal: AbortSignal;
+    onStatus?: (status: LocalBackendStatus) => void;
+};
+/**
+ * Serve one attached folder until `signal` aborts or the Hub refuses the
+ * machine (it was detached elsewhere), in which case Local forgets it.
+ */
+export declare function runPrivateLocalComputer(rawEndpoint: string | URL, computer: string, options: PrivateLocalComputerRunOptions): Promise<"stopped" | "detached">;

package/dist/private-local-computer-attach.js

@@ -0,0 +1,216 @@
+import { generateKeyPairSync } from "node:crypto";
+import { realpath, stat } from "node:fs/promises";
+import { hostname } from "node:os";
+import { basename, resolve } from "node:path";
+import { defineIdFamily } from "@fungi.computer/cairn/id";
+import { z } from "zod";
+import { callFungiMcpTeamControl, fungiMcpTeamEndpoint, readFungiMcpLocalBackends, writeFungiMcpLocalBackends, } from "./private-fungi-account.js";
+import { runLocalComputerBackend, startLocalComputerd, } from "./private-local-computer-backend.js";
+/**
+ * `fungi computer attach|status|detach`: this machine's folders as execution
+ * backends of Team Computers. Attaching generates a device key here, stores
+ * the folder path and private key in Local's owner-only credential file, and
+ * sends the Hub only the public key and two labels through the member's
+ * existing Team MCP login. Every request id is persisted before the network
+ * call so an uncertain outcome is retried, never duplicated.
+ */
+const requestIds = defineIdFamily({
+    family: "local-computer-backend",
+    version: 1,
+    kinds: { attach: { prefix: "local_attach_request" } },
+});
+const computerPageSchema = z.looseObject({
+    computers: z.array(z.looseObject({ computerId: z.string(), name: z.string() })),
+    nextOffset: z.number().int().nonnegative().nullable(),
+});
+const attachResultSchema = z.discriminatedUnion("kind", [
+    z.looseObject({
+        kind: z.literal("attached"),
+        requestId: z.string(),
+        backendId: z.string().regex(/^local-[a-z2-7]{16}$/),
+    }),
+    z.looseObject({
+        kind: z.enum(["uncertain", "denied", "conflict", "invalid"]),
+        requestId: z.string(),
+    }),
+]);
+const detachResultSchema = z.discriminatedUnion("kind", [
+    z.looseObject({ kind: z.literal("detached"), detached: z.boolean() }),
+    z.looseObject({ kind: z.enum(["denied", "uncertain", "invalid"]) }),
+]);
+async function control(teamEndpoint, call, schema, options) {
+    const text = await callFungiMcpTeamControl(teamEndpoint, `return await ${call};`, options);
+    if (text === undefined)
+        return undefined;
+    const parsed = schema.safeParse(JSON.parse(text));
+    return parsed.success ? parsed.data : undefined;
+}
+/** A Team Computer by id or name, through the member's own directory view. */
+async function findComputer(teamEndpoint, computer, options) {
+    let offset = 0;
+    while (offset !== null) {
+        const page = await control(teamEndpoint, `computers.list(${JSON.stringify({ limit: 100, offset })})`, computerPageSchema, options);
+        if (page === undefined)
+            throw new Error("The Hub did not list this Team's Computers; retry");
+        const found = page.computers.find((candidate) => candidate.computerId === computer || candidate.name === computer);
+        if (found !== undefined)
+            return found;
+        offset = page.nextOffset;
+    }
+    return undefined;
+}
+function sameComputer(record, computer) {
+    return record.computerId === computer || record.computerName === computer;
+}
+/** A fresh Ed25519 device key: raw public key and PKCS#8 private key, base64. */
+function deviceKey() {
+    const pair = generateKeyPairSync("ed25519");
+    const jwk = z
+        .object({ x: z.string() })
+        .parse(pair.publicKey.export({ format: "jwk" }));
+    return {
+        publicKey: Buffer.from(jwk.x, "base64url").toString("base64"),
+        privateKey: pair.privateKey
+            .export({ format: "der", type: "pkcs8" })
+            .toString("base64"),
+    };
+}
+/** Attach `folderPath` to a Team Computer, or return the existing attachment. */
+export async function attachPrivateLocalComputer(rawEndpoint, input, options = {}) {
+    const { endpoint, teamId } = fungiMcpTeamEndpoint(rawEndpoint);
+    const rootPath = await realpath(resolve(input.folderPath));
+    if (!(await stat(rootPath)).isDirectory())
+        throw new Error("The folder to attach is not a directory");
+    const saved = await readFungiMcpLocalBackends(options);
+    if (saved.issuer !== endpoint.origin)
+        throw new Error(`Fungi MCP sign-in is required; run fungi login --fungi-mcp ${endpoint.href}`);
+    let record = saved.backends.find((candidate) => candidate.teamId === teamId && sameComputer(candidate, input.computer));
+    if (record !== undefined && record.rootPath !== rootPath)
+        throw new Error(`This machine is already attached to ${record.computerName} with another folder; run fungi computer detach first`);
+    if (record === undefined) {
+        const computer = await findComputer(endpoint, input.computer, options);
+        if (computer === undefined)
+            return { kind: "not-found" };
+        record = {
+            requestId: requestIds.attach.generate(),
+            teamId,
+            computerId: computer.computerId,
+            computerName: computer.name,
+            rootPath,
+            hostLabel: z
+                .string()
+                .trim()
+                .min(1)
+                .max(256)
+                .parse(input.hostLabel ?? hostname()),
+            folderLabel: z.string().min(1).max(256).parse(basename(rootPath)),
+            ...deviceKey(),
+        };
+        const pending = record;
+        await writeFungiMcpLocalBackends((current) => [...current, pending], options);
+    }
+    if (record.backendId !== undefined)
+        return {
+            kind: "attached",
+            computerId: record.computerId,
+            computerName: record.computerName,
+            backendId: record.backendId,
+            rootPath,
+        };
+    const result = await control(endpoint, `computers.attachLocal(${JSON.stringify({
+        computerId: record.computerId,
+        publicKey: record.publicKey,
+        hostLabel: record.hostLabel,
+        folderLabel: record.folderLabel,
+        requestId: record.requestId,
+    })})`, attachResultSchema, options);
+    if (result === undefined)
+        return { kind: "uncertain" };
+    if (result.kind !== "attached")
+        return { kind: result.kind };
+    const attached = { ...record, backendId: result.backendId };
+    await writeFungiMcpLocalBackends((current) => current.map((candidate) => candidate.requestId === attached.requestId ? attached : candidate), options);
+    return {
+        kind: "attached",
+        computerId: attached.computerId,
+        computerName: attached.computerName,
+        backendId: result.backendId,
+        rootPath,
+    };
+}
+/**
+ * Detach a Computer's attachment on the Hub, then forget it here. A pending
+ * attach is replayed first so the Hub never keeps an attachment Local forgot.
+ */
+export async function detachPrivateLocalComputer(rawEndpoint, computer, options = {}) {
+    const { endpoint, teamId } = fungiMcpTeamEndpoint(rawEndpoint);
+    const saved = await readFungiMcpLocalBackends(options);
+    const record = saved.backends.find((candidate) => candidate.teamId === teamId && sameComputer(candidate, computer));
+    if (record === undefined)
+        return { kind: "not-attached" };
+    let backendId = record.backendId;
+    if (backendId === undefined) {
+        const replay = await attachPrivateLocalComputer(endpoint, { computer: record.computerId, folderPath: record.rootPath }, options);
+        if (replay.kind !== "attached")
+            return { kind: "uncertain" };
+        backendId = replay.backendId;
+    }
+    const result = await control(endpoint, `computers.detachLocal(${JSON.stringify({
+        computerId: record.computerId,
+        backendId,
+    })})`, detachResultSchema, options);
+    if (result === undefined)
+        return { kind: "uncertain" };
+    if (result.kind === "denied")
+        return { kind: "denied" };
+    if (result.kind !== "detached")
+        return { kind: "uncertain" };
+    await writeFungiMcpLocalBackends((current) => current.filter((candidate) => candidate.requestId !== record.requestId), options);
+    return { kind: "detached" };
+}
+/** What `fungi computer status` shows: never a key. */
+export async function listPrivateLocalComputers(options = {}) {
+    const saved = await readFungiMcpLocalBackends(options);
+    return saved.backends.map((record) => ({
+        teamId: record.teamId,
+        computerId: record.computerId,
+        computerName: record.computerName,
+        rootPath: record.rootPath,
+        backendId: record.backendId ?? null,
+    }));
+}
+/**
+ * Serve one attached folder until `signal` aborts or the Hub refuses the
+ * machine (it was detached elsewhere), in which case Local forgets it.
+ */
+export async function runPrivateLocalComputer(rawEndpoint, computer, options) {
+    const { endpoint, teamId } = fungiMcpTeamEndpoint(rawEndpoint);
+    const saved = await readFungiMcpLocalBackends(options);
+    const record = saved.backends.find((candidate) => candidate.teamId === teamId && sameComputer(candidate, computer));
+    if (record?.backendId === undefined)
+        throw new Error(`This machine is not attached to ${computer}`);
+    const daemon = await startLocalComputerd({ root: record.rootPath });
+    try {
+        const outcome = await runLocalComputerBackend({
+            target: {
+                hubOrigin: endpoint.origin,
+                teamId,
+                computerId: record.computerId,
+                backendId: record.backendId,
+                deviceId: record.backendId.slice("local-".length),
+                privateKey: record.privateKey,
+            },
+            root: record.rootPath,
+            computerdPort: daemon.port,
+            signal: options.signal,
+            onStatus: options.onStatus,
+        });
+        if (outcome === "stopped")
+            return "stopped";
+        await writeFungiMcpLocalBackends((current) => current.filter((candidate) => candidate.requestId !== record.requestId), options);
+        return "detached";
+    }
+    finally {
+        await daemon.stop();
+    }
+}