tandem-editor 0.6.2 → 0.6.3

package/dist/cli/index.js

@@ -257,7 +257,7 @@ var init_cli_runtime = __esm({
 });
 
 // src/cli/preflight.ts
-async function ensureTandemServer(opts = {}) {
+async function probeTandemServer(opts = {}) {
   const url = resolveTandemUrl(opts.url);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const controller = new AbortController();
@@ -265,22 +265,36 @@ async function ensureTandemServer(opts = {}) {
   try {
     const res = await fetch(`${url}/health`, { signal: controller.signal });
     if (!res.ok) {
-      fail(url, `health endpoint returned HTTP ${res.status}`);
+      return {
+        ok: false,
+        url,
+        reason: `health endpoint returned HTTP ${res.status}`,
+        kind: "unhealthy"
+      };
     }
+    return { ok: true };
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    fail(url, msg);
+    return {
+      ok: false,
+      url,
+      reason: err instanceof Error ? err.message : String(err),
+      kind: "unreachable"
+    };
   } finally {
     clearTimeout(timer);
   }
 }
-function fail(url, detail) {
-  process.stderr.write(
-    `[tandem] Tandem server not reachable at ${url} (${detail}).
-[tandem] Start the Tauri app or run \`tandem start\` on the host, then retry.
+async function ensureTandemServer(opts = {}) {
+  const probe = await probeTandemServer(opts);
+  if (!probe.ok) {
+    const guidance = probe.kind === "unreachable" ? "Start the Tauri app or run `tandem start` on the host, then retry." : "The Tandem server is running but unhealthy \u2014 check the host logs.";
+    process.stderr.write(
+      `[tandem] Tandem server preflight failed at ${probe.url} (${probe.reason}).
+[tandem] ${guidance}
 `
-  );
-  process.exit(1);
+    );
+    process.exit(1);
+  }
 }
 var DEFAULT_TIMEOUT_MS;
 var init_preflight = __esm({
@@ -295,80 +309,165 @@ var init_preflight = __esm({
 var mcp_stdio_exports = {};
 __export(mcp_stdio_exports, {
   getRequestId: () => getRequestId,
+  getResponseId: () => getResponseId,
   runMcpStdio: () => runMcpStdio
 });
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 async function runMcpStdio() {
   const baseUrl = resolveTandemUrl();
-  await ensureTandemServer({ url: baseUrl });
   const http = new StreamableHTTPClientTransport(new URL(`${baseUrl}/mcp`));
   const stdio = new StdioServerTransport();
+  const pendingIds = /* @__PURE__ */ new Set();
+  const preReadyBuffer = [];
   let shuttingDown = false;
-  const shutdown = async (code = 0) => {
+  let httpReady = false;
+  async function sendErrorResponse(id, message, detail) {
+    const errorResponse = {
+      jsonrpc: "2.0",
+      id,
+      error: {
+        // -32000 is the implementation-defined server error range per
+        // JSON-RPC 2.0 §5.1 — upstream unavailability is an application-
+        // level condition, not a generic Internal Error.
+        code: -32e3,
+        message,
+        ...detail !== void 0 ? { data: { detail } } : {}
+      }
+    };
+    try {
+      await stdio.send(errorResponse);
+    } catch (err) {
+      const detail2 = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        `[tandem mcp-stdio] failed to send synthesized error for id ${id}: ${detail2}
+`
+      );
+    }
+  }
+  function forwardToUpstream(msg) {
+    const requestId = getRequestId(msg);
+    if (requestId !== void 0) pendingIds.add(requestId);
+    http.send(msg).catch((err) => {
+      const detail = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[tandem mcp-stdio] upstream send failed: ${detail}
+`);
+      if (requestId !== void 0 && pendingIds.delete(requestId)) {
+        void sendErrorResponse(requestId, "Tandem HTTP upstream unreachable", detail);
+      }
+    });
+  }
+  async function synthesizeBuffered(message, detail) {
+    const buffered2 = preReadyBuffer.splice(0);
+    const ids = buffered2.map((msg) => getRequestId(msg)).filter((id) => id !== void 0);
+    for (const id of ids) {
+      await sendErrorResponse(id, message, detail);
+    }
+  }
+  async function synthesizePending(message, detail) {
+    if (pendingIds.size === 0) return;
+    const ids = [...pendingIds];
+    pendingIds.clear();
+    await Promise.all(ids.map((id) => sendErrorResponse(id, message, detail)));
+  }
+  const shutdown = async (code = 0, synth) => {
     if (!shuttingDown) {
       shuttingDown = true;
-      await http.close().catch(() => {
+      if (synth) {
+        await synthesizeBuffered(synth.message, synth.detail);
+        await synthesizePending(synth.message, synth.detail);
+      }
+      await http.close().catch((err) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[tandem mcp-stdio] http.close failed: ${detail}
+`);
       });
-      await stdio.close().catch(() => {
+      await stdio.close().catch((err) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[tandem mcp-stdio] stdio.close failed: ${detail}
+`);
       });
     }
     process.exit(code);
   };
