npm - tandem-editor - Versions diffs - 0.5.0 → 0.6.0 - Mend

tandem-editor 0.5.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/.claude-plugin/marketplace.json +19 -0
package/.claude-plugin/plugin.json +27 -0
package/CHANGELOG.md +55 -0
package/README.md +27 -0
package/dist/channel/index.js +156 -143
package/dist/channel/index.js.map +1 -1
package/dist/cli/index.js +718 -133
package/dist/cli/index.js.map +1 -1
package/dist/client/assets/index-mo5ZOPfU.js +349 -0
package/dist/client/index.html +63 -2
package/dist/monitor/index.js +4570 -0
package/dist/monitor/index.js.map +1 -0
package/dist/server/index.js +152 -221
package/dist/server/index.js.map +1 -1
package/package.json +5 -3
package/skills/tandem/SKILL.md +93 -0
package/dist/client/assets/index-BS8jwldm.js +0 -345

package/.claude-plugin/marketplace.json ADDED Viewed

@@ -0,0 +1,19 @@
+{
+  "name": "tandem-editor",
+  "owner": {
+    "name": "Tandem"
+  },
+  "metadata": {
+    "description": "Tandem — collaborative AI-human document editor"
+  },
+  "plugins": [
+    {
+      "name": "tandem",
+      "source": {
+        "source": "github",
+        "repo": "bloknayrb/tandem"
+      },
+      "description": "Edit and iterate on documents with Claude — no copy-paste, real-time push via plugin monitor"
+    }
+  ]
+}

package/.claude-plugin/plugin.json ADDED Viewed

@@ -0,0 +1,27 @@
+{
+  "name": "tandem",
+  "version": "0.6.0",
+  "description": "Edit and iterate on documents with Claude — no copy-paste, real-time push via plugin monitor",
+  "author": {
+    "name": "Tandem"
+  },
+  "repository": "https://github.com/bloknayrb/tandem",
+  "license": "MIT",
+  "keywords": ["editor", "collaborative", "mcp", "claude"],
+  "mcpServers": {
+    "tandem": {
+      "command": "npx",
+      "args": ["-y", "tandem-editor", "mcp-stdio"],
+      "env": {
+        "TANDEM_URL": "http://localhost:3479"
+      }
+    },
+    "tandem-channel": {
+      "command": "npx",
+      "args": ["-y", "tandem-editor", "channel"],
+      "env": {
+        "TANDEM_URL": "http://localhost:3479"
+      }
+    }
+  }
+}

package/CHANGELOG.md CHANGED Viewed

