@wopr-network/defcon 1.1.0 → 1.2.1

package/dist/src/api/server.js

@@ -249,20 +249,20 @@ export function createHttpServer(deps) {
         return mcpResultToApi(result);
     });
     // --- Admin: Drain/Undrain Worker ---
-    router.add("POST", "/api/admin/workers/:workerId/drain", async (req) => {
+    router.add("POST", "/api/admin/workers/:worker_id/drain", async (req) => {
         const authErr = requireAdminToken(deps, req);
         if (authErr)
             return authErr;
         const callerToken = extractBearerToken(req.authorization);
-        const result = await callToolHandler(deps.mcpDeps, "admin.worker.drain", { worker_id: req.params.workerId }, { adminToken: deps.adminToken, callerToken });
+        const result = await callToolHandler(deps.mcpDeps, "admin.worker.drain", { worker_id: req.params.worker_id }, { adminToken: deps.adminToken, callerToken });
         return mcpResultToApi(result);
     });
-    router.add("POST", "/api/admin/workers/:workerId/undrain", async (req) => {
+    router.add("POST", "/api/admin/workers/:worker_id/undrain", async (req) => {
         const authErr = requireAdminToken(deps, req);
         if (authErr)
             return authErr;
         const callerToken = extractBearerToken(req.authorization);
-        const result = await callToolHandler(deps.mcpDeps, "admin.worker.undrain", { worker_id: req.params.workerId }, { adminToken: deps.adminToken, callerToken });
+        const result = await callToolHandler(deps.mcpDeps, "admin.worker.undrain", { worker_id: req.params.worker_id }, { adminToken: deps.adminToken, callerToken });
         return mcpResultToApi(result);
     });
     // --- Admin: Rerun Gate ---

package/dist/src/execution/cli.js

@@ -22,6 +22,7 @@ import { DrizzleInvocationRepository } from "../repositories/drizzle/invocation.
 import * as schema from "../repositories/drizzle/schema.js";
 import { entities, entityHistory, flowDefinitions, flowVersions, gateDefinitions, gateResults, invocations, stateDefinitions, transitionRules, } from "../repositories/drizzle/schema.js";
 import { DrizzleTransitionLogRepository } from "../repositories/drizzle/transition-log.repo.js";
+import { WebSocketBroadcaster } from "../ws/broadcast.js";
 import { createMcpServer, startStdioServer } from "./mcp-server.js";
 import { provisionWorktree } from "./provision-worktree.js";
 const DB_DEFAULT = process.env.DEFCON_DB_PATH ?? "./defcon.db";
@@ -244,6 +245,14 @@ program
             workerToken,
             corsOrigin: restCorsResult.origin ?? undefined,
         });
+        if (adminToken) {
+            const wsBroadcaster = new WebSocketBroadcaster({
+                server: restHttpServer,
+                engine,
+                adminToken,
+            });
+            eventEmitter.register(wsBroadcaster);
+        }
         restHttpServer.listen(httpPort, httpHost, () => {
             const addr = restHttpServer?.address();
             const boundPort = addr && typeof addr === "object" ? addr.port : httpPort;

package/dist/src/execution/mcp-server.js

@@ -771,6 +771,7 @@ async function handleAdminFlowPause(deps, args) {
     const flow = await deps.flows.getByName(v.data.flow_name);
     if (!flow)
         return errorResult(`Flow not found: ${v.data.flow_name}`);
+    await deps.flows.snapshot(flow.id);
     await deps.flows.update(flow.id, { paused: true });
     emitDefinitionChanged(deps.eventRepo, flow.id, "admin.flow.pause", { name: v.data.flow_name });
     return jsonResult({ paused: true, flow: v.data.flow_name });
@@ -782,6 +783,7 @@ async function handleAdminFlowResume(deps, args) {
     const flow = await deps.flows.getByName(v.data.flow_name);
     if (!flow)
         return errorResult(`Flow not found: ${v.data.flow_name}`);
+    await deps.flows.snapshot(flow.id);
     await deps.flows.update(flow.id, { paused: false });
     emitDefinitionChanged(deps.eventRepo, flow.id, "admin.flow.resume", { name: v.data.flow_name });
     return jsonResult({ paused: false, flow: v.data.flow_name });
@@ -793,6 +795,12 @@ async function handleAdminEntityCancel(deps, args) {
     const entity = await deps.entities.get(v.data.entity_id);
     if (!entity)
         return errorResult(`Entity not found: ${v.data.entity_id}`);
+    const flow = await deps.flows.get(entity.flowId);
+    if (!flow)
+        return errorResult(`Flow not found for entity: ${v.data.entity_id}`);
+    const cancelledState = flow.states.find((s) => s.name === "cancelled");
+    if (!cancelledState)
+        return errorResult(`State 'cancelled' not found in flow '${flow.name}'`);
     const invocations = await deps.invocations.findByEntity(v.data.entity_id);
     for (const inv of invocations) {
         if (inv.completedAt === null && inv.failedAt === null) {
@@ -800,6 +808,14 @@ async function handleAdminEntityCancel(deps, args) {
         }
     }
     await deps.entities.cancelEntity(v.data.entity_id);
+    await deps.transitions.record({
+        entityId: v.data.entity_id,
+        fromState: entity.state,
+        toState: "cancelled",
+        trigger: "admin.cancel",
+        invocationId: null,
+        timestamp: new Date(),
+    });
     return jsonResult({ cancelled: true, entity_id: v.data.entity_id });
 }
 async function handleAdminEntityReset(deps, args) {
@@ -822,6 +838,14 @@ async function handleAdminEntityReset(deps, args) {
         }
     }
     const updated = await deps.entities.resetEntity(v.data.entity_id, v.data.target_state);
+    await deps.transitions.record({
+        entityId: v.data.entity_id,
+        fromState: entity.state,
+        toState: updated.state,
+        trigger: "admin.reset",
+        invocationId: null,
+        timestamp: new Date(),
+    });
     return jsonResult({ reset: true, entity_id: v.data.entity_id, state: updated.state });
 }
 async function handleAdminWorkerDrain(deps, args) {

package/dist/src/repositories/drizzle/gate.repo.js

@@ -97,7 +97,7 @@ export class DrizzleGateRepository {
         return rows.map(toGateResult);
     }
     async clearResult(entityId, gateId) {
-        this.db
+        await this.db
             .delete(gateResults)
             .where(and(eq(gateResults.entityId, entityId), eq(gateResults.gateId, gateId)))
             .run();

package/dist/src/ws/broadcast.d.ts

@@ -0,0 +1,21 @@
+import type http from "node:http";
+import type { Engine } from "../engine/engine.js";
+import type { EngineEvent, IEventBusAdapter } from "../engine/event-types.js";
+export interface WebSocketBroadcasterDeps {
+    server: http.Server;
+    engine: Engine;
+    adminToken: string;
+}
+export declare class WebSocketBroadcaster implements IEventBusAdapter {
+    private wss;
+    private engine;
+    private adminToken;
+    constructor(deps: WebSocketBroadcasterDeps);
+    private isWsPath;
+    private authenticate;
+    private tokenMatches;
+    private sendSnapshot;
+    emit(event: EngineEvent): Promise<void>;
+    get clientCount(): number;
+    close(): Promise<void>;
+}

package/dist/src/ws/broadcast.js

@@ -0,0 +1,105 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { WebSocketServer } from "ws";
+export class WebSocketBroadcaster {
+    wss;
+    engine;
+    adminToken;
+    constructor(deps) {
+        this.engine = deps.engine;
+        this.adminToken = deps.adminToken;
+        this.wss = new WebSocketServer({ noServer: true });
+        deps.server.on("upgrade", (req, socket, head) => {
+            if (!this.isWsPath(req.url)) {
+                socket.destroy();
+                return;
+            }
+            if (!this.authenticate(req)) {
+                socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+                socket.destroy();
+                return;
+            }
+            this.wss.handleUpgrade(req, socket, head, (ws) => {
+                this.wss.emit("connection", ws, req);
+            });
+        });
+        this.wss.on("connection", (ws) => {
+            this.sendSnapshot(ws);
+            ws.on("close", () => {
+                // Client removed automatically from wss.clients on close
+            });
+        });
+    }
+    isWsPath(url) {
+        if (!url)
+            return false;
+        const pathname = url.split("?")[0];
+        return pathname === "/ws";
+    }
+    authenticate(req) {
+        // Try Authorization header first
+        const authHeader = req.headers.authorization;
+        if (authHeader) {
+            const lower = authHeader.toLowerCase();
+            if (lower.startsWith("bearer ")) {
+                const token = authHeader.slice(7).trim();
+                if (token && this.tokenMatches(token))
+                    return true;
+            }
+        }
+        // Try ?token= query param
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const queryToken = url.searchParams.get("token");
+        if (queryToken && this.tokenMatches(queryToken))
+            return true;
+        return false;
+    }
+    tokenMatches(callerToken) {
+        const hashA = createHash("sha256").update(this.adminToken).digest();
+        const hashB = createHash("sha256").update(callerToken).digest();
+        return timingSafeEqual(hashA, hashB);
+    }
+    async sendSnapshot(ws) {
+        try {
+            const status = await this.engine.getStatus();
+            const msg = JSON.stringify({
+                type: "snapshot",
+                payload: { status },
+                timestamp: new Date().toISOString(),
+            });
+            if (ws.readyState === ws.OPEN) {
+                ws.send(msg);
+            }
+        }
+        catch {
+            if (ws.readyState === ws.OPEN) {
+                ws.send(JSON.stringify({
+                    type: "snapshot",
+                    payload: { status: { flows: {}, activeInvocations: 0, pendingClaims: 0 } },
+                    timestamp: new Date().toISOString(),
+                }));
+            }
+        }
+    }
+    async emit(event) {
+        const { type, emittedAt, ...rest } = event;
+        const msg = JSON.stringify({
+            type,
+            payload: rest,
+            timestamp: emittedAt.toISOString(),
+        });
+        for (const client of this.wss.clients) {
+            if (client.readyState === client.OPEN) {
+                client.send(msg);
+            }
+        }
+    }
+    get clientCount() {
+        return this.wss.clients.size;
+    }
+    close() {
+        for (const client of this.wss.clients) {
+            client.terminate();
+        }
+        return new Promise((resolve) => this.wss.close(() => resolve()));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/defcon",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "type": "module",
   "packageManager": "pnpm@9.15.4",
   "engines": {
@@ -45,12 +45,14 @@
     "commander": "^14.0.3",
     "drizzle-orm": "^0.45.1",
     "handlebars": "^4.7.8",
+    "ws": "^8.19.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.4",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.3.3",
+    "@types/ws": "^8.18.1",
     "@vitest/coverage-v8": "^4.0.18",
     "drizzle-kit": "^0.31.4",
     "tsx": "^4.21.0",