@fungi.computer/truffle 0.1.1 → 0.2.1

package/dist/private-mcp-form-session.js

@@ -0,0 +1,148 @@
+import { correlationKey } from "@fungi.computer/cairn";
+import { defineExtension } from "@fungi.computer/shiitake/extensions";
+import * as Effect from "effect/Effect";
+import { mcpFormApprovalContract, } from "./private-mcp-form-contract.js";
+import { consumeLocalUiCommand, runLocalUiCommand, startLocalUiWatch, } from "./private-local-ui-attachment.js";
+const maximumPendingForms = 100;
+/** Host-owned references to canonical approvals; no suspended tool or second ledger. */
+export function createMcpFormSession() {
+    const pending = new Map();
+    let publish;
+    const extension = defineExtension({
+        id: mcpFormApprovalContract.id,
+        version: "1.0.0",
+    }).define({
+        commands: {
+            specs: mcpFormApprovalContract.commands,
+            handlers: (context) => ({
+                answer: ({ sessionId, input }) => Effect.gen(function* () {
+                    const onComplete = consumeLocalUiCommand(sessionId);
+                    if (onComplete === undefined) {
+                        const result = {
+                            kind: "refused",
+                            reason: "not-attached",
+                        };
+                        return result;
+                    }
+                    const entry = pending.get(input.id);
+                    if (entry?.sessionId !== sessionId) {
+                        const result = {
+                            kind: "refused",
+                            reason: "not-pending",
+                        };
+                        return result;
+                    }
+                    if (entry.answering) {
+                        const result = {
+                            kind: "refused",
+                            reason: "in-flight",
+                        };
+                        return result;
+                    }
+                    entry.answering = true;
+                    onComplete(async (committed) => {
+                        try {
+                            if (!committed)
+                                return { kind: "refused", reason: "not-attached" };
+                            // Session commit and live UI recheck precede the canonical
+                            // decision. Its bound host, never MCP accept, owns apply.
+                            return await entry.approvals.answer({
+                                recordId: entry.approval.record.recordId,
+                                decision: input.decision,
+                                expectedRevision: input.expectedRevision,
+                            });
+                        }
+                        finally {
+                            entry.answering = false;
+                            const view = await entry.approvals.get({
+                                recordId: entry.approval.record.recordId,
+                            });
+                            if (view?.record.state !== "pending")
+                                pending.delete(input.id);
+                            else
+                                entry.approval = view;
+                            await publish?.(sessionId);
+                        }
+                    });
+                    yield* context.observe(sessionId);
+                    const result = { kind: "submitted" };
+                    return result;
+                }),
+            }),
+        },
+        hooks: {
+            start: (context) => {
+                publish = (sessionId) => Effect.runPromise(context.transact(context.observe(sessionId)));
+            },
+        },
+        projection: {
+            schema: mcpFormApprovalContract.projection.schema,
+            read: (_context, sessionId) => ({
+                pending: [...pending.entries()]
+                    .filter(([, entry]) => entry.sessionId === sessionId)
+                    .map(([id, entry]) => ({ id, approval: entry.approval })),
+            }),
+        },
+    });
+    /**
+     * Native host port, never a model or UI command. The caller supplies the
+     * actual submit result and a member-bound capability, not form JSON.
+     */
+    async function presentApproval(sessionId, submitted, approvals) {
+        const approval = await approvals.get({ recordId: submitted.recordId });
+        if (approval?.record.state !== "pending" ||
+            approval.record.requester.sessionId !== sessionId)
+            return { kind: "refused", reason: "not-pending" };
+        const existing = [...pending.entries()].find(([, entry]) => entry.sessionId === sessionId &&
+            entry.approval.record.recordId === submitted.recordId);
+        if (existing !== undefined) {
+            const [id, entry] = existing;
+            entry.approval = approval;
+            entry.approvals = approvals;
+            await publish?.(sessionId);
+            return { kind: "presented", id };
+        }
+        if (pending.size >= maximumPendingForms)
+            return { kind: "refused", reason: "capacity" };
+        const id = correlationKey();
+        pending.set(id, { sessionId, approval, approvals, answering: false });
+        await publish?.(sessionId);
+        return { kind: "presented", id };
+    }
+    function bindSession(sessionId, session, attachment) {
+        if (attachment === undefined)
+            return session;
+        return {
+            ...session,
+            extension: (id) => {
+                const client = session.extension(id);
+                return {
+                    ...client,
+                    call: (command, input) => id === mcpFormApprovalContract.id && command === "answer"
+                        ? runLocalUiCommand(attachment, sessionId, () => client.call(command, input))
+                        : client.call(command, input),
+                };
+            },
+            watch: async (input) => {
+                const stopWatching = startLocalUiWatch(attachment, sessionId);
+                if (stopWatching === undefined)
+                    return session.watch(input);
+                try {
+                    const watch = await session.watch(input);
+                    return {
+                        ...watch,
+                        close: async () => {
+                            stopWatching();
+                            await watch.close();
+                        },
+                    };
+                }
+                catch (error) {
+                    stopWatching();
+                    throw error;
+                }
+            },
+        };
+    }
+    return { extension, presentApproval, bindSession };
+}

