claudelink-bridge 0.1.0

package/bin/cli.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// Auto-install dependencies if ws is missing (happens when running from source)
+const __dir = dirname(fileURLToPath(import.meta.url));
+const bridgeRoot = join(__dir, '..');
+if (!existsSync(join(bridgeRoot, 'node_modules', 'ws'))) {
+  console.log('\x1b[36m→\x1b[0m Installing bridge dependencies…');
+  execSync('npm install --silent', { cwd: bridgeRoot, stdio: 'inherit' });
+  console.log('\x1b[32m✓\x1b[0m Dependencies installed\n');
+}
+
+import { isClaudeInstalled, isNodeInstalled, OS } from '../lib/platform.js';
+import { install, uninstall, status } from '../lib/service.js';
+
+const cmd = process.argv[2];
+
+const BOLD  = '\x1b[1m';
+const GREEN = '\x1b[32m';
+const RED   = '\x1b[31m';
+const YELLOW= '\x1b[33m';
+const CYAN  = '\x1b[36m';
+const RESET = '\x1b[0m';
+
+function ok(msg)   { console.log(`${GREEN}✓${RESET} ${msg}`); }
+function fail(msg) { console.log(`${RED}✗${RESET} ${msg}`); }
+function info(msg) { console.log(`${CYAN}→${RESET} ${msg}`); }
+function warn(msg) { console.log(`${YELLOW}!${RESET} ${msg}`); }
+function title(msg){ console.log(`\n${BOLD}${msg}${RESET}`); }
+
+// ─── setup ────────────────────────────────────────────────────────────────────
+
+if (!cmd || cmd === 'setup') {
+  title('⚡ ClaudeLink Bridge Setup');
+  console.log('This installs the bridge as a background service that starts\nautomatically on login — no manual steps after this.\n');
+
+  // Check prerequisites
+  title('Checking prerequisites…');
+
+  if (!isNodeInstalled()) {
+    fail('Node.js not found. Install it from https://nodejs.org (v18+)');
+    process.exit(1);
+  }
+  ok('Node.js installed');
+
+  if (!isClaudeInstalled()) {
+    fail('Claude Code CLI not found.');
+    info('Install it with:  npm install -g @anthropic-ai/claude-code');
+    info('Then run:         claude  (to log in)');
+    info('Then re-run:      npx claudelink-bridge setup');
+    process.exit(1);
+  }
+  ok('Claude Code CLI installed');
+
+  // Install service
+  title('Installing bridge service…');
+  try {
+    install();
+    ok('Bridge service installed and started');
+  } catch (err) {
+    fail(`Service install failed: ${err.message}`);
+    info('You can still run the bridge manually: npx claudelink-bridge start');
+    process.exit(1);
+  }
+
+  // Done
+  console.log(`
+${GREEN}${BOLD}Setup complete!${RESET}
+
+The bridge is now running on ${BOLD}ws://localhost:9999${RESET} and will
+auto-start every time you log in.
+
+${BOLD}Next steps:${RESET}
+  1. Open Chrome and pin the ClaudeLink extension
+  2. The status indicator should be ${GREEN}green${RESET} — you're ready to go
+
+${BOLD}Useful commands:${RESET}
+  npx claudelink-bridge status     Check if the bridge is running
+  npx claudelink-bridge stop       Stop the service
+  npx claudelink-bridge start      Start the service
+  npx claudelink-bridge uninstall  Remove the service
+`);
+}
+
+// ─── start (manual run) ───────────────────────────────────────────────────────
+
+else if (cmd === 'start') {
+  // Check if already running before starting
+  const port = parseInt(process.env.CLAUDELINK_PORT ?? '9999');
+  const alreadyRunning = await checkPortRunning(port);
+  if (alreadyRunning) {
+    ok(`Bridge is already running on port ${port}. Nothing to do.`);
+    process.exit(0);
+  }
+  info('Starting bridge server (Ctrl+C to stop)…');
+  await import('../lib/server.js');
+}
+
+// ─── kill (force kill whatever is on the port) ───────────────────────────────
+
+else if (cmd === 'kill') {
+  const port = parseInt(process.env.CLAUDELINK_PORT ?? '9999');
+  try {
+    const { execSync } = await import('child_process');
+    if (OS === 'win32') {
+      execSync(`for /f "tokens=5" %a in ('netstat -aon ^| findstr :${port}') do taskkill /F /PID %a`, { shell: true, stdio: 'ignore' });
+    } else {
+      execSync(`lsof -ti:${port} | xargs kill -9 2>/dev/null || true`, { shell: true, stdio: 'ignore' });
+    }
+    ok(`Killed process on port ${port}`);
+  } catch { warn(`Nothing was running on port ${port}`); }
+}
+
+// ─── status ───────────────────────────────────────────────────────────────────
+
+else if (cmd === 'status') {
+  const s = status();
+  if (s === 'running') ok(`Bridge service is ${GREEN}running${RESET}`);
+  else                 warn(`Bridge service is ${RED}stopped${RESET} — run: npx claudelink-bridge setup`);
+}
+
+// ─── stop ─────────────────────────────────────────────────────────────────────
+
+else if (cmd === 'stop') {
+  try {
+    if (OS === 'darwin')  { const { execSync } = await import('child_process'); execSync(`launchctl stop com.devops-monk.claudelink`); }
+    if (OS === 'linux')   { const { execSync } = await import('child_process'); execSync('systemctl --user stop claudelink'); }
+    if (OS === 'win32')   { const { execSync } = await import('child_process'); execSync('schtasks /End /TN ClaudeLinkBridge', { shell: true }); }
+    ok('Bridge service stopped');
+  } catch (e) { fail(`Could not stop: ${e.message}`); }
+}
+
+// ─── uninstall ────────────────────────────────────────────────────────────────
+
+else if (cmd === 'uninstall') {
+  try {
+    uninstall();
+    ok('Bridge service removed');
+  } catch (e) { fail(`Uninstall failed: ${e.message}`); }
+}
+
+// ─── unknown ──────────────────────────────────────────────────────────────────
+
+else {
+  console.log(`Usage: npx claudelink-bridge <command>
+
+Commands:
+  setup      Install bridge as a background auto-start service (run once)
+  start      Run the bridge manually in the foreground (Ctrl+C to stop)
+  kill       Force-kill whatever is running on port 9999
+  status     Check if the background service is running
+  stop       Stop the background service
+  uninstall  Remove the background service
+`);
+}
+
+// ─── Helper ───────────────────────────────────────────────────────────────────
+
+async function checkPortRunning(port) {
+  return new Promise((resolve) => {
+    import('ws').then(({ default: WS }) => {
+      const ws = new WS(`ws://localhost:${port}`);
+      const t = setTimeout(() => { try { ws.terminate(); } catch {} resolve(false); }, 800);
+      ws.on('open', () => ws.send(JSON.stringify({ type: 'ping' })));
+      ws.on('message', (data) => {
+        try {
+          if (JSON.parse(data.toString()).type === 'pong') {
+            clearTimeout(t); ws.terminate(); resolve(true);
+          }
+        } catch { resolve(false); }
+      });
+      ws.on('error', () => { clearTimeout(t); resolve(false); });
+    }).catch(() => resolve(false));
+  });
+}

