@aria-cli/cli 1.0.54 → 1.0.55

package/package.json

@@ -1,22 +1,33 @@
 {
   "name": "@aria-cli/cli",
-  "version": "1.0.54",
-  "description": "ARIA - Adaptive Reasoning Intelligence Agent",
+  "version": "1.0.55",
   "type": "module",
+  "main": "dist/main.js",
+  "types": "dist/index.d.ts",
   "bin": {
     "aria": "bin/aria.mjs"
   },
-  "main": "bin/aria.mjs",
-  "files": [
-    "bin/aria.mjs"
-  ],
-  "engines": {
-    "bun": ">=1.3.11"
+  "scripts": {
+    "test": "vitest run --config vitest.config.ts",
+    "test:list": "bun tests/print-default-test-lane.ts",
+    "test:watch": "vitest --config vitest.config.ts",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:native": "vitest run --config vitest.native.config.ts",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:e2e:watch": "vitest --config vitest.e2e.config.ts",
+    "test:e2e:mocked": "vitest run --config vitest.e2e.config.ts --testNamePattern='mocked|error|rejects|handles|prevents'",
+    "test:real": "vitest run --config vitest.real.config.ts",
+    "test:lanes": "bun tests/print-test-lane-manifest.ts",
+    "test:parity": "bun ../../scripts/run-cli-parity-tests.mjs",
+    "start": "bun dist/main.js",
+    "dev": "bun src/main.ts",
+    "dev:repl": "bun src/main.ts",
+    "smoke:binary": "bun ../../scripts/smoke-compiled-binary.mjs ../../dist-bin/aria"
   },
   "dependencies": {
     "@anthropic-ai/bedrock-sdk": "^0.26.4",
     "@anthropic-ai/sdk": "^0.78.0",
-    "@aws-sdk/credential-providers": "^3.995.0",
+    "@ast-grep/napi": "^0.42.0",
     "@fastify/cors": "^11.0.1",
     "@fastify/websocket": "^11.2.0",
     "@google/genai": "^1.42.0",
@@ -27,6 +38,7 @@
     "color-name": "^2.1.0",
     "commander": "^14.0.3",
     "diff": "^8.0.3",
+    "dotenv": "^17.3.1",
     "eventemitter3": "^5.0.4",
     "fast-glob": "^3.3.3",
     "fastify": "^5.3.2",
@@ -35,27 +47,74 @@
     "highlight.js": "^11.11.1",
     "ink": "npm:@jrichman/ink@^6.4.11",
     "ink-spinner": "^5.0.0",
-    "jsdom": "^26.0.0",
     "katex": "^0.16.33",
     "marked": "^17.0.3",
     "marked-terminal": "^7.3.0",
     "nanoid": "^5.1.6",
     "openai": "^6.25.0",
-    "playwright": "^1.52.0",
     "proper-lockfile": "^4.1.2",
     "react": "^19.2.4",
+    "sqlite-vec": "0.1.7-alpha.2",
     "string-width": "^8.2.0",
     "turndown": "^7.2.2",
     "ulid": "^3.0.2",
+    "undici": "^7.22.0",
     "uuid": "^13.0.0",
+    "vscode-jsonrpc": "^8.2.1",
     "wrap-ansi": "^10.0.0",
+    "ws": "^8.19.0",
     "yaml": "^2.8.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "node-pty": "^1.0.0",
+    "playwright": "^1.52.0",
+    "jsdom": "^26.0.0",
+    "@aws-sdk/credential-providers": "^3.995.0"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.2",
+    "@types/color-name": "^2.0.0",
+    "@types/react": "^19.2.14",
+    "ink-testing-library": "^4.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "@aria-cli/aria": "1.0.54",
+    "@aria-cli/auth": "1.0.54",
+    "@aria-cli/memoria": "1.0.54",
+    "@aria-cli/memoria-bridge": "1.0.54",
+    "@aria-cli/models": "1.0.54",
+    "@aria-cli/server": "1.0.54",
+    "@aria-cli/tools": "1.0.54",
+    "@aria-cli/types": "1.0.54"
   },
+  "files": [
+    "bin/aria.mjs",
+    "src/main.ts",
+    "src/entrypoints/**/*",
+    "src/runtime/**/*",
+    "dist/**/*"
+  ],
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "description": "ARIA — AI coding assistant with persistent memory, self-learning tools, and autonomous agent loop",
+  "homepage": "https://github.com/aria-cli/aria-releases",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aria-cli/aria-releases.git"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "coding-assistant",
+    "agent",
+    "llm",
+    "memory",
+    "tools"
+  ],
+  "module": "dist/main.js",
   "optionalDependencies": {
     "@aws-sdk/client-bedrock": "^3.997.0",
     "@aws-sdk/client-bedrock-runtime": "^3.997.0",
     "@aws-sdk/token-providers": "^3.997.0"
-  },
-  "license": "MIT"
+  }
 }