package/dist/private-openai-claims.d.ts

@@ -0,0 +1,30 @@
+import { decodeJwt } from "jose";
+import { z } from "zod";
+/**
+ * Why a sign-in proved no person: the token or claim at fault and the claim
+ * NAMES present. Never claim values, emails, subjects or tokens.
+ */
+export declare const openAIIdentityDetailSchema: z.ZodObject<{
+    claim: z.ZodEnum<{
+        access_token: "access_token";
+        "access_token.iss": "access_token.iss";
+        "access_token.sub": "access_token.sub";
+    }>;
+    problem: z.ZodEnum<{
+        absent: "absent";
+        malformed: "malformed";
+        invalid: "invalid";
+    }>;
+    claimNames: z.ZodArray<z.ZodString>;
+    authClaimNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type OpenAIIdentityDetail = z.output<typeof openAIIdentityDetailSchema>;
+/** The person a direct-access token belongs to: its issuer and subject. */
+export declare function readOpenAIPerson(access: string, decode?: typeof decodeJwt): Readonly<{
+    kind: "person";
+    iss: string;
+    sub: string;
+}> | Readonly<{
+    kind: "unproven";
+    detail: OpenAIIdentityDetail;
+}>;

package/dist/private-openai-claims.js

@@ -0,0 +1,69 @@
+import { decodeJwt, errors } from "jose";
+import { z } from "zod";
+const identityComponent = z
+    .string()
+    .min(1)
+    .max(256)
+    .refine((value) => value.trim().length > 0);
+const authNamespace = "https://api.openai.com/auth";
+const claimObjectSchema = z.record(z.string(), z.json());
+/** At most this many claim names, each at most this long, ever cross. */
+const claimNameLimit = 32;
+const claimNameLength = 64;
+const claimNamesSchema = z
+    .array(z.string().max(claimNameLength))
+    .max(claimNameLimit);
+/**
+ * Why a sign-in proved no person: the token or claim at fault and the claim
+ * NAMES present. Never claim values, emails, subjects or tokens.
+ */
+export const openAIIdentityDetailSchema = z.strictObject({
+    claim: z.enum(["access_token", "access_token.iss", "access_token.sub"]),
+    problem: z.enum(["malformed", "absent", "invalid"]),
+    claimNames: claimNamesSchema,
+    authClaimNames: claimNamesSchema.optional(),
+});
+const names = (claims) => Object.keys(claims)
+    .slice(0, claimNameLimit)
+    .map((name) => name.slice(0, claimNameLength));
+/** Decode JWT claims; only jose's JWTInvalid means a malformed token. */
+function claimsOf(token, decode) {
+    try {
+        return claimObjectSchema.parse(decode(token));
+    }
+    catch (error) {
+        // Anything other than JWTInvalid is a real fault, not a malformed token.
+        if (error instanceof errors.JWTInvalid)
+            return undefined;
+        throw error;
+    }
+}
+/** The person a direct-access token belongs to: its issuer and subject. */
+export function readOpenAIPerson(access, decode = decodeJwt) {
+    const claims = claimsOf(access, decode);
+    if (claims === undefined)
+        return {
+            kind: "unproven",
+            detail: { claim: "access_token", problem: "malformed", claimNames: [] },
+        };
+    const claimNames = names(claims);
+    const auth = claimObjectSchema.safeParse(claims[authNamespace]);
+    const context = auth.success
+        ? { claimNames, authClaimNames: names(auth.data) }
+        : { claimNames };
+    const unproven = (claim, key) => ({
+        kind: "unproven",
+        detail: {
+            claim,
+            problem: key in claims ? "invalid" : "absent",
+            ...context,
+        },
+    });
+    const iss = identityComponent.safeParse(claims.iss);
+    if (!iss.success)
+        return unproven("access_token.iss", "iss");
+    const sub = identityComponent.safeParse(claims.sub);
+    if (!sub.success)
+        return unproven("access_token.sub", "sub");
+    return { kind: "person", iss: iss.data, sub: sub.data };
+}

package/dist/private-oyster-mcp-auth.d.ts

@@ -0,0 +1,13 @@
+import { UnauthorizedError, type AuthProvider } from "@modelcontextprotocol/client";
+/** A selected Oyster refused its key; never fall through to Hub OAuth. */
+export declare class OysterMcpKeyRejectedError extends UnauthorizedError {
+    constructor();
+}
+/** Read bounded UTF-8 stdin, then place the key in Local's existing private store. */
+export declare function saveOysterMcpKey(endpoint: URL, input: AsyncIterable<Uint8Array>, options?: {
+    credentialPath?: string;
+}): Promise<void>;
+/** Static bearer auth reads only the selected origin's credential, without discovery. */
+export declare function oysterMcpKeyAuth(endpoint: URL, options?: {
+    credentialPath?: string;
+}): AuthProvider;

package/dist/private-oyster-mcp-auth.js

@@ -0,0 +1,57 @@
+import { UnauthorizedError, } from "@modelcontextprotocol/client";
+import { z } from "zod";
+import { createPrivateCredentialStore, maximumCredentialStringLength, } from "./private-file-credential-store.js";
+import { parseFungiMcpEndpoint } from "./private-fungi-mcp-endpoint.js";
+import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
+/** A selected Oyster refused its key; never fall through to Hub OAuth. */
+export class OysterMcpKeyRejectedError extends UnauthorizedError {
+    constructor() {
+        super("The Oyster MCP key was refused. Replace it with fungi mcp use <url> --from-file -.");
+        this.name = "OysterMcpKeyRejectedError";
+    }
+}
+function credentialId(endpoint) {
+    return `oyster-mcp:${parseFungiMcpEndpoint(endpoint).origin}`;
+}
+// Ear Tag's Oyster producer uses the oyk family and nanoid's URL-safe alphabet.
+const oysterKey = z
+    .string()
+    .trim()
+    .min(5)
+    .max(maximumCredentialStringLength)
+    .regex(/^oyk_[A-Za-z0-9_-]+$/);
+/** Read bounded UTF-8 stdin, then place the key in Local's existing private store. */
+export async function saveOysterMcpKey(endpoint, input, options = {}) {
+    const id = credentialId(endpoint);
+    const store = createPrivateCredentialStore(options.credentialPath ?? capturePrivateLocalConfigRoot().credentialPath);
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let bytes = 0;
+    let text = "";
+    for await (const chunk of input) {
+        bytes += chunk.byteLength;
+        if (bytes > maximumCredentialStringLength)
+            throw new Error("Oyster key input is too large");
+        text += decoder.decode(chunk, { stream: true });
+    }
+    text += decoder.decode();
+    const parsed = oysterKey.safeParse(text);
+    if (!parsed.success)
+        throw new Error("Expected one Oyster oyk_ key on stdin");
+    await store.modify(id, () => Promise.resolve({ type: "api_key", key: parsed.data }));
+}
+/** Static bearer auth reads only the selected origin's credential, without discovery. */
+export function oysterMcpKeyAuth(endpoint, options = {}) {
+    const id = credentialId(endpoint);
+    const store = createPrivateCredentialStore(options.credentialPath ?? capturePrivateLocalConfigRoot().credentialPath);
+    return {
+        async token() {
+            const credential = await store.read(id);
+            if (credential?.type !== "api_key" || credential.key === undefined)
+                throw new OysterMcpKeyRejectedError();
+            return credential.key;
+        },
+        onUnauthorized() {
+            return Promise.reject(new OysterMcpKeyRejectedError());
+        },
+    };
+}

package/dist/private-provider-rejection.d.ts

@@ -0,0 +1,15 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ProviderRejection } from "@fungi.computer/mule";
+/** Evidence owned by one Local request, never inferred from assistant prose. */
+export type ModelFailureInput = Readonly<{
+    refusal?: Readonly<{
+        category: string;
+        message: string;
+    }> | undefined;
+    upstream?: AssistantMessage | undefined;
+    rejection?: ProviderRejection | undefined;
+}>;
+/** Local retries only a typed transient, never cancellation or a turn refusal. */
+export declare function modelFailureRetryable(failure: ModelFailureInput): boolean;
+/** The one owned wording for a failed Local model request. */
+export declare function modelFailureMessage(provider: string, failure: ModelFailureInput): string;