@@ -5,6 +5,61 @@ All notable changes to Tandem will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [Unreleased]
+## [0.6.0] - 2026-04-15
+### Added
+- **Plugin bridge to Cowork** — new `tandem mcp-stdio` subcommand is a stdio ↔ HTTP JSON-RPC proxy so Claude Desktop's plugin loader surfaces the full `tandem_*` tool surface into Cowork VM sessions. Verified empirically that plugin-loaded HTTP MCP entries don't bridge to Cowork but plugin-loaded stdio entries do. The plugin's `.claude-plugin/plugin.json` now declares stdio entries for both `tandem` (proxy) and `tandem-channel` (existing shim re-exposed as `tandem channel` subcommand), invoked via `npx -y tandem-editor …` so the plugin cache never needs dev dependencies. Both subcommands share a strict preflight in `src/cli/preflight.ts` that fails fast with a single clear message when the Tandem server isn't running on `localhost:3479`.
+- `tandem channel` CLI subcommand — npm-delivered entry for the plugin's `tandem-channel` MCP server; shares runtime with the standalone `src/channel/index.ts` binary via the new `src/channel/run.ts` extraction.
+- **Settings expansion** — Settings popover grows from layout/dwell/authorship into a fuller preferences surface:
+  - Ctrl+, / Cmd+, hotkey (AZERTY/QWERTZ/IME-safe, survives non-QWERTY layouts)
+  - Display Name field, synced live with the StatusBar via a shared `useUserName` hook
+  - Reduce Motion toggle (JS-gates all autoscroll paths; defaults to `prefers-reduced-motion`)
+  - Text Size S/M/L for editor reading density (browser zoom remains the WCAG 1.4.4 path)
+  - Theme Light/Dark/System (CSS custom-property token system on `<html data-theme>` with `forced-colors` support for Windows High Contrast)
+- Tier 0 accessibility prerequisites on SettingsPopover: `role="dialog"` + `aria-modal`, focus trap, Escape-to-close, pointerdown outside-dismiss, radiogroup semantics, 24×24 hit targets, focus-return on close
+### Changed
+- Repo's project-level `.mcp.json` renamed to `.mcp.json.example` and gitignored so it no longer ships inside plugin installs. The plugin's own `.claude-plugin/plugin.json` is authoritative for MCP wiring. Developers who clone the repo should copy the example to `.mcp.json` (gitignored) if they want Claude Code to auto-connect locally.
+- Settings heading renamed "Layout Settings" → "Settings"
+- Settings popover hardcoded hex values swapped to CSS tokens (remaining components will migrate in a follow-up)
+- `shutdownForTests` renamed to `shutdownMonitor` (test-only alias kept for backward compatibility)
+- `refreshMode` IIFE now wrapped in an outer `.catch` to keep future synchronous throws off the hot path
+### Fixed
+- **Monitor preserves last-known `documentId`** — doc-less events (e.g. `chat:message`) no longer blank out the tracked document, so the shutdown awareness clear always targets a valid document.
+- **Monitor exits 1 on shutdown awareness failure** — if the final `clearAwareness` POST fails during SIGINT/SIGTERM, the monitor exits with a non-zero status rather than silently succeeding.
+- **`/api/setup` returns accurate status codes** — 207 on partial failure (some targets configured, some failed) and 500 on total failure, instead of always returning 200.
+- **Checkpoint after stdout write** — `lastEventId` is only advanced after `process.stdout.write` returns, so EPIPE on a closed pipe no longer silently skips an event on reconnect.
+- **Async EPIPE surfaces as exit(1)** — `process.stdout.on('error')` listener now catches asynchronous EPIPE (plugin host closes pipe mid-stream); monitor exits 1 instead of silently advancing `lastEventId` past lost events.
+- **Defensive exit on monitor fallthrough** — the retry loop exits 1 if it ever terminates without hitting the explicit exhaustion path.
+## [0.5.1] - 2026-04-13
+### Added
+- **Claude Code plugin support** — monitor-based event push (`src/monitor/index.ts`) gives real-time notifications without polling or the channel shim. Install via `claude plugin marketplace add bloknayrb/tandem`.
+- **`--with-channel-shim` opt-in** — `tandem setup --with-channel-shim` writes the legacy `tandem-channel` MCP entry for setups that can't install the plugin.
+### Changed
+- `tandem setup` no longer writes the `tandem-channel` MCP entry by default — running the plugin and the shim simultaneously produces duplicate event notifications. The shim is now opt-in only via `--with-channel-shim`.
+### Fixed
+- **Windows update failure** — sidecar is now killed before the NSIS installer runs, preventing "Error opening file for writing: node-sidecar.exe" during updates
+- **Mode check fails closed** — `/api/mode` errors now fall back to "solo" at startup (privacy signal, not a permissive default) while the hot-path background refresh keeps the last known good value to avoid mid-session suppression.
+- **Retry counter resets on stable uptime** — retry count now resets only after 60s of continuous uptime, not on every delivered event; prevents infinite reconnect loops when the server crashes after each event.
+- **Exponential backoff on reconnect** — monitor reconnects use 2s/4s/8s/16s/30s backoff instead of a fixed 2s delay.
+- **SIGINT/SIGTERM clears awareness** — monitor posts a final `clearAwareness` before exit so the "Claude is active" indicator doesn't hang in the browser.
+- **Per-route fetch timeouts** — `AbortSignal.timeout` enforces budgets per route (connect 10s, mode 2s, awareness 5s, error report 3s) to prevent hung SSE connects or mode lookups from stalling the monitor.
+- **SSE parse errors don't advance `lastEventId`** — JSON parse failures and schema validation errors are logged with event ID + frame tail but do not advance `lastEventId`, so bad events are re-delivered on reconnect rather than silently dropped.
+- **SKILL.md corrected** — `question` annotation guidance now uses `type === 'comment' && directedAt === 'claude' && author === 'user'`; all 5 highlight colors listed (yellow, red, green, blue, purple).
 ## [0.5.0] - 2026-04-13
 ### Added

