@aria-cli/cli 1.0.14

package/dist/ink-repl.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Ink-based REPL for ARIA CLI
+ * Modern React-based UI using Ink
+ */
+import { ArionSession } from "./session.js";
+import type { ArionManager } from "@aria-cli/aria";
+import { type AttachedLocalControlClient } from "./local-control-client.js";
+/** Minimal interface for the legacy Aria parameter until full AgentRunner migration */
+interface AriaCompat {
+    components: {
+        memoria: IMemoria;
+    };
+    recallUserName(): Promise<string | null>;
+    shutdown(): Promise<void>;
+}
+import { type ToolRegistry } from "@aria-cli/tools";
+import type { AuthResolver } from "@aria-cli/auth";
+import type { ModelRouter } from "@aria-cli/models";
+import { getCliModels, type CredentialHints } from "@aria-cli/models";
+import { type IMemoria } from "@aria-cli/types";
+import { type SessionHistory } from "./history/index.js";
+import type { CliContext } from "./cli-context.js";
+import type { ToolCall } from "@aria-cli/types";
+type ToolResult = {
+    id: string;
+    result: string;
+    isError: boolean;
+};
+type CliModelDefinition = ReturnType<typeof getCliModels>[number];
+export declare function executeToolCallsInOrder(toolCalls: ToolCall[], registry: ToolRegistry, executeSingleTool: (toolCall: ToolCall) => Promise<ToolResult>): Promise<ToolResult[]>;
+export declare function startInkRepl(session: ArionSession, manager: ArionManager, router: ModelRouter, aria: AriaCompat, attachedLocalControl: AttachedLocalControlClient, cliContext?: CliContext, inputHistory?: string[], onSaveInput?: (input: string) => void, sessionHistory?: SessionHistory, initialMessage?: string, cachedUserName?: string | null, resumeSessionId?: string, initialAvailableModels?: readonly CliModelDefinition[], refreshAvailableModels?: (force?: boolean) => Promise<readonly CliModelDefinition[]>, credentialHints?: CredentialHints, authResolver?: AuthResolver): Promise<void>;
+export {};

package/dist/local-control-bootstrap.d.ts

@@ -0,0 +1,5 @@
+import type { NodeId, RuntimeBootstrapRecord } from "@aria-cli/tools";
+export type RuntimeBootstrapSource = RuntimeBootstrapRecord | (() => RuntimeBootstrapRecord | Promise<RuntimeBootstrapRecord>);
+export declare function selectBootstrapTlsIdentity(bootstrap: RuntimeBootstrapRecord): string;
+export declare function assertAttachableRuntimeBootstrap(expectedNodeId: NodeId, bootstrap: RuntimeBootstrapRecord): RuntimeBootstrapRecord;
+export declare function loadControlReadyRuntimeBootstrap(bootstrapSource: RuntimeBootstrapSource): Promise<RuntimeBootstrapRecord>;

package/dist/local-control-client.d.ts

@@ -0,0 +1 @@
+export { attachExistingLocalControlClient, attachLocalControlClient, createResilientAttachedClient, requestRuntimeSocketLease, resolveLocalControlClient, resolveLocalControlClientSync, type AttachedLocalControlClient, type ResilientAttachedClient, } from "./attached-local-control-client.js";

package/dist/local-control-error-reporting.d.ts

@@ -0,0 +1,6 @@
+export declare function reportTrustedLocalControlFailure(error: Error, context: {
+    endpoint: string;
+    responseStatus: number | null;
+    payload: unknown;
+    transport: "https" | "runtime_socket_attach";
+}): Promise<void>;

package/dist/local-control-http-client.d.ts

@@ -0,0 +1,9 @@
+import type { LocalControlApi } from "@aria-cli/server/runtime/local-control-api";
+import { type RuntimeBootstrapSource } from "./local-control-bootstrap.js";
+export declare function createLocalControlClient(options: {
+    bootstrap: RuntimeBootstrapSource;
+    pollIntervalMs?: number;
+    attachedClientId?: string;
+    attachedClientAuthToken?: string;
+}): LocalControlApi;
+export { assertAttachableRuntimeBootstrap, type RuntimeBootstrapSource, } from "./local-control-bootstrap.js";

package/dist/network-security.d.ts

