@fungi.computer/truffle 0.1.1 → 0.2.1

package/dist/private-fungi-mcp-connection.js

@@ -4,6 +4,7 @@ import { Client, StreamableHTTPClientTransport, UnauthorizedError, } from "@mode
 import { Mycelium } from "@fungi.computer/mycelium";
 import { z } from "zod";
 import { parseFungiMcpEndpoint } from "./private-fungi-mcp-endpoint.js";
+import { registerMcpFormElicitation, McpFormApprovalError, } from "./private-mcp-form-elicitation.js";
 const localPackage = z
     .looseObject({ version: z.string().min(1) })
     .parse(createRequire(import.meta.url)("../package.json"));
@@ -31,8 +32,11 @@ export function rejectedFungiMcpAccess(response) {
 }
 export function fungiMcpReachableFetch(endpoint, fetchImpl = fetch) {
     return async (url, init) => {
+        const target = new URL(url instanceof Request ? url.url : String(url));
+        if (target.origin !== endpoint.origin)
+            throw new Error("Refusing an MCP request outside the selected origin");
         try {
-            const response = await fetchImpl(url, init);
+            const response = await fetchImpl(url, { ...init, redirect: "error" });
             const authorization = new Headers(init?.headers).get("Authorization");
             if (response.status === 401 && authorization?.startsWith("Bearer "))
                 rejectedAccess.set(response, authorization.slice(7));
@@ -55,9 +59,10 @@ export function createPrivateFungiMcpConnection(options) {
     const fetch = fungiMcpReachableFetch(endpoint, options.fetch);
     return {
         id: "fungi-mcp",
-        acquire: async ({ signal }) => {
+        acquire: async ({ signal, session }) => {
             signal.throwIfAborted();
             const client = new Client(fungiMcpClientInfo);
+            const forms = registerMcpFormElicitation(client, options.requestApproval, session?.sessionId);
             const transportOptions = {
                 authProvider: options.authProvider,
                 fetch,
@@ -84,9 +89,18 @@ export function createPrivateFungiMcpConnection(options) {
                                             try {
                                                 return z
                                                     .json()
-                                                    .parse(await client.callTool({ name: "execute", arguments: input }, { signal: context.signal }));
+                                                    .parse(await forms.run(context.signal, (signal) => client.callTool({ name: "execute", arguments: input }, { signal })));
                                             }
                                             catch (cause) {
+                                                if (cause instanceof McpFormApprovalError)
+                                                    return {
+                                                        isError: true,
+                                                        content: [{ type: "text", text: cause.message }],
+                                                        structuredContent: {
+                                                            kind: cause.kind,
+                                                            reason: cause.reason,
+                                                        },
+                                                    };
                                                 // Report uncertainty as a failed MCP result so the caller
                                                 // can distinguish it from a successful remote result.
                                                 // Replaying arbitrary JavaScript here could duplicate work.
@@ -127,13 +141,18 @@ export function createPrivateFungiMcpConnection(options) {
                             }),
                         ],
                     },
-                    release: () => client.close(),
+                    release: () => {
+                        forms.close();
+                        return client.close();
+                    },
                 };
             }
             catch (error) {
+                forms.close();
                 await client.close();
-                if (error instanceof UnauthorizedError ||
-                    error instanceof FungiSignInRequiredError ||
+                if (error instanceof UnauthorizedError)
+                    throw error;
+                if (error instanceof FungiSignInRequiredError ||
                     z.object({ status: z.literal(401) }).safeParse(error).success)
                     throw new Error(`Fungi MCP sign-in is missing, expired or revoked; run fungi login --fungi-mcp ${endpoint.href}`, { cause: error });
                 throw error;

package/dist/private-fungi-mcp-selection-schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+/** A project selects a target and auth kind; credential material stays with Local. */
+export declare const fungiMcpSelectionSchema: z.ZodObject<{
+    endpoint: z.ZodPipe<z.ZodURL, z.ZodString>;
+    authentication: z.ZodOptional<z.ZodLiteral<"oyster-key">>;
+}, z.core.$strict>;
+export type PrivateFungiMcpSelection = z.infer<typeof fungiMcpSelectionSchema>;

package/dist/private-fungi-mcp-selection-schema.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { parseFungiMcpEndpoint } from "./private-fungi-mcp-endpoint.js";
+/** A project selects a target and auth kind; credential material stays with Local. */
+export const fungiMcpSelectionSchema = z.strictObject({
+    endpoint: z.url().pipe(z.string().refine((value) => {
+        try {
+            parseFungiMcpEndpoint(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, "Fungi MCP requires HTTPS (or HTTP on an exact loopback host) without credentials, query or fragment")),
+    authentication: z.literal("oyster-key").optional(),
+});

package/dist/private-fungi-mcp-selection.d.ts

@@ -1,10 +1,10 @@
-import { z } from "zod";
 import type { PrivateFungiMcpConnectionOptions } from "./private-fungi-mcp-connection.js";
-/** A Team MCP address selects a target; OAuth identity stays with Local. */
-export declare const fungiMcpSelectionSchema: z.ZodObject<{
-    endpoint: z.ZodPipe<z.ZodURL, z.ZodString>;
-}, z.core.$strict>;
-export type PrivateFungiMcpSelection = z.infer<typeof fungiMcpSelectionSchema>;
+import { type PrivateFungiMcpSelection } from "./private-fungi-mcp-selection-schema.js";
+/** The service validates saved project selections with the RPC selection schema. */
+export declare function readProjectFungiMcpSelection(root: string): Promise<{
+    endpoint: string;
+    authentication?: "oyster-key" | undefined;
+} | undefined>;
 export declare function readFungiMcpSelection(selection: PrivateFungiMcpSelection, options?: {
     credentialPath?: string;
 }): PrivateFungiMcpConnectionOptions;

package/dist/private-fungi-mcp-selection.js

@@ -1,18 +1,27 @@
-import { z } from "zod";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
 import { fungiMcpAccountAuth } from "./private-fungi-account.js";
-import { parseFungiMcpEndpoint } from "./private-fungi-mcp-endpoint.js";
-/** A Team MCP address selects a target; OAuth identity stays with Local. */
-export const fungiMcpSelectionSchema = z.strictObject({
-    endpoint: z.url().pipe(z.string().refine((value) => {
-        try {
-            parseFungiMcpEndpoint(value);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }, "Fungi MCP requires HTTPS (or HTTP on an exact loopback host) without credentials, query or fragment")),
-});
+import { oysterMcpKeyAuth } from "./private-oyster-mcp-auth.js";
+import { fungiMcpSelectionSchema, } from "./private-fungi-mcp-selection-schema.js";
+/** The service validates saved project selections with the RPC selection schema. */
+export async function readProjectFungiMcpSelection(root) {
+    const path = join(root, ".fungi", "team-mcp.json");
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+            return undefined;
+        throw cause;
+    }
+    try {
+        return fungiMcpSelectionSchema.parse(JSON.parse(text));
+    }
+    catch (cause) {
+        throw new Error(`${path}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    }
+}
 export function readFungiMcpSelection(selection, options = {}) {
     const parsed = fungiMcpSelectionSchema.safeParse(selection);
     if (!parsed.success)
@@ -22,11 +31,15 @@ export function readFungiMcpSelection(selection, options = {}) {
     const endpoint = new URL(parsed.data.endpoint);
     return {
         endpoint,
-        authProvider: fungiMcpAccountAuth(endpoint, options),
+        authentication: parsed.data.authentication,
+        authProvider: parsed.data.authentication === "oyster-key"
+            ? oysterMcpKeyAuth(endpoint, options)
+            : fungiMcpAccountAuth(endpoint, options),
     };
 }
 export function sameFungiMcpConnection(left, right) {
-    return left?.endpoint.href === right.endpoint.href;
+    return (left?.endpoint.href === right.endpoint.href &&
+        left.authentication === right.authentication);
 }
 export class FungiMcpSelectionConflict extends Error {
     constructor() {

package/dist/private-fungi-model-api.js

@@ -1,5 +1,6 @@
 import process from "node:process";
 import { fungiAccountFetch } from "./private-fungi-account.js";
+import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
 import { FungiSignInRequiredError } from "./private-fungi-auth-error.js";
 import { hasApi, } from "@earendil-works/pi-ai";
 import { stream, streamSimple, } from "@earendil-works/pi-ai/api/openai-completions";
@@ -55,15 +56,14 @@ function assertModelEndpoint(base, url) {
         throw new Error("Fungi refused a model endpoint outside the selected Team");
 }
 /** Access tokens can only travel to the selected Team's two inference endpoints. */
-export function fungiModelFetch(baseUrl, teamName, fetchImpl = globalThis.fetch, credentialPath) {
+export function fungiModelFetch(baseUrl, teamName, fetchImpl = globalThis.fetch, credentialPath = capturePrivateLocalConfigRoot().credentialPath) {
     const base = parseFungiMcpEndpoint(baseUrl);
     if (!/^\/api\/v1\/teams\/[^/]+$/u.test(base.pathname))
         throw new Error("Fungi model requests require a selected Team");
     const accountOptions = {
         fetch: fetchImpl,
+        credentialPath,
     };
-    if (credentialPath !== undefined)
-        accountOptions.credentialPath = credentialPath;
     const accountFetch = fungiAccountFetch(base.origin, accountOptions);
     const transport = async (input, init) => {
         if (!fungiModelsEnabled())
@@ -97,7 +97,7 @@ export function fungiModelFetch(baseUrl, teamName, fetchImpl = globalThis.fetch,
     return Object.assign(transport, { preconnect: fetchImpl.preconnect });
 }
 /** Pi owns streaming; this adapter owns Fungi's destination, incident policy and refusals. */
-export function createFungiModelApi(resolveTeamName, credentialPath) {
+export function createFungiModelApi(resolveTeamName, credentialPath = capturePrivateLocalConfigRoot().credentialPath) {
     const fetchFor = (baseUrl, fetchImpl = globalThis.fetch) => Object.assign(async (input, init) => {
         const teamName = await resolveTeamName(baseUrl);
         return fungiModelFetch(baseUrl, teamName, fetchImpl, credentialPath)(input, init);

package/dist/private-fungi-model-catalog.d.ts

@@ -1,4 +1,14 @@
 import type { Model } from "@earendil-works/pi-ai";
+import { z } from "zod";
+/** The thinking levels a Local model may offer. */
+export declare const thinkingLevelSchema: z.ZodEnum<{
+    minimal: "minimal";
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+    max: "max";
+}>;
 export type FungiHostedModel = Model<"openai-completions"> & {
     default: boolean;
 };

package/dist/private-fungi-model-catalog.js

@@ -1,5 +1,13 @@
 import { z } from "zod";
-const levels = z.enum(["minimal", "low", "medium", "high", "xhigh", "max"]);
+/** The thinking levels a Local model may offer. */
+export const thinkingLevelSchema = z.enum([
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]);
 const catalogSchema = z.object({
     object: z.literal("list"),
     data: z
@@ -9,7 +17,7 @@ const catalogSchema = z.object({
         name: z.string().min(1).max(256),
         context_window: z.number().int().positive(),
         max_output_tokens: z.number().int().positive(),
-        reasoning_levels: z.array(levels).max(6),
+        reasoning_levels: z.array(thinkingLevelSchema).max(6),
         input: z.array(z.literal("text")).length(1),
         default: z.boolean(),
         cost: z.object({

package/dist/private-fungi-model-provider.d.ts

@@ -1,6 +1,6 @@
 import { type FetchFunction } from "@earendil-works/pi-ai";
 /** The selected account Team owns the endpoint; the Hub owns the live model catalog. */
-export declare function createFungiModelProvider(options?: {
+export declare function createFungiModelProvider(input?: {
     credentialPath?: string;
     fetch?: FetchFunction;
 }): import("@earendil-works/pi-ai").Provider<"openai-completions">;

package/dist/private-fungi-model-provider.js

@@ -2,9 +2,14 @@ import { z } from "zod";
 import { createProvider } from "@earendil-works/pi-ai";
 import { createFungiAccountOAuth, fungiAccountTeam, readFungiAccountStatus, } from "./private-fungi-account.js";
 import { fungiHostedModels } from "./private-fungi-model-catalog.js";
+import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
 import { assertFungiModelsEnabled, createFungiModelApi, fungiModelFetch, } from "./private-fungi-model-api.js";
 /** The selected account Team owns the endpoint; the Hub owns the live model catalog. */
-export function createFungiModelProvider(options = {}) {
+export function createFungiModelProvider(input = {}) {
+    const options = {
+        ...input,
+        credentialPath: input.credentialPath ?? capturePrivateLocalConfigRoot().credentialPath,
+    };
     const oauth = createFungiAccountOAuth(options);
     return createProvider({
         id: "fungi",

package/dist/private-fungi-pending-logouts.d.ts

@@ -26,7 +26,7 @@ export type LoginIdentity = z.output<typeof identitySchema>;
 /** Decode only routing metadata. These IDs never authorize a revocation. */
 export declare function loginIdentity(issuer: string, access: string): LoginIdentity | undefined;
 /** Durable logout intent, separate from the credential that logout destroys. */
-export declare function pendingLogouts(credentialPath?: string): {
+export declare function pendingLogouts(credentialPath: string): {
     remember(identity: LoginIdentity, detaches: PendingDetach[]): Promise<void>;
     confirmed(identity: LoginIdentity, detach?: PendingDetach): Promise<void>;
     forAccount(identity: LoginIdentity): Promise<PendingLogout[]>;

package/dist/private-fungi-pending-logouts.js

@@ -5,7 +5,6 @@ import lockfile from "proper-lockfile";
 import writeFileAtomic from "write-file-atomic";
 import { z } from "zod";
 import { logEvent } from "./log-event.js";
-import { resolveDefaultCredentialPath } from "./private-file-credential-store.js";
 const identitySchema = z.strictObject({
     issuer: z.url().max(2048),
     userId: z.string().min(1).max(256),
@@ -43,7 +42,7 @@ function matches(left, right) {
         left.loginId === right.loginId);
 }
 /** Durable logout intent, separate from the credential that logout destroys. */
-export function pendingLogouts(credentialPath = resolveDefaultCredentialPath()) {
+export function pendingLogouts(credentialPath) {
     const path = `${credentialPath}.pending-logouts.json`;
     async function update(change) {
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });

package/dist/private-fungi-service-logout.d.ts

@@ -0,0 +1,44 @@
+import type { FetchLike } from "@modelcontextprotocol/client";
+import { z } from "zod";
+export declare const fungiAccountLogoutRequestSchema: z.ZodObject<{
+    credentialPath: z.ZodString;
+    endpoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FungiAccountLogoutRequest = z.infer<typeof fungiAccountLogoutRequestSchema>;
+export declare const fungiAccountLogoutResultSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "not-logged-in": "not-logged-in";
+        removed: "removed";
+        revoked: "revoked";
+    }>;
+    message: z.ZodString;
+    unconfirmedComputers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** A logout outcome: never a remote-revocation claim the issuer didn't confirm. */
+export type FungiAccountLogoutResult = Readonly<{
+    kind: "not-logged-in" | "removed" | "revoked";
+    message: string;
+    unconfirmedComputers: readonly Readonly<{
+        name: string;
+        url: string;
+    }>[];
+}>;
+/**
+ * Route a logout to the running Local account owner. It never starts,
+ * upgrades, stops or replaces a service. With no service, the caller's own
+ * offline clear runs under the ordinary startup lock, so a service cannot
+ * start between proving its absence and the store mutation. A live owner
+ * that cannot be reached fails closed.
+ */
+export declare function signOutFungiThroughLocalService(endpoint: string | URL | undefined, options: {
+    credentialPath: string;
+    directory: string;
+    fetch?: FetchLike;
+    clearOffline: (endpoint: string | URL | undefined, input: {
+        credentialPath: string;
+        fetch?: FetchLike;
+    }) => Promise<FungiAccountLogoutResult>;
+}): Promise<FungiAccountLogoutResult>;

package/dist/private-fungi-service-logout.js

@@ -0,0 +1,59 @@
+import { newWebSocketRpcSession } from "@fungi.computer/capnweb";
+import { z } from "zod";
+import { acquireServiceLock, readLiveServiceStatus, readServiceRegistration, serviceDirectory, serviceOwnerIsLive, } from "./private-local-service-discovery.js";
+export const fungiAccountLogoutRequestSchema = z.strictObject({
+    credentialPath: z.string().min(1),
+    endpoint: z.string().optional(),
+});
+export const fungiAccountLogoutResultSchema = z.strictObject({
+    kind: z.enum(["not-logged-in", "removed", "revoked"]),
+    message: z.string(),
+    unconfirmedComputers: z.array(z.strictObject({ name: z.string(), url: z.string() })),
+});
+/**
+ * Route a logout to the running Local account owner. It never starts,
+ * upgrades, stops or replaces a service. With no service, the caller's own
+ * offline clear runs under the ordinary startup lock, so a service cannot
+ * start between proving its absence and the store mutation. A live owner
+ * that cannot be reached fails closed.
+ */
+export async function signOutFungiThroughLocalService(endpoint, options) {
+    const { clearOffline, directory: requested, ...input } = options;
+    const directory = await serviceDirectory(requested);
+    const release = await acquireServiceLock(directory, "startup");
+    try {
+        const registration = await readServiceRegistration(directory);
+        const owned = await serviceOwnerIsLive(directory);
+        if (registration?.kind !== "current") {
+            if (owned)
+                throw new Error("The running Local account owner is unavailable");
+            return await clearOffline(endpoint, input);
+        }
+        const probe = await readLiveServiceStatus(registration.record);
+        if (probe.kind !== "running") {
+            if (owned || probe.kind === "unavailable")
+                throw new Error("The running Local account owner is unavailable");
+            return await clearOffline(endpoint, input);
+        }
+        const service = probe.service;
+        const url = new URL(`${service.baseUrl}/service/${service.serviceId}/auth`);
+        url.protocol = "ws:";
+        const socket = new WebSocket(url);
+        const remote = newWebSocketRpcSession(socket);
+        try {
+            const request = {
+                credentialPath: input.credentialPath,
+            };
+            if (endpoint !== undefined)
+                request.endpoint = endpoint.toString();
+            return fungiAccountLogoutResultSchema.parse(await remote.signOutFungi(request));
+        }
+        finally {
+            remote[Symbol.dispose]();
+            socket.close();
+        }
+    }
+    finally {
+        await release();
+    }
+}

package/dist/private-invocation-computer.d.ts

@@ -2,11 +2,21 @@ import * as ChildProcess from "effect/process/ChildProcess";
 import type { KnapsackComputer } from "@fungi.computer/knapsack";
 import { z } from "zod";
 import { type PrivateLocalProcessScope } from "./private-local-computer-processes.js";
+import type { SandboxCommand } from "./private-local-containment.js";
+/** The host admits each launch; undefined is its explicit unavailable fallback. */
+export type LocalSandboxLaunch = (cwd: string, argv: readonly [string, ...string[]]) => SandboxCommand | undefined;
 declare const execOutput: z.ZodDiscriminatedUnion<[z.ZodObject<{
     exitCode: z.ZodNumber;
     stdout: z.ZodString;
     stderr: z.ZodString;
-    truncated: z.ZodBoolean;
+    truncated: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodArray<z.ZodObject<{
+        stream: z.ZodEnum<{
+            stdout: "stdout";
+            stderr: "stderr";
+        }>;
+        keptBytes: z.ZodNumber;
+        totalBytes: z.ZodNumber;
+    }, z.core.$strict>>]>;
     status: z.ZodEnum<{
         failed: "failed";
         completed: "completed";
@@ -15,7 +25,14 @@ declare const execOutput: z.ZodDiscriminatedUnion<[z.ZodObject<{
     exitCode: z.ZodNumber;
     stdout: z.ZodString;
     stderr: z.ZodString;
-    truncated: z.ZodBoolean;
+    truncated: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodArray<z.ZodObject<{
+        stream: z.ZodEnum<{
+            stdout: "stdout";
+            stderr: "stderr";
+        }>;
+        keptBytes: z.ZodNumber;
+        totalBytes: z.ZodNumber;
+    }, z.core.$strict>>]>;
     status: z.ZodLiteral<"deadline_exceeded">;
     timeoutMs: z.ZodNumber;
     elapsedMs: z.ZodNumber;
@@ -33,5 +50,9 @@ export declare function runPrivateInvocationProcess(processCommand: ChildProcess
  * Construct one private invocation-root Computer: bounded shell exec, plus the
  * background-process operations of `processes` when the host supplies a scope.
  */
-export declare function createPrivateInvocationComputer(invocationRoot: string, executionPath?: string, processes?: PrivateLocalProcessScope): Promise<KnapsackComputer>;
+export declare function createPrivateInvocationComputer(invocationRoot: string, executionPath?: string, processes?: PrivateLocalProcessScope, 
+/** Selected host home; standalone callers capture it before any await. */
+home?: string, 
+/** Native Local always supplies its live per-Agent admission callback. */
+sandbox?: LocalSandboxLaunch): Promise<KnapsackComputer>;
 export {};