mulmoterminal 1.7.1 → 1.7.2

package/bin/mulmoterminal.js

@@ -7,13 +7,14 @@
 
 import { execSync, spawn } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
-import { get as httpGet } from "node:http";
 import { createRequire } from "node:module";
 import { createServer } from "node:net";
 import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { computeUpdateNotice, isUpdateCheckDisabled } from "./update-check.js";
+import { detectNpxCacheDir, npxCacheHintLines } from "./npx-cache-hint.js";
+import { waitUntilReady } from "./wait-ready.js";
 import {
   chooseCwd,
   parsePortArg,
@@ -30,10 +31,12 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_DIR = join(__dirname, "..");
 const SERVER_ENTRY = join(PKG_DIR, "server", "index.ts");
 const DEFAULT_PORT = 34567;
-const READY_TIMEOUT_MS = 15_000;
 // Server exit code meaning "port taken at bind time" — keep in sync with
 // server/index.ts (PORT_IN_USE_EXIT_CODE).
 const PORT_IN_USE_EXIT_CODE = 75;
+// Only the end of stderr matters for the crash diagnosis; a long-lived server can log
+// arbitrarily much before dying, so the tail is bounded.
+const STDERR_TAIL_MAX_BYTES = 64 * 1024;
 
 // Single source of truth: read the version from the shipped package.json so
 // `--version` never drifts from the published version.
@@ -170,36 +173,6 @@ function isPortFree(port) {
   });
 }
 
