@fungi.computer/truffle 0.0.0-stage → 0.2.0

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-login.d.ts

@@ -0,0 +1,55 @@
+import type { AuthInteraction, Provider } from "@earendil-works/pi-ai";
+import type { WhistleInteraction } from "@fungi.computer/whistle";
+import type { PrivateLocalServiceManager } from "./private-local-service.js";
+/** Display order for popular model providers; labels remain owned by Pi. */
+export declare const localPopularProviderIds: readonly string[];
+/** One sign-in method, in the provider registry's vocabulary. */
+export type LocalLoginMethod = Readonly<{
+    kind: "api_key" | "subscription";
+    label: string;
+}>;
+/** One provider Local can sign in to, derived from Pi's provider data. */
+export type LocalLoginProvider = Readonly<{
+    id: string;
+    name: string;
+    methods: readonly LocalLoginMethod[];
+}>;
+/**
+ * Describe Pi's providers as registry data. Pi's OAuth sign-in is the
+ * provider's consumer subscription; ambient-only API keys (no interactive
+ * setup) are not offered. Callers pass the policy-filtered collection from
+ * `createPrivateModels`.
+ */
+export declare function localLoginProviders(providers: readonly Provider[]): readonly LocalLoginProvider[];
+/**
+ * Present Pi's provider sign-in through a Whistle interaction. `option`
+ * answers Pi's own method question (e.g. `device_code`) without asking. If
+ * the flow's first event -- a prompt or a notification -- is not a `select`
+ * offering that option, the flow never asks the question at all (e.g.
+ * Anthropic, which has only one sign-in method); cancel before relaying
+ * anything to the host, so no browser URL or other handoff is ever shown
+ * for a method the provider silently ignored.
+ */
+export declare function authInteractionFor(interaction: WhistleInteraction, option?: string): AuthInteraction;
+/** The Local credential owner behind provider-agnostic account commands. */
+export declare function localAccountOwner(manager: Pick<PrivateLocalServiceManager, "auth">, providers: () => readonly Provider[]): {
+    popularProviderIds: readonly string[];
+    access: (signal: AbortSignal) => Promise<Readonly<{
+        providerId: string;
+        providerName: string;
+        state: "configured";
+        type: import("@earendil-works/pi-ai").AuthType;
+    }>[]>;
+    providers: () => Promise<readonly Readonly<{
+        id: string;
+        name: string;
+        methods: readonly LocalLoginMethod[];
+    }>[]>;
+    login: (request: Readonly<{
+        providerId: string;
+        method: LocalLoginMethod["kind"];
+        option?: string;
+    }>, interaction: WhistleInteraction) => Promise<void>;
+    logout: (providerId: string, interaction: WhistleInteraction) => Promise<void>;
+    status: (signal: AbortSignal) => Promise<string>;
+};

package/dist/local-login.js

@@ -0,0 +1,167 @@
+/** Display order for popular model providers; labels remain owned by Pi. */
+export const localPopularProviderIds = Object.freeze([
+    "fungi",
+    "openai",
+    "anthropic",
+    "deepseek",
+    "kimi-coding",
+    "openrouter",
+]);
+/**
+ * Describe Pi's providers as registry data. Pi's OAuth sign-in is the
+ * provider's consumer subscription; ambient-only API keys (no interactive
+ * setup) are not offered. Callers pass the policy-filtered collection from
+ * `createPrivateModels`.
+ */
+export function localLoginProviders(providers) {
+    return providers.flatMap((provider) => {
+        const methods = [];
+        if (provider.auth.apiKey?.login !== undefined)
+            methods.push({ kind: "api_key", label: provider.auth.apiKey.name });
+        if (provider.auth.oauth !== undefined)
+            methods.push({
+                kind: "subscription",
+                label: provider.auth.oauth.loginLabel ?? provider.auth.oauth.name,
+            });
+        return methods.length === 0
+            ? []
+            : [{ id: provider.id, name: provider.name, methods }];
+    });
+}
+function notice(event) {
+    switch (event.type) {
+        case "auth_url":
+            return event.instructions === undefined
+                ? { type: "handoff", url: event.url }
+                : { type: "handoff", url: event.url, message: event.instructions };
+        case "device_code":
+            return {
+                type: "handoff",
+                url: event.verificationUri,
+                code: event.userCode,
+            };
+        case "info":
+            return event.links === undefined
+                ? { type: "info", message: event.message }
+                : {
+                    type: "info",
+                    message: event.message,
+                    links: event.links.map((link) => link.label === undefined
+                        ? { url: link.url }
+                        : { url: link.url, label: link.label }),
+                };
+        case "progress":
+            return { type: "progress", message: event.message };
+    }
+}
+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,
+                options: prompt.options.map((option) => option.description === undefined
+                    ? { value: option.id, label: option.label }
+                    : {
+                        value: option.id,
+                        label: option.label,
+                        description: option.description,
+                    }),
+            }, options);
+        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);
+        }
+        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);
+    }
+}
+const methodNotOffered = "The provider did not offer that sign-in method";
+/**
+ * Present Pi's provider sign-in through a Whistle interaction. `option`
+ * answers Pi's own method question (e.g. `device_code`) without asking. If
+ * the flow's first event -- a prompt or a notification -- is not a `select`
+ * offering that option, the flow never asks the question at all (e.g.
+ * Anthropic, which has only one sign-in method); cancel before relaying
+ * anything to the host, so no browser URL or other handoff is ever shown
+ * for a method the provider silently ignored.
+ */
+export function authInteractionFor(interaction, option) {
+    let preset = option;
+    return {
+        signal: interaction.signal,
+        prompt: (prompt) => {
+            if (preset === undefined)
+                return ask(interaction, prompt);
+            if (prompt.type !== "select") {
+                preset = undefined;
+                return Promise.reject(new Error(methodNotOffered));
+            }
+            const chosen = prompt.options.find((one) => one.id === preset);
+            preset = undefined;
+            if (chosen === undefined)
+                return Promise.reject(new Error(methodNotOffered));
+            return Promise.resolve(chosen.id);
+        },
+        notify: (event) => {
+            if (preset !== undefined) {
+                preset = undefined;
+                throw new Error(methodNotOffered);
+            }
+            interaction.notify(notice(event));
+        },
+    };
+}
+/** The Local credential owner behind provider-agnostic account commands. */
+export function localAccountOwner(manager, providers) {
+    const access = async (signal) => {
+        const result = await manager.auth({ command: "status" }, {
+            signal,
+            prompt: () => Promise.reject(new Error("Account status cannot prompt")),
+            notify: () => undefined,
+        });
+        if (result.kind !== "status")
+            throw new Error("Account status returned a non-status result");
+        return result.providers.filter((provider) => provider.state === "configured");
+    };
+    return {
+        popularProviderIds: localPopularProviderIds,
+        access,
+        providers: () => Promise.resolve(localLoginProviders(providers())),
+        login: async (request, interaction) => {
+            await manager.auth({
+                command: "login",
+                provider: request.providerId,
+                authType: request.method === "subscription" ? "oauth" : "api_key",
+            }, authInteractionFor(interaction, request.option));
+        },
+        logout: async (providerId, interaction) => {
+            await manager.auth({ command: "logout", provider: providerId }, authInteractionFor(interaction));
+        },
+        status: async (signal) => {
+            const configured = (await access(signal)).map((provider) => `${provider.providerName}: configured (${provider.type})`);
+            return configured.length === 0
+                ? "No model provider is signed in. Use /login to add one."
+                : configured.join("\n");
+        },
+    };
+}

