@fungi.computer/truffle 0.1.1 → 0.2.0

package/dist/local-skill-source.js

@@ -1,6 +1,5 @@
 import { open, opendir, realpath, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve, } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { z } from "zod";
 const maximumSkillCount = 64;
@@ -44,6 +43,23 @@ function contained(root, path) {
         throw new Error("Skill path escapes its directory");
     return path;
 }
+function inside(root, path) {
+    const within = relative(root, path);
+    return within === "" ||
+        isAbsolute(within) ||
+        within === ".." ||
+        within.startsWith(`..${sep}`)
+        ? undefined
+        : within;
+}
+/** The model's view of a skill file: invocation-relative, `~/…`, else absolute. */
+function displayLocation(location, roots) {
+    const project = inside(roots.cwd, location);
+    if (project !== undefined)
+        return project;
+    const personal = inside(roots.home, location);
+    return personal === undefined ? location : join("~", personal);
+}
 async function readBounded(path, signal) {
     signal.throwIfAborted();
     const handle = await open(path, "r");
@@ -144,166 +160,226 @@ async function configuredRoots(path, base, home, signal, diagnostics) {
         return [];
     }
 }
-/** Discover project-first skills without widening the invocation Files jail. */
-export function createLocalSkillSource(options) {
-    const cwd = resolve(options.cwd);
-    const home = resolve(options.home ?? homedir());
-    const catalog = async (signal) => {
-        const skills = [];
-        const diagnostics = [];
-        const names = new Set();
-        const paths = new Set();
-        const projectExtras = await configuredRoots(join(cwd, ".fungi/settings.json"), cwd, home, signal, diagnostics);
-        const personalExtras = await configuredRoots(join(home, ".fungi/settings.json"), join(home, ".fungi"), home, signal, diagnostics);
-        const extras = new Set([...projectExtras, ...personalExtras]);
-        const roots = [
-            ...(await discoveryRoots(cwd)),
-            ...projectExtras,
-            join(home, ".fungi/skills"),
-            join(home, ".agents/skills"),
-            ...personalExtras,
-        ];
-        const visitedRoots = new Set();
-        for (const path of roots) {
+function describeOrigin(origin) {
+    return origin.kind === "extension"
+        ? `extension ${origin.extensionId}`
+        : origin.kind;
+}
+/** Walk labeled roots in order; the first skill with a name wins. */
+async function scanRoots(roots, displayRoots, signal, diagnostics) {
+    const skills = [];
+    const owners = new Map();
+    const paths = new Set();
+    const visitedRoots = new Set();
+    for (const { path, origin, named } of roots) {
+        signal.throwIfAborted();
+        let root;
+        try {
+            root = await realpath(path);
+        }
+        catch (cause) {
+            signal.throwIfAborted();
+            if (!absent(cause) || named)
+                diagnostics.push({
+                    path,
+                    reason: "unavailable",
+                    message: "Skill root is unavailable",
+                    cause,
+                });
+            continue;
+        }
+        if (visitedRoots.has(root))
+            continue;
+        visitedRoots.add(root);
+        const visited = new Set();
+        let entries = 0;
+        let found = 0;
+        const before = diagnostics.length;
+        const walk = async (directory, depth) => {
             signal.throwIfAborted();
-            let root;
+            if (depth > maximumDiscoveryDepth) {
+                diagnostics.push(diagnostic(directory, "bound", "Skill discovery exceeds its 16-level depth bound"));
+                return;
+            }
+            if (visited.has(directory))
+                return;
+            visited.add(directory);
+            const skillPath = join(directory, "SKILL.md");
+            let location;
             try {
-                root = await realpath(path);
+                location = contained(directory, await realpath(skillPath));
             }
             catch (cause) {
                 signal.throwIfAborted();
-                if (!absent(cause) || extras.has(path))
+                if (!absent(cause)) {
                     diagnostics.push({
-                        path,
-                        reason: "unavailable",
-                        message: "Skill root is unavailable",
+                        path: skillPath,
+                        reason: "invalid",
+                        message: "Skill file escapes its directory or cannot be read",
                         cause,
                     });
-                continue;
-            }
-            if (visitedRoots.has(root))
-                continue;
-            visitedRoots.add(root);
-            const visited = new Set();
-            let entries = 0;
-            let found = 0;
-            const before = diagnostics.length;
-            const walk = async (directory, depth) => {
-                signal.throwIfAborted();
-                if (depth > maximumDiscoveryDepth) {
-                    diagnostics.push(diagnostic(directory, "bound", "Skill discovery exceeds its 16-level depth bound"));
                     return;
                 }
-                if (visited.has(directory))
-                    return;
-                visited.add(directory);
-                const skillPath = join(directory, "SKILL.md");
-                let location;
+            }
+            if (location !== undefined) {
+                found++;
                 try {
-                    location = contained(directory, await realpath(skillPath));
-                }
-                catch (cause) {
-                    signal.throwIfAborted();
-                    if (!absent(cause)) {
-                        diagnostics.push({
-                            path: skillPath,
-                            reason: "invalid",
-                            message: "Skill file escapes its directory or cannot be read",
-                            cause,
-                        });
+                    if (paths.has(location))
+                        return;
+                    paths.add(location);
+                    const { metadata } = parseSkill(await readBounded(location, signal), directory);
+                    if (!nameSchema.safeParse(metadata.name).success ||
+                        metadata.name !== basename(directory))
+                        diagnostics.push(diagnostic(skillPath, "warning", "Skill name should match its directory, use lowercase letters, digits and single hyphens, and be at most 64 characters"));
+                    if (metadata.description.length > 1_024)
+                        diagnostics.push(diagnostic(skillPath, "warning", "Skill description exceeds the recommended 1024 characters"));
+                    const winner = owners.get(metadata.name);
+                    if (winner !== undefined) {
+                        diagnostics.push(diagnostic(skillPath, "collision", `${describeOrigin(winner)} skill ${metadata.name} wins over ${describeOrigin(origin)}`));
                         return;
                     }
-                }
-                if (location !== undefined) {
-                    found++;
-                    try {
-                        if (paths.has(location))
-                            return;
-                        paths.add(location);
-                        const { metadata } = parseSkill(await readBounded(location, signal), directory);
-                        if (!nameSchema.safeParse(metadata.name).success ||
-                            metadata.name !== basename(directory))
-                            diagnostics.push(diagnostic(skillPath, "warning", "Skill name should match its directory, use lowercase letters, digits and single hyphens, and be at most 64 characters"));
-                        if (metadata.description.length > 1_024)
-                            diagnostics.push(diagnostic(skillPath, "warning", "Skill description exceeds the recommended 1024 characters"));
-                        if (names.has(metadata.name)) {
-                            diagnostics.push(diagnostic(skillPath, "collision", "Earlier skill with this name wins"));
-                            return;
-                        }
-                        names.add(metadata.name);
-                        if (metadata["disable-model-invocation"]) {
-                            diagnostics.push(diagnostic(skillPath, "skipped", "Skill disables model invocation"));
-                            return;
-                        }
-                        const skill = {
-                            name: metadata.name,
-                            description: metadata.description,
-                            location,
-                        };
-                        if (skills.length >= maximumSkillCount ||
-                            utf8.encode(JSON.stringify([...skills, skill])).byteLength >
-                                maximumCatalogBytes) {
-                            diagnostics.push(diagnostic(skillPath, "bound", "Skill catalog exceeds its 64-skill or 16 KB bound"));
-                            return;
-                        }
-                        skills.push(skill);
+                    owners.set(metadata.name, origin);
+                    if (metadata["disable-model-invocation"]) {
+                        diagnostics.push(diagnostic(skillPath, "skipped", "Skill disables model invocation"));
+                        return;
                     }
-                    catch (cause) {
-                        signal.throwIfAborted();
-                        diagnostics.push({
-                            path: skillPath,
-                            reason: "invalid",
-                            message: explanation(cause, "Skill metadata or file is invalid"),
-                            cause,
-                        });
+                    const skill = {
+                        name: metadata.name,
+                        description: metadata.description,
+                        location,
+                        displayLocation: displayLocation(location, displayRoots),
+                        origin,
+                    };
+                    if (skills.length >= maximumSkillCount ||
+                        utf8.encode(JSON.stringify([...skills, skill])).byteLength >
+                            maximumCatalogBytes) {
+                        diagnostics.push(diagnostic(skillPath, "bound", "Skill catalog exceeds its 64-skill or 16 KB bound"));
+                        return;
                     }
-                    return;
+                    skills.push(skill);
                 }
-                const children = [];
-                for await (const entry of await opendir(directory)) {
+                catch (cause) {
                     signal.throwIfAborted();
-                    if (++entries > maximumDirectoryEntries)
-                        throw new SkillSourceError("Skill discovery exceeds its 512-entry bound");
-                    if (entry.name.startsWith(".") || entry.name === "node_modules") {
-                        if (entry.isDirectory() || entry.isSymbolicLink())
-                            diagnostics.push(diagnostic(join(directory, entry.name), "skipped", "Dot directories and node_modules are not searched"));
-                        continue;
-                    }
-                    children.push(entry.name);
-                }
-                for (const child of children.sort()) {
-                    const candidate = join(directory, child);
-                    try {
-                        const canonical = contained(root, await realpath(candidate));
-                        if ((await stat(canonical)).isDirectory())
-                            await walk(canonical, depth + 1);
-                    }
-                    catch (cause) {
-                        signal.throwIfAborted();
-                        if (cause instanceof SkillSourceError)
-                            throw cause;
-                        diagnostics.push(diagnostic(join(candidate, "SKILL.md"), "invalid", "Skill entry escapes its root or is unavailable", cause));
-                    }
+                    diagnostics.push({
+                        path: skillPath,
+                        reason: "invalid",
+                        message: explanation(cause, "Skill metadata or file is invalid"),
+                        cause,
+                    });
                 }
-            };
-            try {
-                await walk(root, 0);
-                if (found === 0 && diagnostics.length === before)
-                    diagnostics.push(diagnostic(path, "empty", entries === 0
-                        ? "Skill root is empty"
-                        : "Skill root contains no SKILL.md files"));
+                return;
             }
-            catch (cause) {
+            const children = [];
+            for await (const entry of await opendir(directory)) {
                 signal.throwIfAborted();
-                diagnostics.push({
-                    path,
-                    reason: cause instanceof SkillSourceError ? "bound" : "unavailable",
-                    message: explanation(cause, "Skill root cannot be searched"),
-                    cause,
-                });
+                if (++entries > maximumDirectoryEntries)
+                    throw new SkillSourceError("Skill discovery exceeds its 512-entry bound");
+                if (entry.name.startsWith(".") || entry.name === "node_modules") {
+                    if (entry.isDirectory() || entry.isSymbolicLink())
+                        diagnostics.push(diagnostic(join(directory, entry.name), "skipped", "Dot directories and node_modules are not searched"));
+                    continue;
+                }
+                children.push(entry.name);
+            }
+            for (const child of children.sort()) {
+                const candidate = join(directory, child);
+                try {
+                    const canonical = contained(root, await realpath(candidate));
+                    if ((await stat(canonical)).isDirectory())
+                        await walk(canonical, depth + 1);
+                }
+                catch (cause) {
+                    signal.throwIfAborted();
+                    if (cause instanceof SkillSourceError)
+                        throw cause;
+                    diagnostics.push(diagnostic(join(candidate, "SKILL.md"), "invalid", "Skill entry escapes its root or is unavailable", cause));
+                }
             }
+        };
+        try {
+            await walk(root, 0);
+            if (found === 0 && diagnostics.length === before)
+                diagnostics.push(diagnostic(path, "empty", entries === 0
+                    ? "Skill root is empty"
+                    : "Skill root contains no SKILL.md files"));
         }
-        return { skills, diagnostics };
+        catch (cause) {
+            signal.throwIfAborted();
+            diagnostics.push({
+                path,
+                reason: cause instanceof SkillSourceError ? "bound" : "unavailable",
+                message: explanation(cause, "Skill root cannot be searched"),
+                cause,
+            });
+        }
+    }
+    return { skills, diagnostics };
+}
+/** What an extension's skills folder offers, for the install prompt. */
+export function describeExtensionSkills(folder, signal) {
+    // The install prompt lists names only, so display paths are never shown.
+    return scanRoots([
+        {
+            path: folder.directory,
+            origin: { kind: "extension", extensionId: folder.extensionId },
+            named: true,
+        },
+    ], { cwd: folder.directory, home: folder.directory }, signal, []);
+}
+/**
+ * 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 function createLocalSkillSource(options) {
+    const cwd = resolve(options.cwd);
+    const home = resolve(options.home);
+    // Skill files are canonical paths, so compare them with canonical roots.
+    // A root that does not exist has no symlinks to resolve; any other failure
+    // (permissions, loops) propagates to the caller.
+    const canonical = async (path) => {
+        try {
+            return await realpath(path);
+        }
+        catch (cause) {
+            if (absent(cause))
+                return path;
+            throw cause;
+        }
+    };
+    const catalog = async (signal) => {
+        const displayRoots = {
+            cwd: await canonical(cwd),
+            home: await canonical(home),
+        };
+        const diagnostics = [];
+        const projectExtras = await configuredRoots(join(cwd, ".fungi/settings.json"), cwd, home, signal, diagnostics);
+        const personalExtras = await configuredRoots(join(home, ".fungi/settings.json"), join(home, ".fungi"), home, signal, diagnostics);
+        const project = { kind: "project" };
+        const personal = { kind: "personal" };
+        const roots = [
+            ...(await discoveryRoots(cwd)).map((path) => ({
+                path,
+                origin: project,
+                named: false,
+            })),
+            ...projectExtras.map((path) => ({ path, origin: project, named: true })),
+            ...[join(home, ".fungi/skills"), join(home, ".agents/skills")].map((path) => ({ path, origin: personal, named: false })),
+            ...personalExtras.map((path) => ({
+                path,
+                origin: personal,
+                named: true,
+            })),
+            ...(options.extensions ?? []).map(({ extensionId, directory }) => ({
+                path: directory,
+                origin: { kind: "extension", extensionId },
+                named: true,
+            })),
+        ];
+        return scanRoots(roots, displayRoots, signal, diagnostics);
     };
     return {
         catalog,

package/dist/log-event.d.ts

@@ -1,2 +1,9 @@
+export type LocalFailureMetadata = Readonly<{
+    source: "local-runtime";
+    operation: string;
+    failureKind: "Error" | "NonErrorThrown";
+}>;
+/** The only persistable projection of a caught Local failure. */
+export declare function localFailureMetadata(operation: string, cause: unknown): LocalFailureMetadata;
 /** Retain the original Local failure without printing exception or input text. */
 export declare function logEvent(operation: string, cause: unknown): void;

package/dist/log-event.js

@@ -1,9 +1,13 @@
 import * as Redacted from "effect/Redacted";
-/** Retain the original Local failure without printing exception or input text. */
-export function logEvent(operation, cause) {
-    globalThis.console.error(JSON.stringify({
+/** The only persistable projection of a caught Local failure. */
+export function localFailureMetadata(operation, cause) {
+    return {
         source: "local-runtime",
         operation,
         failureKind: cause instanceof Error ? "Error" : "NonErrorThrown",
-    }), Redacted.make(cause));
+    };
+}
+/** Retain the original Local failure without printing exception or input text. */
+export function logEvent(operation, cause) {
+    globalThis.console.error(JSON.stringify(localFailureMetadata(operation, cause)), Redacted.make(cause));
 }

package/dist/private-bounded-response.d.ts

@@ -0,0 +1,2 @@
+/** Local HTTP response budget, checked before text/JSON/schema decoding. */
+export declare function readBoundedResponse(response: Response, maximumBytes: number, description: string): Promise<string>;

package/dist/private-bounded-response.js

@@ -0,0 +1,41 @@
+/** Local HTTP response budget, checked before text/JSON/schema decoding. */
+export async function readBoundedResponse(response, maximumBytes, description) {
+    const declared = response.headers.get("content-length");
+    if (declared !== null) {
+        const declaredBytes = Number(declared);
+        if (!Number.isSafeInteger(declaredBytes) ||
+            declaredBytes < 0 ||
+            declaredBytes > maximumBytes)
+            throw new Error(`${description} response is too large`);
+    }
+    if (response.body === null)
+        throw new Error(`${description} returned no body`);
+    const stream = response.body.pipeThrough(new TransformStream());
+    const reader = stream.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            const bytes = next.value;
+            size += bytes.byteLength;
+            if (size > maximumBytes) {
+                await reader.cancel();
+                throw new Error(`${description} response is too large`);
+            }
+            chunks.push(bytes);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const joined = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        joined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(joined);
+}

package/dist/private-file-credential-store.d.ts

@@ -1,24 +1,46 @@
+import { type MachineEnrollmentRecord, type LocalMachineEnrollment } from "./private-local-mesh-record.js";
 import type { AuthOperationOptions, Credential, CredentialInfo, CredentialStore } from "@earendil-works/pi-ai";
+import { z } from "zod";
 export declare const maximumCredentialStringLength: number;
+export declare const oauthCredentialSchema: z.ZodObject<{
+    type: z.ZodLiteral<"oauth">;
+    refresh: z.ZodString;
+    access: z.ZodString;
+    expires: z.ZodNumber;
+}, z.core.$catchall<z.ZodJSONSchema>>;
 export type AtomicWrite = (path: string, content: string, options: Readonly<{
     encoding: BufferEncoding;
     fsync: boolean;
     mode: number;
 }>) => Promise<void>;
+/** The signed-in credential that must still own an enrollment origin. */
+export type MachineEnrollmentOwner = Readonly<{
+    providerId: string;
+    /** Throws unless this credential owns the origin being edited. */
+    admit: (current: Credential | undefined) => void;
+}>;
 /** A host-private Pi credential store selected by one absolute filesystem path. */
 export type PrivateCredentialStore = CredentialStore & {
+    readMachineEnrollments(): Promise<MachineEnrollmentRecord[]>;
+    /**
+     * Edit one origin's enrollments under the file lock. An empty result removes
+     * the record. When the origin belongs to a signed-in credential, `owner`
+     * admits that credential under the same lock before anything is written.
+     */
+    modifyMachineEnrollments(origin: string, edit: (current: readonly LocalMachineEnrollment[]) => LocalMachineEnrollment[], owner?: MachineEnrollmentOwner): Promise<void>;
+    removeMachineEnrollments(origin: string): Promise<boolean>;
     /** Stable host identity supplied to Pi's ChatGPT sign-in, never a credential. */
     getDeviceId(): Promise<string>;
     /** Revoke or validate current custody under the same lock, then delete it atomically. */
     remove<T>(providerId: string, beforeRemove: (credential: Credential) => Promise<T>, options?: AuthOperationOptions): Promise<T | undefined>;
 };
 /** Resolve the host-owned default path without consulting project or Agent Home state. */
-export declare function resolveDefaultCredentialPath(home?: string): string;
+export declare function resolveDefaultCredentialPath(home: string): string;
 /**
  * Internal constructor permits one focused write-failure test while the public
  * package surface remains the Pi CredentialStore factory below.
  */
-export declare class FileCredentialStore implements CredentialStore {
+export declare class FileCredentialStore implements PrivateCredentialStore {
     #private;
     constructor(path: string, writeAtomic?: AtomicWrite);
     /** Keep the installation UUID beside credentials, across logout and restart. */
@@ -27,7 +49,10 @@ export declare class FileCredentialStore implements CredentialStore {
     list(options?: AuthOperationOptions): Promise<readonly CredentialInfo[]>;
     modify(providerId: string, callback: (current: Credential | undefined) => Promise<Credential | undefined>, options?: AuthOperationOptions): Promise<Credential | undefined>;
     delete(providerId: string, options?: AuthOperationOptions): Promise<void>;
+    readMachineEnrollments(): Promise<MachineEnrollmentRecord[]>;
+    modifyMachineEnrollments(origin: string, edit: (current: readonly LocalMachineEnrollment[]) => LocalMachineEnrollment[], owner?: MachineEnrollmentOwner): Promise<void>;
+    removeMachineEnrollments(origin: string): Promise<boolean>;
     remove<T>(providerId: string, beforeRemove: (credential: Credential) => Promise<T>, options?: AuthOperationOptions): Promise<T | undefined>;
 }
 /** Create the one private Pi CredentialStore selected by the local host. */
-export declare function createPrivateCredentialStore(path?: string): PrivateCredentialStore;
+export declare function createPrivateCredentialStore(path: string): PrivateCredentialStore;

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

@@ -1,6 +1,7 @@
 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 { homedir } from "node:os";
 import { dirname, isAbsolute, resolve } from "node:path";
 import lockfile from "proper-lockfile";
 import writeFileAtomic from "write-file-atomic";
@@ -45,7 +46,7 @@ const apiKeyCredentialSchema = z
         credential.env = input.env;
     return credential;
 });
-const oauthCredentialSchema = z
+export const oauthCredentialSchema = z
     .object({
     type: z.literal("oauth"),
     refresh: credentialStringSchema,
@@ -72,10 +73,19 @@ const oauthCredentialSchema = z
 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",
@@ -85,7 +95,7 @@ const credentialMapSchema = z
 });
 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 = homedir()) {
+export function resolveDefaultCredentialPath(home) {
     if (!isAbsolute(home)) {
         throw new Error("Default credential home must be absolute");
     }
@@ -98,7 +108,8 @@ function ownCredential(credentials, providerId) {
     if (credentials === undefined || !Object.hasOwn(credentials, providerId)) {
         return undefined;
     }
-    return credentials[providerId];
+    const record = credentials[providerId];
+    return record?.type === "machine_enrollment" ? undefined : record;
 }
 function parseCredentials(serialized) {
     let parsed;
@@ -172,16 +183,17 @@ export class FileCredentialStore {
         const credentials = await this.#readCredentials();
         if (credentials === undefined)
             return [];
-        return Object.entries(credentials).map(([providerId, credential]) => ({
-            providerId,
-            type: credential.type,
-        }));
+        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();
@@ -202,6 +214,42 @@ export class FileCredentialStore {
     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 () => {
@@ -278,6 +326,6 @@ export class FileCredentialStore {
     }
 }
 /** Create the one private Pi CredentialStore selected by the local host. */
-export function createPrivateCredentialStore(path = resolveDefaultCredentialPath()) {
+export function createPrivateCredentialStore(path) {
     return new FileCredentialStore(path);
 }