@aria-cli/cli 1.0.51 → 1.0.54

package/dist/commands/logout-handler.js

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

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

@@ -1,60 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,265 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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