ai-whisper 0.5.7 → 0.5.8

package/dist/bin/broker-daemon.js

@@ -2478,6 +2478,25 @@ function derivePlanPath(specPath, dateIso) {
   return `docs/superpowers/plans/${date}-${slug}.md`;
 }
 
+// ../broker/dist/storage/repositories/workflow-event-outbox-repository.js
+function appendWorkflowEvent(db, input) {
+  db.prepare(`INSERT INTO workflow_event_outbox (collab_id, event_name, payload_json, created_at)
+		 VALUES (?, ?, ?, ?)`).run(input.collabId, input.eventName, JSON.stringify(input.payload), input.now);
+}
+function getMaxWorkflowEventId(db, collabId2) {
+  const row = db.prepare("SELECT MAX(id) AS maxId FROM workflow_event_outbox WHERE collab_id = ?").get(collabId2);
+  return row.maxId ?? 0;
+}
+function listWorkflowEventsAfter(db, input) {
+  const rows = db.prepare(`SELECT id, event_name, payload_json FROM workflow_event_outbox
+			 WHERE collab_id = ? AND id > ? ORDER BY id ASC`).all(input.collabId, input.afterId);
+  return rows.map((r) => ({
+    id: r.id,
+    eventName: r.event_name,
+    payload: JSON.parse(r.payload_json)
+  }));
+}
+
 // ../broker/dist/control/workflow-control.js
 var SHA_REGEX = /^[0-9a-f]{7,40}$/;
 function liveReviewCommitRange(ctx) {
@@ -2514,6 +2533,10 @@ function composeResumeNotice(input) {
 }
 function createWorkflowControl(deps) {
   const { db, events } = deps;
+  function emitAndRecord(collabId2, name, payload, now) {
+    events.emit(name, payload);
+    appendWorkflowEvent(db, { collabId: collabId2, eventName: name, payload, now });
+  }
   function createWorkflow(input) {
     const collab2 = getCollab(db, input.collabId);
     if (!collab2) {
@@ -2552,7 +2575,7 @@ function createWorkflowControl(deps) {
       });
     });
     tx.immediate();
-    events.emit("workflow.created", { workflowId });
+    emitAndRecord(input.collabId, "workflow.created", { workflowId }, input.now);
     return { workflowId };
   }
   function getWorkflow(workflowId) {
@@ -3295,7 +3318,7 @@ ${findingsText}`;
       });
     });
     tx.immediate();
-    events.emit("workflow.paused", { workflowId: input.workflowId });
+    emitAndRecord(workflow.collabId, "workflow.paused", { workflowId: input.workflowId }, input.now);
     maybeCaptureQuiesceSnapshot({ workflowId: input.workflowId, now: input.now });
   }
   function resumeHaltedWorkflow(workflow, now) {
@@ -3312,10 +3335,7 @@ ${findingsText}`;
       });
     });
     tx.immediate();
-    events.emit("workflow.resumed", {
-      workflowId: workflow.workflowId,
-      phaseIndex: workflow.currentPhaseIndex
-    });
+    emitAndRecord(workflow.collabId, "workflow.resumed", { workflowId: workflow.workflowId, phaseIndex: workflow.currentPhaseIndex }, now);
   }
   function resumeWorkflow(input) {
     const workflow = getWorkflowById(db, input.workflowId);
@@ -3366,10 +3386,7 @@ ${findingsText}`;
       });
     });
     tx.immediate();
-    events.emit("workflow.resumed", {
-      workflowId: input.workflowId,
-      phaseIndex: workflow.currentPhaseIndex
-    });
+    emitAndRecord(workflow.collabId, "workflow.resumed", { workflowId: input.workflowId, phaseIndex: workflow.currentPhaseIndex }, input.now);
   }
   function cancelWorkflow(input) {
     const workflow = getWorkflowById(db, input.workflowId);
@@ -3428,10 +3445,7 @@ ${findingsText}`;
       });
     });
     tx.immediate();