package/dist/private-provider-rejection.js

@@ -0,0 +1,24 @@
+import { isContextOverflow } from "@earendil-works/pi-ai/utils/overflow";
+/** Local retries only a typed transient, never cancellation or a turn refusal. */
+export function modelFailureRetryable(failure) {
+    return (failure.refusal === undefined &&
+        failure.upstream?.stopReason !== "aborted" &&
+        failure.rejection?.code === "provider_unavailable");
+}
+/** The one owned wording for a failed Local model request. */
+export function modelFailureMessage(provider, failure) {
+    if (failure.refusal !== undefined)
+        return `${failure.refusal.category}: ${failure.refusal.message}`;
+    // Typed subscription evidence wins over all SDK/provider wording.
+    if (failure.rejection?.code === "usage-limit-reached")
+        return `${provider} usage limit reached (usage-limit-reached). Check ChatGPT Settings > Usage, then try again later.`;
+    if (modelFailureRetryable(failure))
+        return `${provider} service unavailable. Try again shortly.`;
+    if (failure.upstream !== undefined) {
+        if (isContextOverflow(failure.upstream))
+            return `${provider} request exceeds the context window. Compact the Session or choose another model.`;
+    }
+    if (failure.rejection?.code === "provider_rejected")
+        return `${provider} rejected the model request (${failure.rejection.code}, HTTP ${String(failure.rejection.status)}). Check /login or choose another model with /model.`;
+    return `${provider} rejected the model request. Check /login or choose another model with /model.`;
+}

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

