@fungi.computer/truffle 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,396 @@
+import { RpcTarget } from "@fungi.computer/capnweb";
+import { z } from "zod";
+import { fungiAccountLogoutRequestSchema, fungiAccountLogoutResultSchema, } from "./private-fungi-service-logout.js";
+import { LocalAuthRefusal, localAuthInputLimit, runLocalAuthCli, } from "./auth-cli.js";
+import { openAIIdentityDetailSchema } from "./private-openai-claims.js";
+import { CredentialActivationError } from "./subscription-activation.js";
+import { OpenAIIdentityUnavailable } from "./subscription-identity.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);
+/**
+ * The closed set of failures that cross the service. Provider errors can
+ * contain credential material, so no free text, cause or provider message
+ * crosses: only a fixed category, HTTP status, or missing-person claim NAMES.
+ */
+const localAuthFailureSchema = z.discriminatedUnion("category", [
+    z.strictObject({
+        category: z.literal("identity-unavailable"),
+        detail: openAIIdentityDetailSchema.optional(),
+    }),
+    z.strictObject({ category: z.literal("callback-port-in-use") }),
+    z.strictObject({ category: z.literal("oauth-state-mismatch") }),
+    z.strictObject({
+        category: z.literal("token-exchange-rejected"),
+        status: z.number().int().min(100).max(599),
+    }),
+    z.strictObject({ category: z.literal("cancelled") }),
+    z.strictObject({ category: z.literal("no-key-entered") }),
+    z.strictObject({ category: z.literal("unknown") }),
+]);
+const wireResultSchema = z.union([
+    authResultSchema,
+    z.strictObject({
+        kind: z.literal("failed"),
+        failure: localAuthFailureSchema,
+    }),
+]);
+/** Pi 1.3.0's fixed error prefixes; never retain a provider body suffix. */
+const callbackPortInUse = /^Port \d+ is in use\b/u;
+const oauthStateMismatch = "OAuth state mismatch";
+const openAITokenRequestFailed = /^OpenAI OAuth token request failed \(([1-5]\d{2})\)/u;
+function classifyFailure(cause, aborted) {
+    if (aborted)
+        return { category: "cancelled" };
+    if (cause instanceof LocalAuthRefusal)
+        return { category: "no-key-entered" };
+    if (cause instanceof OpenAIIdentityUnavailable)
+        return { category: "identity-unavailable", detail: cause.detail };
+    if (cause instanceof CredentialActivationError &&
+        cause.category === "identity-unavailable")
+        return { category: "identity-unavailable" };
+    if (cause instanceof Error) {
+        const tokenRequest = openAITokenRequestFailed.exec(cause.message);
+        if (tokenRequest !== null)
+            return {
+                category: "token-exchange-rejected",
+                status: Number(tokenRequest[1]),
+            };
+    }
+    if (cause instanceof Error && callbackPortInUse.test(cause.message))
+        return { category: "callback-port-in-use" };
+    if (cause instanceof Error && cause.message === oauthStateMismatch)
+        return { category: "oauth-state-mismatch" };
+    return { category: "unknown" };
+}
+/** Fixed wording per category; the dialog shows exactly this. */
+function failureText(failure) {
+    switch (failure.category) {
+        case "identity-unavailable": {
+            const detail = failure.detail;
+            if (detail === undefined)
+                return "Sign-in could not establish the account identity (identity-unavailable). Nothing was saved.";
+            const auth = detail.authClaimNames === undefined
+                ? ""
+                : "; auth claims: " + (detail.authClaimNames.join(", ") || "none");
+            return ("OpenAI sign-in did not identify the person (identity-unavailable: " +
+                detail.claim +
+                " " +
+                detail.problem +
+                "; claims: " +
+                (detail.claimNames.join(", ") || "none") +
+                auth +
+                "). Nothing was saved.");
+        }
+        case "callback-port-in-use":
+            return "The sign-in callback port is in use, probably by another sign-in or the Codex CLI. Close it and try again.";
+        case "oauth-state-mismatch":
+            return "The sign-in redirect did not belong to this attempt. Start the sign-in again.";
+        case "token-exchange-rejected":
+            return `OpenAI refused the sign-in token exchange (HTTP ${String(failure.status)}).`;
+        case "cancelled":
+            return "Authentication cancelled";
+        case "no-key-entered":
+            return new LocalAuthRefusal().message;
+        case "unknown":
+            return "Local authentication failed";
+    }
+}
+/** The client-side error for one typed failure; its message is fixed text. */
+class LocalAuthFailure extends Error {
+    failure;
+    constructor(failure) {
+        super(failureText(failure));
+        this.failure = failure;
+        this.name = "LocalAuthFailure";
+    }
+}
+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 provider or Fungi-account operation. */
+export class PrivateLocalAuthTarget extends RpcTarget {
+    #controller = new AbortController();
+    #used = false;
+    #run;
+    #signOutAccount;
+    constructor(run, signOutAccount) {
+        super();
+        this.#run = run;
+        this.#signOutAccount = signOutAccount;
+    }
+    async signOutFungi(input) {
+        if (this.#used)
+            throw new Error("Authentication connection already used");
+        this.#used = true;
+        return fungiAccountLogoutResultSchema.parse(await this.#signOutAccount(fungiAccountLogoutRequestSchema.parse(input)));
+    }
+    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 (cause) {
+            return {
+                kind: "failed",
+                failure: classifyFailure(cause, signal.aborted),
+            };
+        }
+        finally {
+            this.cancel();
+        }
+    }
+}
+/**
+ * Takes ownership of a dedicated auth RPC connection, never the Session client.
+ * A cancel the caller asked for is awaited before the connection is released,
+ * so an ordinary cancel is never cut off by its own teardown; a cancel that
+ * genuinely fails is handed to `reportCleanupFailure` with its cause.
+ */
+export async function runPrivateLocalAuthRemote(remote, request, interaction, reportCleanupFailure) {
+    const controller = new AbortController();
+    const signal = interaction.signal === undefined
+        ? controller.signal
+        : AbortSignal.any([controller.signal, interaction.signal]);
+    const presenter = new AuthPresenterTarget({ ...interaction, signal });
+    let cancellation;
+    const cancel = () => {
+        cancellation = (async () => {
+            await remote.cancel();
+        })();
+    };
+    signal.addEventListener("abort", cancel, { once: true });
+    try {
+        signal.throwIfAborted();
+        const result = wireResultSchema.parse(await remote.run(request, presenter));
+        if (result.kind === "failed")
+            throw new LocalAuthFailure(result.failure);
+        return result;
+    }
+    finally {
+        signal.removeEventListener("abort", cancel);
+        controller.abort();
+        try {
+            const [cancelled] = await Promise.allSettled([cancellation]);
+            if (cancelled.status === "rejected")
+                reportCleanupFailure(cancelled.reason);
+        }
+        finally {
+            remote[Symbol.dispose]();
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+export declare class LocalBwrapUnavailable extends Error {
+    readonly reason: "missing" | "invalid-digest" | "digest-mismatch" | "not-executable";
+    readonly name = "LocalBwrapUnavailable";
+    constructor(reason: "missing" | "invalid-digest" | "digest-mismatch" | "not-executable", message: string, options?: ErrorOptions);
+}
+export type LinuxSandboxPayload = {
+    readonly executable: string;
+    readonly seccompFilter: Uint8Array;
+};
+/** Check both packaged artifacts on every use; never cache verification. */
+export declare function verifyLocalLinuxSandboxPayload(executable: string): LinuxSandboxPayload;
+/** Same optional native-package lookup as apply_patch, with no PATH fallback. */
+export declare function localLinuxSandboxPayload(): LinuxSandboxPayload;

package/dist/private-local-bwrap.js

@@ -0,0 +1,70 @@
+import { createHash } from "node:crypto";
+import { accessSync, constants, readFileSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+const digestSchema = z
+    .string()
+    .trim()
+    .regex(/^[a-f0-9]{64}$/u);
+export class LocalBwrapUnavailable extends Error {
+    reason;
+    name = "LocalBwrapUnavailable";
+    constructor(reason, message, options) {
+        super(message, options);
+        this.reason = reason;
+    }
+}
+/** Check both packaged artifacts on every use; never cache verification. */
+export function verifyLocalLinuxSandboxPayload(executable) {
+    verifiedBytes(executable, "fungi-bwrap");
+    try {
+        accessSync(executable, constants.X_OK);
+    }
+    catch (cause) {
+        throw new LocalBwrapUnavailable("not-executable", "Packaged fungi-bwrap cannot be executed; reinstall Fungi.", { cause });
+    }
+    return {
+        executable,
+        seccompFilter: verifiedBytes(join(dirname(executable), "fungi-seccomp.bpf"), "fungi-seccomp.bpf"),
+    };
+}
+function verifiedBytes(path, label) {
+    let bytes;
+    let digest;
+    try {
+        if (!statSync(path).isFile())
+            throw new LocalBwrapUnavailable("not-executable", `Packaged ${label} is not a regular file; reinstall Fungi.`);
+        bytes = readFileSync(path);
+        digest = readFileSync(`${path}.sha256`, "utf8");
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+            throw new LocalBwrapUnavailable("missing", `Packaged ${label} or its digest is missing; reinstall Fungi with optional dependencies enabled.`, { cause });
+        throw cause;
+    }
+    const expected = digestSchema.safeParse(digest);
+    if (!expected.success)
+        throw new LocalBwrapUnavailable("invalid-digest", `Packaged ${label} has an invalid SHA-256 record; reinstall Fungi.`);
+    if (createHash("sha256").update(bytes).digest("hex") !== expected.data)
+        throw new LocalBwrapUnavailable("digest-mismatch", `Packaged ${label} digest mismatch; reinstall Fungi. No command was started.`);
+    return bytes;
+}
+/** Same optional native-package lookup as apply_patch, with no PATH fallback. */
+export function localLinuxSandboxPayload() {
+    let executable;
+    if (process.env.FUNGI_BUNDLED_CLI) {
+        const name = `@fungi.computer/spore-native-${process.platform}-${process.arch}`;
+        try {
+            executable = createRequire(process.env.FUNGI_BUNDLED_CLI).resolve(`${name}/bin/fungi-bwrap`);
+        }
+        catch (cause) {
+            throw new LocalBwrapUnavailable("missing", `Missing ${name}/bin/fungi-bwrap; reinstall Fungi with optional dependencies enabled.`, { cause });
+        }
+    }
+    else {
+        executable = fileURLToPath(new URL("../native/bin/fungi-bwrap", import.meta.url));
+    }
+    return verifyLocalLinuxSandboxPayload(executable);
+}

package/dist/private-local-client-version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Read the installed producer, never the calling window's frozen environment.
+ * Undefined means no fungi is installed on PATH, so no client is current.
+ */
+export declare function readInstalledLocalClientBuildId(launcher?: string): Promise<string | undefined>;

package/dist/private-local-client-version.js

@@ -0,0 +1,43 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFile, realpath } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+const execute = promisify(execFile);
+const queryOptions = { timeout: 2_000, maxBuffer: 4_096 };
+const buildId = z.string().regex(/^[a-f0-9]{64}$/u);
+function installedLauncherOnPath() {
+    return new Promise((resolve, reject) => {
+        execFile("which", ["fungi"], queryOptions, (error, stdout) => {
+            if (error === null)
+                resolve(stdout.trim());
+            // which exits 1 when nothing named fungi is installed on PATH.
+            else if (error.code === 1)
+                resolve(undefined);
+            else
+                reject(new Error("Could not look up the installed fungi launcher", {
+                    cause: error,
+                }));
+        });
+    });
+}
+/**
+ * Read the installed producer, never the calling window's frozen environment.
+ * Undefined means no fungi is installed on PATH, so no client is current.
+ */
+export async function readInstalledLocalClientBuildId(launcher) {
+    const found = launcher ?? (await installedLauncherOnPath());
+    if (found === undefined)
+        return undefined;
+    const installed = await realpath(found);
+    if (basename(installed) === "fungi.cjs") {
+        // npm replaces cli.js in place. This is the launcher's own identity rule.
+        return createHash("sha256")
+            .update(await readFile(join(dirname(installed), "cli.js")))
+            .digest("hex");
+    }
+    // Compiled launchers identify their embedded archive, not executable bytes.
+    const { stdout } = await execute(installed, ["--internal-build-id"], queryOptions);
+    return buildId.parse(JSON.parse(stdout));
+}

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;
+}>, controlOptions?: 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, input?: 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, input: PrivateLocalComputerRunOptions): Promise<"stopped" | "detached">;