@sanqianx/ai-coding-event-bridge-console 0.7.2 → 0.7.3

package/src/bridge/connectors/claude-code/hook-entry.js

@@ -1,45 +1,45 @@
-'use strict';
-
-const { normalizeClaudeCode } = require('../../core/normalizer');
-const { resolveRepoContext } = require('../../core/repo-context');
-const { journalFor } = require('../../core/journal-router');
-const { isCaptureDisabled, captureDisabledResult } = require('../capture-guard');
-const { notifyConsumers } = require('./notify');
-
-/**
- * Durable-first Claude Code hook processing. The event is appended and fsynced
- * to the Bridge journal before any consumer notification is attempted, and the
- * whole entry fails open: a broken Bridge must never block the AI client.
- * Internal host SDK sessions (AI_CODING_EVENT_BRIDGE_CAPTURE=0) are ignored
- * before any Git/journal work happens.
- */
-async function main({ home, payload, source }) {
-  if (isCaptureDisabled(process.env, payload)) {
-    return captureDisabledResult();
-  }
-  if (!payload || typeof payload !== 'object') {
-    return { status: 'ignored' };
-  }
-  const event = normalizeClaudeCode(payload, source);
-  if (!event) {
-    return { status: 'ignored' };
-  }
-  const cwd = typeof payload.cwd === 'string' && payload.cwd ? payload.cwd : process.cwd();
-  const repo = await resolveRepoContext(cwd);
-  const journal = journalFor(home, event.repoIdentity || repo.repoIdentity);
-  const appended = await journal.appendConversationEvent({
-    ...event,
-    repoIdentity: event.repoIdentity || repo.repoIdentity,
-    projectPath: event.projectPath || repo.projectPath,
-    branch: event.branch || repo.branch,
-    headAtCapture: event.headAtCapture || repo.headAtCapture
-  });
-  await notifyConsumers(home, { sequence: appended.sequence, eventId: appended.eventId });
-  return { status: 'captured', sequence: appended.sequence, turnId: appended.turnId };
-}
-
-function mainFailOpen({ home, payload, source }) {
-  return main({ home, payload, source }).catch(() => ({ status: 'fail-open' }));
-}
-
-module.exports = { main, mainFailOpen };
+'use strict';
+
+const { normalizeClaudeCode } = require('../../core/normalizer');
+const { resolveRepoContext } = require('../../core/repo-context');
+const { journalFor } = require('../../core/journal-router');
+const { isCaptureDisabled, captureDisabledResult } = require('../capture-guard');
+const { notifyConsumers } = require('./notify');
+
+/**
+ * Durable-first Claude Code hook processing. The event is appended and fsynced
+ * to the Bridge journal before any consumer notification is attempted, and the
+ * whole entry fails open: a broken Bridge must never block the AI client.
+ * Internal host SDK sessions (AI_CODING_EVENT_BRIDGE_CAPTURE=0) are ignored
+ * before any Git/journal work happens.
+ */
+async function main({ home, payload, source }) {
+  if (isCaptureDisabled(process.env, payload)) {
+    return captureDisabledResult();
+  }
+  if (!payload || typeof payload !== 'object') {
+    return { status: 'ignored' };
+  }
+  const event = normalizeClaudeCode(payload, source);
+  if (!event) {
+    return { status: 'ignored' };
+  }
+  const cwd = typeof payload.cwd === 'string' && payload.cwd ? payload.cwd : process.cwd();
+  const repo = await resolveRepoContext(cwd);
+  const journal = journalFor(home, event.repoIdentity || repo.repoIdentity);
+  const appended = await journal.appendConversationEvent({
+    ...event,
+    repoIdentity: event.repoIdentity || repo.repoIdentity,
+    projectPath: event.projectPath || repo.projectPath,
+    branch: event.branch || repo.branch,
+    headAtCapture: event.headAtCapture || repo.headAtCapture
+  });
+  await notifyConsumers(home, { sequence: appended.sequence, eventId: appended.eventId });
+  return { status: 'captured', sequence: appended.sequence, turnId: appended.turnId };
+}
+
+function mainFailOpen({ home, payload, source }) {
+  return main({ home, payload, source }).catch(() => ({ status: 'fail-open' }));
+}
+
+module.exports = { main, mainFailOpen };

package/src/bridge/connectors/claude-code/notify.js

