@16pxh/cli-bridge 1.0.0

package/README.md

@@ -0,0 +1,20 @@
+# @16pxh/cli-bridge
+
+Bridge your local Claude CLI to 16pxh AI features.
+
+## Prerequisites
+- Node.js 18+
+- Claude CLI installed and authenticated (`claude --version`)
+
+## Usage
+1. Go to 16pxh Settings → AI Agent → Claude → "Connect CLI Bridge"
+2. Copy the verification token shown
+3. Run: `npx @16pxh/cli-bridge`
+4. Paste the token when prompted
+5. Click "Verify Connection" in your browser
+
+The bridge runs on `localhost:1676`. Keep the terminal open while using AI features.
+
+## Commands
+- `r` + Enter: Reset token (enter a new one)
+- `Ctrl+C`: Shutdown bridge

package/bin/bridge.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import * as readline from 'node:readline';
+import { setToken, clearToken } from '../lib/auth.mjs';
+import { checkClaudeInstalled, killActive } from '../lib/claude.mjs';
+import { startServer } from '../lib/server.mjs';
+
+console.log('🔌 16pxh CLI Bridge');
+console.log('');
+
+// --- Check Claude CLI ---
+const version = await checkClaudeInstalled();
+if (!version) {
+  console.error('Error: Claude CLI is not installed or not in PATH.');
+  console.error('Install it from: https://claude.ai/download');
+  process.exit(1);
+}
+console.log(`Claude CLI detected: ${version}`);
+
+// --- Readline setup ---
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  terminal: true,
+});
+
+/**
+ * Prompt the user for a token and store it.
+ */
+async function promptToken() {
+  return new Promise((resolve) => {
+    rl.question('Paste your verification token: ', (answer) => {
+      const token = answer.trim();
+      if (!token) {
+        console.log('Token cannot be empty. Try again.');
+        resolve(promptToken());
+      } else {
+        setToken(token);
+        console.log('Token accepted.');
+        resolve();
+      }
+    });
+  });
+}
+
+await promptToken();
+
+// --- Start server ---
+const server = startServer();
+console.log('Bridge ready on port 1676.');
+console.log('Commands: r + Enter to reset token | Ctrl+C to quit');
+
+// --- Listen for "r" to reset token ---
+rl.on('line', async (line) => {
+  if (line.trim().toLowerCase() === 'r') {
+    clearToken();
+    console.log('Token cleared. Enter a new token:');
+    await promptToken();
+    console.log('Token updated. Bridge still running on port 1676.');
+  }
+});
+
+// --- Graceful shutdown ---
+let shuttingDown = false;
+
+function shutdown() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log('\nShutting down...');
+
+  const forceExit = setTimeout(() => process.exit(0), 3000);
+  forceExit.unref();
+
+  killActive();
+
+  server.close(() => {
+    rl.close();
+    process.exit(0);
+  });
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/lib/auth.mjs

@@ -0,0 +1,48 @@
+import { createHmac } from 'node:crypto';
+
+const SECRET = '16pxh-bridge-v1';
+
+/** @type {string | null} */
+let storedHash = null;
+
+/**
+ * Hash a raw token with the shared secret (HMAC-SHA256).
+ * @param {string} rawToken
+ * @returns {string}
+ */
+function hashToken(rawToken) {
+  return createHmac('sha256', SECRET).update(rawToken).digest('hex');
+}
+
+/**
+ * Hash rawToken and store it in memory.
+ * @param {string} rawToken
+ */
+export function setToken(rawToken) {
+  storedHash = hashToken(rawToken);
+}
+
+/**
+ * Clear the stored token hash.
+ */
+export function clearToken() {
+  storedHash = null;
+}
+
+/**
+ * Compare rawToken's hash against the stored hash.
+ * @param {string} rawToken
+ * @returns {boolean}
+ */
+export function verifyToken(rawToken) {
+  if (!storedHash) return false;
+  return hashToken(rawToken) === storedHash;
+}
+
+/**
+ * Return true if a token has been set.
+ * @returns {boolean}
+ */
+export function hasToken() {
+  return storedHash !== null;
+}

package/lib/claude.mjs

