cx-viewer 1.0.0

package/lib/perm-bridge.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * perm-bridge.js — PreToolUse hook bridge for tool permission approval.
+ *
+ * Registered with matcher: "" (empty = match all tools) in ~/.codex/settings.json.
+ * Called by Codex before any tool executes. Reads hook payload from stdin,
+ * forwards to cx-viewer server via long-poll HTTP, waits for user decision
+ * (allow/deny) in the web UI, then outputs hookSpecificOutput.
+ *
+ * Exit 0 = success (stdout contains hookSpecificOutput with permissionDecision)
+ * Exit 1 = fallback (Codex proceeds with normal terminal UI)
+ */
+
+import { readFileSync } from 'node:fs';
+import http from 'node:http';
+
+const port = process.env.CXVIEWER_PORT;
+if (!port) {
+  // cx-viewer not running — fall back to terminal UI silently (exit 0)
+  // exit(1) causes Codex to log "hook error" on every tool call
+  process.stdout.write(JSON.stringify({ continue: true, suppressOutput: true }) + '\n');
+  process.exit(0);
+}
+
+let stdinData;
+try {
+  stdinData = readFileSync(0, 'utf-8');
+} catch {
+  process.exit(1);
+}
+
+if (!stdinData || !stdinData.trim()) {
+  process.exit(1);
+}
+
+let payload;
+try {
+  payload = JSON.parse(stdinData);
+} catch {
+  process.exit(1);
+}
+
+const toolName = payload?.tool_name;
+const toolInput = payload?.tool_input;
+
+if (!toolName || !toolInput) {
+  process.exit(1);
+}
+
+// 硬拦截：git commit/push 和 npm publish 即使在 --d (bypass) 模式下也强制走 Web UI 审批
+// 这是安全底线，不受 --dangerously-skip-permissions 影响
+const isPublishCmd = toolName === 'Bash' && toolInput.command &&
+  /git\s+(commit|push)|npm\s+publish/i.test(toolInput.command);
+
+// Bypass mode: auto-allow all tools except publish commands
+// 使用显式 allow 而非 exit(1) fallback，避免 Codex 记录 hook error 日志
+if (process.env.CXV_BYPASS_PERMISSIONS === '1' && !isPublishCmd) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' },
+  }) + '\n');
+  process.exit(0);
+}
+
+// AskUserQuestion has its own dedicated hook (ask-bridge.js)
+if (toolName === 'AskUserQuestion') {
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse' } }) + '\n');
+  process.exit(0);
+}
+
+// These tools need explicit user approval via Web UI (mutating or external access).
+const APPROVAL_TOOLS = new Set(['Bash', 'Edit', 'Write', 'NotebookEdit', 'WebFetch', 'WebSearch']);
+if (!APPROVAL_TOOLS.has(toolName)) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' },
+  }) + '\n');
+  process.exit(0);
+}
+
+const TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+
+function postToViewer() {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ toolName, input: toolInput });
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: Number(port),
+      path: '/api/perm-hook',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          try {
+            resolve(JSON.parse(data));
+          } catch {
+            reject(new Error('Invalid response JSON'));
+          }
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.setTimeout(TIMEOUT_MS, () => {
+      req.destroy();
+      reject(new Error('Timeout'));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+
+try {
+  const data = await postToViewer();
+  const decision = data.decision === 'allow' ? 'allow' : 'deny';
+
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: decision,
+    },
+  };
+
+  // If denied, add a reason message
+  if (decision === 'deny') {
+    output.hookSpecificOutput.permissionDecisionReason = 'User denied via cx-viewer';
+  }
+
+  process.stdout.write(JSON.stringify(output) + '\n');
+  process.exit(0);
+} catch (err) {
+  // Server unreachable → fall back to terminal UI (not auto-allow)
+  // continue: true means "this hook has no decision, let Codex handle it normally"
+  process.stderr.write(`perm-bridge: ${err.message} (falling back to terminal UI)\n`);
+  process.stdout.write(JSON.stringify({ continue: true, suppressOutput: true }) + '\n');
+  process.exit(0);
+}

