@aria-cli/cli 1.0.51 → 1.0.54

package/dist/headless/call-command.js

@@ -1,143 +0,0 @@
-import { Command } from "commander";
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import path from "node:path";
-function readInputJson(pathOrDash) {
-    if (!pathOrDash || pathOrDash === "-") {
-        const raw = readFileSync(0, "utf8").trim();
-        return raw ? JSON.parse(raw) : {};
-    }
-    return JSON.parse(readFileSync(pathOrDash, "utf8"));
-}
-function makeClientFrame(operation, input) {
-    if (operation === "interaction.respond") {
-        return {
-            kind: "interaction.respond",
-            requestId: "call-1",
-            ...input,
-        };
-    }
-    return {
-        kind: "request",
-        requestId: "call-1",
-        op: operation,
-        input,
-    };
-}
-function resolveAriaHome() {
-    if (process.env.ARIA_HOME) {
-        return process.env.ARIA_HOME;
-    }
-    return path.join(process.env.HOME || homedir(), ".aria");
-}
-function resolveCallArionName(options) {
-    if (typeof options.arion === "string" && options.arion.trim().length > 0) {
-        return options.arion.trim();
-    }
-    const configPath = path.join(resolveAriaHome(), "config.json");
-    if (!existsSync(configPath)) {
-        return "ARIA";
-    }
-    try {
-        const raw = JSON.parse(readFileSync(configPath, "utf8"));
-        if (typeof raw.activeArion === "string" && raw.activeArion.trim().length > 0) {
-            return raw.activeArion.trim();
-        }
-    }
-    catch {
-        // Fall through to the default Arion name when config is unreadable.
-    }
-    return "ARIA";
-}
-function missingResult(operation) {
-    return {
-        kind: "result",
-        requestId: "call-1",
-        op: operation,
-        ok: false,
-        error: {
-            code: "NO_RESULT",
-            message: `Operation ${operation} produced no result frame`,
-        },
-    };
-}
-async function runFastSessionCall(operation, input, options) {
-    const [{ SessionHistory }, { createSessionOperationHandlers }, { cliStallPhase }] = await Promise.all([
-        import("../history/index.js"),
-        import("./operations/session.js"),
-        import("../history/stall-phase-bridge.js"),
-    ]);
-    const sessionLedger = new SessionHistory(SessionHistory.resolvePerArionPath(resolveAriaHome(), resolveCallArionName(options)), { stallPhase: cliStallPhase });
-    try {
-        const handlers = createSessionOperationHandlers({
-            sessionLedger,
-        });
-        let lastResult = null;
-        for await (const frame of handlers[operation]("call-1", input)) {
-            if (frame.kind === "result") {
-                lastResult = frame;
-            }
-        }
-        return lastResult ?? missingResult(operation);
-    }
-    finally {
-        sessionLedger.close();
-    }
-}
-async function tryRunFastPath(operation, input, options) {
-    switch (operation) {
-        case "session.list":
-        case "session.read":
-        case "session.load":
-            return runFastSessionCall(operation, input, options);
-        default:
-            return null;
-    }
-}
-export async function runHeadlessCall(operation, options) {
-    try {
-        const input = readInputJson(options.inputJson);
-        const fastPathResult = await tryRunFastPath(operation, input, options);
-        if (fastPathResult) {
-            process.stdout.write(`${JSON.stringify(fastPathResult)}\n`);
-            return fastPathResult.ok ? 0 : 1;
-        }
-        const { createHeadlessKernelRuntime } = await import("./kernel.js");
-        const runtime = await createHeadlessKernelRuntime({
-            cwd: process.cwd(),
-            arionName: options.arion,
-        });
-        try {
-            let lastResult = null;
-            for await (const frame of runtime.kernel.dispatch(makeClientFrame(operation, input))) {
-                if (frame.kind === "result") {
-                    lastResult = frame;
-                }
-            }
-            if (!lastResult) {
-                process.stdout.write(`${JSON.stringify(missingResult(operation))}\n`);
-                return 1;
-            }
-            process.stdout.write(`${JSON.stringify(lastResult)}\n`);
-            return lastResult.ok ? 0 : 1;
-        }
-        finally {
-            await runtime.release();
-        }
-    }
-    catch (error) {
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return 2;
-    }
-}
-export function createHeadlessCallCommand() {
-    return new Command("call")
-        .description("Execute one headless operation and print exactly one JSON result")
-        .argument("<operation>", "Headless operation name")
-        .option("--input-json <path|->", "Read JSON input from a file path or stdin", "-")
-        .option("--arion <name>", "Arion name for per-Arion session context")
-        .action(async (operation, options) => {
-        process.exitCode = await runHeadlessCall(operation, options);
-    });
-}
-//# sourceMappingURL=call-command.js.map

