@aria-cli/cli 1.0.50 → 1.0.52

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),
+  };
+}

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+import type { InternalInvocation } from "./internal-mode.js";
+import { parseInteractiveInvocation } from "./interactive-invocation.js";
+import { runInteractiveEntrypoint } from "../entrypoints/interactive.js";
+import { runDaemonEntrypoint } from "../entrypoints/daemon.js";
+import { runHeadlessStdioEntrypoint } from "../entrypoints/headless-stdio.js";
+
+export async function runInternalMode(invocation: InternalInvocation): Promise<void> {
+  switch (invocation.mode) {
+    case "repl":
+      await runInteractiveEntrypoint(parseInteractiveInvocation(invocation.args));
+      return;
+    case "daemon":
+      await runDaemonEntrypoint(invocation.args);
+      return;
+    case "headless-stdio":
+      await runHeadlessStdioEntrypoint(invocation.args);
+      return;
+  }
+}

package/src/runtime/runtime-kind.test.ts

@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { getRuntimeKind } from "./runtime-kind.js";
+
+describe("getRuntimeKind", () => {
+  const originalOverride = process.env.ARIA_RUNTIME_KIND;
+  const originalArgv = [...process.argv];
+
+  afterEach(() => {
+    if (originalOverride === undefined) delete process.env.ARIA_RUNTIME_KIND;
+    else process.env.ARIA_RUNTIME_KIND = originalOverride;
+    process.argv = [...originalArgv];
+  });
+
+  it("respects explicit override", () => {
+    process.env.ARIA_RUNTIME_KIND = "compiled-bun";
+    expect(getRuntimeKind()).toBe("compiled-bun");
+  });
+
+  it("detects source runtime from script argv", () => {
+    process.argv = [process.argv[0] ?? "bun", "packages/cli/src/main.ts"];
+    expect(getRuntimeKind()).toBe("source-bun");
+  });
+});

package/src/runtime/runtime-kind.ts

@@ -0,0 +1,41 @@
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+export type RuntimeKind = "source-bun" | "compiled-bun" | "bundled-bun";
+
+function resolveAdjacentMainCandidates(): string[] {
+  return [
+    fileURLToPath(new URL("../main.ts", import.meta.url)),
+    fileURLToPath(new URL("../main.js", import.meta.url)),
+  ];
+}
+
+export function getRuntimeKind(): RuntimeKind {
+  const override = process.env.ARIA_RUNTIME_KIND?.trim();
+  if (override === "source-bun" || override === "compiled-bun" || override === "bundled-bun") {
+    return override as RuntimeKind;
+  }
+
+  const argv1 = process.argv[1] ?? "";
+
+  // Compiled binary: argv[1] is not a file path
+  if (!argv1.endsWith(".ts") && !argv1.endsWith(".js") && !argv1.endsWith(".mjs")) {
+    return "compiled-bun";
+  }
+
+  // Source dev: adjacent main.ts exists
+  if (resolveAdjacentMainCandidates().some((candidate) => existsSync(candidate))) {
+    return "source-bun";
+  }
+
+  // Bundled npm install: .mjs file but no adjacent main.ts
+  return "bundled-bun";
+}
+
+export function isSourceRuntime(): boolean {
+  return getRuntimeKind() === "source-bun";
+}
+
+export function isCompiledRuntime(): boolean {
+  return getRuntimeKind() === "compiled-bun";
+}

package/src/runtime/spawn-aria.ts

@@ -0,0 +1,62 @@
+import type { LaunchSpec } from "./launch-spec.js";
+
+export interface SpawnAriaOptions {
+  ipc?: boolean;
+  detached?: boolean;
+  stdio?: "inherit" | ["ignore" | "inherit", "ignore" | "inherit", number | "ignore" | "inherit"];
+}
+
+/**
+ * Thin wrapper around the spawned ARIA process.
+ *
+ * Provides a uniform event-listener surface so callers don't depend on
+ * Bun.Subprocess internals. The IPC path wires Bun.spawn's callback-based
+ * `ipc` option into `.on("message")` / `.send()` that the supervisor and
+ * daemon launcher expect.
+ */
+export interface AriaProcess {
+  send(message: unknown): void;
+  on(event: string, fn: (...args: unknown[]) => void): void;
+  unref(): void;
+}
+
+export function spawnAria(spec: LaunchSpec, options: SpawnAriaOptions = {}): AriaProcess {
+  type Listener = (...args: unknown[]) => void;
+  const listeners: Record<string, Listener[]> = {};
+
+  const spawnOptions: Record<string, unknown> = {
+    cwd: spec.cwd,
+    env: spec.env,
+    stdio: options.stdio ?? ["inherit", "inherit", "inherit"],
+  };
+
+  if (options.ipc) {
+    spawnOptions.ipc = (message: unknown) => {
+      for (const fn of listeners["message"] ?? []) fn(message);
+    };
+  }
+
+  const proc = Bun.spawn([spec.command, ...spec.args], spawnOptions);
+
+  // Wire exit → "close" event, catch → "error" event.
+  proc.exited
+    .then((code) => {
+      for (const fn of listeners["close"] ?? []) fn(code);
+    })
+    .catch((err: unknown) => {
+      const error = err instanceof Error ? err : new Error(String(err));
+      for (const fn of listeners["error"] ?? []) fn(error);
+    });
+
+  return {
+    send(message: unknown) {
+      (proc as unknown as { send(m: unknown): void }).send(message);
+    },
+    on(event: string, fn: Listener) {
+      (listeners[event] ??= []).push(fn);
+    },
+    unref() {
+      proc.unref();
+    },
+  };
+}