@aria-cli/cli 1.0.50 → 1.0.51

package/dist/commands/daemon.js

@@ -0,0 +1,245 @@
+/**
+ * Daemon command - monitor-style projection over the shared daemon service.
+ *
+ * The CLI wrapper only parses options, starts/stops the daemon via the
+ * canonical `daemon.*` service, prints human status lines, and stays resident
+ * until interrupted. It must not own runtime bootstrap semantics directly.
+ */
+import { createCliContext } from "../cli-context.js";
+import { loadConfig } from "../config.js";
+import { createDaemonService } from "../headless/daemon-service.js";
+function formatStorageDiagnostics(storage) {
+    if (!storage || typeof storage !== "object") {
+        return [];
+    }
+    const lines = [];
+    const storageRecord = storage;
+    for (const [label, raw] of Object.entries(storageRecord)) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const value = raw;
+        const parts = [
+            `backend=${String(value.backend ?? "unknown")}`,
+            `extensions=${String(value.loadableExtensions ?? false)}`,
+            `customSQLite=${String(value.customSQLiteConfigured ?? false)}`,
+        ];
+        if (typeof value.sqliteVec === "boolean") {
+            parts.push(`sqliteVec=${String(value.sqliteVec)}`);
+        }
+        if (typeof value.vectorSearchMode === "string") {
+            parts.push(`vectorMode=${value.vectorSearchMode}`);
+        }
+        if (typeof value.customSQLitePath === "string") {
+            parts.push(`sqlitePath=${value.customSQLitePath}`);
+        }
+        lines.push(`[daemon] storage.${label} ${parts.join(" · ")}`);
+    }
+    return lines;
+}
+function parsePositiveInt(raw, field, fallback) {
+    if (raw === undefined || raw.trim() === "")
+        return fallback;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`${field} must be a positive integer`);
+    }
+    return value;
+}
+function parseCsv(raw) {
+    if (!raw)
+        return undefined;
+    const values = raw
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return values.length > 0 ? values : undefined;
+}
+function parsePort(raw, fallback) {
+    if (raw === undefined || raw.trim() === "")
+        return fallback;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error("port must be a non-negative integer (0 = OS-assigned)");
+    }
+    return value;
+}
+function parseDaemonOptions(options) {
+    return {
+        arion: options.arion,
+        port: parsePort(options.port, 0),
+        intervalMs: parsePositiveInt(options.intervalMs, "intervalMs", 60_000),
+        allowedToolCategories: parseCsv(options.allowedToolCategories),
+        allowedShellCommands: parseCsv(options.allowedShellCommands),
+        maxWriteOpsPerMinute: options.maxWriteOpsPerMinute !== undefined
+            ? parsePositiveInt(options.maxWriteOpsPerMinute, "maxWriteOpsPerMinute", 30)
+            : undefined,
+        maxGitPushesPerHour: options.maxGitPushesPerHour !== undefined
+            ? parsePositiveInt(options.maxGitPushesPerHour, "maxGitPushesPerHour", 5)
+            : undefined,
+        foreground: options.foreground === true,
+    };
+}
+function waitForAbort(signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        signal.addEventListener("abort", () => resolve(), { once: true });
+    });
+}
+function toDaemonInput(options) {
+    return {
+        ...(options.arion ? { arion: options.arion } : {}),
+        ...(options.port >= 0 ? { port: options.port } : {}),
+        intervalMs: options.intervalMs,
+        ...(options.allowedToolCategories
+            ? { allowedToolCategories: options.allowedToolCategories }
+            : {}),
+        ...(options.allowedShellCommands ? { allowedShellCommands: options.allowedShellCommands } : {}),
+        ...(typeof options.maxWriteOpsPerMinute === "number"
+            ? { maxWriteOpsPerMinute: options.maxWriteOpsPerMinute }
+            : {}),
+        ...(typeof options.maxGitPushesPerHour === "number"
+            ? { maxGitPushesPerHour: options.maxGitPushesPerHour }
+            : {}),
+    };
+}
+export function buildSafetyPolicy(options) {
+    const policy = {};
+    if (options.allowedToolCategories) {
+        policy.allowedToolCategories = options.allowedToolCategories;
+    }
+    if (options.allowedShellCommands) {
+        policy.allowedShellCommands = options.allowedShellCommands;
+    }
+    if (typeof options.maxWriteOpsPerMinute === "number") {
+        policy.maxWriteOpsPerMinute = options.maxWriteOpsPerMinute;
+    }
+    if (typeof options.maxGitPushesPerHour === "number") {
+        policy.maxGitPushesPerHour = options.maxGitPushesPerHour;
+    }
+    return policy;
+}
+export async function runDaemonFromCli(options = {}) {
+    const parsed = parseDaemonOptions(options);
+    await runDaemon(parsed);
+}
+export async function stopDaemonFromCli() {
+    const { resolveRuntimeRootDirectory, findRuntimeOwnerRecordByAriaHome, removeRuntimeOwnerRecord, } = await import("@aria-cli/server");
+    const { getAriaDir } = await import("../config.js");
+    const ariaHome = getAriaDir();
+    const runtimeRoot = resolveRuntimeRootDirectory();
+    const owner = findRuntimeOwnerRecordByAriaHome(runtimeRoot, ariaHome);
+    if (!owner) {
+        console.log("[daemon] no running daemon found");
+        return;
+    }
+    try {
+        process.kill(owner.runtimePid, "SIGINT");
+        console.log(`[daemon] sent SIGINT to pid ${owner.runtimePid}`);
+        // Wait for process to exit
+        const deadline = Date.now() + 5_000;
+        while (Date.now() < deadline) {
+            try {
+                process.kill(owner.runtimePid, 0);
+                await new Promise((r) => setTimeout(r, 200));
+            }
+            catch {
+                break; // Process exited
+            }
+        }
+        // Force kill if still alive
+        try {
+            process.kill(owner.runtimePid, 0);
+            process.kill(owner.runtimePid, "SIGKILL");
+            console.log(`[daemon] force-killed pid ${owner.runtimePid}`);
+        }
+        catch {
+            // Already dead — good
+        }
+    }
+    catch {
+        // PID doesn't exist — stale record
+    }
+    removeRuntimeOwnerRecord(runtimeRoot, owner.nodeId);
+    console.log("[daemon] stopped");
+}
+export async function restartDaemonFromCli(options = {}) {
+    await stopDaemonFromCli();
+    await new Promise((r) => setTimeout(r, 500));
+    const { ensureDaemon } = await import("../ensure-daemon.js");
+    const cliContext = await createCliContext();
+    const conn = await ensureDaemon(cliContext);
+    const peers = await conn.control.listPeers();
+    console.log(`[daemon] restarted (${peers.length} peers connected)`);
+    await cliContext.pool?.closeAll?.();
+}
+async function runDaemon(options) {
+    const config = loadConfig();
+    const arionName = options.arion?.trim() || config.activeArion?.trim() || "ARIA";
+    const cliContext = await createCliContext({ startupMode: "daemon" });
+    const daemonService = createDaemonService({
+        cli: cliContext,
+        cwd: process.cwd(),
+        arionName,
+    });
+    try {
+        const status = await daemonService.start(toDaemonInput(options));
+        console.log(`[daemon] runtime node ${String(status.nodeId ?? "unknown")}`);
+        console.log(`[daemon] runtime ${String(status.runtimeId ?? "unknown")} listening on port ${String(status.port ?? "unknown")}`);
+        console.log(`[daemon] running arion "${arionName}" (interval ${options.intervalMs}ms)`);
+        for (const line of formatStorageDiagnostics(status.storage)) {
+            console.log(line);
+        }
+    }
+    catch (err) {
+        console.error(`[daemon] Runtime startup failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+        await cliContext.pool.closeAll().catch(() => { });
+        return;
+    }
+    // ── Default mode: print status and exit ──────────────────────────
+    // The detached daemon child is self-sufficient. The CLI wrapper does
+    // not need to stay resident. Use --foreground to keep a monitor alive.
+    if (!options.foreground) {
+        console.log("[daemon] started (use --foreground to keep this process as a monitor)");
+        await cliContext.pool.closeAll().catch(() => { });
+        return;
+    }
+    // ── Foreground monitor mode ──────────────────────────────────────
+    // Stay resident and poll status. Ctrl-C stops both this monitor and
+    // the daemon (via shouldStopOnShutdown).
+    console.log("[daemon] foreground monitor active (Ctrl-C to stop daemon)");
+    const controller = new AbortController();
+    const onSigint = () => controller.abort();
+    const onSigterm = () => controller.abort();
+    const onSighup = () => {
+        // Attached-client terminal hangups must not stop the runtime by themselves.
+    };
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    process.on("SIGHUP", onSighup);
+    const statusPoll = setInterval(() => {
+        void daemonService.status({}).catch(() => { });
+    }, Math.min(Math.max(options.intervalMs, 1_000), 5_000));
+    try {
+        await waitForAbort(controller.signal);
+    }
+    finally {
+        clearInterval(statusPoll);
+        try {
+            if (controller.signal.aborted && daemonService.shouldStopOnShutdown?.()) {
+                await daemonService.stop?.(toDaemonInput(options));
+            }
+        }
+        catch {
+            // Stop is best-effort during shutdown.
+        }
+        await daemonService.releaseAll?.();
+        await cliContext.pool.closeAll().catch(() => { });
+        process.removeListener("SIGINT", onSigint);
+        process.removeListener("SIGTERM", onSigterm);
+        process.removeListener("SIGHUP", onSighup);
+        console.log("[daemon] stopped");
+    }
+}
+//# sourceMappingURL=daemon.js.map

package/dist/commands/definitions.js

@@ -0,0 +1,176 @@
+/**
+ * Command definitions for the CLI
+ */
+export const COMMANDS = [
+    // Arion commands
+    {
+        name: "become",
+        description: "Switch to another arion",
+        usage: "/become <name>",
+        args: ["<name>"],
+        requiresArgs: true,
+    },
+    { name: "arions", description: "List all arions", args: [] },
+    {
+        name: "hatch",
+        description: "Create a new arion",
+        usage: "/hatch <name> [description]",
+        args: ["<name>", "[description]"],
+        requiresArgs: true,
+    },
+    {
+        name: "rest",
+        description: "Put an arion to rest",
+        usage: "/rest <name>",
+        args: ["<name>"],
+        requiresArgs: true,
+    },
+    {
+        name: "wake",
+        description: "Wake a resting arion",
+        usage: "/wake <name>",
+        args: ["<name>"],
+        requiresArgs: true,
+    },
+    // Model commands
+    {
+        name: "model",
+        description: "Change or view current AI model",
+        usage: "/model [name|list|refresh] [--provider <name>] [--use-env]",
+        args: ["[name|list|refresh]", "[--provider <name>]", "[--use-env]"],
+    },
+    // Safety commands
+    {
+        name: "autonomy",
+        description: "Change permission approval policy",
+        usage: "/autonomy [level]",
+        args: ["[level]"],
+    },
+    // Sound commands
+    {
+        name: "sound",
+        description: "Open sound preferences or toggle notifications",
+        usage: "/sound [on|off]",
+        args: ["[on|off]"],
+    },
+    // Memory commands
+    {
+        name: "remember",
+        description: "Store a memory",
+        usage: "/remember <text>",
+        args: ["<text>"],
+        requiresArgs: true,
+    },
+    {
+        name: "recall",
+        description: "Search memories",
+        usage: "/recall <query>",
+        args: ["<query>"],
+        requiresArgs: true,
+    },
+    {
+        name: "recall_knowledge",
+        description: "Search learned tools (skills, procedures, techniques)",
+        usage: "/recall_knowledge <topic>",
+        args: ["<topic>"],
+        requiresArgs: true,
+    },
+    {
+        name: "send",
+        description: "Send a peer or same-home client message through the runtime transport",
+        usage: "/send <peer-name|node-id|client-id> <message>",
+        args: ["<peer-name|node-id|client-id>", "<message>"],
+        requiresArgs: true,
+    },
+    {
+        name: "forget",
+        description: "Delete a memory",
+        usage: "/forget <id>",
+        args: ["<id>"],
+        requiresArgs: true,
+    },
+    { name: "memories", description: "Browse all memories", args: [] },
+    // Session commands
+    {
+        name: "resume",
+        description: "Resume a previous session",
+        args: ["[session-id]"],
+    },
+    {
+        name: "fork",
+        description: "Fork the current session into a new branch",
+        usage: "/fork [session-id] [message-count] [--stay]",
+        args: ["[session-id]", "[message-count]", "[--stay]"],
+    },
+    { name: "clear", description: "Clear the screen", args: [] },
+    // Auth commands
+    {
+        name: "login",
+        description: "Authenticate with provider (bedrock, anthropic, openai, google, copilot)",
+        usage: "/login [provider] [api-key|--profile <label>|--source <gh|device>]",
+        args: ["[provider]", "[api-key|flags]"],
+    },
+    {
+        name: "logout",
+        description: "Disconnect a provider or clear all credentials",
+        usage: "/logout [provider|all]",
+        args: ["[provider|all]"],
+    },
+    {
+        name: "auth",
+        description: "Auth utilities such as importing env credentials into session scope",
+        usage: "/auth import-env [provider ...] | /auth clear-session | /auth status-session",
+        args: ["import-env|clear-session|status-session", "[provider ...]"],
+    },
+    // System commands
+    { name: "help", description: "Show available commands", args: [] },
+    {
+        name: "daemon",
+        description: "Open daemon control panel or run start/stop/restart",
+        usage: "/daemon [start|stop|restart]",
+        args: ["[start|stop|restart]"],
+    },
+    {
+        name: "terminal-setup",
+        description: "Install Shift+Enter newline key binding for supported terminals",
+        usage: "/terminal-setup",
+        args: [],
+    },
+    // Display commands
+    {
+        name: "theme",
+        description: "View or change the color theme",
+        usage: "/theme [name]",
+        args: ["[name]"],
+    },
+    // Peer discovery commands
+    {
+        name: "invite",
+        description: "Create an internet invite token",
+        usage: "/invite [label]",
+        args: ["[label]"],
+    },
+    {
+        name: "join",
+        description: "Accept an internet invite token",
+        usage: "/join [token]",
+        args: ["[token]"],
+    },
+    { name: "peers", description: "Show nearby peers and connect", args: [] },
+    { name: "clients", description: "Show same-home attached clients", args: [] },
+    { name: "exit", description: "Exit ARIA", args: [] },
+];
+/**
+ * Get a command by name
+ */
+export function getCommand(name) {
+    return COMMANDS.find((c) => c.name === name);
+}
+/**
+ * Filter commands by prefix
+ */
+export function filterCommands(prefix) {
+    const lower = prefix.toLowerCase();
+    return COMMANDS.filter((c) => c.name.toLowerCase().startsWith(lower));
+}
+//# sourceMappingURL=definitions.js.map

package/dist/commands/index.js

@@ -0,0 +1,74 @@
+/**
+ * ARIA CLI Commands - Command infrastructure using Commander.js
+ */
+import { Command } from "commander";
+import { createArionsCommand } from "./arions.js";
+import { createAuthCommand } from "./auth.js";
+import { runDaemonFromCli, stopDaemonFromCli, restartDaemonFromCli } from "./daemon.js";
+import { createHeadlessCallCommand } from "../headless/call-command.js";
+import { createPairingCommand } from "./pairing.js";
+import { createRuntimeCutoverResetCommand } from "./runtime-cutover-reset-command.js";
+import { startHeadlessStdioServer } from "../headless/stdio-server.js";
+// Create the main program
+export const program = new Command();
+import { CLI_VERSION } from "../release-notes.js";
+program
+    .name("aria")
+    .description("ARIA - Adaptive Reasoning Intelligence Agent")
+    .version(CLI_VERSION);
+// Arions command - Manage Arion personas
+program.addCommand(createArionsCommand());
+// Auth command - Manage API keys
+program.addCommand(createAuthCommand());
+// Pairing command - End-user internet invite/join
+program.addCommand(createPairingCommand());
+program
+    .command("headless")
+    .description("Run the persistent headless stdio control server")
+    .option("--arion <name>", "Arion name for per-Arion session context")
+    .action(async (options) => {
+    await startHeadlessStdioServer({
+        cwd: process.cwd(),
+        arionName: options.arion,
+    });
+});
+program.addCommand(createHeadlessCallCommand());
+// Daemon command group
+const daemonCmd = program.command("daemon").description("Manage the ARIA daemon");
+daemonCmd
+    .command("start", { isDefault: true })
+    .description("Start the daemon (default: launch and exit; use --foreground to stay resident)")
+    .option("--arion <name>", "Run daemon for a specific Arion")
+    .option("--port <port>", "Server port (default: 0 = OS-assigned)")
+    .option("--interval-ms <ms>", "Wake loop interval in milliseconds (default: 60000)")
+    .option("--foreground", "Stay resident as a monitor (Ctrl-C stops the daemon)")
+    .option("--allowed-tool-categories <list>", "Comma-separated tool category allowlist")
+    .option("--allowed-shell-commands <list>", "Comma-separated shell command prefix allowlist")
+    .option("--max-write-ops-per-minute <count>", "Rate limit for write operations per minute")
+    .option("--max-git-pushes-per-hour <count>", "Rate limit for git pushes per hour")
+    .action(async (options) => {
+    await runDaemonFromCli(options);
+});
+daemonCmd
+    .command("stop")
+    .description("Stop the running daemon")
+    .action(async () => {
+    await stopDaemonFromCli();
+});
+daemonCmd
+    .command("restart")
+    .description("Stop the daemon and start a fresh one")
+    .action(async () => {
+    await restartDaemonFromCli();
+});
+program.addCommand(createRuntimeCutoverResetCommand());
+// Export for use in bin/aria.js
+export { createArionsCommand } from "./arions.js";
+export { createAuthCommand } from "./auth.js";
+export { createHeadlessCallCommand } from "../headless/call-command.js";
+export { runDaemonFromCli } from "./daemon.js";
+export { createPairingCommand } from "./pairing.js";
+export { createRuntimeCutoverResetCommand } from "./runtime-cutover-reset-command.js";
+export { startHeadlessStdioServer } from "../headless/stdio-server.js";
+export { runtimeCutoverResetCommand } from "./runtime-cutover-reset.js";
+//# sourceMappingURL=index.js.map