package/lib/plugin-loader.js

@@ -0,0 +1,161 @@
+import { readdirSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { LOG_DIR } from '../findcx.js';
+
+// 动态获取（LOG_DIR 可能在运行时被 setLogDir 修改）
+export function getPluginsDir() { return join(LOG_DIR, 'plugins'); }
+function getPrefsFilePath() { return join(LOG_DIR, 'preferences.json'); }
+const SHOULD_LOG = process.env.CXV_DEBUG_PLUGINS === '1';
+
+// Hook 类型定义
+const HOOK_TYPES = {
+  httpsOptions: 'waterfall',
+  localUrl: 'waterfall',
+  serverStarted: 'parallel',
+  serverStopping: 'parallel',
+  onNewEntry: 'parallel',
+};
+
+let _plugins = [];
+
+/**
+ * 扫描 LOG_DIR/plugins/ 目录，动态 import 每个 .js/.mjs 文件
+ */
+export async function loadPlugins() {
+  _plugins = [];
+
+  if (!existsSync(getPluginsDir())) return;
+
+  // 读取 disabledPlugins 列表
+  let disabledPlugins = [];
+  try {
+    if (existsSync(getPrefsFilePath())) {
+      const prefs = JSON.parse(readFileSync(getPrefsFilePath(), 'utf-8'));
+      if (Array.isArray(prefs.disabledPlugins)) {
+        disabledPlugins = prefs.disabledPlugins;
+      }
+    }
+  } catch { }
+
+  let files;
+  try {
+    files = readdirSync(getPluginsDir())
+      .filter(f => f.endsWith('.js') || f.endsWith('.mjs'))
+      .sort();
+  } catch {
+    return;
+  }
+
+  for (const file of files) {
+    const filePath = join(getPluginsDir(), file);
+    try {
+      const mod = await import(`file://${filePath}`);
+      const plugin = mod.default || mod;
+      const name = plugin.name || file;
+
+      if (disabledPlugins.includes(name)) {
+        if (SHOULD_LOG) console.error(`[CX Viewer] Plugin "${name}" is disabled, skipping.`);
+        continue;
+      }
+
+      if (plugin.hooks && typeof plugin.hooks === 'object') {
+        _plugins.push({ name, hooks: plugin.hooks, file });
+        if (SHOULD_LOG) console.error(`[CX Viewer] Plugin loaded: ${name} (${file})`);
+      }
+    } catch (err) {
+      if (SHOULD_LOG) console.error(`[CX Viewer] Failed to load plugin "${file}":`, err.message);
+    }
+  }
+}
+
+/**
+ * waterfall hook：串行管道执行，前一个的返回值传给下一个
+ */
+export async function runWaterfallHook(name, initialValue) {
+  let value = initialValue;
+  for (const plugin of _plugins) {
+    const hookFn = plugin.hooks[name];
+    if (typeof hookFn !== 'function') continue;
+    try {
+      const result = await hookFn(value);
+      if (result != null && typeof result === 'object') {
+        value = { ...value, ...result };
+      }
+    } catch (err) {
+      if (SHOULD_LOG) console.error(`[CX Viewer] Plugin "${plugin.name}" hook "${name}" error:`, err.message);
+    }
+  }
+  return value;
+}
+
+/**
+ * parallel hook：并行通知执行，返回值忽略
+ */
+export async function runParallelHook(name, context = {}) {
+  const tasks = [];
+  for (const plugin of _plugins) {
+    const hookFn = plugin.hooks[name];
+    if (typeof hookFn !== 'function') continue;
+    tasks.push(
+      Promise.resolve()
+        .then(() => hookFn(context))
+        .catch(err => {
+          if (SHOULD_LOG) console.error(`[CX Viewer] Plugin "${plugin.name}" hook "${name}" error:`, err.message);
+        })
+    );
+  }
+  await Promise.all(tasks);
+}
+
+/**
+ * 返回所有插件文件信息（含已禁用的），供 /api/plugins 使用
+ */
+export function getPluginsInfo() {
+  if (!existsSync(getPluginsDir())) return [];
+
+  let disabledPlugins = [];
+  try {
+    if (existsSync(getPrefsFilePath())) {
+      const prefs = JSON.parse(readFileSync(getPrefsFilePath(), 'utf-8'));
+      if (Array.isArray(prefs.disabledPlugins)) {
+        disabledPlugins = prefs.disabledPlugins;
+      }
+    }
+  } catch { }
+
+  let files;
+  try {
+    files = readdirSync(getPluginsDir())
+      .filter(f => f.endsWith('.js') || f.endsWith('.mjs'))
+      .sort();
+  } catch {
+    return [];
+  }
+
+  return files.map(file => {
+    const loaded = _plugins.find(p => p.file === file);
+    let name = file;
+
+    // 如果插件已加载，使用加载时的 name
+    if (loaded) {
+      name = loaded.name;
+    } else {
+      // 如果插件未加载（可能被禁用），尝试读取文件获取真实的 name
+      try {
+        const filePath = join(getPluginsDir(), file);
+        const content = readFileSync(filePath, 'utf-8');
+        // 简单匹配 name: 'xxx' 或 name: "xxx"
+        const match = content.match(/name\s*:\s*['"]([^'"]+)['"]/);
+        if (match) {
+          name = match[1];
+        }
+      } catch {
+        // 读取失败，使用文件名
+      }
+    }
+
+    const hooks = loaded ? Object.keys(loaded.hooks) : [];
+    const enabled = !disabledPlugins.includes(name);
+    return { name, file, hooks, enabled };
+  });
+}

package/lib/plugin-manager.js

@@ -0,0 +1,118 @@
+import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { tmpdir } from 'node:os';
+
+/**
+ * Upload plugin files from a file list.
+ * @param {string} pluginsDir - path to plugins directory
+ * @param {Array<{name: string, content: string}>} fileList - files to upload
+ * @returns {number} number of files written
+ * @throws {Error} on validation failure
+ */
+export function uploadPlugins(pluginsDir, fileList) {
+  if (!Array.isArray(fileList) || fileList.length === 0) {
+    throw Object.assign(new Error('No files provided'), { statusCode: 400 });
+  }
+  if (!existsSync(pluginsDir)) {
+    mkdirSync(pluginsDir, { recursive: true });
+  }
+  let written = 0;
+  for (const { name, content } of fileList) {
+    if (!name || typeof content !== 'string') continue;
+    const filename = name.replace(/.*[/\\]/, '');
+    if (!filename.endsWith('.js') && !filename.endsWith('.mjs')) {
+      throw Object.assign(new Error('Only .js or .mjs files are allowed'), { statusCode: 400 });
+    }
+    if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
+      throw Object.assign(new Error('Invalid file name'), { statusCode: 400 });
+    }
+    writeFileSync(join(pluginsDir, filename), content, 'utf-8');
+    written++;
+  }
+  return written;
+}
+
+/**
+ * Install a plugin by downloading from a URL.
+ * @param {string} pluginsDir - path to plugins directory
+ * @param {string} fileUrl - URL to download from
+ * @param {string} extractNameScript - path to lib/extract-plugin-name.mjs
+ * @returns {Promise<{filename: string}>} the saved filename
+ * @throws {Error} on validation or download failure
+ */
+export async function installPluginFromUrl(pluginsDir, fileUrl, extractNameScript) {
+  if (!fileUrl) {
+    throw Object.assign(new Error('URL is required'), { statusCode: 400 });
+  }
+  // Validate URL format
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(fileUrl);
+  } catch {
+    throw Object.assign(new Error('Invalid URL'), { statusCode: 400 });
+  }
+  if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+    throw Object.assign(new Error('Invalid URL'), { statusCode: 400 });
+  }
+
+  // Download remote file (5MB limit, 30s timeout)
+  const MAX_PLUGIN_SIZE = 5 * 1024 * 1024;
+  let content;
+  try {
+    const resp = await fetch(fileUrl, { signal: AbortSignal.timeout(30000) });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    const text = await resp.text();
+    if (text.length > MAX_PLUGIN_SIZE) throw new Error('File too large (max 5MB)');
+    content = text;
+  } catch (fetchErr) {
+    throw Object.assign(new Error('Failed to fetch: ' + fetchErr.message), { statusCode: 500 });
+  }
+
+  // Extract plugin name via subprocess import()
+  let saveName = '';
+  const tmpFile = join(tmpdir(), `cxv-install-${Date.now()}.mjs`);
+  writeFileSync(tmpFile, content, 'utf-8');
+  try {
+    const result = await new Promise((resolve, reject) => {
+      execFile('node', [extractNameScript, tmpFile], { timeout: 5000 }, (err, stdout) => {
+        if (err) return reject(err);
+        resolve(stdout);
+      });
+    });
+    const parsed = JSON.parse(result);
+    if (parsed.name) saveName = parsed.name;
+  } catch { }
+  try { unlinkSync(tmpFile); } catch { }
+
+  // Fallback: extract filename from URL path, excluding generic names
+  if (!saveName) {
+    const urlFilename = parsedUrl.pathname.split('/').pop();
+    if (urlFilename && (urlFilename.endsWith('.js') || urlFilename.endsWith('.mjs'))
+        && urlFilename !== 'index.js' && urlFilename !== 'index.mjs') {
+      saveName = urlFilename.replace(/\.(js|mjs)$/, '');
+    }
+  }
+  // Final fallback: use plugin-<timestamp>
+  if (!saveName) {
+    saveName = `plugin-${Date.now()}`;
+  }
+
+  let filename = (saveName.endsWith('.js') || saveName.endsWith('.mjs')) ? saveName : saveName + '.js';
+  // Safety check
+  if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
+    filename = `plugin-${Date.now()}.js`;
+  }
+  // Ensure plugins dir exists
+  if (!existsSync(pluginsDir)) {
+    mkdirSync(pluginsDir, { recursive: true });
+  }
+  // Deduplicate: append unique identifier for same-name files
+  if (existsSync(join(pluginsDir, filename))) {
+    const ext = filename.endsWith('.mjs') ? '.mjs' : '.js';
+    const base = filename.slice(0, -ext.length);
+    filename = `${base}-${Date.now()}${ext}`;
+  }
+  writeFileSync(join(pluginsDir, filename), content, 'utf-8');
+  return { filename };
+}