package/src/entrypoints/command-mode.ts

@@ -0,0 +1,5 @@
+import { program } from "../commands/index.js";
+
+export async function runCommandMode(argv = process.argv): Promise<void> {
+  await program.parseAsync(argv);
+}

package/src/entrypoints/daemon.ts

@@ -0,0 +1,54 @@
+import type { DaemonLauncherCliOptions } from "@aria-cli/server/daemon-launcher";
+import { runServerDaemonLauncherFromCli } from "@aria-cli/server/daemon-launcher";
+
+function requireValue(argv: string[], index: number, flag: string): string {
+  const value = argv[index + 1];
+  if (!value) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+function parseDaemonArgs(argv: string[]): DaemonLauncherCliOptions {
+  const options: DaemonLauncherCliOptions = {};
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--arion":
+        options.arion = requireValue(argv, i, arg);
+        i += 1;
+        break;
+      case "--port":
+        options.port = requireValue(argv, i, arg);
+        i += 1;
+        break;
+      case "--interval-ms":
+        options.intervalMs = requireValue(argv, i, arg);
+        i += 1;
+        break;
+      case "--allowed-tool-categories":
+        options.allowedToolCategories = requireValue(argv, i, arg);
+        i += 1;
+        break;
+      case "--allowed-shell-commands":
+        options.allowedShellCommands = requireValue(argv, i, arg);
+        i += 1;
+        break;
+      case "--max-write-ops-per-minute":
+        options.maxWriteOpsPerMinute = requireValue(argv, i, arg);
+        i += 1;
+        break;
+      case "--max-git-pushes-per-hour":
+        options.maxGitPushesPerHour = requireValue(argv, i, arg);
+        i += 1;
+        break;
+      default:
+        throw new Error(`[aria] Unknown internal daemon arg: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+export async function runDaemonEntrypoint(argv: string[]): Promise<void> {
+  await runServerDaemonLauncherFromCli(parseDaemonArgs(argv));
+}

package/src/entrypoints/headless-stdio.ts

@@ -0,0 +1,27 @@
+import { startHeadlessStdioServer } from "../headless/stdio-server.js";
+
+function parseHeadlessArgs(argv: string[]): { arionName?: string } {
+  let arionName: string | undefined;
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--arion") {
+      const next = argv[i + 1];
+      if (!next) throw new Error("--arion requires a value");
+      arionName = next;
+      i += 1;
+      continue;
+    }
+    throw new Error(`[aria] Unknown internal headless-stdio arg: ${arg}`);
+  }
+
+  return { arionName };
+}
+
+export async function runHeadlessStdioEntrypoint(argv: string[]): Promise<void> {
+  const parsed = parseHeadlessArgs(argv);
+  await startHeadlessStdioServer({
+    cwd: process.cwd(),
+    arionName: parsed.arionName,
+  });
+}

package/src/entrypoints/interactive.ts

@@ -0,0 +1,112 @@
+import { ArionManager, ArionStorage } from "@aria-cli/aria";
+import { Memoria } from "@aria-cli/memoria";
+import { getCliModels } from "@aria-cli/models";
+import type { InteractiveInvocation } from "../runtime/interactive-invocation.js";
+import { createAttachedCliContext } from "../cli-context.js";
+import { getAriaDir } from "../config.js";
+import { ensureDaemon } from "../ensure-daemon.js";
+import { startInkRepl } from "../ink-repl.js";
+import { attachExistingLocalControlClient } from "../local-control-client.js";
+import { SessionHistory } from "../history/index.js";
+import { ArionSession } from "../session.js";
+
+async function recallUserName(memoria: Memoria): Promise<string | null> {
+  try {
+    const raw = memoria.storage?.getConfigValue?.("user_profile");
+    return raw ? (JSON.parse(raw).name ?? null) : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function runInteractiveEntrypoint(invocation: InteractiveInvocation): Promise<void> {
+  const ariaHome = getAriaDir();
+  const cli = await createAttachedCliContext();
+
+  await ensureDaemon(cli);
+
+  const attached = await attachExistingLocalControlClient({
+    ariaHome,
+    clientKind: "tui",
+  });
+
+  if (!attached) {
+    throw new Error("[aria] Attached REPL requires an existing local-control runtime");
+  }
+
+  const memoriaPath = process.env.ARIA_MEMORY_PATH || `${cli.ariaDir}/arions/ARIA/memory.db`;
+  const memoria = new Memoria({ path: memoriaPath, router: cli.router });
+  memoria.initialize().catch((error) => {
+    console.debug(
+      `[aria] Memoria background init failed (will retry on use): ${error?.message ?? error}`,
+    );
+  });
+
+  const aria = {
+    components: { memoria },
+    recallUserName: () => recallUserName(memoria),
+    shutdown: async () => {
+      await memoria.close();
+      await cli.pool.closeAll();
+    },
+  };
+
+  const storage = new ArionStorage(cli.ariaDir);
+  const manager = new ArionManager(storage, cli.memoriaFactory);
+  await manager.initialize();
+  manager.setRouter(cli.router);
+
+  const activeArion = cli.config.activeArion?.trim() || "ARIA";
+  const historyPath = SessionHistory.resolvePerArionPath(cli.ariaDir, activeArion);
+  SessionHistory.migrateJsonlLogs(cli.ariaDir, activeArion);
+  const history = new SessionHistory(historyPath);
+  const inputHistory = history.getInputHistory(100);
+  const appendInputHistory = (value: string) => history.addInputHistory(value);
+
+  let resolvedSessionId: string | undefined;
+  if (invocation.resumeSessionId) {
+    const found = history.findSessionByPrefix(invocation.resumeSessionId);
+    if (!found) {
+      throw new Error(`Error: No session found matching \"${invocation.resumeSessionId}\"`);
+    }
+    resolvedSessionId = found;
+  } else if (invocation.continueLatest) {
+    const latest = history.listSessions(1);
+    if (latest.length === 0) {
+      throw new Error("Error: No recent sessions to continue");
+    }
+    resolvedSessionId = latest[0]?.id;
+  }
+
+  const session = new ArionSession({
+    manager,
+    router: cli.router,
+    memoria,
+    onArionRest: async () => {},
+  });
+  await session.initialize(cli.config.activeArion);
+
+  const cachedUserName = await recallUserName(memoria);
+  const initialModelSnapshot = await attached.control.getModelSnapshot?.().catch(() => undefined);
+
+  await startInkRepl(
+    session,
+    manager,
+    cli.router,
+    aria,
+    attached,
+    cli,
+    inputHistory,
+    appendInputHistory,
+    history,
+    invocation.prompt,
+    cachedUserName,
+    resolvedSessionId,
+    (initialModelSnapshot?.models as
+      | readonly import("@aria-cli/models").ReadonlyModelDefinition[]
+      | undefined) ?? getCliModels(),
+    undefined,
+    cli.credentialHints,
+    cli.authResolver,
+  );
+}

