mixdog 0.9.65 → 0.9.67

package/src/tui/markdown/streaming-markdown.mjs

@@ -4,10 +4,17 @@
  */
 import { marked } from 'marked';
 import { configureMarked, hasMarkdownSyntax } from './render-ansi.mjs';
-import { trimPartialClosingFences, findOpenFenceStart } from './stream-fence.mjs';
+import {
+  trimPartialClosingFences,
+  findOpenFenceStart,
+  resetAllOpenFenceScans,
+  resetOpenFenceScan,
+} from './stream-fence.mjs';
 import { displayWidth } from '../display-width.mjs';
 
 const stablePrefixByStreamKey = new Map();
+const markdownSyntaxByStreamKey = new Map();
+const plainWindowSyntaxByStreamKey = new Map();
 // Reuse the current normalized-text split across measure → render → harvest.
 const resolvedPartsByStreamKey = new Map();
 const STABLE_PREFIX_LRU_MAX = 32;
@@ -17,48 +24,92 @@ export function streamingLayoutText(text) {
   return String(text ?? '').replace(/^\n+|\n+$/g, '');
 }
 
-export function windowPlainStreamingText(text, columns, maxRows) {
+export function windowPlainStreamingText(text, columns, maxRows, streamKey = null) {
   const value = streamingLayoutText(text);
   const rowBudget = Math.max(0, Math.floor(Number(maxRows) || 0));
-  if (!value || rowBudget <= 0 || hasMarkdownSyntax(value)) return value;
-  const lines = value.split('\n');
+  const key = streamKey == null || streamKey === '' ? null : String(streamKey);
+  if (!value || rowBudget <= 0 || cachedStreamingHasMarkdownSyntax(
+    plainWindowSyntaxByStreamKey,
+    value,
+    key,
+  )) return value;
   const width = Math.max(1, Math.floor(Number(columns) || 80));
   let rows = 0;
-  let start = lines.length;
-  while (start > 0) {
-    const line = lines[start - 1];
+  let end = value.length;
+  let start = end;
+  while (end >= 0) {
+    const newline = value.lastIndexOf('\n', end - 1);
+    const lineStart = newline + 1;
+    const line = value.slice(lineStart, end);
     const lineRows = Math.max(1, Math.ceil(displayWidth(line) / width));
     if (rows > 0 && rows + lineRows > rowBudget) break;
     rows += lineRows;
-    start -= 1;
-    if (rows >= rowBudget) break;
+    start = lineStart;
+    if (rows >= rowBudget || newline < 0) break;
+    end = newline;
   }
-  return start > 0 ? lines.slice(start).join('\n') : value;
+  return start > 0 ? value.slice(start) : value;
 }
 
 function isWhitespaceOnlyText(text) {
   return !String(text ?? '').trim();
 }
 
-function touchStablePrefixKey(key, value) {
+function touchLruKey(cache, key, value) {
   if (!key) return;
-  if (stablePrefixByStreamKey.has(key)) stablePrefixByStreamKey.delete(key);
-  stablePrefixByStreamKey.set(key, value);
-  while (stablePrefixByStreamKey.size > STABLE_PREFIX_LRU_MAX) {
-    const oldest = stablePrefixByStreamKey.keys().next().value;
+  if (cache.has(key)) cache.delete(key);
+  cache.set(key, value);
+  while (cache.size > STABLE_PREFIX_LRU_MAX) {
+    const oldest = cache.keys().next().value;
     if (oldest === undefined) break;
-    stablePrefixByStreamKey.delete(oldest);
+    cache.delete(oldest);
   }
 }
 
+function touchStablePrefixKey(key, value) {
+  touchLruKey(stablePrefixByStreamKey, key, value);
+}
+
 function getStablePrefixKey(key) {
-  if (!key || !stablePrefixByStreamKey.has(key)) return '';
+  if (!key || !stablePrefixByStreamKey.has(key)) return { text: '', chunks: [] };
   const value = stablePrefixByStreamKey.get(key);
-  stablePrefixByStreamKey.delete(key);
-  stablePrefixByStreamKey.set(key, value);
+  touchStablePrefixKey(key, value);
   return value;
 }
 
+function stableStateForText(text, previous) {
+  if (!text) return { text: '', chunks: [] };
+  if (text.startsWith(previous.text)) {
+    const appended = text.substring(previous.text.length);
+    return appended
+      ? { text, chunks: [...previous.chunks, appended] }
+      : previous;
+  }
+  return { text, chunks: [text] };
+}
+
+function cachedStreamingHasMarkdownSyntax(cache, text, key) {
+  if (!key) return hasMarkdownSyntax(text);
+  const previous = cache.get(key);
+  let value;
+  if (previous && text.startsWith(previous.text)) {
+    if (previous.value) {
+      value = true;
+    } else {
+      const lineStart = previous.text.lastIndexOf('\n') + 1;
+      value = hasMarkdownSyntax(text.substring(Math.max(0, lineStart - 1)));
+    }
+  } else {
+    value = hasMarkdownSyntax(text);
+  }
+  touchLruKey(cache, key, { text, value });
+  return value;
+}
+
+function streamingHasMarkdownSyntax(text, key) {
+  return cachedStreamingHasMarkdownSyntax(markdownSyntaxByStreamKey, text, key);
+}
+
 function getResolvedPartsKey(key, text) {
   if (!key) return null;
   const entry = resolvedPartsByStreamKey.get(key);
@@ -136,12 +187,18 @@ export function resetStreamingMarkdownStablePrefix(streamKey) {
   if (streamKey == null || streamKey === '') return;
   const key = String(streamKey);
   stablePrefixByStreamKey.delete(key);
+  markdownSyntaxByStreamKey.delete(key);
+  plainWindowSyntaxByStreamKey.delete(key);
   resolvedPartsByStreamKey.delete(key);
+  resetOpenFenceScan(key);
 }
 
 export function resetAllStreamingMarkdownStablePrefixes() {
   stablePrefixByStreamKey.clear();
+  markdownSyntaxByStreamKey.clear();
+  plainWindowSyntaxByStreamKey.clear();
   resolvedPartsByStreamKey.clear();
+  resetAllOpenFenceScans();
 }
 
 export function resolveStreamingMarkdownParts(text, streamKey) {
@@ -155,42 +212,47 @@ export function resolveStreamingMarkdownParts(text, streamKey) {
     return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: '',
+      stableChunks: [],
       unstableSuffix: '',
       unstableForRender: '',
     });
   }
 
-  if (!hasMarkdownSyntax(t)) {
+  if (!streamingHasMarkdownSyntax(t, key)) {
     if (key) stablePrefixByStreamKey.delete(key);
     return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: '',
+      stableChunks: [],
       unstableSuffix: t,
       unstableForRender: t,
     });
   }
 
-  let stablePrefix = key ? getStablePrefixKey(key) : '';
-  if (!t.startsWith(stablePrefix)) {
-    stablePrefix = '';
+  let stableState = key ? getStablePrefixKey(key) : { text: '', chunks: [] };
+  if (!t.startsWith(stableState.text)) {
+    stableState = { text: '', chunks: [] };
   }
+  let stablePrefix = stableState.text;
 
   // Open-fence fast path: never run marked.lexer on a growing unclosed code
   // block (its closing-fence regex never matches and backtracks over the whole
   // body every delta — the ~56ms/frame cost). Split cheaply at the fence line:
   // everything before it is settled markdown (lexed + cached once by the stable
   // <Markdown>), the open block is rendered flat until the closing fence lands.
-  const open = findOpenFenceStart(t);
+  const open = findOpenFenceStart(t, key);
   if (open) {
     let openPrefix = t.substring(0, open.index);
     if (isWhitespaceOnlyText(openPrefix)) openPrefix = '';
-    if (key && openPrefix) touchStablePrefixKey(key, openPrefix);
+    stableState = stableStateForText(openPrefix, stableState);
+    if (key && openPrefix) touchStablePrefixKey(key, stableState);
     else if (key) stablePrefixByStreamKey.delete(key);
     const unstableSuffix = t.substring(openPrefix.length);
     return cacheResolvedPartsKey(key, t, {
       plain: false,
       openFence: true,
       stablePrefix: openPrefix,
+      stableChunks: stableState.chunks,
       unstableSuffix,
       unstableForRender: unstableSuffix,
     });
@@ -214,20 +276,26 @@ export function resolveStreamingMarkdownParts(text, streamKey) {
     if (advance > 0) {
       stablePrefix = t.substring(0, boundary + advance);
       if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = '';
-      if (key && stablePrefix) touchStablePrefixKey(key, stablePrefix);
+      stableState = stableStateForText(stablePrefix, stableState);
+      if (key && stablePrefix) touchStablePrefixKey(key, stableState);
       else if (key && !stablePrefix) stablePrefixByStreamKey.delete(key);
     }
   } catch {
     stablePrefix = '';
+    stableState = { text: '', chunks: [] };
     if (key) stablePrefixByStreamKey.delete(key);
   }
 
-  if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = '';
+  if (isWhitespaceOnlyText(stablePrefix)) {
+    stablePrefix = '';
+    stableState = { text: '', chunks: [] };
+  }
 
   const unstableSuffix = t.substring(stablePrefix.length);
   return cacheResolvedPartsKey(key, t, {
     plain: false,
     stablePrefix,
+    stableChunks: stableState.chunks,
     unstableSuffix,
     unstableForRender: balanceStreamingMarkdown(unstableSuffix),
   });

package/src/tui/time-format.mjs

@@ -1,53 +1,6 @@
 /**
- * TUI duration formatting (compact elapsed-time labels).
- *
- * Examples:
- *   42s
- *   9m 23s
- *   1h 2m 3s
- *   1d 3h 20m
+ * TUI duration formatting — moved to runtime/shared/time-format.mjs so the
+ * desktop tool cards share the exact same elapsed labels. This module remains
+ * as the TUI-facing import path.
  */
-export function formatDuration(ms, options = {}) {
-  if (!Number.isFinite(Number(ms))) return '';
-  const value = Math.max(0, Number(ms) || 0);
-  if (value < 60_000) {
-    if (value < 1_000) return '';
-    return `${Math.floor(value / 1000)}s`;
-  }
-
-  let days = Math.floor(value / 86_400_000);
-  let hours = Math.floor((value % 86_400_000) / 3_600_000);
-  let minutes = Math.floor((value % 3_600_000) / 60_000);
-  const seconds = Math.floor((value % 60_000) / 1000);
-
-  if (options.mostSignificantOnly) {
-    if (days > 0) return `${days}d`;
-    if (hours > 0) return `${hours}h`;
-    if (minutes > 0) return `${minutes}m`;
-    return `${seconds}s`;
-  }
-
-  const hide = options.hideTrailingZeros;
-  if (days > 0) {
-    if (hide && hours === 0 && minutes === 0) return `${days}d`;
-    if (hide && minutes === 0) return `${days}d ${hours}h`;
-    return `${days}d ${hours}h ${minutes}m`;
-  }
-  if (hours > 0) {
-    if (hide && minutes === 0 && seconds === 0) return `${hours}h`;
-    if (hide && seconds === 0) return `${hours}h ${minutes}m`;
-    return `${hours}h ${minutes}m ${seconds}s`;
-  }
-  if (minutes > 0) {
-    if (hide && seconds === 0) return `${minutes}m`;
-    return `${minutes}m ${seconds}s`;
-  }
-  return `${seconds}s`;
-}
-
-export function formatElapsed(ms) {
-  const n = Math.max(0, Number(ms || 0));
-  if (!Number.isFinite(n) || n <= 0) return '';
-  if (n < 1000) return '';
-  return formatDuration(n);
-}
+export { formatDuration, formatElapsed } from '../runtime/shared/time-format.mjs';

package/src/ui/stream-finalize.mjs

@@ -0,0 +1,45 @@
+import { visibleWidth } from './ansi.mjs';
+
+/**
+ * Build a conservative in-place final-format patch for a streamed terminal
+ * block. Logical rows must map 1:1 to physical rows; wrapped or structurally
+ * changed output returns null so the caller can use the full-redraw fallback.
+ */
+export function buildStreamFinalPatch(rawText, renderedText, { columns = 80 } = {}) {
+  const raw = String(rawText ?? '');
+  const rendered = String(renderedText ?? '');
+  if (raw.includes('\r') || rendered.includes('\r')) return null;
+  const rawLines = raw.split('\n');
+  const renderedLines = rendered.split('\n');
+  if (rawLines.length !== renderedLines.length) return null;
+
+  const width = Math.max(1, Math.floor(Number(columns) || 80));
+  for (let index = 0; index < rawLines.length; index += 1) {
+    if (visibleWidth(rawLines[index]) >= width || visibleWidth(renderedLines[index]) >= width) {
+      return null;
+    }
+  }
+
+  const changedRows = [];
+  for (let index = 0; index < rawLines.length; index += 1) {
+    if (rawLines[index] !== renderedLines[index]) changedRows.push(index);
+  }
+  if (changedRows.length === 0) {
+    return { output: '', changedRows: 0, totalRows: rawLines.length };
+  }
+
+  let output = '\r';
+  for (let index = rawLines.length - 1; index >= 0; index -= 1) {
+    if (rawLines[index] !== renderedLines[index]) {
+      output += `\x1b[2K${renderedLines[index]}`;
+    }
+    if (index > 0) output += '\r\x1b[1A';
+  }
+  if (rawLines.length > 1) {
+    output += `\r\x1b[${rawLines.length - 1}B`;
+    const lastWidth = visibleWidth(renderedLines.at(-1) || '');
+    if (lastWidth > 0) output += `\x1b[${lastWidth}C`;
+  }
+
+  return { output, changedRows: changedRows.length, totalRows: rawLines.length };
+}

package/src/runtime/channels/lib/webhook/ngrok.mjs

@@ -1,181 +0,0 @@
-import * as http from "http";
-import { join } from "path";
-import { spawnSync } from "child_process";
-import { readFileSync, writeFileSync, unlinkSync, existsSync } from "fs";
-import { DATA_DIR } from "../config.mjs";
-import { logWebhook } from "./log.mjs";
-
-function _readNgrokBinFromRegistry() {
-  if (process.platform !== "win32") return null;
-  try {
-    const r = spawnSync("reg", ["query", "HKCU\\Environment", "/v", "NGROK_BIN"], {
-      encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "ignore"],
-    });
-    if (r.status === 0 && r.stdout) {
-      const m = r.stdout.match(/NGROK_BIN\s+REG_(?:EXPAND_)?SZ\s+(.+?)\r?\n/);
-      if (m && m[1]) return m[1].trim();
-    }
-  } catch { /* missing reg.exe is non-fatal */ }
-  return null;
-}
-function resolveNgrokBin() {
-  // Invariant on Windows: BOTH process.env.NGROK_BIN AND HKCU\Environment\NGROK_BIN
-  // are candidate sources. process.env is the shell-start snapshot; registry
-  // is the live user definition. Each candidate is tried in order and the
-  // first that resolves to an existing file wins. This recovers two distinct
-  // post-setx cases without a host-agent restart:
-  //   (a) env unset, registry set    — fresh install + setx after process start
-  //   (b) env set to stale old path, registry set to new — user moved or
-  //       re-installed ngrok and setx'd the new path; the old env value would
-  //       otherwise dead-end at existsSync=false.
-  // POSIX has no registry; process.env is the sole candidate.
-  const candidates = [];
-  if (process.env.NGROK_BIN) candidates.push(process.env.NGROK_BIN);
-  const fromReg = _readNgrokBinFromRegistry();
-  if (fromReg && !candidates.includes(fromReg)) candidates.push(fromReg);
-  for (const p of candidates) {
-    if (existsSync(p)) return p;
-  }
-  if (candidates.length > 0) {
-    throw new Error(`NGROK_BIN candidates (${candidates.join(", ")}) do not exist on disk. Set NGROK_BIN to the correct ngrok binary path.`);
-  }
-  throw new Error('NGROK_BIN env var is not set. Set NGROK_BIN to the path of the ngrok binary (e.g. NGROK_BIN=/usr/local/bin/ngrok).');
-}
-const NGROK_META_FILE = join(DATA_DIR, "ngrok-meta.json");
-const NGROK_OLD_PID_FILE = join(DATA_DIR, "ngrok.pid");
-const NGROK_MAX_AGE_MS = 24 * 60 * 60 * 1e3; // 24 hours
-
-function normalizeDomain(d) {
-  if (!d) return '';
-  const url = new URL(d.includes('://') ? d : 'https://' + d);
-  if (!url.hostname) throw new Error(`[webhook] invalid host: ${d}`);
-  return url.hostname.toLowerCase();
-}
-
-function readNgrokMeta() {
-  try { return JSON.parse(readFileSync(NGROK_META_FILE, 'utf8')) } catch {}
-  // Migration: read old pid file if meta doesn't exist
-  try {
-    const pid = parseInt(readFileSync(NGROK_OLD_PID_FILE, 'utf8').trim());
-    if (pid > 0) {
-      logWebhook(`migrating ngrok.pid (PID ${pid}) to ngrok-meta.json`);
-      const meta = { pid, domain: '', port: 0, startedAt: new Date().toISOString() };
-      writeNgrokMeta(meta);
-      try { unlinkSync(NGROK_OLD_PID_FILE) } catch {}
-      return meta;
-    }
-  } catch {}
-  return null;
-}
-function writeNgrokMeta(meta) {
-  try { writeFileSync(NGROK_META_FILE, JSON.stringify(meta, null, 2)) } catch {}
-}
-function clearNgrokMeta() {
-  try { unlinkSync(NGROK_META_FILE) } catch {}
-}
-// Recycled-PID guard: a stale ngrok-meta.json may name a PID that ngrok
-// long ago freed and the OS reassigned to an unrelated process (commonly
-// another mixdog server). Verify the PID is actually an ngrok process
-// before sending a kill signal, so a live peer's server is never taken
-// down. Returns false (skip kill) when the check is inconclusive.
-function isLikelyNgrok(pid) {
-  if (!pid || pid <= 0) return false;
-  try {
-    if (process.platform === "win32") {
-      const r = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], { encoding: "utf8", timeout: 5000, windowsHide: true });
-      return /ngrok/i.test(r.stdout || "");
-    }
-    const r = spawnSync("ps", ["-p", String(pid), "-o", "comm="], { encoding: "utf8", timeout: 5000, windowsHide: true });
-    return /ngrok/i.test(r.stdout || "");
-  } catch { return false; }
-}
-
-function isProcessAlive(pid) {
-  if (!pid || pid <= 0) return false;
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-// Strict PID extraction: the first non-empty output line must be decimal-only.
-// `123junk` / any non-numeric noise → null, so a malformed shell result can
-// never be coerced into a real PID we might later signal or kill.
-function parseStrictPidLine(out) {
-  const line = String(out || "").split(/\r?\n/).map((s) => s.trim()).find((s) => s.length > 0);
-  if (!line || !/^\d+$/.test(line)) return null;
-  const n = parseInt(line, 10);
-  return Number.isFinite(n) && n > 0 ? n : null;
-}
-
-function resolvePortOwnerPid(port) {
-  // Coerce + range-validate the port BEFORE any spawn so it can never inject
-  // into a command, and use spawnSync argv (no shell) for defense in depth.
-  // Invalid port → null (treated as "no owner", never an exec).
-  const p = Number(port);
-  if (!Number.isInteger(p) || p < 1 || p > 65535) return null;
-  try {
-    if (process.platform === "win32") {
-      const r = spawnSync(
-        "powershell",
-        ["-NoProfile", "-Command", `(Get-NetTCPConnection -LocalPort ${p} -State Listen -ErrorAction SilentlyContinue | Select-Object -First 1).OwningProcess`],
-        { encoding: "utf8", timeout: 3000, windowsHide: true },
-      );
-      return r.status === 0 ? parseStrictPidLine(r.stdout) : null;
-    }
-    const r = spawnSync("lsof", ["-ti", `:${p}`, "-sTCP:LISTEN"], { encoding: "utf8", timeout: 3000, windowsHide: true });
-    return r.status === 0 ? parseStrictPidLine(r.stdout) : null;
-  } catch {
-    return null;
-  }
-}
-
-async function handleWebhookPortInUse(basePort, expectedDomain) {
-  const ownerPid = resolvePortOwnerPid(basePort);
-  const ownerAlive = ownerPid != null && isProcessAlive(ownerPid);
-  const ownerIsNgrok = ownerAlive && isLikelyNgrok(ownerPid);
-  logWebhook(
-    `port ${basePort} EADDRINUSE — not reclaiming external PID ${ownerPid ?? "unknown"} (alive=${ownerAlive}, ngrok=${ownerIsNgrok}); trying next port`,
-  );
-  return { ok: false, bump: true, ownerPid };
-}
-
-function checkNgrokHealth(expectedDomain, expectedPort = null) {
-  try {
-    return new Promise((resolve) => {
-      const req = http.get("http://localhost:4040/api/tunnels", { timeout: 2000 }, (res) => {
-        let data = "";
-        res.on("data", chunk => data += chunk);
-        res.on("end", () => {
-          try {
-            const tunnels = JSON.parse(data).tunnels || [];
-            const expected = normalizeDomain(expectedDomain);
-            const match = tunnels.some(t => {
-              if (normalizeDomain(t.public_url) !== expected) return false;
-              if (!expectedPort) return true;
-              const addr = String(t.config?.addr || '');
-              return addr === `http://localhost:${expectedPort}`
-                || addr === `https://localhost:${expectedPort}`
-                || addr.endsWith(`:${expectedPort}`);
-            });
-            resolve(match);
-          } catch { resolve(false); }
-        });
-      });
-      req.on("error", () => resolve(false));
-      req.on("timeout", () => { req.destroy(); resolve(false); });
-    });
-  } catch { return Promise.resolve(false); }
-}
-
-export {
-  NGROK_MAX_AGE_MS,
-  resolveNgrokBin,
-  normalizeDomain,
-  readNgrokMeta,
-  writeNgrokMeta,
-  clearNgrokMeta,
-  isLikelyNgrok,
-  isProcessAlive,
-  parseStrictPidLine,
-  resolvePortOwnerPid,
-  handleWebhookPortInUse,
-  checkNgrokHealth,
-};