@@ -1,57 +1,57 @@
-'use strict';
-
-const http = require('http');
-const https = require('https');
-const { ConsumerRegistry } = require('../../core/consumer-registry');
-
-function postJson(url, body, timeoutMs = 1500) {
-  return new Promise((resolve) => {
-    try {
-      const target = new URL(url);
-      const mod = target.protocol === 'https:' ? https : http;
-      const data = JSON.stringify(body);
-      const req = mod.request(
-        {
-          hostname: target.hostname,
-          port: target.port || (target.protocol === 'https:' ? 443 : 80),
-          path: `${target.pathname}${target.search}`,
-          method: 'POST',
-          headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(data) },
-          timeout: timeoutMs
-        },
-        (res) => {
-          res.resume();
-          res.on('end', () => resolve({ ok: res.statusCode && res.statusCode < 500 }));
-        }
-      );
-      req.on('timeout', () => {
-        req.destroy();
-        resolve({ ok: false });
-      });
-      req.on('error', () => resolve({ ok: false }));
-      req.end(data);
-    } catch (_) {
-      resolve({ ok: false });
-    }
-  });
-}
-
-/**
- * Best-effort wake-up for consumers that registered a notifyUrl. Always runs
- * after the durable append; failures never propagate to the AI client.
- */
-async function notifyConsumers(home, info) {
-  try {
-    const registry = new ConsumerRegistry(home);
-    const consumers = await registry.getConsumers();
-    const urls = consumers
-      .map((consumer) => consumer.meta && consumer.meta.notifyUrl)
-      .filter((url) => typeof url === 'string' && url);
-    await Promise.all(urls.map((url) => postJson(url, info)));
-    return { notified: urls.length };
-  } catch (_) {
-    return { notified: 0 };
-  }
-}
-
-module.exports = { notifyConsumers, postJson };
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const { ConsumerRegistry } = require('../../core/consumer-registry');
+
+function postJson(url, body, timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    try {
+      const target = new URL(url);
+      const mod = target.protocol === 'https:' ? https : http;
+      const data = JSON.stringify(body);
+      const req = mod.request(
+        {
+          hostname: target.hostname,
+          port: target.port || (target.protocol === 'https:' ? 443 : 80),
+          path: `${target.pathname}${target.search}`,
+          method: 'POST',
+          headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(data) },
+          timeout: timeoutMs
+        },
+        (res) => {
+          res.resume();
+          res.on('end', () => resolve({ ok: res.statusCode && res.statusCode < 500 }));
+        }
+      );
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({ ok: false });
+      });
+      req.on('error', () => resolve({ ok: false }));
+      req.end(data);
+    } catch (_) {
+      resolve({ ok: false });
+    }
+  });
+}
+
+/**
+ * Best-effort wake-up for consumers that registered a notifyUrl. Always runs
+ * after the durable append; failures never propagate to the AI client.
+ */
+async function notifyConsumers(home, info) {
+  try {
+    const registry = new ConsumerRegistry(home);
+    const consumers = await registry.getConsumers();
+    const urls = consumers
+      .map((consumer) => consumer.meta && consumer.meta.notifyUrl)
+      .filter((url) => typeof url === 'string' && url);
+    await Promise.all(urls.map((url) => postJson(url, info)));
+    return { notified: urls.length };
+  } catch (_) {
+    return { notified: 0 };
+  }
+}
+
+module.exports = { notifyConsumers, postJson };

package/src/bridge/connectors/codex/cursor-store.js