package/lib/proxy-env.js

@@ -0,0 +1,23 @@
+import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
+
+// 纯函数，从 env 中解析代理配置（可独立测试）
+export function resolveProxyConfig(env = process.env) {
+  const allProxy = env.all_proxy || env.ALL_PROXY;
+  return {
+    httpProxy: env.http_proxy || env.HTTP_PROXY || allProxy || undefined,
+    httpsProxy: env.https_proxy || env.HTTPS_PROXY || allProxy || undefined,
+    noProxy: env.no_proxy || env.NO_PROXY || undefined,
+  };
+}
+
+export function setupProxyEnv() {
+  const { httpProxy, httpsProxy, noProxy } = resolveProxyConfig();
+  if (!httpProxy && !httpsProxy) return;
+
+  setGlobalDispatcher(new EnvHttpProxyAgent({ httpProxy, httpsProxy, noProxy }));
+  if (process.env.CXV_DEBUG) {
+    console.error(`[CX Viewer] HTTP proxy: http=${httpProxy || '(none)'}, https=${httpsProxy || '(none)'}${noProxy ? `, no_proxy=${noProxy}` : ''}`);
+  }
+}
+
+setupProxyEnv();

package/lib/proxy-errors.js

@@ -0,0 +1,18 @@
+export function extractApiErrorMessage(status, errorText) {
+  try {
+    const errorJson = JSON.parse(errorText);
+    if (errorJson?.error?.message) return errorJson.error.message;
+    if (errorJson?.message) return errorJson.message;
+  } catch { }
+  return `API Error (${status}): ${String(errorText).slice(0, 200)}`;
+}
+
+export function formatProxyRequestError(err) {
+  let msg = err?.message || String(err);
+  if (err?.cause) {
+    msg += ` (${err.cause.message || err.cause.code || err.cause})`;
+  }
+  if (msg.includes('HEADERS_TIMEOUT')) msg = 'Upstream headers timeout';
+  if (msg.includes('BODY_TIMEOUT')) msg = 'Upstream body timeout';
+  return `[CX-Viewer Proxy] Request failed: ${msg}`;
+}

