@provos/ironcurtain 0.10.0 → 0.12.0

package/dist/web-ui/web-event-bus.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Web UI event map and typed bus.
+ *
+ * The transport-neutral pub/sub mechanics live in
+ * {@link ../event-bus/typed-event-bus.js | TypedEventBus}; this file owns
+ * the web-flavored event map and the `WebEventBus` alias used by the
+ * daemon, transports, and dispatch layer. The WebUiServer subscribes and
+ * broadcasts to all connected WebSocket clients.
+ */
+import type { SessionDto, BudgetSummaryDto, DaemonStatusDto, EscalationDto, CompilationPhase, PersonaCompileResultDto, ErrorCode } from './web-ui-types.js';
+import type { HumanGateRequestDto } from '../workflow/types.js';
+import type { DiagnosticEvent } from '../session/types.js';
+import type { RunRecord } from '../cron/types.js';
+import type { TokenStreamEvent } from '../docker/token-stream-types.js';
+import { TypedEventBus, type EventHandler } from '../event-bus/typed-event-bus.js';
+/**
+ * Typed event map. Each key maps to a specific payload type.
+ * Adding a new event requires updating this interface, ensuring
+ * all producers and consumers agree on the payload shape at compile time.
+ */
+export interface WebEventMap {
+    'session.created': SessionDto;
+    'session.ended': {
+        label: number;
+        reason: string;
+    };
+    'session.updated': SessionDto;
+    'session.thinking': {
+        label: number;
+        turnNumber: number;
+    };
+    'session.tool_call': {
+        label: number;
+        toolName: string;
+        preview: string;
+    };
+    'session.tool_result': {
+        label: number;
+        toolName: string;
+        stepIndex: number;
+    };
+    'session.text_delta': {
+        label: number;
+        preview: string;
+    };
+    'session.output': {
+        label: number;
+        text: string;
+        turnNumber: number;
+    };
+    'session.diagnostic': {
+        label: number;
+        event: DiagnosticEvent;
+    };
+    'session.budget_update': {
+        label: number;
+        budget: BudgetSummaryDto;
+    };
+    'escalation.created': EscalationDto;
+    'escalation.resolved': {
+        escalationId: string;
+        decision: 'approved' | 'denied';
+    };
+    'escalation.expired': {
+        escalationId: string;
+        sessionLabel: number;
+    };
+    'job.started': {
+        jobId: string;
+        sessionLabel: number;
+    };
+    'job.completed': {
+        jobId: string;
+        record: RunRecord;
+    };
+    'job.failed': {
+        jobId: string;
+        error: string;
+    };
+    'job.list_changed': Record<string, never>;
+    'daemon.status': DaemonStatusDto;
+    'workflow.started': {
+        workflowId: string;
+        name: string;
+        taskDescription: string;
+    };
+    'workflow.state_entered': {
+        workflowId: string;
+        state: string;
+        previousState?: string;
+    };
+    'workflow.completed': {
+        workflowId: string;
+    };
+    'workflow.failed': {
+        workflowId: string;
+        error: string;
+    };
+    'workflow.gate_raised': {
+        workflowId: string;
+        gate: HumanGateRequestDto;
+    };
+    'workflow.gate_dismissed': {
+        workflowId: string;
+        gateId: string;
+    };
+    'workflow.agent_started': {
+        workflowId: string;
+        stateId: string;
+        persona: string;
+        /**
+         * Session ID of the agent session. The daemon always emits this;
+         * the WS broadcast path delivers it to frontend clients, which
+         * type it as required (see `event-handler.ts`'s `WebEvent` union).
+         * Its primary consumer today is the daemon's bridge wiring, which
+         * registers this mapping so token events produced by the
+         * workflow-owned session reach `observe --all` subscribers.
+         */
+        sessionId: string;
+    };
+    'workflow.agent_completed': {
+        workflowId: string;
+        stateId: string;
+        verdict?: string;
+        confidence?: string;
+    };
+    /**
+     * Fires unconditionally in the orchestrator's agent-state finally
+     * block, pairing 1:1 with 'workflow.agent_started'. The daemon's
+     * bridge wiring uses this to tear down the per-session token-stream
+     * mapping on both success and failure paths.
+     */
+    'workflow.agent_session_ended': {
+        workflowId: string;
+        stateId: string;
+        sessionId: string;
+    };
+    'session.token_stream': {
+        label: number;
+        events: readonly TokenStreamEvent[];
+    };
+    'persona.compile.started': {
+        name: string;
+        operationId: string;
+        actor: string;
+    };
+    'persona.compile.progress': {
+        name: string;
+        operationId: string;
+        serverName: string;
+        phase: CompilationPhase;
+        detail?: string;
+    };
+    'persona.compile.done': {
+        name: string;
+        operationId: string;
+        result: PersonaCompileResultDto;
+    };
+    'persona.compile.failed': {
+        name: string;
+        operationId: string;
+        code: ErrorCode;
+        error: string;
+    };
+    'personas.changed': Record<string, never>;
+}
+export type WebEventName = keyof WebEventMap;
+export type WebEventHandler = EventHandler<WebEventMap>;
+/**
+ * Typed pub/sub bus for web UI events. Thin alias over the generic
+ * {@link TypedEventBus} that fixes the event map to {@link WebEventMap}.
+ * Producers call `emit()`; the WebUiServer subscribes and broadcasts to
+ * WS clients.
+ */
+export declare class WebEventBus extends TypedEventBus<WebEventMap> {
+}

