swarmpath-claudecode-bridge 1.0.0

package/README.md

@@ -0,0 +1,160 @@
+# SwarmPath Claude Code Bridge v2.4.1
+
+手机远程控制 Mac 本地 Claude Code — 一行命令连接，自动登录，无需手动粘贴 Token。
+
+## 快速开始
+
+```bash
+# 第一步：配置（仅首次）
+npx swarmpath-claudecode-bridge --setup
+
+# 第二步：启动（任意项目目录下）
+cd ~/my-project
+npx swarmpath-claudecode-bridge
+
+# 第三步：手机 SwarmPath Chat 输入配对码
+/connect XXXXXX
+```
+
+## 原理
+
+```
+手机 SwarmPath Chat          SwarmPath 服务器           Mac 本地
+     |                           |                       |
+     |                           |<-- WebSocket --------| bridge 启动 + 自动登录
+     |                           |--- 配对码 A3X7 ----->| 终端显示
+     |-- /connect A3X7 -------->| 配对成功                |
+     |                           |                       |
+     |-- 发送消息 ------------->|-- ws 转发 ------------>|
+     |                           |                       | claude -p "..." --resume
+     |<-- 流式回显 -------------|<-- ws 流式回传 --------|
+```
+
+## 安装 & 配置
+
+### 前置条件
+
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)（终端输入 `claude --version` 验证）
+- Node.js 18+
+- SwarmPath Chat 账号
+
+### 首次配置
+
+```bash
+npx swarmpath-claudecode-bridge --setup
+```
+
+交互式输入：
+```
+🔧 SwarmPath Claude Code Bridge — 初始配置
+
+SwarmPath 服务器地址 [wss://www.swarmpathchat.com]:
+用户名: admin
+密码: ****
+
+✅ 配置已保存到 ~/.swarmpath-bridge.json
+✅ 登录成功!
+```
+
+配置保存到 `~/.swarmpath-bridge.json`，后续启动自动读取，无需重复配置。
+
+## 使用
+
+### 启动
+
+```bash
+# 当前目录
+npx swarmpath-claudecode-bridge
+
+# 指定项目目录
+npx swarmpath-claudecode-bridge --cwd /Users/apple/my-project
+```
+
+输出：
+```
+🌐 SwarmPath Claude Code Bridge
+📁 Working directory: /Users/apple/my-project
+🔑 自动登录成功
+
+🔗 Connecting to wss://www.swarmpathchat.com ...
+✅ Connected to SwarmPath server
+
+═══════════════════════════════════════════
+   配对码 (Pairing Code):  F8USY4
+   有效期: 300 秒
+═══════════════════════════════════════════
+
+在 SwarmPath Chat 中输入: /connect F8USY4
+```
+
+### 手机端配对
+
+在 SwarmPath Chat 任意对话中输入：
+```
+/connect F8USY4
+```
+
+### 对话
+
+在 Bridge session 中直接发消息：
+- `帮我看看当前目录有什么文件`
+- `帮我写一个 hello.py`
+- `运行测试`
+- `帮我把这个项目的架构图绘制出来`
+
+### 切换模型
+
+点击 header 模型名（Sonnet/Opus/Haiku）切换 Claude Code 使用的模型。
+
+### 切换工作目录
+
+```
+/cd /Users/apple/another-project
+/cd ..
+```
+
+### 重新连接
+
+bridge 重启后，在同一个 Bridge session 中输入新配对码即可重连（不创建新 session，历史保留）：
+```
+/connect XXXXXX
+```
+
+## 参数
+
+| 参数 | 说明 |
+|------|------|
+| `--setup` | 交互式首次配置 |
+| `--cwd <path>` | 指定工作目录（默认当前目录） |
+| `--server <url>` | 覆盖服务器地址 |
+| `--token <jwt>` | 手动指定 token（跳过自动登录） |
+
+环境变量：
+```bash
+export SWARMPATH_SERVER=wss://www.swarmpathchat.com
+export SWARMPATH_TOKEN=eyJ...
+```
+
+## 特性
+
+| 特性 | 说明 |
+|------|------|
+| **自动登录** | 首次 `--setup` 后，后续启动自动用存储的凭据登录 |
+| **Token 自动续期** | 每 12 分钟自动刷新，无需手动干预 |
+| **断线重连** | WebSocket 断开后自动重连（指数退避 5s → 60s） |
+| **Token 过期自动恢复** | 4001 断开时自动重新登录并重连 |
+| **长对话上下文** | `--resume` 复用 Claude session，多轮对话保持上下文 |
+| **远程文件浏览** | 资源管理器远程浏览 Mac 文件（只读） |
+| **`/cd` 切目录** | 动态切换工作目录，无需重启 |
+
+## 安全
+
+- 凭据存储在本地 `~/.swarmpath-bridge.json`（权限 600 建议）
+- 配对码 6 位加密随机，5 分钟有效，一次性
+- 所有通信通过 WSS 加密
+- 服务器仅转发，不存储文件内容
+- 远程资源管理器只读
+
+## 退出
+
+终端按 `Ctrl+C` 优雅退出。

