claude-runtime-sync 0.1.0

package/src/codex-plugin-bridge.js

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+
+/**
+ * Codex Plugin Bridge
+ *
+ * 读取 ~/.codex/plugins/claude-bridge/manifest.json，
+ * 将 Codex 事件映射为 Claude hooks 事件并执行 command hook。
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const BRIDGE_MANIFEST_RELATIVE_PATH = path.join('plugins', 'claude-bridge', 'manifest.json');
+
+const CODEX_EVENT_MAP = {
+  exec_approval_request: ['PermissionRequest'],
+  apply_patch_approval_request: ['PermissionRequest'],
+  request_user_input: ['PermissionRequest'],
+  task_started: ['TaskStarted'],
+  session_configured: ['TaskStarted'],
+  task_complete: ['TaskComplete'],
+  error: ['ToolError'],
+  warning: ['ToolError'],
+  turn_aborted: ['ToolError'],
+  stream_error: ['ToolError'],
+  mcp_startup_complete: ['MCPStartupComplete']
+};
+
+function parseArgs(argv) {
+  const options = {
+    codexHome: null,
+    projectRoot: null,
+    since: null,
+    watch: false,
+    pollMs: 600,
+    emitStop: false,
+    quiet: true
+  };
+
+  for (const arg of argv) {
+    if (arg === '--watch') {
+      options.watch = true;
+      continue;
+    }
+
+    if (arg === '--emit-stop') {
+      options.emitStop = true;
+      continue;
+    }
+
+    if (arg === '--verbose') {
+      options.quiet = false;
+      continue;
+    }
+
+    if (arg.startsWith('--codex-home=')) {
+      options.codexHome = path.resolve(arg.slice('--codex-home='.length));
+      continue;
+    }
+
+    if (arg.startsWith('--project-root=')) {
+      options.projectRoot = path.resolve(arg.slice('--project-root='.length));
+      continue;
+    }
+
+    if (arg.startsWith('--since=')) {
+      const raw = Number(arg.slice('--since='.length));
+      if (Number.isFinite(raw) && raw > 0) {
+        options.since = raw;
+      }
+      continue;
+    }
+
+    if (arg.startsWith('--poll-ms=')) {
+      const raw = Number(arg.slice('--poll-ms='.length));
+      if (Number.isFinite(raw) && raw >= 200) {
+        options.pollMs = raw;
+      }
+      continue;
+    }
+
+    throw new Error(`未知参数: ${arg}`);
+  }
+
+  return options;
+}
+
+function resolveCodexHome(overrideValue) {
+  if (overrideValue) {
+    return overrideValue;
+  }
+
+  if (process.env.CODEX_HOME && process.env.CODEX_HOME.trim()) {
+    return path.resolve(process.env.CODEX_HOME);
+  }
+
+  return path.join(os.homedir(), '.codex');
+}
+
+function readJsonIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  const raw = fs.readFileSync(filePath, 'utf8');
+  if (!raw.trim()) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${filePath} JSON 解析失败: ${error.message}`);
+  }
+}
+
+function readManifest(codexHome) {
+  const manifestPath = path.join(codexHome, BRIDGE_MANIFEST_RELATIVE_PATH);
+  const manifest = readJsonIfExists(manifestPath);
+  if (!manifest || typeof manifest !== 'object') {
+    return {
+      manifestPath,
+      plugins: [],
+      topHooks: []
+    };
+  }
+
+  return {
+    manifestPath,
+    plugins: Array.isArray(manifest.plugins) ? manifest.plugins : [],
+    topHooks: Array.isArray(manifest.topHooks) ? manifest.topHooks : []
+  };
+}
+
+function collectSessionFiles(sessionsRoot, sinceEpochSec) {
+  if (!fs.existsSync(sessionsRoot)) {
+    return [];
+  }
+
+  const files = [];
+  const stack = [sessionsRoot];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const entries = fs.readdirSync(current, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+
+      if (!entry.isFile() || !entry.name.endsWith('.jsonl')) {
+        continue;
+      }
+
+      if (sinceEpochSec) {
+        const stat = fs.statSync(fullPath);
+        const modifiedSec = Math.floor(stat.mtimeMs / 1000);
+        if (modifiedSec < sinceEpochSec) {
+          continue;
+        }
+      }
+
+      files.push(fullPath);
+    }
+  }
+
+  return files.sort((a, b) => a.localeCompare(b));
+}
+
+function parseCodexEvent(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (_) {
+    return null;
+  }
+
+  if (!parsed || typeof parsed !== 'object') {
+    return null;
+  }
+
+  if (parsed.type !== 'event_msg') {
+    return null;
+  }
+
+  const payload = parsed.payload;
+  if (!payload || typeof payload !== 'object' || typeof payload.type !== 'string') {
+    return null;
+  }
+
+  return {
+    rawType: payload.type,
+    payload
+  };
+}
+
+function mapEventNames(rawType) {
+  const mapped = CODEX_EVENT_MAP[rawType] || [];
+  return [...mapped, rawType];
+}
+
+function buildMatcherText(eventRecord) {
+  const payload = eventRecord.payload || {};
+
+  const parts = [eventRecord.rawType];
+  if (Array.isArray(payload.command)) {
+    parts.push(payload.command.join(' '));
+  }
+
+  if (typeof payload.reason === 'string') {
+    parts.push(payload.reason);
+  }
+
+  if (typeof payload.call_id === 'string') {
+    parts.push(payload.call_id);
+  }
+
+  return parts.join(' ');
+}
+
+function matchesRule(matcher, text) {
+  if (!matcher) {
+    return true;
+  }
+
+  try {
+    return new RegExp(matcher).test(text);
+  } catch (_) {
+    return false;
+  }
+}
+
+function safeStringValue(value) {
+  if (value == null) {
+    return '';
+  }
+
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+
+  return JSON.stringify(value);
+}
+
+function runHookCommand({ command, timeoutSec, contextEnv, quiet }) {
+  const result = spawnSync('bash', ['-lc', command], {
+    env: {
+      ...process.env,
+      ...contextEnv
+    },
+    stdio: quiet ? 'ignore' : 'inherit',
+    timeout: Math.max(1, timeoutSec) * 1000
+  });
+
+  return result.status === 0;
+}
+
+function getAllHookSources(manifest) {
+  return [...manifest.plugins, ...manifest.topHooks];
+}
+
+function executeEvent(manifest, eventRecord, projectRoot, quiet) {
+  const names = mapEventNames(eventRecord.rawType);
+  const matcherText = buildMatcherText(eventRecord);
+  const sources = getAllHookSources(manifest);
+
+  for (const source of sources) {
+    const events = Array.isArray(source.events) ? source.events : [];
+
+    for (const eventDef of events) {
+      if (!eventDef || typeof eventDef.eventName !== 'string') {
+        continue;
+      }
+
+      if (!names.includes(eventDef.eventName)) {
+        continue;
+      }
+
+      if (!matchesRule(eventDef.matcher, matcherText)) {
+        continue;
+      }
+
+      const commands = Array.isArray(eventDef.commands) ? eventDef.commands : [];
+      for (const commandDef of commands) {
+        if (!commandDef || typeof commandDef.command !== 'string' || !commandDef.command.trim()) {
+          continue;
+        }
+
+        const timeout = Number.isFinite(commandDef.timeout) ? Number(commandDef.timeout) : 10;
+        runHookCommand({
+          command: commandDef.command,
+          timeoutSec: timeout,
+          quiet,
+          contextEnv: {
+            CLAUDE_PLUGIN_ROOT: source.rootPath || '',
+            CLAUDE_PROJECT_ROOT: projectRoot || '',
+            CRS_EVENT_TYPE: names[0],
+            CRS_EVENT_RAW_TYPE: eventRecord.rawType,
+            CRS_EVENT_MATCHER_TEXT: matcherText,
+            CRS_EVENT_REASON: safeStringValue(eventRecord.payload.reason),
+            CRS_CALL_ID: safeStringValue(eventRecord.payload.call_id)
+          }
+        });
+      }
+    }
+  }
+}
+
+function processSessionFile(filePath, state, manifest, projectRoot, quiet) {
+  let currentOffset = state.offsets.get(filePath) || 0;
+  let remainder = state.remainders.get(filePath) || '';
+
+  const stat = fs.statSync(filePath);
+  if (stat.size < currentOffset) {
+    currentOffset = 0;
+    remainder = '';
+  }
+
+  if (stat.size === currentOffset) {
+    return;
+  }
+
+  const fd = fs.openSync(filePath, 'r');
+  const chunkSize = stat.size - currentOffset;
+  const buffer = Buffer.alloc(chunkSize);
+  fs.readSync(fd, buffer, 0, chunkSize, currentOffset);
+  fs.closeSync(fd);
+
+  const text = `${remainder}${buffer.toString('utf8')}`;
+  const lines = text.split('\n');
+  remainder = lines.pop() || '';
+
+  for (const line of lines) {
+    if (!line.trim()) {
+      continue;
+    }
+
+    const eventRecord = parseCodexEvent(line);
+    if (!eventRecord) {
+      continue;
+    }
+
+    executeEvent(manifest, eventRecord, projectRoot, quiet);
+  }
+
+  state.offsets.set(filePath, stat.size);
+  state.remainders.set(filePath, remainder);
+}
+
+function runOnce(options) {
+  const codexHome = resolveCodexHome(options.codexHome);
+  const manifest = readManifest(codexHome);
+  const sessionsRoot = path.join(codexHome, 'sessions');
+  const files = collectSessionFiles(sessionsRoot, options.since);
+
+  const state = {
+    offsets: new Map(),
+    remainders: new Map()
+  };
+
+  for (const filePath of files) {
+    processSessionFile(filePath, state, manifest, options.projectRoot, options.quiet);
+  }
+
+  if (options.emitStop) {
+    executeEvent(manifest, { rawType: 'Stop', payload: {} }, options.projectRoot, options.quiet);
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function watch(options) {
+  const codexHome = resolveCodexHome(options.codexHome);
+  const manifest = readManifest(codexHome);
+  const sessionsRoot = path.join(codexHome, 'sessions');
+
+  const state = {
+    offsets: new Map(),
+    remainders: new Map()
+  };
+
+  let stopping = false;
+  const requestStop = () => {
+    stopping = true;
+  };
+
+  process.on('SIGINT', requestStop);
+  process.on('SIGTERM', requestStop);
+
+  while (!stopping) {
+    const files = collectSessionFiles(sessionsRoot, options.since);
+    for (const filePath of files) {
+      if (stopping) {
+        break;
+      }
+      processSessionFile(filePath, state, manifest, options.projectRoot, options.quiet);
+    }
+
+    await sleep(options.pollMs);
+  }
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.watch) {
+    await watch(options);
+    return;
+  }
+
+  runOnce(options);
+}
+
+main().catch(error => {
+  console.error(`codex-plugin-bridge 运行失败: ${error.message}`);
+  process.exit(1);
+});

package/src/install-codex-zsh-hook.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const mode = process.argv[2] || 'install';
+const zshrcArg = process.argv[3];
+
+if (!['install', 'remove'].includes(mode)) {
+  console.error('Usage: node scripts/install-codex-zsh-hook.js [install|remove] [zshrc_path]');
+  process.exit(1);
+}
+
+function resolveCodexHome() {
+  if (process.env.CODEX_HOME && process.env.CODEX_HOME.trim()) {
+    return path.resolve(process.env.CODEX_HOME);
+  }
+
+  return path.join(os.homedir(), '.codex');
+}
+
+function expandPath(inputPath) {
+  if (!inputPath) {
+    return path.join(os.homedir(), '.zshrc');
+  }
+
+  if (inputPath === '~') {
+    return os.homedir();
+  }
+
+  if (inputPath.startsWith('~/')) {
+    return path.join(os.homedir(), inputPath.slice(2));
+  }
+
+  return path.resolve(inputPath);
+}
+
+function readText(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return '';
+  }
+
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function writeText(filePath, text) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, text, 'utf8');
+}
+
+function findManagedBlock(text, startMarker, endMarker) {
+  const start = text.indexOf(startMarker);
+  if (start === -1) {
+    return null;
+  }
+
+  const endStart = text.indexOf(endMarker, start);
+  if (endStart === -1) {
+    return null;
+  }
+
+  let end = endStart + endMarker.length;
+  if (text[end] === '\n') {
+    end += 1;
+  }
+
+  return { start, end };
+}
+
+function copyScript(sourcePath, targetPath) {
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error(`未找到脚本: ${sourcePath}`);
+  }
+
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+  fs.chmodSync(targetPath, 0o755);
+}
+
+function installHelpers(codexHome) {
+  const syncSourcePath = path.join(__dirname, 'claude-runtime-sync.js');
+  const baseSyncSourcePath = path.join(__dirname, 'sync-claude-all-to-codex.js');
+  const bridgeSourcePath = path.join(__dirname, 'codex-plugin-bridge.js');
+
+  const syncTargetPath = path.join(codexHome, 'scripts', 'sync-claude-to-codex.js');
+  const baseSyncTargetPath = path.join(codexHome, 'scripts', 'sync-claude-all-to-codex.js');
+  const bridgeTargetPath = path.join(codexHome, 'scripts', 'codex-plugin-bridge.js');
+
+  copyScript(syncSourcePath, syncTargetPath);
+  copyScript(baseSyncSourcePath, baseSyncTargetPath);
+  copyScript(bridgeSourcePath, bridgeTargetPath);
+
+  return {
+    syncTargetPath,
+    baseSyncTargetPath,
+    bridgeTargetPath
+  };
+}
+
+const codexHome = resolveCodexHome();
+const zshrcPath = expandPath(zshrcArg);
+const startMarker = '# >>> codex-claude-sync >>>';
+const endMarker = '# <<< codex-claude-sync <<<';
+
+const block = [
+  '# >>> codex-claude-sync >>>',
+  '# Auto-sync ~/.claude (+ project .claude) into Codex before launching Codex.',
+  '# Set CODEX_SYNC_DISABLE=1 to temporarily skip sync.',
+  '# Set CODEX_PLUGIN_BRIDGE_DISABLE=1 to temporarily disable plugin hooks bridge.',
+  'codex() {',
+  '  local first_arg="${1-}"',
+  '  local codex_home',
+  '  local sync_script',
+  '  local bridge_script',
+  '  local bridge_pid=""',
+  '  local bridge_since=""',
+  '',
+  '  case "$first_arg" in',
+  '    -h|--help|-V|--version|completion|login|logout|features)',
+  '      command codex "$@"',
+  '      return $?',
+  '      ;;',
+  '  esac',
+  '',
+  '  codex_home="${CODEX_HOME:-$HOME/.codex}"',
+  '  sync_script="$codex_home/scripts/sync-claude-to-codex.js"',
+  '  bridge_script="$codex_home/scripts/codex-plugin-bridge.js"',
+  '',
+  '  if [[ "${CODEX_SYNC_DISABLE:-0}" != "1" ]]; then',
+  '    if command -v node >/dev/null 2>&1 && [[ -f "$sync_script" ]]; then',
+  '      node "$sync_script" --check >/dev/null 2>&1 || node "$sync_script" >/dev/null 2>&1',
+  '    fi',
+  '  fi',
+  '',
+  '  if [[ "${CODEX_PLUGIN_BRIDGE_DISABLE:-0}" != "1" ]]; then',
+  '    if command -v node >/dev/null 2>&1 && [[ -f "$bridge_script" ]]; then',
+  '      bridge_since="$(date +%s)"',
+  '      node "$bridge_script" --watch --since="$bridge_since" --codex-home="$codex_home" --project-root="$PWD" >/dev/null 2>&1 &',
+  '      bridge_pid="$!"',
+  '    fi',
+  '  fi',
+  '',
+  '  command codex "$@"',
+  '  local codex_rc=$?',
+  '',
+  '  if [[ -n "$bridge_pid" ]]; then',
+  '    node "$bridge_script" --emit-stop --codex-home="$codex_home" --project-root="$PWD" >/dev/null 2>&1 || true',
+  '    kill "$bridge_pid" >/dev/null 2>&1 || true',
+  '    wait "$bridge_pid" >/dev/null 2>&1 || true',
+  '  fi',
+  '',
+  '  return $codex_rc',
+  '}',
+  '# <<< codex-claude-sync <<<'
+].join('\n');
+
+const currentText = readText(zshrcPath);
+
+if (mode === 'install') {
+  const helperPaths = installHelpers(codexHome);
+  const existing = findManagedBlock(currentText, startMarker, endMarker);
+  let newText;
+
+  if (existing) {
+    const before = currentText.slice(0, existing.start).replace(/\s*$/, '');
+    const after = currentText.slice(existing.end).replace(/^\s*/, '');
+    const parts = [before, block, after].filter(Boolean);
+    newText = `${parts.join('\n\n')}\n`;
+  } else if (currentText.trim()) {
+    newText = `${currentText.replace(/\s*$/, '')}\n\n${block}\n`;
+  } else {
+    newText = `${block}\n`;
+  }
+
+  writeText(zshrcPath, newText);
+  console.log(`Installed Codex sync helper to ${helperPaths.syncTargetPath}`);
+  console.log(`Installed Codex base sync helper to ${helperPaths.baseSyncTargetPath}`);
+  console.log(`Installed Codex plugin bridge helper to ${helperPaths.bridgeTargetPath}`);
+  console.log(`Installed Codex sync hook in ${zshrcPath}`);
+  process.exit(0);
+}
+
+const existing = findManagedBlock(currentText, startMarker, endMarker);
+if (!existing) {
+  console.log(`No hook block found in ${zshrcPath}`);
+  process.exit(0);
+}
+
+const before = currentText.slice(0, existing.start).replace(/\s*$/, '');
+const after = currentText.slice(existing.end).replace(/^\s*/, '');
+const parts = [before, after].filter(Boolean);
+const newText = parts.length > 0 ? `${parts.join('\n\n')}\n` : '';
+
+writeText(zshrcPath, newText);
+console.log(`Removed Codex sync hook from ${zshrcPath}`);