package/dist/web-ui/web-event-bus.js

@@ -0,0 +1,19 @@
+/**
+ * Web UI event map and typed bus.
+ *
+ * The transport-neutral pub/sub mechanics live in
+ * {@link ../event-bus/typed-event-bus.js | TypedEventBus}; this file owns
+ * the web-flavored event map and the `WebEventBus` alias used by the
+ * daemon, transports, and dispatch layer. The WebUiServer subscribes and
+ * broadcasts to all connected WebSocket clients.
+ */
+import { TypedEventBus } from '../event-bus/typed-event-bus.js';
+/**
+ * Typed pub/sub bus for web UI events. Thin alias over the generic
+ * {@link TypedEventBus} that fixes the event map to {@link WebEventMap}.
+ * Producers call `emit()`; the WebUiServer subscribes and broadcasts to
+ * WS clients.
+ */
+export class WebEventBus extends TypedEventBus {
+}
+//# sourceMappingURL=web-event-bus.js.map

package/dist/web-ui/web-event-bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-event-bus.js","sourceRoot":"","sources":["../../src/web-ui/web-event-bus.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAeH,OAAO,EAAE,aAAa,EAAqB,MAAM,iCAAiC,CAAC;AA0FnF;;;;;GAKG;AACH,MAAM,OAAO,WAAY,SAAQ,aAA0B;CAAG"}

package/dist/web-ui/web-session-transport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Web session transport -- bridges session events to the WebEventBus.
+ *
+ * Follows the same pattern as SignalSessionTransport: run() blocks
+ * until close() is called, forwardMessage() routes input through
+ * the session, and callback factories emit events to the event bus.
+ */
+import { BaseTransport, type BaseTransportOptions } from '../session/base-transport.js';
+import type { Session, DiagnosticEvent, EscalationRequest } from '../session/types.js';
+import type { SessionManager } from '../session/session-manager.js';
+import type { WebEventBus } from './web-event-bus.js';
+export interface WebSessionTransportOptions extends BaseTransportOptions {
+    readonly eventBus: WebEventBus;
+    readonly sessionManager: SessionManager;
+}
+export declare class WebSessionTransport extends BaseTransport {
+    private session;
+    private readonly eventBus;
+    private readonly sessionManager;
+    private exitResolve;
+    /** Session label assigned after construction. */
+    sessionLabel: number;
+    constructor(options: WebSessionTransportOptions);
+    protected runSession(session: Session): Promise<void>;
+    close(): void;
+    forwardMessage(text: string): Promise<string>;
+    createDiagnosticHandler(): (event: DiagnosticEvent) => void;
+    createEscalationHandler(): (request: EscalationRequest) => void;
+    createEscalationResolvedHandler(): (escalationId: string, decision: string) => void;
+    createEscalationExpiredHandler(): () => void;
+}