@@ -0,0 +1,7 @@
+import { type PrincipalFingerprint, type SigningPublicKey, type TlsCaFingerprint } from "@aria-cli/tools/network-runtime";
+export declare function isLocalCoordinationHost(hostname: string): boolean;
+export declare function parseAndValidateCoordinationUrl(rawUrl: string): URL;
+export declare function normalizeTlsCaFingerprintId(fingerprint: TlsCaFingerprint): string;
+export declare function trustedCaPathForFingerprint(ariaDir: string, fingerprint: TlsCaFingerprint): string;
+export declare function signingKeyFingerprintHex(signingPublicKeyB64: SigningPublicKey): PrincipalFingerprint;
+export declare function assertResponderIdentityMatchesExpectedFingerprint(expectedFingerprint: PrincipalFingerprint | undefined, responderSigningPublicKeyB64: SigningPublicKey): void;

package/dist/networking-server.d.ts

@@ -0,0 +1,28 @@
+/**
+ * CLI adapter over the real server-owned NodeRuntime.
+ *
+ * Machine-local attach/start semantics now route through the server-owned
+ * HostSupervisor. This file is only the CLI adapter layer.
+ */
+import type { MemoriaFactory } from "@aria-cli/aria";
+import type { AuthResolver } from "@aria-cli/auth";
+import type { ModelRouter } from "@aria-cli/models";
+import { type HostSupervisorAttachment, type NodeRuntimeOptions, type NodeRuntimeMailbox, type HostSupervisorAttachInput } from "@aria-cli/server";
+import type { NetworkManagerRef } from "@aria-cli/tools";
+/** Minimal Mailbox interface for tunnel↔Mailbox wiring */
+export type MailboxLike = NodeRuntimeMailbox;
+export interface EnsureNetworkingServerOptions extends Omit<HostSupervisorAttachInput, "clientKind"> {
+    memoriaFactory?: MemoriaFactory;
+    router?: ModelRouter;
+    authResolver?: AuthResolver;
+    networkManager?: NetworkManagerRef;
+    port?: number;
+    mailboxRef?: NodeRuntimeOptions["mailboxRef"];
+}
+/**
+ * Start the ARIA networking server — shared between interactive and daemon modes.
+ * Returns null if this arion is already running (caller should use client mode).
+ */
+export declare function ensureNetworkingServer(opts: EnsureNetworkingServerOptions): Promise<(HostSupervisorAttachment["runtime"] & {
+    cleanup: () => Promise<void>;
+}) | null>;

package/dist/peer-identity.d.ts

@@ -0,0 +1,3 @@
+import type { SelectablePeer } from "./selectable-peer.js";
+export declare function discoveredPeerIdentityKey(peer: SelectablePeer): string;
+export declare function mergeDiscoveredPeersByIdentity(preferredPeers: readonly SelectablePeer[], additionalPeers: readonly SelectablePeer[]): SelectablePeer[];

package/dist/polling-subscription.d.ts

@@ -0,0 +1,7 @@
+export declare function createPollingSubscription<T>(loadOnce: () => Promise<T[]>, options?: {
+    pollIntervalMs: number;
+    initialAfterCreatedAt?: number;
+    getIdentityKey?: (item: T) => string | undefined;
+    getCursor?: (item: T) => number | undefined;
+    getVersionKey?: (item: T) => string | number;
+}): AsyncIterable<T>;

package/dist/relaunch.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @aria/cli - Relaunch / self-restart infrastructure
+ *
+ * Implements the parent-child supervisor pattern (inspired by gemini-cli):
+ *
+ *   Parent process (supervisor)
+ *     └─ spawns child with ARIA_NO_RELAUNCH=true, stdio: inherit
+ *     └─ loops: if child exits with RELAUNCH_EXIT_CODE → respawn
+ *     └─ otherwise: propagate exit code and exit
+ *
+ *   Child process (actual ARIA)
+ *     └─ runs the Ink REPL normally
+ *     └─ on restart: requestRelaunch() → process.exit(RELAUNCH_EXIT_CODE)
+ *     └─ supervisor catches it and respawns
+ *
+ * This replaces the fragile "detached spawn + kill self" approach
+ * with a reliable supervisor loop that inherits the terminal properly.
+ */
+export { NO_RELAUNCH_ENV, RELAUNCH_EXIT_CODE, RESUME_ARION_ENV, RESUME_SESSION_ENV, RESTART_KIND_ENV, } from "@aria-cli/types";
+export interface RelaunchMarker {
+    sessionId: string | null;
+    arionName: string;
+    pid: number;
+    timestamp: string;
+}
+export declare function writeRelaunchMarker(marker: RelaunchMarker): void;
+export declare function readRelaunchMarker(pid?: number): RelaunchMarker | null;
+export declare function clearRelaunchMarker(pid?: number): void;
+export interface SuperviseOptions {
+    beforeSpawn?: () => void | Promise<void>;
+}
+export declare function setPendingResumeSessionId(sessionId: string | null | undefined): void;
+export declare function getPendingResumeSessionId(): string | null;
+export declare function setPendingArionName(name: string): void;
+export declare function getPendingArionName(): string;
+/**
+ * Rebuild workspace before relaunch (dev workflow).
+ *
+ * This is best-effort and only runs when a pnpm workspace root is detected.
+ */
+export declare function rebuildWorkspaceIfPresent(startDir?: string): Promise<{
+    attempted: boolean;
+    root?: string;
+    durationMs?: number;
+}>;
+/**
+ * Returns true if we are already running inside a supervised child process.
+ */
+export declare function isChildProcess(): boolean;
+/**
+ * Trigger a relaunch from the child process.
+ * Simply exits with the magic code — the parent supervisor handles the rest.
+ */
+export declare function requestRelaunch(reason?: string, resumeSessionId?: string | null): Promise<never>;
+export declare function supervise(scriptPath: string, scriptArgs: string[], nodeArgs?: string[], options?: SuperviseOptions): Promise<never>;