package/dist/local-models.d.ts

@@ -0,0 +1,16 @@
+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, providerOptions?: {
+    providers?: readonly Provider[];
+}): MutableModels;
+export type PrivateLocalModelChoice = Readonly<{
+    providerId: string;
+    providerName: string;
+    id: string;
+    name: string;
+    reasoning: readonly ThinkingLevel[];
+}>;
+/** Refresh configured dynamic catalogs before exposing the bounded owner picker. */
+export declare function listPrivateModels(credentialPath?: string): Promise<readonly PrivateLocalModelChoice[]>;

package/dist/local-models.js

@@ -0,0 +1,82 @@
+import { createModels, getSupportedThinkingLevels, } from "@earendil-works/pi-ai";
+import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
+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();
+}
+/** Local credentials belong to the one person who owns this machine. */
+const allowedHere = (providerId, method) => loginAllowed({ providerId, method, host: "local", scope: "user" }, 
+// FUNGI_SUBSCRIPTION_KILL=anthropic,openai turns logins off without a release.
+subscriptionKillSwitchFrom(process.env.FUNGI_SUBSCRIPTION_KILL));
+/** Keep only the login methods Veil's provider policy allows on this machine. */
+function locallyPermitted(provider) {
+    const apiKey = allowedHere(provider.id, "api_key")
+        ? provider.auth.apiKey
+        : undefined;
+    const oauth = allowedHere(provider.id, "subscription")
+        ? provider.auth.oauth
+        : undefined;
+    if (apiKey === undefined && oauth === undefined)
+        return undefined;
+    const auth = {};
+    if (apiKey !== undefined)
+        auth.apiKey = apiKey;
+    if (oauth !== undefined)
+        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 = capturePrivateLocalConfigRoot().credentialPath, providerOptions = {}) {
+    const options = { credentialPath };
+    const credentials = createFungiAccountCredentialStore(options);
+    const models = createModels({ credentials });
+    registerSubscriptionTurnOwner(models, credentials);
+    for (const provider of providerOptions.providers ?? builtinProviders()) {
+        const permitted = locallyPermitted(provider);
+        if (permitted !== undefined)
+            models.setProvider(permitted);
+    }
+    const fungi = locallyPermitted(createFungiModelProvider(options));
+    if (fungi !== undefined)
+        models.setProvider(fungi);
+    return models;
+}
+/** Refresh configured dynamic catalogs before exposing the bounded owner picker. */
+export async function listPrivateModels(credentialPath) {
+    const models = createPrivateModels(credentialPath);
+    const result = await models.refresh();
+    if (result.aborted)
+        throw new Error("Model catalog refresh was cancelled");
+    const fungiFailure = result.errors.get("fungi");
+    if (fungiFailure !== undefined)
+        throw fungiFailure;
+    if (result.errors.size > 0)
+        throw new AggregateError([...result.errors.values()], "Could not refresh model catalogs");
+    return Object.freeze(models
+        .getProviders()
+        .flatMap((provider) => models.getModels(provider.id).map((model) => ({
+        providerId: provider.id,
+        providerName: provider.name,
+        id: model.id,
+        name: model.name,
+        reasoning: getSupportedThinkingLevels(model).filter((level) => level !== "off"),
+    })))
+        .sort((left, right) => left.providerName.localeCompare(right.providerName) ||
+        left.name.localeCompare(right.name) ||
+        left.providerId.localeCompare(right.providerId) ||
+        left.id.localeCompare(right.id))
+        .map((choice) => Object.freeze({
+        ...choice,
+        reasoning: Object.freeze(choice.reasoning),
+    })));
+}

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

@@ -0,0 +1,21 @@
+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;
+    extensions?: readonly ExtensionSkillFolder[];
+}>): SkillSource;