package/src/main.ts

@@ -0,0 +1,72 @@
+import "./runtime/configure-bun-sqlite.js";
+import { installProcessCrashHandlers } from "./runtime/crash-handlers.js";
+import { installOwnerLeaseIfNeeded } from "./runtime/owner-lease.js";
+import { parseInternalInvocation } from "./runtime/internal-mode.js";
+import { isPublicCommandInvocation } from "./runtime/public-mode.js";
+import { parseInteractiveInvocation } from "./runtime/interactive-invocation.js";
+import { isChildProcess, superviseInteractiveSession } from "./relaunch.js";
+import { isCompiledRuntime } from "./runtime/runtime-kind.js";
+
+export async function main(argv = process.argv): Promise<void> {
+  installProcessCrashHandlers();
+  installOwnerLeaseIfNeeded();
+
+  const userArgs = argv.slice(2);
+
+  const internal = parseInternalInvocation(userArgs);
+  if (internal) {
+    const { runInternalMode } = await import("./runtime/run-internal-mode.js");
+    await runInternalMode(internal);
+    return;
+  }
+
+  if (isPublicCommandInvocation(userArgs)) {
+    const { runCommandMode } = await import("./entrypoints/command-mode.js");
+    await runCommandMode(argv);
+    return;
+  }
+
+  const interactive = parseInteractiveInvocation(userArgs);
+  if (isChildProcess()) {
+    const { runInteractiveEntrypoint } = await import("./entrypoints/interactive.js");
+    await runInteractiveEntrypoint(interactive);
+    return;
+  }
+
+  // Compiled binary: run REPL directly in this process instead of spawning
+  // a supervisor + child (which loads the 82MB binary twice). Saves ~3-13s
+  // on cold start. Relaunch (rare) spawns a new process in supervisor mode.
+  // ARIA_USE_SUPERVISOR is set by requestRelaunch() to force the supervisor
+  // path on respawned processes, preventing waiter process accumulation.
+  if (isCompiledRuntime() && !process.env.ARIA_USE_SUPERVISOR) {
+    await runCompiledDirect(interactive);
+    return;
+  }
+
+  await superviseInteractiveSession(interactive);
+}
+
+/**
+ * Compiled-binary direct mode: run the REPL in-process (single binary load).
+ *
+ * The normal supervisor pattern loads the 82MB binary twice (parent + child).
+ * In compiled mode, we skip the supervisor and run the REPL directly. If the
+ * user requests a relaunch (rare), requestRelaunch() spawns a new process
+ * with resume env vars — the current process waits and propagates exit code.
+ */
+async function runCompiledDirect(
+  interactive: import("./runtime/interactive-invocation.js").InteractiveInvocation,
+): Promise<void> {
+  const { NO_RELAUNCH_ENV } = await import("@aria-cli/types");
+  process.env[NO_RELAUNCH_ENV] = "true";
+  const { runInteractiveEntrypoint } = await import("./entrypoints/interactive.js");
+  await runInteractiveEntrypoint(interactive);
+}
+
+if ((import.meta as ImportMeta & { main?: boolean }).main) {
+  main(process.argv).catch((error) => {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+  });
+}

