@fungi.computer/truffle 0.0.0-stage → 0.2.0

package/dist/linear-auth.d.ts

@@ -0,0 +1,4 @@
+import { Cli } from "@fungi.computer/lantern";
+import type { AuthInteraction } from "@earendil-works/pi-ai";
+/** Pi owns provider flows and credentials; Clack owns only their presentation. */
+export declare function linearAuthInteraction(interactive: boolean, cli?: Cli): AuthInteraction;

package/dist/linear-auth.js

@@ -0,0 +1,72 @@
+import { Cli, isCancel, } from "@fungi.computer/lantern";
+const defaultAuthUrlInstructions = "Waiting for the browser… If it doesn't return, paste the final redirect URL here.";
+/** Pi owns provider flows and credentials; Clack owns only their presentation. */
+export function linearAuthInteraction(interactive, cli = new Cli({ brand: "fungi-local-auth", interactive })) {
+    return {
+        async prompt(prompt) {
+            if (!interactive)
+                throw new Error("This choice needs an interactive terminal; pass --provider <id> instead. No credentials were changed.");
+            const options = {
+                message: prompt.message,
+            };
+            if (prompt.signal !== undefined)
+                options.signal = prompt.signal;
+            let answer;
+            if (prompt.type === "select") {
+                answer = await cli.select({
+                    ...options,
+                    options: prompt.options.map((option) => {
+                        const choice = {
+                            value: option.id,
+                            label: option.label,
+                        };
+                        if (option.description !== undefined)
+                            choice.hint = option.description;
+                        return choice;
+                    }),
+                });
+            }
+            else if (prompt.type === "secret" || prompt.type === "manual_code") {
+                answer = await cli.password(options);
+            }
+            else {
+                const textOptions = { ...options };
+                if (prompt.placeholder !== undefined)
+                    textOptions.placeholder = prompt.placeholder;
+                answer = await cli.text(textOptions);
+            }
+            if (isCancel(answer))
+                throw new Error("Login cancelled.");
+            return answer;
+        },
+        notify(event) {
+            switch (event.type) {
+                case "auth_url": {
+                    const heading = event.providerLabel === undefined
+                        ? "Sign in"
+                        : `Sign in to ${event.providerLabel}`;
+                    // The hyperlink line carries the whole URL in its OSC 8 escape; the
+                    // URL itself follows as one framed, unbroken line for copying.
+                    cli.info(heading);
+                    cli.info(cli.link("Open sign-in page", event.url));
+                    cli.url(event.url);
+                    cli.info(event.instructions === undefined
+                        ? defaultAuthUrlInstructions
+                        : `Waiting for the browser… ${event.instructions}`);
+                    break;
+                }
+                case "device_code":
+                    cli.info(`Open ${event.verificationUri}\nEnter code: ${event.userCode}`);
+                    break;
+                case "info":
+                    cli.info([
+                        event.message,
+                        ...(event.links ?? []).map((link) => link.url),
+                    ].join("\n"));
+                    break;
+                case "progress":
+                    cli.step(event.message);
+            }
+        },
+    };
+}

package/dist/local-archive-handoff.d.ts

@@ -0,0 +1,12 @@
+import type { ExtensionGrantV0, RosteredExtensionV0 } from "@fungi.computer/shiitake/extensions";
+/** What the Local roster gains for the compaction archive. */
+export type LocalArchiveHandoff = Readonly<{
+    roster: readonly RosteredExtensionV0[];
+    grants: readonly ExtensionGrantV0[];
+}>;
+/**
+ * Zookeeper's compaction handoff over files beside the Agent store. An
+ * installed extension the owner chose keeps the single `compaction_handoff`
+ * slot: Zookeeper is then skipped and the skip is reported, never a failure.
+ */
+export declare function localArchiveHandoff(storeDirectory: string, installedGrants: readonly ExtensionGrantV0[], report?: (operation: string, cause: unknown) => void): LocalArchiveHandoff;

package/dist/local-archive-handoff.js

