@fungi.computer/truffle 0.1.1 → 0.2.0

package/dist/private-local-session-discovery.d.ts

@@ -1,15 +1,62 @@
 import { type StoredSessionSummary } from "@fungi.computer/shiitake/effect";
-import type { PrivateLocalServiceManager, PrivateLocalServiceRequestOptions, PrivateLocalSessionDiscovery } from "./private-local-service-contract.js";
+import type { PrivateLocalServiceManager, PrivateLocalDiscoveryOptions, PrivateLocalSessionDiscovery } from "./private-local-service-contract.js";
 export type LocalSummary = StoredSessionSummary & Readonly<{
     databasePath: string;
     sessionId: string;
 }>;
-export declare function listPrivateLocalAgentStores(root: string): Promise<readonly string[]>;
+/**
+ * Which Agent stores a listing returns: the ones in use, only the archived
+ * ones (to restore them), or both (to find one by id).
+ */
+export type LocalStoreVisibility = "active" | "archived" | "all";
+/** The one plain phrase for a store written before the current schema, with how to reset it. */
+export declare function unreadableStoreReason(agentId: string): string;
+/**
+ * Whether a store's Agent is archived. A store this cannot read counts as
+ * not archived, so discovery still reports it as a problem.
+ */
+export declare function isArchivedStore(path: string): boolean;
+export declare function listPrivateLocalAgentStores(root: string, visibility?: LocalStoreVisibility): Promise<readonly string[]>;
+/** A Local or Woodstock store outside the current schema; Local never migrates it. */
+export declare class LocalStoreSchemaError extends Error {
+    readonly databasePath: string;
+    readonly name = "LocalStoreSchemaError";
+    constructor(databasePath: string, options?: ErrorOptions);
+}
+/**
+ * One Agent store's chosen display name, default model, whether it is
+ * archived and the Agent that created it (absent when a human made it), read
+ * without opening a host.
+ */
+export declare function readPrivateLocalAgentProfile(path: string): {
+    name: string | undefined;
+    createdBy: string | null;
+    archived: boolean;
+    requireSandbox: boolean;
+    folder: string;
+    model: {
+        readonly providerId: string;
+        readonly modelId: string;
+        readonly reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    } | null;
+};
 export declare function readPrivateLocalSessionSummaries(path: string): Promise<readonly LocalSummary[]>;
