@aria-cli/cli 1.0.51 → 1.0.54

package/dist/headless/stdio-server.js

@@ -1,439 +0,0 @@
-import { HEADLESS_OPERATION_SCHEMAS, HeadlessInteractionResponseSchema, HeadlessRequestIdSchema, } from "@aria-cli/tools";
-import { createHeadlessKernelRuntime } from "./kernel.js";
-const DISPATCH_ITERATOR_CLEANUP_TIMEOUT_MS = 200;
-const RUNTIME_RELEASE_CLEANUP_GRACE_MS = 500;
-function createFrameWriter(stream = process.stdout) {
-    let outputFailed = false;
-    const handleStreamError = () => {
-        outputFailed = true;
-    };
-    stream.on?.("error", handleStreamError);
-    const writer = ((frame) => {
-        if (outputFailed) {
-            return false;
-        }
-        try {
-            stream.write(`${JSON.stringify(frame)}\n`);
-            return true;
-        }
-        catch {
-            outputFailed = true;
-            return false;
-        }
-    });
-    writer.close = () => {
-        stream.off?.("error", handleStreamError);
-    };
-    return writer;
-}
-function parseClientFrame(line, parseErrorSeq, writeFrame) {
-    let raw;
-    try {
-        raw = JSON.parse(line);
-    }
-    catch {
-        writeFrame({
-            kind: "result",
-            requestId: `parse-error-${parseErrorSeq}`,
-            op: "unknown",
-            ok: false,
-            error: {
-                code: "PARSE_ERROR",
-                message: "Malformed JSON input",
-            },
-        });
-        return null;
-    }
-    if (!raw || typeof raw !== "object") {
-        writeFrame({
-            kind: "result",
-            requestId: `parse-error-${parseErrorSeq}`,
-            op: "unknown",
-            ok: false,
-            error: {
-                code: "PARSE_ERROR",
-                message: "Input must be a JSON object",
-            },
-        });
-        return null;
-    }
-    const record = raw;
-    if (record.kind === "interaction.respond" &&
-        HeadlessRequestIdSchema.safeParse(record.requestId).success &&
-        typeof record.interactionId === "string") {
-        return record;
-    }
-    if (record.kind === "request" &&
-        HeadlessRequestIdSchema.safeParse(record.requestId).success &&
-        typeof record.op === "string") {
-        return record;
-    }
-    writeFrame({
-        kind: "result",
-        requestId: `parse-error-${parseErrorSeq}`,
-        op: "unknown",
-        ok: false,
-        error: {
-            code: "PARSE_ERROR",
-            message: "Missing required kind/requestId/op fields",
-        },
-    });
-    return null;
-}
-export async function startHeadlessStdioServer(options) {
-    const writeFrame = createFrameWriter();
-    let runtimePromise = null;
-    let runtime = null;
-    let runtimeReleasePromise = null;
-    const inFlight = new Set();
-    const seenRequestIds = new Set();
-    const pendingIteratorCleanup = new Set();
-    const active = new Map();
-    let parseErrorSeq = 0;
-    let shutdownPromise = null;
-    let inputBuffer = "";
-    let inputClosed = false;
-    let serverDoneResolved = false;
-    let resolveServerDone = null;
-    const serverDone = new Promise((resolve) => {
-        resolveServerDone = () => {
-            if (serverDoneResolved) {
-                return;
-            }
-            serverDoneResolved = true;
-            resolve();
-        };
-    });
-    const ensureRuntime = () => {
-        runtimePromise ??= createHeadlessKernelRuntime(options).then((created) => {
-            runtime = created;
-            return created;
-        });
-        return runtimePromise;
-    };
-    const releaseRuntime = () => {
-        runtimeReleasePromise ??= (async () => {
-            if (runtime) {
-                await runtime.release();
-                return;
-            }
-            if (!runtimePromise) {
-                return;
-            }
-            try {
-                const created = await runtimePromise;
-                runtime = created;
-                await created.release();
-            }
-            catch {
-                // createHeadlessKernelRuntime is responsible for rolling back partial bootstrap state.
-            }
-        })();
-        return runtimeReleasePromise;
-    };
-    const isKnownOperation = (op) => Object.prototype.hasOwnProperty.call(HEADLESS_OPERATION_SCHEMAS, op);
-    const raceWithAbort = async (signal, task) => {
-        if (signal.aborted) {
-            return { kind: "aborted" };
-        }
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const onAbort = () => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                signal.removeEventListener("abort", onAbort);
-                resolve({ kind: "aborted" });
-            };
-            signal.addEventListener("abort", onAbort);
-            task.then((value) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                signal.removeEventListener("abort", onAbort);
-                resolve({ kind: "value", value });
-            }, (error) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                signal.removeEventListener("abort", onAbort);
-                reject(error);
-            });
-        });
-    };
-    const detachDispatchIterator = async (iterator) => {
-        if (typeof iterator.return !== "function") {
-            return true;
-        }
-        try {
-            const cleanupPromise = iterator.return().then(() => undefined, () => undefined);
-            const trackedCleanup = cleanupPromise.finally(() => {
-                pendingIteratorCleanup.delete(trackedCleanup);
-            });
-            const result = await Promise.race([
-                trackedCleanup.then(() => true),
-                new Promise((resolve) => setTimeout(() => resolve(false), DISPATCH_ITERATOR_CLEANUP_TIMEOUT_MS)),
-            ]);
-            if (!result) {
-                pendingIteratorCleanup.add(trackedCleanup);
-            }
-            return result;
-        }
-        catch {
-            // Best-effort shutdown: iterator cleanup failure should not block runtime release.
-            return false;
-        }
-    };
-    const writeConnectionClosedResult = (requestId, op) => writeFrame({
-        kind: "result",
-        requestId,
-        op,
-        ok: false,
-        error: {
-            code: "CONNECTION_CLOSED",
-            message: "Connection closed before request completed",
-        },
-    });
-    const shutdown = () => {
-        shutdownPromise ??= (async () => {
-            for (const [requestId, state] of active) {
-                state.controller.abort();
-                if (state.completed || state.connectionClosedEmitted) {
-                    continue;
-                }
-                state.connectionClosedEmitted = true;
-                writeConnectionClosedResult(requestId, state.op);
-            }
-            await Promise.allSettled([...active.values()].map((state) => state.promise));
-            if (pendingIteratorCleanup.size > 0) {
-                await Promise.race([
-                    Promise.allSettled([...pendingIteratorCleanup]),
-                    new Promise((resolve) => setTimeout(() => resolve(), RUNTIME_RELEASE_CLEANUP_GRACE_MS)),
-                ]);
-            }
-            await releaseRuntime();
-            writeFrame.close();
-            process.stdin.removeListener("data", handleData);
-            process.stdin.removeListener("end", handleInputClosed);
-            process.stdin.removeListener("close", handleInputClosed);
-            process.removeListener("SIGTERM", handleSigterm);
-        })();
-        return shutdownPromise;
-    };
-    const handleSigterm = () => {
-        process.stdin.pause();
-        void shutdown().finally(() => resolveServerDone?.());
-    };
-    process.once("SIGTERM", handleSigterm);
-    const dispatchLine = (line) => {
-        parseErrorSeq += 1;
-        const parsed = parseClientFrame(line, parseErrorSeq, writeFrame);
-        if (parsed) {
-            launch(parsed);
-        }
-    };
-    const flushBufferedLines = () => {
-        while (true) {
-            const newlineIndex = inputBuffer.indexOf("\n");
-            if (newlineIndex < 0) {
-                return;
-            }
-            let line = inputBuffer.slice(0, newlineIndex);
-            if (line.endsWith("\r")) {
-                line = line.slice(0, -1);
-            }
-            inputBuffer = inputBuffer.slice(newlineIndex + 1);
-            dispatchLine(line);
-        }
-    };
-    const handleData = (chunk) => {
-        inputBuffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-        flushBufferedLines();
-    };
-    const handleInputClosed = () => {
-        if (inputClosed) {
-            return;
-        }
-        inputClosed = true;
-        let trailing = inputBuffer;
-        if (trailing.endsWith("\r")) {
-            trailing = trailing.slice(0, -1);
-        }
-        inputBuffer = "";
-        if (trailing.trim().length > 0) {
-            dispatchLine(trailing);
-        }
-        void shutdown().finally(() => resolveServerDone?.());
-    };
-    const launch = (frame) => {
-        const op = frame.kind === "request" ? frame.op : "interaction.respond";
-        const scopeSwitchInFlight = [...active.values()].some((state) => state.op === "arion.become");
-        if (frame.kind === "request" &&
-            ((frame.op === "arion.become" && inFlight.size > 0) ||
-                (frame.op !== "arion.become" && scopeSwitchInFlight))) {
-            writeFrame({
-                kind: "result",
-                requestId: frame.requestId,
-                op,
-                ok: false,
-                error: {
-                    code: "ARION_SCOPE_BUSY",
-                    message: frame.op === "arion.become"
-                        ? "arion.become requires an idle headless connection"
-                        : "Headless scope is switching arions; wait for arion.become to finish",
-                },
-            });
-            seenRequestIds.add(frame.requestId);
-            return;
-        }
-        if (inFlight.has(frame.requestId)) {
-            writeFrame({
-                kind: "result",
-                requestId: frame.requestId,
-                op,
-                ok: false,
-                error: {
-                    code: "DUPLICATE_REQUEST_ID",
-                    message: `Request ${frame.requestId} is already in flight`,
-                },
-            });
-            return;
-        }
-        if (seenRequestIds.has(frame.requestId)) {
-            writeFrame({
-                kind: "result",
-                requestId: frame.requestId,
-                op: frame.kind === "request" ? frame.op : "interaction.respond",
-                ok: false,
-                error: {
-                    code: "DUPLICATE_REQUEST_ID",
-                    message: `Request ${frame.requestId} has already been used on this connection`,
-                },
-            });
-            return;
-        }
-        if (frame.kind === "request") {
-            if (!isKnownOperation(frame.op)) {
-                writeFrame({
-                    kind: "result",
-                    requestId: frame.requestId,
-                    op: frame.op,
-                    ok: false,
-                    error: {
-                        code: "UNKNOWN_OPERATION",
-                        message: `Unknown operation ${frame.op}`,
-                    },
-                });
-                seenRequestIds.add(frame.requestId);
-                return;
-            }
-            const schema = HEADLESS_OPERATION_SCHEMAS[frame.op].input;
-            if (!schema.safeParse(frame.input).success) {
-                writeFrame({
-                    kind: "result",
-                    requestId: frame.requestId,
-                    op: frame.op,
-                    ok: false,
-                    error: {
-                        code: "INVALID_INPUT",
-                        message: `Invalid input for ${frame.op}`,
-                    },
-                });
-                seenRequestIds.add(frame.requestId);
-                return;
-            }
-        }
-        else if (!HeadlessInteractionResponseSchema.safeParse(frame).success) {
-            writeFrame({
-                kind: "result",
-                requestId: frame.requestId,
-                op: "interaction.respond",
-                ok: false,
-                error: {
-                    code: "INVALID_INPUT",
-                    message: "Invalid input for interaction.respond",
-                },
-            });
-            seenRequestIds.add(frame.requestId);
-            return;
-        }
-        inFlight.add(frame.requestId);
-        seenRequestIds.add(frame.requestId);
-        const controller = new AbortController();
-        let promise = null;
-        promise = (async () => {
-            try {
-                const runtimeOrAbort = await raceWithAbort(controller.signal, ensureRuntime().then((created) => ({
-                    runtime: created,
-                })));
-                if (runtimeOrAbort.kind !== "value") {
-                    return;
-                }
-                const iterator = runtimeOrAbort.value.runtime.kernel
-                    .dispatch(frame, {
-                    signal: controller.signal,
-                })[Symbol.asyncIterator]();
-                while (true) {
-                    const nextOrAbort = await raceWithAbort(controller.signal, iterator.next().then((result) => ({ result })));
-                    if (nextOrAbort.kind === "aborted") {
-                        await detachDispatchIterator(iterator);
-                        return;
-                    }
-                    if (nextOrAbort.value.result.done) {
-                        return;
-                    }
-                    const outFrame = nextOrAbort.value.result.value;
-                    const state = active.get(frame.requestId);
-                    if (controller.signal.aborted || state?.connectionClosedEmitted) {
-                        continue;
-                    }
-                    writeFrame(outFrame);
-                    if (outFrame.kind === "result") {
-                        if (state) {
-                            state.completed = true;
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                const state = active.get(frame.requestId);
-                if (controller.signal.aborted || state?.connectionClosedEmitted) {
-                    return;
-                }
-                writeFrame({
-                    kind: "result",
-                    requestId: frame.requestId,
-                    op,
-                    ok: false,
-                    error: {
-                        code: "INTERNAL_ERROR",
-                        message: error instanceof Error ? error.message : String(error),
-                    },
-                });
-                if (state) {
-                    state.completed = true;
-                }
-            }
-            finally {
-                inFlight.delete(frame.requestId);
-                active.delete(frame.requestId);
-            }
-        })();
-        active.set(frame.requestId, {
-            op,
-            controller,
-            completed: false,
-            connectionClosedEmitted: false,
-            promise,
-        });
-    };
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", handleData);
-    process.stdin.once("end", handleInputClosed);
-    process.stdin.once("close", handleInputClosed);
-    await serverDone;
-}
-//# sourceMappingURL=stdio-server.js.map

package/dist/history/SessionHistory.js

@@ -1,8 +0,0 @@
-/**
- * SessionHistory — re-exported from @aria-cli/aria.
- *
- * The canonical implementation lives in packages/aria/src/history/SessionHistory.ts.
- * This re-export keeps all existing CLI imports working unchanged.
- */
-export * from "@aria-cli/aria/history/SessionHistory.js";
-//# sourceMappingURL=SessionHistory.js.map

package/dist/history/SessionHistoryClient.js

@@ -1,186 +0,0 @@
-/**
- * IPC-backed session history client for the REPL.
- *
- * Bulk writes (appendMessages, replaceMessages, markCompleted) are dispatched
- * to the daemon over the existing LocalControl IPC socket — fire-and-forget,
- * never blocking the event loop.  Small writes (completeRun, claimSession,
- * etc.) run locally with a short busy_timeout (100ms via lowContentionMode).
- * Reads are served locally from the same WAL connection (instant).
- *
- * The daemon owns the canonical single-writer connection and serializes all
- * IPC writes.  On IPC failure, writes fall back to the local connection.
- */
-import { log } from "@aria-cli/types";
-import { clearStallPhase, setStallPhase } from "../event-loop-watchdog.js";
-/**
- * Fire-and-forget IPC write. Logs on failure, never throws.
- * Falls back to a local sync write if provided.
- */
-/** Errors that are expected during normal teardown and should not be logged. */
-function isTeardownError(err) {
-    if (!(err instanceof Error))
-        return false;
-    const msg = err.message;
-    return msg.includes("has been released") || msg.includes("aborted");
-}
-function fireAndForget(label, ipcCall, fallback) {
-    if (!ipcCall) {
-        fallback?.();
-        return;
-    }
-    ipcCall.catch((err) => {
-        // Silently fall back during normal teardown (client released / aborted).
-        if (!isTeardownError(err)) {
-            log.warn(`[SessionHistoryClient] ${label} IPC failed:`, err?.message ?? err);
-        }
-        if (fallback) {
-            try {
-                fallback();
-            }
-            catch (localErr) {
-                log.warn(`[SessionHistoryClient] ${label} local fallback also failed:`, localErr?.message ?? localErr);
-            }
-        }
-    });
-}
-export class SessionHistoryClient {
-    readDb;
-    ipc;
-    constructor(
-    /** Local SessionHistory for reads + local fallback writes. */
-    readDb, 
-    /** IPC handle to the daemon's localControl API. */
-    ipc) {
-        this.readDb = readDb;
-        this.ipc = ipc;
-        // The daemon owns the main writer.  This local connection only does tiny
-        // writes (createSession, claimSession) so reduce busy_timeout from 5s to
-        // 100ms to avoid blocking the event loop.
-        readDb.enableLowContentionMode();
-    }
-    // ---------------------------------------------------------------------------
-    // Reads — local, instant, zero contention.  Proxy every read method so the
-    // client is a full drop-in replacement for SessionHistory.
-    // ---------------------------------------------------------------------------
-    withPhase(label, fn) {
-        setStallPhase(label);
-        try {
-            return fn();
-        }
-        finally {
-            clearStallPhase();
-        }
-    }
-    listSessions(...args) {
-        return this.withPhase("session-history:listSessions", () => this.readDb.listSessions(...args));
-    }
-    loadSessionMessages(...args) {
-        return this.withPhase("session-history:loadSessionMessages", () => this.readDb.loadSessionMessages(...args));
-    }
-    loadSession(...args) {
-        return this.withPhase("session-history:loadSession", () => this.readDb.loadSession(...args));
-    }
-    searchSessionsFts(...args) {
-        return this.withPhase("session-history:searchSessionsFts", () => this.readDb.searchSessionsFts(...args));
-    }
-    searchSessionSummaries(...args) {
-        return this.withPhase("session-history:searchSessionSummaries", () => this.readDb.searchSessionSummaries(...args));
-    }
-    findSessionByPrefix(...args) {
-        return this.readDb.findSessionByPrefix(...args);
-    }
-    getSessionRuntimeState(...args) {
-        return this.readDb.getSessionRuntimeState(...args);
-    }
-    getInteraction(...args) {
-        return this.readDb.getInteraction(...args);
-    }
-    getIncompleteSessions(...args) {
-        return this.readDb.getIncompleteSessions(...args);
-    }
-    getInputHistory(...args) {
-        return this.withPhase("session-history:getInputHistory", () => this.readDb.getInputHistory(...args));
-    }
-    addInputHistory(...args) {
-        return this.withPhase("session-history:addInputHistory", () => this.readDb.addInputHistory(...args));
-    }
-    getSessionCount(...args) {
-        return this.readDb.getSessionCount(...args);
-    }
-    markStaleSessionsCompleted(...args) {
-        return this.withPhase("session-history:markStaleSessionsCompleted", () => this.readDb.markStaleSessionsCompleted(...args));
-    }
-    getSession(...args) {
-        return this.readDb.getSession(...args);
-    }
-    // ---------------------------------------------------------------------------
-    // createSession — local write so it's immediately readable
-    // ---------------------------------------------------------------------------
-    createSession(...args) {
-        return this.readDb.createSession(...args);
-    }
-    // ---------------------------------------------------------------------------
-    // Writes — fire-and-forget via IPC to daemon
-    // ---------------------------------------------------------------------------
-    persistMessagesNonBlocking(sessionId, msgs) {
-        if (msgs.length === 0)
-            return;
-        // Mark session as incremental BEFORE the IPC call so that the orchestrator's
-        // deferred replaceConversationMessages sees it and short-circuits (no-op).
-        this.readDb.markSessionIncremental(sessionId);
-        fireAndForget("appendSessionMessages", this.ipc.appendSessionMessages?.(sessionId, msgs), () => this.readDb.addConversationMessages(sessionId, msgs));
-    }
-    /** Batched sync write — used by addConversationMessages callers. Routes to IPC. */
-    addConversationMessages(sessionId, msgs) {
-        this.persistMessagesNonBlocking(sessionId, msgs);
-    }
-    /** Single message write — routes to batched path. */
-    addConversationMessage(sessionId, msg) {
-        this.persistMessagesNonBlocking(sessionId, [msg]);
-    }
-    markCompleted(sessionId) {
-        fireAndForget("markSessionCompleted", this.ipc.markSessionCompleted?.(sessionId), () => this.readDb.markCompleted(sessionId));
-    }
-    replaceConversationMessages(sessionId, msgs) {
-        fireAndForget("replaceSessionMessages", this.ipc.replaceSessionMessages?.(sessionId, msgs), () => this.readDb.replaceConversationMessages(sessionId, msgs));
-    }
-    // ---------------------------------------------------------------------------
-    // Small writes — local only (fast single-row ops, not worth IPC overhead).
-    // With lowContentionMode (100ms busy_timeout), these never block the event
-    // loop meaningfully.  The daemon sees them through WAL visibility.
-    // ---------------------------------------------------------------------------
-    completeRun(...args) {
-        return this.readDb.completeRun(...args);
-    }
-    claimSessionForMutation(...args) {
-        return this.readDb.claimSessionForMutation(...args);
-    }
-    releaseSessionClaim(...args) {
-        return this.readDb.releaseSessionClaim(...args);
-    }
-    recordPausedRun(...args) {
-        return this.readDb.recordPausedRun(...args);
-    }
-    deleteSession(...args) {
-        return this.readDb.deleteSession(...args);
-    }
-    forkSession(...args) {
-        return this.readDb.forkSession(...args);
-    }
-    cancelInteraction(...args) {
-        return this.readDb.cancelInteraction(...args);
-    }
-    setSessionTitle(...args) {
-        return this.readDb.setSessionTitle(...args);
-    }
-    recordInteractionResponse(...args) {
-        return this.readDb.recordInteractionResponse(...args);
-    }
-    // ---------------------------------------------------------------------------
-    // Passthrough
-    // ---------------------------------------------------------------------------
-    close() {
-        this.readDb.close();
-    }
-}
-//# sourceMappingURL=SessionHistoryClient.js.map