-// Poll the server until it answers, then call onReady; give up after the timeout
-// so the launcher never hangs on a crash loop. Returns a cancel function — a
-// raced/abandoned attempt stops polling so it can't fire a stale banner.
-function waitUntilReady(port, onReady) {
-  const startedAt = Date.now();
-  let timer = null;
-  let cancelled = false;
-  const attempt = () => {
-    if (cancelled) return;
-    const req = httpGet({ host: "127.0.0.1", port, path: "/", timeout: 1000 }, (res) => {
-      res.resume();
-      if (!cancelled) onReady();
-    });
-    req.on("error", retry);
-    req.on("timeout", () => {
-      req.destroy();
-      retry();
-    });
-  };
-  const retry = () => {
-    if (cancelled || Date.now() - startedAt > READY_TIMEOUT_MS) return;
-    timer = setTimeout(attempt, 300);
-  };
-  attempt();
-  return () => {
-    cancelled = true;
-    if (timer) clearTimeout(timer);
-  };
-}
-
 function printReadyBanner(url) {
   const bar = "\x1b[32m" + "─".repeat(48) + "\x1b[0m";
   console.log(`\n${bar}`);
@@ -272,10 +245,18 @@ async function choosePort(requested, explicit) {
 function runServer(port, noOpen, cwd, onChild) {
   return new Promise((resolveExit) => {
     log(`Starting MulmoTerminal on port ${port}...`);
+    // stderr is piped (and passed through) so a fatal boot error can be inspected once the
+    // child closes — a half-unpacked npx cache entry crashes here with ERR_MODULE_NOT_FOUND,
+    // and without reading stderr the launcher cannot tell that from a real bug.
     const server = spawn(process.execPath, ["--import", "tsx", SERVER_ENTRY], {
       cwd: PKG_DIR,
       env: { ...process.env, NODE_ENV: "production", PORT: String(port), CLAUDE_CWD: cwd },
-      stdio: "inherit",
+      stdio: ["inherit", "inherit", "pipe"],
+    });
+    let stderrTail = "";
+    server.stderr.on("data", (chunk) => {
+      process.stderr.write(chunk);
+      stderrTail = (stderrTail + chunk.toString()).slice(-STDERR_TAIL_MAX_BYTES);
     });
     onChild(server);
 
@@ -292,7 +273,10 @@ function runServer(port, noOpen, cwd, onChild) {
       }
     });
 
-    server.on("exit", (code) => {
+    // `close`, not `exit`: it fires only once the piped stderr has fully drained, so the
+    // whole crash output — including a trailing `_npx/<hash>` line that can arrive after
+    // `exit` — is in `stderrTail` before we inspect it.
+    server.on("close", (code) => {
       cancelReady();
       // Exit code 75 means this child failed to bind (EADDRINUSE) and never
       // served — always retriable, regardless of what a probe to the port saw
@@ -301,6 +285,10 @@ function runServer(port, noOpen, cwd, onChild) {
         resolveExit();
         return;
       }
+      if (code !== 0) {
+        const cacheDir = detectNpxCacheDir(stderrTail);
+        if (cacheDir) npxCacheHintLines(cacheDir, process.platform).forEach((line) => error(line));
+      }
       process.exit(code ?? 1);
     });
   });

package/bin/npx-cache-hint.d.ts

@@ -0,0 +1,2 @@
+export declare function detectNpxCacheDir(stderrText: string): string | null;
+export declare function npxCacheHintLines(cacheDir: string, platform: NodeJS.Platform): string[];

package/bin/npx-cache-hint.js

@@ -0,0 +1,69 @@
+// Turning a confusing crash into a one-line fix. When an `npx mulmoterminal` install is
+// aborted mid-unpack (npm's npx lock race — `ECOMPROMISED: Lock compromised`), the next run
+// reuses the half-unpacked `~/.npm/_npx/<hash>/node_modules` and dies at boot with
+// ERR_MODULE_NOT_FOUND for some transitive dependency. That reads as a broken package, but
+// the published tarball is fine — the local npx cache entry is corrupted, and removing it
+// is the whole fix. Nothing here reads the filesystem; the caller feeds it stderr text.
+
+const MISSING_MODULE = /ERR_MODULE_NOT_FOUND|Cannot find (?:package|module)/;
+
+// The cache entry itself: `<sep>_npx<sep><hash>` followed by another separator. Anchored on
+// the literal `_npx` rather than on a leading `[^\s'"]*` wildcard — that prefix can also match
+// separators, which makes the match ambiguous and the regex backtrack super-linearly on a long
+// stack trace. The directory part before it is recovered by scanning, not by matching.
+const NPX_ENTRY = /[/\\]_npx[/\\][0-9a-f]+(?=[/\\])/;
+
+// What ends the path token a stack trace embeds: whitespace, or the quotes Node wraps
+// specifiers in.
+const PATH_BOUNDARIES = [" ", "\t", "\n", "\r", "'", '"'];
+
+// Where the path token containing the entry begins: just past the last boundary before it.
+const pathStartIndex = (textBefore) => Math.max(-1, ...PATH_BOUNDARIES.map((ch) => textBefore.lastIndexOf(ch))) + 1;
+
+/**
+ * The corrupted npx cache entry a failed boot points at, or null.
+ * Fires only when BOTH signals are present — a module-resolution error and a path inside
+ * an `_npx/<hash>` cache entry — so an ordinary crash, or a resolution error in a normal
+ * install, never triggers the hint.
+ */
+export function detectNpxCacheDir(stderrText) {
+  if (typeof stderrText !== "string" || !MISSING_MODULE.test(stderrText)) return null;
+  const match = NPX_ENTRY.exec(stderrText);
+  if (!match) return null;
+  return stderrText.slice(pathStartIndex(stderrText.slice(0, match.index)), match.index + match[0].length);
+}
+
+// Shell-quote the cache dir so a path containing quote characters (a home dir with an
+// apostrophe on POSIX is the realistic case) produces a command that is still valid — and
+// safe — to copy-paste, rather than one that breaks or runs something unintended.
+
+// POSIX single-quoting: wrap in '…' and turn every embedded ' into '\'' (close, escaped
+// quote, reopen). Nothing inside single quotes is special, so this is injection-proof.
+const posixQuote = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+
+// PowerShell single-quoting: '…' with each ' doubled. Single quotes suppress $-interpolation
+// (a double-quoted path containing $ would otherwise expand a variable), so this is safe.
+const powershellQuote = (s) => `'${s.replace(/'/g, "''")}'`;
+
+// cmd has no way to escape a " inside "…", but " is an illegal character in a Windows path,
+// so double-quoting a real cache dir is safe; it protects the spaces that do occur.
+const cmdQuote = (s) => `"${s}"`;
+
+// The delete command differs per platform, and a wrong one is worse than none: `rm -rf` is not
+// a command on Windows, and cmd's `rmdir /s /q` is a syntax error in PowerShell (where `rmdir`
+// aliases Remove-Item), so Windows gets both of its shells spelled out.
+const removalCommands = (cacheDir, platform) =>
+  platform === "win32"
+    ? [`  cmd:        rmdir /s /q ${cmdQuote(cacheDir)}`, `  PowerShell: Remove-Item -Recurse -Force ${powershellQuote(cacheDir)}`]
+    : [`  rm -rf ${posixQuote(cacheDir)}`];
+
+/** The recovery instructions shown under the crash, one string per line. */
+export function npxCacheHintLines(cacheDir, platform) {
+  return [
+    "This looks like a corrupted npx cache, not a MulmoTerminal bug.",
+    'An interrupted `npx` install (npm\'s "Lock compromised" race) can leave this entry half-unpacked:',
+    `  ${cacheDir}`,
+    "Remove it and run the same command again:",
+    ...removalCommands(cacheDir, platform),
+  ];
+}

package/bin/wait-ready.d.ts

@@ -0,0 +1,26 @@
+// Only the surface probeOnce actually touches — narrower than http.ClientRequest /
+// IncomingMessage on purpose, so a test fake and the real node:http both satisfy it.
+export interface ProbeRequest {
+  on(event: "error" | "timeout", listener: (...args: unknown[]) => void): unknown;
+  destroy(): void;
+}
+
+export interface ProbeResponse {
+  resume(): void;
+}
+
+export type ProbeGet = (opts: { host: string; port: number; path: string; timeout: number }, cb: (res: ProbeResponse) => void) => ProbeRequest;
+
+export declare function probeOnce(get: ProbeGet, port: number, timeoutMs?: number): Promise<"ready" | "retry">;
+
+export declare function waitUntilReady(
+  port: number,
+  onReady: () => void,
+  deps?: {
+    get?: ProbeGet;
+    now?: () => number;
+    timeoutMs?: number;
+    intervalMs?: number;
+    readyTimeoutMs?: number;
+  },
+): () => void;

package/bin/wait-ready.js

@@ -0,0 +1,61 @@
+// Polling the launched server until it answers `/`, then firing onReady exactly once.
+// Split out of mulmoterminal.js so the retry state machine is testable without a socket.
+
+import { get as httpGet } from "node:http";
+
+const PROBE_TIMEOUT_MS = 1000;
+const RETRY_INTERVAL_MS = 300;
+const DEFAULT_READY_TIMEOUT_MS = 15_000;
+
+// One probe of the server: resolves "ready" if it answers, else "retry". It NEVER
+// rejects, and yields exactly ONE outcome per call — the crucial guarantee. Destroying a
+// timed-out request itself emits an 'error', so a single timeout would otherwise trigger
+// both the timeout handler AND the error handler; each schedules a retry, the poll loop
+// forks in two, and every fork fires onReady when the server finally answers — printing
+// the banner and opening the browser several times. The `settled` latch collapses each
+// request to one outcome.
+export function probeOnce(get, port, timeoutMs = PROBE_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (outcome) => {
+      if (settled) return;
+      settled = true;
+      resolve(outcome);
+    };
+    const req = get({ host: "127.0.0.1", port, path: "/", timeout: timeoutMs }, (res) => {
+      res.resume();
+      done("ready");
+    });
+    req.on("error", () => done("retry"));
+    req.on("timeout", () => {
+      req.destroy();
+      done("retry");
+    });
+  });
+}
+
+// Poll until the server answers, then call onReady once; give up after readyTimeoutMs so
+// the launcher never hangs on a crash loop. Returns a cancel function — a raced/abandoned
+// attempt stops polling so it can't fire a stale banner. `deps` is injectable for tests.
+export function waitUntilReady(port, onReady, deps = {}) {
+  const { get = httpGet, now = Date.now, timeoutMs = PROBE_TIMEOUT_MS, intervalMs = RETRY_INTERVAL_MS, readyTimeoutMs = DEFAULT_READY_TIMEOUT_MS } = deps;
+  const startedAt = now();
+  let cancelled = false;
+  let timer = null;
+  const loop = async () => {
+    if (cancelled) return;
+    const outcome = await probeOnce(get, port, timeoutMs);
+    if (cancelled) return;
+    if (outcome === "ready") {
+      onReady();
+      return;
+    }
+    if (now() - startedAt > readyTimeoutMs) return;
+    timer = setTimeout(loop, intervalMs);
+  };
+  loop();
+  return () => {
+    cancelled = true;
+    if (timer) clearTimeout(timer);
+  };
+}

package/common/modelPresets.ts

@@ -197,7 +197,7 @@ export const MODEL_PRESETS: readonly ModelPreset[] = [
     provider: "openrouter",
     id: "nvidia/nemotron-3-ultra-550b-a55b",
     label: "Nemotron 3 Ultra 550B",
-    contextLength: 512_288,
+    contextLength: 524_288, // 512 KiB = 512 * 1024; was 512_288 (a typo)
     pricePerMTok: { input: 0.6, output: 3.6 },
     trials: measured(3, 3, 13),
   },
@@ -300,14 +300,19 @@ export const MODEL_PRESETS: readonly ModelPreset[] = [
 
 // Presets for one provider, plus whatever the user added to that provider's `models`.
 // A user entry with the same id as a preset keeps the preset's measured numbers rather
-// than appearing twice.
+// than appearing twice — and two user entries for the same id (even differing only in
+// case) collapse to one, so a dropdown never shows the same model twice.
 export function presetsForProvider(providerId: string, userModels: readonly string[] = []): ModelPreset[] {
   const presets = MODEL_PRESETS.filter((preset) => preset.provider === providerId);
   // Match `presetFor` (modelOption.ts), which compares ids case-insensitively: a user
   // entry that only differs from a preset in case is the same model, not a new one.
-  const known = new Set(presets.map((preset) => preset.id.toLowerCase()));
-  const added: ModelPreset[] = userModels
-    .filter((id) => !known.has(id.toLowerCase()))
-    .map((id) => ({ provider: providerId, id, label: id, contextLength: 0, pricePerMTok: { input: 0, output: 0 }, trials: { status: "unmeasured" } }));
+  const seen = new Set(presets.map((preset) => preset.id.toLowerCase()));
+  const added: ModelPreset[] = [];
+  for (const id of userModels) {
+    const key = id.toLowerCase();
+    if (seen.has(key)) continue; // already a preset OR an earlier user entry
+    seen.add(key);
+    added.push({ provider: providerId, id, label: id, contextLength: 0, pricePerMTok: { input: 0, output: 0 }, trials: { status: "unmeasured" } });
+  }
   return [...presets, ...added];
 }

package/dist/assets/{abnfDiagram-VRR7QNED-RjiYivmv-0ZB3Q7Mv.js → abnfDiagram-VRR7QNED-RjiYivmv-CCLjG9E9.js}

@@ -1 +1 @@
-import{n as e}from"./chunk-Y2CYZVJY-Bdt8pFDJ-DsF7k-Jl.js";import{f as t}from"./src-Brzfja-q-ch1VcTiG.js";import{_ as n,g as r}from"./mermaid-parser.core-DxEa8E3F-bFNCoAMV.js";import"./chunk-WYO6CB5R-BlzOfotS-Dm5-lJPj.js";import"./chunk-VAUOI2AC-CS9QJ4yz-BkjFKKFo.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-DynKnij8.js";import{t as s}from"./chunk-JWPE2WC7-BQ3zXr2k-DSd3Ct95.js";var c=r().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{s(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{a.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let r=c.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new n(r);let i=r.value;t.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:o,styles:i};export{g as diagram};
+import{n as e}from"./chunk-Y2CYZVJY-Bdt8pFDJ-DsF7k-Jl.js";import{f as t}from"./src-Brzfja-q-ch1VcTiG.js";import{_ as n,g as r}from"./mermaid-parser.core-DxEa8E3F-kLn0LOBf.js";import"./chunk-WYO6CB5R-BlzOfotS-Cg8JP_k-.js";import"./chunk-VAUOI2AC-CS9QJ4yz-rBHFym4n.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-CfjRj6ge.js";import{t as s}from"./chunk-JWPE2WC7-BQ3zXr2k-DSd3Ct95.js";var c=r().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{s(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{a.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let r=c.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new n(r);let i=r.value;t.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:o,styles:i};export{g as diagram};

package/dist/assets/architecture-TIHT7OUA-0NsD2xW1-Dc62_ljl.js

@@ -0,0 +1 @@
+import{f as e}from"./mermaid-parser.core-DxEa8E3F-kLn0LOBf.js";export{e as createArchitectureServices};