@@ -1,7 +1,39 @@
 import { DatabaseSync } from "node:sqlite";
 import type { SqliteOwner } from "@fungi.computer/shiitake";
+export type NativeOutput = null | number | bigint | string | Uint8Array;
+export type NativeInput = null | number | string | Uint8Array;
+/** Bun keeps its native transaction and deterministic statement-close APIs. */
+export type PrivateBunSqliteDatabase = {
+    readonly isTransaction: boolean;
+    exec: (statement: string) => void;
+    prepare: (statement: string) => {
+        all: (...bindings: NativeInput[]) => Record<string, NativeOutput>[];
+        get: (...bindings: NativeInput[]) => Record<string, NativeOutput> | undefined;
+        run: (...bindings: NativeInput[]) => {
+            changes: number | bigint;
+        };
+    };
+    transactionSync: SqliteOwner["transactionSync"];
+    close: () => void;
+};
+/** The actual Node connection or Local's explicit native Bun adapter. */
+export type PrivateSqliteDatabase = DatabaseSync | PrivateBunSqliteDatabase;
+/**
+ * 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 declare function openPrivateReadOnlySqliteDatabase(path: string): PrivateSqliteDatabase;
+/** Writable connections own their statements through deterministic close. */
+export declare function openPrivateWritableSqliteDatabase(path: string, timeout: number): PrivateSqliteDatabase;
 export type PrivateSqliteFailureCode = "busy" | "locked" | "corrupt" | "not_a_database" | "other";