package/lib/sdk-adapter.js

@@ -0,0 +1,77 @@
+/**
+ * sdk-adapter.js — Convert Agent SDK messages to JSONL entry format.
+ *
+ * The frontend expects entries shaped like intercepted OpenAI API request/response pairs.
+ * This adapter converts SDKAssistantMessage objects into that format so the
+ * existing SSE pipeline and ChatView rendering work unchanged.
+ */
+
+// Minimal tool stubs — only used as fallback if SDK doesn't provide real tools
+const STUB_TOOLS = [
+  { name: 'Bash' }, { name: 'Edit' }, { name: 'Read' },
+  { name: 'Write' }, { name: 'Glob' }, { name: 'Agent' },
+];
+
+/**
+ * Convert an SDK assistant message + accumulated conversation into a JSONL entry.
+ *
+ * @param {object} assistantMsg — SDKAssistantMessage (has .message: BetaMessage)
+ * @param {Array} messages — Accumulated conversation messages [{role, content}]
+ * @param {string} model — Model name
+ * @param {string} projectName — Project name
+ * @param {object} [opts] — Additional options
+ * @param {string} [opts.timestamp] — Stable timestamp for dedup (same per turn)
+ * @param {boolean} [opts.inProgress] — Whether response is still streaming
+ * @param {string} [opts.requestId] — Request ID for in-progress entries
+ * @param {Array} [opts.tools] — Real tools list from SDK init message
+ * @returns {object} JSONL entry compatible with frontend expectations
+ */
+export function sdkToJSONLEntry(assistantMsg, messages, model, projectName, opts = {}) {
+  const respBody = assistantMsg?.message || null;
+  const entry = {
+    timestamp: opts.timestamp || new Date().toISOString(),
+    project: projectName || 'sdk',
+    url: 'https://api.openai.com/v1/chat/completions',
+    method: 'POST',
+    headers: {},
+    body: {
+      model: model || respBody?.model || 'gpt-4o',
+      system: [{ type: 'text', text: 'You are Codex' }],
+      tools: opts.tools || STUB_TOOLS,
+      messages: messages || [],
+      metadata: {},
+    },
+    response: opts.inProgress ? null : {
+      status: 200,
+      statusText: 'OK',
+      headers: {},
+      body: respBody,
+    },
+    duration: 0,
+    isStream: false,
+    mainAgent: true,
+  };
+
+  if (opts.inProgress) {
+    entry.inProgress = true;
+    entry.requestId = opts.requestId || `sdk_${Date.now()}`;
+  }
+
+  return entry;
+}
+
+/**
+ * Build a streaming status event payload.
+ */
+export function buildStreamingStatus(active, meta = {}) {
+  if (active) {
+    return {
+      active: true,
+      model: meta.model || null,
+      startTime: meta.startTime || Date.now(),
+      bytesReceived: 0,
+      chunksReceived: 0,
+    };
+  }
+  return { active: false };
+}