@sanqianx/ai-coding-event-bridge-console 0.5.0 → 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';
@@ -60,6 +60,16 @@ function decodeCursor(raw) {
   return null;
 }
 
+function decodeSeqCursor(raw) {
+  try {
+    const decoded = JSON.parse(Buffer.from(String(raw), 'base64url').toString('utf8'));
+    if (decoded && decoded.v === 1 && typeof decoded.seq === 'number') return decoded;
+  } catch (_) {
+    // fall through
+  }
+  return null;
+}
+
 function pickFolderEnabled() {
   return process.env.BRIDGE_CONSOLE_PICK_FOLDER !== '0';
 }
@@ -294,7 +304,7 @@ function createConsoleServer({ home }) {
    * project journal after its last commit boundary. Everything earlier is
    * archived under <store>/commits and served by the commit-doc endpoints.
    */
-  async function currentTurns(project, { limit, cursorRaw }) {
+  async function currentTurns(project, { limit, cursorRaw, order }) {
     const dir = projectJournalDir(project);
     const journal = existingJournal(dir);
     if (!journal) {
@@ -307,24 +317,43 @@ function createConsoleServer({ home }) {
     const records = await journal.readEvents({ fromSequence: lastBoundary + 1 });
     const turns = queryAt(dir)._projectTurns(records.filter(isConversationEvent));
     turns.sort((a, b) => a.startSequence - b.startSequence);
-    let start = 0;
-    if (cursorRaw) {
-      let decoded = null;
-      try {
-        decoded = JSON.parse(Buffer.from(String(cursorRaw), 'base64url').toString('utf8'));
-      } catch (_) {
-        decoded = null;
+    let pageAsc;
+    let nextCursor = null;
+    if (order === 'desc') {
+      // Newest on top: page 1 holds the newest turns; each cursor step pages
+      // further into the past.
+      let start;
+      if (cursorRaw) {
+        const decoded = decodeSeqCursor(cursorRaw);
+        if (!decoded || (decoded.o && decoded.o !== 'desc')) return null;
+        start = turns.findIndex((turn) => turn.startSequence < decoded.seq);
+        if (start === -1) start = turns.length;
+      } else {
+        start = Math.max(0, turns.length - limit);
+      }
+      pageAsc = turns.slice(start, start + limit);
+      if (start > 0) {
+        nextCursor = encodeCursor({ v: 1, seq: turns[start].startSequence, o: 'desc' });
+      }
+    } else {
+      let start = 0;
+      if (cursorRaw) {
+        const decoded = decodeSeqCursor(cursorRaw);
+        if (!decoded || (decoded.o && decoded.o !== 'asc')) return null;
+        start = turns.findIndex((turn) => turn.startSequence > decoded.seq);
+        if (start === -1) start = turns.length;
+      }
+      pageAsc = turns.slice(start, start + limit);
+      if (start + limit < turns.length && pageAsc.length) {
+        nextCursor = encodeCursor({ v: 1, seq: pageAsc[pageAsc.length - 1].startSequence, o: 'asc' });
       }
-      if (!decoded || decoded.v !== 1 || typeof decoded.seq !== 'number') return null;
-      start = turns.findIndex((turn) => turn.startSequence > decoded.seq);
-      if (start === -1) start = turns.length;
     }
-    const page = turns.slice(start, start + limit);
+    const page = order === 'desc' ? pageAsc.slice().reverse() : pageAsc;
     return {
       project: project.id,
       date: null,
       turns: page,
-      nextCursor: start + limit < turns.length && page.length ? encodeCursor({ v: 1, seq: page[page.length - 1].startSequence }) : null,
+      nextCursor,
       totalTurns: turns.length,
       annotations: {}
     };
@@ -618,11 +647,12 @@ function createConsoleServer({ home }) {
 
       if (route === 'GET /api/turns') {
         const limit = Math.max(1, Math.min(Number(url.searchParams.get('limit')) || 50, 200));
+        const order = url.searchParams.get('order') === 'desc' ? 'desc' : 'asc';
         if (!project.auto) {
           // Registered projects: the journal is a conveyor — serve only the
           // current (uncommitted) conversation and keep it maintained.
           await maintainProject(project);
-          const current = await currentTurns(project, { limit, cursorRaw: url.searchParams.get('cursor') });
+          const current = await currentTurns(project, { limit, cursorRaw: url.searchParams.get('cursor'), order });
           if (!current) {
             sendJson(res, 400, { error: { code: 'CURSOR_INVALID', message: 'cursor is invalid; restart the query' } });
             return;
@@ -633,22 +663,49 @@ function createConsoleServer({ home }) {
         const date = url.searchParams.get('date') || null;
         const merged = await mergedTurns(project, { date });
         const cursor = url.searchParams.get('cursor');
-        let start = 0;
-        if (cursor) {
-          const decoded = decodeCursor(cursor);
-          if (!decoded) {
-            sendJson(res, 400, { error: { code: 'CURSOR_INVALID', message: 'cursor is invalid; restart the query' } });
-            return;
+        let pageAsc;
+        let nextCursor = null;
+        if (order === 'desc') {
+          // Newest on top: page 1 holds the newest turns; each cursor step
+          // pages further into the past.
+          let start;
+          if (cursor) {
+            const decoded = decodeCursor(cursor);
+            if (!decoded || (decoded.o && decoded.o !== 'desc')) {
+              sendJson(res, 400, { error: { code: 'CURSOR_INVALID', message: 'cursor is invalid; restart the query' } });
+              return;
+            }
+            start = merged.findIndex((turn) => turnSortKey(turn) < decoded.key);
+            if (start === -1) start = merged.length;
+          } else {
+            start = Math.max(0, merged.length - limit);
+          }
+          pageAsc = merged.slice(start, start + limit);
+          if (start > 0) {
+            nextCursor = encodeCursor({ v: 1, key: turnSortKey(merged[start]), o: 'desc' });
+          }
+        } else {
+          let start = 0;
+          if (cursor) {
+            const decoded = decodeCursor(cursor);
+            if (!decoded || (decoded.o && decoded.o !== 'asc')) {
+              sendJson(res, 400, { error: { code: 'CURSOR_INVALID', message: 'cursor is invalid; restart the query' } });
+              return;
+            }
+            start = merged.findIndex((turn) => turnSortKey(turn) > decoded.key);
+            if (start === -1) start = merged.length;
+          }
+          pageAsc = merged.slice(start, start + limit);
+          if (start + limit < merged.length && pageAsc.length) {
+            nextCursor = encodeCursor({ v: 1, key: turnSortKey(pageAsc[pageAsc.length - 1]), o: 'asc' });
           }
-          start = merged.findIndex((turn) => turnSortKey(turn) > decoded.key);
-          if (start === -1) start = merged.length;
         }
-        const page = merged.slice(start, start + limit);
+        const page = order === 'desc' ? pageAsc.slice().reverse() : pageAsc;
         sendJson(res, 200, {
           project: project.id,
           date,
           turns: page,
-          nextCursor: start + limit < merged.length ? encodeCursor({ v: 1, key: turnSortKey(merged[start + limit - 1]) }) : null,
+          nextCursor,
           totalTurns: merged.length,
           annotations: await annotationsFor(project, page)
         });