@fungi.computer/truffle 0.1.1 → 0.2.1

package/dist/local-image-fit.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Local shrinks every image it reads before it becomes an image part, as the
+ * retained `read_image` did on the Images binding: at most 512 px on the long
+ * edge as a quality-80 JPEG, stepping down to a 256 px floor until the bytes
+ * meet the 100 KB budget. Photon (Rust `image` compiled to WebAssembly, inlined
+ * in the package) decodes and encodes with no network, no Cloudflare and no
+ * per-platform native build.
+ *
+ * Photon's WebAssembly memory grows to the largest decode and never shrinks,
+ * and the Local service is long-running, so each image is decoded in its own
+ * worker thread that is terminated afterwards, returning that memory.
+ */
+/** Largest image file Local reads to shrink; larger files are refused unread. */
+export declare const maximumLocalImageInputBytes: number;
+/**
+ * Largest decoded image Local shrinks, checked from the header before any
+ * worker starts. 25 megapixels admits 24 MP phone photos (5712 x 4284) and 6K
+ * screenshots.
+ */
+export declare const maximumLocalImagePixels = 25000000;
+/** At most this many bytes of one image reach the model. */
+export declare const maximumLocalImageViewBytes: number;
+/**
+ * Shrink one whole png, jpeg, gif (first frame) or webp file for the model.
+ * Refuses, with the Files read error, an image whose header or pixels cannot
+ * be decoded, one above {@link maximumLocalImagePixels}, and one still above
+ * {@link maximumLocalImageViewBytes} at the 256 px floor. Never passes the
+ * original bytes through.
+ */
+export declare function fitLocalImage(path: string, bytes: Uint8Array, signal: AbortSignal): Promise<Uint8Array>;

package/dist/local-image-fit.js