@@ -0,0 +1,21 @@
+import { zookeeperCompaction, zookeeperCompactionGrant, } from "@fungi.computer/zookeeper";
+import { logEvent } from "./log-event.js";
+import { localArchiveWriter } from "./local-session-archives.js";
+/**
+ * Zookeeper's compaction handoff over files beside the Agent store. An
+ * installed extension the owner chose keeps the single `compaction_handoff`
+ * slot: Zookeeper is then skipped and the skip is reported, never a failure.
+ */
+export function localArchiveHandoff(storeDirectory, installedGrants, report = logEvent) {
+    const holder = installedGrants.find(({ capabilities }) => capabilities.includes("compaction_handoff"));
+    if (holder !== undefined) {
+        report("local-zookeeper-skipped", new Error(`Installed extension ${holder.id} holds the compaction handoff; Zookeeper archives are off for this Agent`));
+        return { roster: [], grants: [] };
+    }
+    return {
+        roster: [
+            zookeeperCompaction({ writer: localArchiveWriter(storeDirectory) }),
+        ],
+        grants: [zookeeperCompactionGrant],
+    };
+}

package/dist/local-extensions.d.ts

@@ -0,0 +1,143 @@
+import { Mycelium } from "@fungi.computer/mycelium";
+import { defineExtension, type ExtensionCapabilityV0, type ExtensionGrantV0, type RosteredExtensionV0 } from "@fungi.computer/shiitake/extensions";
+import { z } from "zod";
+import { type ExtensionSkillFolder } from "./local-skill-source.js";
+export type LocalExtensionFailureReason = "install" | "manifest" | "artifact" | "not-installed" | "not-enabled" | "no-tools" | "no-skills" | "not-held" | "load";
+/** A typed refusal from the extension owner; never reported as usable. */
+export declare class LocalExtensionError extends Error {
+    readonly name = "LocalExtensionError";
+    readonly reason: LocalExtensionFailureReason;
+    constructor(reason: LocalExtensionFailureReason, message: string, options?: ErrorOptions);
+}
+/**
+ * The host port an installed extension's `./host` factory receives: the
+ * host's own extension SDK instances and this project's private runtime
+ * directory, which its terminal programs also receive.
+ */
+export type LocalExtensionHostV1 = Readonly<{
+    runtimeDirectory: string;
+    defineExtension: typeof defineExtension;
+    Mycelium: typeof Mycelium;
+    z: typeof z;
+}>;
+/** What an installed package's `./host` entry exports by default. */
+export type LocalExtensionFactoryV1 = (host: LocalExtensionHostV1) => RosteredExtensionV0 | Promise<RosteredExtensionV0>;
+/** What `add` reports: the summary plus the names of the skills it ships. */
+export type LocalInstalledExtension = LocalExtensionSummary & Readonly<{
+    skills: readonly string[];
+}>;
+export type LocalExtensionSummary = Readonly<{
+    id: string;
+    revision: string;
+    version: string;
+    source: string;
+    commit: string | null;
+    capabilities: readonly ExtensionCapabilityV0[];
+    terminals: readonly string[];
+}>;
+/** One program a project-enabled extension may open in a terminal pane. */
+export type LocalExtensionTerminal = Readonly<{
+    extensionId: string;
+    terminalId: string;
+    name: string;
+    description: string;
+    /** Absolute executable followed by its arguments. */
+    command: readonly string[];
+    cwd: string;
+    env: Readonly<Record<string, string>>;
+}>;
+export type LocalProjectExtensions = Readonly<{
+    /** Absolute client entries for the ordinary client-extension loader. */
+    clients: readonly string[];
+    terminals: readonly LocalExtensionTerminal[];
+    diagnostics: readonly Error[];
+}>;
+export type LocalAgentExtensions = Readonly<{
+    roster: readonly RosteredExtensionV0[];
+    grants: readonly ExtensionGrantV0[];
+    /** Skills folders of extensions this Agent opted into, read in place. */
+    skills: readonly ExtensionSkillFolder[];
+    /** Extensions left out of this Agent's roster, and why. */
+    diagnostics: readonly Readonly<{
+        extensionId: string;
+        error: Error;
+    }>[];
+}>;
+export type LocalExtensionsOptions = Readonly<{
+    /** The selected user home that owns `.fungi/extensions`. */
+    home: string;
+}>;
+/** Open the one extension owner for a user home. */
+export declare function localExtensions(options: LocalExtensionsOptions): {
+    root: string;
+    /**
+     * Install a package with the shipped Bun package manager (lifecycle
+     * scripts disabled) and record the exact resolved revision. A Git source
+     * is pinned to the commit Bun's lockfile resolved; updating is another
+     * explicit `add`. Missing declared artifacts are a refusal.
+     */
+    add(source: string): Promise<LocalInstalledExtension>;
+    /** Remove the package and every activation that references it. */
+    remove(id: string): Promise<boolean>;
+    list(): Promise<readonly LocalExtensionSummary[]>;
+    /** Enable the current revision's client part and programs for a project. */
+    enableProject(projectRoot: string, id: string): Promise<string>;
+    disableProject(projectRoot: string, id: string): Promise<boolean>;
+    /**
+     * The one check that an Agent holds an extension: refuses with
+     * `not-held`, naming every id it lacks. Callers needing a whole request
+     * judged before any effect call this first; `enableAgent` applies it too.
+     */
+    assertHeldByAgent(agentStoreDirectory: string, ids: readonly string[]): Promise<void>;
+    /**
+     * Grant one Agent store the current revision's declared capabilities.
+     * Running work keeps its captured roster; the Agent applies this when it
+     * next opens. A human (the CLI) names no requester. When an Agent asks, it
+     * must hold the extension itself.
+     */
+    enableAgent(storeDirectory: string, id: string, requester?: Readonly<{
+        agentStoreDirectory: string;
+    }>): Promise<{
+        revision: string;
+        capabilities: ("state" | "attention" | "settled" | "send" | "timers" | "commands" | "projection" | "run_tools" | "files" | "prompt" | "compaction_handoff")[];
+        skills: boolean;
+    }>;
+    /**
+     * Opt one Agent store into the skills the extension ships, without
+     * granting any tools. An existing activation keeps its revision and its
+     * capabilities; a new one carries none.
+     */
+    enableAgentSkills(storeDirectory: string, id: string): Promise<string>;
+    /**
+     * Turn only the skills off. Tools stay granted; an activation left with
+     * neither is removed.
+     */
+    disableAgentSkills(storeDirectory: string, id: string): Promise<boolean>;
+    disableAgent(storeDirectory: string, id: string): Promise<boolean>;
+    /** The project's enabled client entries and program launchers. */
+    project(projectRoot: string): Promise<LocalProjectExtensions>;
+    /** Capture validated records so one reload cannot mix file generations. */
+    captureAgent(): Promise<(storeDirectory: string, projectRoot: string) => Promise<Readonly<{
+        roster: readonly RosteredExtensionV0[];
+        grants: readonly ExtensionGrantV0[];
+        /** Skills folders of extensions this Agent opted into, read in place. */
+        skills: readonly ExtensionSkillFolder[];
+        /** Extensions left out of this Agent's roster, and why. */
+        diagnostics: readonly Readonly<{
+            extensionId: string;
+            error: Error;
+        }>[];
+    }>>>;
+    agent(storeDirectory: string, projectRoot: string): Promise<Readonly<{
+        roster: readonly RosteredExtensionV0[];
+        grants: readonly ExtensionGrantV0[];
+        /** Skills folders of extensions this Agent opted into, read in place. */
+        skills: readonly ExtensionSkillFolder[];
+        /** Extensions left out of this Agent's roster, and why. */
+        diagnostics: readonly Readonly<{
+            extensionId: string;
+            error: Error;
+        }>[];
+    }>>;
+};
+export type LocalExtensions = ReturnType<typeof localExtensions>;