@@ -1,83 +1,83 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { writeJsonAtomicSync, readJsonIfExists, ensureDirSync } = require('../../core/fs-utils');
-
-/**
- * Atomic per-session cursor state. One JSON file per Codex session under
- * <home>/cursors/codex/, written via rename so a crash never corrupts it.
- * Cursor v2 stores an independent offset and workspace context for every
- * rollout file. A v1 cursor is upgraded in memory without resetting its
- * consumed offset, so discovering a continuation file never replays history.
- */
-const CURSOR_SCHEMA = 'codex-cursor/v2';
-
-function fileState(state = {}) {
-  return {
-    filePath: state.filePath,
-    byteOffset: Number.isInteger(state.byteOffset) && state.byteOffset >= 0 ? state.byteOffset : 0,
-    lastRecordKey: state.lastRecordKey || null,
-    activeCwd: state.activeCwd || null,
-    repoIdentity: state.repoIdentity || null,
-    projectPath: state.projectPath || null,
-    branch: state.branch || null,
-    headAtCapture: state.headAtCapture || null
-  };
-}
-
-function normalizeCursor(sessionId, state) {
-  const normalized = { schema: CURSOR_SCHEMA, sessionId: String(sessionId), files: {} };
-  if (!state || typeof state !== 'object') return normalized;
-
-  if (state.schema === CURSOR_SCHEMA && state.files && typeof state.files === 'object') {
-    for (const [key, value] of Object.entries(state.files)) {
-      if (!value || typeof value !== 'object' || typeof value.filePath !== 'string') continue;
-      normalized.files[key] = fileState(value);
-    }
-    return normalized;
-  }
-
-  // v1 compatibility: preserve the exact consumed offset and context. The
-  // caller supplies the canonical key after resolving the legacy file path.
-  if (typeof state.filePath === 'string' && state.filePath) {
-    normalized.legacyFile = fileState(state);
-  }
-  return normalized;
-}
-
-class CodexCursorStore {
-  constructor(homeDir) {
-    this.dir = path.join(homeDir, 'cursors', 'codex');
-    ensureDirSync(this.dir);
-  }
-
-  _fileFor(sessionId) {
-    const safe = String(sessionId).replace(/[^A-Za-z0-9._-]/g, '_');
-    return path.join(this.dir, `${safe}.json`);
-  }
-
-  read(sessionId) {
-    return normalizeCursor(sessionId, readJsonIfExists(this._fileFor(sessionId)));
-  }
-
-  write(sessionId, state) {
-    const normalized = normalizeCursor(sessionId, state);
-    writeJsonAtomicSync(this._fileFor(sessionId), {
-      schema: CURSOR_SCHEMA,
-      sessionId: normalized.sessionId,
-      files: normalized.files,
-      updatedAt: new Date().toISOString()
-    });
-  }
-
-  clear(sessionId) {
-    try {
-      fs.rmSync(this._fileFor(sessionId), { force: true });
-    } catch (_) {
-      // Already gone.
-    }
-  }
-}
-
-module.exports = { CodexCursorStore, CURSOR_SCHEMA, normalizeCursor };
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { writeJsonAtomicSync, readJsonIfExists, ensureDirSync } = require('../../core/fs-utils');
+
+/**
+ * Atomic per-session cursor state. One JSON file per Codex session under
+ * <home>/cursors/codex/, written via rename so a crash never corrupts it.
+ * Cursor v2 stores an independent offset and workspace context for every
+ * rollout file. A v1 cursor is upgraded in memory without resetting its
+ * consumed offset, so discovering a continuation file never replays history.
+ */
+const CURSOR_SCHEMA = 'codex-cursor/v2';
+
+function fileState(state = {}) {
+  return {
+    filePath: state.filePath,
+    byteOffset: Number.isInteger(state.byteOffset) && state.byteOffset >= 0 ? state.byteOffset : 0,
+    lastRecordKey: state.lastRecordKey || null,
+    activeCwd: state.activeCwd || null,
+    repoIdentity: state.repoIdentity || null,
+    projectPath: state.projectPath || null,
+    branch: state.branch || null,
+    headAtCapture: state.headAtCapture || null
+  };
+}
+
+function normalizeCursor(sessionId, state) {
+  const normalized = { schema: CURSOR_SCHEMA, sessionId: String(sessionId), files: {} };
+  if (!state || typeof state !== 'object') return normalized;
+
+  if (state.schema === CURSOR_SCHEMA && state.files && typeof state.files === 'object') {
+    for (const [key, value] of Object.entries(state.files)) {
+      if (!value || typeof value !== 'object' || typeof value.filePath !== 'string') continue;
+      normalized.files[key] = fileState(value);
+    }
+    return normalized;
+  }
+
+  // v1 compatibility: preserve the exact consumed offset and context. The
+  // caller supplies the canonical key after resolving the legacy file path.
+  if (typeof state.filePath === 'string' && state.filePath) {
+    normalized.legacyFile = fileState(state);
+  }
+  return normalized;
+}
+
+class CodexCursorStore {
+  constructor(homeDir) {
+    this.dir = path.join(homeDir, 'cursors', 'codex');
+    ensureDirSync(this.dir);
+  }
+
+  _fileFor(sessionId) {
+    const safe = String(sessionId).replace(/[^A-Za-z0-9._-]/g, '_');
+    return path.join(this.dir, `${safe}.json`);
+  }
+
+  read(sessionId) {
+    return normalizeCursor(sessionId, readJsonIfExists(this._fileFor(sessionId)));
+  }
+
+  write(sessionId, state) {
+    const normalized = normalizeCursor(sessionId, state);
+    writeJsonAtomicSync(this._fileFor(sessionId), {
+      schema: CURSOR_SCHEMA,
+      sessionId: normalized.sessionId,
+      files: normalized.files,
+      updatedAt: new Date().toISOString()
+    });
+  }
+
+  clear(sessionId) {
+    try {
+      fs.rmSync(this._fileFor(sessionId), { force: true });
+    } catch (_) {
+      // Already gone.
+    }
+  }
+}
+
+module.exports = { CodexCursorStore, CURSOR_SCHEMA, normalizeCursor };