@fungi.computer/truffle 0.3.1 → 0.5.0

package/dist/local-extensions.js

@@ -1,15 +1,16 @@
 import { createHash } from "node:crypto";
-import { access, constants, mkdir, mkdtemp, readFile, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { access, constants, mkdir, mkdtemp, open, readFile, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { Mycelium } from "@fungi.computer/mycelium";
 import { defineExtension, ExtensionId, } from "@fungi.computer/shiitake/extensions";
 import * as Predicate from "effect/Predicate";
 import * as Schema from "effect/Schema";
-import lockfile from "proper-lockfile";
 import writeFileAtomic from "write-file-atomic";
 import { z } from "zod";
 import { describeExtensionSkills, } from "./local-skill-source.js";
+import { activationsSchema, capabilities, } from "./private-local-extension-records.js";
+import { acquireExtensionOwnerLock, extensionArchiveNoticesAreDeferred, extensionArchiveNameSchema, takePendingExtensionArchiveNoticesUnderOwnerLock, writeExtensionArchiveNotice, } from "./private-local-extension-archive-notice.js";
 /**
  * Installed Local extensions. One owner holds the package bytes under
  * `~/.fungi/extensions`, and the activations its typed operations write. A
@@ -23,19 +24,6 @@ import { describeExtensionSkills, } from "./local-skill-source.js";
  * them. This covers Local installed extensions only; Hub-hosted extensions
  * are not covered.
  */
-const capabilities = [
-    "state",
-    "attention",
-    "settled",
-    "send",
-    "timers",
-    "commands",
-    "projection",
-    "run_tools",
-    "files",
-    "prompt",
-    "compaction_handoff",
-];
 const decodeExtensionId = Schema.decodeUnknownSync(ExtensionId);
 const identifier = z.string().regex(/^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$/u);
 const revisionPattern = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/u;
@@ -49,6 +37,11 @@ const manifestSchema = z.strictObject({
         id: identifier.max(64),
         name: z.string().trim().min(1).max(64),
         description: z.string().max(200).default(""),
+        /** A shell key that opens this program beside the focused pane. */
+        binding: z
+            .string()
+            .regex(/^<leader>[a-z]$/u)
+            .optional(),
         /** Package-relative executable and its arguments. */
         command: z
             .array(z.string().min(1).max(1_024))
@@ -72,6 +65,7 @@ const terminalRecord = z.strictObject({
     id: z.string(),
     name: z.string(),
     description: z.string(),
+    binding: z.string().optional(),
     command: z.array(z.string()),
 });
 const revisionRecord = z.strictObject({
@@ -93,14 +87,13 @@ const installedSchema = z.strictObject({
         revisions: z.record(z.string(), revisionRecord),
     })),
 });
-const activationsSchema = z.strictObject({
-    projects: z.record(z.string(), z.record(z.string(), z.string())),
-    agents: z.record(z.string(), z.record(z.string(), z.strictObject({
-        revision: z.string(),
-        capabilities: z.array(z.enum(capabilities)),
-        /** The opt-in to the revision's skills folder; separate from tools. */
-        skills: z.boolean(),
-    }))),
+const extensionNameNoticeSchema = z.object({
+    extensions: z.record(z.string(), z.object({
+        current: z.string(),
+        revisions: z.record(z.string(), z.object({
+            name: z.unknown().optional(),
+        })),
+    })),
 });
 const lockSchema = z.looseObject({
     packages: z.record(z.string(), z.array(z.unknown()).min(1)),
@@ -169,20 +162,108 @@ export function localExtensions(options) {
             throw new LocalExtensionError("install", `${path} is from an earlier extension format; ${remedy}`, { cause: parsed.error });
         return parsed.data;
     }
-    const readInstalled = () => readJson(installedPath, installedSchema, { extensions: {} }, "delete it and run `fungi extension add` again");
+    function extensionNamesForNotice(text) {
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            return [];
+        }
+        const parsed = extensionNameNoticeSchema.safeParse(value);
+        if (!parsed.success)
+            return [];
+        return [
+            ...new Set(Object.entries(parsed.data.extensions).flatMap(([id, extension]) => {
+                if (!Object.hasOwn(extension.revisions, extension.current))
+                    return [];
+                const revision = extension.revisions[extension.current];
+                if (revision === undefined)
+                    return [];
+                const revisionName = extensionArchiveNameSchema.safeParse(revision.name);
+                const idName = extensionArchiveNameSchema.safeParse(id);
+                const name = revisionName.success ? revisionName : idName;
+                return name.success ? [name.data] : [];
+            })),
+        ];
+    }
+    async function archiveInstalled(text) {
+        const names = extensionNamesForNotice(text);
+        const archiveRoot = join(resolve(options.home), ".fungi", "archive");
+        await mkdir(archiveRoot, { recursive: true, mode: 0o700 });
+        for (let suffix = 1; suffix <= 9; suffix += 1) {
+            const slug = "unversioned";
+            const directory = join(archiveRoot, slug, "extensions");
+            const filename = suffix === 1 ? "installed.json" : `installed-${suffix.toString()}.json`;
+            const destination = join(directory, filename);
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            const reservation = await open(destination, "wx", 0o600).catch((cause) => {
+                if (cause instanceof Error &&
+                    "code" in cause &&
+                    cause.code === "EEXIST")
+                    return undefined;
+                throw cause;
+            });
+            if (reservation === undefined)
+                continue;
+            try {
+                await rename(installedPath, destination);
+            }
+            catch (cause) {
+                if (absent(cause))
+                    return { extensions: {} };
+                throw new LocalExtensionError("install", `Could not archive ${installedPath} at ${destination}`, { cause });
+            }
+            finally {
+                await reservation.close();
+            }
+            await writeExtensionArchiveNotice(options.home, slug, filename, names);
+            if (!extensionArchiveNoticesAreDeferred(options.home)) {
+                const pending = await takePendingExtensionArchiveNoticesUnderOwnerLock(options.home);
+                for (const message of pending)
+                    process.stderr.write(`${message}\n`);
+            }
+            return { extensions: {} };
+        }
+        throw new LocalExtensionError("install", `Could not archive ${installedPath}: every unversioned archive destination already exists`);
+    }
+    async function readInstalled(underOwnerLock = false) {
+        let text;
+        try {
+            text = await readFile(installedPath, "utf8");
+        }
+        catch (cause) {
+            if (absent(cause))
+                return { extensions: {} };
+            throw cause;
+        }
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            value = undefined;
+        }
+        const parsed = installedSchema.safeParse(value);
+        if (parsed.success)
+            return parsed.data;
+        if (!underOwnerLock) {
+            const release = await acquireExtensionOwnerLock(root);
+            try {
+                return await readInstalled(true);
+            }
+            finally {
+                await release();
+            }
+        }
+        return archiveInstalled(text);
+    }
     const readActivations = () => readJson(activationsPath, activationsSchema, { projects: {}, agents: {} }, "delete it, then re-enable your extensions");
     /** Serialize owner writes across CLI and service processes. */
     async function update(change) {
-        await mkdir(root, { recursive: true, mode: 0o700 });
-        const release = await lockfile.lock(root, {
-            realpath: false,
-            lockfilePath: join(root, ".owner.lock"),
-            stale: 30_000,
-            update: 10_000,
-            retries: { retries: 20, factor: 1.2, minTimeout: 25, maxTimeout: 100 },
-        });
+        const release = await acquireExtensionOwnerLock(root);
         try {
-            const installed = await readInstalled();
+            const installed = await readInstalled(true);
             const activations = await readActivations();
             const result = change(installed, activations);
             const options = { encoding: "utf8", fsync: true, mode: 0o600 };
@@ -539,8 +620,8 @@ export function localExtensions(options) {
                 if (record.client !== null)
                     clients.push(record.client);
                 const runtime = await runtimeDirectory(project, id);
-                for (const terminal of record.terminals)
-                    terminals.push({
+                for (const terminal of record.terminals) {
+                    const launcher = {
                         extensionId: id,
                         terminalId: terminal.id,
                         name: terminal.name,
@@ -555,7 +636,11 @@ export function localExtensions(options) {
                             FUNGI_PROJECT_ROOT: project,
                             FUNGI_EXTENSION_RUNTIME_DIR: runtime,
                         },
-                    });
+                    };
+                    terminals.push(terminal.binding === undefined
+                        ? launcher
+                        : { ...launcher, binding: terminal.binding });
+                }
             }
             return { clients, terminals, diagnostics };
         },

package/dist/local-login.js

@@ -1,3 +1,4 @@
+import { interactionTitleLimit } from "@fungi.computer/whistle/wire";
 /** Display order for popular model providers; labels remain owned by Pi. */
 export const localPopularProviderIds = Object.freeze([
     "fungi",
@@ -54,13 +55,32 @@ function notice(event) {
             return { type: "progress", message: event.message };
     }
 }
+/**
+ * Pi's prompt text is provider wording, not a modal title: Whistle titles are
+ * at most `interactionTitleLimit` characters, and Pi 1.3's Anthropic paste
+ * prompt is longer. A message that fits stays the title; a longer one keeps
+ * every word as the summary under Fungi's fixed title for that prompt kind,
+ * so a provider sentence can never make the dialog refuse to open.
+ */
+function modalText(message, fallbackTitle, hint) {
+    const fits = message.trim() !== "" && message.length <= interactionTitleLimit;
+    const lines = [
+        ...(fits ? [] : [message]),
+        ...(hint === undefined ? [] : [hint]),
+    ];
+    const title = fits ? message : fallbackTitle;
+    return lines.length === 0
+        ? { message: title }
+        : { message: title, summary: lines.join(" ") };
+}
+const placeholderOf = (placeholder) => placeholder === undefined ? {} : { placeholder };
 async function ask(interaction, prompt) {
     const options = prompt.signal === undefined ? {} : { signal: prompt.signal };
     switch (prompt.type) {
         case "select":
             return interaction.prompt({
                 type: "choice",
-                message: prompt.message,
+                ...modalText(prompt.message, "Choose a sign-in option"),
                 options: prompt.options.map((option) => option.description === undefined
                     ? { value: option.id, label: option.label }
                     : {
@@ -69,30 +89,24 @@ async function ask(interaction, prompt) {
                         description: option.description,
                     }),
             }, options);
-        case "manual_code": {
+        case "manual_code":
             // Generic across every provider that falls back to a pasted code or
             // redirect URL (OpenAI, Anthropic): the provider's own
             // message explains what to paste; this adds the SSH hint once, here,
             // instead of baking it into one provider's registry label.
-            const message = `${prompt.message} If you're connecting over SSH, paste the URL here instead of opening a browser.`;
-            return interaction.prompt(prompt.placeholder === undefined
-                ? { type: "text", message }
-                : { type: "text", message, placeholder: prompt.placeholder }, options);
-        }
+            return interaction.prompt({
+                type: "text",
+                ...modalText(prompt.message, "Paste the sign-in code or redirect URL", "Connecting over SSH? Paste the URL here instead of opening a browser."),
+                ...placeholderOf(prompt.placeholder),
+            }, options);
         case "secret":
         case "text":
-            return interaction.prompt(prompt.placeholder === undefined
-                ? {
-                    type: "text",
-                    message: prompt.message,
-                    secret: prompt.type === "secret",
-                }
-                : {
-                    type: "text",
-                    message: prompt.message,
-                    placeholder: prompt.placeholder,
-                    secret: prompt.type === "secret",
-                }, options);
+            return interaction.prompt({
+                type: "text",
+                ...modalText(prompt.message, prompt.type === "secret" ? "Enter your key" : "Enter a value"),
+                ...placeholderOf(prompt.placeholder),
+                secret: prompt.type === "secret",
+            }, options);
     }
 }
 const methodNotOffered = "The provider did not offer that sign-in method";

package/dist/local-upgrade.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import type { PrivateLocalServiceStopResult } from "./private-local-service-contract.js";
+declare const versionMarkerSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    release: z.ZodString;
+    spore: z.ZodString;
+    build: z.ZodUnion<readonly [z.ZodLiteral<"source">, z.ZodString]>;
+}, z.core.$strict>;
+export type PriorInstall = Readonly<{
+    kind: "recorded";
+    release: string;
+    spore: string;
+}> | Readonly<{
+    kind: "protocol";
+    protocol: number;
+    build: string;
+}> | Readonly<{
+    kind: "unrecorded";
+}>;
+/** Version marker is a label, not permission to accept an older store schema. */
+export declare function readPriorInstall(home: string): Promise<PriorInstall>;
+/** Only the completed upgrade pass calls this writer; never write it early. */
+export declare function writeLocalVersionMarker(home: string, marker: Omit<z.input<typeof versionMarkerSchema>, "version">): Promise<void>;
+export type LocalUpgradeOptions = Readonly<{
+    home?: string;
+    directory?: string;
+    signal?: AbortSignal;
+    /** The package's generated, changelog-checked asset beside its CLI. */
+    newsPath: string;
+    spore: string;
+    /** Tests may supply the same bounded stop contract as the real manager. */
+    stopService?: (expectedServiceId?: string) => Promise<PrivateLocalServiceStopResult>;
+    /** Override only for an isolated proof of the installed-client identity. */
+    installedClientBuildId?: () => Promise<string | undefined>;
+}>;
+/** Invalid news lines are optional; a missing release label is not safe to mark current. */
+export declare function readLocalUpgradeNews(path: string): Promise<{
+    release: string;
+    lines: string[];
+}>;
+export type ArchivedArtifact = Readonly<{
+    kind: "agent-store" | "extension-activations";
+    from: string;
+    to: string;
+}>;
+export type LocalUpgradeReport = Readonly<{
+    from: PriorInstall;
+    to: string;
+    service: "stopped" | "killed" | "absent";
+    archive: string | undefined;
+    archived: readonly ArchivedArtifact[];
+    whatsNew: readonly string[];
+}>;
+export type LocalUpgradeOutcome = Readonly<{
+    kind: "current";
+}> | Readonly<{
+    kind: "upgraded";
+    report: LocalUpgradeReport;
+}>;
+/** Upgrade → service startup → extensions owner: this lock is always first. */
+export declare function upgradeLocalHome(options: LocalUpgradeOptions): Promise<LocalUpgradeOutcome>;
+export declare function formatLocalUpgradeNotice(report: LocalUpgradeReport): readonly string[];
+export {};