@16pxh/cli-bridge 1.0.4 → 1.0.7

package/lib/claude.mjs

@@ -1,5 +1,8 @@
 import { spawn, execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 
 const execFileAsync = promisify(execFile);
 
@@ -22,10 +25,10 @@ export async function checkClaudeInstalled() {
 /**
  * Spawn `claude -p <prompt> --output-format json`, resolve with parsed result.
  * @param {string} prompt
- * @param {{ timeoutMs?: number }} [options]
+ * @param {{ sessionId?: string }} [options]
  * @returns {Promise<{ result: string, session_id: string, duration_ms: number }>}
  */
-export function runPrompt(prompt, { timeoutMs = 60000, sessionId } = {}) {
+export function runPrompt(prompt, { sessionId } = {}) {
   return new Promise((resolve, reject) => {
     const args = ['-p', prompt, '--output-format', 'json'];
     if (sessionId) args.push('--resume', sessionId);
@@ -39,13 +42,7 @@ export function runPrompt(prompt, { timeoutMs = 60000, sessionId } = {}) {
     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) {
@@ -74,6 +71,86 @@ export function runPrompt(prompt, { timeoutMs = 60000, sessionId } = {}) {
   });
 }
 
+/**
+ * Write files to temp dir, run Claude CLI with edit permission, read back modified files.
+ * @param {string} prompt
+ * @param {{ html: string, css: string, js: string }} files
+ * @param {{ sessionId?: string }} [options]
+ * @returns {Promise<{ html: string, css: string, js: string, result: string, session_id: string, duration_ms: number }>}
+ */
+export function runEditFiles(prompt, files, { sessionId } = {}) {
+  return new Promise((resolve, reject) => {
+    // Create temp dir with files
+    const tempDir = join(tmpdir(), `16pxh-edit-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    writeFileSync(join(tempDir, 'index.html'), files.html, 'utf-8');
+    writeFileSync(join(tempDir, 'style.css'), files.css, 'utf-8');
+    writeFileSync(join(tempDir, 'script.js'), files.js, 'utf-8');
+
+    const args = ['-p', prompt, '--output-format', 'json', '--allowedTools', 'Edit'];
+    if (sessionId) args.push('--resume', sessionId);
+
+    const child = spawn('claude', args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: tempDir,
+    });
+
+    activeProcess = child;
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+
+    child.on('close', (code) => {
+      if (activeProcess === child) activeProcess = null;
+
+      if (code !== 0) {
+        cleanup();
+        return reject(new Error(`Claude CLI exited with code ${code}: ${stderr.trim()}`));
+      }
+
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout.trim());
+      } catch (err) {
+        cleanup();
+        return reject(new Error(`Failed to parse output: ${err.message}`));
+      }
+
+      // Read back modified files
+      try {
+        const html = readFileSync(join(tempDir, 'index.html'), 'utf-8');
+        const css = readFileSync(join(tempDir, 'style.css'), 'utf-8');
+        const js = readFileSync(join(tempDir, 'script.js'), 'utf-8');
+        cleanup();
+        resolve({
+          html,
+          css,
+          js,
+          result: parsed.result ?? '',
+          session_id: parsed.session_id ?? '',
+          duration_ms: parsed.duration_ms ?? 0,
+        });
+      } catch (err) {
+        cleanup();
+        reject(new Error(`Failed to read edited files: ${err.message}`));
+      }
+    });
+
+    child.on('error', (err) => {
+      if (activeProcess === child) activeProcess = null;
+      cleanup();
+      reject(err);
+    });
+
+    function cleanup() {
+      try { rmSync(tempDir, { recursive: true, force: true }); } catch {}
+    }
+  });
+}
+
 /**
  * Kill the currently running claude child process, if any.
  */

package/lib/crypto.mjs

@@ -0,0 +1,44 @@
+import { createHash, createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
+
+const ALGORITHM = 'aes-256-cbc';
+const CACHE_TTL = 5 * 60 * 1000;
+
+let cachedSecret = null;
+let cachedAt = 0;
+
+export async function getBridgeSecret() {
+  if (cachedSecret && Date.now() - cachedAt < CACHE_TTL) return cachedSecret;
+  const url = process.env.BRIDGE_SECRET_URL;
+  if (!url) return null;
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return null;
+    cachedSecret = (await res.text()).trim();
+    cachedAt = Date.now();
+    return cachedSecret;
+  } catch {
+    return null;
+  }
+}
+
+function deriveKey(secret) {
+  return createHash('sha256').update(secret).digest();
+}
+
+export async function encryptSummary(text) {
+  const secret = await getBridgeSecret();
+  if (!secret) throw new Error('Bridge secret not available');
+  const key = deriveKey(secret);
+  const iv = randomBytes(16);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  return iv.toString('hex') + ':' + cipher.update(text, 'utf8', 'hex') + cipher.final('hex');
+}
+
+export async function decryptSummary(encrypted) {
+  const secret = await getBridgeSecret();
+  if (!secret) throw new Error('Bridge secret not available');
+  const key = deriveKey(secret);
+  const [ivHex, data] = encrypted.split(':');
+  const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(ivHex, 'hex'));
+  return decipher.update(data, 'hex', 'utf8') + decipher.final('utf8');
+}

package/lib/server.mjs

@@ -1,6 +1,7 @@
 import { createServer } from 'node:http';
 import { verifyToken, hasToken } from './auth.mjs';
-import { checkClaudeInstalled, runPrompt } from './claude.mjs';
+import { checkClaudeInstalled, runPrompt, runEditFiles } from './claude.mjs';
+import { decryptSummary, encryptSummary } from './crypto.mjs';
 
 const PORT = 1676;
 const HOST = '127.0.0.1';
@@ -173,6 +174,117 @@ export function startServer() {
       return;
     }
 
+    // POST /edit-files — write html/css/js to temp files, let Claude edit, read back
+    if (req.method === 'POST' && url.pathname === '/edit-files') {
+      if (!authenticate(req, res)) {
+        logRequest('POST', '/edit-files', 403);
+        return;
+      }
+
+      let body;
+      try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+      } catch {
+        logRequest('POST', '/edit-files', 400, `${c.red}invalid JSON${c.reset}`);
+        json(res, 400, { error: 'Invalid JSON body' });
+        return;
+      }
+
+      const { prompt, html, css, js, session_id } = body;
+      if (!prompt) {
+        json(res, 400, { error: 'Missing prompt' });
+        return;
+      }
+
+      const promptPreview = truncateWords(prompt, 12);
+      console.log(`${c.dim}${timestamp()}${c.reset} ${c.magenta}→ edit${c.reset} ${c.dim}${promptPreview}${c.reset}`);
+
+      try {
+        const result = await runEditFiles(
+          prompt,
+          { html: html ?? '', css: css ?? '', js: js ?? '' },
+          { sessionId: session_id }
+        );
+
+        logRequest('POST', '/edit-files', 200, `${c.dim}${result.duration_ms}ms${c.reset}`);
+        console.log(`${c.dim}${timestamp()}${c.reset} ${c.green}← edit done${c.reset}`);
+
+        json(res, 200, {
+          success: true,
+          html: result.html,
+          css: result.css,
+          js: result.js,
+          result: result.result,
+          session_id: result.session_id,
+          duration_ms: result.duration_ms,
+        });
+      } catch (err) {
+        logRequest('POST', '/edit-files', 500, `${c.red}${err.message}${c.reset}`);
+        json(res, 500, { error: err.message });
+      }
+      return;
+    }
+
+    // POST /summary — decrypt summary, run AI prompt, encrypt new summary
+    if (req.method === 'POST' && url.pathname === '/summary') {
+      if (!authenticate(req, res)) {
+        logRequest('POST', '/summary', 403);
+        return;
+      }
+
+      let body;
+      try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+      } catch {
+        logRequest('POST', '/summary', 400, `${c.red}invalid JSON${c.reset}`);
+        json(res, 400, { error: 'Invalid JSON body' });
+        return;
+      }
+
+      const { prompt, encrypted_summary } = body;
+      if (!prompt) {
+        json(res, 400, { error: 'Missing prompt' });
+        return;
+      }
+
+      try {
+        let currentSummary = '';
+        if (encrypted_summary) {
+          currentSummary = await decryptSummary(encrypted_summary);
+        }
+
+        const fullPrompt = prompt.replace('{current_summary}', currentSummary || '(empty — this is the first activity)');
+
+        const promptPreview = truncateWords(fullPrompt, 12);
+        console.log(`${c.dim}${timestamp()}${c.reset} ${c.magenta}→ summary${c.reset} ${c.dim}${promptPreview}${c.reset}`);
+
+        const { result, duration_ms } = await runPrompt(fullPrompt);
+
+        const jsonMatch = result.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) throw new Error('No JSON in response');
+        const parsed = JSON.parse(jsonMatch[0]);
+
+        const encryptedNewSummary = await encryptSummary(parsed.summary || '');
+
+        const resultPreview = truncateChars(parsed.writing_style || '', 64);
+        logRequest('POST', '/summary', 200, `${c.dim}${duration_ms}ms${c.reset}`);
+        console.log(`${c.dim}${timestamp()}${c.reset} ${c.green}← style:${c.reset} ${c.dim}${resultPreview}${c.reset}`);
+
+        json(res, 200, {
+          success: true,
+          encrypted_summary: encryptedNewSummary,
+          writing_style: parsed.writing_style || '',
+          duration_ms,
+        });
+      } catch (err) {
+        logRequest('POST', '/summary', 500, `${c.red}${err.message}${c.reset}`);
+        json(res, 500, { error: err.message });
+      }
+      return;
+    }
+
     // 404 fallback
     json(res, 404, { error: 'Not found' });
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@16pxh/cli-bridge",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "Bridge local Claude CLI to 16pxh AI features",
   "type": "module",
   "bin": {