package/index.mjs

@@ -0,0 +1,527 @@
+#!/usr/bin/env node
+/**
+ * SwarmPath Claude Code Bridge
+ * Connect local Claude Code to SwarmPath Chat — control your Mac from your phone.
+ *
+ * Usage:
+ *   npx swarmpath-claudecode-bridge --setup                    # First-time setup
+ *   npx swarmpath-claudecode-bridge                            # Start (auto-login)
+ *   npx swarmpath-claudecode-bridge --cwd /path/to/project     # Specify working directory
+ *   npx swarmpath-claudecode-bridge --server wss://... --token <jwt>  # Manual token mode
+ */
+
+import { spawn } from 'child_process';
+import { resolve, join, extname } from 'path';
+import { readdirSync, statSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { createInterface } from 'readline';
+import WebSocket from 'ws';
+
+// ---------------------------------------------------------------------------
+// Config file
+// ---------------------------------------------------------------------------
+const CONFIG_PATH = join(homedir(), '.swarmpath-bridge.json');
+
+function loadConfig() {
+  try {
+    if (existsSync(CONFIG_PATH)) return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch {}
+  return {};
+}
+
+function saveConfig(cfg) {
+  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), 'utf-8');
+}
+
+// ---------------------------------------------------------------------------
+// Interactive setup
+// ---------------------------------------------------------------------------
+async function runSetup() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise(r => rl.question(q, r));
+
+  console.log('\n🔧 SwarmPath Claude Code Bridge — 初始配置\n');
+
+  const cfg = loadConfig();
+  const server = await ask(`SwarmPath 服务器地址 [${cfg.server || 'wss://www.swarmpathchat.com'}]: `);
+  const username = await ask(`用户名 [${cfg.username || ''}]: `);
+  const password = await ask('密码: ');
+
+  cfg.server = server.trim() || cfg.server || 'wss://www.swarmpathchat.com';
+  cfg.username = username.trim() || cfg.username || '';
+  cfg.password = password || cfg.password || '';
+
+  saveConfig(cfg);
+  console.log(`\n✅ 配置已保存到 ${CONFIG_PATH}`);
+
+  // Test login
+  try {
+    const tokens = await login(cfg.server, cfg.username, cfg.password);
+    cfg.accessToken = tokens.accessToken;
+    cfg.refreshToken = tokens.refreshToken;
+    saveConfig(cfg);
+    console.log('✅ 登录成功!\n');
+    console.log('现在可以运行:');
+    console.log('  npx swarmpath-claudecode-bridge');
+    console.log('  npx swarmpath-claudecode-bridge --cwd /path/to/project\n');
+  } catch (err) {
+    console.error(`❌ 登录失败: ${err.message}\n`);
+  }
+
+  rl.close();
+  process.exit(0);
+}
+
+// ---------------------------------------------------------------------------
+// Auth: login & refresh
+// ---------------------------------------------------------------------------
+async function login(serverWs, username, password) {
+  const httpUrl = serverWs.replace('wss://', 'https://').replace('ws://', 'http://');
+  const res = await fetch(`${httpUrl}/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ username, password }),
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.error || `HTTP ${res.status}`);
+  }
+  return res.json();
+}
+
+async function refreshToken(serverWs, rToken) {
+  const httpUrl = serverWs.replace('wss://', 'https://').replace('ws://', 'http://');
+  const res = await fetch(`${httpUrl}/auth/refresh`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ refreshToken: rToken }),
+  });
+  if (!res.ok) throw new Error('Refresh failed');
+  return res.json();
+}
+
+async function ensureToken(cfg) {
+  // Try existing access token
+  if (cfg.accessToken) return cfg.accessToken;
+
+  // Try refresh
+  if (cfg.refreshToken) {
+    try {
+      const tokens = await refreshToken(cfg.server, cfg.refreshToken);
+      cfg.accessToken = tokens.accessToken;
+      if (tokens.refreshToken) cfg.refreshToken = tokens.refreshToken;
+      saveConfig(cfg);
+      return cfg.accessToken;
+    } catch {}
+  }
+
+  // Re-login with stored credentials
+  if (cfg.username && cfg.password) {
+    const tokens = await login(cfg.server, cfg.username, cfg.password);
+    cfg.accessToken = tokens.accessToken;
+    cfg.refreshToken = tokens.refreshToken;
+    saveConfig(cfg);
+    return cfg.accessToken;
+  }
+
+  throw new Error('No valid credentials. Run: npx swarmpath-claudecode-bridge --setup');
+}
+
+// ---------------------------------------------------------------------------
+// Parse CLI args
+// ---------------------------------------------------------------------------
+const cliArgs = process.argv.slice(2);
+function getArg(name) {
+  const idx = cliArgs.indexOf(`--${name}`);
+  return idx >= 0 && idx + 1 < cliArgs.length ? cliArgs[idx + 1] : null;
+}
+const hasFlag = (name) => cliArgs.includes(`--${name}`);
+
+// Handle --setup
+if (hasFlag('setup')) {
+  await runSetup();
+}
+
+// Resolve config
+const cfg = loadConfig();
+const SERVER = getArg('server') || cfg.server || process.env.SWARMPATH_SERVER;
+let TOKEN = getArg('token') || process.env.SWARMPATH_TOKEN;
+let CWD = getArg('cwd') || process.cwd();
+
+if (!SERVER) {
+  console.error('❌ 未配置服务器。请先运行: npx swarmpath-claudecode-bridge --setup');
+  process.exit(1);
+}
+
+// Auto-login if no token provided
+if (!TOKEN) {
+  try {
+    TOKEN = await ensureToken(cfg);
+    console.log('🔑 自动登录成功');
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+let ws = null;
+let reconnectTimer = null;
+let heartbeatTimer = null;
+let tokenRefreshTimer = null;
+let activeChild = null;
+let activeRequestId = null;
+let claudeSessionId = null;
+let shuttingDown = false;
+
+const HEARTBEAT_MS = 30_000;
+const RECONNECT_MS = 5_000;
+const MAX_RECONNECT_MS = 60_000;
+const TOKEN_REFRESH_MS = 12 * 60 * 1000; // Refresh token every 12 min (before 15-min expiry)
+let reconnectDelay = RECONNECT_MS;
+
+// ---------------------------------------------------------------------------
+// Token auto-refresh
+// ---------------------------------------------------------------------------
+function startTokenRefresh() {
+  clearInterval(tokenRefreshTimer);
+  tokenRefreshTimer = setInterval(async () => {
+    try {
+      TOKEN = await ensureToken(cfg);
+      console.log('🔑 Token 已自动续期');
+    } catch (err) {
+      console.error('⚠️  Token 续期失败:', err.message);
+    }
+  }, TOKEN_REFRESH_MS);
+}
+
+// ---------------------------------------------------------------------------
+// WebSocket connection
+// ---------------------------------------------------------------------------
+function connect() {
+  const cwdParam = encodeURIComponent(CWD);
+  const url = `${SERVER}/ws/bridge?token=${TOKEN}&cwd=${cwdParam}`;
+
+  console.log(`\n🔗 Connecting to ${SERVER} ...`);
+  ws = new WebSocket(url);
+
+  ws.on('open', () => {
+    console.log('✅ Connected to SwarmPath server');
+    reconnectDelay = RECONNECT_MS;
+
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = setInterval(() => {
+      if (ws?.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'heartbeat' }));
+      }
+    }, HEARTBEAT_MS);
+
+    ws.send(JSON.stringify({ type: 'cwd', cwd: CWD }));
+  });
+
+  ws.on('message', (raw) => {
+    try {
+      const msg = JSON.parse(raw.toString());
+      handleMessage(msg);
+    } catch (e) {
+      console.error('Failed to parse message:', e.message);
+    }
+  });
+
+  ws.on('close', async (code, reason) => {
+    const reasonStr = reason?.toString() || 'none';
+    console.log(`🔌 Disconnected (code=${code}, reason=${reasonStr})`);
+    clearInterval(heartbeatTimer);
+
+    // If token expired, auto-refresh and reconnect
+    if (code === 4001 && !shuttingDown) {
+      console.log('🔑 Token 过期，尝试自动续期...');
+      try {
+        TOKEN = await ensureToken(cfg);
+        console.log('🔑 续期成功，重新连接...');
+        reconnectDelay = RECONNECT_MS;
+        setTimeout(() => connect(), 1000);
+        return;
+      } catch (err) {
+        console.error('❌ 续期失败:', err.message);
+      }
+    }
+
+    if (!shuttingDown) scheduleReconnect();
+  });
+
+  ws.on('error', (err) => {
+    console.error('WebSocket error:', err.message);
+  });
+}
+
+function scheduleReconnect() {
+  if (reconnectTimer) return;
+  console.log(`⏳ Reconnecting in ${reconnectDelay / 1000}s ...`);
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    reconnectDelay = Math.min(reconnectDelay * 1.5, MAX_RECONNECT_MS);
+    connect();
+  }, reconnectDelay);
+}
+
+// ---------------------------------------------------------------------------
+// Message handling
+// ---------------------------------------------------------------------------
+function handleMessage(msg) {
+  switch (msg.type) {
+    case 'paired_code':
+      console.log('');
+      console.log('═══════════════════════════════════════════');
+      console.log(`   配对码 (Pairing Code):  ${msg.code}`);
+      console.log(`   有效期: ${msg.expiresIn || 300} 秒`);
+      console.log('═══════════════════════════════════════════');
+      console.log('');
+      console.log('在 SwarmPath Chat 中输入: /connect ' + msg.code);
+      console.log('');
+      break;
+
+    case 'paired':
+      console.log(`🤝 配对成功! (bridgeId: ${msg.bridgeId})`);
+      console.log(`📁 工作目录: ${CWD}`);
+      console.log('等待指令...\n');
+      break;
+
+    case 'prompt':
+      console.log(`📨 收到指令 [${msg.requestId}]${msg.model ? ' (' + msg.model + ')' : ''}: ${msg.prompt.slice(0, 80)}${msg.prompt.length > 80 ? '...' : ''}`);
+      executePrompt(msg.requestId, msg.prompt, msg.model);
+      break;
+
+    case 'abort':
+      console.log(`⛔ 收到中止指令 [${msg.requestId}]`);
+      if (activeChild && activeRequestId === msg.requestId) {
+        activeChild.kill('SIGTERM');
+        setTimeout(() => { if (activeChild && !activeChild.killed) activeChild.kill('SIGKILL'); }, 3000);
+      }
+      break;
+
+    case 'file_request':
+      handleFileRequest(msg);
+      break;
+
+    case 'error':
+      console.error('Server error:', msg.message);
+      break;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Execute Claude CLI
+// ---------------------------------------------------------------------------
+function executePrompt(requestId, prompt, model) {
+  if (activeChild && activeRequestId) {
+    const prevReqId = activeRequestId;
+    activeChild.kill('SIGTERM');
+    wsSend({ type: 'stream_error', requestId: prevReqId, error: 'Superseded by new request' });
+  }
+
+  activeRequestId = requestId;
+
+  const args = ['-p', prompt, '--output-format', 'stream-json', '--verbose', '--dangerously-skip-permissions'];
+  if (claudeSessionId) args.push('--resume', claudeSessionId);
+  if (model) args.push('--model', model);
+
+  const child = spawn('claude', args, {
+    cwd: CWD,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env },
+  });
+
+  activeChild = child;
+  wsSend({ type: 'stream_start', requestId });
+
+  let buffer = '';
+  let hasSentDelta = false;
+
+  child.stdout.on('data', (chunk) => {
+    buffer += chunk.toString();
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line);
+        if (event.session_id && !claudeSessionId) {
+          claudeSessionId = event.session_id;
+          console.log(`  📎 Session ID: ${claudeSessionId}`);
+        }
+        hasSentDelta = processClaudeEvent(requestId, event, hasSentDelta) || hasSentDelta;
+      } catch {
+        if (line.trim()) {
+          wsSend({ type: 'stream_delta', requestId, content: line + '\n' });
+          hasSentDelta = true;
+        }
+      }
+    }
+  });
+
+  const MAX_STDERR = 64 * 1024;
+  let stderrBuf = '';
+  child.stderr.on('data', (chunk) => {
+    if (stderrBuf.length < MAX_STDERR) {
+      stderrBuf += chunk.toString();
+      if (stderrBuf.length > MAX_STDERR) stderrBuf = stderrBuf.slice(0, MAX_STDERR);
+    }
+  });
+
+  child.on('close', (code) => {
+    if (buffer.trim()) {
+      try {
+        const event = JSON.parse(buffer);
+        hasSentDelta = processClaudeEvent(requestId, event, hasSentDelta) || hasSentDelta;
+      } catch {
+        if (buffer.trim()) wsSend({ type: 'stream_delta', requestId, content: buffer });
+      }
+    }
+    if (activeRequestId === requestId) {
+      if (code === 0) wsSend({ type: 'stream_done', requestId });
+      else wsSend({ type: 'stream_error', requestId, error: stderrBuf.trim() || `Claude exited with code ${code}` });
+      activeChild = null;
+      activeRequestId = null;
+    }
+    console.log(`  ✓ 完成 [${requestId}] (exit=${code})`);
+  });
+
+  child.on('error', (err) => {
+    console.error(`  ✗ 失败 [${requestId}]:`, err.message);
+    wsSend({ type: 'stream_error', requestId, error: err.message });
+    if (activeRequestId === requestId) { activeChild = null; activeRequestId = null; }
+  });
+}
+
+function processClaudeEvent(requestId, event, hasSentDelta) {
+  if (event.type === 'content_block_delta' && event.delta?.text) {
+    wsSend({ type: 'stream_delta', requestId, content: event.delta.text });
+    return true;
+  }
+  if (event.type === 'assistant' && event.message?.content) {
+    let sent = false;
+    for (const block of event.message.content) {
+      if (block.type === 'text' && block.text) {
+        if (hasSentDelta) wsSend({ type: 'stream_delta', requestId, content: '\n\n' });
+        wsSend({ type: 'stream_delta', requestId, content: block.text });
+        sent = true;
+      }
+    }
+    return sent || hasSentDelta;
+  }
+  if (event.type === 'result' && !hasSentDelta) {
+    const text = typeof event.result === 'string' ? event.result : event.result?.text || '';
+    if (text) { wsSend({ type: 'stream_delta', requestId, content: text }); return true; }
+  }
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// File operations
+// ---------------------------------------------------------------------------
+const SKIP_DIRS = new Set(['node_modules', '.git', '.next', '__pycache__', '.cache', 'dist', '.DS_Store']);
+const MIME_MAP = {
+  '.js': 'text/javascript', '.mjs': 'text/javascript', '.ts': 'text/plain', '.tsx': 'text/plain',
+  '.json': 'application/json', '.md': 'text/markdown', '.txt': 'text/plain', '.html': 'text/html',
+  '.css': 'text/css', '.py': 'text/plain', '.sh': 'text/plain', '.yaml': 'text/yaml', '.yml': 'text/yaml',
+  '.xml': 'text/xml', '.svg': 'image/svg+xml', '.png': 'image/png', '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.pdf': 'application/pdf',
+};
+
+function handleFileRequest(msg) {
+  const { requestId, action } = msg;
+  try {
+    if (action === 'cd') {
+      const target = msg.path || '..';
+      const newCwd = resolve(CWD, target);
+      const st = statSync(newCwd);
+      if (!st.isDirectory()) throw new Error('Not a directory');
+      CWD = newCwd;
+      wsSend({ type: 'cwd', cwd: CWD });
+      console.log(`  📂 切换目录: ${CWD}`);
+      wsSend({ type: 'file_response', requestId, data: { cwd: CWD } });
+    } else if (action === 'tree') {
+      const tree = buildTree(CWD, '', msg.depth || 3, !!msg.showHidden);
+      wsSend({ type: 'file_response', requestId, data: { cwd: CWD, tree } });
+    } else if (action === 'read') {
+      const relPath = msg.path;
+      if (!relPath) throw new Error('path required');
+      const fullPath = resolve(CWD, relPath);
+      if (!fullPath.startsWith(resolve(CWD) + '/') && fullPath !== resolve(CWD)) throw new Error('Access denied');
+      const ext = extname(fullPath).toLowerCase();
+      const mime = MIME_MAP[ext] || 'application/octet-stream';
+      const isText = mime.startsWith('text/') || mime === 'application/json' || mime === 'text/markdown';
+      if (isText) {
+        wsSend({ type: 'file_response', requestId, data: { content: readFileSync(fullPath, 'utf-8'), mimeType: mime, encoding: 'utf8' } });
+      } else {
+        const buf = readFileSync(fullPath);
+        if (buf.length > 2 * 1024 * 1024) throw new Error('File too large');
+        wsSend({ type: 'file_response', requestId, data: { content: buf.toString('base64'), mimeType: mime, encoding: 'base64' } });
+      }
+    } else {
+      throw new Error(`Unknown action: ${action}`);
+    }
+  } catch (err) {
+    wsSend({ type: 'file_response', requestId, error: err.message || String(err) });
+  }
+}
+
+function buildTree(dir, relPrefix, maxDepth, showHidden, depth = 0) {
+  if (depth >= maxDepth) return [];
+  const entries = [];
+  try {
+    for (const item of readdirSync(dir, { withFileTypes: true })) {
+      if (!showHidden && item.name.startsWith('.')) continue;
+      if (SKIP_DIRS.has(item.name)) continue;
+      const relPath = relPrefix ? relPrefix + '/' + item.name : item.name;
+      if (item.isDirectory()) {
+        entries.push({ name: item.name, path: relPath, isDir: true, children: buildTree(join(dir, item.name), relPath, maxDepth, showHidden, depth + 1) });
+      } else {
+        try { entries.push({ name: item.name, path: relPath, isDir: false, size: statSync(join(dir, item.name)).size }); }
+        catch { entries.push({ name: item.name, path: relPath, isDir: false, size: 0 }); }
+      }
+    }
+  } catch {}
+  entries.sort((a, b) => (a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1));
+  return entries;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function wsSend(data) {
+  if (ws?.readyState === WebSocket.OPEN) ws.send(JSON.stringify(data));
+}
+
+// ---------------------------------------------------------------------------
+// Graceful shutdown
+// ---------------------------------------------------------------------------
+function shutdown() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log('\n🛑 Shutting down...');
+  clearInterval(heartbeatTimer);
+  clearInterval(tokenRefreshTimer);
+  clearTimeout(reconnectTimer);
+  if (activeChild) {
+    activeChild.kill('SIGTERM');
+    setTimeout(() => { if (activeChild && !activeChild.killed) activeChild.kill('SIGKILL'); }, 2000);
+  }
+  if (ws) ws.close(1000, 'Shutdown');
+  setTimeout(() => process.exit(0), 3000);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+console.log('🌐 SwarmPath Claude Code Bridge');
+console.log(`📁 Working directory: ${CWD}`);
+startTokenRefresh();
+connect();

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "swarmpath-claudecode-bridge",
+  "version": "1.0.0",
+  "description": "Connect local Claude Code to SwarmPath Chat — control your Mac from your phone",
+  "type": "module",
+  "bin": {
+    "swarmpath-claudecode-bridge": "./index.mjs"
+  },
+  "keywords": [
+    "claude-code",
+    "swarmpath",
+    "bridge",
+    "remote-control",
+    "ai-agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SwarmPathAI/swarmpath-agent-chat"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "ws": "^8.19.0"
+  }
+}