package/dist/web-ui/web-session-transport.js

@@ -0,0 +1,109 @@
+/**
+ * Web session transport -- bridges session events to the WebEventBus.
+ *
+ * Follows the same pattern as SignalSessionTransport: run() blocks
+ * until close() is called, forwardMessage() routes input through
+ * the session, and callback factories emit events to the event bus.
+ */
+import { BaseTransport } from '../session/base-transport.js';
+import * as logger from '../logger.js';
+export class WebSessionTransport extends BaseTransport {
+    session = null;
+    eventBus;
+    sessionManager;
+    exitResolve = null;
+    /** Session label assigned after construction. */
+    sessionLabel = 0;
+    constructor(options) {
+        super(options);
+        this.eventBus = options.eventBus;
+        this.sessionManager = options.sessionManager;
+    }
+    async runSession(session) {
+        this.session = session;
+        return new Promise((resolve) => {
+            this.exitResolve = resolve;
+        });
+    }
+    close() {
+        this.session = null;
+        this.exitResolve?.();
+        this.exitResolve = null;
+    }
+    async forwardMessage(text) {
+        if (!this.session)
+            throw new Error('No active session');
+        return this.sendAndLog(this.session, text);
+    }
+    // --- Callback factories (wired into SessionOptions) ---
+    createDiagnosticHandler() {
+        return (event) => {
+            switch (event.kind) {
+                case 'tool_call':
+                    this.eventBus.emit('session.tool_call', {
+                        label: this.sessionLabel,
+                        toolName: event.toolName,
+                        preview: event.preview,
+                    });
+                    break;
+                case 'agent_text':
+                    this.eventBus.emit('session.text_delta', {
+                        label: this.sessionLabel,
+                        preview: event.preview,
+                    });
+                    break;
+                case 'step_finish':
+                    this.eventBus.emit('session.tool_result', {
+                        label: this.sessionLabel,
+                        toolName: '',
+                        stepIndex: event.stepIndex,
+                    });
+                    break;
+            }
+        };
+    }
+    createEscalationHandler() {
+        return (request) => {
+            logger.info(`[Web Transport] Escalation fired on session #${this.sessionLabel} ` +
+                `(tool=${request.serverName}/${request.toolName}, id=${request.escalationId})`);
+            const escalationData = {
+                escalationId: request.escalationId,
+                sessionLabel: this.sessionLabel,
+                toolName: request.toolName,
+                serverName: request.serverName,
+                arguments: request.arguments,
+                reason: request.reason,
+                context: request.context,
+                whitelistCandidates: request.whitelistCandidates,
+                receivedAt: new Date().toISOString(),
+            };
+            this.sessionManager.setPendingEscalation(this.sessionLabel, escalationData);
+            const dto = {
+                ...escalationData,
+                sessionSource: { kind: 'web' },
+                whitelistCandidates: request.whitelistCandidates,
+            };
+            this.eventBus.emit('escalation.created', dto);
+        };
+    }
+    createEscalationResolvedHandler() {
+        return (escalationId, decision) => {
+            this.eventBus.emit('escalation.resolved', {
+                escalationId,
+                decision: decision,
+            });
+        };
+    }
+    createEscalationExpiredHandler() {
+        return () => {
+            const managed = this.sessionManager.get(this.sessionLabel);
+            const escalationId = managed?.pendingEscalation?.escalationId ?? 'unknown';
+            this.sessionManager.clearPendingEscalation(this.sessionLabel);
+            this.eventBus.emit('escalation.expired', {
+                escalationId,
+                sessionLabel: this.sessionLabel,
+            });
+        };
+    }
+}
+//# sourceMappingURL=web-session-transport.js.map

package/dist/web-ui/web-session-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-session-transport.js","sourceRoot":"","sources":["../../src/web-ui/web-session-transport.ts"],"names":[],"mappings":"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"}

