patchcord 0.5.95 → 0.5.96

package/bin/patchcord.mjs

@@ -1818,6 +1818,24 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     if (ocOk) {
       console.log(`\n  ${green}✓${r} OpenCode configured: ${dim}${ocPath}${r}`);
     }
+    // Slash commands → .opencode/commands/
+    try {
+      const ocCmdDir = join(cwd, ".opencode", "commands");
+      mkdirSync(ocCmdDir, { recursive: true });
+      for (const f of ["patchcord-inbox.md", "patchcord-wait.md"]) {
+        cpSync(join(pluginRoot, "commands", "opencode", f), join(ocCmdDir, f));
+      }
+      console.log(`  ${green}✓${r} Commands installed: ${dim}/patchcord-inbox${r}, ${dim}/patchcord-wait${r}`);
+    } catch {}
+    // Realtime-wake plugin → .opencode/plugins/ (spawns `patchcord subscribe`
+    // and injects a prompt via client.session.prompt on each new message).
+    try {
+      const ocPluginDir = join(cwd, ".opencode", "plugins");
+      mkdirSync(ocPluginDir, { recursive: true });
+      cpSync(join(pluginRoot, "plugins", "opencode", "patchcord.js"), join(ocPluginDir, "patchcord.js"));
+      console.log(`  ${green}✓${r} Realtime-wake plugin installed: ${dim}.opencode/plugins/patchcord.js${r}`);
+      console.log(`  ${dim}New Patchcord messages will wake the agent automatically.${r}`);
+    } catch {}
   } else if (isOpenClaw) {
     // OpenClaw: global ~/.openclaw/openclaw.json → mcp.servers
     // Try CLI first, fall back to direct file write

package/commands/opencode/patchcord-inbox.md

@@ -0,0 +1,11 @@
+---
+description: Check the Patchcord inbox and reply to messages from other agents
+---
+Call the patchcord inbox tool. The first header line is YOUR identity (the recipient); each message's real sender is on its "From X" line — never confuse the header with the sender.
+
+For each pending message, classify and act:
+- ACK ("thanks", "noted", "ok", "works", "👍") → reply(message_id, resolve=true) with NO content. Never reply to an ack with text.
+- BLOCKED (can't act right now) → reply(message_id, "<reason>", defer=true).
+- ACTIONABLE → do the work first, THEN reply(message_id, "<concrete summary with file paths/results>").
+
+Do the work before replying; never reply with a bare acknowledgement. Then tell me who wrote, what they asked, and what you did.

package/commands/opencode/patchcord-wait.md

@@ -0,0 +1,8 @@
+---
+description: Block and wait for one incoming Patchcord message (up to ~5 minutes)
+---
+Call the patchcord wait_for_message tool — it blocks until a message arrives or ~5 minutes elapse.
+
+If a message arrives, handle it the same way as /patchcord-inbox: ACK → reply(message_id, resolve=true) with no content; BLOCKED → reply(message_id, "<reason>", defer=true); ACTIONABLE → do the work first, then reply(message_id, "<concrete summary>").
+
+If it times out with nothing, tell me nothing arrived.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.5.95",
+  "version": "0.5.96",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
   "author": "ppravdin",
   "license": "MIT",
@@ -28,6 +28,7 @@
     "skills/",
     "per-project-skills/",
     "commands/",
-    "README.md"
+    "README.md",
+    "plugins/"
   ]
 }

package/plugins/opencode/patchcord.js

@@ -0,0 +1,88 @@
+// Patchcord realtime-wake plugin for OpenCode.
+//
+// Spawns `patchcord subscribe` — the self-reconnecting Supabase realtime
+// listener (shared with every other client) — and, on each incoming message,
+// injects a prompt into the active session via client.session.prompt(). The
+// agent wakes and checks its inbox. Real-time push, no re-arm.
+//
+// We prompt on the realtime event (not on session.idle) on purpose: re-prompting
+// from session.idle has a documented teardown race in headless `opencode run`
+// mode. Injecting on message arrival sidesteps it.
+import { spawn } from "node:child_process";
+
+export const PatchcordPlugin = async ({ client, directory }) => {
+  let sessionId = null;
+  let proc = null;
+
+  const wake = (from) => {
+    if (!sessionId) return; // no session to inject into yet; the listener's
+    // 60s pending-heartbeat re-emits, so nothing is lost.
+    client.session
+      .prompt({
+        path: { id: sessionId },
+        body: {
+          parts: [
+            {
+              type: "text",
+              text:
+                `You have a new Patchcord message from ${from}. Call the patchcord ` +
+                `inbox tool now and handle each pending message: an ACK ("thanks", ` +
+                `"ok", "noted", "works") -> reply(message_id, resolve=true) with NO ` +
+                `content; BLOCKED (can't act now) -> reply(message_id, "reason", ` +
+                `defer=true); ACTIONABLE -> do the work first, then ` +
+                `reply(message_id, "concrete summary"). Then tell me who wrote and ` +
+                `what you did.`,
+            },
+          ],
+        },
+      })
+      .catch(() => {});
+  };
+
+  const start = () => {
+    if (proc) return;
+    try {
+      proc = spawn("patchcord", ["subscribe"], {
+        cwd: directory,
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+    } catch {
+      proc = null;
+      return;
+    }
+    let buf = "";
+    proc.stdout.on("data", (chunk) => {
+      buf += chunk.toString();
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        if (line.startsWith("PATCHCORD:")) {
+          const m = line.match(/from (\S+)/);
+          wake(m ? m[1] : "another agent");
+        }
+      }
+    });
+    proc.on("error", () => {
+      proc = null;
+    });
+    proc.on("exit", () => {
+      proc = null;
+    });
+  };
+
+  // Start the listener as soon as the plugin loads.
+  start();
+
+  return {
+    event: async ({ event }) => {
+      const sid =
+        event?.session_id ||
+        event?.sessionID ||
+        event?.properties?.sessionID ||
+        event?.properties?.session_id ||
+        event?.properties?.info?.id;
+      if (sid) sessionId = sid;
+    },
+  };
+};