package/dist/release-notes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Release notes shown in the TUI startup banner.
+ * Update this file each release to keep "What's New" accurate.
+ *
+ * Guidelines:
+ *   - Only user-facing features — no bug fixes, refactors, or internals
+ *   - Lead with the verb / action the user can take
+ *   - Keep it to 4-5 items max
+ */
+export declare const CLI_VERSION: string;
+export declare const WHATS_NEW: string[];

package/dist/repl-cleanup.d.ts

@@ -0,0 +1,20 @@
+export interface ReplCleanupResources {
+    release?: () => void | Promise<void>;
+    sessionHistory?: {
+        close?: () => void;
+    } | null;
+    pool?: {
+        closeAll?: () => Promise<void>;
+    } | null;
+    aria?: {
+        shutdown?: () => Promise<void>;
+    } | null;
+    warn?: (message: string) => void;
+}
+/**
+ * Run REPL work and ALWAYS release process-pinning resources on exit.
+ *
+ * This protects /exit from hanging due to open SQLite handles or background
+ * worker timers behind Memoria instances.
+ */
+export declare function withReplCleanup<T>(run: () => Promise<T>, getResources: () => ReplCleanupResources): Promise<T>;

package/dist/selectable-client.d.ts

@@ -0,0 +1,7 @@
+import type { LocalControlClientKind } from "@aria-cli/tools";
+export interface SelectableClient {
+    clientId: string;
+    clientKind: LocalControlClientKind;
+    displayLabel: string;
+    self: boolean;
+}

package/dist/selectable-peer.d.ts

@@ -0,0 +1,12 @@
+import type { NodeId, PrincipalFingerprint, TlsCaFingerprint } from "@aria-cli/tools";
+export interface SelectablePeer {
+    displayNameSnapshot: string;
+    nodeId: NodeId;
+    host?: string;
+    port?: number;
+    principalFingerprint?: PrincipalFingerprint;
+    version: string;
+    tlsCaFingerprint?: TlsCaFingerprint;
+    transport?: "lan" | "wan";
+    status?: "discovered" | "connected";
+}

