tandem-editor 0.16.0 → 0.18.0

package/dist/server/index.js

@@ -93543,8 +93543,8 @@ function resolveChannelDist(env3 = process.env, exists = existsSync) {
   return resolve3(PACKAGE_ROOT, "dist/channel/index.js");
 }
 function resolveCliVersion() {
-  if (true) return "0.16.0";
-  if (true) return "0.16.0";
+  if (true) return "0.18.0";
+  if (true) return "0.18.0";
   for (const rel of ["../../package.json", "../../../package.json"]) {
     try {
       const pkg = JSON.parse(readFileSync2(resolve3(__dirname2, rel), "utf8"));
@@ -129433,6 +129433,10 @@ import { request } from "http";
 import { createConnection } from "net";
 import { homedir as homedir3, platform } from "os";
 import { join as join5 } from "path";
+function errorClass(err) {
+  if (err instanceof Error) return err.name;
+  return typeof err;
+}
 function checkNodeVersion(r) {
   const version3 = process.version;
   const major2 = Number.parseInt(version3.slice(1), 10);
@@ -129452,6 +129456,201 @@ function checkNodeModules(r) {
     r.fail("node_modules/ not found", "npm install");
   }
 }
+function recordEvaluation(r, result2) {
+  if (!result2) return;
+  if (result2.status === "warn") {
+    r.warn(result2.message, result2.fix, result2.data);
+    return;
+  }
+  if (result2.status === "skip") {
+    r.pass(`skipped \u2014 ${result2.message}`, result2.fix, { ...result2.data, skipped: true });
+    return;
+  }
+  r.pass(result2.message, result2.fix, result2.data);
+}
+function probeTandemEditorRepo(dir) {
+  const read = readJson2(join5(dir, "package.json"));
+  if (read.kind === "absent") return "no";
+  if (read.kind === "unreadable") return "unreadable";
+  const parsed = read.value;
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return "unreadable";
+  }
+  return parsed.name === "tandem-editor" ? "yes" : "no";
+}
+function readJson2(path33) {
+  let raw;
+  try {
+    raw = readFileSync3(path33, "utf-8");
+  } catch (err) {
+    const code3 = err.code;
+    if (code3 === "ENOENT") return { kind: "absent" };
+    return { kind: "unreadable", reason: code3 ?? errorClass(err) };
+  }
+  try {
+    return { kind: "ok", value: JSON.parse(raw) };
+  } catch {
+    return { kind: "unreadable", reason: "not valid JSON" };
+  }
+}
+function parseLockfileEntry(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const entry = value;
+  if (entry.version !== void 0 && typeof entry.version !== "string") return null;
+  if (entry.optional !== void 0 && typeof entry.optional !== "boolean") return null;
+  return {
+    version: entry.version,
+    optional: entry.optional
+  };
+}
+function parseLockfileJson(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const obj2 = value;
+  if (obj2.version !== void 0 && typeof obj2.version !== "string") return null;
+  const version3 = obj2.version;
+  if (obj2.packages === void 0) return { version: version3 };
+  if (typeof obj2.packages !== "object" || obj2.packages === null || Array.isArray(obj2.packages)) {
+    return null;
+  }
+  const packages = {};
+  for (const [path33, raw] of Object.entries(obj2.packages)) {
+    const entry = parseLockfileEntry(raw);
+    if (!entry) return null;
+    packages[path33] = entry;
+  }
+  return { version: version3, packages };
+}
+function evaluateNpmStaleness(pkgInput, lockInput, hiddenLockInput) {
+  if (!pkgInput || !lockInput || !hiddenLockInput) return null;
+  const lock = parseLockfileJson(lockInput);
+  if (!lock) {
+    return {
+      status: "skip",
+      message: "cannot compare (package-lock.json has an unexpected structure)",
+      fix: "Restore it from git: git checkout package-lock.json",
+      data: { reason: "malformed-lock" }
+    };
+  }
+  const hiddenLock = parseLockfileJson(hiddenLockInput);
+  if (!hiddenLock) {
+    return {
+      status: "skip",
+      message: "cannot compare (node_modules/.package-lock.json has an unexpected structure)",
+      fix: "npm install",
+      data: { reason: "malformed-hidden-lock" }
+    };
+  }
+  const pkg = typeof pkgInput === "object" && !Array.isArray(pkgInput) ? pkgInput : {};
+  const pkgVersion = typeof pkg.version === "string" ? pkg.version : void 0;
+  if (pkgVersion && lock.version && pkgVersion !== lock.version) {
+    return {
+      status: "warn",
+      message: `package-lock.json (v${lock.version}) is out of date with package.json (v${pkgVersion})`,
+      fix: "npm install",
+      data: { packageVersion: pkgVersion, lockVersion: lock.version }
+    };
+  }
+  if (lock.version && hiddenLock.version && lock.version !== hiddenLock.version) {
+    return {
+      status: "warn",
+      message: `node_modules was installed from a different lockfile (v${hiddenLock.version} installed, v${lock.version} expected)`,
+      fix: "npm install",
+      data: { lockVersion: lock.version, installedVersion: hiddenLock.version }
+    };
+  }
+  const wanted = lock.packages ?? {};
+  const installed = hiddenLock.packages ?? {};
+  const wantedCount = Object.keys(wanted).filter((path33) => path33 !== "").length;
+  if (wantedCount === 0) {
+    return {
+      status: "skip",
+      message: "cannot compare (package-lock.json lists no packages \u2014 a lockfileVersion 1 file, or one written by something other than npm)",
+      fix: "npm install",
+      // No inferred `lockfileVersion` here: we did not read that field, and
+      // guessing it from the presence of `packages` would put a fabricated
+      // value under a real npm field name.
+      data: { reason: "no-comparable-packages" }
+    };
+  }
+  const drifted = [];
+  for (const [path33, entry] of Object.entries(wanted)) {
+    if (path33 === "") continue;
+    const got = installed[path33];
+    if (!got) {
+      if (!entry.optional) drifted.push(path33);
+    } else if (entry.version !== got.version) {
+      drifted.push(path33);
+    }
+  }
+  for (const path33 of Object.keys(installed)) {
+    if (path33 !== "" && !(path33 in wanted)) drifted.push(path33);
+  }
+  if (drifted.length > 0) {
+    return {
+      status: "warn",
+      message: `node_modules is stale \u2014 ${drifted.length} package(s) differ from package-lock.json (e.g. after a pull or branch switch)`,
+      fix: "npm install",
+      data: { driftCount: drifted.length, sample: drifted.slice(0, 5) }
+    };
+  }
+  const missingVersions = [];
+  if (!pkgVersion) missingVersions.push("package.json");
+  if (!lock.version) missingVersions.push("package-lock.json");
+  if (!hiddenLock.version) missingVersions.push("node_modules/.package-lock.json");
+  if (missingVersions.length > 0) {
+    return {
+      status: "skip",
+      message: `node_modules matches package-lock.json, but the version check could not run \u2014 no "version" field in ${missingVersions.join(", ")}`,
+      data: { reason: "no-comparable-version", missingVersions }
+    };
+  }
+  return {
+    status: "pass",
+    message: "node_modules matches package-lock.json",
+    data: { packageCount: Object.keys(installed).length }
+  };
+}
+function readLockfileOrReport(r, path33, label) {
+  const read = readJson2(path33);
+  if (read.kind === "absent") {
+    r.pass(`skipped \u2014 cannot compare (${label} not found)`, void 0, {
+      skipped: true,
+      reason: "absent",
+      path: label
+    });
+    return { ok: false };
+  }
+  if (read.kind === "ok") {
+    if (typeof read.value === "object" && read.value !== null && !Array.isArray(read.value)) {
+      return { ok: true, value: read.value };
+    }
+    r.warn(
+      `${label} is not a JSON object \u2014 npm install staleness cannot be checked`,
+      "Check for a truncated or hand-edited file, then: npm install",
+      { reason: "not-an-object", path: label }
+    );
+    return { ok: false };
+  }
+  r.warn(
+    `${label} could not be read (${read.reason}) \u2014 npm install staleness cannot be checked`,
+    "Check for merge-conflict markers or a truncated file, then: npm install",
+    { reason: read.reason, path: label }
+  );
+  return { ok: false };
+}
+function checkNpmStaleness(r, repoDir) {
+  const pkgRead = readJson2(join5(repoDir, "package.json"));
+  const pkg = pkgRead.kind === "ok" ? pkgRead.value : null;
+  const lock = readLockfileOrReport(r, join5(repoDir, "package-lock.json"), "package-lock.json");
+  if (!lock.ok) return;
+  const hiddenLock = readLockfileOrReport(
+    r,
+    join5(repoDir, "node_modules", ".package-lock.json"),
+    "node_modules/.package-lock.json"
+  );
+  if (!hiddenLock.ok) return;
+  recordEvaluation(r, evaluateNpmStaleness(pkg, lock.value, hiddenLock.value));
+}
 function checkMcpJson(r) {
   const mcpPath = join5(process.cwd(), ".mcp.json");
   if (!existsSync2(mcpPath)) {
@@ -129577,14 +129776,64 @@ async function checkPorts(r, wsPort2, mcpPort2) {
   }
   return { ws, mcp };
 }
+function evaluateOrphanedVite(input) {
+  const { viteUp, viteConfirmed, wsUp, mcpUp, wsPort: wsPort2, mcpPort: mcpPort2, vitePort } = input;
+  if (!viteUp) return null;
+  if (!viteConfirmed) {
+    return {
+      status: "skip",
+      message: `cannot identify the process on :${vitePort} \u2014 it is listening but did not answer /@vite/client, so it is probably not a Vite dev server`,
+      data: { vite: false, ws: wsUp, mcp: mcpUp, reason: "unconfirmed-vite" }
+    };
+  }
+  if (!wsUp && !mcpUp) {
+    return {
+      status: "warn",
+      message: `Vite dev server on :${vitePort} is running but the backend (:${wsPort2} + :${mcpPort2}) is down \u2014 likely orphaned by a crashed dev session`,
+      fix: `If you meant to run the client alone (npm run dev:client), this is expected. Otherwise kill the process on :${vitePort} and restart: npm run dev:standalone`,
+      data: { vite: true, ws: wsUp, mcp: mcpUp }
+    };
+  }
+  if (wsUp !== mcpUp) {
+    return {
+      status: "skip",
+      message: `cannot tell whether the Vite dev server on :${vitePort} is orphaned \u2014 the backend is only partially up (:${wsPort2} ${wsUp ? "up" : "down"}, :${mcpPort2} ${mcpUp ? "up" : "down"}); see the ports check`,
+      data: { vite: true, ws: wsUp, mcp: mcpUp, reason: "partial-backend" }
+    };
+  }
+  return {
+    status: "pass",
+    message: `Vite dev server (:${vitePort}) running alongside the backend`,
+    data: { vite: true, ws: wsUp, mcp: mcpUp }
+  };
+}
+async function checkOrphanedVite(r, wsUp, mcpUp, wsPort2, mcpPort2, vitePort) {
+  const viteUp = await probePort(vitePort);
+  const viteConfirmed = viteUp ? await isViteDevServer(vitePort) : false;
+  recordEvaluation(
+    r,
+    evaluateOrphanedVite({ viteUp, viteConfirmed, wsUp, mcpUp, wsPort: wsPort2, mcpPort: mcpPort2, vitePort })
+  );
+}
 function httpGet(url, timeoutMs = 3e3) {
   return new Promise((resolve5) => {
     const req = request(url, { timeout: timeoutMs }, (res) => {
       let body = "";
+      let bytes = 0;
+      let truncated = false;
       res.on("data", (chunk2) => {
+        if (truncated) return;
+        bytes += Buffer.byteLength(chunk2);
+        if (bytes > HTTP_MAX_BYTES) {
+          truncated = true;
+          res.destroy();
+          resolve5({ status: res.statusCode, data: null });
+          return;
+        }
         body += chunk2;
       });
       res.on("end", () => {
+        if (truncated) return;
         try {
           resolve5({ status: res.statusCode, data: JSON.parse(body) });
         } catch {
@@ -129600,6 +129849,10 @@ function httpGet(url, timeoutMs = 3e3) {
     req.end();
   });
 }
+async function isViteDevServer(port) {
+  const result2 = await httpGet(`http://127.0.0.1:${port}/@vite/client`, 2e3);
+  return result2?.status === 200;
+}
 async function checkHealth(r, mcpPort2) {
   const result2 = await httpGet(`http://127.0.0.1:${mcpPort2}/health`);
   if (!result2) {
@@ -129839,7 +130092,7 @@ function evaluateStaleGlobal(bundled, globalVersion) {
   };
 }
 async function checkStaleGlobal(r) {
-  const bundled = true ? "0.16.0" : null;
+  const bundled = true ? "0.18.0" : null;
   if (!bundled) return;
   let globalVersion;
   try {
@@ -129858,16 +130111,37 @@ async function checkStaleGlobal(r) {
 async function runDoctor(opts = {}) {
   const wsPort2 = opts.wsPort ?? DEFAULT_WS_PORT;
   const mcpPort2 = opts.mcpPort ?? DEFAULT_MCP_PORT;
+  const vitePort = opts.vitePort ?? VITE_DEV_PORT;
   const r = new Recorder();
+  const cwd = process.cwd();
+  const repo = probeTandemEditorRepo(cwd);
+  const devRepo = repo === "yes";
   await r.check("node-version", () => checkNodeVersion(r));
   await r.check("node-modules", () => checkNodeModules(r));
+  if (repo === "unreadable") {
+    await r.check(
+      "dev-repo",
+      () => r.warn(
+        "package.json in the current directory could not be read \u2014 if this is the tandem-editor checkout, the npm-staleness and orphaned-Vite checks are being skipped",
+        "Check for merge-conflict markers or a truncated file: git checkout package.json"
+      )
+    );
+  }
+  if (devRepo) {
+    await r.check("npm-staleness", () => checkNpmStaleness(r, cwd));
+  }
   await r.check("mcp-json", () => checkMcpJson(r));
   await r.check("user-mcp-config", () => checkUserMcpConfig(r));
   await r.check("annotation-store", () => checkAnnotationStore(r));
   await r.check("stale-global", () => checkStaleGlobal(r));
-  const { mcp } = await r.check("ports", () => checkPorts(r, wsPort2, mcpPort2));
+  const ports = await r.check("ports", () => checkPorts(r, wsPort2, mcpPort2));
+  const ws = ports?.ws ?? false;
+  const mcp = ports?.mcp ?? false;
+  if (devRepo) {
+    await r.check("orphaned-vite", () => checkOrphanedVite(r, ws, mcp, wsPort2, mcpPort2, vitePort));
+  }
   if (mcp) {
-    const healthy = await r.check("health", () => checkHealth(r, mcpPort2));
+    const healthy = await r.check("health", () => checkHealth(r, mcpPort2)) ?? false;
     if (healthy) {
       await r.check("sse", () => checkSseEndpoint(r, mcpPort2));
     }
@@ -129882,7 +130156,7 @@ async function runDoctor(opts = {}) {
     results: r.results
   };
 }
-var Recorder;
+var Recorder, VITE_DEV_PORT, HTTP_MAX_BYTES;
 var init_doctor = __esm({
   "src/cli/doctor.ts"() {
     "use strict";
@@ -129893,11 +130167,29 @@ var init_doctor = __esm({
       warnings = 0;
       results = [];
       currentCheck = "";
+      /**
+       * Run one check under `name`. A throwing check is contained here and
+       * recorded as a `fail` rather than taking the whole report down.
+       *
+       * Returns `T | undefined` — NOT `T`. The `undefined` is load-bearing and
+       * must not be cast away: a crashed check produced no value, and the two
+       * callers that consume one (`ports` destructures `{ws, mcp}`; `health`
+       * gates the `sse` check) have to say what they want instead. Returning
+       * `undefined as T` would satisfy the compiler and then throw a TypeError
+       * on the destructure — converting a clear crash into a confusing one on
+       * the exact path this containment exists to protect.
+       */
       async check(name2, fn) {
         const prev = this.currentCheck;
         this.currentCheck = name2;
         try {
           return await fn();
+        } catch (err) {
+          this.fail(
+            `${name2} check crashed (${errorClass(err)}) \u2014 the rest of the report is still valid`,
+            "Please report this at https://github.com/bloknayrb/tandem/issues"
+          );
+          return void 0;
         } finally {
           this.currentCheck = prev;
         }
@@ -129920,6 +130212,8 @@ var init_doctor = __esm({
         this.record("fail", msg, fix, fields);
       }
     };
+    VITE_DEV_PORT = 5173;
+    HTTP_MAX_BYTES = 256 * 1024;
   }
 });
 
@@ -129974,7 +130268,13 @@ var init_diagnostics = __esm({
     "use strict";
     init_doctor();
     init_middleware();
-    DEV_REPO_CHECKS = /* @__PURE__ */ new Set(["node-modules", "mcp-json"]);
+    DEV_REPO_CHECKS = /* @__PURE__ */ new Set([
+      "node-modules",
+      "mcp-json",
+      "npm-staleness",
+      "orphaned-vite",
+      "dev-repo"
+    ]);
   }
 });
 
@@ -174831,7 +175131,7 @@ function registerAwarenessTools(server) {
   server.registerTool(
     "tandem_checkInbox",
     {
-      description: "Check for user actions you haven't seen yet \u2014 new comments, chat messages, and responses to your annotations. Call after completing any task, between steps, and whenever you pause. Low token cost.",
+      description: "Check for user actions you haven't seen yet \u2014 new comments, chat messages, and responses to your annotations. You cannot tell whether real-time push is reaching you, so poll at a steady cadence: every 2-3 tool calls, after completing any task, between steps, and whenever you pause. Already-seen items are de-duplicated, so frequent calls are cheap and never double-report. Low token cost \u2014 when in doubt, call it.",
       inputSchema: {
         documentId: external_exports.string().optional().describe("Target document ID (defaults to active document)")
       },
@@ -187922,6 +188222,10 @@ function sseHandler(req, res) {
   }
   res.write(": connected\n\n");
   let keepalive;
+  function cleanup() {
+    clearInterval(keepalive);
+    unsubscribe(onEvent);
+  }
   const onEvent = (event) => {
     try {
       writeEvent(res, event);
@@ -187930,17 +188234,23 @@ function sseHandler(req, res) {
         "[SSE] Write failed, cleaning up subscriber:",
         err instanceof Error ? err.message : err
       );
-      clearInterval(keepalive);
-      unsubscribe(onEvent);
+      cleanup();
     }
   };
   subscribe2(onEvent);
   keepalive = setInterval(() => {
-    res.write(": keepalive\n\n");
+    try {
+      if (!res.writableEnded) res.write(": keepalive\n\n");
+    } catch (err) {
+      console.error(
+        "[SSE] Keepalive write failed, cleaning up subscriber:",
+        err instanceof Error ? err.message : err
+      );
+      cleanup();
+    }
   }, CHANNEL_SSE_KEEPALIVE_MS);
   req.on("close", () => {
-    clearInterval(keepalive);
-    unsubscribe(onEvent);
+    cleanup();
     console.error("[SSE] Client disconnected from /api/events");
   });
   console.error("[SSE] Client connected to /api/events");
@@ -188114,7 +188424,7 @@ init_document2();
 init_document_service();
 init_docx_apply2();
 var esmRequire2 = createRequire2(import.meta.url);
-var APP_VERSION = true ? "0.16.0" : _readVersionFromDisk();
+var APP_VERSION = true ? "0.18.0" : _readVersionFromDisk();
 var MCP_SDK_VERSION = true ? "1.27.1" : "0.0.0-unknown";
 var __dirname3 = dirname3(fileURLToPath4(import.meta.url));
 var CLIENT_DIST = join7(__dirname3, "../client");