-/** Discover existing folder sessions without opening or reconciling a host. */
-export declare function readPrivateLocalSessionDiscovery(invocationRoot: string, request?: PrivateLocalServiceRequestOptions): Promise<{
+/**
+ * Discover existing folder sessions without opening or reconciling a host.
+ * Archived Agents and their Sessions are left out, so no picker or "newest
+ * Session" choice can land on one; `archived` lists only those instead.
+ */
+export declare function readPrivateLocalSessionDiscovery(invocationRoot: string, request?: PrivateLocalDiscoveryOptions): Promise<{
     root: string;
-    agentCount: number;
+    agents: Readonly<{
+        agentId: string;
+        unreadable?: string | undefined;
+        name?: string | undefined;
+        createdBy?: string | null | undefined;
+        databasePath: string;
+        sessionCount: number;
+        updatedAt?: number | undefined;
+    }>[];
     sessions: LocalSummary[];
     problems: Readonly<{
         kind: "corrupt" | "in_use" | "unreadable";

package/dist/private-local-session-discovery.js

@@ -1,9 +1,13 @@
 import { readdir, realpath, stat } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { basename, dirname, join, resolve } from "node:path";
 import * as Effect from "effect/Effect";
+import { parseModelPreferenceJson } from "@fungi.computer/shiitake/model-preference";
+import { z } from "zod";
+import { readAgentDefaultModelJson } from "./private-local-agent-default-model.js";
+import { localAgentFolderSchema, resolveAgentFolder, } from "./private-local-sandbox-policy.js";
+import { logEvent } from "./log-event.js";
 import { readSessionSummaries, } from "@fungi.computer/shiitake/effect";
-import { createPrivateSqliteOwner, privateSqliteFailureCode, } from "./private-sqlite-owner.js";
+import { createPrivateSqliteOwner, openPrivateReadOnlySqliteDatabase, privateSqliteFailureCode, } from "./private-sqlite-owner.js";
 function compareSummaries(left, right) {
     return (right.updatedAt - left.updatedAt ||
         right.createdAt - left.createdAt ||
@@ -61,12 +65,33 @@ async function immediateStoreCandidates(root, relative) {
         }
     })).then((values) => values.filter((value) => value !== undefined));
 }
-export async function listPrivateLocalAgentStores(root) {
+/** The one plain phrase for a store written before the current schema, with how to reset it. */
+export function unreadableStoreReason(agentId) {
+    return `predates the current schema; move .fungi/agents/${agentId} aside to reset it`;
+}
+/**
+ * Whether a store's Agent is archived. A store this cannot read counts as
+ * not archived, so discovery still reports it as a problem.
+ */
+export function isArchivedStore(path) {
+    try {
+        return readPrivateLocalAgentProfile(path).archived;
+    }
+    catch (cause) {
+        if (!(cause instanceof LocalStoreSchemaError))
+            logEvent("store-archived", cause);
+        return false;
+    }
+}
+export async function listPrivateLocalAgentStores(root, visibility = "active") {
     const candidates = await immediateStoreCandidates(root, ".fungi/agents");
     const paths = new Set();
     for (const candidate of candidates) {
         try {
-            paths.add(await realpath(candidate.path));
+            const path = await realpath(candidate.path);
+            if (visibility === "all" ||
+                isArchivedStore(path) === (visibility === "archived"))
+                paths.add(path);
         }
         catch (cause) {
             if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
@@ -76,8 +101,62 @@ export async function listPrivateLocalAgentStores(root) {
     }
     return [...paths];
 }
+const storedProfileSchema = z.strictObject({
+    name: z.string().nullable(),
+    createdBy: z.string().nullable(),
+    archived: z.union([z.literal(0), z.literal(1)]),
+    requireSandbox: z.union([z.literal(0), z.literal(1)]),
+    folder: localAgentFolderSchema,
+    model: z.string(),
+});
+/** A Local or Woodstock store outside the current schema; Local never migrates it. */
+export class LocalStoreSchemaError extends Error {
+    databasePath;
+    name = "LocalStoreSchemaError";
+    constructor(databasePath, options) {
+        super(`Agent store ${databasePath} is incompatible with this version of Fungi. To reset, stop the owning Fungi service, then move this database, its .owner.sqlite sidecar and any associated SQLite journal files aside together. Create a fresh Agent; existing Sessions are not migrated. Keep the moved files if you need their data.`, options);
+        this.databasePath = databasePath;
+    }
+}
+/**
+ * One Agent store's chosen display name, default model, whether it is
+ * archived and the Agent that created it (absent when a human made it), read
+ * without opening a host.
+ */
+export function readPrivateLocalAgentProfile(path) {
+    const database = openPrivateReadOnlySqliteDatabase(path);
+    try {
+        const columns = database
+            .prepare("PRAGMA table_info(private_local_identity)")
+            .all();
+        if (!["name", "created_by", "archived", "require_sandbox", "folder"].every((required) => columns.some((column) => column.name === required)))
+            throw new LocalStoreSchemaError(path);
+        const identity = database
+            .prepare("SELECT name, created_by, archived, require_sandbox, folder FROM private_local_identity WHERE singleton = 1")
+            .get();
+        const stored = storedProfileSchema.parse({
+            name: identity?.name,
+            createdBy: identity?.created_by,
+            archived: identity?.archived,
+            requireSandbox: identity?.require_sandbox,
+            folder: identity?.folder,
+            model: readAgentDefaultModelJson(database),
+        });
+        return {
+            name: stored.name ?? undefined,
+            createdBy: stored.createdBy,
+            archived: stored.archived === 1,
+            requireSandbox: stored.requireSandbox === 1,
+            folder: stored.folder,
+            model: parseModelPreferenceJson(stored.model),
+        };
+    }
+    finally {
+        database.close();
+    }
+}
 export async function readPrivateLocalSessionSummaries(path) {
-    const database = new DatabaseSync(path, { readOnly: true, timeout: 0 });
+    const database = openPrivateReadOnlySqliteDatabase(path);
     try {
         database.exec("PRAGMA foreign_keys = ON");
         let sqliteFailure;
@@ -117,24 +196,65 @@ export async function readPrivateLocalSessionSummaries(path) {
         database.close();
     }
 }
-/** Discover existing folder sessions without opening or reconciling a host. */
+/**
+ * Discover existing folder sessions without opening or reconciling a host.
+ * Archived Agents and their Sessions are left out, so no picker or "newest
+ * Session" choice can land on one; `archived` lists only those instead.
+ */
 export async function readPrivateLocalSessionDiscovery(invocationRoot, request = {}) {
     request.signal?.throwIfAborted();
     const root = await realpath(resolve(invocationRoot));
-    const paths = await listPrivateLocalAgentStores(root);
+    const paths = await listPrivateLocalAgentStores(root, request.archived === true ? "archived" : "active");
     const discovered = [];
+    const agents = [];
+    const profiles = new Map();
     const problems = [];
     for (const path of paths) {
         request.signal?.throwIfAborted();
+        const agentId = basename(dirname(path));
         try {
-            discovered.push(...(await readPrivateLocalSessionSummaries(path)));
+            const summaries = await readPrivateLocalSessionSummaries(path);
+            discovered.push(...summaries);
+            let profile;
+            let unreadable;
+            try {
+                profile = readPrivateLocalAgentProfile(path);
+                resolveAgentFolder(root, profile.folder);
+                profiles.set(agentId, profile);
+            }
+            catch (cause) {
+                // Shown on the row so the user knows to reset the store; opening it
+                // refuses with the same error.
+                if (!(cause instanceof LocalStoreSchemaError))
+                    throw cause;
+                unreadable = unreadableStoreReason(agentId);
+            }
+            agents.push({
+                agentId,
+                name: profile?.name,
+                unreadable,
+                databasePath: path,
+                sessionCount: summaries.length,
+                updatedAt: summaries[0]?.updatedAt,
+            });
         }
         catch (cause) {
             problems.push({ kind: problemKind(cause) });
+            agents.push({ agentId, databasePath: path, sessionCount: 0 });
         }
     }
     discovered.sort(compareSummaries);
-    return { root, agentCount: paths.length, sessions: discovered, problems };
+    // The wire carries identity; clients derive the “made by” label from names.
+    const labelled = agents.map((agent) => {
+        const createdBy = profiles.get(agent.agentId)?.createdBy;
+        if (createdBy === undefined)
+            return agent;
+        return {
+            ...agent,
+            createdBy,
+        };
+    });
+    return { root, agents: labelled, sessions: discovered, problems };
 }
 /** Project the service-owned discovery into choices that resume through it. */
 export function projectPrivateLocalSessionDiscovery(discovered, connect) {
@@ -147,10 +267,11 @@ export function projectPrivateLocalSessionDiscovery(discovered, connect) {
             databasePath,
             sessionId,
             fungiMcp: resumeRequest?.fungiMcp,
+            requireSandbox: resumeRequest?.requireSandbox,
         }, resumeRequest),
     }));
     return Object.freeze({
-        agentCount: discovered.agentCount,
+        agents: Object.freeze(discovered.agents),
         sessions: Object.freeze(sessions),
         problems: Object.freeze(discovered.problems),
     });

package/dist/private-local-shiitake-host.js

@@ -35,7 +35,7 @@ async function closePrivateShiitakeResources(failures, client, server, owner) {
 /** Open one bounded private local Hono host on a loopback-only ephemeral port. */
 export async function openPrivateLocalShiitakeHost(input, openServer, openHost = openPrivateLocalRuntimeHost, eventSource) {
     const owner = await openHost(input);
-    const routes = createShiitakeHttpRoutes(owner.getSession, owner.listSessions, owner.createSession, owner.deleteSession, () => owner.extensions);
+    const routes = createShiitakeHttpRoutes((sessionId) => owner.getSession(sessionId), owner.listSessions, owner.createSession, owner.deleteSession, () => owner.extensions);
     const fetch = (request) => routes.fetch(request);
     let server;
     let client;
@@ -107,7 +107,7 @@ export async function openPrivateLocalShiitakeWorkerBatch(inputs, openServer, op
         for (const input of validated) {
             const owner = await openHost(input.owner);
             owners.push({ name: input.name, owner });
-            const routes = createShiitakeHttpRoutes(owner.getSession, owner.listSessions, owner.createSession, owner.deleteSession, () => owner.extensions);
+            const routes = createShiitakeHttpRoutes((sessionId) => owner.getSession(sessionId), owner.listSessions, owner.createSession, owner.deleteSession, () => owner.extensions);
             const routePath = "/workers/" + input.name;
             app.route(routePath, routes);
             workers.push(Object.freeze({

package/dist/private-local-startup-model.d.ts

@@ -0,0 +1,51 @@
+import { getSupportedThinkingLevels, type Api, type Model, type Models, type ThinkingLevel } from "@earendil-works/pi-ai";
+import { type ModelPreference } from "@fungi.computer/shiitake/model-preference";
+/** Which layer decided a startup model: a Session override, the Agent default, or the available login. */
+export type LocalStartupModelSource = "session" | "agent" | "available";
+/** The one model choice a run or a new chat starts from, before it is checked against its provider. */
+export type LocalStartupChoice = Readonly<{
+    preference: ModelPreference;
+    source: LocalStartupModelSource;
+}>;
+/** The effective model a new chat of one Agent starts with. */
+export type LocalStartupModel = Readonly<{
+    providerId: string;
+    modelId: string;
+    reasoning: ThinkingLevel | undefined;
+    source: LocalStartupModelSource;
+}>;
+/** Validate a requested thinking level against the registered model. */
+export declare function validateLocalReasoning(model: Parameters<typeof getSupportedThinkingLevels>[0], requested: ThinkingLevel | undefined): void;
+/** Local's default is medium, clamped through Pi's model capabilities. */
+export declare function defaultLocalReasoning(model: Parameters<typeof getSupportedThinkingLevels>[0]): ThinkingLevel | undefined;
+/**
+ * The thinking level a chosen model runs with: the choice's own level, else
+ * the opener's level when this model supports it, else Local's default.
+ */
+export declare function startupReasoning(selected: Model<Api>, preference: ModelPreference, ownerReasoning?: ThinkingLevel): ThinkingLevel | undefined;
+/** Resolve explicit layers without checking logins or discovering models. */
+export declare function resolveKnownLocalStartupChoice(input: Readonly<{
+    session: ModelPreference | null;
+    agent: ModelPreference | null;
+}>): LocalStartupChoice | null;
+/**
+ * Resolve the explicit choice, or discover the available login. An explicit
+ * layer never falls through on an auth failure; the caller reports it.
+ */
+export declare function resolveLocalStartupChoice(input: Readonly<{
+    models: Models;
+    session: ModelPreference | null;
+    agent: ModelPreference | null;
+    signal: AbortSignal;
+}>): Promise<LocalStartupChoice | null>;
+/**
+ * The model a new chat of the Agent at `databasePath` starts with; no store
+ * means a new Agent, which starts from the available login. A store that
+ * predates the current schema fails loudly. The landing and a
+ * fresh Session both resolve through this chain.
+ */
+export declare function resolveAgentStartupModel(input: Readonly<{
+    models: Models;
+    databasePath: string | undefined;
+    signal: AbortSignal;
+}>): Promise<LocalStartupModel | null>;

package/dist/private-local-startup-model.js

@@ -0,0 +1,86 @@
+import { clampThinkingLevel, getSupportedThinkingLevels, } from "@earendil-works/pi-ai";
+import {} from "@fungi.computer/shiitake/model-preference";
+import { readPrivateLocalAgentProfile } from "./private-local-session-discovery.js";
+import { defaultLocalModel } from "./private-local-default-model.js";
+/** Validate a requested thinking level against the registered model. */
+export function validateLocalReasoning(model, requested) {
+    if (requested === undefined)
+        return;
+    const supported = getSupportedThinkingLevels(model).filter((level) => level !== "off");
+    if (!supported.includes(requested))
+        throw new Error("Reasoning level " +
+            requested +
+            " is not supported by " +
+            model.provider +
+            "/" +
+            model.id +
+            "; supported levels: " +
+            (supported.join(", ") || "none"));
+}
+/** Local's default is medium, clamped through Pi's model capabilities. */
+export function defaultLocalReasoning(model) {
+    const level = clampThinkingLevel(model, "medium");
+    return level === "off" ? undefined : level;
+}
+/**
+ * The thinking level a chosen model runs with: the choice's own level, else
+ * the opener's level when this model supports it, else Local's default.
+ */
+export function startupReasoning(selected, preference, ownerReasoning) {
+    return (preference.reasoning ??
+        (ownerReasoning !== undefined &&
+            getSupportedThinkingLevels(selected).includes(ownerReasoning)
+            ? ownerReasoning
+            : defaultLocalReasoning(selected)));
+}
+/** Resolve explicit layers without checking logins or discovering models. */
+export function resolveKnownLocalStartupChoice(input) {
+    if (input.session !== null)
+        return { preference: input.session, source: "session" };
+    if (input.agent !== null)
+        return { preference: input.agent, source: "agent" };
+    return null;
+}
+/**
+ * Resolve the explicit choice, or discover the available login. An explicit
+ * layer never falls through on an auth failure; the caller reports it.
+ */
+export async function resolveLocalStartupChoice(input) {
+    const known = resolveKnownLocalStartupChoice(input);
+    if (known !== null)
+        return known;
+    const available = await defaultLocalModel(input.models, input.signal);
+    return available === null
+        ? null
+        : { preference: available, source: "available" };
+}
+/**
+ * The model a new chat of the Agent at `databasePath` starts with; no store
+ * means a new Agent, which starts from the available login. A store that
+ * predates the current schema fails loudly. The landing and a
+ * fresh Session both resolve through this chain.
+ */
+export async function resolveAgentStartupModel(input) {
+    const agent = input.databasePath === undefined
+        ? null
+        : readPrivateLocalAgentProfile(input.databasePath).model;
+    const choice = await resolveLocalStartupChoice({
+        models: input.models,
+        session: null,
+        agent,
+        signal: input.signal,
+    });
+    if (choice === null)
+        return null;
+    const { providerId, modelId } = choice.preference;
+    const selected = input.models.getModel(providerId, modelId);
+    return {
+        providerId,
+        modelId,
+        // A catalog not loaded yet cannot name a level; the run resolves it later.
+        reasoning: selected === undefined
+            ? choice.preference.reasoning
+            : startupReasoning(selected, choice.preference),
+        source: choice.source,
+    };
+}

package/dist/private-local-stop-all.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/** The service reports each attempted Agent, including partial failures. */
+export declare const stopAllResultSchema: z.ZodObject<{
+    rootAgentId: z.ZodString;
+    agents: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        outcome: z.ZodEnum<{
+            stopped: "stopped";
+            idle: "idle";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        outcome: z.ZodLiteral<"failed">;
+        reason: z.ZodString;
+    }, z.core.$strict>], "outcome">>;
+    discoveryFailures: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type StopAllResult = z.infer<typeof stopAllResultSchema>;
+export declare const stopAllRequestSchema: z.ZodObject<{
+    invocationRoot: z.ZodString;
+    agentId: z.ZodString;
+}, z.core.$strict>;

package/dist/private-local-stop-all.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+/** The service reports each attempted Agent, including partial failures. */
+export const stopAllResultSchema = z.strictObject({
+    rootAgentId: z.string(),
+    agents: z.array(z.discriminatedUnion("outcome", [
+        z.strictObject({
+            agentId: z.string(),
+            name: z.string(),
+            outcome: z.enum(["stopped", "idle"]),
+        }),
+        z.strictObject({
+            agentId: z.string(),
+            name: z.string(),
+            outcome: z.literal("failed"),
+            reason: z.string(),
+        }),
+    ])),
+    discoveryFailures: z.array(z.strictObject({
+        agentId: z.string(),
+        reason: z.string(),
+    })),
+});
+export const stopAllRequestSchema = z.strictObject({
+    invocationRoot: z.string().min(1),
+    agentId: z.string().min(1),
+});

package/dist/private-local-ui-attachment.d.ts

@@ -0,0 +1,19 @@
+import type { Json } from "@fungi.computer/shiitake/extensions";
+import { z } from "zod";
+export declare const localUiAttachmentLifetimeSchema: z.ZodEnum<{
+    watch: "watch";
+    connection: "connection";
+}>;
+export type LocalUiAttachmentLifetime = z.infer<typeof localUiAttachmentLifetimeSchema>;
+/** Host-held authority; a JSON identity or pending id cannot create one. */
+export type LocalUiAttachment = Readonly<{
+    sessionId: string;
+    signal: AbortSignal;
+    close: () => void;
+}>;
+export declare function createLocalUiAttachment(sessionId: string, lifetime?: LocalUiAttachmentLifetime): LocalUiAttachment;
+export declare function startLocalUiWatch(attachment: LocalUiAttachment, sessionId: string): (() => void) | undefined;
+/** Authority lasts for one command, not model work that might wake later. */
+export declare function runLocalUiCommand(attachment: LocalUiAttachment, sessionId: string, body: () => Promise<Json>): Promise<Json>;
+/** Consume host authority before registering the post-commit continuation. */
+export declare function consumeLocalUiCommand(sessionId: string): ((complete: (committed: boolean) => Promise<Json>) => void) | undefined;

package/dist/private-local-ui-attachment.js

@@ -0,0 +1,71 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { z } from "zod";
+export const localUiAttachmentLifetimeSchema = z.enum(["watch", "connection"]);
+const attachments = new WeakMap();
+export function createLocalUiAttachment(sessionId, lifetime = "watch") {
+    const controller = new AbortController();
+    const attachment = {
+        sessionId,
+        signal: controller.signal,
+        close: () => {
+            attachments.delete(attachment);
+            controller.abort();
+        },
+    };
+    attachments.set(attachment, { watches: 0, lifetime });
+    return attachment;
+}
+export function startLocalUiWatch(attachment, sessionId) {
+    const state = attachments.get(attachment);
+    if (state === undefined || attachment.sessionId !== sessionId)
+        return undefined;
+    state.watches += 1;
+    let watching = true;
+    return () => {
+        if (!watching)
+            return;
+        watching = false;
+        state.watches -= 1;
+        // TUI/form authority is watch-scoped. ACP closes each prompt's watch,
+        // but its host-issued route belongs to the retained connection binding.
+        if (state.lifetime === "watch")
+            attachment.close();
+    };
+}
+const commands = new AsyncLocalStorage();
+function isAttached(command) {
+    return (command.attachment.sessionId === command.sessionId &&
+        (attachments.get(command.attachment)?.watches ?? 0) > 0);
+}
+/** Authority lasts for one command, not model work that might wake later. */
+export function runLocalUiCommand(attachment, sessionId, body) {
+    const command = { attachment, sessionId, available: true };
+    return commands.run(command, async () => {
+        let result;
+        try {
+            result = await body();
+        }
+        catch (cause) {
+            command.available = false;
+            await command.complete?.(false);
+            throw cause;
+        }
+        command.available = false;
+        return command.complete === undefined
+            ? result
+            : command.complete(isAttached(command));
+    });
+}
+/** Consume host authority before registering the post-commit continuation. */
+export function consumeLocalUiCommand(sessionId) {
+    const command = commands.getStore();
+    if (command === undefined ||
+        !command.available ||
+        command.sessionId !== sessionId ||
+        !isAttached(command))
+        return undefined;
+    command.available = false;
+    return (complete) => {
+        command.complete = complete;
+    };
+}

package/dist/private-local-worker-server.d.ts

@@ -8,6 +8,7 @@ export type Output = Pick<NodeJS.WritableStream, "write">;
 export type OpenWorkerBatch = typeof openPrivateLocalBunShiitakeWorkerBatch;
 export type PrivateLocalWorkerServerIo = Readonly<{
     cwd: string;
+    home?: string;
     stdout?: Output | undefined;
     signals?: Signals | undefined;
 }>;

package/dist/private-local-worker-server.js

@@ -1,5 +1,7 @@
 import { logEvent } from "./log-event.js";
-import { fungiMcpSelectionSchema, readFungiMcpSelection, } from "./private-fungi-mcp-selection.js";
+import { capturePrivateLocalConfigRoot, } from "./private-local-config-root.js";
+import { readFungiMcpSelection } from "./private-fungi-mcp-selection.js";
+import { fungiMcpSelectionSchema } from "./private-fungi-mcp-selection-schema.js";
 import { readFile } from "node:fs/promises";
 import process from "node:process";
 import { dirname, resolve } from "node:path";
@@ -37,7 +39,7 @@ function parseWorkers(value, filePath) {
         },
     }));
 }
-async function readWorkers(filePath, cwd) {
+async function readWorkers(filePath, cwd, configRoot) {
     const absolutePath = resolve(cwd, filePath);
     let value;
     try {
@@ -49,11 +51,16 @@ async function readWorkers(filePath, cwd) {
     const workers = [];
     for (const { name, owner } of parseWorkers(value, absolutePath)) {
         const { fungiMcp, ...local } = owner;
-        let configured = local;
+        let configured = {
+            ...local,
+            configRoot,
+        };
         if (fungiMcp !== undefined)
             configured = {
                 ...configured,
-                fungiMcp: readFungiMcpSelection(fungiMcp),
+                fungiMcp: readFungiMcpSelection(fungiMcp, {
+                    credentialPath: configRoot.credentialPath,
+                }),
             };
         workers.push({ name, owner: configured });
     }
@@ -78,7 +85,8 @@ export async function runPrivateLocalWorkerServer(workersFile, listen, io, openB
     const { openPrivateLocalBunShiitakeWorkerBatch } = await import("./private-bun-shiitake-host.js");
     return openPrivateLocalBunShiitakeWorkerBatch(...args);
 }) {
-    const workers = await readWorkers(workersFile, io.cwd);
+    const root = capturePrivateLocalConfigRoot(io.home);
+    const workers = await readWorkers(workersFile, io.cwd, root);
     const stdout = io.stdout ?? process.stdout;
     const signals = io.signals ?? process;
     const stopped = Promise.withResolvers();