package/src/runtime/configure-bun-sqlite.ts

@@ -0,0 +1,3 @@
+import { configureBunCustomSqlite } from "@aria-cli/tools";
+
+configureBunCustomSqlite();

package/src/runtime/crash-handlers.ts

@@ -0,0 +1,128 @@
+import { createHash } from "node:crypto";
+import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import v8 from "node:v8";
+import { RESUME_SESSION_ENV } from "@aria-cli/types";
+
+function getAriaHome(): string {
+  return process.env.ARIA_HOME?.trim() || join(homedir(), ".aria");
+}
+
+function writeCrashReport(type: string, error: unknown): void {
+  try {
+    const crashDir = join(getAriaHome(), "crash-reports");
+    mkdirSync(crashDir, { recursive: true });
+
+    const err = error instanceof Error ? error : new Error(String(error));
+    const memory = process.memoryUsage();
+    const timestamp = new Date().toISOString();
+    const sessionId = process.env[RESUME_SESSION_ENV] || "unknown";
+    const payload = {
+      timestamp,
+      sessionId,
+      type,
+      error: {
+        message: err.message,
+        stack: err.stack,
+        name: err.name,
+      },
+      process: {
+        pid: process.pid,
+        heapUsedMb: Math.round((memory.heapUsed / 1024 / 1024) * 100) / 100,
+        rssMb: Math.round((memory.rss / 1024 / 1024) * 100) / 100,
+        uptime: Math.round(process.uptime()),
+      },
+    };
+
+    writeFileSync(join(crashDir, "latest.json"), JSON.stringify(payload, null, 2));
+
+    const stackFirst = err.stack?.split("\n")[1]?.trim() ?? "";
+    const bucket = Math.floor(Date.now() / 10000);
+    const fingerprint = createHash("sha256")
+      .update(`${err.message}|${stackFirst}|${bucket}`)
+      .digest("hex")
+      .slice(0, 12);
+
+    appendFileSync(
+      join(getAriaHome(), "error-events.jsonl"),
+      `${JSON.stringify({
+        id: `crash-${fingerprint}`,
+        timestamp,
+        severity: 0,
+        category: "crash",
+        domain: "cli",
+        name: err.name,
+        message: err.message,
+        stackTrace: err.stack,
+        recoverable: false,
+        status: "new",
+      })}\n`,
+      "utf-8",
+    );
+  } catch {
+    // Best effort only.
+  }
+}
+
+let installed = false;
+
+/**
+ * Install V8 heap diagnostics for OOM investigation.
+ *
+ * - `setHeapSnapshotNearHeapLimit(3)`: Auto-captures up to 3 progressive heap
+ *   snapshots as the heap approaches the V8 limit. Snapshots land in the
+ *   diagnostic directory and survive the crash — load in Chrome DevTools
+ *   Memory tab for retainer trace analysis.
+ *
+ * - `process.report.reportOnFatalError`: Generates a diagnostic JSON report
+ *   on fatal errors (including OOM) with native stack, heap space breakdown,
+ *   libuv handles, and resource usage.
+ *
+ * Both are lightweight and production-safe — zero overhead until triggered.
+ */
+function installHeapDiagnostics(): void {
+  const crashDir = join(getAriaHome(), "crash-reports");
+  mkdirSync(crashDir, { recursive: true });
+
+  // Auto-capture heap snapshots as V8 approaches the heap limit.
+  // Writes .heapsnapshot files to crashDir before OOM kills the process.
+  try {
+    v8.setHeapSnapshotNearHeapLimit(3);
+  } catch {
+    // Bun or older Node without this API — non-fatal.
+  }
+
+  // Generate a diagnostic report JSON on fatal errors (OOM, segfault).
+  try {
+    process.report.reportOnFatalError = true;
+    process.report.directory = crashDir;
+  } catch {
+    // Non-fatal if report API is unavailable.
+  }
+}
+
+export function installProcessCrashHandlers(): void {
+  if (installed) return;
+  installed = true;
+
+  installHeapDiagnostics();
+
+  process.on("uncaughtException", (error, origin) => {
+    writeCrashReport("uncaughtException", error);
+    process.stderr.write(`[aria] FATAL uncaughtException (origin: ${origin}):\n`);
+    process.stderr.write(
+      `${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`,
+    );
+    process.exit(1);
+  });
+
+  process.on("unhandledRejection", (error) => {
+    writeCrashReport("unhandledRejection", error);
+    process.stderr.write("[aria] FATAL unhandledRejection:\n");
+    process.stderr.write(
+      `${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`,
+    );
+    process.exit(1);
+  });
+}