package/bridge.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+// ClaudeLink bridge — run once: node bridge/bridge.js
+// Connects Claude Code CLI to the browser extension via WebSocket.
+
+import { WebSocketServer } from 'ws';
+import { spawn } from 'child_process';
+import { writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+const PORT = process.env.CLAUDELINK_PORT ? parseInt(process.env.CLAUDELINK_PORT) : 9999;
+const ALLOWED_ORIGIN = 'chrome-extension://';
+
+const wss = new WebSocketServer({ port: PORT });
+
+console.log(`\n⚡ ClaudeLink bridge running on ws://localhost:${PORT}`);
+console.log(`   Waiting for extension to connect…\n`);
+
+wss.on('connection', (ws, req) => {
+  const origin = req.headers['origin'] ?? '';
+  if (!origin.startsWith(ALLOWED_ORIGIN)) {
+    ws.close(1008, 'Forbidden');
+    return;
+  }
+
+  console.log(`[+] Extension connected`);
+
+  ws.on('message', async (raw) => {
+    let msg;
+    try { msg = JSON.parse(raw.toString()); }
+    catch { ws.send(JSON.stringify({ type: 'error', text: 'Invalid JSON' })); return; }
+
+    if (msg.type === 'ping') {
+      ws.send(JSON.stringify({ type: 'pong' }));
+      return;
+    }
+
+    if (msg.type === 'prompt') {
+      console.log(`[>] Prompt: ${String(msg.prompt).slice(0, 80)}…`);
+      runClaude(['--print', msg.prompt], ws);
+      return;
+    }
+
+    if (msg.type === 'file-prompt') {
+      const tmpFile = join(tmpdir(), `claudelink-${Date.now()}.md`);
+      writeFileSync(tmpFile, msg.content);
+      console.log(`[>] File prompt: ${tmpFile}`);
+      runClaude(['-p', tmpFile], ws, () => { try { unlinkSync(tmpFile); } catch {} });
+      return;
+    }
+
+    if (msg.type === 'run-script') {
+      const tmpScript = join(tmpdir(), `claudelink-script-${Date.now()}.sh`);
+      writeFileSync(tmpScript, msg.script, { mode: 0o755 });
+      console.log(`[>] Running script: ${tmpScript}`);
+      runScript(tmpScript, ws, () => { try { unlinkSync(tmpScript); } catch {} });
+      return;
+    }
+  });
+
+  ws.on('close', () => console.log(`[-] Extension disconnected`));
+});
+
+function runClaude(args, ws, onClose) {
+  const proc = spawn('claude', args, { env: { ...process.env } });
+  proc.stdout.on('data', (d) => ws.send(JSON.stringify({ type: 'chunk', text: d.toString() })));
+  proc.stderr.on('data', (d) => ws.send(JSON.stringify({ type: 'error', text: d.toString() })));
+  proc.on('close', (code) => {
+    onClose?.();
+    ws.send(JSON.stringify({ type: 'done', exitCode: code }));
+    console.log(`[✓] Done (exit ${code})`);
+  });
+  proc.on('error', (e) => {
+    ws.send(JSON.stringify({ type: 'error', text: `Failed to start claude: ${e.message}\nMake sure Claude Code CLI is installed: npm install -g @anthropic-ai/claude-code` }));
+    ws.send(JSON.stringify({ type: 'done', exitCode: 1 }));
+  });
+}
+
+function runScript(scriptPath, ws, onClose) {
+  const proc = spawn('bash', [scriptPath], { env: { ...process.env } });
+  proc.stdout.on('data', (d) => ws.send(JSON.stringify({ type: 'chunk', text: d.toString() })));
+  proc.stderr.on('data', (d) => ws.send(JSON.stringify({ type: 'error', text: d.toString() })));
+  proc.on('close', (code) => {
+    onClose?.();
+    ws.send(JSON.stringify({ type: 'done', exitCode: code }));
+    console.log(`[✓] Script done (exit ${code})`);
+  });
+  proc.on('error', (e) => {
+    ws.send(JSON.stringify({ type: 'error', text: `Script error: ${e.message}` }));
+    ws.send(JSON.stringify({ type: 'done', exitCode: 1 }));
+  });
+}

package/lib/platform.js

@@ -0,0 +1,51 @@
+import { platform, homedir } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+
+export const OS = platform(); // 'darwin' | 'linux' | 'win32'
+
+export const HOME = homedir();
+export const PORT = parseInt(process.env.CLAUDELINK_PORT ?? '9999');
+
+export const SERVICE_NAME = 'com.devops-monk.claudelink';
+
+// Path to this package's server entry point
+export const SERVER_SCRIPT = new URL('../lib/server.js', import.meta.url).pathname;
+
+export function getServicePaths() {
+  if (OS === 'darwin') {
+    return {
+      plist: join(HOME, 'Library', 'LaunchAgents', `${SERVICE_NAME}.plist`),
+    };
+  }
+  if (OS === 'linux') {
+    return {
+      service: join(HOME, '.config', 'systemd', 'user', 'claudelink.service'),
+    };
+  }
+  if (OS === 'win32') {
+    return {
+      taskName: 'ClaudeLinkBridge',
+    };
+  }
+  return {};
+}
+
+export function isClaudeInstalled() {
+  try {
+    execSync('claude --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isNodeInstalled() {
+  try {
+    execSync('node --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/lib/server.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+import { WebSocketServer } from 'ws';
+import { spawn } from 'child_process';
+import { writeFileSync, unlinkSync, mkdirSync } from 'fs';
+import { tmpdir, homedir } from 'os';
+import { join } from 'path';
+
+const PORT = process.env.CLAUDELINK_PORT ? parseInt(process.env.CLAUDELINK_PORT) : 9999;
+const ALLOWED_ORIGIN = 'chrome-extension://';
+
+// Persistent screenshot dir so images survive long sessions
+const SCREENSHOT_DIR = join(homedir(), '.claudelink', 'screenshots');
+mkdirSync(SCREENSHOT_DIR, { recursive: true });
+
+// Increase max payload to 50MB to handle large screenshots
+const wss = new WebSocketServer({ port: PORT, maxPayload: 50 * 1024 * 1024 });
+
+wss.on('error', (err) => {
+  if (err.code === 'EADDRINUSE') {
+    // Check if it's already our bridge running on that port
+    checkIfAlreadyRunning(PORT).then(running => {
+      if (running) {
+        console.log(`\n✓ ClaudeLink bridge is already running on port ${PORT}.`);
+        console.log(`  Nothing to do — the extension is connected.\n`);
+      } else {
+        console.error(`\n✗ Port ${PORT} is already in use by another process.`);
+        console.error(`\n  To fix this, run one of:`);
+        console.error(`    lsof -ti:${PORT} | xargs kill -9   # kill whatever is on the port`);
+        console.error(`    CLAUDELINK_PORT=9998 node bridge/lib/server.js  # use a different port\n`);
+      }
+      process.exit(0);
+    });
+    return;
+  }
+  console.error('[ClaudeLink] Server error:', err);
+});
+
+function checkIfAlreadyRunning(port) {
+  return new Promise((resolve) => {
+    import('ws').then(({ default: WS }) => {
+      const ws = new WS(`ws://localhost:${port}`);
+      const t = setTimeout(() => { ws.terminate(); resolve(false); }, 1000);
+      ws.on('open', () => {
+        ws.send(JSON.stringify({ type: 'ping' }));
+      });
+      ws.on('message', (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === 'pong') { clearTimeout(t); ws.terminate(); resolve(true); }
+        } catch { resolve(false); }
+      });
+      ws.on('error', () => { clearTimeout(t); resolve(false); });
+    });
+  });
+}
+
+console.log(`\n⚡ ClaudeLink bridge running on ws://localhost:${PORT}`);
+console.log(`   Waiting for extension to connect…\n`);
+
+wss.on('connection', (ws, req) => {
+  const origin = req.headers['origin'] ?? '';
+  if (!origin.startsWith(ALLOWED_ORIGIN)) {
+    ws.close(1008, 'Forbidden');
+    return;
+  }
+  console.log(`[+] Extension connected`);
+
+  ws.on('message', async (raw) => {
+    let msg;
+    try { msg = JSON.parse(raw.toString()); }
+    catch { ws.send(JSON.stringify({ type: 'error', text: 'Invalid JSON from extension' })); return; }
+
+    if (msg.type === 'ping') {
+      ws.send(JSON.stringify({ type: 'pong' }));
+      return;
+    }
+
+    if (msg.type === 'prompt') {
+      console.log(`[>] Prompt: "${String(msg.prompt).slice(0, 80)}"`);
+      runClaude(msg.prompt, ws);
+      return;
+    }
+
+    if (msg.type === 'file-prompt') {
+      const tmpFile = join(tmpdir(), `claudelink-${Date.now()}.md`);
+      writeFileSync(tmpFile, msg.content);
+      console.log(`[>] File prompt: ${tmpFile}`);
+      runClaudeFile(tmpFile, ws, () => cleanup(tmpFile));
+      return;
+    }
+
+    if (msg.type === 'image-prompt') {
+      console.log(`[>] Image prompt received (${(raw.length / 1024).toFixed(0)}KB)`);
+      const imgFile = join(SCREENSHOT_DIR, `screenshot-${Date.now()}.png`);
+      try {
+        const base64 = msg.imageDataUrl.replace(/^data:image\/\w+;base64,/, '');
+        writeFileSync(imgFile, Buffer.from(base64, 'base64'));
+        console.log(`[>] Screenshot saved: ${imgFile}`);
+      } catch (e) {
+        safeSend(ws, { type: 'error', text: `Failed to save screenshot: ${e.message}` });
+        safeSend(ws, { type: 'done', exitCode: 1 });
+        return;
+      }
+
+      const promptText = (msg.prompt || '').trim() || 'Describe this screenshot in detail.';
+      // Write a markdown prompt file with the image embedded as a data URL
+      // This lets Claude Code see the image inline without needing file read permissions
+      const base64Data = msg.imageDataUrl;
+      const mdFile = join(SCREENSHOT_DIR, `prompt-${Date.now()}.md`);
+      writeFileSync(mdFile, `${promptText}\n\n![screenshot](${base64Data})\n`);
+      console.log(`[>] Running image prompt via -p`);
+      runClaudeFile(mdFile, ws, () => cleanup(imgFile, mdFile));
+      return;
+    }
+
+    if (msg.type === 'run-script') {
+      const tmpScript = join(tmpdir(), `claudelink-script-${Date.now()}.sh`);
+      writeFileSync(tmpScript, msg.script, { mode: 0o755 });
+      console.log(`[>] Running script`);
+      runScript(tmpScript, ws, () => cleanup(tmpScript));
+      return;
+    }
+  });
+
+  ws.on('close', () => console.log(`[-] Extension disconnected`));
+  ws.on('error', (e) => console.error(`[!] WS error: ${e.message}`));
+});
+
+// ─── Runners ──────────────────────────────────────────────────────────────────
+
+function runClaude(prompt, ws, onClose) {
+  const proc = spawn('claude', ['--print', '--dangerously-skip-permissions', prompt], {
+    env: { ...process.env },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  proc.stdout.on('data', (d) => safeSend(ws, { type: 'chunk', text: d.toString() }));
+  proc.stderr.on('data', (d) => {
+    const text = d.toString();
+    // Filter the known benign stdin warning — user already sees output
+    if (!text.includes('no stdin data received')) {
+      safeSend(ws, { type: 'error', text });
+    }
+  });
+  proc.on('close', (code) => {
+    onClose?.();
+    safeSend(ws, { type: 'done', exitCode: code });
+    console.log(`[✓] Done (exit ${code})`);
+  });
+  proc.on('error', (e) => {
+    safeSend(ws, { type: 'error', text: `Failed to start claude: ${e.message}\n\nIs Claude Code CLI installed?\n  npm install -g @anthropic-ai/claude-code` });
+    safeSend(ws, { type: 'done', exitCode: 1 });
+  });
+}
+
+function runClaudeFile(file, ws, onClose) {
+  const proc = spawn('claude', ['-p', file, '--dangerously-skip-permissions'], {
+    env: { ...process.env },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  proc.stdout.on('data', (d) => safeSend(ws, { type: 'chunk', text: d.toString() }));
+  proc.stderr.on('data', (d) => {
+    const text = d.toString();
+    if (!text.includes('no stdin data received')) safeSend(ws, { type: 'error', text });
+  });
+  proc.on('close', (code) => {
+    onClose?.();
+    safeSend(ws, { type: 'done', exitCode: code });
+    console.log(`[✓] Done (exit ${code})`);
+  });
+  proc.on('error', (e) => {
+    safeSend(ws, { type: 'error', text: `Failed to start claude: ${e.message}` });
+    safeSend(ws, { type: 'done', exitCode: 1 });
+  });
+}
+
+function runScript(scriptPath, ws, onClose) {
+  const proc = spawn('bash', [scriptPath], {
+    env: { ...process.env },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  proc.stdout.on('data', (d) => safeSend(ws, { type: 'chunk', text: d.toString() }));
+  proc.stderr.on('data', (d) => safeSend(ws, { type: 'error', text: d.toString() }));
+  proc.on('close', (code) => {
+    onClose?.();
+    safeSend(ws, { type: 'done', exitCode: code });
+    console.log(`[✓] Script done (exit ${code})`);
+  });
+  proc.on('error', (e) => {
+    safeSend(ws, { type: 'error', text: `Script error: ${e.message}` });
+    safeSend(ws, { type: 'done', exitCode: 1 });
+  });
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function safeSend(ws, obj) {
+  if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(obj));
+}
+
+function cleanup(...files) {
+  for (const f of files) { try { unlinkSync(f); } catch {} }
+}

package/lib/service.js

@@ -0,0 +1,151 @@
+import { writeFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
+import { execSync, spawnSync } from 'child_process';
+import { dirname } from 'path';
+import { OS, HOME, PORT, SERVICE_NAME, SERVER_SCRIPT, getServicePaths } from './platform.js';
+
+// ─── Install ──────────────────────────────────────────────────────────────────
+
+export function install() {
+  if (OS === 'darwin') return installMac();
+  if (OS === 'linux')  return installLinux();
+  if (OS === 'win32')  return installWindows();
+  throw new Error(`Unsupported platform: ${OS}`);
+}
+
+function installMac() {
+  const { plist } = getServicePaths();
+  const nodePath = execSync('which node').toString().trim();
+
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${SERVER_SCRIPT}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>CLAUDELINK_PORT</key>
+    <string>${PORT}</string>
+    <key>PATH</key>
+    <string>${process.env.PATH}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${HOME}/.claudelink/bridge.log</string>
+  <key>StandardErrorPath</key>
+  <string>${HOME}/.claudelink/bridge-error.log</string>
+</dict>
+</plist>`;
+
+  mkdirSync(`${HOME}/.claudelink`, { recursive: true });
+  mkdirSync(dirname(plist), { recursive: true });
+  writeFileSync(plist, xml);
+
+  // Unload if already loaded, then load fresh
+  spawnSync('launchctl', ['unload', plist], { stdio: 'ignore' });
+  const result = spawnSync('launchctl', ['load', '-w', plist]);
+  if (result.status !== 0) throw new Error('launchctl load failed');
+}
+
+function installLinux() {
+  const { service } = getServicePaths();
+  const nodePath = execSync('which node').toString().trim();
+
+  const unit = `[Unit]
+Description=ClaudeLink Bridge — Claude Code CLI ↔ Browser
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${SERVER_SCRIPT}
+Restart=always
+RestartSec=3
+Environment=CLAUDELINK_PORT=${PORT}
+Environment=PATH=${process.env.PATH}
+
+[Install]
+WantedBy=default.target`;
+
+  mkdirSync(dirname(service), { recursive: true });
+  writeFileSync(service, unit);
+
+  execSync('systemctl --user daemon-reload');
+  execSync('systemctl --user enable --now claudelink');
+}
+
+function installWindows() {
+  const { taskName } = getServicePaths();
+  const nodePath = execSync('where node').toString().trim().split('\n')[0].trim();
+
+  // Create a scheduled task that starts at logon and runs indefinitely
+  const cmd = [
+    'schtasks', '/Create', '/F',
+    '/TN', taskName,
+    '/TR', `"${nodePath}" "${SERVER_SCRIPT}"`,
+    '/SC', 'ONLOGON',
+    '/RL', 'HIGHEST',
+  ].join(' ');
+
+  execSync(cmd, { shell: true });
+
+  // Start it immediately too
+  execSync(`schtasks /Run /TN "${taskName}"`, { shell: true });
+}
+
+// ─── Uninstall ────────────────────────────────────────────────────────────────
+
+export function uninstall() {
+  if (OS === 'darwin') return uninstallMac();
+  if (OS === 'linux')  return uninstallLinux();
+  if (OS === 'win32')  return uninstallWindows();
+}
+
+function uninstallMac() {
+  const { plist } = getServicePaths();
+  if (existsSync(plist)) {
+    spawnSync('launchctl', ['unload', plist]);
+    unlinkSync(plist);
+  }
+}
+
+function uninstallLinux() {
+  execSync('systemctl --user disable --now claudelink', { stdio: 'ignore' });
+  const { service } = getServicePaths();
+  if (existsSync(service)) unlinkSync(service);
+}
+
+function uninstallWindows() {
+  const { taskName } = getServicePaths();
+  execSync(`schtasks /Delete /F /TN "${taskName}"`, { shell: true, stdio: 'ignore' });
+}
+
+// ─── Status ───────────────────────────────────────────────────────────────────
+
+export function status() {
+  try {
+    if (OS === 'darwin') {
+      const out = execSync(`launchctl list | grep ${SERVICE_NAME}`, { stdio: 'pipe' }).toString();
+      return out.trim().length > 0 ? 'running' : 'stopped';
+    }
+    if (OS === 'linux') {
+      const out = execSync('systemctl --user is-active claudelink', { stdio: 'pipe' }).toString().trim();
+      return out === 'active' ? 'running' : 'stopped';
+    }
+    if (OS === 'win32') {
+      const { taskName } = getServicePaths();
+      const out = execSync(`schtasks /Query /TN "${taskName}"`, { stdio: 'pipe', shell: true }).toString();
+      return out.includes('Running') ? 'running' : 'stopped';
+    }
+  } catch {
+    return 'stopped';
+  }
+  return 'unknown';
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "claudelink-bridge",
+  "version": "0.1.0",
+  "description": "Local bridge server connecting ClaudeLink Chrome extension to Claude Code CLI",
+  "type": "module",
+  "bin": {
+    "claudelink-bridge": "bin/cli.js"
+  },
+  "scripts": {
+    "start": "node lib/server.js"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "cli",
+    "chrome-extension"
+  ],
+  "author": "DevOps-Monk",
+  "license": "MIT"
+}