package/README.md CHANGED Viewed

@@ -34,6 +34,33 @@ tandem           # starts server + opens browser
 `tandem setup` auto-detects Claude Code and Claude Desktop, writes MCP configuration, and installs a skill (`~/.claude/skills/tandem/SKILL.md`) that teaches Claude how to use Tandem's tools effectively. Re-run after upgrading (`npm update -g tandem-editor && tandem setup`).
+### Quickstart: Claude Code plugin (recommended)
+Install the plugin to expose Tandem's tools and real-time event stream into Claude Desktop chats **and** Cowork VM sessions:
+```bash
+claude plugin marketplace add bloknayrb/tandem
+claude plugin install tandem@tandem-editor
+```
+**Tandem must be running on the host before the plugin can do anything.** The plugin spawns two stdio MCP processes (`tandem mcp-stdio` and `tandem channel`) that proxy to `http://localhost:3479`. If the server isn't up they fail fast and log "Tandem server not reachable at …". Start the Tauri desktop app or run `tandem start` on the host first, then open Claude.
+### Legacy stdio channel shim
+If you can't install the plugin, use the older channel shim:
+```bash
+tandem setup --with-channel-shim
+```
+This writes a `tandem-channel` entry to your Claude Code MCP config. Start Claude Code with:
+```bash
+claude --dangerously-load-development-channels server:tandem-channel
+```
+Don't combine this with the plugin — both subscribe to `/api/events` and you'll get duplicate notifications for every event.
 ### Connect Claude Code
 For the full Tandem experience, start Claude Code with the **channel push** flag:

package/dist/channel/index.js CHANGED Viewed

@@ -6799,7 +6799,7 @@ var require_dist = __commonJS({
   }
 });
-// src/channel/index.ts
+// src/channel/run.ts
 import { createConnection } from "net";
 // node_modules/zod/v3/external.js
@@ -17915,6 +17915,17 @@ var SESSION_MAX_AGE = 30 * 24 * 60 * 60 * 1e3;
 var CHANNEL_MAX_RETRIES = 5;
 var CHANNEL_RETRY_DELAY_MS = 2e3;