-    events.emit("workflow.canceled", {
-      workflowId: input.workflowId,
-      reason: "canceled by operator"
-    });
+    emitAndRecord(workflow.collabId, "workflow.canceled", { workflowId: input.workflowId, reason: "canceled by operator" }, input.now);
   }
   function getHandoffWithWorkflowMeta(handoffId) {
     const meta = getHandoffWithWorkflowMetaById(db, handoffId);
@@ -4715,6 +4729,19 @@ function ensureBrokerStateRow(db) {
 		  schema_version = excluded.schema_version,
 		  migrated = 1`).run(CURRENT_SCHEMA_VERSION);
 }
+function ensureWorkflowEventOutbox(db) {
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS workflow_event_outbox (
+			id            INTEGER PRIMARY KEY AUTOINCREMENT,
+			collab_id     TEXT NOT NULL,
+			event_name    TEXT NOT NULL,
+			payload_json  TEXT NOT NULL,
+			created_at    TEXT NOT NULL
+		);
+		CREATE INDEX IF NOT EXISTS idx_workflow_event_outbox_collab_id
+			ON workflow_event_outbox (collab_id, id);
+	`);
+}
 function applyMigrations(db) {
   const current = db.pragma("user_version", { simple: true });
   if (current < CURRENT_SCHEMA_VERSION) {
@@ -4731,6 +4758,7 @@ function applyMigrations(db) {
   ensureBrokerStateRow(db);
   enforceOneActiveCollabPerWorkspace(db);
   sweepStaleCaptureLease(db);
+  ensureWorkflowEventOutbox(db);
 }
 function runMigrationBody(db) {
   db.exec(initMigrationSql);
@@ -5503,6 +5531,140 @@ function createBrokerRuntime(input) {
   };
 }
 
+// ../broker/dist/runtime/event-protocol.js
+var EVENT_PROTOCOL_VERSION = "1";
+
+// ../broker/dist/runtime/event-socket-server.js
+import { createServer } from "node:net";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var EVENT_NAME_TABLE = {
+  "chain.resolved": true,
+  "chain.escalated": true,
+  "workflow.created": true,
+  "workflow.phase-started": true,
+  "workflow.round-started": true,
+  "workflow.phase-done": true,
+  "workflow.halted": true,
+  "workflow.canceled": true,
+  "workflow.done": true,
+  "workflow.resumed": true,
+  "workflow.paused": true
+};
+var ALL_BROKER_EVENT_NAMES = Object.keys(EVENT_NAME_TABLE);
+async function createEventSocketServer(input) {
+  const now = input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const clients = /* @__PURE__ */ new Set();
+  mkdirSync3(dirname2(input.socketPath), { recursive: true });
+  if (existsSync4(input.socketPath)) {
+    try {
+      unlinkSync2(input.socketPath);
+    } catch {
+    }
+  }
+  function dropClient(conn) {
+    clients.delete(conn);
+    try {
+      conn.destroy();
+    } catch {
+    }
+  }
+  function writeLine(conn, line) {
+    try {
+      conn.write(line);
+    } catch {
+      dropClient(conn);
+    }
+  }
+  const server = createServer((conn) => {
+    clients.add(conn);
+    conn.on("error", () => dropClient(conn));
+    conn.on("close", () => clients.delete(conn));
+    const hello = {
+      type: "hello",
+      engineVersion: input.engineVersion,
+      protocolVersion: EVENT_PROTOCOL_VERSION
+    };
+    writeLine(conn, `${JSON.stringify(hello)}
+`);
+  });
+  const buses = Array.isArray(input.events) ? input.events : [input.events];
+  const unsubscribes = buses.flatMap((bus) => ALL_BROKER_EVENT_NAMES.map((name) => bus.on(name, (payload) => {
+    const frame = { type: "event", name, payload, ts: now() };
+    const line = `${JSON.stringify(frame)}
+`;
+    for (const conn of [...clients])
+      writeLine(conn, line);
+  })));
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(input.socketPath, () => {
+      server.removeListener("error", reject);
+      resolve2();
+    });
+  });
+  return {
+    socketPath: input.socketPath,
+    close: () => new Promise((resolve2) => {
+      for (const unsub of unsubscribes)
+        unsub();
+      for (const conn of [...clients])
+        dropClient(conn);
+      server.close(() => {
+        try {
+          if (existsSync4(input.socketPath))
+            unlinkSync2(input.socketPath);
+        } catch {
+        }
+        resolve2();
+      });
+    })
+  };
+}
+
+// ../broker/dist/runtime/workflow-event-bridge.js
+function createWorkflowEventBridge(input) {
+  let lastId = 0;
+  let seeded = false;
+  let timer = null;
+  function tick() {
+    if (!seeded) {
+      lastId = getMaxWorkflowEventId(input.db, input.collabId);
+      seeded = true;
+      return;
+    }
+    const rows = listWorkflowEventsAfter(input.db, {
+      collabId: input.collabId,
+      afterId: lastId
+    });
+    for (const row of rows) {
+      input.events.emit(row.eventName, row.payload);
+      lastId = row.id;
+    }
+  }
+  return {
+    tick,
+    start() {
+      if (timer)
+        return;
+      tick();
+      timer = setInterval(() => {
+        try {
+          tick();
+        } catch {
+        }
+      }, input.intervalMs);
+      timer.unref();
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    }
+  };
+}
+
 // src/runtime/relay-orchestrator-evaluator.ts
 import * as crypto3 from "node:crypto";
 import Anthropic from "@anthropic-ai/sdk";