-/** Decode Node SQLite's structured result code before higher owners sanitize it. */
+/** Decode the maintained drivers' structured result codes before sanitizing. */
 export declare function privateSqliteFailureCode(cause: unknown): PrivateSqliteFailureCode | undefined;
+/**
+ * Keep Local's native failure reporting around a host-supplied SQL owner.
+ * The supplied owner retains transaction mechanics and connection lifetime.
+ */
+export declare function observePrivateSqliteOwner(owner: SqliteOwner, onFailure?: (code: PrivateSqliteFailureCode) => void): SqliteOwner;
 /** Adapt one synchronous native database to Shiitake's public owner shape. */
-export declare function createPrivateSqliteOwner(database: DatabaseSync, onFailure?: (code: PrivateSqliteFailureCode) => void): SqliteOwner;
+export declare function createPrivateSqliteOwner(database: PrivateSqliteDatabase, onFailure?: (code: PrivateSqliteFailureCode) => void): SqliteOwner;

package/dist/private-sqlite-owner.js

@@ -1,19 +1,84 @@
 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 sqliteFailureSchema = z.object({
-    code: z.literal("ERR_SQLITE_ERROR"),
-    errcode: z.number().int(),
-});
+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 Node SQLite's structured result code before higher owners sanitize it. */
+/** 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.errcode & sqlitePrimaryCodeMask) {
+    switch (parsed.data & sqlitePrimaryCodeMask) {
         case 5:
             return "busy";
         case 6:
@@ -44,8 +109,11 @@ function nativeOutput(value) {
 function nativeRow(row) {
     return Object.fromEntries(Object.entries(row).map(([key, value]) => [key, nativeOutput(value)]));
 }
-/** Adapt one synchronous native database to Shiitake's public owner shape. */
-export function createPrivateSqliteOwner(database, onFailure) {
+/**
+ * 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)
@@ -55,17 +123,36 @@ export function createPrivateSqliteOwner(database, onFailure) {
     return Object.freeze({
         sql: Object.freeze({
             exec: (statement, ...bindings) => {
-                let rows;
                 try {
-                    const prepared = database.prepare(statement);
-                    const values = bindings.map(nativeInput);
-                    rows = readerStatement.test(statement)
-                        ? prepared.all(...values).map(nativeRow)
-                        : (prepared.run(...values), []);
+                    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: () => {
@@ -76,28 +163,7 @@ export function createPrivateSqliteOwner(database, onFailure) {
                     },
                 });
             },
-        }),
-        transactionSync: (operation) => {
-            try {
-                database.exec("BEGIN");
-            }
-            catch (cause) {
-                return observeFailure(cause);
-            }
-            try {
-                const value = operation();
-                database.exec("COMMIT");
-                return value;
-            }
-            catch (cause) {
-                try {
-                    database.exec("ROLLBACK");
-                }
-                catch (rollbackCause) {
-                    observeFailure(rollbackCause);
-                }
-                return observeFailure(cause);
-            }
         },
-    });
+        transactionSync: database.transactionSync,
+    }, onFailure);
 }

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

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

package/dist/private-team-computers.js

@@ -1,5 +1,6 @@
 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"]) }),
@@ -49,7 +50,11 @@ async function directory(endpoint, options) {
     throw new Error("This Team has too many Computer pages to list in one command.");
 }
 /** Team directory and real runtime liveness, using Local's existing authenticated MCP transport. */
-export async function listPrivateTeamComputers(rawEndpoint, options = {}) {
+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 = [];
@@ -61,7 +66,11 @@ export async function listPrivateTeamComputers(rawEndpoint, options = {}) {
     return rows;
 }
 /** Await admission while reporting live queue positions. Ctrl-C stops the local wait. */
-export async function startPrivateTeamComputer(rawEndpoint, name, options) {
+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);