@aria-cli/cli 1.0.49 → 1.0.51

package/dist/commands/logout-handler.js

@@ -0,0 +1,92 @@
+/**
+ * Slash command handler for /logout -- disconnect providers and clear credentials.
+ *
+ * Supports two result modes:
+ * - PickerResult:  `/logout` with no args -> list connected/expired providers
+ * - DirectResult:  `/logout <provider>` or `/logout all` -> immediate disconnect
+ */
+import { ensureAuthProfileStore, listProfilesForProvider, updateAuthProfileStoreWithLockSync, } from "@aria-cli/auth";
+import { getProviderOptions } from "./login-handler.js";
+// ---------------------------------------------------------------------------
+// disconnectProvider -- remove all profiles for a given provider
+// ---------------------------------------------------------------------------
+function disconnectProvider(provider) {
+    const store = ensureAuthProfileStore();
+    const profileIds = listProfilesForProvider(store, provider);
+    if (profileIds.length === 0) {
+        return {
+            success: false,
+            message: `No credentials found for "${provider}"`,
+        };
+    }
+    updateAuthProfileStoreWithLockSync({
+        updater: (freshStore) => {
+            for (const id of profileIds) {
+                const providerKey = freshStore.profiles[id]?.provider;
+                delete freshStore.profiles[id];
+                if (providerKey && freshStore.lastGood) {
+                    delete freshStore.lastGood[providerKey];
+                }
+            }
+            if (freshStore.usageStats) {
+                for (const id of profileIds) {
+                    delete freshStore.usageStats[id];
+                }
+            }
+            return true;
+        },
+    });
+    const plural = profileIds.length === 1 ? "profile" : "profiles";
+    return {
+        success: true,
+        message: `Disconnected ${provider} (removed ${profileIds.length} ${plural})`,
+    };
+}
+// ---------------------------------------------------------------------------
+// disconnectAll -- clear every profile in the store
+// ---------------------------------------------------------------------------
+function disconnectAll() {
+    const store = ensureAuthProfileStore();
+    const count = Object.keys(store.profiles).length;
+    if (count === 0) {
+        return { success: false, message: "No providers connected" };
+    }
+    updateAuthProfileStoreWithLockSync({
+        updater: (freshStore) => {
+            freshStore.profiles = {};
+            freshStore.lastGood = undefined;
+            freshStore.usageStats = undefined;
+            return true;
+        },
+    });
+    const plural = count === 1 ? "profile" : "profiles";
+    return {
+        success: true,
+        message: `Cleared all credentials (${count} ${plural} removed)`,
+    };
+}
+// ---------------------------------------------------------------------------
+// handleLogoutCommand -- entry point from REPL command dispatch
+// ---------------------------------------------------------------------------
+export function handleLogoutCommand(args) {
+    const trimmed = args.trim().toLowerCase();
+    // /logout all -> clear everything
+    if (trimmed === "all") {
+        return { mode: "direct", result: disconnectAll() };
+    }
+    // /logout <provider> -> disconnect specific provider
+    if (trimmed) {
+        return { mode: "direct", result: disconnectProvider(trimmed) };
+    }
+    // /logout (no args) -> show connected/expired providers
+    const allProviders = getProviderOptions();
+    const connected = allProviders.filter((p) => p.status !== "none");
+    if (connected.length === 0) {
+        return {
+            mode: "direct",
+            result: { success: true, message: "No providers connected" },
+        };
+    }
+    return { mode: "picker", providers: connected };
+}
+//# sourceMappingURL=logout-handler.js.map

package/dist/commands/memory-handlers.js