@@ -6283,6 +6445,9 @@ import path from "node:path";
 function getStateRoot() {
   return process.env.AI_WHISPER_STATE_ROOT ?? path.join(os.homedir(), ".ai-whisper");
 }
+function getStateSocketsDir() {
+  return path.join(getStateRoot(), "sockets");
+}
 
 // src/runtime/evaluator-config.ts
 function parseDotEnv(text) {
@@ -6389,6 +6554,31 @@ function recordEvaluatorStatus(db, input) {
 
 // src/bin/broker-daemon.ts
 import { execFile as execFile2 } from "node:child_process";
+import { join as join6 } from "node:path";
+
+// src/runtime/cli-package-info.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+import { fileURLToPath } from "node:url";
+var PKG_CANDIDATES = ["../../package.json", "../package.json"];
+function readWhisperPackage() {
+  for (const rel of PKG_CANDIDATES) {
+    try {
+      const url = new URL(rel, import.meta.url);
+      const pkg = JSON.parse(readFileSync3(url, "utf8"));
+      if (pkg.name === "ai-whisper" && typeof pkg.version === "string") {
+        return { url, version: pkg.version };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveCliVersion() {
+  return readWhisperPackage()?.version ?? "0.0.0-dev";
+}
+
+// src/bin/broker-daemon.ts
 var sqlitePath = process.env.AI_WHISPER_BROKER_SQLITE;
 var host = process.env.AI_WHISPER_BROKER_HOST ?? "127.0.0.1";
 var port = Number(process.env.AI_WHISPER_BROKER_PORT ?? "4311");
@@ -6401,6 +6591,31 @@ if (collabId) {
   });
 }
 await broker.start();
+var eventSocket = null;
+var workflowEventBridge = null;
+if (collabId) {
+  try {
+    const externalEvents = createBrokerEventBus();
+    workflowEventBridge = createWorkflowEventBridge({
+      db: broker.db,
+      events: externalEvents,
+      collabId,
+      intervalMs: Number(process.env.AI_WHISPER_WORKFLOW_EVENT_BRIDGE_MS ?? 1e3)
+    });
+    workflowEventBridge.start();
+    eventSocket = await createEventSocketServer({
+      socketPath: join6(getStateSocketsDir(), `events-${collabId}.sock`),
+      events: [broker.events, externalEvents],
+      engineVersion: resolveCliVersion()
+    });
+  } catch (err) {
+    workflowEventBridge?.stop();
+    workflowEventBridge = null;
+    console.error(
+      `event-socket fanout unavailable: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 var resolved;
 var loaderError = null;
 try {
@@ -6462,6 +6677,8 @@ var orchestrator = collab?.orchestratorEnabled && evaluator ? createRelayOrchest
 orchestrator?.start();
 async function shutdown() {
   orchestrator?.stop();
+  workflowEventBridge?.stop();
+  await eventSocket?.close();
   await broker.stop();
   process.exit(0);
 }