relay-companion 0.1.0

package/overlay/preload.cjs

@@ -0,0 +1,37 @@
+const { contextBridge, ipcRenderer } = require("electron");
+
+contextBridge.exposeInMainWorld("relay", {
+  // streams from main -> renderer
+  onInbox: (cb) => ipcRenderer.on("inbox", (_e, payload) => cb(payload)),
+  onNewRelay: (cb) => ipcRenderer.on("newRelay", (_e, relay) => cb(relay)),
+  onOpenDone: (cb) => ipcRenderer.on("openDone", (_e, id) => cb(id)),
+
+  // pull the full payload on demand
+  refresh: () => ipcRenderer.invoke("relay:get"),
+
+  // Relay rows
+  open: (id) => ipcRenderer.send("relay:open", id),
+  ack: (id) => ipcRenderer.send("relay:ack", id),
+  openUrl: (url) => ipcRenderer.send("relay:openUrl", url),
+
+  // task mutations (return { ok, error?, conflict? })
+  accept: (taskId, participantId) => ipcRenderer.invoke("relay:accept", taskId, participantId),
+  reject: (taskId, participantId) => ipcRenderer.invoke("relay:reject", taskId, participantId),
+  approve: (taskId, approvalId) => ipcRenderer.invoke("relay:approve", taskId, approvalId),
+  decline: (taskId, approvalId) => ipcRenderer.invoke("relay:decline", taskId, approvalId),
+  answer: (taskId, messageId, text) => ipcRenderer.invoke("relay:answer", taskId, messageId, text),
+
+  // tasks view
+  refreshTasks: () => ipcRenderer.invoke("relay:refreshTasks"),
+  openTask: (taskId) => ipcRenderer.send("relay:openTask", taskId),
+
+  // contacts
+  contacts: () => ipcRenderer.invoke("relay:contacts"),
+  contactSave: (input) => ipcRenderer.invoke("relay:contactSave", input),
+
+  // window plumbing
+  setFocusable: (v) => ipcRenderer.send("relay:setFocusable", v),
+  interactive: (v) => ipcRenderer.send("relay:interactive", v),
+  setPos: (x, y) => ipcRenderer.send("relay:setPos", x, y),
+  soundBytes: (name) => ipcRenderer.invoke("relay:soundBytes", name),
+});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "relay-companion",
+  "version": "0.1.0",
+  "description": "Relay companion: connects local coding agents to Relay tasks, approvals, and connector tools.",
+  "type": "module",
+  "bin": {
+    "relay": "bin/relay.js"
+  },
+  "main": "bin/relay.js",
+  "scripts": {
+    "mcp": "node src/mcp.js",
+    "daemon": "node src/task-daemon.js",
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.195",
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "electron": "^32.0.0"
+  },
+  "files": [
+    "bin",
+    "src",
+    "overlay"
+  ]
+}

package/src/claude-materializer.js

@@ -0,0 +1,85 @@
+// Claude materializer. Ported faithfully from
+// granular/tools/relay-companion/src/claude-materializer.js. Writes the Claude
+// Code / Cowork fallback markdown artifact and (for Claude Code targets) forges
+// the native Claude Desktop session via writeClaudeNativeSession.
+//
+// Adaptations (input side only): the input is a cloud companion row, not a
+// granular packet. Title/body come from ./relay-briefing.js. For the open path
+// the overlay always passes --host claude, so forceClaudeCode is set by openRelay.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { renderRelayRowBriefing, renderRelayRowSeed } from "./relay-briefing.js";
+import { writeClaudeNativeSession } from "./claude-session-writer.js";
+import { claudeDesktopConfigPath, storeDir } from "./host-paths.js";
+
+export function materializeRowForClaude(row, { cwd = process.cwd(), forceClaudeCode = false } = {}) {
+  const body = renderClaudeHandoffMarkdown(row);
+  const fileName = `${safeFileStem(row.createdAt)}-${safeFileStem(row.id)}.md`;
+  const wantsClaudeCode = forceClaudeCode || rowTargetsSurface(row, "claude_code");
+  const wantsCowork = rowTargetsSurface(row, "claude_cowork");
+  const targets = [];
+  if (wantsClaudeCode) targets.push(path.join(storeDir(), "claude-inbox"));
+  if (wantsCowork) targets.push(coworkRelayInboxDir());
+  const paths = [];
+  for (const target of targets) {
+    fs.mkdirSync(target, { recursive: true });
+    const filePath = path.join(target, fileName);
+    fs.writeFileSync(filePath, body);
+    paths.push(filePath);
+  }
+  const nativeSession =
+    wantsClaudeCode && shouldMaterializeClaudeNative()
+      ? writeClaudeNativeSession({ row, cwd, seed: renderRelayRowSeed(row) })
+      : null;
+  return {
+    paths,
+    nativeSession,
+    surfaces: {
+      claudeCode: wantsClaudeCode,
+      claudeCowork: wantsCowork,
+    },
+  };
+}
+
+export function renderClaudeHandoffMarkdown(row) {
+  return `${renderRelayRowBriefing(row)}
+
+## Claude Code / Cowork
+
+This is a fallback/debug copy of the same Relay content. For Claude Code targets, Relay also writes a native Claude Code transcript and asks Claude Desktop to import it through \`claude://resume?session=...\`. For Cowork targets, this file is the Cowork-facing inbox artifact until Claude exposes a stable native Cowork import surface.
+`;
+}
+
+export function coworkRelayInboxDir() {
+  const configPath = claudeDesktopConfigPath();
+  let userFilesPath = path.join(os.homedir(), "Claude");
+  try {
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      userFilesPath = config.coworkUserFilesPath || userFilesPath;
+    }
+  } catch {
+    // Fall back to ~/Claude; a malformed Claude config should not block Relay materialization.
+  }
+  return path.join(userFilesPath, "Relay Inbox");
+}
+
+// The cloud row carries delivery.targetSurfaces when its snapshot packet is read;
+// the staged row defaults both Codex + Claude Code. Treat a missing list as "all".
+function rowTargetsSurface(row, surface) {
+  const list = row?.delivery?.targetSurfaces || row?.targetSurfaces || null;
+  if (!Array.isArray(list) || !list.length) return true;
+  return list
+    .map((value) => String(value || "").trim().toLowerCase().replace(/[\s-]+/g, "_"))
+    .includes(surface);
+}
+
+function safeFileStem(value) {
+  return String(value || new Date().toISOString()).replace(/[^0-9A-Za-z._-]+/g, "-").replace(/^-|-$/g, "");
+}
+
+function shouldMaterializeClaudeNative() {
+  return process.env.RELAY_MATERIALIZE_CLAUDE !== "0";
+}