@fungi.computer/truffle 0.0.0-stage → 0.2.0

package/dist/private-local-admission-gate.js

@@ -0,0 +1,52 @@
+/**
+ * Admissions of work to one Agent share it as short leases; an archive takes the
+ * Agent exclusively. So an archive sees every command admitted before it, and
+ * work offered after it finds the Agent archived: nothing runs in between.
+ */
+export class AdmissionGate {
+    #leases = 0;
+    #exclusive = false;
+    #waiters = [];
+    #changed() {
+        for (const wake of this.#waiters.splice(0))
+            wake();
+    }
+    #change() {
+        return new Promise((resolve) => {
+            this.#waiters.push(resolve);
+        });
+    }
+    /** Nothing holds or waits for this gate, so it can be forgotten. */
+    get idle() {
+        return this.#leases === 0 && !this.#exclusive && this.#waiters.length === 0;
+    }
+    /** Hold a shared lease; the returned release may be called more than once. */
+    async lease() {
+        while (this.#exclusive)
+            await this.#change();
+        this.#leases += 1;
+        let held = true;
+        return () => {
+            if (!held)
+                return;
+            held = false;
+            this.#leases -= 1;
+            this.#changed();
+        };
+    }
+    /** Run alone: after every held lease is released and before any new one. */
+    async exclusive(run) {
+        while (this.#exclusive)
+            await this.#change();
+        this.#exclusive = true;
+        try {
+            while (this.#leases > 0)
+                await this.#change();
+            return await run();
+        }
+        finally {
+            this.#exclusive = false;
+            this.#changed();
+        }
+    }
+}

package/dist/private-local-agent-control.d.ts

@@ -0,0 +1,101 @@
+import { type AgentControlAgent, type AgentControlDirectory } from "@fungi.computer/shiitake/agent-control";
+import { createConversationAgents } from "@fungi.computer/shiitake-extensions/roster/conversation-agents";
+/** One Agent creating an Agent, as the project's Agent directory receives it. */
+export type LocalCreateRequest = Parameters<NonNullable<AgentControlDirectory["create"]>>[0] & Readonly<{
+    /** The Agent creating, resolved by the creator's own host, never by the caller. */
+    createdBy: string;
+}>;
+/**
+ * One ordinary Agent as the project's directory lists it. `unreadable` is
+ * set when this Agent's own store cannot be read (for
+ * example one written before the current schema); only that row is affected.
+ */
+export type LocalAgentControlAgent = AgentControlAgent & Readonly<{
+    unreadable?: string;
+}>;
+/**
+ * Who archives or restores an Agent: an Agent, named by its own host and never
+ * by the caller, or a person at the CLI or TUI. A person may archive any
+ * Agent; an Agent only one it created.
+ */
+export type LocalArchiver = Readonly<{
+    kind: "agent";
+    agentId: string;
+}> | Readonly<{
+    kind: "human";
+}>;
+/** One archive or restore request, as the project's Agent directory receives it. */
+export type LocalArchiveRequest = Readonly<{
+    agentId: string;
+    by: LocalArchiver;
+}>;
+/**
+ * The project's Agent directory a Local host receives. Its create names the
+ * creating Agent, so the directory owner can hold the created Agent to what
+ * the creator holds; its archive names who archives.
+ */
+export type LocalAgentControlDirectory = Omit<AgentControlDirectory, "create" | "list" | "archive" | "unarchive"> & Readonly<{
+    list: (signal: AbortSignal, options?: Readonly<{
+        archived?: boolean;
+    }>) => Promise<readonly LocalAgentControlAgent[]>;
+    create: (input: LocalCreateRequest, signal: AbortSignal) => Promise<AgentControlAgent>;
+    archive: (input: LocalArchiveRequest, signal: AbortSignal) => Promise<void>;
+    unarchive: (input: LocalArchiveRequest, signal: AbortSignal) => Promise<void>;
+}>;
+/**
+ * Ordinary Agent controls bound to this authenticated creating Agent; each
+ * conversation's accepted creates and sends are recorded in this Agent's own
+ * store for its footer.
+ */
+export declare function createPrivateLocalAgentControl(input: Readonly<{
+    agentId: string;
+    directory: LocalAgentControlDirectory;
+    storage: Parameters<typeof createConversationAgents>[0];
+}>): {
+    control: Readonly<{
+        id: string;
+        acquire: (context: import("@fungi.computer/mycelium").CapabilitySourceContext) => Promise<import("@fungi.computer/mycelium").CapabilitySourceAcquisition>;
+    }>;
+    source: Readonly<{
+        read: (sessionId: string, limit: number) => Promise<Readonly<{
+            agents: readonly import("@fungi.computer/shiitake-extensions/subagents/host").SubagentRecord[];
+            more: number;
+        }>>;
+        open: (agentId: string, signal: AbortSignal) => Promise<Readonly<{
+            agent: import("@fungi.computer/shiitake-extensions/subagents/host").SubagentAgent;
+            release: () => Promise<void>;
+        }>>;
+    }>;
+    directory: Readonly<{
+        list: (signal: AbortSignal, options?: Readonly<{
+            archived?: boolean;
+        }>) => Promise<readonly AgentControlAgent[]>;
+        send?: (input: import("@fungi.computer/shiitake/agent-control").AgentDelegationInput, sourceSessionId: string, signal: AbortSignal, invocation?: import("@fungi.computer/shiitake/agent-control").AgentDelegationInvocation) => Promise<import("@fungi.computer/shiitake").Accepted>;
+        recall?: (input: import("@fungi.computer/shiitake/agent-control").AgentRecallInput, sourceSessionId: string, signal: AbortSignal) => Promise<import("@fungi.computer/shiitake").CancelResult>;
+        create?: (input: Readonly<{
+            requestId: string;
+            name?: string;
+            model?: import("@fungi.computer/shiitake").ModelPreference;
+            extensions?: readonly string[];
+        }>, signal: AbortSignal) => Promise<AgentControlAgent>;
+        setModel?: (input: Readonly<{
+            agentId: string;
+            model: import("@fungi.computer/shiitake").ModelPreference;
+        }>, signal: AbortSignal) => Promise<void>;
+        archive?: (input: Readonly<{
+            agentId: string;
+        }>, signal: AbortSignal) => Promise<void>;
+        unarchive?: (input: Readonly<{
+            agentId: string;
+        }>, signal: AbortSignal) => Promise<void>;
+        models?: (signal: AbortSignal) => Promise<readonly import("@fungi.computer/shiitake/agent-control").AgentControlModel[]>;
+        checkModel?: (input: Readonly<{
+            agentId: string;
+            sessionId: string;
+        }>, signal: AbortSignal) => Promise<void>;
+        open: (agentId: string, signal: AbortSignal) => Promise<Readonly<{
+            agent: import("@fungi.computer/shiitake").ShiitakeAgent;
+            release: () => Promise<void>;
+        }>>;
+    }>;
+};

package/dist/private-local-agent-control.js

@@ -0,0 +1,30 @@
+import { AgentCreateRefused, } from "@fungi.computer/shiitake/agent-control";
+import { createConversationAgents } from "@fungi.computer/shiitake-extensions/roster/conversation-agents";
+/**
+ * Ordinary Agent controls bound to this authenticated creating Agent; each
+ * conversation's accepted creates and sends are recorded in this Agent's own
+ * store for its footer.
+ */
+export function createPrivateLocalAgentControl(input) {
+    const conversations = createConversationAgents(input.storage);
+    function bound(parentSessionId) {
+        const { create, archive, unarchive } = input.directory;
+        const by = { kind: "agent", agentId: input.agentId };
+        return {
+            ...input.directory,
+            archive: ({ agentId }, signal) => archive({ agentId, by }, signal),
+            unarchive: ({ agentId }, signal) => unarchive({ agentId, by }, signal),
+            create: async (request, signal) => {
+                if (parentSessionId === undefined)
+                    throw new AgentCreateRefused("no_creator", "creation requires an invoking Session");
+                return create({ ...request, createdBy: input.agentId }, signal);
+            },
+        };
+    }
+    const control = conversations.control(bound);
+    return {
+        control,
+        source: conversations.source(input.directory),
+        directory: conversations.recording(undefined, bound(undefined)),
+    };
+}

package/dist/private-local-agent-default-model.d.ts

@@ -0,0 +1,12 @@
+import type { PrivateSqliteDatabase } from "./private-sqlite-owner.js";
+import { type ModelPreference } from "@fungi.computer/shiitake/model-preference";
+/** Create the Agent default's table in a store this host owns. */
+export declare function ensureAgentDefaultModelTable(database: PrivateSqliteDatabase): void;
+/** Keep an Agent's first default; later changes go through the writer. */
+export declare function seedAgentDefaultModel(database: PrivateSqliteDatabase, model: ModelPreference | null): void;
+/** The stored default as written (JSON text); undefined when the row is missing. */
+export declare function readAgentDefaultModelJson(database: PrivateSqliteDatabase): string | undefined;
+/** Read the Agent default a store holds; null when none is set. */
+export declare function readAgentDefaultModel(database: PrivateSqliteDatabase): ModelPreference | null;
+/** Replace the Agent default, thinking level included. */
+export declare function writeAgentDefaultModel(database: PrivateSqliteDatabase, model: ModelPreference): void;

package/dist/private-local-agent-default-model.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { parseModelPreferenceJson, } from "@fungi.computer/shiitake/model-preference";
+/** The one module that owns the Agent default's table SQL. */
+const settingsTable = "private_local_model_settings";
+const storedModelSchema = z.string().optional();
+/** Create the Agent default's table in a store this host owns. */
+export function ensureAgentDefaultModelTable(database) {
+    database.exec(`CREATE TABLE IF NOT EXISTS ${settingsTable} (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), model TEXT NOT NULL) STRICT`);
+}
+/** Keep an Agent's first default; later changes go through the writer. */
+export function seedAgentDefaultModel(database, model) {
+    database
+        .prepare(`INSERT OR IGNORE INTO ${settingsTable} VALUES (1, ?)`)
+        .run(JSON.stringify(model));
+}
+/** The stored default as written (JSON text); undefined when the row is missing. */
+export function readAgentDefaultModelJson(database) {
+    return storedModelSchema.parse(database
+        .prepare(`SELECT model FROM ${settingsTable} WHERE singleton = 1`)
+        .get()?.model);
+}
+/** Read the Agent default a store holds; null when none is set. */
+export function readAgentDefaultModel(database) {
+    return parseModelPreferenceJson(readAgentDefaultModelJson(database));
+}
+/** Replace the Agent default, thinking level included. */
+export function writeAgentDefaultModel(database, model) {
+    database
+        .prepare(`UPDATE ${settingsTable} SET model = ? WHERE singleton = 1`)
+        .run(JSON.stringify(model));
+}

package/dist/private-local-auth-rpc.d.ts

@@ -0,0 +1,129 @@
+import type { AuthInteraction, AuthEvent } from "@earendil-works/pi-ai";
+import { RpcTarget, type RpcStub } from "@fungi.computer/capnweb";
+import { z } from "zod";
+import { type FungiAccountLogoutRequest, type FungiAccountLogoutResult } from "./private-fungi-service-logout.js";
+import { runLocalAuthCli, type LocalAuthResult } from "./auth-cli.js";
+declare const requestSchema: z.ZodObject<{
+    command: z.ZodEnum<{
+        status: "status";
+        login: "login";
+        logout: "logout";
+    }>;
+    provider: z.ZodOptional<z.ZodString>;
+    authType: z.ZodOptional<z.ZodEnum<{
+        oauth: "oauth";
+        api_key: "api_key";
+    }>>;
+    method: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PrivateLocalAuthRequest = z.infer<typeof requestSchema>;
+declare const promptSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    message: z.ZodString;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"secret">;
+    message: z.ZodString;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"manual_code">;
+    message: z.ZodString;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"select">;
+    message: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+export type AuthPromptRequest = z.infer<typeof promptSchema>;
+/** What one auth RPC operation returns: a result or a typed failure. */
+export type LocalAuthWireResult = z.output<typeof wireResultSchema>;
+declare const wireResultSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"completed">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"status">;
+    providers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        providerId: z.ZodString;
+        providerName: z.ZodString;
+        state: z.ZodLiteral<"unconfigured">;
+    }, z.core.$strip>, z.ZodObject<{
+        providerId: z.ZodString;
+        providerName: z.ZodString;
+        state: z.ZodLiteral<"configured">;
+        type: z.ZodEnum<{
+            oauth: "oauth";
+            api_key: "api_key";
+        }>;
+    }, z.core.$strip>], "state">>;
+}, z.core.$strip>], "kind">, z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+    failure: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        category: z.ZodLiteral<"identity-unavailable">;
+        detail: z.ZodOptional<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>>;
+    }, z.core.$strict>, z.ZodObject<{
+        category: z.ZodLiteral<"callback-port-in-use">;
+    }, z.core.$strict>, z.ZodObject<{
+        category: z.ZodLiteral<"oauth-state-mismatch">;
+    }, z.core.$strict>, z.ZodObject<{
+        category: z.ZodLiteral<"token-exchange-rejected">;
+        status: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        category: z.ZodLiteral<"cancelled">;
+    }, z.core.$strict>, z.ZodObject<{
+        category: z.ZodLiteral<"no-key-entered">;
+    }, z.core.$strict>, z.ZodObject<{
+        category: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>], "category">;
+}, z.core.$strict>]>;
+declare class AuthPromptTarget extends RpcTarget {
+    #private;
+    constructor(prompt: AuthPromptRequest, interaction: AuthInteraction);
+    result(): Promise<string>;
+    cancel(): void;
+    [Symbol.dispose](): void;
+}
+declare class AuthPresenterTarget extends RpcTarget {
+    #private;
+    constructor(interaction: AuthInteraction);
+    openPrompt(request: AuthPromptRequest): AuthPromptTarget;
+    notify(event: AuthEvent): void;
+}
+/** The auth-only RPC door shared by its producer and remote client. */
+export type PrivateLocalAuthEndpoint = RpcTarget & {
+    cancel(): void;
+    signOutFungi(input: FungiAccountLogoutRequest): Promise<FungiAccountLogoutResult>;
+    run(input: PrivateLocalAuthRequest, presenter: RpcStub<AuthPresenterTarget>): Promise<LocalAuthWireResult>;
+};
+/** One transient connection runs one provider or Fungi-account operation. */
+export declare class PrivateLocalAuthTarget extends RpcTarget implements PrivateLocalAuthEndpoint {
+    #private;
+    constructor(run: typeof runLocalAuthCli, signOutAccount: (input: FungiAccountLogoutRequest) => Promise<FungiAccountLogoutResult>);
+    signOutFungi(input: FungiAccountLogoutRequest): Promise<FungiAccountLogoutResult>;
+    cancel(): void;
+    [Symbol.dispose](): void;
+    run(input: PrivateLocalAuthRequest, presenter: RpcStub<AuthPresenterTarget>): Promise<LocalAuthWireResult>;
+}
+/**
+ * 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 declare function runPrivateLocalAuthRemote(remote: RpcStub<PrivateLocalAuthEndpoint>, request: PrivateLocalAuthRequest, interaction: AuthInteraction, reportCleanupFailure: (cause: unknown) => void): Promise<LocalAuthResult>;
+export type { AuthPresenterTarget, AuthPromptTarget };