+  function deferredShutdown(synth) {
+    setTimeout(() => void shutdown(1, synth), PREFLIGHT_GRACE_MS);
+  }
   stdio.onmessage = (msg) => {
-    http.send(msg).catch((err) => {
-      const detail = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[tandem mcp-stdio] upstream send failed: ${detail}
-`);
-      const requestId = getRequestId(msg);
-      if (requestId !== void 0) {
-        const errorResponse = {
-          jsonrpc: "2.0",
-          id: requestId,
-          error: {
-            // -32000 is the implementation-defined server error range per
-            // JSON-RPC 2.0 §5.1 — the upstream being unreachable is an
-            // application-level condition, not a generic Internal Error.
-            code: -32e3,
-            message: "Tandem HTTP upstream unreachable",
-            data: { detail }
-          }
-        };
-        stdio.send(errorResponse).catch(() => {
-        });
-      }
-    });
+    if (!httpReady) {
+      preReadyBuffer.push(msg);
+      return;
+    }
+    forwardToUpstream(msg);
   };
   http.onmessage = (msg) => {
-    stdio.send(msg).catch((err) => {
-      const detail = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[tandem mcp-stdio] stdio write failed: ${detail}
-`);
-    });
+    const responseId = getResponseId(msg);
+    stdio.send(msg).then(
+      () => {
+        if (responseId !== void 0) pendingIds.delete(responseId);
+      },
+      (err) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        process.stderr.write(
+          `[tandem mcp-stdio] stdio write failed for id ${responseId ?? "<notification>"}: ${detail}
+`
+        );
+        void shutdown(1, {
+          message: "Tandem stdio write failed",
+          detail
+        });
+      }
+    );
   };
   stdio.onerror = (err) => {
     process.stderr.write(`[tandem mcp-stdio] stdio error: ${err.message}
+${err.stack ?? ""}
 `);
   };
   http.onerror = (err) => {
-    process.stderr.write(`[tandem mcp-stdio] http error: ${err.message}
-`);
+    const cause = err.cause;
+    process.stderr.write(
+      `[tandem mcp-stdio] http error: ${err.message}
+${err.stack ?? ""}${cause !== void 0 ? `
+cause: ${cause}` : ""}
+`
+    );
   };
   stdio.onclose = () => {
     void shutdown(0);
   };
   http.onclose = () => {
-    void shutdown(0);
+    if (shuttingDown) return;
+    void shutdown(1, {
+      message: "Tandem HTTP upstream closed unexpectedly",
+      detail: "upstream connection dropped mid-session"
+    });
   };
   await stdio.start();
+  const probe = await probeTandemServer({ url: baseUrl });
+  if (!probe.ok) {
+    const guidance = probe.kind === "unreachable" ? "Start the Tauri app or run `tandem start` on the host, then retry." : "The Tandem server is running but unhealthy \u2014 check the host logs.";
+    process.stderr.write(
+      `[tandem mcp-stdio] Tandem server preflight failed at ${probe.url} (${probe.reason}).
+[tandem mcp-stdio] ${guidance}
+`
+    );
+    const synthMessage = probe.kind === "unreachable" ? "Tandem server not running. Start the Tauri app or run `tandem start`." : "Tandem server unhealthy (check host logs).";
+    deferredShutdown({ message: synthMessage, detail: probe.reason });
+    return;
+  }
   try {
     await http.start();
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[tandem mcp-stdio] upstream http start failed: ${detail}
 `);
-    await shutdown(1);
+    deferredShutdown({ message: "Tandem HTTP upstream failed to start", detail });
+    return;
   }
+  httpReady = true;
+  const buffered = preReadyBuffer.splice(0);
+  for (const msg of buffered) forwardToUpstream(msg);
 }
 function getRequestId(msg) {
   const m = msg;
@@ -376,12 +475,34 @@ function getRequestId(msg) {
   if (typeof m.id === "string" || typeof m.id === "number") return m.id;
   return void 0;
 }
+function getResponseId(msg) {
+  const m = msg;
+  if (typeof m.method === "string") return void 0;
+  if (typeof m.id === "string" || typeof m.id === "number") return m.id;
+  return void 0;
+}
+var PREFLIGHT_GRACE_MS;
 var init_mcp_stdio = __esm({
   "src/cli/mcp-stdio.ts"() {
     "use strict";
     init_cli_runtime();
     init_preflight();
     redirectConsoleToStderr();
+    PREFLIGHT_GRACE_MS = 1500;
+    process.once("uncaughtException", (err) => {
+      process.stderr.write(
+        `[tandem mcp-stdio] uncaughtException: ${err.message}
+${err.stack ?? ""}
+`
+      );
+      process.exit(1);
+    });
+    process.once("unhandledRejection", (reason) => {
+      const detail = reason instanceof Error ? reason.message : String(reason);
+      process.stderr.write(`[tandem mcp-stdio] unhandledRejection: ${detail}
+`);
+      process.exit(1);
+    });
   }
 });
 
@@ -905,7 +1026,7 @@ var init_start = __esm({
 
 // src/cli/index.ts
 import updateNotifier from "update-notifier";
-var version = true ? "0.6.2" : "0.0.0-dev";
+var version = true ? "0.6.3" : "0.0.0-dev";
 var args = process.argv.slice(2);
 var isStdioMode = args[0] === "mcp-stdio" || args[0] === "channel";
 if (!isStdioMode) {