muonroi-cli 1.6.4 → 1.6.6

package/dist/src/ui/utils/relaunch.d.ts

@@ -0,0 +1,41 @@
+/**
+ * src/ui/utils/relaunch.ts
+ *
+ * Helpers for "relaunch the CLI with a different session" — used by the
+ * /sessions picker so the user does not have to remember the id + restart
+ * the binary manually (the whole motivation of the picker).
+ *
+ * The argv mangling is a PURE function so it is unit-testable in isolation
+ * from the spawn side effects. `relaunchWithSession` glues argv mangling +
+ * child_process spawn + parent exit; it returns nothing (process replaces).
+ */
+import { spawn } from "node:child_process";
+/**
+ * Strip any existing `-s <id>` / `--session <id>` / `--session=<id>` from
+ * argv (kept indices intact otherwise) and append a fresh `--session <id>`.
+ * Pure — input arrays are not mutated.
+ *
+ * `argv` is in the shape Node provides: `[exec, scriptOrFirstArg, ...rest]`.
+ * The caller passes `process.argv.slice(1)` (the args part) and re-prepends
+ * `process.argv[0]` itself. We sanitize the WHOLE args portion in one pass.
+ */
+export declare function sanitizeArgvForResume(args: ReadonlyArray<string>, sessionId: string): string[];
+export interface RelaunchOptions {
+    /** Override process.argv (tests). Defaults to live process.argv. */
+    argv?: ReadonlyArray<string>;
+    /** Override the exit hook (tests). Defaults to process.exit. */
+    onExit?: (code: number) => void;
+    /** Injected spawn for tests. Defaults to the real node:child_process spawn. */
+    spawnFn?: typeof spawn;
+}
+/**
+ * Spawn a fresh CLI process bound to {sessionId} and exit the current one.
+ * Cross-platform: uses `stdio: "inherit"` so the child takes over the TTY,
+ * and `detached: false` so killing the parent's terminal kills the child
+ * (the user expects "close window = kill" semantics).
+ *
+ * NOTE: the caller should disconnect/teardown the current TUI before invoking
+ * this — the spawn happens immediately and the parent exit is on next tick,
+ * so any open file handles / MCP transports must be released first.
+ */
+export declare function relaunchWithSession(sessionId: string, opts?: RelaunchOptions): void;

package/dist/src/ui/utils/relaunch.js

@@ -0,0 +1,71 @@
+/**
+ * src/ui/utils/relaunch.ts
+ *
+ * Helpers for "relaunch the CLI with a different session" — used by the
+ * /sessions picker so the user does not have to remember the id + restart
+ * the binary manually (the whole motivation of the picker).
+ *
+ * The argv mangling is a PURE function so it is unit-testable in isolation
+ * from the spawn side effects. `relaunchWithSession` glues argv mangling +
+ * child_process spawn + parent exit; it returns nothing (process replaces).
+ */
+import { spawn } from "node:child_process";
+/**
+ * Strip any existing `-s <id>` / `--session <id>` / `--session=<id>` from
+ * argv (kept indices intact otherwise) and append a fresh `--session <id>`.
+ * Pure — input arrays are not mutated.
+ *
+ * `argv` is in the shape Node provides: `[exec, scriptOrFirstArg, ...rest]`.
+ * The caller passes `process.argv.slice(1)` (the args part) and re-prepends
+ * `process.argv[0]` itself. We sanitize the WHOLE args portion in one pass.
+ */
+export function sanitizeArgvForResume(args, sessionId) {
+    if (!sessionId || !sessionId.trim()) {
+        throw new Error("sanitizeArgvForResume: sessionId is required");
+    }
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "-s" || a === "--session") {
+            // skip the flag AND its value (if present and not another flag)
+            const next = args[i + 1];
+            if (next !== undefined && !next.startsWith("-"))
+                i++;
+            continue;
+        }
+        if (a.startsWith("--session=")) {
+            continue; // skip the combined form
+        }
+        out.push(a);
+    }
+    out.push("--session", sessionId);
+    return out;
+}
+/**
+ * Spawn a fresh CLI process bound to {sessionId} and exit the current one.
+ * Cross-platform: uses `stdio: "inherit"` so the child takes over the TTY,
+ * and `detached: false` so killing the parent's terminal kills the child
+ * (the user expects "close window = kill" semantics).
+ *
+ * NOTE: the caller should disconnect/teardown the current TUI before invoking
+ * this — the spawn happens immediately and the parent exit is on next tick,
+ * so any open file handles / MCP transports must be released first.
+ */
+export function relaunchWithSession(sessionId, opts = {}) {
+    const argv = opts.argv ?? process.argv;
+    const exec = argv[0];
+    if (!exec) {
+        throw new Error("relaunchWithSession: process.argv[0] is empty — cannot relaunch");
+    }
+    const exit = opts.onExit ?? ((code) => process.exit(code));
+    const spawnImpl = opts.spawnFn ?? spawn;
+    const args = sanitizeArgvForResume(argv.slice(1), sessionId);
+    const child = spawnImpl(exec, args, { stdio: "inherit", detached: false });
+    child.once("error", (err) => {
+        console.error(`[relaunch] spawn failed: ${err?.message ?? err}`);
+        exit(1);
+    });
+    // Hand the TTY to the child and exit cleanly. The child takes over rendering.
+    child.once("spawn", () => exit(0));
+}
+//# sourceMappingURL=relaunch.js.map