package/dist/session.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Arion Session Manager
+ * Manages the primary arion, active arions, and shared conversation history.
+ */
+import type { Arion, ArionManager, MemoriaLike, ContributionType } from "@aria-cli/aria";
+import type { IMemoria, ToolCall } from "@aria-cli/types";
+import { Room, type ModelRouterLike } from "@aria-cli/aria";
+export interface RespondingArion {
+    arion: Arion;
+    isAddressed: boolean;
+    assessment?: {
+        confidence: number;
+        contributionType: ContributionType;
+    };
+}
+export interface Message {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    arion?: string;
+    toolCallId?: string;
+    toolCalls?: ToolCall[];
+}
+export interface SessionConfig {
+    manager: ArionManager;
+    router: ModelRouterLike;
+    memoria?: MemoriaLike;
+    onArionRest?: (arion: Arion) => Promise<void>;
+}
+export declare class ArionSession {
+    private room;
+    private history;
+    private manager;
+    readonly router: ModelRouterLike;
+    private memoria?;
+    private contributionGate;
+    private initialized;
+    constructor(config: SessionConfig);
+    /**
+     * Initialize the session with the default or specified arion as primary.
+     */
+    initialize(activeArionName?: string): Promise<void>;
+    /**
+     * Switch to a different arion as primary.
+     * Wakes resting arions automatically.
+     */
+    become(name: string): Promise<Arion>;
+    /**
+     * Activate an arion (add to room without making primary).
+     * Wakes resting arions automatically.
+     */
+    activate(name: string): Promise<Arion>;
+    /**
+     * Dismiss an arion from the room (send to rest).
+     * Cannot dismiss the primary arion.
+     */
+    dismiss(name: string): Promise<void>;
+    /**
+     * Get the current primary arion.
+     */
+    getPrimary(): Arion | null;
+    /**
+     * Get the backing room instance for handoff-aware RunSession wiring.
+     */
+    getRoom(): Room;
+    /**
+     * Get all active arions in the room.
+     */
+    getActiveArions(): Arion[];
+    /**
+     * Check if an arion is currently active in the room.
+     */
+    isActive(name: string): boolean;
+    /**
+     * Add a message to the conversation history.
+     */
+    addToHistory(message: Message): void;
+    /**
+     * Get a copy of the conversation history.
+     */
+    getHistory(): Message[];
+    /**
+     * Clear the conversation history.
+     */
+    clearHistory(): void;
+    /**
+     * Parse a message for @mentions and dismissals.
+     */
+    parseMessage(input: string): import("@aria-cli/aria").ParsedMessage;
+    /**
+     * Determine which arions should respond to a message.
+     * Includes addressed arions and evaluates volunteers from other active arions.
+     * Returns assessment info for volunteers to display contribution type.
+     */
+    getRespondingArions(input: string, addressedArions: Arion[], previousResponses: Array<{
+        arion: string;
+        content: string;
+    }>): Promise<RespondingArion[]>;
+    /**
+     * Get the Memoria instance for a specific arion.
+     * Returns null if arion has no Memoria configured.
+     */
+    getArionMemoria(arion: Arion): Promise<IMemoria | null>;
+}

package/dist/slash-commands.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Slash command parsing utilities.
+ *
+ * Pure functions for extracting command names and arguments from
+ * user input like "/remember my note" or "/help".
+ *
+ * These are intentionally kept separate from React components
+ * so they can be easily tested and reused.
+ */
+export interface SlashCommand {
+    /** The command name (without the leading slash) */
+    command: string;
+    /** The arguments after the command name, trimmed */
+    args: string;
+}
+/**
+ * Parse a slash command from user input.
+ * Returns null if the input is not a slash command.
+ *
+ * Examples:
+ *   "/remember my note" -> { command: "remember", args: "my note" }
+ *   "/help"             -> { command: "help", args: "" }
+ *   "hello world"       -> null
+ *   ""                  -> null
+ */
+export declare function parseSlashCommand(input: string): SlashCommand | null;
+/** List of built-in slash commands recognized by handleCommand */
+export declare const BUILTIN_COMMANDS: readonly ["help", "arions", "exit", "hatch", "remember", "recall", "recall_knowledge", "send", "model", "become", "rest", "wake", "memories", "forget", "clear", "autonomy", "resume", "fork", "restart", "login", "logout", "terminal-setup", "theme", "invite", "join"];
+export type BuiltinCommandName = (typeof BUILTIN_COMMANDS)[number];
+export declare function canonicalizeBuiltinCommand(command: string): BuiltinCommandName | null;
+/**
+ * Check whether a parsed command name is a known built-in command.
+ */
+export declare function isBuiltinCommand(command: string): command is BuiltinCommandName;

package/dist/sounds.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Warcraft II sound notifications for ARIA.
+ *
+ * Maps RunEvent lifecycle events to thematic Warcraft II sounds.
+ * Always on — no opt-in, no opt-out.
+ *
+ * Sound files live in `.comms/sounds/wav/` (repo root).
+ * Uses macOS `afplay` for non-blocking playback.
+ */
+/** Minimal event shape — accepts both RunEvent and RuntimeRunEvent without tight coupling. */
+interface SoundEvent {
+    type: string;
+    name?: string;
+    input?: unknown;
+    result?: unknown;
+}
+export declare function setEnabled(value: boolean): void;
+export declare function isEnabled(): boolean;
+/** Call once when the CLI session starts. "Ready to work!" */
+export declare function onSessionStart(): void;
+/** Call once when the CLI session ends. */
+export declare function onSessionEnd(): void;
+/** Call when the user submits a prompt. Plays annoyance escalation. */
+export declare function onPromptSubmit(): void;
+/** Call when the runner finishes responding. Plays completion sound. */
+export declare function onResponseComplete(): void;
+/** Call for every RunEvent during streaming. Handles tool sounds. */
+export declare function onRunEvent(event: SoundEvent): void;
+/** Check if sounds are available (WAV directory found). */
+export declare function isSoundAvailable(): boolean;
+export {};