muonroi-cli 1.4.0 → 1.4.1

package/src/utils/ee-logger.ts

@@ -1,163 +0,0 @@
-/**
- * src/utils/ee-logger.ts
- *
- * Structured EE-failure logger.
- *
- * Every silent Experience Engine catch site routes through `logEeFailure` so:
- *   1. Operators see a `[ee.<source>.<kind>]` warn line with the error name +
- *      message (no full stack — these failures are degrade signals, not
- *      crashes).
- *   2. The agent harness sees an `ee-timeout` / `ee-error` `LiveEvent` when
- *      `globalThis.__muonroiAgentRuntime?.emitEvent` is wired (TUI agent-mode).
- *
- * Contract:
- *   - Pure aside from `console.warn` + best-effort `emitEvent`.
- *   - NEVER throws (the existing degrade paths must keep returning their
- *     fallbacks unchanged).
- *   - No PII — only error name/message/stack-less metadata is logged.
- *
- * Source labels are documented in `.planning/phases/21-ee-observability-resilience/21-01-PLAN.md`.
- */
-
-export type EeFailureKind = "timeout" | "error";
-
-/**
- * Phase 21 — Plan 02 / T4
- *
- * Read a numeric env var with bounds clamping. Returns `def` if the env var is
- * unset, non-numeric, or out of range. Centralized here so both
- * `src/pil/layer3-ee-injection.ts` and `src/ee/bb-retrieval.ts` (and any future
- * EE timeout knob) read from the same helper — keeping the env-name → default
- * mapping reviewable in one place.
- *
- * @param name Env var name (e.g. `MUONROI_PIL_SEARCH_TIMEOUT_MS`)
- * @param def Default value when env is unset or invalid
- * @param lo Inclusive lower bound (clamped)
- * @param hi Inclusive upper bound (clamped)
- */
-export function readTimeoutEnv(name: string, def: number, lo: number, hi: number): number {
-  const raw = process.env[name];
-  if (raw === undefined || raw === "") return def;
-  const n = Number(raw);
-  if (!Number.isFinite(n)) return def;
-  return Math.max(lo, Math.min(hi, n));
-}
-
-export interface EeFailureExtra {
-  elapsedMs?: number;
-  budgetMs?: number;
-  [k: string]: unknown;
-}
-
-/**
- * Phase 21.5 — hotfix for `routeModel` / `routeTask` hanging when EE server is
- * unreachable. Those core calls do not accept an AbortSignal, so we race the
- * promise against a `TimeoutError` rejection. The caller's existing catch arm
- * then runs `logEeFailure(source, "timeout", err)` and falls back to null.
- *
- * Rejected error has `name = "TimeoutError"` so `classifyEeError` treats it as
- * a timeout (not a generic error), keeping forensics + harness events tidy.
- */
-export async function withEeTimeout<T>(p: Promise<T>, timeoutMs: number): Promise<T> {
-  return await new Promise<T>((resolve, reject) => {
-    const handle = setTimeout(() => {
-      const e = new Error(`EE call exceeded ${timeoutMs}ms`);
-      e.name = "TimeoutError";
-      reject(e);
-    }, timeoutMs);
-    p.then(
-      (v) => {
-        clearTimeout(handle);
-        resolve(v);
-      },
-      (err) => {
-        clearTimeout(handle);
-        reject(err);
-      },
-    );
-  });
-}
-
-interface AgentRuntimeLike {
-  emitEvent?: (e: unknown) => void;
-}
-
-function readAgentRuntime(): AgentRuntimeLike | undefined {
-  try {
-    const candidate = (globalThis as Record<string, unknown>).__muonroiAgentRuntime;
-    return candidate as AgentRuntimeLike | undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function describeError(err: unknown): { name: string; message: string } {
-  if (err === null) return { name: "Null", message: "null" };
-  if (err === undefined) return { name: "Undefined", message: "undefined" };
-  if (typeof err === "string") return { name: "String", message: err };
-  if (err instanceof Error) {
-    return { name: err.name || "Error", message: err.message || "" };
-  }
-  if (typeof err === "object") {
-    const rec = err as { name?: unknown; message?: unknown };
-    const name = typeof rec.name === "string" ? rec.name : "Object";
-    const message = typeof rec.message === "string" ? rec.message : "";
-    return { name, message };
-  }
-  return { name: typeof err, message: String(err) };
-}
-
-/**
- * Classify an unknown error as timeout vs. error.
- *
- * Treats both `TimeoutError` (Web/Node spec for `AbortSignal.timeout`) and
- * `AbortError` (Node fetch / older spec) as timeouts because in EE paths both
- * indicate "budget exceeded" rather than a thrown failure.
- */
-export function classifyEeError(err: unknown): EeFailureKind {
-  const { name } = describeError(err);
-  return name === "TimeoutError" || name === "AbortError" ? "timeout" : "error";
-}
-
-/**
- * Log a silent EE failure as a structured warn + harness event.
- *
- * Never throws. Safe to call from `.catch(...)` arms in fire-and-forget paths.
- */
-export function logEeFailure(source: string, kind: EeFailureKind, err: unknown, extra?: EeFailureExtra): void {
-  const { name, message } = describeError(err);
-
-  try {
-    // eslint-disable-next-line no-console
-    console.warn(`[ee.${source}.${kind}]`, { name, message }, extra ?? {});
-  } catch {
-    /* best-effort logging — never fatal */
-  }
-
-  try {
-    const runtime = readAgentRuntime();
-    if (!runtime || typeof runtime.emitEvent !== "function") return;
-
-    if (kind === "timeout") {
-      runtime.emitEvent({
-        t: "event",
-        kind: "ee-timeout",
-        source,
-        elapsedMs: extra?.elapsedMs,
-        budgetMs: extra?.budgetMs,
-        ts: Date.now(),
-      });
-    } else {
-      runtime.emitEvent({
-        t: "event",
-        kind: "ee-error",
-        source,
-        name,
-        message,
-        ts: Date.now(),
-      });
-    }
-  } catch {
-    /* harness emit must never break degrade paths */
-  }
-}

package/src/utils/file-index.ts

@@ -1,152 +0,0 @@
-import { execSync } from "child_process";
-import { basename, resolve } from "path";
-import { findGitRoot } from "./git-root.js";
-
-const REFRESH_TTL_MS = 30_000;
-const BINARY_EXTENSIONS = new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".webp",
-  ".ico",
-  ".bmp",
-  ".tiff",
-  ".mp3",
-  ".mp4",
-  ".wav",
-  ".avi",
-  ".mov",
-  ".mkv",
-  ".flac",
-  ".ogg",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".bz2",
-  ".7z",
-  ".rar",
-  ".xz",
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".eot",
-  ".otf",
-  ".pdf",
-  ".doc",
-  ".docx",
-  ".xls",
-  ".xlsx",
-  ".ppt",
-  ".pptx",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".o",
-  ".a",
-  ".pyc",
-  ".class",
-  ".wasm",
-]);
-
-function isBinaryPath(filePath: string): boolean {
-  const ext = filePath.lastIndexOf(".");
-  if (ext === -1) return false;
-  return BINARY_EXTENSIONS.has(filePath.slice(ext).toLowerCase());
-}
-
-function collectFiles(cwd: string): string[] {
-  const gitRoot = findGitRoot(cwd);
-  try {
-    const cmd = gitRoot
-      ? "git ls-files --cached --others --exclude-standard"
-      : "find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' | head -5000";
-    const raw = execSync(cmd, {
-      cwd: gitRoot ?? cwd,
-      encoding: "utf-8",
-      maxBuffer: 10 * 1024 * 1024,
-      timeout: 5000,
-    });
-    return raw
-      .split("\n")
-      .map((l) => l.trim())
-      .filter((l) => l.length > 0 && !isBinaryPath(l));
-  } catch {
-    return [];
-  }
-}
-
-function scoreMatch(filePath: string, query: string): number {
-  const lowerPath = filePath.toLowerCase();
-  const lowerQuery = query.toLowerCase();
-  if (!lowerPath.includes(lowerQuery)) return -1;
-
-  let score = 0;
-  const name = basename(filePath).toLowerCase();
-
-  if (name === lowerQuery) score += 100;
-  else if (name.startsWith(lowerQuery)) score += 60;
-  else if (name.includes(lowerQuery)) score += 30;
-
-  if (lowerPath.startsWith(lowerQuery)) score += 20;
-
-  const idx = lowerPath.indexOf(lowerQuery);
-  score -= idx * 0.1;
-
-  score -= filePath.length * 0.05;
-
-  return score;
-}
-
-export class FileIndex {
-  private files: string[] = [];
-  private cwd: string;
-  private baseDir: string;
-  private lastRefresh = 0;
-
-  constructor(cwd: string) {
-    this.cwd = cwd;
-    this.baseDir = findGitRoot(cwd) ?? cwd;
-  }
-
-  async refresh(): Promise<void> {
-    this.files = collectFiles(this.cwd);
-    this.lastRefresh = Date.now();
-  }
-
-  updateCwd(cwd: string): void {
-    if (cwd !== this.cwd) {
-      this.cwd = cwd;
-      this.baseDir = findGitRoot(cwd) ?? cwd;
-      this.lastRefresh = 0;
-    }
-  }
-
-  private async ensureFresh(): Promise<void> {
-    if (Date.now() - this.lastRefresh > REFRESH_TTL_MS) {
-      await this.refresh();
-    }
-  }
-
-  async match(query: string, maxResults = 10): Promise<string[]> {
-    await this.ensureFresh();
-    if (!query) return this.files.slice(0, maxResults);
-
-    const scored: { path: string; score: number }[] = [];
-    for (const f of this.files) {
-      const s = scoreMatch(f, query);
-      if (s >= 0) scored.push({ path: f, score: s });
-    }
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, maxResults).map((s) => s.path);
-  }
-
-  get size(): number {
-    return this.files.length;
-  }
-
-  resolvePath(filePath: string): string {
-    return resolve(this.baseDir, filePath);
-  }
-}

