@fungi.computer/truffle 0.0.0-stage → 0.2.0

package/dist/private-file-credential-store.js

@@ -0,0 +1,331 @@
+import { correlationKey } from "@fungi.computer/cairn";
+import { createHash } from "node:crypto";
+import { machineEnrollmentRecordSchema, } from "./private-local-mesh-record.js";
+import { chmod, mkdir, open } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import lockfile from "proper-lockfile";
+import writeFileAtomic from "write-file-atomic";
+import { z } from "zod";
+const maximumCredentialFileBytes = 256 * 1_024;
+const maximumCredentialEntries = 128;
+const maximumProviderIdLength = 256;
+export const maximumCredentialStringLength = 64 * 1_024;
+const maximumEnvironmentEntries = 64;
+const maximumExtensionEntries = 64;
+const privateDirectoryMode = 0o700;
+const privateFileMode = 0o600;
+const lockOptions = {
+    realpath: false,
+    stale: 30_000,
+    update: 10_000,
+    retries: { retries: 20, factor: 1.2, minTimeout: 25, maxTimeout: 100 },
+};
+const providerIdSchema = z.string().min(1).max(maximumProviderIdLength);
+const credentialStringSchema = z.string().max(maximumCredentialStringLength);
+const environmentSchema = z
+    .record(z.string().min(1).max(maximumProviderIdLength), credentialStringSchema)
+    .superRefine((environment, context) => {
+    if (Object.keys(environment).length > maximumEnvironmentEntries) {
+        context.addIssue({
+            code: "custom",
+            message: "Credential environment contains too many entries",
+        });
+    }
+});
+const apiKeyCredentialSchema = z
+    .strictObject({
+    type: z.literal("api_key"),
+    key: credentialStringSchema.optional(),
+    env: environmentSchema.optional(),
+})
+    .transform((input) => {
+    const credential = { type: "api_key" };
+    if (input.key !== undefined)
+        credential.key = input.key;
+    if (input.env !== undefined)
+        credential.env = input.env;
+    return credential;
+});
+export const oauthCredentialSchema = z
+    .object({
+    type: z.literal("oauth"),
+    refresh: credentialStringSchema,
+    access: credentialStringSchema,
+    expires: z.number(),
+})
+    .catchall(z.json())
+    .superRefine((credential, context) => {
+    if (Object.keys(credential).length > maximumExtensionEntries + 4) {
+        context.addIssue({
+            code: "custom",
+            message: "OAuth credential contains too many entries",
+        });
+    }
+    for (const key of Object.keys(credential)) {
+        if (key.length > maximumProviderIdLength) {
+            context.addIssue({
+                code: "custom",
+                message: "OAuth credential contains an oversized key",
+            });
+        }
+    }
+});
+const credentialSchema = z.discriminatedUnion("type", [
+    apiKeyCredentialSchema,
+    oauthCredentialSchema,
+    machineEnrollmentRecordSchema,
+]);
+const machineRecordId = (origin) => `machine-enrollment:${createHash("sha256").update(origin).digest("hex")}`;
+const credentialMapSchema = z
+    .record(providerIdSchema, credentialSchema)
+    .superRefine((credentials, context) => {
+    for (const [id, record] of Object.entries(credentials))
+        if (record.type === "machine_enrollment" &&
+            id !== machineRecordId(record.origin))
+            context.addIssue({
+                code: "custom",
+                message: "Machine enrollment origin does not match its record",
+            });
+    if (Object.keys(credentials).length > maximumCredentialEntries) {
+        context.addIssue({
+            code: "custom",
+            message: "Credential store contains too many providers",
+        });
+    }
+});
+const missingFileErrorSchema = z.object({ code: z.literal("ENOENT") });
+/** Resolve the host-owned default path without consulting project or Agent Home state. */
+export function resolveDefaultCredentialPath(home) {
+    if (!isAbsolute(home)) {
+        throw new Error("Default credential home must be absolute");
+    }
+    return resolve(home, ".config", "fungi", "credentials.json");
+}
+function credentialStoreError(message) {
+    return new Error(message);
+}
+function ownCredential(credentials, providerId) {
+    if (credentials === undefined || !Object.hasOwn(credentials, providerId)) {
+        return undefined;
+    }
+    const record = credentials[providerId];
+    return record?.type === "machine_enrollment" ? undefined : record;
+}
+function parseCredentials(serialized) {
+    let parsed;
+    try {
+        parsed = JSON.parse(serialized);
+    }
+    catch {
+        throw credentialStoreError("Credential store contains malformed JSON");
+    }
+    const result = credentialMapSchema.safeParse(parsed);
+    if (!result.success) {
+        throw credentialStoreError("Credential store contains invalid credential data");
+    }
+    return result.data;
+}
+/**
+ * Internal constructor permits one focused write-failure test while the public
+ * package surface remains the Pi CredentialStore factory below.
+ */
+export class FileCredentialStore {
+    #path;
+    #writeAtomic;
+    constructor(path, writeAtomic = writeFileAtomic) {
+        if (!isAbsolute(path)) {
+            throw new Error("Private credential path must be absolute");
+        }
+        this.#path = path;
+        this.#writeAtomic = writeAtomic;
+    }
+    /** Keep the installation UUID beside credentials, across logout and restart. */
+    async getDeviceId() {
+        return this.#withLock(async () => {
+            const path = `${this.#path}.device-id`;
+            let handle;
+            try {
+                handle = await open(path, "r");
+            }
+            catch (error) {
+                if (!missingFileErrorSchema.safeParse(error).success)
+                    throw error;
+                const id = correlationKey();
+                await this.#writeAtomic(path, id, {
+                    encoding: "utf8",
+                    fsync: true,
+                    mode: privateFileMode,
+                });
+                return id;
+            }
+            try {
+                // A UUID has exactly 36 bytes; the extra byte detects oversized input.
+                const bytes = Buffer.alloc(37);
+                const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
+                const parsed = z
+                    .uuid()
+                    .safeParse(bytes.subarray(0, bytesRead).toString("utf8"));
+                if (!parsed.success)
+                    throw credentialStoreError("Local model device ID is invalid");
+                return parsed.data;
+            }
+            finally {
+                await handle.close();
+            }
+        });
+    }
+    async read(providerId, options) {
+        options?.signal?.throwIfAborted();
+        return ownCredential(await this.#readCredentials(), providerId);
+    }
+    async list(options) {
+        options?.signal?.throwIfAborted();
+        const credentials = await this.#readCredentials();
+        if (credentials === undefined)
+            return [];
+        return Object.entries(credentials).flatMap(([providerId, credential]) => credential.type === "machine_enrollment"
+            ? []
+            : [{ providerId, type: credential.type }]);
+    }
+    async modify(providerId, callback, options) {
+        options?.signal?.throwIfAborted();
+        return await this.#withLock(async () => {
+            options?.signal?.throwIfAborted();
+            const credentials = (await this.#readCredentials()) ?? {};
+            if (credentials[providerId]?.type === "machine_enrollment")
+                throw credentialStoreError("A model credential cannot replace a machine enrollment");
+            const current = ownCredential(credentials, providerId);
+            const next = await callback(current);
+            options?.signal?.throwIfAborted();
+            if (next === undefined)
+                return current;
+            const validated = this.#validateCredentials({
+                ...credentials,
+                [providerId]: next,
+            });
+            await this.#replace(validated);
+            const persisted = ownCredential(validated, providerId);
+            if (persisted === undefined) {
+                throw credentialStoreError("Credential store failed to retain its update");
+            }
+            return persisted;
+        });
+    }
+    async delete(providerId, options) {
+        await this.remove(providerId, () => Promise.resolve(), options);
+    }
+    async readMachineEnrollments() {
+        return Object.values((await this.#readCredentials()) ?? {}).filter((record) => record.type === "machine_enrollment");
+    }
+    async modifyMachineEnrollments(origin, edit, owner) {
+        await this.#withLock(async () => {
+            const credentials = (await this.#readCredentials()) ?? {};
+            owner?.admit(ownCredential(credentials, owner.providerId));
+            const id = machineRecordId(origin);
+            const previous = credentials[id];
+            if (previous !== undefined && previous.type !== "machine_enrollment")
+                throw credentialStoreError("Machine enrollment record is occupied");
+            const enrollments = edit(previous?.enrollments ?? []);
+            const others = Object.fromEntries(Object.entries(credentials).filter(([key]) => key !== id));
+            await this.#replace(this.#validateCredentials(enrollments.length === 0
+                ? others
+                : {
+                    ...others,
+                    [id]: machineEnrollmentRecordSchema.parse({
+                        type: "machine_enrollment",
+                        origin,
+                        enrollments,
+                    }),
+                }));
+        });
+    }
+    async removeMachineEnrollments(origin) {
+        return this.#withLock(async () => {
+            const credentials = await this.#readCredentials();
+            const id = machineRecordId(origin);
+            if (credentials?.[id]?.type !== "machine_enrollment")
+                return false;
+            const next = Object.fromEntries(Object.entries(credentials).filter(([key]) => key !== id));
+            await this.#replace(this.#validateCredentials(next));
+            return true;
+        });
+    }
+    async remove(providerId, beforeRemove, options) {
+        options?.signal?.throwIfAborted();
+        return this.#withLock(async () => {
+            options?.signal?.throwIfAborted();
+            const credentials = await this.#readCredentials();
+            const current = ownCredential(credentials, providerId);
+            if (credentials === undefined || current === undefined)
+                return undefined;
+            const result = await beforeRemove(current);
+            const next = Object.fromEntries(Object.entries(credentials).filter(([id]) => id !== providerId));
+            options?.signal?.throwIfAborted();
+            await this.#replace(this.#validateCredentials(next));
+            return result;
+        });
+    }
+    #validateCredentials(credentials) {
+        const result = credentialMapSchema.safeParse(credentials);
+        if (!result.success) {
+            throw credentialStoreError("Credential update contains invalid credential data");
+        }
+        return result.data;
+    }
+    async #readCredentials() {
+        let handle;
+        try {
+            handle = await open(this.#path, "r");
+        }
+        catch (error) {
+            if (missingFileErrorSchema.safeParse(error).success)
+                return undefined;
+            throw error;
+        }
+        try {
+            const bytes = Buffer.alloc(maximumCredentialFileBytes + 1);
+            let totalBytesRead = 0;
+            while (totalBytesRead < bytes.length) {
+                const { bytesRead } = await handle.read(bytes, totalBytesRead, bytes.length - totalBytesRead, totalBytesRead);
+                if (bytesRead === 0)
+                    break;
+                totalBytesRead += bytesRead;
+            }
+            if (totalBytesRead > maximumCredentialFileBytes) {
+                throw credentialStoreError("Credential store exceeds its private file bound");
+            }
+            return parseCredentials(bytes.subarray(0, totalBytesRead).toString("utf8"));
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async #replace(credentials) {
+        await this.#writeAtomic(this.#path, JSON.stringify(credentials), {
+            encoding: "utf8",
+            fsync: true,
+            mode: privateFileMode,
+        });
+    }
+    /**
+     * proper-lockfile bounds acquisition through retries but cannot cancel it
+     * while queued. Callers check their signal before acquisition and
+     * immediately after it succeeds.
+     */
+    async #withLock(callback) {
+        const directory = dirname(this.#path);
+        await mkdir(directory, { recursive: true, mode: privateDirectoryMode });
+        await chmod(directory, privateDirectoryMode);
+        const release = await lockfile.lock(this.#path, lockOptions);
+        try {
+            return await callback();
+        }
+        finally {
+            await release();
+        }
+    }
+}
+/** Create the one private Pi CredentialStore selected by the local host. */
+export function createPrivateCredentialStore(path) {
+    return new FileCredentialStore(path);
+}

