@sanqianx/ai-coding-event-bridge-console 0.5.1 → 0.6.0

package/src/bridge/installers/zcode/installer.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { ensureRuntimeHome } = require('../../core/runtime-home');
+const { ConsumerRegistry } = require('../../core/consumer-registry');
+const { readJsonIfExists, writeJsonAtomicSync } = require('../../core/fs-utils');
+
+const HOOK_EVENTS = ['UserPromptSubmit', 'Stop'];
+
+// ZCode configuration-file hooks are disabled by default: the runner only
+// exists when hooks.enabled is true (or a plugin contributes hooks, which we
+// must not rely on). The managed entries therefore force it on; uninstall
+// leaves the flag alone because third-party config hooks may depend on it.
+class InstallerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'InstallerError';
+  }
+}
+
+function shimPathFor(homeDir) {
+  return path.join(homeDir, 'bin', 'bridge-hook.cjs');
+}
+
+// process hooks (argument vector, no shell) are the portable form; bare
+// `node` survives Node upgrades, unlike a baked-in absolute executable path.
+function managedHook(shimPath) {
+  return { type: 'process', command: 'node', args: [shimPath], timeoutMs: 15000 };
+}
+
+function isManagedHook(hook, shimPath) {
+  if (!hook || typeof hook !== 'object') return false;
+  if (hook.type === 'process') {
+    return Array.isArray(hook.args) && hook.args.some((arg) => typeof arg === 'string' && arg.includes(shimPath));
+  }
+  return typeof hook.command === 'string' && hook.command.includes(shimPath);
+}
+
+function readConfig(configFile) {
+  const config = readJsonIfExists(configFile);
+  if (config === null) {
+    if (fs.existsSync(configFile)) {
+      throw new InstallerError(`config file is not valid JSON: ${configFile}`);
+    }
+    return {};
+  }
+  if (typeof config !== 'object' || config === null || Array.isArray(config)) {
+    throw new InstallerError(`config file must contain a JSON object: ${configFile}`);
+  }
+  return config;
+}
+
+function eventsOf(config) {
+  if (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) {
+    config.hooks = {};
+  }
+  if (!config.hooks.events || typeof config.hooks.events !== 'object' || Array.isArray(config.hooks.events)) {
+    config.hooks.events = {};
+  }
+  return config.hooks.events;
+}
+
+function upsertManagedEntries(config, shimPath) {
+  const events = eventsOf(config);
+  const changed = [];
+  for (const eventName of HOOK_EVENTS) {
+    if (!Array.isArray(events[eventName])) {
+      events[eventName] = [];
+    }
+    const alreadyManaged = events[eventName].some(
+      (group) => group && Array.isArray(group.hooks) && group.hooks.some((hook) => isManagedHook(hook, shimPath))
+    );
+    if (alreadyManaged) continue;
+    events[eventName].push({ hooks: [managedHook(shimPath)] });
+    changed.push(eventName);
+  }
+  if (config.hooks.enabled !== true) {
+    config.hooks.enabled = true;
+  }
+  return changed;
+}
+
+function removeManagedEntries(config, shimPath) {
+  const removed = [];
+  for (const eventName of Object.keys(config.hooks.events)) {
+    const groups = config.hooks.events[eventName];
+    if (!Array.isArray(groups)) continue;
+    const kept = groups.filter(
+      (group) =>
+        !(group && Array.isArray(group.hooks) && group.hooks.some((hook) => isManagedHook(hook, shimPath)))
+    );
+    if (kept.length !== groups.length) removed.push(eventName);
+    if (kept.length === 0) {
+      delete config.hooks.events[eventName];
+    } else {
+      config.hooks.events[eventName] = kept;
+    }
+  }
+  return removed;
+}
+
+// Host-level consumer registration is owned by the host; the installer mutates
+// the registry only on explicit opt-in (same contract as the other connectors).
+async function installZcodeHook({ homeDir, consumerName, consumerMeta = {}, registerConsumer = false, configFile, version } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = configFile || path.join(os.homedir(), '.zcode', 'cli', 'config.json');
+  const runtime = await ensureRuntimeHome({ homeDir: home, version });
+  const registry = new ConsumerRegistry(home);
+  if (consumerName && registerConsumer) {
+    await registry.registerConsumer(consumerName, consumerMeta);
+  }
+  const config = readConfig(target);
+  const added = upsertManagedEntries(config, shimPathFor(home));
+  writeJsonAtomicSync(target, config);
+  return { added, configFile: target, runtime, consumers: (await registry.getConsumers()).map((c) => c.name) };
+}
+
+async function statusZcodeHook({ homeDir, configFile } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = configFile || path.join(os.homedir(), '.zcode', 'cli', 'config.json');
+  const config = readConfig(target);
+  const events = config.hooks && typeof config.hooks === 'object' ? config.hooks.events || {} : {};
+  const shimPath = shimPathFor(home);
+  const managedEvents = [];
+  let thirdPartyCount = 0;
+  for (const eventName of Object.keys(events)) {
+    const groups = events[eventName];
+    if (!Array.isArray(groups)) continue;
+    let hasManaged = false;
+    for (const group of groups) {
+      for (const hook of (group && group.hooks) || []) {
+        if (isManagedHook(hook, shimPath)) {
+          hasManaged = true;
+        } else {
+          thirdPartyCount++;
+        }
+      }
+    }
+    if (hasManaged) managedEvents.push(eventName);
+  }
+  const registry = new ConsumerRegistry(home);
+  return {
+    installed:
+      HOOK_EVENTS.every((eventName) => managedEvents.includes(eventName)) &&
+      Boolean(config.hooks && config.hooks.enabled),
+    managedEvents,
+    thirdPartyCount,
+    consumers: (await registry.getConsumers()).map((c) => c.name)
+  };
+}
+
+async function repairZcodeHook({ homeDir, consumerName, consumerMeta = {}, registerConsumer = false, configFile, version } = {}) {
+  return installZcodeHook({ homeDir, consumerName, consumerMeta, registerConsumer, configFile, version });
+}
+
+async function uninstallZcodeHook({ homeDir, consumerName, unregisterConsumer = false, configFile } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = configFile || path.join(os.homedir(), '.zcode', 'cli', 'config.json');
+  const registry = new ConsumerRegistry(home);
+  const config = readConfig(target);
+  const removed = config.hooks && config.hooks.events ? removeManagedEntries(config, shimPathFor(home)) : [];
+  writeJsonAtomicSync(target, config);
+  let consumerUnregistered = false;
+  if (consumerName && unregisterConsumer) {
+    await registry.unregisterConsumer(consumerName);
+    consumerUnregistered = true;
+  }
+  return {
+    removed: true,
+    removedEvents: removed,
+    configFile: target,
+    consumerUnregistered,
+    consumers: (await registry.getConsumers()).map((c) => c.name)
+  };
+}
+
+module.exports = {
+  HOOK_EVENTS,
+  InstallerError,
+  installZcodeHook,
+  statusZcodeHook,
+  repairZcodeHook,
+  uninstallZcodeHook,
+  managedHook,
+  isManagedHook
+};