package/src/utils/file-lock.ts

@@ -1,66 +0,0 @@
-import { promises as fs } from "node:fs";
-
-const DEFAULT_RETRY_MS = [10, 25, 50, 100, 200, 400, 800];
-const DEFAULT_TIMEOUT_MS = 10_000;
-
-// In-process mutex: ensures same-process callers are serialized before
-// competing for the on-disk lock file, so the first caller always wins.
-const inProcessLocks = new Map<string, Promise<void>>();
-
-export interface FileLockOptions {
-  retryDelays?: number[];
-  timeoutMs?: number;
-}
-
-export async function withFileLock<T>(filePath: string, fn: () => Promise<T>, opts: FileLockOptions = {}): Promise<T> {
-  // Chain behind any existing in-process waiter for the same path.
-  const prev = inProcessLocks.get(filePath) ?? Promise.resolve();
-  let resolveInProcess!: () => void;
-  const next = new Promise<void>((r) => {
-    resolveInProcess = r;
-  });
-  inProcessLocks.set(
-    filePath,
-    prev.then(() => next),
-  );
-
-  try {
-    // Wait for our turn in-process first.
-    await prev;
-    return await acquireFileLock(filePath, fn, opts);
-  } finally {
-    resolveInProcess();
-    // Clean up map entry once this waiter has resolved its slot.
-    if (inProcessLocks.get(filePath) === prev.then(() => next)) {
-      inProcessLocks.delete(filePath);
-    }
-  }
-}
-
-async function acquireFileLock<T>(filePath: string, fn: () => Promise<T>, opts: FileLockOptions): Promise<T> {
-  const lockPath = `${filePath}.lock`;
-  const retryDelays = opts.retryDelays ?? DEFAULT_RETRY_MS;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const startedAt = Date.now();
-  let attempt = 0;
-  while (true) {
-    try {
-      const handle = await fs.open(lockPath, "wx");
-      await handle.close();
-      try {
-        return await fn();
-      } finally {
-        await fs.unlink(lockPath).catch(() => {});
-      }
-    } catch (e: any) {
-      // EEXIST = lock exists (POSIX); EPERM = lock exists and locked (Windows)
-      if (e?.code !== "EEXIST" && e?.code !== "EPERM") throw e;
-      if (Date.now() - startedAt > timeoutMs) {
-        throw new Error(`withFileLock: timed out waiting for ${lockPath}`);
-      }
-      const delay = retryDelays[Math.min(attempt, retryDelays.length - 1)];
-      attempt += 1;
-      await new Promise((r) => setTimeout(r, delay));
-    }
-  }
-}

