@alpacakit/agents 0.1.0-beta.37 → 0.2.0-beta.2

package/dist/kernel/session.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Session driver pieces shared by the built-in hosts: the definition-side
+ * capability contract, the long-lived interactive child (spawn, NDJSON
+ * lines, EOF-first close), and the turn/event state
+ * every Session keeps. Protocol knowledge (what to write, how to read a
+ * line) stays in the adapter modules.
+ */
+import { AGENT_ERROR_CODE, AgentError } from "../core/error.js";
+import type { Clock, Exec, ExecExit, Logger } from "../core/ports.js";
+import { type Session, type SessionEvent, type SessionFacts, type TurnOutcome, type TurnResult } from "../core/session.js";
+import type { HostContext } from "../host/context.js";
+/** Resolved (rule 2): what a session adapter gets to open or resume. */
+export type SessionContext = {
+    /** Fully layered: baseEnv → options.env. */
+    env: Record<string, string>;
+    exec: Exec;
+    clock: Clock;
+    /** Pre-scoped to the session by the kernel. */
+    logger: Logger;
+};
+export type ResolvedSessionOpenOptions<Permissions> = {
+    workspace: string;
+    permissions: Permissions;
+};
+export type ResolvedSessionResumeOptions<Permissions> = ResolvedSessionOpenOptions<Permissions> & {
+    /** Codex only: unarchive an archived thread before resuming it. */
+    unarchive: boolean;
+};
+/** Definition-side session capability; absent = `Agent.session` is `null`. */
+export type SessionCapability<Permissions> = {
+    open(options: ResolvedSessionOpenOptions<Permissions>, ctx: SessionContext): Promise<Session>;
+    resume(id: string, options: ResolvedSessionResumeOptions<Permissions>, ctx: SessionContext): Promise<Session>;
+    inspect(id: string, ctx: HostContext): Promise<SessionFacts<Permissions> | null>;
+};
+export declare function assertHostSessionId(id: string, agentId: string): void;
+export declare function sessionStateError(agentId: string, reason: string): AgentError<typeof AGENT_ERROR_CODE.invalidInput>;
+export declare function sessionExitedError(agentId: string, exit: ExecExit | null, stderrTail: string): AgentError<typeof AGENT_ERROR_CODE.failed>;
+/**
+ * One interactive child held for the life of a Session: stdout is read as
+ * NDJSON lines, stdin stays open for incremental writes, and `close()`
+ * ends stdin first (both hosts exit on EOF) before escalating to signals.
+ */
+export declare class SessionProcess {
+    private readonly process;
+    private readonly clock;
+    private exitValue;
+    private stderrTail;
+    private constructor();
+    static spawn(input: {
+        command: string;
+        args: readonly string[];
+        cwd: string;
+        ctx: SessionContext;
+        agentId: string;
+    }): Promise<SessionProcess>;
+    get exit(): Promise<ExecExit>;
+    get exited(): ExecExit | null;
+    get stderr(): string;
+    writeLine(line: string): void;
+    /** Non-empty stdout lines in order; stderr is kept as a tail for errors. */
+    lines(): AsyncGenerator<string, void, void>;
+    close(): Promise<ExecExit>;
+}
+/**
+ * Turn bookkeeping and the event stream. Exactly one turn runs at a time:
+ * `send` needs idle, `steer`/`interrupt` need active — both are typed
+ * `invalid_input`, never a silent queue.
+ */
+export declare class SessionState {
+    private readonly agentId;
+    private readonly broadcast;
+    private active;
+    /** A turn whose start the host has not acknowledged yet (Codex `turn/start` in flight). */
+    private starting;
+    private ended;
+    constructor(agentId: string);
+    get events(): AsyncIterable<SessionEvent>;
+    get activeTurnId(): string | null;
+    get isEnded(): boolean;
+    get isStarting(): boolean;
+    emit(event: SessionEvent): void;
+    /** Record a message for the turn's fallback text and publish it. */
+    message(text: string): void;
+    requireOpen(): void;
+    requireIdle(): void;
+    /** Reserve the idle slot while the host is asked to start the turn. */
+    markStarting(): void;
+    /** The host refused to start the turn; the slot is idle again. */
+    clearStarting(): void;
+    requireActive(): string;
+    beginTurn(turnId: string): Promise<TurnResult>;
+    /** `text === null` falls back to the turn's collected messages. */
+    endTurn(outcome: TurnOutcome, text: string | null): void;
+    /** The process is gone: fail the running turn, publish `exited`, end the stream. */
+    end(exit: ExecExit, stderrTail: string): void;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/kernel/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/kernel/session.ts"],"names":[],"mappings":"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"}

package/dist/kernel/session.js

@@ -0,0 +1,255 @@
+/**
+ * Session driver pieces shared by the built-in hosts: the definition-side
+ * capability contract, the long-lived interactive child (spawn, NDJSON
+ * lines, EOF-first close), and the turn/event state
+ * every Session keeps. Protocol knowledge (what to write, how to read a
+ * line) stays in the adapter modules.
+ */
+import { AGENT_ERROR_CODE, AgentError, NOT_AVAILABLE_CAUSE, } from "../core/error.js";
+import { redactSecrets } from "../core/redact.js";
+import { SESSION_EVENT_TYPE, TURN_OUTCOME, } from "../core/session.js";
+import { endProcessGracefully } from "../core/process-close.js";
+import { OUTPUT_CHANNEL } from "../core/values.js";
+import { EventBroadcast } from "./handle.js";
+const OUTPUT_TAIL_CHARS = 2_000;
+const EVENT_BASE_COST_BYTES = 64;
+/** Both hosts use UUID-shaped conversation ids; anything else never reaches a path. */
+const HOST_SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+export function assertHostSessionId(id, agentId) {
+    if (HOST_SESSION_ID.test(id)) {
+        return;
+    }
+    throw new AgentError({
+        code: AGENT_ERROR_CODE.invalidInput,
+        classification: AgentError.agentFailure(AGENT_ERROR_CODE.invalidInput),
+        message: `Agent "${agentId}" session id is not a UUID`,
+        data: { reason: "session id must be a UUID" },
+        agentId,
+    });
+}
+function sessionEventCost(event) {
+    return (EVENT_BASE_COST_BYTES +
+        (event.type === SESSION_EVENT_TYPE.message ? event.text.length : 0));
+}
+function appendTail(current, next) {
+    const combined = current + next;
+    return combined.length <= OUTPUT_TAIL_CHARS
+        ? combined
+        : combined.slice(-OUTPUT_TAIL_CHARS);
+}
+export function sessionStateError(agentId, reason) {
+    return new AgentError({
+        code: AGENT_ERROR_CODE.invalidInput,
+        classification: AgentError.agentFailure(AGENT_ERROR_CODE.invalidInput),
+        message: `Agent "${agentId}" session: ${reason}`,
+        data: { reason },
+        agentId,
+    });
+}
+export function sessionExitedError(agentId, exit, stderrTail) {
+    const tail = redactSecrets(stderrTail);
+    return new AgentError({
+        code: AGENT_ERROR_CODE.failed,
+        classification: AgentError.agentFailure(AGENT_ERROR_CODE.failed),
+        message: `Agent "${agentId}" session process exited`,
+        data: {
+            exitCode: exit?.code ?? null,
+            stdoutTail: null,
+            stderrTail: tail === "" ? null : tail,
+        },
+        agentId,
+    });
+}
+/**
+ * One interactive child held for the life of a Session: stdout is read as
+ * NDJSON lines, stdin stays open for incremental writes, and `close()`
+ * ends stdin first (both hosts exit on EOF) before escalating to signals.
+ */
+export class SessionProcess {
+    process;
+    clock;
+    exitValue = null;
+    stderrTail = "";
+    constructor(process, clock) {
+        this.process = process;
+        this.clock = clock;
+        void process.exit.then((exit) => {
+            this.exitValue = exit;
+        }, () => {
+            this.exitValue = { code: null, signal: null };
+        });
+    }
+    static async spawn(input) {
+        const command = await input.ctx.exec.which(input.command, input.ctx.env);
+        if (command === null) {
+            throw new AgentError({
+                code: AGENT_ERROR_CODE.notAvailable,
+                classification: AgentError.agentFailure(AGENT_ERROR_CODE.notAvailable),
+                message: `Command "${input.command}" was not found on PATH`,
+                data: { cause: NOT_AVAILABLE_CAUSE.notInstalled },
+                agentId: input.agentId,
+            });
+        }
+        const process = input.ctx.exec.spawn({
+            command,
+            args: [...input.args],
+            cwd: input.cwd,
+            env: input.ctx.env,
+            stdin: null,
+            keepStdinOpen: true,
+        });
+        return new SessionProcess(process, input.ctx.clock);
+    }
+    get exit() {
+        return this.process.exit;
+    }
+    get exited() {
+        return this.exitValue;
+    }
+    get stderr() {
+        return this.stderrTail;
+    }
+    writeLine(line) {
+        this.process.writeStdin(`${line}\n`);
+    }
+    /** Non-empty stdout lines in order; stderr is kept as a tail for errors. */
+    async *lines() {
+        let pending = "";
+        for await (const chunk of this.process.chunks) {
+            if (chunk.channel === OUTPUT_CHANNEL.stderr) {
+                this.stderrTail = appendTail(this.stderrTail, chunk.text);
+                continue;
+            }
+            pending += chunk.text;
+            const lines = pending.split(/\r?\n/u);
+            pending = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed !== "") {
+                    yield trimmed;
+                }
+            }
+        }
+        const last = pending.trim();
+        if (last !== "") {
+            yield last;
+        }
+    }
+    close() {
+        if (this.exitValue !== null) {
+            return Promise.resolve(this.exitValue);
+        }
+        return endProcessGracefully(this.process, this.clock);
+    }
+}
+/**
+ * Turn bookkeeping and the event stream. Exactly one turn runs at a time:
+ * `send` needs idle, `steer`/`interrupt` need active — both are typed
+ * `invalid_input`, never a silent queue.
+ */
+export class SessionState {
+    agentId;
+    broadcast = new EventBroadcast(undefined, sessionEventCost);
+    active = null;
+    /** A turn whose start the host has not acknowledged yet (Codex `turn/start` in flight). */
+    starting = false;
+    ended = false;
+    constructor(agentId) {
+        this.agentId = agentId;
+    }
+    get events() {
+        return this.broadcast.events;
+    }
+    get activeTurnId() {
+        return this.active?.turnId ?? null;
+    }
+    get isEnded() {
+        return this.ended;
+    }
+    get isStarting() {
+        return this.starting;
+    }
+    emit(event) {
+        this.broadcast.push(event);
+    }
+    /** Record a message for the turn's fallback text and publish it. */
+    message(text) {
+        this.active?.messages.push(text);
+        this.emit({ type: SESSION_EVENT_TYPE.message, text });
+    }
+    requireOpen() {
+        if (this.ended) {
+            throw sessionStateError(this.agentId, "session is closed");
+        }
+    }
+    requireIdle() {
+        this.requireOpen();
+        if (this.active !== null || this.starting) {
+            throw sessionStateError(this.agentId, "a turn is in progress; use steer() or interrupt()");
+        }
+    }
+    /** Reserve the idle slot while the host is asked to start the turn. */
+    markStarting() {
+        this.starting = true;
+    }
+    /** The host refused to start the turn; the slot is idle again. */
+    clearStarting() {
+        this.starting = false;
+    }
+    requireActive() {
+        this.requireOpen();
+        if (this.active === null) {
+            throw sessionStateError(this.agentId, "no turn is in progress");
+        }
+        return this.active.turnId;
+    }
+    beginTurn(turnId) {
+        this.starting = false;
+        return new Promise((resolve, reject) => {
+            this.active = { turnId, messages: [], resolve, reject };
+            this.emit({ type: SESSION_EVENT_TYPE.turnStarted, turnId });
+        });
+    }
+    /** `text === null` falls back to the turn's collected messages. */
+    endTurn(outcome, text) {
+        const turn = this.active;
+        if (turn === null) {
+            return;
+        }
+        this.active = null;
+        this.emit({
+            type: SESSION_EVENT_TYPE.turnEnded,
+            turnId: turn.turnId,
+            outcome,
+        });
+        turn.resolve({
+            turnId: turn.turnId,
+            outcome,
+            text: text ?? turn.messages.join("\n"),
+        });
+    }
+    /** The process is gone: fail the running turn, publish `exited`, end the stream. */
+    end(exit, stderrTail) {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
+        this.starting = false;
+        const turn = this.active;
+        this.active = null;
+        if (turn !== null) {
+            this.emit({
+                type: SESSION_EVENT_TYPE.turnEnded,
+                turnId: turn.turnId,
+                outcome: TURN_OUTCOME.failed,
+            });
+            turn.reject(sessionExitedError(this.agentId, exit, stderrTail));
+        }
+        this.emit({
+            type: SESSION_EVENT_TYPE.exited,
+            code: exit.code,
+            signal: exit.signal,
+        });
+        this.broadcast.end();
+    }
+}