@@ -0,0 +1,88 @@
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+/** @type {import('node:child_process').ChildProcess | null} */
+let activeProcess = null;
+
+/**
+ * Run `claude --version` and return the version string, or null if not installed.
+ * @returns {Promise<string | null>}
+ */
+export async function checkClaudeInstalled() {
+  try {
+    const { stdout } = await execFileAsync('claude', ['--version']);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Spawn `claude -p <prompt> --output-format json`, resolve with parsed result.
+ * @param {string} prompt
+ * @param {{ timeoutMs?: number }} [options]
+ * @returns {Promise<{ result: string, session_id: string, duration_ms: number }>}
+ */
+export function runPrompt(prompt, { timeoutMs = 60000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const args = ['-p', prompt, '--output-format', 'json'];
+    const child = spawn('claude', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+
+    activeProcess = child;
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error(`Claude CLI timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (activeProcess === child) activeProcess = null;
+
+      if (code !== 0) {
+        return reject(new Error(`Claude CLI exited with code ${code}: ${stderr.trim()}`));
+      }
+
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout.trim());
+      } catch (err) {
+        return reject(new Error(`Failed to parse Claude CLI output: ${err.message}\nRaw: ${stdout.slice(0, 200)}`));
+      }
+
+      resolve({
+        result: parsed.result ?? parsed.content ?? '',
+        session_id: parsed.session_id ?? '',
+        duration_ms: parsed.duration_ms ?? 0,
+      });
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      if (activeProcess === child) activeProcess = null;
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Kill the currently running claude child process, if any.
+ */
+export function killActive() {
+  if (activeProcess) {
+    try {
+      activeProcess.kill('SIGKILL');
+    } catch {
+      // already gone
+    }
+    activeProcess = null;
+  }
+}

package/lib/server.mjs

@@ -0,0 +1,133 @@
+import { createServer } from 'node:http';
+import { verifyToken, hasToken } from './auth.mjs';
+import { checkClaudeInstalled, runPrompt } from './claude.mjs';
+
+const PORT = 1676;
+const HOST = '127.0.0.1';
+
+const CORS_HEADERS = {
+  'Access-Control-Allow-Origin': '*',
+  'Access-Control-Allow-Headers': 'x-bridge-token, content-type',
+  'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+};
+
+/**
+ * Send a JSON response.
+ * @param {import('node:http').ServerResponse} res
+ * @param {number} status
+ * @param {object} data
+ */
+function json(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    'Content-Type': 'application/json',
+    'Content-Length': Buffer.byteLength(body),
+    ...CORS_HEADERS,
+  });
+  res.end(body);
+}
+
+/**
+ * Read the full request body as a string.
+ * @param {import('node:http').IncomingMessage} req
+ * @returns {Promise<string>}
+ */
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', (chunk) => { body += chunk; });
+    req.on('end', () => resolve(body));
+    req.on('error', reject);
+  });
+}
+
+/**
+ * Authenticate request via `x-bridge-token` header.
+ * Returns true if valid, writes 401/403 and returns false otherwise.
+ * @param {import('node:http').IncomingMessage} req
+ * @param {import('node:http').ServerResponse} res
+ * @returns {boolean}
+ */
+function authenticate(req, res) {
+  const token = req.headers['x-bridge-token'];
+  if (!token) {
+    json(res, 401, { error: 'Missing x-bridge-token header' });
+    return false;
+  }
+  if (!verifyToken(token)) {
+    json(res, 403, { error: 'Invalid token' });
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Create and start the HTTP server.
+ * @returns {import('node:http').Server}
+ */
+export function startServer() {
+  const server = createServer(async (req, res) => {
+    // Handle CORS preflight
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204, CORS_HEADERS);
+      res.end();
+      return;
+    }
+
+    const url = new URL(req.url, `http://${HOST}`);
+
+    // GET /health
+    if (req.method === 'GET' && url.pathname === '/health') {
+      if (!authenticate(req, res)) return;
+
+      const version = await checkClaudeInstalled();
+      json(res, 200, {
+        status: 'ok',
+        claude_cli: version !== null,
+        version: version ?? null,
+      });
+      return;
+    }
+
+    // POST /prompt
+    if (req.method === 'POST' && url.pathname === '/prompt') {
+      if (!authenticate(req, res)) return;
+
+      let body;
+      try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+      } catch {
+        json(res, 400, { error: 'Invalid JSON body' });
+        return;
+      }
+
+      const { prompt, images } = body;
+      if (!prompt || typeof prompt !== 'string') {
+        json(res, 400, { error: 'Missing or invalid "prompt" field' });
+        return;
+      }
+
+      let fullPrompt = prompt;
+      if (Array.isArray(images) && images.length > 0) {
+        for (const url of images) {
+          fullPrompt += `\n\nAnalyze this image: ${url}`;
+        }
+      }
+
+      try {
+        const { result, session_id, duration_ms } = await runPrompt(fullPrompt);
+        json(res, 200, { success: true, result, session_id, duration_ms });
+      } catch (err) {
+        json(res, 500, { error: err.message });
+      }
+      return;
+    }
+
+    // 404 fallback
+    json(res, 404, { error: 'Not found' });
+  });
+
+  server.listen(PORT, HOST);
+  return server;
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@16pxh/cli-bridge",
+  "version": "1.0.0",
+  "description": "Bridge local Claude CLI to 16pxh AI features",
+  "type": "module",
+  "bin": {
+    "16pxh-bridge": "./bin/bridge.mjs"
+  },
+  "files": ["bin/", "lib/", "README.md"],
+  "keywords": ["16pxh", "claude", "cli", "bridge"],
+  "license": "MIT",
+  "engines": { "node": ">=18" }
+}