package/dist/headless/daemon-service.js

@@ -1,318 +0,0 @@
-import { existsSync, mkdirSync, openSync, closeSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import process from "node:process";
-import { resolveLocalControlClient } from "../local-control-client.js";
-import { resolveAriaLaunchSpec } from "../runtime/launch-spec.js";
-import { spawnAria } from "../runtime/spawn-aria.js";
-const DAEMON_READY_TIMEOUT_MS = 15_000;
-const DAEMON_READY_POLL_MS = 250;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, Math.max(ms, 0)));
-}
-function resolveArionName(cli, fallback, raw) {
-    const fromInput = typeof raw.arion === "string" ? raw.arion.trim() : "";
-    return fromInput || fallback || cli.config.activeArion?.trim() || "ARIA";
-}
-function toAutonomousLoopCommand(input) {
-    return {
-        ...(typeof input.intervalMs === "number" ? { intervalMs: input.intervalMs } : {}),
-        ...(input.allowedToolCategories ||
-            input.allowedShellCommands ||
-            typeof input.maxWriteOpsPerMinute === "number" ||
-            typeof input.maxGitPushesPerHour === "number"
-            ? {
-                safetyPolicy: {
-                    ...(Array.isArray(input.allowedToolCategories)
-                        ? { allowedToolCategories: input.allowedToolCategories }
-                        : {}),
-                    ...(Array.isArray(input.allowedShellCommands)
-                        ? { allowedShellCommands: input.allowedShellCommands }
-                        : {}),
-                    ...(typeof input.maxWriteOpsPerMinute === "number"
-                        ? { maxWriteOpsPerMinute: input.maxWriteOpsPerMinute }
-                        : {}),
-                    ...(typeof input.maxGitPushesPerHour === "number"
-                        ? { maxGitPushesPerHour: input.maxGitPushesPerHour }
-                        : {}),
-                },
-            }
-            : {}),
-    };
-}
-async function waitForDaemonStatus(options) {
-    const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
-    let lastError = null;
-    while (Date.now() < deadline) {
-        try {
-            const control = await resolveLocalControlClient({ ariaHome: options.ariaHome });
-            if (control) {
-                const status = await control.getRuntimeStatus();
-                if (!options.requireRunning || status.autonomousLoop.status === "running") {
-                    return status;
-                }
-            }
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-        }
-        await sleep(DAEMON_READY_POLL_MS);
-    }
-    throw new Error(lastError?.message ?? "Timed out waiting for the daemon runtime to become reachable");
-}
-async function findLocalRuntimeOwner(options) {
-    const { resolveRuntimeRootDirectory, findRuntimeOwnerRecordByAriaHome, readRuntimeOwnerRecord, removeRuntimeOwnerRecord, } = await import("@aria-cli/server");
-    const runtimeRoot = resolveRuntimeRootDirectory();
-    if (options.liveControl) {
-        try {
-            const status = await options.liveControl.getRuntimeStatus();
-            const byNodeId = readRuntimeOwnerRecord(runtimeRoot, status.nodeId);
-            if (byNodeId) {
-                return { runtimeRoot, owner: byNodeId, removeRuntimeOwnerRecord };
-            }
-        }
-        catch {
-            // Fall back to ARIA_HOME-scoped owner lookup below.
-        }
-    }
-    const owner = findRuntimeOwnerRecordByAriaHome(runtimeRoot, options.ariaHome);
-    return { runtimeRoot, owner, removeRuntimeOwnerRecord };
-}
-function isPidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function killOwnedDaemonProcess(options) {
-    const { runtimeRoot, owner, removeRuntimeOwnerRecord } = await findLocalRuntimeOwner(options);
-    if (!owner) {
-        return { stopped: false };
-    }
-    const pid = owner.runtimePid;
-    if (!isPidAlive(pid)) {
-        removeRuntimeOwnerRecord(runtimeRoot, owner.nodeId);
-        return { stopped: false, pid };
-    }
-    try {
-        process.kill(pid, "SIGINT");
-    }
-    catch {
-        removeRuntimeOwnerRecord(runtimeRoot, owner.nodeId);
-        return { stopped: false, pid };
-    }
-    const deadline = Date.now() + 5_000;
-    while (Date.now() < deadline) {
-        if (!isPidAlive(pid)) {
-            try {
-                removeRuntimeOwnerRecord(runtimeRoot, owner.nodeId);
-            }
-            catch { }
-            return { stopped: true, pid };
-        }
-        await sleep(200);
-    }
-    try {
-        process.kill(pid, "SIGKILL");
-    }
-    catch { }
-    try {
-        removeRuntimeOwnerRecord(runtimeRoot, owner.nodeId);
-    }
-    catch { }
-    return { stopped: true, pid };
-}
-function sanitizeDaemonEnv(env, overrides) {
-    const passthrough = [
-        "HOME",
-        "PATH",
-        "USER",
-        "LOGNAME",
-        "SHELL",
-        "TERM",
-        "COLORTERM",
-        "LANG",
-        "LC_ALL",
-        "LC_CTYPE",
-        "LC_MESSAGES",
-        "TMPDIR",
-        "TMP",
-        "TEMP",
-        "SSH_AUTH_SOCK",
-        "DISPLAY",
-        "WAYLAND_DISPLAY",
-        "XDG_RUNTIME_DIR",
-        "XDG_CONFIG_HOME",
-        "XDG_CACHE_HOME",
-        "XDG_DATA_HOME",
-        // Preserve machine-local AWS shared config path overrides. These are configuration
-        // selectors/locations, not credentials, and are required for daemon-owned Bedrock auth
-        // on systems that don't use the default ~/.aws paths.
-        "AWS_CONFIG_FILE",
-        "AWS_SHARED_CREDENTIALS_FILE",
-        "NO_COLOR",
-        "CI",
-    ];
-    const sanitized = {};
-    for (const key of passthrough) {
-        const value = env[key];
-        if (typeof value === "string" && value.length > 0) {
-            sanitized[key] = value;
-        }
-    }
-    return { ...sanitized, ...overrides };
-}
-function ensureFreshDaemonBootstrapNetworkConfig(ariaHome) {
-    const networkDir = path.join(ariaHome, "network");
-    const networkConfigPath = path.join(networkDir, "config.json");
-    if (existsSync(networkConfigPath)) {
-        return;
-    }
-    mkdirSync(networkDir, { recursive: true });
-    writeFileSync(networkConfigPath, `${JSON.stringify({ listenPort: 0 }, null, 2)}\n`, {
-        encoding: "utf8",
-        flag: "wx",
-        mode: 0o600,
-    });
-}
-function spawnDetachedDaemonLauncher(options) {
-    const args = ["--arion", options.arionName];
-    if (typeof options.input.port === "number") {
-        args.push("--port", String(options.input.port));
-    }
-    if (typeof options.input.intervalMs === "number") {
-        args.push("--interval-ms", String(options.input.intervalMs));
-    }
-    if (Array.isArray(options.input.allowedToolCategories) &&
-        options.input.allowedToolCategories.length > 0) {
-        args.push("--allowed-tool-categories", options.input.allowedToolCategories.join(","));
-    }
-    if (Array.isArray(options.input.allowedShellCommands) &&
-        options.input.allowedShellCommands.length > 0) {
-        args.push("--allowed-shell-commands", options.input.allowedShellCommands.join(","));
-    }
-    if (typeof options.input.maxWriteOpsPerMinute === "number") {
-        args.push("--max-write-ops-per-minute", String(options.input.maxWriteOpsPerMinute));
-    }
-    if (typeof options.input.maxGitPushesPerHour === "number") {
-        args.push("--max-git-pushes-per-hour", String(options.input.maxGitPushesPerHour));
-    }
-    // Defense-in-depth: redirect stderr to a file so uncaught exceptions
-    // and native Node warnings are captured even if the log module's file
-    // sink hasn't initialized yet. The daemon-launcher configures a proper
-    // JSONL file sink inside the child process for structured log output;
-    // this stderr redirect catches only what bypasses the log module.
-    const logsDir = path.join(options.ariaHome, "logs");
-    mkdirSync(logsDir, { recursive: true });
-    ensureFreshDaemonBootstrapNetworkConfig(options.ariaHome);
-    const stderrFd = openSync(path.join(logsDir, "daemon-stderr.log"), "a");
-    const spec = resolveAriaLaunchSpec({
-        mode: "daemon",
-        args,
-        cwd: options.cwd,
-        env: sanitizeDaemonEnv(process.env, {
-            ARIA_HOME: options.ariaHome,
-        }),
-    });
-    const child = spawnAria(spec, {
-        detached: true,
-        stdio: ["ignore", "ignore", stderrFd],
-    });
-    child.unref();
-    closeSync(stderrFd); // Parent closes its copy; child inherits the fd
-}
-export function createDaemonService(options) {
-    const ariaHome = options.cli.ariaDir;
-    let stopOnShutdown = false;
-    const resolveScopedArionName = () => options.getArionName?.() ?? options.arionName ?? "ARIA";
-    const assertScopedTargetArion = (raw) => {
-        const requestedArion = typeof raw.arion === "string" ? raw.arion.trim() : "";
-        const scopedArion = resolveScopedArionName();
-        if (requestedArion && requestedArion !== scopedArion) {
-            throw new Error(`daemon operations are scoped to ${scopedArion}; switch scope with arion.become before targeting ${requestedArion}`);
-        }
-        return requestedArion || scopedArion;
-    };
-    const resolveScopedLiveControl = async () => {
-        if (!options.localControl) {
-            return null;
-        }
-        try {
-            await options.localControl.getRuntimeStatus();
-            return options.localControl;
-        }
-        catch {
-            return null;
-        }
-    };
-    return {
-        async start(input) {
-            const arionName = resolveArionName(options.cli, assertScopedTargetArion(input), input);
-            const liveControl = await resolveScopedLiveControl();
-            if (!liveControl) {
-                stopOnShutdown = true;
-                spawnDetachedDaemonLauncher({
-                    ariaHome,
-                    cwd: options.cwd,
-                    arionName,
-                    input,
-                });
-                return waitForDaemonStatus({ ariaHome, requireRunning: true });
-            }
-            const before = await liveControl.getRuntimeStatus();
-            if (before.autonomousLoop.status === "running") {
-                stopOnShutdown = false;
-                return before;
-            }
-            if (!liveControl.startAutonomousLoop) {
-                throw new Error("Live runtime does not expose autonomous-loop start control");
-            }
-            stopOnShutdown = true;
-            return liveControl.startAutonomousLoop(toAutonomousLoopCommand(input));
-        },
-        async status(input = {}) {
-            assertScopedTargetArion(input);
-            const liveControl = await resolveScopedLiveControl();
-            if (!liveControl) {
-                throw new Error("No live runtime is available for daemon.status");
-            }
-            return liveControl.getRuntimeStatus();
-        },
-        async stop(input = {}) {
-            assertScopedTargetArion(input);
-            const stopped = await killOwnedDaemonProcess({
-                ariaHome,
-                liveControl: await resolveScopedLiveControl(),
-            });
-            stopOnShutdown = false;
-            return {
-                running: false,
-                stopped: true,
-                pid: stopped.pid,
-            };
-        },
-        async restart(input = {}) {
-            const arionName = resolveArionName(options.cli, assertScopedTargetArion(input), input);
-            await killOwnedDaemonProcess({
-                ariaHome,
-                liveControl: await resolveScopedLiveControl(),
-            });
-            stopOnShutdown = true;
-            spawnDetachedDaemonLauncher({
-                ariaHome,
-                cwd: options.cwd,
-                arionName,
-                input,
-            });
-            const status = await waitForDaemonStatus({ ariaHome, requireRunning: false });
-            return status;
-        },
-        shouldStopOnShutdown() {
-            return stopOnShutdown;
-        },
-        async releaseAll() { },
-    };
-}
-//# sourceMappingURL=daemon-service.js.map