package/src/utils/git-root.ts

@@ -1,17 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-export function findGitRoot(start: string): string | null {
-  let current = start;
-
-  while (true) {
-    const gitPath = path.join(current, ".git");
-    if (fs.existsSync(gitPath)) {
-      return current;
-    }
-
-    const parent = path.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}

package/src/utils/host-clipboard.ts

@@ -1,68 +0,0 @@
-import { spawnSync } from "node:child_process";
-import os from "node:os";
-
-/**
- * Put plain text on the OS clipboard (OpenCode-style fallback when OSC 52 is not enough).
- */
-export function copyTextToHostClipboard(text: string): void {
-  const platform = os.platform();
-
-  if (platform === "darwin") {
-    const r = spawnSync("pbcopy", [], { input: text });
-    if (r.status === 0) return;
-  }
-
-  if (platform === "linux") {
-    if (process.env.WAYLAND_DISPLAY) {
-      const w = spawnSync("wl-copy", [], { input: text });
-      if (w.status === 0) return;
-    }
-    const x = spawnSync("xclip", ["-selection", "clipboard"], { input: text });
-    if (x.status === 0) return;
-    const s = spawnSync("xsel", ["--clipboard", "--input"], { input: text });
-    if (s.status === 0) return;
-  }
-
-  if (platform === "win32") {
-    const clip = spawnSync("clip", [], { input: text });
-    if (clip.status === 0) return;
-  }
-}
-
-/**
- * Read plain text from the OS clipboard. Returns empty string on failure
- * or when the clipboard does not contain text. Used by the right-click
- * paste shortcut in the prompt input.
- */
-export function readTextFromHostClipboard(): string {
-  const platform = os.platform();
-
-  if (platform === "darwin") {
-    const r = spawnSync("pbpaste", [], { encoding: "utf8" });
-    if (r.status === 0 && typeof r.stdout === "string") return r.stdout;
-    return "";
-  }
-
-  if (platform === "linux") {
-    if (process.env.WAYLAND_DISPLAY) {
-      const w = spawnSync("wl-paste", ["--no-newline"], { encoding: "utf8" });
-      if (w.status === 0 && typeof w.stdout === "string") return w.stdout;
-    }
-    const x = spawnSync("xclip", ["-selection", "clipboard", "-o"], { encoding: "utf8" });
-    if (x.status === 0 && typeof x.stdout === "string") return x.stdout;
-    const s = spawnSync("xsel", ["--clipboard", "--output"], { encoding: "utf8" });
-    if (s.status === 0 && typeof s.stdout === "string") return s.stdout;
-    return "";
-  }
-
-  if (platform === "win32") {
-    // Powershell Get-Clipboard returns text content, with a trailing CRLF.
-    const r = spawnSync("powershell", ["-NoProfile", "-Command", "Get-Clipboard -Raw"], { encoding: "utf8" });
-    if (r.status === 0 && typeof r.stdout === "string") {
-      return r.stdout.replace(/\r\n$/, "");
-    }
-    return "";
-  }
-
-  return "";
-}

package/src/utils/install-manager.test.ts

@@ -1,167 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  buildScriptUninstallPlan,
-  getInstallMetadataPath,
-  getReleaseTargetForPlatform,
-  getScriptInstallContext,
-  getScriptInstallDir,
-  loadScriptInstallMetadata,
-  parseChecksumsFile,
-  saveScriptInstallMetadata,
-} from "./install-manager";
-
-let tempDirs: string[] = [];
-
-afterEach(() => {
-  for (const dir of tempDirs) fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-  tempDirs = [];
-});
-
-function createTempDir(prefix: string): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-describe("getReleaseTargetForPlatform", () => {
-  it("maps supported platforms to release asset names", () => {
-    expect(getReleaseTargetForPlatform("darwin", "arm64")?.assetName).toBe("muonroi-cli-darwin-arm64");
-    expect(getReleaseTargetForPlatform("darwin", "x64")?.assetName).toBe("muonroi-cli-darwin-arm64");
-    expect(getReleaseTargetForPlatform("linux", "x64")?.assetName).toBe("muonroi-cli-linux-x64");
-    expect(getReleaseTargetForPlatform("win32", "x64")?.assetName).toBe("muonroi-cli-windows-x64.exe");
-    expect(getReleaseTargetForPlatform("linux", "arm64")).toBeNull();
-  });
-});
-
-describe("parseChecksumsFile", () => {
-  it("parses standard and BSD-style checksum entries", () => {
-    const checksums = parseChecksumsFile(
-      [
-        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa  muonroi-cli-darwin-arm64",
-        "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb *muonroi-cli-windows-x64.exe",
-      ].join("\n"),
-    );
-    expect(checksums.get("muonroi-cli-darwin-arm64")).toBe(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-    );
-    expect(checksums.get("muonroi-cli-windows-x64.exe")).toBe(
-      "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-    );
-  });
-});
-
-describe("script install metadata", () => {
-  it("round-trips metadata through write and load", () => {
-    const homeDir = createTempDir("muonroi-cli-meta-");
-    const installDir = getScriptInstallDir(homeDir);
-    const metadata = {
-      schemaVersion: 1,
-      installMethod: "script" as const,
-      version: "1.2.3",
-      repo: "muonroi/muonroi-cli",
-      binaryPath: path.join(installDir, "muonroi-cli"),
-      installDir,
-      assetName: "muonroi-cli-darwin-arm64",
-      target: "darwin-arm64" as const,
-      installedAt: "2026-04-03T00:00:00.000Z",
-      shellConfigPath: path.join(homeDir, ".zshrc"),
-      pathCommand: `export PATH=${installDir}:$PATH`,
-    };
-
-    saveScriptInstallMetadata(metadata, homeDir);
-    expect(loadScriptInstallMetadata(homeDir)).toEqual(metadata);
-    expect(fs.existsSync(getInstallMetadataPath(homeDir))).toBe(true);
-  });
-
-  it("returns null when no metadata file exists", () => {
-    expect(loadScriptInstallMetadata(createTempDir("muonroi-cli-empty-"))).toBeNull();
-  });
-});
-
-describe("getScriptInstallContext", () => {
-  it("returns context when metadata exists", () => {
-    const homeDir = createTempDir("muonroi-cli-ctx-");
-    const installDir = getScriptInstallDir(homeDir);
-    const currentTarget = getReleaseTargetForPlatform();
-    expect(currentTarget).not.toBeNull();
-
-    saveScriptInstallMetadata(
-      {
-        schemaVersion: 1,
-        installMethod: "script" as const,
-        version: "1.2.3",
-        repo: "muonroi/muonroi-cli",
-        binaryPath: path.join(installDir, currentTarget!.binaryName),
-        installDir,
-        assetName: currentTarget!.assetName,
-        target: currentTarget!.key,
-        installedAt: "2026-04-03T00:00:00.000Z",
-      },
-      homeDir,
-    );
-
-    const ctx = getScriptInstallContext(homeDir);
-    expect(ctx?.metadata.installMethod).toBe("script");
-    expect(ctx?.binaryPath).toBe(path.join(installDir, currentTarget!.binaryName));
-  });
-
-  it("returns null when no metadata exists", () => {
-    expect(getScriptInstallContext(createTempDir("muonroi-cli-no-ctx-"))).toBeNull();
-  });
-});
-
-describe("buildScriptUninstallPlan", () => {
-  it("removes the full ~/.muonroi-cli directory by default", () => {
-    const homeDir = createTempDir("muonroi-cli-uninstall-");
-    const installDir = getScriptInstallDir(homeDir);
-    const currentTarget = getReleaseTargetForPlatform()!;
-    fs.mkdirSync(installDir, { recursive: true });
-
-    saveScriptInstallMetadata(
-      {
-        schemaVersion: 1,
-        installMethod: "script" as const,
-        version: "1.2.3",
-        repo: "muonroi/muonroi-cli",
-        binaryPath: path.join(installDir, currentTarget.binaryName),
-        installDir,
-        assetName: currentTarget.assetName,
-        target: currentTarget.key,
-        installedAt: "2026-04-03T00:00:00.000Z",
-      },
-      homeDir,
-    );
-
-    const plan = buildScriptUninstallPlan({}, homeDir);
-    expect(plan?.removePaths).toContain(path.join(homeDir, ".muonroi-cli"));
-  });
-
-  it("keeps config and data when requested", () => {
-    const homeDir = createTempDir("muonroi-cli-keep-");
-    const installDir = getScriptInstallDir(homeDir);
-    const currentTarget = getReleaseTargetForPlatform()!;
-    fs.mkdirSync(installDir, { recursive: true });
-
-    saveScriptInstallMetadata(
-      {
-        schemaVersion: 1,
-        installMethod: "script" as const,
-        version: "1.2.3",
-        repo: "muonroi/muonroi-cli",
-        binaryPath: path.join(installDir, currentTarget.binaryName),
-        installDir,
-        assetName: currentTarget.assetName,
-        target: currentTarget.key,
-        installedAt: "2026-04-03T00:00:00.000Z",
-      },
-      homeDir,
-    );
-
-    const plan = buildScriptUninstallPlan({ keepConfig: true, keepData: true }, homeDir);
-    expect(plan?.removePaths).not.toContain(path.join(homeDir, ".muonroi-cli"));
-    expect(plan?.removePaths).toContain(path.join(installDir, currentTarget.binaryName));
-  });
-});