package/dist/private-files-patch.d.ts

@@ -0,0 +1,4 @@
+import type { FilesPatch, FilesPort } from "@fungi.computer/knapsack";
+import { type LocalSandboxLaunch } from "./private-invocation-computer.js";
+/** Advertise only a packaged native engine; never install tools during a model call. */
+export declare function createPrivateFilesPatch(root: string, read: FilesPort["read"], sandbox?: LocalSandboxLaunch): Promise<FilesPatch | undefined>;

package/dist/private-files-patch.js

@@ -0,0 +1,104 @@
+import { access, constants } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import process from "node:process";
+import * as ChildProcess from "effect/process/ChildProcess";
+import { parsePatch } from "diff";
+import * as Stream from "effect/Stream";
+import { runPrivateInvocationProcess, } from "./private-invocation-computer.js";
+function patchExecutable() {
+    if (process.env.FUNGI_BUNDLED_CLI) {
+        const name = `@fungi.computer/spore-native-${process.platform}-${process.arch}`;
+        try {
+            return createRequire(process.env.FUNGI_BUNDLED_CLI).resolve(`${name}/bin/fungi-apply-patch`);
+        }
+        catch (cause) {
+            throw new Error(`Missing ${name}; reinstall Fungi with npm optional dependencies enabled`, { cause });
+        }
+    }
+    return fileURLToPath(new URL("../native/bin/fungi-apply-patch", import.meta.url));
+}
+const maximumPatchBytes = 128 * 1024;
+const mismatchExitCode = 23;
+const formatExitCode = 24;
+/** Read-only recovery guidance for rejected standard unified-diff input. */
+async function unifiedDiffContext(patch, read, context) {
+    try {
+        const unified = patch
+            .replace(/^\*\*\* Begin Patch\r?\n/u, "")
+            .replace(/\r?\n\*\*\* End Patch\s*$/u, "");
+        const file = parsePatch(unified)[0];
+        const hunk = file?.hunks[0];
+        const path = file?.oldFileName.replace(/^a\//u, "");
+        if (path === undefined || hunk === undefined || path === "/dev/null")
+            return "\nInclude *** Update File: path/to/file before @@ to identify the target.\n";
+        const current = await read({ path, offset: 0, limit: maximumPatchBytes }, context);
+        if ("image" in current)
+            throw new Error(`${path} is an image, not text`);
+        const lines = current.content.split(/\r?\n/u);
+        const from = Math.min(Math.max(0, hunk.oldStart - 3), Math.max(0, lines.length - 7));
+        const nearby = lines
+            .slice(from, from + 7)
+            .map((line, index) => `  ${String(from + index + 1)}: ${line.length > 160 ? line.slice(0, 160) + "…" : line}`);
+        return `\nCurrent lines in ${path.slice(0, 160)}:\n${nearby.join("\n")}\n${current.truncated ? "File preview is truncated at 128 KiB.\n" : ""}`;
+    }
+    catch (cause) {
+        context.signal.throwIfAborted();
+        return `\nCurrent file preview unavailable: ${cause instanceof Error ? cause.message.slice(0, 512) : "unified diff could not be decoded"}\n`;
+    }
+}
+/** Advertise only a packaged native engine; never install tools during a model call. */
+export async function createPrivateFilesPatch(root, read, sandbox) {
+    const executable = patchExecutable();
+    try {
+        await access(executable, constants.X_OK);
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+            return undefined;
+        throw cause;
+    }
+    return async ({ patch }, context) => {
+        context.signal.throwIfAborted();
+        const bytes = new TextEncoder().encode(patch);
+        if (bytes.byteLength > maximumPatchBytes)
+            throw new Error("Patch exceeds the 128 KiB input bound");
+        const launch = sandbox?.(root, [executable]);
+        const env = { ...process.env, ...launch?.environment };
+        if (launch !== undefined) {
+            delete env.XDG_RUNTIME_DIR;
+            delete env.DBUS_SESSION_BUS_ADDRESS;
+        }
+        const command = ChildProcess.make(launch?.executable ?? executable, launch?.args ?? [], {
+            cwd: root,
+            env,
+            extendEnv: false,
+            stdin: Stream.make(bytes),
+            additionalFds: launch?.seccompFilter === undefined
+                ? undefined
+                : {
+                    fd3: {
+                        type: "input",
+                        stream: Stream.make(launch.seccompFilter),
+                    },
+                },
+        });
+        const result = await runPrivateInvocationProcess(command, context.signal, 30_000);
+        if (result.status === "deadline_exceeded")
+            return {
+                status: "failed",
+                exitCode: result.exitCode,
+                stdout: result.stdout,
+                stderr: `${result.stderr}\n${result.message} Earlier patch writes may remain.`,
+                truncated: result.truncated,
+            };
+        if (result.status === "failed" && result.exitCode === formatExitCode)
+            return {
+                ...result,
+                stderr: result.stderr + (await unifiedDiffContext(patch, read, context)),
+            };
+        return result.status === "failed" && result.exitCode === mismatchExitCode
+            ? { ...result, error: { kind: "mismatch" } }
+            : result;
+    };
+}

package/dist/private-fungi-account.d.ts

@@ -0,0 +1,252 @@
+import { type AuthProvider, type FetchLike, type OAuthClientProvider, type StoredOAuthClientInformation } from "@modelcontextprotocol/client";
+import { z } from "zod";
+import type { Credential, CredentialStore, OAuthAuth } from "@earendil-works/pi-ai";
+import { type LocalMachineEnrollmentAccount } from "./private-local-mesh-record.js";
+import { type FungiAccountLogoutResult } from "./private-fungi-service-logout.js";
+/**
+ * One folder attached to a Team Computer. The absolute folder path and the
+ * device's private key never leave this file; the Hub holds only the public
+ * key and the two labels.
+ */
+declare const localBackendRecordSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    teamId: z.ZodString;
+    computerId: z.ZodString;
+    computerName: z.ZodString;
+    rootPath: z.ZodString;
+    hostLabel: z.ZodString;
+    folderLabel: z.ZodString;
+    publicKey: z.ZodBase64;
+    privateKey: z.ZodBase64;
+    backendId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type LocalBackendRecord = z.output<typeof localBackendRecordSchema>;
+declare const teamChoiceSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type FungiAccountTeam = z.output<typeof teamChoiceSchema>;
+export type PrivateFungiAccountOAuthProviderOptions = {
+    interactive?: boolean;
+    credentialPath?: string;
+    issuer?: string;
+    /** The Team MCP endpoint named in re-login guidance. */
+    endpoint?: URL;
+    /** The listening loopback callback for an interactive login. */
+    redirectUrl?: string;
+    openBrowser?: (url: URL) => void;
+};
+/**
+ * Enrollment uses the account file and lock, without Pi's selected-payer view.
+ * Fungi enrollments are partitioned by issuer in the origin-keyed enrollment
+ * records: only the signed-in issuer's partition is ever read for dialing, so
+ * a switch never lends one issuer's Team or device identifiers to another,
+ * and signing in to an issuer again finds its own partition.
+ */
+export declare function createLocalMachineEnrollmentAccount(credentialPath: string): LocalMachineEnrollmentAccount;
+/** Hand a Fungi sign-in page to the platform browser; callers show the URL. */
+export declare function launchPlatformBrowser(url: URL): void;
+/** Persisted OAuth state uses Local's existing owner-only Pi credential file. */
+export declare function privateFungiAccountOAuthProvider(input?: PrivateFungiAccountOAuthProviderOptions): OAuthClientProvider & {
+    saveClientInformation(information: StoredOAuthClientInformation): Promise<void>;
+    expectedState(): string | undefined;
+    authorizationUrl(): URL | undefined;
+};
+export type PrivateFungiAccountLoginOptions = {
+    credentialPath?: string;
+    /**
+     * Asked before a login for another origin replaces the saved login. Without
+     * it, a login for another origin fails with the logout command to run.
+     */
+    confirmReplace?: (savedIssuer: string, nextIssuer: string) => Promise<boolean>;
+    /** Choose a current membership when the account has several Teams. */
+    chooseTeam?: (teams: readonly FungiAccountTeam[]) => Promise<string>;
+    signal?: AbortSignal;
+    /** The maintained OAuth fetch seam. */
+    fetch?: FetchLike;
+    /** Opens the Hub pages; the default launches the platform browser. */
+    openBrowser?: (url: URL) => void;
+};
+export type PrivateFungiAccountLogoutResult = FungiAccountLogoutResult;
+/** An in-process account change the service owner reacts to. */
+export type FungiAccountChange = Readonly<{
+    type: "signed-out";
+}>;
+/** Installed only by the service holding this home's owner lease. */
+export declare function registerFungiAccountOwner(credentialPath: string, changed: (event: FungiAccountChange) => Promise<void>): () => void;
+export type FungiAccountStatus = {
+    issuer: string;
+    accessExpiresAt: Date;
+    team?: FungiAccountTeam;
+    teamCount?: number;
+};
+/** Non-secret status of the shared Fungi account. */
+export declare function readFungiAccountStatus(input?: {
+    credentialPath?: string;
+}): Promise<FungiAccountStatus | undefined>;
+/**
+ * Ask the running Local account owner to remove this origin's login and revoke
+ * its refresh grant. Without a service, clear offline; never start one for
+ * logout. A login for another origin is kept. Explicit standalone stores have
+ * no service home; clients with a custom service directory name it explicitly.
+ */
+export declare function signOutFungiAccount(rawEndpoint?: string | URL, input?: {
+    credentialPath?: string;
+    serviceDirectory?: string;
+    fetch?: FetchLike;
+}): Promise<PrivateFungiAccountLogoutResult>;
+/** Store mutation for the service owner or a verified no-service caller. */
+export declare function signOutOwnedFungiAccount(rawEndpoint?: string | URL, input?: {
+    credentialPath?: string;
+    fetch?: FetchLike;
+}): Promise<PrivateFungiAccountLogoutResult>;
+/**
+ * Run one Mycelium control call against the Team MCP endpoint with the saved
+ * login, and return the tool's text result. An error result or a transport
+ * failure is `undefined`: the caller retries with its persisted request id.
+ */
+export declare function callFungiMcpTeamControl(teamEndpoint: URL, code: string, options?: Readonly<{
+    credentialPath?: string;
+    fetch?: FetchLike;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}>): Promise<string | undefined>;
+/** The Team MCP endpoint and Team a control call addresses, validated. */
+export declare function fungiMcpTeamEndpoint(rawEndpoint: string | URL): {
+    endpoint: URL;
+    teamId: string;
+};
+/** The machine's attached folders, as Local keeps them. */
+export declare function readFungiMcpLocalBackends(input?: Readonly<{
+    credentialPath?: string;
+}>): Promise<Readonly<{
+    issuer: string | undefined;
+    backends: LocalBackendRecord[];
+}>>;
+/** Replace the attached folder records in the owner-only credential file. */
+export declare function writeFungiMcpLocalBackends(update: (current: readonly LocalBackendRecord[]) => LocalBackendRecord[], input?: Readonly<{
+    credentialPath?: string;
+}>): Promise<void>;
+/** Complete first-party registration and OAuth authorization in a foreground TUI. */
+export declare function signInFungiAccount(rawEndpoint: string | URL, input?: PrivateFungiAccountLoginOptions): Promise<void>;
+/** Switch only to a fresh membership; failure preserves the prior selected Team. */
+export declare function switchFungiAccountTeam(teamId: string, input?: {
+    credentialPath?: string;
+    fetch?: FetchLike;
+}): Promise<void>;
+export type FungiAccountTeams = Readonly<{
+    teams: readonly FungiAccountTeam[];
+    selectedTeamId?: string;
+}>;
+/** Fresh memberships for the saved account, with the Team that pays for models. */
+export declare function readFungiAccountTeams(input?: {
+    credentialPath?: string;
+    fetch?: FetchLike;
+}): Promise<FungiAccountTeams>;
+declare const teamBalanceSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    balance: z.ZodObject<{
+        amount: z.ZodString;
+        currency: z.ZodObject<{
+            code: z.ZodLiteral<"USD">;
+            base: z.ZodLiteral<10>;
+            exponent: z.ZodLiteral<2>;
+        }, z.core.$strip>;
+        scale: z.ZodLiteral<5>;
+    }, z.core.$strip>;
+    included: z.ZodNullable<z.ZodObject<{
+        granted: z.ZodObject<{
+            amount: z.ZodString;
+            currency: z.ZodObject<{
+                code: z.ZodLiteral<"USD">;
+                base: z.ZodLiteral<10>;
+                exponent: z.ZodLiteral<2>;
+            }, z.core.$strip>;
+            scale: z.ZodLiteral<5>;
+        }, z.core.$strip>;
+        remaining: z.ZodObject<{
+            amount: z.ZodString;
+            currency: z.ZodObject<{
+                code: z.ZodLiteral<"USD">;
+                base: z.ZodLiteral<10>;
+                exponent: z.ZodLiteral<2>;
+            }, z.core.$strip>;
+            scale: z.ZodLiteral<5>;
+        }, z.core.$strip>;
+        expiresAt: z.ZodNumber;
+    }, z.core.$strict>>;
+    reserved: z.ZodObject<{
+        amount: z.ZodString;
+        currency: z.ZodObject<{
+            code: z.ZodLiteral<"USD">;
+            base: z.ZodLiteral<10>;
+            exponent: z.ZodLiteral<2>;
+        }, z.core.$strip>;
+        scale: z.ZodLiteral<5>;
+    }, z.core.$strip>;
+    available: z.ZodObject<{
+        amount: z.ZodString;
+        currency: z.ZodObject<{
+            code: z.ZodLiteral<"USD">;
+            base: z.ZodLiteral<10>;
+            exponent: z.ZodLiteral<2>;
+        }, z.core.$strip>;
+        scale: z.ZodLiteral<5>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FungiTeamCredit = z.output<typeof teamBalanceSchema>;
+/**
+ * The selected Team's credit as the Hub billing read reports it. Refusals are
+ * typed absences: 404 the person is no longer a member, 403 this sign-in
+ * lacks the billing:read grant (signed in before it existed; sign in again),
+ * 401 the Hub does not admit this sign-in for billing.
+ */
+export type FungiTeamBalance = Readonly<{
+    kind: "balance";
+    credit: FungiTeamCredit;
+}> | Readonly<{
+    kind: "not-available";
+    reason: "no-team" | "not-a-member" | "sign-in-again" | "sign-in-not-admitted";
+}>;
+export declare function readFungiTeamBalance(input?: {
+    credentialPath?: string;
+    fetch?: FetchLike;
+}): Promise<FungiTeamBalance>;
+/**
+ * One cross-process credential lock serves MCP and model access, but only
+ * when the saved access token actually needs it: a plain read never takes
+ * the lock or rewrites the file, so a still-valid credential stays untouched.
+ */
+export declare function freshFungiAccess(rawHub: string | URL, input?: {
+    credentialPath?: string;
+    fetch?: FetchLike;
+    signal?: AbortSignal;
+    /** Compare inside the lock: another request may already have rotated it. */
+    rejectedAccess?: string;
+}): Promise<string>;
+/** Retry an explicitly refused request once; the cloned body is replayable. */
+export declare function fungiAccountFetch(rawHub: string | URL, input?: {
+    credentialPath?: string;
+    fetch?: FetchLike;
+    signal?: AbortSignal;
+}): typeof globalThis.fetch;
+/** The SDK owns exactly one retry; this hook rotates only the refused credential. */
+export declare function fungiMcpAccountAuth(endpoint: URL, input?: {
+    credentialPath?: string;
+    fetch?: FetchLike;
+    signal?: AbortSignal;
+}): AuthProvider;
+/** Selected payer metadata belongs to the shared account, never a model request body. */
+export declare function fungiAccountTeam(credential: Credential): FungiAccountTeam;
+/** Pi uses its own locked modify; this owner supplies the same refresh as MCP. */
+export declare function createFungiAccountOAuth(input?: {
+    credentialPath?: string;
+    fetch?: FetchLike;
+}): OAuthAuth;
+/** Pi deletion clears Local custody and reports unconfirmed remote revocation. */
+export declare function createFungiAccountCredentialStore(input?: {
+    credentialPath?: string;
+    fetch?: FetchLike;
+}): CredentialStore;
+export {};