@aria-cli/cli 1.0.57 → 1.0.58

package/src/entrypoints/headless-stdio.ts

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

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

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

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

package/src/runtime/crash-handlers.ts

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

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

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

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

@@ -1,24 +0,0 @@
-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),
-  };
-}

package/src/runtime/launch-spec.test.ts

@@ -1,26 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { resolveAriaLaunchSpec } from "./launch-spec.js";
-
-describe("resolveAriaLaunchSpec", () => {
-  const originalOverride = process.env.ARIA_RUNTIME_KIND;
-
-  afterEach(() => {
-    if (originalOverride === undefined) delete process.env.ARIA_RUNTIME_KIND;
-    else process.env.ARIA_RUNTIME_KIND = originalOverride;
-  });
-
-  it("resolves source-bun launch spec", () => {
-    process.env.ARIA_RUNTIME_KIND = "source-bun";
-    const spec = resolveAriaLaunchSpec({ mode: "daemon", args: ["--port", "0"] });
-    expect(spec.command === "bun" || spec.command === "bun.exe").toBe(true);
-    expect(spec.args).toContain("__internal");
-    expect(spec.args).toContain("daemon");
-  });
-
-  it("resolves compiled-bun launch spec", () => {
-    process.env.ARIA_RUNTIME_KIND = "compiled-bun";
-    const spec = resolveAriaLaunchSpec({ mode: "repl", args: ["--continue"] });
-    expect(spec.command).toBe(process.execPath);
-    expect(spec.args.slice(0, 2)).toEqual(["__internal", "repl"]);
-  });
-});

package/src/runtime/launch-spec.ts

@@ -1,84 +0,0 @@
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { getRuntimeKind } from "./runtime-kind.js";
-
-export type AriaLaunchMode = "repl" | "daemon" | "headless-stdio";
-
-export interface AriaLaunchSpecInput {
-  mode: AriaLaunchMode;
-  args?: string[];
-  env?: NodeJS.ProcessEnv;
-  cwd?: string;
-}
-
-export interface LaunchSpec {
-  command: string;
-  args: string[];
-  env: NodeJS.ProcessEnv;
-  cwd: string;
-}
-
-function getBunCommand(): string {
-  return process.platform === "win32" ? "bun.exe" : "bun";
-}
-
-function resolveSourceEntrypoint(): string {
-  const candidates = [
-    fileURLToPath(new URL("../main.ts", import.meta.url)),
-    fileURLToPath(new URL("../main.js", import.meta.url)),
-  ];
-
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-
-  throw new Error("[aria] Could not resolve Bun source entrypoint for internal relaunch");
-}
-
-function resolveBundledEntrypoint(): string {
-  // In npm-installed bundle, argv[1] is the aria.mjs file itself
-  const argv1 = process.argv[1] ?? "";
-  if (existsSync(argv1)) return argv1;
-  // Fallback: look relative to import.meta.url
-  const candidates = [
-    fileURLToPath(new URL("../../bin/aria.mjs", import.meta.url)),
-    fileURLToPath(new URL("../bin/aria.mjs", import.meta.url)),
-  ];
-  for (const c of candidates) {
-    if (existsSync(c)) return c;
-  }
-  throw new Error("[aria] Could not resolve bundled entrypoint for internal relaunch");
-}
-
-export function resolveAriaLaunchSpec(input: AriaLaunchSpecInput): LaunchSpec {
-  const runtimeKind = getRuntimeKind();
-  const forwardedArgs = input.args ?? [];
-  const env = { ...process.env, ...(input.env ?? {}) };
-  const cwd = input.cwd ?? process.cwd();
-
-  switch (runtimeKind) {
-    case "source-bun":
-      return {
-        command: getBunCommand(),
-        args: [resolveSourceEntrypoint(), "__internal", input.mode, ...forwardedArgs],
-        env,
-        cwd,
-      };
-    case "bundled-bun":
-      return {
-        command: getBunCommand(),
-        args: [resolveBundledEntrypoint(), "__internal", input.mode, ...forwardedArgs],
-        env,
-        cwd,
-      };
-    case "compiled-bun":
-      return {
-        command: process.execPath,
-        args: ["__internal", input.mode, ...forwardedArgs],
-        env,
-        cwd,
-      };
-  }
-}

package/src/runtime/owner-lease.ts

@@ -1,52 +0,0 @@
-export function installOwnerLeaseIfNeeded(
-  options: {
-    env?: NodeJS.ProcessEnv;
-    processRef?: Pick<NodeJS.Process, "env" | "kill" | "pid" | "once">;
-    pollMs?: number;
-    onOwnerGone?: (ownerPid: number) => void;
-  } = {},
-): () => void {
-  const env = options.env ?? process.env;
-  const processRef = options.processRef ?? process;
-  const pollMs = options.pollMs ?? 1000;
-
-  const ownerPidRaw = env.ARIA_HARNESS_OWNER_PID;
-  if (!ownerPidRaw) return () => {};
-
-  const ownerPid = Number.parseInt(ownerPidRaw, 10);
-  if (!Number.isFinite(ownerPid) || ownerPid <= 0) {
-    throw new Error(`ARIA_HARNESS_OWNER_PID must be a positive integer, got: ${ownerPidRaw}`);
-  }
-
-  let released = false;
-  const interval = setInterval(() => {
-    if (released) return;
-    try {
-      processRef.kill(ownerPid, 0);
-    } catch (error) {
-      const code =
-        error && typeof error === "object" && "code" in error
-          ? (error as { code?: string }).code
-          : undefined;
-      if (code && code !== "ESRCH") return;
-      released = true;
-      clearInterval(interval);
-      if (options.onOwnerGone) {
-        options.onOwnerGone(ownerPid);
-        return;
-      }
-      processRef.kill(processRef.pid, "SIGTERM");
-    }
-  }, pollMs);
-
-  interval.unref?.();
-
-  const dispose = () => {
-    if (released) return;
-    released = true;
-    clearInterval(interval);
-  };
-
-  processRef.once("exit", dispose);
-  return dispose;
-}

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

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isPublicCommandInvocation } from "./public-mode.js";
-
-describe("isPublicCommandInvocation", () => {
-  it("detects explicit commands", () => {
-    expect(isPublicCommandInvocation(["auth"])).toBe(true);
-    expect(isPublicCommandInvocation(["daemon"])).toBe(true);
-  });
-
-  it("detects top-level flags", () => {
-    expect(isPublicCommandInvocation(["--version"])).toBe(true);
-    expect(isPublicCommandInvocation(["--help"])).toBe(true);
-  });
-
-  it("does not treat prompt text as public command", () => {
-    expect(isPublicCommandInvocation(["hello", "world"])).toBe(false);
-  });
-});

package/src/runtime/public-mode.ts

@@ -1,19 +0,0 @@
-const PUBLIC_TOP_LEVELS = new Set([
-  "daemon",
-  "auth",
-  "arions",
-  "headless",
-  "call",
-  "pairing",
-  "runtime-cutover-reset",
-  "--help",
-  "-h",
-  "--version",
-  "-v",
-]);
-
-export function isPublicCommandInvocation(argv: string[]): boolean {
-  const first = argv[0];
-  if (!first) return false;
-  return PUBLIC_TOP_LEVELS.has(first) || first.startsWith("--");
-}