package/src/runtime/interactive-invocation.test.ts

@@ -0,0 +1,42 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { parseInteractiveInvocation } from "./interactive-invocation.js";
+
+describe("parseInteractiveInvocation", () => {
+  const originalResume = process.env.ARIA_RESUME_SESSION_ID;
+  const originalRestartKind = process.env.ARIA_RESTART_KIND;
+
+  afterEach(() => {
+    if (originalResume === undefined) delete process.env.ARIA_RESUME_SESSION_ID;
+    else process.env.ARIA_RESUME_SESSION_ID = originalResume;
+
+    if (originalRestartKind === undefined) delete process.env.ARIA_RESTART_KIND;
+    else process.env.ARIA_RESTART_KIND = originalRestartKind;
+  });
+
+  it("parses a prompt", () => {
+    expect(parseInteractiveInvocation(["hello", "world"]).prompt).toBe("hello world");
+  });
+
+  it("parses resume flag", () => {
+    expect(parseInteractiveInvocation(["--resume", "sess-1"]).resumeSessionId).toBe("sess-1");
+  });
+
+  it("parses continue flag", () => {
+    expect(parseInteractiveInvocation(["--continue"]).continueLatest).toBe(true);
+  });
+
+  it("consumes resume env when explicit args are absent", () => {
+    process.env.ARIA_RESUME_SESSION_ID = "sess-env";
+    process.env.ARIA_RESTART_KIND = "explicit";
+    const parsed = parseInteractiveInvocation([]);
+    expect(parsed.resumeSessionId).toBe("sess-env");
+    expect(process.env.ARIA_RESUME_SESSION_ID).toBeUndefined();
+    expect(process.env.ARIA_RESTART_KIND).toBeUndefined();
+  });
+
+  it("rejects resume + continue together", () => {
+    expect(() => parseInteractiveInvocation(["--resume", "sess-1", "--continue"])).toThrow(
+      /mutually exclusive/i,
+    );
+  });
+});

