@aria-cli/cli 1.0.51 → 1.0.54

package/dist/commands/daemon.js

@@ -1,245 +0,0 @@
-/**
- * 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

@@ -1,176 +0,0 @@
-/**
- * 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

@@ -1,74 +0,0 @@
-/**
- * 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