+// src/shared/cli-runtime.ts
+function redirectConsoleToStderr() {
+  console.log = console.error;
+  console.warn = console.error;
+  console.info = console.error;
+}
+function resolveTandemUrl(override) {
+  const raw = override ?? process.env.TANDEM_URL ?? `http://localhost:${DEFAULT_MCP_PORT}`;
+  return raw.replace(/\/$/, "");
+}
 // src/server/events/types.ts
 var VALID_EVENT_TYPES = /* @__PURE__ */ new Set([
   "annotation:created",
@@ -18013,12 +18024,12 @@ function formatEventMeta(event) {
 // src/channel/event-bridge.ts
 var AWARENESS_DEBOUNCE_MS = 500;
 var MODE_CACHE_TTL_MS = 2e3;
-async function startEventBridge(mcp2, tandemUrl) {
+async function startEventBridge(mcp, tandemUrl) {
   let retries = 0;
   let lastEventId;
   while (retries < CHANNEL_MAX_RETRIES) {
     try {
-      await connectAndStream(mcp2, tandemUrl, lastEventId, (id) => {
+      await connectAndStream(mcp, tandemUrl, lastEventId, (id) => {
         lastEventId = id;
         retries = 0;
       });
@@ -18051,7 +18062,7 @@ async function startEventBridge(mcp2, tandemUrl) {
     }
   }
 }
-async function connectAndStream(mcp2, tandemUrl, lastEventId, onEventId) {
+async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
   const headers = { Accept: "text/event-stream" };
   if (lastEventId) headers["Last-Event-ID"] = lastEventId;
   const res = await fetch(`${tandemUrl}/api/events`, { headers });
@@ -18136,7 +18147,7 @@ async function connectAndStream(mcp2, tandemUrl, lastEventId, onEventId) {
       }
       if (eventId) onEventId(eventId);
       try {
-        await mcp2.notification({
+        await mcp.notification({
           method: "notifications/claude/channel",
           params: {
             content: formatEventContent(event),
@@ -18175,11 +18186,143 @@ async function getCachedMode(tandemUrl) {
   return cachedMode;
 }
-// src/channel/index.ts
-console.log = console.error;
-console.warn = console.error;
-console.info = console.error;
-var TANDEM_URL = process.env.TANDEM_URL || "http://localhost:3479";
+// src/channel/run.ts
+async function runChannel(opts = {}) {
+  redirectConsoleToStderr();
+  const tandemUrl = resolveTandemUrl();
+  const mcp = new Server(
+    { name: "tandem-channel", version: "0.1.0" },
+    {
+      capabilities: {
+        experimental: {
+          "claude/channel": {},
+          "claude/channel/permission": {}
+        },
+        tools: {}
+      },
+      instructions: [
+        'Events from Tandem arrive as <channel source="tandem-channel" event_type="..." document_id="...">.',
+        "These are real-time push notifications of user actions in the collaborative document editor.",
+        "Event types: annotation:created, annotation:accepted, annotation:dismissed, annotation:reply,",
+        "chat:message, document:opened, document:closed, document:switched.",
+        "Chat messages may include a 'selection' field with buffered selection context.",
+        "Use your tandem MCP tools (tandem_getTextContent, tandem_comment, tandem_highlight, etc.) to act on them.",
+        "Reply to chat messages using tandem_reply. Pass document_id from the tag attributes.",
+        "Do not reply to non-chat events \u2014 just act on them using tools.",
+        "If you haven't received channel notifications recently, call tandem_checkInbox as a fallback."
+      ].join(" ")
+    }
+  );
+  mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "tandem_reply",
+        description: "Reply to a chat message in Tandem",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "The reply message" },
+            documentId: {
+              type: "string",
+              description: "Document ID from the channel event (optional)"
+            },
+            replyTo: {
+              type: "string",
+              description: "Message ID being replied to (optional)"
+            }
+          },
+          required: ["text"]
+        }
+      }
+    ]
+  }));
+  mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+    if (req.params.name === "tandem_reply") {
+      const args = req.params.arguments;
+      try {
+        const res = await fetch(`${tandemUrl}/api/channel-reply`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(args)
+        });
+        let data;
+        try {
+          data = await res.json();
+        } catch {
+          data = { message: "Non-JSON response" };
+        }
+        if (!res.ok) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Reply failed (${res.status}): ${JSON.stringify(data)}`
+              }
+            ],
+            isError: true
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to send reply: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    throw new Error(`Unknown tool: ${req.params.name}`);
+  });
+  const PermissionRequestSchema = external_exports.object({
+    method: external_exports.literal("notifications/claude/channel/permission_request"),
+    params: external_exports.object({
+      request_id: external_exports.string(),
+      tool_name: external_exports.string(),
+      description: external_exports.string(),
+      input_preview: external_exports.string()
+    })
+  });
+  mcp.setNotificationHandler(PermissionRequestSchema, async ({ params }) => {
+    try {
+      const res = await fetch(`${tandemUrl}/api/channel-permission`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          requestId: params.request_id,
+          toolName: params.tool_name,
+          description: params.description,
+          inputPreview: params.input_preview
+        })
+      });
+      if (!res.ok) {
+        console.error(
+          `[Channel] Permission relay got HTTP ${res.status} \u2014 browser may not see prompt`
+        );
+      }
+    } catch (err) {
+      console.error("[Channel] Failed to forward permission request:", err);
+    }
+  });
+  console.error(`[Channel] Tandem channel shim starting (server: ${tandemUrl})`);
+  if (!opts.skipReachabilityLog) {
+    const reachable = await checkServerReachable(tandemUrl);
+    if (!reachable) {
+      console.error(`[Channel] Cannot reach Tandem server at ${tandemUrl}`);
+      console.error("[Channel] Start it with: tandem start");
+    }
+  }
+  const transport = new StdioServerTransport();
+  await mcp.connect(transport);
+  console.error("[Channel] Connected to Claude Code via stdio");
+  startEventBridge(mcp, tandemUrl).catch((err) => {
+    console.error("[Channel] Event bridge failed unexpectedly:", err);
+    process.exit(1);
+  });
+}
 async function checkServerReachable(url, timeoutMs = 2e3) {
   let parsed;
   try {
@@ -18208,139 +18351,9 @@ async function checkServerReachable(url, timeoutMs = 2e3) {
     });
   });
 }
-var mcp = new Server(
-  { name: "tandem-channel", version: "0.1.0" },
-  {
-    capabilities: {
-      experimental: {
-        "claude/channel": {},
-        "claude/channel/permission": {}
-      },
-      tools: {}
-    },
-    instructions: [
-      'Events from Tandem arrive as <channel source="tandem-channel" event_type="..." document_id="...">.',
-      "These are real-time push notifications of user actions in the collaborative document editor.",
-      "Event types: annotation:created, annotation:accepted, annotation:dismissed, annotation:reply,",
-      "chat:message, document:opened, document:closed, document:switched.",
-      "Chat messages may include a 'selection' field with buffered selection context.",
-      "Use your tandem MCP tools (tandem_getTextContent, tandem_comment, tandem_highlight, etc.) to act on them.",
-      "Reply to chat messages using tandem_reply. Pass document_id from the tag attributes.",
-      "Do not reply to non-chat events \u2014 just act on them using tools.",
-      "If you haven't received channel notifications recently, call tandem_checkInbox as a fallback."
-    ].join(" ")
-  }
-);
-mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: "tandem_reply",
-      description: "Reply to a chat message in Tandem",
-      inputSchema: {
-        type: "object",
-        properties: {
-          text: { type: "string", description: "The reply message" },
-          documentId: {
-            type: "string",
-            description: "Document ID from the channel event (optional)"
-          },
-          replyTo: {
-            type: "string",
-            description: "Message ID being replied to (optional)"
-          }
-        },
-        required: ["text"]
-      }
-    }
-  ]
-}));
-mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
-  if (req.params.name === "tandem_reply") {
-    const args = req.params.arguments;
-    try {
-      const res = await fetch(`${TANDEM_URL}/api/channel-reply`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(args)
-      });
-      let data;
-      try {
-        data = await res.json();
-      } catch {
-        data = { message: "Non-JSON response" };
-      }
-      if (!res.ok) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Reply failed (${res.status}): ${JSON.stringify(data)}`
-            }
-          ],
-          isError: true
-        };
-      }
-      return { content: [{ type: "text", text: JSON.stringify(data) }] };
-    } catch (err) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Failed to send reply: ${err instanceof Error ? err.message : String(err)}`
-          }
-        ],
-        isError: true
-      };
-    }
-  }
-  throw new Error(`Unknown tool: ${req.params.name}`);
-});
-var PermissionRequestSchema = external_exports.object({
-  method: external_exports.literal("notifications/claude/channel/permission_request"),
-  params: external_exports.object({
-    request_id: external_exports.string(),
-    tool_name: external_exports.string(),
-    description: external_exports.string(),
-    input_preview: external_exports.string()
-  })
-});
-mcp.setNotificationHandler(PermissionRequestSchema, async ({ params }) => {
-  try {
-    const res = await fetch(`${TANDEM_URL}/api/channel-permission`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        requestId: params.request_id,
-        toolName: params.tool_name,
-        description: params.description,
-        inputPreview: params.input_preview
-      })
-    });
-    if (!res.ok) {
-      console.error(
-        `[Channel] Permission relay got HTTP ${res.status} \u2014 browser may not see prompt`
-      );
-    }
-  } catch (err) {
-    console.error("[Channel] Failed to forward permission request:", err);
-  }
-});
-async function main() {
-  console.error(`[Channel] Tandem channel shim starting (server: ${TANDEM_URL})`);
-  const reachable = await checkServerReachable(TANDEM_URL);
-  if (!reachable) {
-    console.error(`[Channel] Cannot reach Tandem server at ${TANDEM_URL}`);
-    console.error("[Channel] Start it with: npm run dev:standalone");
-  }
-  const transport = new StdioServerTransport();
-  await mcp.connect(transport);
-  console.error("[Channel] Connected to Claude Code via stdio");
-  startEventBridge(mcp, TANDEM_URL).catch((err) => {
-    console.error("[Channel] Event bridge failed unexpectedly:", err);
-    process.exit(1);
-  });
-}
-main().catch((err) => {
+// src/channel/index.ts
+runChannel().catch((err) => {
   console.error("[Channel] Fatal error:", err);
   process.exit(1);
 });