package/src/bridge/query/conversation-query.js

@@ -0,0 +1,194 @@
+'use strict';
+
+const path = require('path');
+const crypto = require('crypto');
+const { Journal } = require('../core/journal');
+const { repoIdentityKey } = require('../core/repo-context');
+
+/**
+ * Headless conversation query over the durable journal. This is the controlled
+ * business query surface: it may return full user/assistant bodies, supports
+ * cursor pagination for virtualized UIs, and never depends on a host database.
+ */
+class ConversationQuery {
+  constructor({ journalDir, journal } = {}) {
+    this.journal = journal || new Journal(journalDir);
+  }
+
+  async _events() {
+    return this.journal.readEvents({});
+  }
+
+  _isConversationEvent(record) {
+    return (
+      record.schema === 'ai-coding-event/v1'
+      && (record.eventType === 'user_prompt' || record.eventType === 'assistant_response')
+    );
+  }
+
+  async listProjects() {
+    const events = (await this._events()).filter(e => this._isConversationEvent(e) && repoIdentityKey(e.repoIdentity));
+    const byProject = new Map();
+    for (const event of events) {
+      const key = repoIdentityKey(event.repoIdentity);
+      const entry = byProject.get(key) || {
+        repoIdentity: event.repoIdentity,
+        projectPath: event.projectPath || null,
+        sources: new Set(),
+        eventCount: 0,
+        lastSequence: 0,
+        lastCapturedAt: null
+      };
+      entry.sources.add(event.source);
+      entry.eventCount += 1;
+      if (event.sequence > entry.lastSequence) {
+        entry.lastSequence = event.sequence;
+        entry.lastCapturedAt = event.capturedAt || null;
+      }
+      byProject.set(key, entry);
+    }
+    return [...byProject.values()]
+      .map(entry => ({ ...entry, sources: [...entry.sources] }))
+      .sort((a, b) => b.lastSequence - a.lastSequence);
+  }
+
+  async listSessions({ project } = {}) {
+    const projectKey = project === undefined || project === null ? null : repoIdentityKey(project) || project;
+    const events = (await this._events()).filter(
+      e => this._isConversationEvent(e) && (!projectKey || repoIdentityKey(e.repoIdentity) === projectKey) && e.sessionId
+    );
+    const bySession = new Map();
+    for (const event of events) {
+      const entry = bySession.get(event.sessionId) || {
+        sessionId: event.sessionId,
+        repoIdentity: event.repoIdentity,
+        source: event.source,
+        eventCount: 0,
+        firstSequence: event.sequence,
+        lastSequence: event.sequence
+      };
+      entry.eventCount += 1;
+      entry.lastSequence = Math.max(entry.lastSequence, event.sequence);
+      entry.firstSequence = Math.min(entry.firstSequence, event.sequence);
+      bySession.set(event.sessionId, entry);
+    }
+    return [...bySession.values()].sort((a, b) => b.lastSequence - a.lastSequence);
+  }
+
+  _localDay(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime())) return null;
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+  }
+
+  _projectTurns(events) {
+    // Turn assembly by turnId; assistant events without turnId bind to the
+    // single open turn of their session (same rule as the journal projection).
+    const turns = [];
+    const open = new Map();
+    for (const event of events) {
+      if (event.eventType === 'user_prompt' && event.turnId) {
+        const turn = {
+          turnId: event.turnId,
+          sessionId: event.sessionId || null,
+          source: event.source,
+          repoIdentity: event.repoIdentity,
+          day: this._localDay(event.capturedAt),
+          startSequence: event.sequence,
+          endSequence: event.sequence,
+          userEvents: [],
+          assistantEvents: []
+        };
+        turn.userEvents.push(this._projectEvent(event));
+        turns.push(turn);
+        open.set(event.turnId, turn);
+      } else if (event.eventType === 'assistant_response') {
+        let turn = event.turnId ? open.get(event.turnId) : null;
+        if (!turn && event.sessionId) {
+          const openForSession = [...open.values()].filter(t => t.sessionId === event.sessionId);
+          if (openForSession.length === 1) turn = openForSession[0];
+        }
+        if (turn) {
+          turn.assistantEvents.push(this._projectEvent(event));
+          turn.endSequence = event.sequence;
+          open.delete(turn.turnId);
+        }
+        // Orphan assistant evidence is intentionally not surfaced as a turn.
+      }
+    }
+    return turns;
+  }
+
+  _projectEvent(event) {
+    // Controlled projection: full conversation bodies, journal internals stripped.
+    return {
+      sequence: event.sequence,
+      eventId: event.eventId,
+      role: event.role,
+      content: event.content === undefined ? null : event.content,
+      source: event.source,
+      sessionId: event.sessionId || null,
+      turnId: event.turnId || null,
+      capturedAt: event.capturedAt || null,
+      identityConfidence: event.identityConfidence || 'unavailable',
+      captureStatus: event.captureStatus || 'complete'
+    };
+  }
+
+  _encodeCursor(turns, lastIndex) {
+    return Buffer.from(
+      JSON.stringify({ v: 1, last: turns[lastIndex] ? turns[lastIndex].startSequence : 0, n: lastIndex + 1 })
+    ).toString('base64url');
+  }
+
+  async turns({ project, date, cursor, limit = 50 } = {}) {
+    const projectKey = project === undefined || project === null ? null : repoIdentityKey(project) || project;
+    const all = (await this._events()).filter(
+      e => this._isConversationEvent(e) && (!projectKey || repoIdentityKey(e.repoIdentity) === projectKey)
+    );
+    let turns = this._projectTurns(all);
+    if (date) turns = turns.filter(t => t.day === date);
+    turns.sort((a, b) => a.startSequence - b.startSequence);
+    let start = 0;
+    if (cursor) {
+      let decoded;
+      try {
+        decoded = JSON.parse(Buffer.from(String(cursor), 'base64url').toString('utf8'));
+      } catch (_) {
+        decoded = null;
+      }
+      if (!decoded || decoded.v !== 1 || typeof decoded.last !== 'number') {
+        const err = new Error('conversation cursor is invalid; restart the query');
+        err.code = 'LOG_CURSOR_EXPIRED';
+        throw err;
+      }
+      start = turns.findIndex(t => t.startSequence > decoded.last);
+      if (start === -1) start = turns.length;
+    }
+    const pageSize = Math.max(1, Math.min(Number(limit) || 50, 200));
+    const page = turns.slice(start, start + pageSize);
+    return {
+      project: project || null,
+      date: date || null,
+      turns: page,
+      nextCursor: start + pageSize < turns.length ? this._encodeCursor(turns, start + pageSize - 1) : null,
+      totalTurns: turns.length
+    };
+  }
+
+  async searchConversations({ project, q, limit = 20 } = {}) {
+    const needle = String(q || '').toLowerCase();
+    const projectKey = project === undefined || project === null ? null : repoIdentityKey(project) || project;
+    const events = (await this._events()).filter(
+      e => this._isConversationEvent(e) && (!projectKey || repoIdentityKey(e.repoIdentity) === projectKey) && typeof e.content === 'string' && e.content.toLowerCase().includes(needle)
+    );
+    return {
+      matches: events
+        .slice(-Math.max(1, Math.min(Number(limit) || 20, 100)))
+        .reverse()
+        .map(e => this._projectEvent(e))
+    };
+  }
+}
+
+module.exports = { ConversationQuery };

package/src/server.js

@@ -13,10 +13,10 @@ const {
   globalJournalDir,
   projectJournalDir,
   repoIdentityKey
-} = require('@sanqianx/ai-coding-event-bridge');
+} = require('./bridge');
 const { pickFolder } = require('./pick-folder');
 const { detectAgents } = require('./agent-detect');
-const corePackage = require('@sanqianx/ai-coding-event-bridge/package.json');
+const corePackage = require('../package.json');
 
 const BOUNDARY_SCHEMA = 'git-commit-boundary/v1';
 const EVENT_SCHEMA = 'ai-coding-event/v1';