package/src/runtime/interactive-invocation.ts

@@ -0,0 +1,51 @@
+import { RESUME_SESSION_ENV, RESTART_KIND_ENV } from "@aria-cli/types";
+
+export interface InteractiveInvocation {
+  prompt?: string;
+  resumeSessionId?: string | null;
+  continueLatest?: boolean;
+  rawArgs: string[];
+}
+
+export function parseInteractiveInvocation(argv: string[]): InteractiveInvocation {
+  let resumeSessionId: string | null = null;
+  let continueLatest = false;
+  const promptParts: string[] = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === undefined) continue;
+
+    if (arg === "-r" || arg === "--resume") {
+      const next = argv[i + 1];
+      if (!next) throw new Error("Error: -r/--resume requires a session ID");
+      resumeSessionId = next;
+      i += 1;
+      continue;
+    }
+
+    if (arg === "-c" || arg === "--continue") {
+      continueLatest = true;
+      continue;
+    }
+
+    promptParts.push(arg);
+  }
+
+  if (resumeSessionId && continueLatest) {
+    throw new Error("Error: -r/--resume and -c/--continue are mutually exclusive");
+  }
+
+  if (!resumeSessionId && !continueLatest && process.env[RESUME_SESSION_ENV]) {
+    resumeSessionId = process.env[RESUME_SESSION_ENV] ?? null;
+    delete process.env[RESUME_SESSION_ENV];
+    delete process.env[RESTART_KIND_ENV];
+  }
+
+  return {
+    prompt: promptParts.length > 0 ? promptParts.join(" ") : undefined,
+    resumeSessionId,
+    continueLatest,
+    rawArgs: [...argv],
+  };
+}

package/src/runtime/internal-mode.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { parseInternalInvocation } from "./internal-mode.js";
+
+describe("parseInternalInvocation", () => {
+  it("returns null for public args", () => {
+    expect(parseInternalInvocation(["auth"])).toBeNull();
+  });
+
+  it("parses valid internal mode", () => {
+    expect(parseInternalInvocation(["__internal", "daemon", "--port", "0"])).toEqual({
+      mode: "daemon",
+      args: ["--port", "0"],
+    });
+  });
+
+  it("throws on unknown internal mode", () => {
+    expect(() => parseInternalInvocation(["__internal", "wat"])).toThrow(/Unknown internal mode/i);
+  });
+});

package/src/runtime/internal-mode.ts

@@ -0,0 +1,24 @@
+export type InternalMode = "repl" | "daemon" | "headless-stdio";
+
+export interface InternalInvocation {
+  mode: InternalMode;
+  args: string[];
+}
+
+export const INTERNAL_SENTINEL = "__internal";
+
+export function parseInternalInvocation(argv: string[]): InternalInvocation | null {
+  if (argv[0] !== INTERNAL_SENTINEL) return null;
+
+  const mode = argv[1];
+  if (mode !== "repl" && mode !== "daemon" && mode !== "headless-stdio") {
+    throw new Error(
+      `[aria] Unknown internal mode \"${String(mode)}\". Expected repl | daemon | headless-stdio.`,
+    );
+  }
+
+  return {
+    mode,
+    args: argv.slice(2),
+  };
+}