package/dist/src/ui/utils/relaunch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/ui/utils/relaunch.test.js

@@ -0,0 +1,83 @@
+import { EventEmitter } from "node:events";
+import { describe, expect, it, vi } from "vitest";
+import { relaunchWithSession, sanitizeArgvForResume } from "./relaunch.js";
+describe("sanitizeArgvForResume", () => {
+    it("appends --session when no prior session flag exists", () => {
+        expect(sanitizeArgvForResume(["-m", "grok-build-0.1"], "abc-123")).toEqual([
+            "-m",
+            "grok-build-0.1",
+            "--session",
+            "abc-123",
+        ]);
+    });
+    it("strips an existing `-s <id>` and replaces it", () => {
+        expect(sanitizeArgvForResume(["-s", "old-id", "-m", "grok-build-0.1"], "new-id")).toEqual([
+            "-m",
+            "grok-build-0.1",
+            "--session",
+            "new-id",
+        ]);
+    });
+    it("strips an existing `--session <id>` (long form)", () => {
+        expect(sanitizeArgvForResume(["--session", "old-id", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
+    });
+    it("strips the combined `--session=<id>` form", () => {
+        expect(sanitizeArgvForResume(["--session=old-id", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
+    });
+    it("strips `--session` even when its value looks like another flag (treats value as missing)", () => {
+        // edge: user typed `--session --batch-api` — we don't eat the next flag
+        expect(sanitizeArgvForResume(["--session", "--batch-api", "-y"], "new-id")).toEqual([
+            "--batch-api",
+            "-y",
+            "--session",
+            "new-id",
+        ]);
+    });
+    it("removes multiple stray session flags (defensive — last wins)", () => {
+        expect(sanitizeArgvForResume(["-s", "a", "--session", "b", "--session=c"], "z")).toEqual(["--session", "z"]);
+    });
+    it("throws when sessionId is empty or whitespace", () => {
+        expect(() => sanitizeArgvForResume([], "")).toThrow(/sessionId is required/);
+        expect(() => sanitizeArgvForResume([], "  ")).toThrow(/sessionId is required/);
+    });
+});
+describe("relaunchWithSession", () => {
+    it("spawns the same executable with the sanitized argv + session id, then exits 0", () => {
+        const exitMock = vi.fn();
+        const child = new EventEmitter();
+        const spawnMock = vi.fn(() => child);
+        relaunchWithSession("sess-xyz", {
+            argv: ["/usr/local/bin/muonroi-cli", "-m", "grok-build-0.1"],
+            onExit: exitMock,
+            spawnFn: spawnMock,
+        });
+        expect(spawnMock).toHaveBeenCalledTimes(1);
+        expect(spawnMock).toHaveBeenCalledWith("/usr/local/bin/muonroi-cli", ["-m", "grok-build-0.1", "--session", "sess-xyz"], { stdio: "inherit", detached: false });
+        // exit fires on the child's "spawn" event
+        child.emit("spawn");
+        expect(exitMock).toHaveBeenCalledWith(0);
+    });
+    it("exits 1 if the child spawn errors before starting", () => {
+        const exitMock = vi.fn();
+        const errMock = vi.spyOn(console, "error").mockImplementation(() => { });
+        const child = new EventEmitter();
+        const spawnMock = vi.fn(() => child);
+        relaunchWithSession("sess-xyz", {
+            argv: ["/bin/muonroi", "-y"],
+            onExit: exitMock,
+            spawnFn: spawnMock,
+        });
+        child.emit("error", new Error("ENOENT"));
+        expect(exitMock).toHaveBeenCalledWith(1);
+        expect(errMock).toHaveBeenCalled();
+        errMock.mockRestore();
+    });
+    it("throws when argv[0] is missing (cannot relaunch without an executable)", () => {
+        expect(() => relaunchWithSession("sess", {
+            argv: [],
+            onExit: () => { },
+            spawnFn: (() => new EventEmitter()),
+        })).toThrow(/process\.argv\[0\] is empty/);
+    });
+});
+//# sourceMappingURL=relaunch.test.js.map

package/dist/src/utils/settings.d.ts

@@ -330,6 +330,16 @@ export declare function getProviderStallTimeoutMs(): number;
  * Default 1. Env override: MUONROI_PROVIDER_STALL_RETRIES.
  */
 export declare function getProviderStallRetries(): number;
+/**
+ * Live-queue steering: when true, a message typed while a turn is streaming is
+ * injected into the running turn at the next prepareStep boundary (as a `user`
+ * interjection) instead of waiting for the turn to finish and running as a new
+ * turn. When false, the legacy deferred-queue behaviour is preserved (the
+ * message runs only after the current turn completes). House convention for a
+ * default-true boolean knob: only an explicit "0" disables; unset/blank/any
+ * other value = enabled. Env override: MUONROI_STEER_INJECTION.
+ */
+export declare function getSteerInjectionEnabled(): boolean;
 /**
  * Phase B3 — threshold (in chars of cumulative message content) above which
  * the sub-agent `prepareStep` compactor rewrites older tool_result parts

package/dist/src/utils/settings.js

@@ -714,6 +714,18 @@ export function getProviderStallRetries() {
     }
     return 1;
 }
+/**
+ * Live-queue steering: when true, a message typed while a turn is streaming is
+ * injected into the running turn at the next prepareStep boundary (as a `user`
+ * interjection) instead of waiting for the turn to finish and running as a new
+ * turn. When false, the legacy deferred-queue behaviour is preserved (the
+ * message runs only after the current turn completes). House convention for a
+ * default-true boolean knob: only an explicit "0" disables; unset/blank/any
+ * other value = enabled. Env override: MUONROI_STEER_INJECTION.
+ */
+export function getSteerInjectionEnabled() {
+    return process.env.MUONROI_STEER_INJECTION !== "0";
+}
 /**
  * Phase B3 — threshold (in chars of cumulative message content) above which
  * the sub-agent `prepareStep` compactor rewrites older tool_result parts

package/dist/src/utils/settings.test.js

@@ -188,4 +188,25 @@ describe("getProviderStallRetries", () => {
         }
     });
 });
+describe("getSteerInjectionEnabled", () => {
+    it("defaults to true when the env var is unset or blank", async () => {
+        vi.unstubAllEnvs();
+        const { getSteerInjectionEnabled } = await import("./settings.js");
+        expect(getSteerInjectionEnabled()).toBe(true);
+        vi.stubEnv("MUONROI_STEER_INJECTION", "");
+        expect(getSteerInjectionEnabled()).toBe(true);
+    });
+    it("returns false only for an explicit '0'", async () => {
+        const { getSteerInjectionEnabled } = await import("./settings.js");
+        vi.stubEnv("MUONROI_STEER_INJECTION", "0");
+        expect(getSteerInjectionEnabled()).toBe(false);
+    });
+    it("returns true for '1' and any other non-'0' value", async () => {
+        const { getSteerInjectionEnabled } = await import("./settings.js");
+        for (const v of ["1", "true", "yes", "on", "xyz"]) {
+            vi.stubEnv("MUONROI_STEER_INJECTION", v);
+            expect(getSteerInjectionEnabled()).toBe(true);
+        }
+    });
+});
 //# sourceMappingURL=settings.test.js.map

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "1.6.4",
+  "version": "1.6.6",
   "description": "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.",
   "repository": {
     "type": "git",