@@ -0,0 +1,105 @@
+import { Worker } from "node:worker_threads";
+import { imageSize } from "image-size";
+import { z } from "zod";
+/**
+ * Local shrinks every image it reads before it becomes an image part, as the
+ * retained `read_image` did on the Images binding: at most 512 px on the long
+ * edge as a quality-80 JPEG, stepping down to a 256 px floor until the bytes
+ * meet the 100 KB budget. Photon (Rust `image` compiled to WebAssembly, inlined
+ * in the package) decodes and encodes with no network, no Cloudflare and no
+ * per-platform native build.
+ *
+ * Photon's WebAssembly memory grows to the largest decode and never shrinks,
+ * and the Local service is long-running, so each image is decoded in its own
+ * worker thread that is terminated afterwards, returning that memory.
+ */
+/** Largest image file Local reads to shrink; larger files are refused unread. */
+export const maximumLocalImageInputBytes = 16 * 1_024 * 1_024;
+/**
+ * Largest decoded image Local shrinks, checked from the header before any
+ * worker starts. 25 megapixels admits 24 MP phone photos (5712 x 4284) and 6K
+ * screenshots.
+ */
+export const maximumLocalImagePixels = 25_000_000;
+/** At most this many bytes of one image reach the model. */
+export const maximumLocalImageViewBytes = 100 * 1_024;
+/** The retained steps: 512 px long edge, down to a 256 px floor. */
+const viewDimensions = [512, 384, 256];
+const viewQuality = 80;
+/** Built beside this module; the CLI bundle ships it at the same relative path. */
+const workerUrl = new URL("./internal/local-image-fit-worker.mjs", import.meta.url);
+const replySchema = z.discriminatedUnion("kind", [
+    z.strictObject({
+        kind: z.literal("fitted"),
+        bytes: z.instanceof(Uint8Array),
+    }),
+    z.strictObject({ kind: z.literal("undecodable") }),
+    z.strictObject({ kind: z.literal("over-budget") }),
+]);
+const undecodable = (path) => new Error(`Image ${path} could not be decoded. Refusing to read it.`);
+/** Read the header with `image-size`; a header it cannot parse is refused. */
+function header(path, bytes) {
+    try {
+        return imageSize(bytes);
+    }
+    catch {
+        throw undecodable(path);
+    }
+}
+/** Run one throwaway worker over `bytes`; it is terminated however it ends. */
+async function shrinkInWorker(bytes, orientation, signal) {
+    signal.throwIfAborted();
+    const worker = new Worker(workerUrl, {
+        workerData: {
+            bytes,
+            orientation,
+            dimensions: viewDimensions,
+            quality: viewQuality,
+            maxBytes: maximumLocalImageViewBytes,
+        },
+    });
+    // Ends the abort listener with the worker.
+    const settled = new AbortController();
+    try {
+        return await new Promise((resolve, reject) => {
+            signal.addEventListener("abort", () => {
+                reject(new Error("Local image read was cancelled", {
+                    cause: signal.reason,
+                }));
+            }, { once: true, signal: settled.signal });
+            worker.once("message", (message) => {
+                const reply = replySchema.safeParse(message);
+                if (reply.success)
+                    resolve(reply.data);
+                else
+                    reject(new Error("Local image worker sent an invalid reply"));
+            });
+            worker.once("error", reject);
+            worker.once("exit", (code) => {
+                reject(new Error(`Local image worker exited (${String(code)}) before replying`));
+            });
+        });
+    }
+    finally {
+        settled.abort();
+        await worker.terminate();
+    }
+}
+/**
+ * Shrink one whole png, jpeg, gif (first frame) or webp file for the model.
+ * Refuses, with the Files read error, an image whose header or pixels cannot
+ * be decoded, one above {@link maximumLocalImagePixels}, and one still above
+ * {@link maximumLocalImageViewBytes} at the 256 px floor. Never passes the
+ * original bytes through.
+ */
+export async function fitLocalImage(path, bytes, signal) {
+    const { width, height, orientation } = header(path, bytes);
+    if (width * height > maximumLocalImagePixels)
+        throw new Error(`Image ${path} is ${String(width)} x ${String(height)} pixels; the read limit is ${String(maximumLocalImagePixels)} pixels. Refusing to read it.`);
+    const reply = await shrinkInWorker(bytes, orientation, signal);
+    if (reply.kind === "fitted")
+        return reply.bytes;
+    if (reply.kind === "undecodable")
+        throw undecodable(path);
+    throw new Error(`Image ${path} does not fit ${String(maximumLocalImageViewBytes)} bytes at ${String(viewDimensions.at(-1))} px. Refusing to read it.`);
+}

package/dist/local-models.d.ts

@@ -1,8 +1,10 @@
-import { type MutableModels, type ThinkingLevel } from "@earendil-works/pi-ai";
+import { type MutableModels, type Provider, type ThinkingLevel } from "@earendil-works/pi-ai";
 /** Register Pi's standalone OAuth modules on the same instance Local uses. */
 export declare function registerPrivateBundledModelOAuthFlows(): void;
 /** Create the private local Pi collection with Pi's policy-permitted providers. */
