claude-watch-relay 0.1.0

package/README.md

@@ -0,0 +1,62 @@
+# claude-watch-relay
+
+Mac relay server for **Claude Watch Remote** — bridges Claude Code CLI prompts to your iPhone and Apple Watch via WebSocket.
+
+## How it works
+
+```
+Claude Code (PTY) ←→ claude-watch-relay (WebSocket + Bonjour) ←→ iPhone ←→ Apple Watch
+```
+
+The relay wraps `claude` in a PTY, detects interactive prompts (permissions, file access, y/n), and broadcasts them over WebSocket to the Claude Watch Remote iOS app.
+
+## Install
+
+```bash
+npm install -g claude-watch-relay
+```
+
+> Requires macOS and Node.js 18+. Xcode Command Line Tools needed for native module build (`xcode-select --install`).
+
+## Usage
+
+```bash
+# Instead of running `claude` directly:
+claude-watch-relay
+
+# Pass arguments to Claude Code:
+claude-watch-relay --help
+claude-watch-relay "fix the bug in auth.ts"
+```
+
+On startup, the relay prints a **6-digit pairing code**. Enter this code in the Claude Watch Remote iPhone app to pair.
+
+## Configuration
+
+| Environment Variable | Default | Description |
+|---------------------|---------|-------------|
+| `RELAY_PORT` | `19876` | WebSocket server port |
+
+## How the iPhone/Watch finds your Mac
+
+The relay advertises itself via **Bonjour** (mDNS) as `_claude-watch._tcp`. The iPhone app auto-discovers Macs on the local network — no manual IP entry needed.
+
+## Protocol
+
+WebSocket JSON messages:
+
+| Direction | Type | Fields |
+|-----------|------|--------|
+| Client → Relay | `pair` | `code` |
+| Relay → Client | `pair_result` | `success`, `message` |
+| Relay → Client | `prompt` | `prompt: { id, type, text, detail, options, timestamp }` |
+| Client → Relay | `response` | `promptId`, `answer` |
+| Client → Relay | `voice_command` | `text` |
+| Relay → Client | `voice_ack` | `text`, `timestamp` |
+| Relay → Client | `prompt_resolved` | `promptId`, `answer` |
+| Relay → Client | `terminal_output` | `data` |
+| Relay → Client | `terminal_exit` | `exitCode` |
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "claude-watch-relay",
+  "version": "0.1.0",
+  "description": "Mac relay server for Claude Watch Remote — bridges Claude Code CLI prompts to iPhone/Apple Watch",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "claude-watch-relay": "src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node test/test-detector.mjs && node test/test-websocket.mjs",
+    "postinstall": "npx node-gyp rebuild --directory=node_modules/node-pty 2>/dev/null || true"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "apple-watch",
+    "relay",
+    "remote",
+    "pty",
+    "websocket",
+    "bonjour"
+  ],
+  "author": "",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "homepage": "",
+  "os": ["darwin"],
+  "dependencies": {
+    "node-pty": "^1.0.0",
+    "ws": "^8.16.0",
+    "bonjour-service": "^1.2.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}

package/src/index.js

@@ -0,0 +1,468 @@
+#!/usr/bin/env node
+
+import { spawn } from "node-pty";
+import { WebSocketServer } from "ws";
+import { Bonjour } from "bonjour-service";
+import { randomBytes } from "crypto";
+import { execSync } from "child_process";
+
+// ─── Prompt Detector ───────────────────────────────────────────
+
+class PromptDetector {
+  constructor() {
+    // Patterns that Claude Code uses for interactive prompts
+    this.patterns = [
+      // Yes/No permission prompts
+      {
+        type: "permission",
+        regex:
+          /Do you want to (proceed|continue|allow|accept|run|execute|install)\?/i,
+        options: ["Yes", "No"],
+      },
+      // File access prompts
+      {
+        type: "file_access",
+        regex: /Allow (?:read|write|access) to (.+)\?/i,
+        options: ["Allow", "Deny"],
+      },
+      // Tool use approval
+      {
+        type: "tool_approval",
+        regex:
+          /(?:May I|Can I|Allow me to|I'd like to) (?:run|execute|use|call) (.+?)[\?\n]/i,
+        options: ["Yes", "No"],
+      },
+      // Generic yes/no
+      {
+        type: "yes_no",
+        regex: /\(y\/n\)/i,
+        options: ["y", "n"],
+      },
+      // Bash tool approval (Claude Code specific)
+      {
+        type: "bash_approval",
+        regex: /❯ (.+)\n.*(?:Allow|Run|Execute)\?/s,
+        options: ["Allow", "Deny"],
+      },
+      // Edit file approval
+      {
+        type: "edit_approval",
+        regex: /(?:Edit|Write|Create) (?:file )?(.+?)[\?\n]/i,
+        options: ["Allow", "Deny"],
+      },
+    ];
+
+    this.buffer = "";
+    this.bufferTimeout = null;
+  }
+
+  /**
+   * Feed terminal output and detect prompts.
+   * Returns detected prompt or null.
+   */
+  feed(data) {
+    // Accumulate output in a rolling buffer
+    this.buffer += data;
+
+    // Keep buffer manageable (last 4KB)
+    if (this.buffer.length > 4096) {
+      this.buffer = this.buffer.slice(-4096);
+    }
+
+    // Strip ANSI escape codes for matching
+    const clean = this.stripAnsi(this.buffer);
+
+    for (const pattern of this.patterns) {
+      const match = clean.match(pattern.regex);
+      if (match) {
+        const prompt = {
+          id: randomBytes(8).toString("hex"),
+          type: pattern.type,
+          text: match[0].trim(),
+          detail: match[1] || null,
+          options: pattern.options,
+          timestamp: Date.now(),
+        };
+        // Clear the buffer after detection to avoid re-triggering
+        this.buffer = "";
+        return prompt;
+      }
+    }
+
+    return null;
+  }
+
+  stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "");
+  }
+}
+
+// ─── Terminal Manager ──────────────────────────────────────────
+
+class TerminalManager {
+  constructor(onData, onExit) {
+    this.pty = null;
+    this.onData = onData;
+    this.onExit = onExit;
+  }
+
+  /**
+   * Spawn Claude Code in a PTY.
+   * Passes through all args after the relay command.
+   */
+  start(args = []) {
+    // Resolve claude command — it may be an alias, npx, or a real binary
+    let claudeCmd;
+    let claudeArgs;
+
+    try {
+      // Check for a real binary first
+      const realPath = execSync("command -v claude 2>/dev/null || true", {
+        encoding: "utf8",
+        shell: "/bin/zsh",
+      }).trim();
+
+      if (realPath && !realPath.includes("alias") && !realPath.includes("not found")) {
+        claudeCmd = realPath;
+        claudeArgs = args;
+      } else {
+        throw new Error("not a binary");
+      }
+    } catch {
+      // Fall back: launch via npx
+      const npxPath = execSync("which npx", {
+        encoding: "utf8",
+        shell: "/bin/zsh",
+      }).trim();
+
+      if (!npxPath) {
+        console.error(
+          "[relay] Error: Neither 'claude' nor 'npx' found in PATH.\n" +
+            "  Install Claude Code CLI: npm install -g @anthropic-ai/claude-code"
+        );
+        process.exit(1);
+      }
+
+      claudeCmd = npxPath;
+      claudeArgs = ["@anthropic-ai/claude-code", ...args];
+    }
+
+    console.log(`[relay] Spawning: ${claudeCmd} ${claudeArgs.join(" ")}`);
+
+    this.pty = spawn(claudeCmd, claudeArgs, {
+      name: "xterm-256color",
+      cols: process.stdout.columns || 120,
+      rows: process.stdout.rows || 40,
+      cwd: process.cwd(),
+      env: { ...process.env, TERM: "xterm-256color" },
+    });
+
+    this.pty.onData((data) => {
+      // Pass through to local terminal
+      process.stdout.write(data);
+      // Notify callback for prompt detection
+      this.onData(data);
+    });
+
+    this.pty.onExit(({ exitCode }) => {
+      console.log(`\n[relay] Claude Code exited with code ${exitCode}`);
+      this.onExit(exitCode);
+    });
+
+    // Handle terminal resize
+    process.stdout.on("resize", () => {
+      if (this.pty) {
+        this.pty.resize(
+          process.stdout.columns || 120,
+          process.stdout.rows || 40
+        );
+      }
+    });
+
+    // Forward local stdin to PTY
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.on("data", (data) => {
+      if (this.pty) {
+        this.pty.write(data.toString());
+      }
+    });
+  }
+
+  /**
+   * Send a response string to the PTY (simulates user input).
+   */
+  sendResponse(text) {
+    if (this.pty) {
+      this.pty.write(text);
+    }
+  }
+
+  kill() {
+    if (this.pty) {
+      this.pty.kill();
+    }
+  }
+}
+
+// ─── Relay Server (WebSocket + Bonjour) ────────────────────────
+
+class RelayServer {
+  constructor() {
+    this.wss = null;
+    this.bonjour = null;
+    this.clients = new Map(); // ws -> { authenticated, pairCode }
+    this.pairCode = this.generatePairCode();
+    this.detector = new PromptDetector();
+    this.terminal = null;
+    this.pendingPrompts = new Map(); // promptId -> prompt
+  }
+
+  generatePairCode() {
+    return Math.floor(100000 + Math.random() * 900000).toString();
+  }
+
+  start() {
+    const port = parseInt(process.env.RELAY_PORT || "19876", 10);
+
+    // Start WebSocket server
+    this.wss = new WebSocketServer({ port });
+    console.log(`[relay] WebSocket server listening on port ${port}`);
+    console.log(`[relay] Pairing code: ${this.pairCode}`);
+
+    this.wss.on("connection", (ws) => {
+      console.log("[relay] New client connected");
+      this.clients.set(ws, { authenticated: false });
+
+      ws.on("message", (raw) => {
+        this.handleMessage(ws, raw);
+      });
+
+      ws.on("close", () => {
+        console.log("[relay] Client disconnected");
+        this.clients.delete(ws);
+      });
+
+      ws.on("error", (err) => {
+        console.error("[relay] WebSocket error:", err.message);
+        this.clients.delete(ws);
+      });
+    });
+
+    // Advertise via Bonjour/mDNS
+    this.bonjour = new Bonjour();
+    this.bonjour.publish({
+      name: "Claude Watch Relay",
+      type: "claude-watch",
+      protocol: "tcp",
+      port,
+      txt: {
+        version: "1",
+      },
+    });
+    console.log("[relay] Bonjour service published: _claude-watch._tcp");
+
+    // Start Claude Code in PTY
+    const claudeArgs = process.argv.slice(2);
+    this.terminal = new TerminalManager(
+      (data) => this.onTerminalData(data),
+      (code) => this.onTerminalExit(code)
+    );
+    this.terminal.start(claudeArgs);
+  }
+
+  handleMessage(ws, raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      ws.send(JSON.stringify({ type: "error", message: "Invalid JSON" }));
+      return;
+    }
+
+    const client = this.clients.get(ws);
+
+    switch (msg.type) {
+      case "pair": {
+        if (msg.code === this.pairCode) {
+          client.authenticated = true;
+          ws.send(
+            JSON.stringify({
+              type: "pair_result",
+              success: true,
+              message: "Paired successfully",
+            })
+          );
+          console.log("[relay] Client authenticated");
+          // Send any pending prompts
+          for (const prompt of this.pendingPrompts.values()) {
+            ws.send(JSON.stringify({ type: "prompt", prompt }));
+          }
+        } else {
+          ws.send(
+            JSON.stringify({
+              type: "pair_result",
+              success: false,
+              message: "Invalid pairing code",
+            })
+          );
+        }
+        break;
+      }
+
+      case "response": {
+        if (!client.authenticated) {
+          ws.send(
+            JSON.stringify({ type: "error", message: "Not authenticated" })
+          );
+          return;
+        }
+        this.handlePromptResponse(msg);
+        break;
+      }
+
+      case "voice_command": {
+        if (!client.authenticated) {
+          ws.send(
+            JSON.stringify({ type: "error", message: "Not authenticated" })
+          );
+          return;
+        }
+        this.handleVoiceCommand(msg);
+        break;
+      }
+
+      case "ping": {
+        ws.send(JSON.stringify({ type: "pong" }));
+        break;
+      }
+
+      default:
+        ws.send(
+          JSON.stringify({ type: "error", message: `Unknown type: ${msg.type}` })
+        );
+    }
+  }
+
+  handlePromptResponse(msg) {
+    const { promptId, answer } = msg;
+    const prompt = this.pendingPrompts.get(promptId);
+    if (!prompt) {
+      console.log(`[relay] Unknown prompt ID: ${promptId}`);
+      return;
+    }
+
+    console.log(`[relay] Response for prompt ${promptId}: ${answer}`);
+    this.pendingPrompts.delete(promptId);
+
+    // Send the answer to Claude Code's PTY
+    // Map the answer to actual keystrokes
+    const keystroke = this.mapAnswerToKeystroke(prompt, answer);
+    this.terminal.sendResponse(keystroke);
+
+    // Notify all authenticated clients that the prompt was answered
+    this.broadcast({
+      type: "prompt_resolved",
+      promptId,
+      answer,
+    });
+  }
+
+  mapAnswerToKeystroke(prompt, answer) {
+    const lower = answer.toLowerCase();
+
+    if (prompt.type === "yes_no") {
+      return lower.startsWith("y") ? "y" : "n";
+    }
+
+    // For most Claude Code prompts, "y" + Enter or "n" + Enter
+    if (lower === "yes" || lower === "allow" || lower === "y") {
+      return "y\n";
+    }
+    if (lower === "no" || lower === "deny" || lower === "n") {
+      return "n\n";
+    }
+
+    // For free-form input, send as-is with Enter
+    return answer + "\n";
+  }
+
+  handleVoiceCommand(msg) {
+    const { text } = msg;
+    console.log(`[relay] Voice command: ${text}`);
+
+    // Send voice text directly to Claude Code's PTY as user input
+    this.terminal.sendResponse(text + "\n");
+
+    this.broadcast({
+      type: "voice_ack",
+      text,
+      timestamp: Date.now(),
+    });
+  }
+
+  onTerminalData(data) {
+    const prompt = this.detector.feed(data);
+    if (prompt) {
+      console.log(`[relay] Detected prompt: ${prompt.type} — ${prompt.text}`);
+      this.pendingPrompts.set(prompt.id, prompt);
+
+      // Send to all authenticated clients
+      this.broadcast({ type: "prompt", prompt });
+    }
+
+    // Also send raw terminal output to clients for live view (optional)
+    this.broadcast({
+      type: "terminal_output",
+      data: data.toString(),
+    });
+  }
+
+  onTerminalExit(code) {
+    this.broadcast({
+      type: "terminal_exit",
+      exitCode: code,
+    });
+
+    // Graceful shutdown
+    setTimeout(() => {
+      this.shutdown();
+      process.exit(code);
+    }, 1000);
+  }
+
+  broadcast(msg) {
+    const json = JSON.stringify(msg);
+    for (const [ws, client] of this.clients) {
+      if (client.authenticated && ws.readyState === 1) {
+        ws.send(json);
+      }
+    }
+  }
+
+  shutdown() {
+    console.log("[relay] Shutting down...");
+    if (this.terminal) this.terminal.kill();
+    if (this.bonjour) this.bonjour.destroy();
+    if (this.wss) this.wss.close();
+  }
+}
+
+// ─── Main ──────────────────────────────────────────────────────
+
+const relay = new RelayServer();
+
+process.on("SIGINT", () => {
+  relay.shutdown();
+  process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+  relay.shutdown();
+  process.exit(0);
+});
+
+relay.start();