package/dist/web-ui/web-ui-server.d.ts

@@ -0,0 +1,90 @@
+/**
+ * WebUiServer -- HTTP + WebSocket server for the daemon web UI.
+ *
+ * Serves the compiled Svelte SPA as static files and handles
+ * WebSocket upgrades for the JSON-RPC frame protocol. Bearer token
+ * authentication is required for WebSocket connections.
+ */
+import { WebSocket as WsWebSocket } from 'ws';
+import type { SessionManager } from '../session/session-manager.js';
+import type { ControlRequestHandler } from '../daemon/control-socket.js';
+import type { SessionMode } from '../session/types.js';
+import type { TokenStreamBridge } from './token-stream-bridge.js';
+import { WebEventBus } from './web-event-bus.js';
+import type { WorkflowManager } from '../workflow/workflow-manager.js';
+export interface WebUiServerOptions {
+    readonly port: number;
+    readonly host: string;
+    readonly handler: ControlRequestHandler;
+    readonly sessionManager: SessionManager;
+    readonly mode: SessionMode;
+    readonly maxConcurrentWebSessions: number;
+    /** When true, skip Origin validation (for Vite dev server). */
+    readonly devMode?: boolean;
+    /** Optional WorkflowManager for workflow RPC methods. */
+    readonly workflowManager?: WorkflowManager;
+    /**
+     * Process-wide capture-traces default inherited from the daemon CLI
+     * flag. Per-session JSON-RPC `captureTraces` field overrides this when
+     * present. See docs/designs/mitm-token-trajectory-capture.md §10.
+     */
+    readonly captureTracesDefault?: boolean;
+    /**
+     * Persona policy-mutation kill switch inherited from the daemon CLI
+     * `--allow-policy-mutation` flag (Phase 1c). Threaded into
+     * `dispatchCtx.allowPolicyMutation`. Off by default; when off, every
+     * persona-mutation method returns POLICY_MUTATION_FORBIDDEN and the UI
+     * hides mutation controls (via `DaemonStatusDto.allowPolicyMutation`).
+     */
+    readonly allowPolicyMutation?: boolean;
+}
+export declare class WebUiServer {
+    private httpServer;
+    private wss;
+    private readonly clients;
+    private readonly authToken;
+    private readonly options;
+    private readonly eventBus;
+    private readonly dispatchCtx;
+    private tokenStreamBridge;
+    private eventSeq;
+    private statusInterval;
+    private pingInterval;
+    private orphanTimer;
+    private readonly aliveClients;
+    private readonly missedPings;
+    private readonly staticRoot;
+    private readonly staticCache;
+    constructor(options: WebUiServerOptions);
+    /** Returns the event bus for external producers. */
+    getEventBus(): WebEventBus;
+    /** Set the WorkflowManager after construction (avoids circular dependency). */
+    setWorkflowManager(manager: WorkflowManager): void;
+    /** Returns the bearer auth token for external consumers (e.g., CLI observe). */
+    getAuthToken(): string;
+    /** Returns the actual port the server is listening on. */
+    getPort(): number;
+    /** Set the TokenStreamBridge after construction. */
+    setTokenStreamBridge(bridge: TokenStreamBridge): void;
+    start(): Promise<string>;
+    stop(): Promise<void>;
+    private broadcast;
+    /**
+     * Send an event frame to a specific set of clients (targeted delivery).
+     * Used by TokenStreamBridge for per-subscription delivery without
+     * modifying the generic broadcast() path.
+     */
+    sendToSubscribers(clients: ReadonlySet<WsWebSocket>, event: string, payload: unknown): void;
+    private pingClients;
+    private removeClient;
+    private static readonly ORPHAN_GRACE_MS;
+    private startOrphanTimerIfNeeded;
+    private cancelOrphanTimer;
+    private cleanupOrphanedWebSessions;
+    private handleHttpRequest;
+    private serveFromCache;
+    private handleUpgrade;
+    private verifyToken;
+    private isValidOrigin;
+    private handleMessage;
+}