package/dist/testing/fake-exec.d.ts

@@ -13,6 +13,12 @@ export type FakeExecScript = {
         stderr(text: string): void;
         exit(exit: ExecExit): void;
     }) => void;
+    /** Runs when the caller ends stdin — script `controls.exit(...)` here for a child that exits on EOF. */
+    onStdinEnd?: (controls: {
+        stdout(text: string): void;
+        stderr(text: string): void;
+        exit(exit: ExecExit): void;
+    }) => void;
 };
 export type FakeExec = Exec & {
     readonly spawns: (ExecSpawnOptions | InteractiveExecSpawnOptions)[];

package/dist/testing/fake-exec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fake-exec.d.ts","sourceRoot":"","sources":["../../src/testing/fake-exec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,gBAAgB,EAEhB,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAG1B,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,6DAA6D;IAC7D,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,CACR,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE;QACR,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;KAC5B,KACE,IAAI,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,CAAC,gBAAgB,GAAG,2BAA2B,CAAC,EAAE,CAAC;IACpE,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;IACjC,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvC,CAAC;AAWF,wBAAgB,QAAQ,CAAC,OAAO,GAAE,cAAc,EAAO,GAAG,QAAQ,CAmFjE"}
+{"version":3,"file":"fake-exec.d.ts","sourceRoot":"","sources":["../../src/testing/fake-exec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,gBAAgB,EAEhB,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAG1B,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,6DAA6D;IAC7D,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,CACR,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE;QACR,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;KAC5B,KACE,IAAI,CAAC;IACV,wGAAwG;IACxG,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE;QACtB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;KAC5B,KAAK,IAAI,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,CAAC,gBAAgB,GAAG,2BAA2B,CAAC,EAAE,CAAC;IACpE,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;IACjC,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvC,CAAC;AAWF,wBAAgB,QAAQ,CAAC,OAAO,GAAE,cAAc,EAAO,GAAG,QAAQ,CAqFjE"}

package/dist/testing/fake-exec.js

@@ -56,7 +56,9 @@ export function fakeExec(scripts = []) {
                 writes.push(text);
                 script.onWrite?.(text, controls);
             },
-            endStdin: () => { },
+            endStdin: () => {
+                script.onStdinEnd?.(controls);
+            },
             kill: (signal) => {
                 killSignals.push(signal);
                 if (signal === PROCESS_SIGNAL.sigterm &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alpacakit/agents",
-  "version": "0.1.0-beta.37",
+  "version": "0.2.0-beta.2",
   "description": "Run AI coding agents programmatically: execute, stream, classify failures, fail over.",
   "license": "MIT",
   "type": "module",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "zod": "^4.3.6",
-    "@alpacakit/core": "0.1.0-beta.37"
+    "@alpacakit/core": "0.2.0-beta.2"
   },
   "devDependencies": {
     "typescript": "^5.9.3",

package/dist/auth/profile-store.d.ts

@@ -1,14 +0,0 @@
-/**
- * Minimal file-backed profile store (A11): rows follow rule 2 and never
- * contain secret values (A9) — materials carry refs and paths only.
- * Profile management UX is consumer territory. Unlike fleet state, this
- * is durable user data: malformed or unknown-version files are typed
- * errors, never silent resets.
- */
-import { type AuthProfile } from "./material.js";
-export interface ProfileStore {
-    list(): Promise<AuthProfile[]>;
-    save(profiles: AuthProfile[]): Promise<void>;
-}
-export declare function fileProfileStore(filePath: string): ProfileStore;
-//# sourceMappingURL=profile-store.d.ts.map

package/dist/auth/profile-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"profile-store.d.ts","sourceRoot":"","sources":["../../src/auth/profile-store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAcrE,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAC/B,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C;AA+FD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,CAE/D"}

package/dist/auth/profile-store.js

@@ -1,102 +0,0 @@
-/**
- * Minimal file-backed profile store (A11): rows follow rule 2 and never
- * contain secret values (A9) — materials carry refs and paths only.
- * Profile management UX is consumer territory. Unlike fleet state, this
- * is durable user data: malformed or unknown-version files are typed
- * errors, never silent resets.
- */
-import { readFile } from "node:fs/promises";
-import { AGENT_ERROR_CODE, AgentError } from "../core/error.js";
-import { isErrnoCode, writeFileAtomically } from "../core/fs.js";
-import { readUnknownRecord } from "../core/json.js";
-import { TEXT_ENCODING } from "../core/values.js";
-import { AUTH_MATERIAL_KIND } from "./material.js";
-const PROFILE_FILE_VERSION = 1;
-const PROFILE_STORE_ERROR_REASON = {
-    unreadable: "unreadable file",
-    malformedJson: "malformed JSON",
-    rootMustBeObject: "root must be an object",
-    unsupportedVersion: "unsupported version",
-    invalidProfiles: "profiles must be auth profile records",
-};
-function profileStoreError(reason, cause) {
-    return new AgentError({
-        code: AGENT_ERROR_CODE.invalidInput,
-        classification: AgentError.agentFailure(AGENT_ERROR_CODE.invalidInput),
-        message: `Invalid auth profile store: ${reason}`,
-        data: { reason },
-        ...(cause === undefined ? {} : { cause }),
-    });
-}
-function isSecretRef(value) {
-    const record = readUnknownRecord(value);
-    if (record === null) {
-        return false;
-    }
-    const { resolver, id } = record;
-    return typeof resolver === "string" && typeof id === "string";
-}
-function isAuthProfile(value) {
-    const record = readUnknownRecord(value);
-    if (record === null) {
-        return false;
-    }
-    const { id, agentId, material: materialValue } = record;
-    const material = readUnknownRecord(materialValue);
-    if (material === null) {
-        return false;
-    }
-    const { kind, path, secret } = material;
-    const materialValid = (kind === AUTH_MATERIAL_KIND.homeDir && typeof path === "string") ||
-        (kind === AUTH_MATERIAL_KIND.apiKey && isSecretRef(secret));
-    return typeof id === "string" && typeof agentId === "string" && materialValid;
-}
-function parseProfileFile(raw) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (error) {
-        throw profileStoreError(PROFILE_STORE_ERROR_REASON.malformedJson, error);
-    }
-    const root = readUnknownRecord(parsed);
-    if (root === null) {
-        throw profileStoreError(PROFILE_STORE_ERROR_REASON.rootMustBeObject);
-    }
-    const { version, profiles } = root;
-    if (version !== PROFILE_FILE_VERSION) {
-        throw profileStoreError(PROFILE_STORE_ERROR_REASON.unsupportedVersion);
-    }
-    if (!Array.isArray(profiles) || !profiles.every(isAuthProfile)) {
-        throw profileStoreError(PROFILE_STORE_ERROR_REASON.invalidProfiles);
-    }
-    return profiles;
-}
-class FileProfileStore {
-    filePath;
-    constructor(filePath) {
-        this.filePath = filePath;
-    }
-    async list() {
-        let raw;
-        try {
-            raw = await readFile(this.filePath, TEXT_ENCODING);
-        }
-        catch (error) {
-            // Durable user data: only "not created yet" reads as empty; any
-            // other read failure surfaces instead of masking real profiles.
-            if (isErrnoCode(error, "ENOENT")) {
-                return [];
-            }
-            throw profileStoreError(PROFILE_STORE_ERROR_REASON.unreadable, error);
-        }
-        return parseProfileFile(raw);
-    }
-    async save(profiles) {
-        const file = { version: PROFILE_FILE_VERSION, profiles };
-        await writeFileAtomically(this.filePath, `${JSON.stringify(file, null, 2)}\n`);
-    }
-}
-export function fileProfileStore(filePath) {
-    return new FileProfileStore(filePath);
-}

package/dist/keyring/index.d.ts

@@ -1,2 +0,0 @@
-export { keyringResolver, type KeyringResolverOptions, } from "./resolver.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/keyring/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/keyring/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,sBAAsB,GAC5B,MAAM,eAAe,CAAC"}

package/dist/keyring/index.js

@@ -1 +0,0 @@
-export { keyringResolver, } from "./resolver.js";

package/dist/keyring/resolver.d.ts

@@ -1,9 +0,0 @@
-import type { SecretResolver } from "../core/ports.js";
-export type KeyringResolverOptions = {
-    readonly service: string;
-};
-type KeyringModuleLoader = () => Promise<unknown>;
-export declare function keyringResolver(options: KeyringResolverOptions): SecretResolver;
-export declare function createKeyringResolver(options: KeyringResolverOptions, loader: KeyringModuleLoader): SecretResolver;
-export {};
-//# sourceMappingURL=resolver.d.ts.map

package/dist/keyring/resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/keyring/resolver.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,KAAK,mBAAmB,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;AAiBlD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,sBAAsB,GAC9B,cAAc,CAEhB;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,EAC/B,MAAM,EAAE,mBAAmB,GAC1B,cAAc,CA4BhB"}

package/dist/keyring/resolver.js

@@ -1,64 +0,0 @@
-// biome-ignore-all lint/style/useNamingConvention: Keyring peer exports mirror upstream PascalCase names.
-import { AGENT_ERROR_CODE, AgentError, NOT_AVAILABLE_CAUSE, } from "../core/error.js";
-const KEYRING_PEER_PACKAGE = "@napi-rs/keyring";
-const KEYRING_ENTRY_EXPORT = "Entry";
-const EMPTY_SECRET_VALUE = "";
-const defaultKeyringModuleLoader = () => import(KEYRING_PEER_PACKAGE);
-export function keyringResolver(options) {
-    return createKeyringResolver(options, defaultKeyringModuleLoader);
-}
-export function createKeyringResolver(options, loader) {
-    const service = options.service;
-    let modulePromise = null;
-    const load = () => {
-        modulePromise ??= loadKeyringModule(loader);
-        return modulePromise;
-    };
-    return {
-        resolve: async (id) => {
-            const module = await load();
-            try {
-                // Absent entries are the `null` return (`Entry.getPassword():
-                // string | null` in @napi-rs/keyring); anything thrown is a real
-                // keychain failure, never "missing secret".
-                const value = await new module.Entry(service, id).getPassword();
-                return value === EMPTY_SECRET_VALUE ? null : value;
-            }
-            catch (error) {
-                throw new AgentError({
-                    code: AGENT_ERROR_CODE.failed,
-                    classification: AgentError.agentFailure(AGENT_ERROR_CODE.failed),
-                    message: `Keyring secret "${id}" could not be read`,
-                    data: { exitCode: null, stdoutTail: null, stderrTail: null },
-                    cause: error,
-                });
-            }
-        },
-    };
-}
-async function loadKeyringModule(loader) {
-    let loaded;
-    try {
-        loaded = await loader();
-    }
-    catch (error) {
-        throw keyringNotInstalledError(error);
-    }
-    if (typeof loaded !== "object" || loaded === null) {
-        throw keyringNotInstalledError(null);
-    }
-    const entry = Reflect.get(loaded, KEYRING_ENTRY_EXPORT);
-    if (typeof entry !== "function") {
-        throw keyringNotInstalledError(null);
-    }
-    return { Entry: entry };
-}
-function keyringNotInstalledError(cause) {
-    return new AgentError({
-        code: AGENT_ERROR_CODE.notAvailable,
-        classification: AgentError.agentFailure(AGENT_ERROR_CODE.notAvailable),
-        message: "Keyring peer is not installed",
-        data: { cause: NOT_AVAILABLE_CAUSE.notInstalled },
-        cause,
-    });
-}