-export declare function createPrivateModels(credentialPath?: string): MutableModels;
+export declare function createPrivateModels(credentialPath?: string, providerOptions?: {
+    providers?: readonly Provider[];
+}): MutableModels;
 export type PrivateLocalModelChoice = Readonly<{
     providerId: string;
     providerName: string;

package/dist/local-models.js

@@ -4,6 +4,9 @@ import { registerBunOAuthFlows } from "@earendil-works/pi-ai/bun-oauth";
 import { loginAllowed, subscriptionKillSwitchFrom, } from "@fungi.computer/veil/model-credentials";
 import { createFungiAccountCredentialStore } from "./private-fungi-account.js";
 import { createFungiModelProvider } from "./private-fungi-model-provider.js";
+import { retainSubscriptionIdentity } from "./subscription-identity.js";
+import { registerSubscriptionTurnOwner } from "./subscription-turn.js";
+import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
 /** Register Pi's standalone OAuth modules on the same instance Local uses. */
 export function registerPrivateBundledModelOAuthFlows() {
     registerBunOAuthFlows();
@@ -26,17 +29,19 @@ function locallyPermitted(provider) {
     if (apiKey !== undefined)
         auth.apiKey = apiKey;
     if (oauth !== undefined)
-        auth.oauth = oauth;
+        auth.oauth =
+            provider.id === "anthropic" || provider.id === "openai"
+                ? retainSubscriptionIdentity(oauth, provider.id)
+                : oauth;
     return { ...provider, auth };
 }
 /** Create the private local Pi collection with Pi's policy-permitted providers. */
-export function createPrivateModels(credentialPath) {
-    const options = {};
-    if (credentialPath !== undefined)
-        options.credentialPath = credentialPath;
+export function createPrivateModels(credentialPath = capturePrivateLocalConfigRoot().credentialPath, providerOptions = {}) {
+    const options = { credentialPath };
     const credentials = createFungiAccountCredentialStore(options);
     const models = createModels({ credentials });
-    for (const provider of builtinProviders()) {
+    registerSubscriptionTurnOwner(models, credentials);
+    for (const provider of providerOptions.providers ?? builtinProviders()) {
         const permitted = locallyPermitted(provider);
         if (permitted !== undefined)
             models.setProvider(permitted);

package/dist/local-session-archives.d.ts

@@ -0,0 +1,8 @@
+import type { ArchiveWriter } from "@fungi.computer/zookeeper";
+/**
+ * Plain archive files beside the Agent store, never synced through Home:
+ * `<storeDirectory>/archives/<sessionId>/<contextRevision>-<materialKey>`.
+ * Each archive is streamed to a temp file, fsynced, then hard-linked into
+ * place so an existing archive is never overwritten.
+ */
+export declare function localArchiveWriter(storeDirectory: string, syncDirectoryPort?: (directory: string) => Promise<void>): ArchiveWriter;

package/dist/local-session-archives.js

@@ -0,0 +1,152 @@
+import { createHash } from "node:crypto";
+import { link, mkdir, open, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { archiveSessionSegment } from "@fungi.computer/zookeeper";
+import { nanoid } from "@fungi.computer/cairn";
+import { Effect } from "effect";
+import { z } from "zod";
+const MAX_CHUNK_BYTES = 64 * 1024;
+const SAFE_SEGMENT = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+const SHA256_HEX = /^[0-9a-f]{64}$/;
+/** Internal control flow: carries the reason a write was refused. */
+class ArchiveRefusal extends Error {
+    reason;
+    constructor(reason) {
+        super(`archive write refused: ${reason}`);
+        this.reason = reason;
+    }
+}
+const keyTakenSchema = z.object({ code: z.literal("EEXIST") });
+const refusalSchema = z.instanceof(ArchiveRefusal);
+function validate(input) {
+    const segments = [
+        archiveSessionSegment(input.sessionId),
+        input.contextRevision,
+        input.materialKey,
+    ];
+    if (!segments.every((segment) => SAFE_SEGMENT.test(segment)) ||
+        !SHA256_HEX.test(input.sha256) ||
+        input.materialKey !== input.sha256.slice(0, 32) ||
+        !Number.isSafeInteger(input.byteLength) ||
+        input.byteLength < 0) {
+        throw new ArchiveRefusal("invalid");
+    }
+}
+/** Stream the chunks into an open file, then check them against the declaration. */
+async function writeVerified(path, input, signal) {
+    const handle = await open(path, "wx", 0o600);
+    try {
+        const hash = createHash("sha256");
+        let total = 0;
+        for await (const chunk of input.chunks()) {
+            signal.throwIfAborted();
+            if (chunk.byteLength > MAX_CHUNK_BYTES) {
+                throw new ArchiveRefusal("invalid");
+            }
+            hash.update(chunk);
+            total += chunk.byteLength;
+            let written = 0;
+            while (written < chunk.byteLength) {
+                const result = await handle.write(chunk, written);
+                written += result.bytesWritten;
+            }
+        }
+        if (total !== input.byteLength || hash.digest("hex") !== input.sha256) {
+            throw new ArchiveRefusal("invalid");
+        }
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function syncDirectory(directory) {
+    const handle = await open(directory, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function existingMatches(path, input) {
+    const handle = await open(path, "r");
+    try {
+        const hash = createHash("sha256");
+        const buffer = Buffer.alloc(MAX_CHUNK_BYTES);
+        let total = 0;
+        for (;;) {
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+            if (bytesRead === 0) {
+                break;
+            }
+            hash.update(buffer.subarray(0, bytesRead));
+            total += bytesRead;
+        }
+        return total === input.byteLength && hash.digest("hex") === input.sha256;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Hard-link the finished temp file into place; false when the key is taken. */
+async function linkIntoPlace(tempPath, finalPath) {
+    try {
+        await link(tempPath, finalPath);
+        return true;
+    }
+    catch (error) {
+        if (keyTakenSchema.safeParse(error).success) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function writeArchiveFile(storeDirectory, input, signal, syncDirectoryPort) {
+    validate(input);
+    const name = `${input.contextRevision}-${input.materialKey}`;
+    const session = archiveSessionSegment(input.sessionId);
+    const directory = join(storeDirectory, "archives", session);
+    const finalPath = join(directory, name);
+    const tempPath = join(directory, `.${input.materialKey}.${nanoid()}.tmp`);
+    const receipt = {
+        key: `archives/${session}/${name}`,
+        sha256: input.sha256,
+        byteLength: input.byteLength,
+    };
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    try {
+        await writeVerified(tempPath, input, signal);
+        const created = await linkIntoPlace(tempPath, finalPath);
+        if (!created && !(await existingMatches(finalPath, input))) {
+            throw new ArchiveRefusal("conflict");
+        }
+        // A verified archive stays even when the directory fsync fails: a retry
+        // finds it by link and returns this same receipt.
+        await syncDirectoryPort(directory);
+        return receipt;
+    }
+    finally {
+        await rm(tempPath, { force: true });
+    }
+}
+/**
+ * Plain archive files beside the Agent store, never synced through Home:
+ * `<storeDirectory>/archives/<sessionId>/<contextRevision>-<materialKey>`.
+ * Each archive is streamed to a temp file, fsynced, then hard-linked into
+ * place so an existing archive is never overwritten.
+ */
+export function localArchiveWriter(storeDirectory, syncDirectoryPort = syncDirectory) {
+    return {
+        write: (input) => Effect.tryPromise({
+            try: (signal) => writeArchiveFile(storeDirectory, input, signal, syncDirectoryPort),
+            catch: (error) => {
+                const refusal = refusalSchema.safeParse(error);
+                return {
+                    _tag: "ArchiveWriteError",
+                    reason: refusal.success ? refusal.data.reason : "unavailable",
+                };
+            },
+        }),
+    };
+}

package/dist/local-skill-source.d.ts

@@ -1,6 +1,21 @@
-import type { SkillSource } from "@fungi.computer/shiitake-extensions/skills/source";
-/** Discover project-first skills without widening the invocation Files jail. */
+import type { SkillCatalog, SkillSource } from "@fungi.computer/shiitake-extensions/skills/source";
+/** An enabled extension's skills folder, as the extension owner reports it. */
+export type ExtensionSkillFolder = Readonly<{
+    extensionId: string;
+    directory: string;
+}>;
+/** What an extension's skills folder offers, for the install prompt. */
+export declare function describeExtensionSkills(folder: ExtensionSkillFolder, signal: AbortSignal): Promise<SkillCatalog>;
+/**
+ * Discover skills without widening the invocation Files jail. Folders are
+ * searched project first, then personal, then installed extensions' (lowest);
+ * the first skill with a name wins, so your own skill beats an extension's.
+ * `extensions` is already filtered by the extension owner's activation: a
+ * folder that is not passed here contributes nothing. Local installed
+ * extensions only; Hub-hosted extensions are not covered.
+ */
 export declare function createLocalSkillSource(options: Readonly<{
     cwd: string;
-    home?: string;
+    home: string;
+    extensions?: readonly ExtensionSkillFolder[];
 }>): SkillSource;