package/dist/headless/hook-actions.js

@@ -1,235 +0,0 @@
-/**
- * Shared hook action implementations used by the `hook.*` headless operations.
- *
- * These functions provide the Memoria/router-backed extraction, reflection,
- * consolidation, ingestion, and harvesting behavior without a dedicated legacy
- * hook CLI mode.
- */
-import { lightReflection } from "@aria-cli/aria";
-import { ingestClaudeCodeHistory } from "@aria-cli/memoria-bridge";
-const EXTRACT_MAX_PAIRS = 50;
-const EXTRACT_CONCURRENCY = 5;
-function throwIfAborted(signal) {
-    if (!signal?.aborted) {
-        return;
-    }
-    const message = signal.reason instanceof Error && signal.reason.message
-        ? signal.reason.message
-        : "The operation was aborted";
-    const error = new Error(message);
-    error.name = "AbortError";
-    throw error;
-}
-function normalizeHarvestInput(input = {}) {
-    const normalized = {
-        feedback: input.feedback === true,
-        extract: input.extract === true,
-        stats: input.stats === true,
-        cleanup: input.cleanup === true,
-        all: input.all === true,
-        limit: typeof input.limit === "number" && Number.isInteger(input.limit) && input.limit > 0
-            ? input.limit
-            : 50,
-    };
-    if (normalized.all) {
-        normalized.extract = true;
-        normalized.stats = true;
-    }
-    return normalized;
-}
-export function parseHarvestArgs(args) {
-    const limitIdx = args.indexOf("--limit");
-    return normalizeHarvestInput({
-        feedback: args.includes("--feedback"),
-        extract: args.includes("--extract"),
-        stats: args.includes("--stats"),
-        cleanup: args.includes("--cleanup"),
-        all: args.includes("--all"),
-        ...(limitIdx >= 0 && args[limitIdx + 1]
-            ? { limit: Number.parseInt(args[limitIdx + 1] ?? "50", 10) || 50 }
-            : {}),
-    });
-}
-export async function actionExtract(memoria, stdin, options = {}) {
-    throwIfAborted(options.signal);
-    if (!stdin) {
-        return { output: { error: "no input on stdin" }, exitCode: 1 };
-    }
-    let pairs;
-    try {
-        pairs = JSON.parse(stdin);
-        if (!Array.isArray(pairs))
-            throw new Error("expected array");
-    }
-    catch {
-        return {
-            output: { error: "stdin must be JSON array of {user, assistant} pairs" },
-            exitCode: 1,
-        };
-    }
-    if (pairs.length > EXTRACT_MAX_PAIRS) {
-        return {
-            output: { error: `hook.extract accepts at most ${EXTRACT_MAX_PAIRS} pairs per request` },
-            exitCode: 1,
-        };
-    }
-    const results = [];
-    let nextIndex = 0;
-    const workers = Array.from({ length: Math.min(EXTRACT_CONCURRENCY, pairs.length) }, async () => {
-        while (true) {
-            throwIfAborted(options.signal);
-            const index = nextIndex;
-            nextIndex += 1;
-            if (index >= pairs.length) {
-                return;
-            }
-            const pair = pairs[index];
-            if (!pair.user || !pair.assistant) {
-                results[index] = {
-                    user: pair.user ?? "",
-                    extracted: 0,
-                    error: "missing user or assistant",
-                };
-                continue;
-            }
-            try {
-                const result = await memoria.extractFromConversation(pair.user, pair.assistant);
-                throwIfAborted(options.signal);
-                const learned = result?.learned;
-                results[index] = {
-                    user: pair.user.slice(0, 80),
-                    extracted: Array.isArray(learned) ? learned.length : 0,
-                };
-            }
-            catch (err) {
-                throwIfAborted(options.signal);
-                results[index] = {
-                    user: pair.user.slice(0, 80),
-                    extracted: 0,
-                    error: err instanceof Error ? err.message : String(err),
-                };
-            }
-        }
-    });
-    await Promise.all(workers);
-    return { output: { extracted: results } };
-}
-export async function actionReflect(memoria, router, stdin, options = {}) {
-    throwIfAborted(options.signal);
-    const messages = [];
-    if (stdin) {
-        try {
-            const parsed = JSON.parse(stdin);
-            if (Array.isArray(parsed)) {
-                for (const msg of parsed) {
-                    if (msg.role && msg.content) {
-                        messages.push({
-                            role: msg.role,
-                            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
-                        });
-                    }
-                }
-            }
-        }
-        catch {
-            messages.push({ role: "user", content: "Session review" });
-            messages.push({ role: "assistant", content: stdin });
-        }
-    }
-    if (messages.length < 2) {
-        return { output: { findings: null, reason: "insufficient conversation" } };
-    }
-    try {
-        const result = await lightReflection(router, memoria, messages);
-        throwIfAborted(options.signal);
-        return { output: { findings: result } };
-    }
-    catch (err) {
-        throwIfAborted(options.signal);
-        return {
-            output: {
-                findings: null,
-                error: err instanceof Error ? err.message : String(err),
-            },
-        };
-    }
-}
-export async function actionConsolidate(memoria, options = {}) {
-    throwIfAborted(options.signal);
-    try {
-        const stats = await memoria.reflect({ full: false });
-        throwIfAborted(options.signal);
-        return { output: stats };
-    }
-    catch (err) {
-        throwIfAborted(options.signal);
-        return {
-            output: {
-                error: err instanceof Error ? err.message : String(err),
-            },
-        };
-    }
-}
-export async function actionIngest(memoria, options = {}) {
-    throwIfAborted(options.signal);
-    try {
-        const result = await ingestClaudeCodeHistory(memoria);
-        throwIfAborted(options.signal);
-        return { output: result };
-    }
-    catch (err) {
-        throwIfAborted(options.signal);
-        return {
-            output: {
-                error: err instanceof Error ? err.message : String(err),
-            },
-        };
-    }
-}
-export async function actionHarvest(memoria, router, input = {}, options = {}) {
-    throwIfAborted(options.signal);
-    const flags = normalizeHarvestInput(input);
-    if (!flags.feedback && !flags.extract && !flags.stats && !flags.cleanup) {
-        return {
-            output: {
-                help: "Use hook.harvest via `aria call` or the persistent headless server.",
-                actions: [
-                    "--extract: session extraction WITH LLM",
-                    "--stats: health dashboard (includes learning velocity + dupe rate)",
-                    "--cleanup: garbage removal",
-                    "--all: extract + stats",
-                    "--feedback: (deprecated, no-op)",
-                ],
-            },
-        };
-    }
-    const results = {};
-    if (flags.extract) {
-        process.stderr.write("[harvest] Running extraction...\n");
-        throwIfAborted(options.signal);
-        results.extract = toHarvestExtractResult(await actionReflect(memoria, router, "", options));
-    }
-    if (flags.stats) {
-        try {
-            throwIfAborted(options.signal);
-            results.stats = await memoria.reflect({ full: false });
-            throwIfAborted(options.signal);
-        }
-        catch (err) {
-            throwIfAborted(options.signal);
-            results.stats = { error: err instanceof Error ? err.message : String(err) };
-        }
-    }
-    if (flags.cleanup) {
-        results.cleanup = { skipped: true, message: "cleanup remains a no-op in headless cutover" };
-    }
-    if (flags.feedback) {
-        process.stderr.write("[harvest] --feedback is deprecated and has no effect.\n");
-        results.feedback = { deprecated: true };
-    }
-    return { output: results };
-}
-function toHarvestExtractResult(result) {
-    return result.output;
-}
-//# sourceMappingURL=hook-actions.js.map