@@ -0,0 +1,89 @@
+/**
+ * Slash command handlers for memory operations.
+ *
+ * Thin wrappers around Memoria API for testable command dispatch.
+ * Used by the REPL command pipeline and E2E tests.
+ */
+export async function handleRememberCommand(args, memoria) {
+    const content = args.trim();
+    if (!content) {
+        return { success: false, message: "Usage: /remember <text to remember>" };
+    }
+    try {
+        const memory = await memoria.remember(content);
+        if (!memory || !memory.id) {
+            return {
+                success: false,
+                message: "Failed to store memory (system closed or degraded)",
+            };
+        }
+        const count = await memoria.count();
+        const preview = content.length > 50 ? content.slice(0, 50) + "..." : content;
+        return {
+            success: true,
+            message: `Remembered: "${preview}"`,
+            data: { id: memory.id, count },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Error remembering: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export async function handleRecallCommand(args, memoria) {
+    const query = args.trim();
+    if (!query) {
+        return { success: false, message: "Usage: /recall <query>" };
+    }
+    try {
+        const results = await memoria.recall(query);
+        if (results.memories.length === 0) {
+            return {
+                success: true,
+                message: "No memories found matching your query.",
+                data: { count: 0, memories: [] },
+            };
+        }
+        return {
+            success: true,
+            message: `Found ${results.memories.length} memories:`,
+            data: { count: results.memories.length, memories: results.memories },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Error recalling: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export async function handleForgetCommand(args, memoria) {
+    const id = args.trim();
+    if (!id) {
+        return { success: false, message: "Usage: /forget <memory-id>" };
+    }
+    try {
+        const deleted = await memoria.deleteMemory(id);
+        if (deleted) {
+            return {
+                success: true,
+                message: `Deleted memory ${id}.`,
+                data: { deleted: true },
+            };
+        }
+        return {
+            success: true,
+            message: `Memory ${id} not found or already deleted.`,
+            data: { deleted: false },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Error forgetting: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+//# sourceMappingURL=memory-handlers.js.map

package/dist/commands/pairing.js

@@ -0,0 +1,60 @@
+import { Command } from "commander";
+import { createCliContext } from "../cli-context.js";
+import { ensureDaemon } from "../ensure-daemon.js";
+function parseDurationMs(rawValue) {
+    const parsed = Number.parseInt(rawValue, 10);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new Error(`Invalid --duration-ms value: ${rawValue}`);
+    }
+    return parsed;
+}
+export function createPairingCommand() {
+    const pairing = new Command("pairing").description("Invite and join peers over the internet");
+    pairing
+        .command("invite")
+        .description("Create an end-user internet pairing invite")
+        .argument("[label]", "Optional local label for the invite")
+        .option("--duration-ms <ms>", "Invite lifetime in milliseconds", parseDurationMs)
+        .action(async (label, options) => {
+        const ctx = await createCliContext();
+        try {
+            const { control } = await ensureDaemon(ctx);
+            const result = await control.createInvite({
+                ...(label?.trim() ? { inviteLabel: label.trim() } : {}),
+                ...(typeof options?.durationMs === "number" ? { durationMs: options.durationMs } : {}),
+            });
+            console.log("Invite token:");
+            console.log(result.inviteToken);
+            console.log("");
+            console.log(`Join with: aria pairing join ${result.inviteToken}`);
+        }
+        catch (error) {
+            console.error(`Failed to create invite: ${error.message}`);
+            process.exit(1);
+        }
+        finally {
+            await ctx.pool?.closeAll?.();
+        }
+    });
+    pairing
+        .command("join")
+        .description("Accept an internet pairing invite token")
+        .argument("<token>", "Invite token to accept")
+        .action(async (token) => {
+        const ctx = await createCliContext();
+        try {
+            const { control } = await ensureDaemon(ctx);
+            const result = await control.acceptInviteToken({ inviteToken: token.trim() });
+            console.log(`Paired with ${result.displayNameSnapshot ?? result.nodeId}`);
+        }
+        catch (error) {
+            console.error(`Failed to accept invite: ${error.message}`);
+            process.exit(1);
+        }
+        finally {
+            await ctx.pool?.closeAll?.();
+        }
+    });
+    return pairing;
+}
+//# sourceMappingURL=pairing.js.map

package/dist/commands/runtime-cutover-reset-command.js

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+export function createRuntimeCutoverResetCommand() {
+    return new Command("runtime-cutover-reset")
+        .description("Destructively clear stale runtime state while preserving local node identity by default")
+        .option("--full-reset", "Also remove local node identity material")
+        .option("--json", "Emit the reset report as JSON")
+        .action(async (options) => {
+        const { runtimeCutoverResetCommand } = await import("./runtime-cutover-reset.js");
+        await runtimeCutoverResetCommand(options);
+    });
+}
+//# sourceMappingURL=runtime-cutover-reset-command.js.map

package/dist/commands/runtime-cutover-reset.js

@@ -0,0 +1,265 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveRuntimeRootDirectory, runtimeSocketsDirectory } from "@aria-cli/server";
+import { openCompatSqliteDatabase } from "@aria-cli/tools";
+import { getAriaDir } from "../config.js";
+function canonicalizeAriaHome(ariaHome) {
+    const resolved = path.resolve(ariaHome);
+    try {
+        return fs.realpathSync.native(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+function resolveMachineDirectory() {
+    return path.join(process.env.HOME ?? "/tmp", ".aria");
+}
+function nodeStorePathForAriaHome(ariaHome) {
+    return path.join(ariaHome, "node", "node-state.db");
+}
+function nodeStoreLockPathForAriaHome(ariaHome) {
+    return `${nodeStorePathForAriaHome(ariaHome)}.lock`;
+}
+function runtimeCutoverReportPath(ariaHome) {
+    return path.join(ariaHome, "node", "runtime-cutover-last-report.json");
+}
+function isPidAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function removeIfExists(targetPath, report) {
+    if (!fs.existsSync(targetPath)) {
+        report.skippedPaths.push(targetPath);
+        return;
+    }
+    fs.rmSync(targetPath, { recursive: true, force: true });
+    report.removedPaths.push(targetPath);
+}
+function removeDatabaseFamily(dbPath, report) {
+    for (const candidate of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+        removeIfExists(candidate, report);
+    }
+}
+function listArionDirectories(ariaHome) {
+    const arionsDir = path.join(ariaHome, "arions");
+    if (!fs.existsSync(arionsDir)) {
+        return [];
+    }
+    return fs
+        .readdirSync(arionsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(arionsDir, entry.name));
+}
+function collectLiveOwnerProjectionPids(runtimeRoot) {
+    const ownersDir = path.join(runtimeRoot, "owners");
+    if (!fs.existsSync(ownersDir)) {
+        return [];
+    }
+    const pids = new Set();
+    for (const entry of fs.readdirSync(ownersDir)) {
+        if (!entry.endsWith(".json"))
+            continue;
+        try {
+            const raw = fs.readFileSync(path.join(ownersDir, entry), "utf8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.runtimePid === "number" && isPidAlive(parsed.runtimePid)) {
+                pids.add(parsed.runtimePid);
+            }
+        }
+        catch {
+            // Ignore malformed stale projections — reset will remove them later.
+        }
+    }
+    return [...pids];
+}
+function collectLiveJsonPidFiles(root, matcher, pidExtractor) {
+    if (!fs.existsSync(root)) {
+        return [];
+    }
+    const pids = new Set();
+    for (const entry of fs.readdirSync(root)) {
+        if (!matcher(entry))
+            continue;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(root, entry), "utf8"));
+            const pid = pidExtractor(parsed);
+            if (pid !== null && isPidAlive(pid)) {
+                pids.add(pid);
+            }
+        }
+        catch {
+            // Ignore malformed or stale artifacts; reset will remove them later.
+        }
+    }
+    return [...pids];
+}
+function collectLivePresencePids(machineDir) {
+    return collectLiveJsonPidFiles(machineDir, (entry) => entry.startsWith("presence-") && entry.endsWith(".json"), (parsed) => {
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            "pid" in parsed &&
+            typeof parsed.pid === "number") {
+            return parsed.pid;
+        }
+        return null;
+    });
+}
+function collectLiveNodeStoreOwnerPids(ariaHome) {
+    const dbPath = nodeStorePathForAriaHome(ariaHome);
+    if (!fs.existsSync(dbPath)) {
+        return [];
+    }
+    const db = openCompatSqliteDatabase({ path: dbPath });
+    try {
+        const rows = db
+            .prepare(`SELECT runtime_pid
+           FROM runtime_owner_records`)
+            .all();
+        return rows
+            .map((row) => row.runtime_pid)
+            .filter((pid) => Number.isFinite(pid) && isPidAlive(pid));
+    }
+    catch {
+        return [];
+    }
+    finally {
+        db.close();
+    }
+}
+function assertNoLiveRuntimeArtifacts(ariaHome, runtimeRoot) {
+    const machineDir = resolveMachineDirectory();
+    const presencePids = collectLivePresencePids(machineDir);
+    const ownerPids = collectLiveOwnerProjectionPids(runtimeRoot);
+    const nodeStoreOwnerPids = collectLiveNodeStoreOwnerPids(ariaHome);
+    const livePids = [...new Set([...presencePids, ...ownerPids, ...nodeStoreOwnerPids])];
+    if (livePids.length > 0) {
+        throw new Error(`[runtime-cutover-reset] refuse live runtime mutation while runtime is live (pids: ${livePids.join(", ")}). Stop all ARIA daemons/clients first.`);
+    }
+}
+function clearNodeStoreRuntimeState(ariaHome, report) {
+    const dbPath = nodeStorePathForAriaHome(ariaHome);
+    if (!fs.existsSync(dbPath)) {
+        return { runtimeOwnerRecords: 0, runtimeEvents: 0 };
+    }
+    const db = openCompatSqliteDatabase({ path: dbPath });
+    try {
+        const runtimeOwnerRecords = db.prepare(`DELETE FROM runtime_owner_records`).run().changes;
+        const runtimeEvents = db.prepare(`DELETE FROM runtime_events`).run().changes;
+        report.preservedPaths.push(dbPath);
+        return { runtimeOwnerRecords, runtimeEvents };
+    }
+    finally {
+        db.close();
+    }
+}
+function removeMachineArtifacts(ariaHome, report) {
+    const machineDir = resolveMachineDirectory();
+    removeIfExists(path.join(machineDir, "mesh-events.db"), report);
+    removeIfExists(path.join(machineDir, "mesh-events.db-wal"), report);
+    removeIfExists(path.join(machineDir, "mesh-events.db-shm"), report);
+    removeIfExists(path.join(machineDir, "event_queue"), report);
+    removeIfExists(path.join(machineDir, "event_queue.db"), report);
+    removeIfExists(path.join(machineDir, "event_queue.db-wal"), report);
+    removeIfExists(path.join(machineDir, "event_queue.db-shm"), report);
+    removeIfExists(path.join(resolveRuntimeRootDirectory(), "host-supervisor.sock"), report);
+    const cleanupRoots = [...new Set([machineDir, ariaHome])];
+    for (const root of cleanupRoots) {
+        if (!fs.existsSync(root)) {
+            continue;
+        }
+        for (const entry of fs.readdirSync(root)) {
+            const isDaemonInfo = entry.startsWith("daemon-info-") &&
+                (entry.endsWith(".json") || entry.endsWith(".json.lock"));
+            const isPresence = root === machineDir && entry.startsWith("presence-") && entry.endsWith(".json");
+            if (isDaemonInfo || isPresence) {
+                removeIfExists(path.join(root, entry), report);
+            }
+        }
+    }
+}
+function removeAriaHomeArtifacts(ariaHome, runtimeRoot, fullReset, report) {
+    removeDatabaseFamily(path.join(ariaHome, "network", "state.db"), report);
+    removeIfExists(path.join(ariaHome, "network", "trusted-cas"), report);
+    removeIfExists(path.join(ariaHome, "server-session-history.json"), report);
+    removeIfExists(path.join(ariaHome, "sessions"), report);
+    removeDatabaseFamily(path.join(ariaHome, "history.db"), report);
+    for (const arionDir of listArionDirectories(ariaHome)) {
+        removeDatabaseFamily(path.join(arionDir, "memory.db"), report);
+        removeDatabaseFamily(path.join(arionDir, "history.db"), report);
+        removeIfExists(path.join(arionDir, "daemon"), report);
+        removeIfExists(path.join(arionDir, "logs"), report);
+    }
+    removeIfExists(path.join(runtimeRoot, "owners"), report);
+    removeIfExists(runtimeSocketsDirectory(runtimeRoot), report);
+    if (fullReset) {
+        removeDatabaseFamily(nodeStorePathForAriaHome(ariaHome), report);
+        removeIfExists(nodeStoreLockPathForAriaHome(ariaHome), report);
+        removeIfExists(path.join(ariaHome, "network", "config.json"), report);
+        removeIfExists(path.join(ariaHome, "network", "tls"), report);
+        return { runtimeOwnerRecords: 0, runtimeEvents: 0 };
+    }
+    report.preservedPaths.push(path.join(ariaHome, "network", "config.json"));
+    report.preservedPaths.push(path.join(ariaHome, "network", "tls"));
+    return clearNodeStoreRuntimeState(ariaHome, report);
+}
+function writeReport(report) {
+    fs.mkdirSync(path.dirname(report.reportPath), { recursive: true });
+    fs.writeFileSync(report.reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+    return report;
+}
+function printHumanReport(report) {
+    console.log("[runtime-cutover-reset] completed");
+    console.log(`  ariaHome: ${report.ariaHome}`);
+    console.log(`  fullReset: ${report.fullReset ? "yes" : "no"}`);
+    console.log(`  preserveLocalNodeIdentity: ${report.preserveLocalNodeIdentity ? "yes" : "no"}`);
+    console.log(`  deleted: ${report.deletedPaths.length}`);
+    console.log(`  preserved: ${report.preservedPaths.length}`);
+    console.log(`  cleared runtime owner records: ${report.cleared.runtimeOwnerRecords}`);
+    console.log(`  cleared runtime journal events: ${report.cleared.runtimeEvents}`);
+    console.log(`  report: ${report.reportPath}`);
+}
+export async function runRuntimeCutoverReset(options = {}) {
+    const ariaHome = canonicalizeAriaHome(options.ariaHome ?? getAriaDir());
+    const runtimeRoot = resolveRuntimeRootDirectory();
+    const fullNodeReset = options.fullNodeReset ?? options.fullReset ?? false;
+    const preserveLocalNodeIdentity = options.preserveLocalNodeIdentity ?? !fullNodeReset;
+    assertNoLiveRuntimeArtifacts(ariaHome, runtimeRoot);
+    const report = {
+        ariaHome,
+        runtimeRoot,
+        generatedAt: new Date().toISOString(),
+        fullReset: fullNodeReset,
+        fullNodeReset,
+        preserveLocalNodeIdentity,
+        reportPath: runtimeCutoverReportPath(ariaHome),
+        removedPaths: [],
+        deletedPaths: [],
+        preservedPaths: [],
+        skippedPaths: [],
+        cleared: {
+            runtimeOwnerRecords: 0,
+            runtimeEvents: 0,
+        },
+    };
+    removeMachineArtifacts(ariaHome, report);
+    report.cleared = removeAriaHomeArtifacts(ariaHome, runtimeRoot, fullNodeReset, report);
+    report.deletedPaths = [...report.removedPaths];
+    return writeReport(report);
+}
+export async function runtimeCutoverResetCommand(options = {}) {
+    const report = await runRuntimeCutoverReset(options);
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    printHumanReport(report);
+}
+//# sourceMappingURL=runtime-cutover-reset.js.map

package/dist/commands/terminal-setup.js

@@ -0,0 +1,84 @@
+import { EOL, homedir, platform } from "os";
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { spawnSync } from "node:child_process";
+import { loadConfig, saveConfig } from "../config.js";
+export function isShiftEnterKeyBindingInstalled() {
+    return loadConfig().shiftEnterKeyBindingInstalled === true;
+}
+export function isTerminalSetupSupported() {
+    const term = (process.env.TERM_PROGRAM ?? "").toLowerCase();
+    return (platform() === "darwin" && term === "iterm.app") || term === "vscode";
+}
+function installBindingsForITerm2() {
+    // Keep implementation shell-free for safety/parity with existing CLI code style.
+    // iTerm2 reads this defaults key for GlobalKeyMap.
+    const result = spawnSync("defaults", [
+        "write",
+        "com.googlecode.iterm2",
+        "GlobalKeyMap",
+        "-dict-add",
+        "0xd-0x20000-0x24",
+        `<dict>
+      <key>Text</key>
+      <string>\\n</string>
+      <key>Action</key>
+      <integer>12</integer>
+      <key>Version</key>
+      <integer>1</integer>
+      <key>Keycode</key>
+      <integer>13</integer>
+      <key>Modifiers</key>
+      <integer>131072</integer>
+    </dict>`,
+    ]);
+    if (result.status !== 0) {
+        throw new Error("Failed to install iTerm2 Shift+Enter key binding");
+    }
+    return `Installed iTerm2 Shift+Enter key binding${EOL}See iTerm2 → Preferences → Keys${EOL}`;
+}
+function installBindingsForVSCodeTerminal() {
+    const vscodeKeybindingsPath = join(homedir(), platform() === "win32"
+        ? join("AppData", "Roaming", "Code", "User")
+        : platform() === "darwin"
+            ? join("Library", "Application Support", "Code", "User")
+            : join(".config", "Code", "User"), "keybindings.json");
+    let keybindings = [];
+    try {
+        const content = readFileSync(vscodeKeybindingsPath, "utf-8").trim();
+        keybindings = content ? JSON.parse(content) : [];
+        if (!Array.isArray(keybindings)) {
+            keybindings = [];
+        }
+    }
+    catch {
+        // If file doesn't exist or parse fails, start with empty array.
+        keybindings = [];
+    }
+    const existingBinding = keybindings.find((binding) => binding.key === "shift+enter" &&
+        binding.command === "workbench.action.terminal.sendSequence" &&
+        binding.when === "terminalFocus");
+    if (existingBinding) {
+        return `Found existing VSCode terminal Shift+Enter key binding. Remove it to continue.${EOL}See ${vscodeKeybindingsPath}${EOL}`;
+    }
+    keybindings.push({
+        key: "shift+enter",
+        command: "workbench.action.terminal.sendSequence",
+        args: { text: "\\\r\n" },
+        when: "terminalFocus",
+    });
+    writeFileSync(vscodeKeybindingsPath, JSON.stringify(keybindings, null, 2), "utf-8");
+    return `Installed VSCode terminal Shift+Enter key binding${EOL}See ${vscodeKeybindingsPath}${EOL}`;
+}
+export function runTerminalSetup() {
+    if (!isTerminalSetupSupported()) {
+        throw new Error("terminal-setup is supported only in iTerm2 (macOS) and VSCode terminal");
+    }
+    const term = (process.env.TERM_PROGRAM ?? "").toLowerCase();
+    const result = term === "vscode" ? installBindingsForVSCodeTerminal() : installBindingsForITerm2();
+    const config = loadConfig();
+    config.shiftEnterKeyBindingInstalled = true;
+    saveConfig(config);
+    return result;
+}
+//# sourceMappingURL=terminal-setup.js.map