@shepai/cli 1.26.0 → 1.27.0

package/dist/packages/core/src/infrastructure/services/notifications/desktop-notifier.js

@@ -0,0 +1,39 @@
+/**
+ * Desktop Notifier
+ *
+ * Wraps node-notifier to send native OS desktop notifications
+ * (macOS Notification Center, Linux libnotify, Windows toast).
+ *
+ * All inputs are sanitized before passing to node-notifier:
+ * - Shell metacharacters are stripped (defense in depth)
+ * - Title truncated to 100 chars, body to 500 chars
+ * - Errors are caught and logged (never thrown)
+ */
+import notifier from 'node-notifier';
+const SHELL_METACHAR_REGEX = /[`$|;&()<>]/g;
+const MAX_TITLE_LENGTH = 100;
+const MAX_BODY_LENGTH = 500;
+export class DesktopNotifier {
+    /**
+     * Send a native OS desktop notification.
+     *
+     * @param title - Notification title (sanitized and truncated)
+     * @param body - Notification body text (sanitized and truncated)
+     */
+    send(title, body) {
+        try {
+            notifier.notify({
+                title: this.sanitize(title, MAX_TITLE_LENGTH),
+                message: this.sanitize(body, MAX_BODY_LENGTH),
+            });
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.warn('Desktop notification failed:', error);
+        }
+    }
+    sanitize(input, maxLength) {
+        const cleaned = input.replace(SHELL_METACHAR_REGEX, '');
+        return cleaned.slice(0, maxLength);
+    }
+}

package/dist/packages/core/src/infrastructure/services/notifications/notification-bus.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Notification Event Bus
+ *
+ * Typed EventEmitter singleton for in-process pub/sub of notification events.
+ * Follows the getSettings() singleton pattern from settings.service.ts.
+ *
+ * Multiple listeners can subscribe to the 'notification' event for fan-out
+ * delivery (SSE clients, desktop notifier, etc.).
+ *
+ * Usage:
+ * ```typescript
+ * import { getNotificationBus } from './notification-bus.js';
+ *
+ * const bus = getNotificationBus();
+ * bus.on('notification', (event) => { ... });
+ * bus.emit('notification', event);
+ * ```
+ */
+import { EventEmitter } from 'node:events';
+import type { NotificationEvent } from '../../../domain/generated/output.js';
+export interface NotificationEventMap {
+    notification: [event: NotificationEvent];
+}
+export type NotificationBus = EventEmitter<NotificationEventMap>;
+/**
+ * Initialize the notification event bus singleton.
+ * Must be called once during CLI bootstrap.
+ *
+ * @throws Error if the bus is already initialized
+ */
+export declare function initializeNotificationBus(): void;
+/**
+ * Get the notification event bus singleton.
+ *
+ * @returns The notification event bus
+ * @throws Error if the bus hasn't been initialized yet
+ */
+export declare function getNotificationBus(): NotificationBus;
+/**
+ * Check if the notification bus has been initialized.
+ *
+ * @returns True if the bus is initialized, false otherwise
+ */
+export declare function hasNotificationBus(): boolean;
+/**
+ * Reset the notification bus singleton (for testing purposes only).
+ * DO NOT use in production code.
+ *
+ * @internal
+ */
+export declare function resetNotificationBus(): void;
+//# sourceMappingURL=notification-bus.d.ts.map

package/dist/packages/core/src/infrastructure/services/notifications/notification-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-bus.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/notifications/notification-bus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAE7E,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;CAC1C;AAED,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,oBAAoB,CAAC,CAAC;AAIjE;;;;;GAKG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAMhD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAQpD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAK3C"}

package/dist/packages/core/src/infrastructure/services/notifications/notification-bus.js

@@ -0,0 +1,64 @@
+/**
+ * Notification Event Bus
+ *
+ * Typed EventEmitter singleton for in-process pub/sub of notification events.
+ * Follows the getSettings() singleton pattern from settings.service.ts.
+ *
+ * Multiple listeners can subscribe to the 'notification' event for fan-out
+ * delivery (SSE clients, desktop notifier, etc.).
+ *
+ * Usage:
+ * ```typescript
+ * import { getNotificationBus } from './notification-bus.js';
+ *
+ * const bus = getNotificationBus();
+ * bus.on('notification', (event) => { ... });
+ * bus.emit('notification', event);
+ * ```
+ */
+import { EventEmitter } from 'node:events';
+let busInstance = null;
+/**
+ * Initialize the notification event bus singleton.
+ * Must be called once during CLI bootstrap.
+ *
+ * @throws Error if the bus is already initialized
+ */
+export function initializeNotificationBus() {
+    if (busInstance !== null) {
+        throw new Error('Notification bus already initialized. Cannot re-initialize.');
+    }
+    busInstance = new EventEmitter();
+}
+/**
+ * Get the notification event bus singleton.
+ *
+ * @returns The notification event bus
+ * @throws Error if the bus hasn't been initialized yet
+ */
+export function getNotificationBus() {
+    if (busInstance === null) {
+        throw new Error('Notification bus not initialized. Call initializeNotificationBus() during CLI bootstrap.');
+    }
+    return busInstance;
+}
+/**
+ * Check if the notification bus has been initialized.
+ *
+ * @returns True if the bus is initialized, false otherwise
+ */
+export function hasNotificationBus() {
+    return busInstance !== null;
+}
+/**
+ * Reset the notification bus singleton (for testing purposes only).
+ * DO NOT use in production code.
+ *
+ * @internal
+ */
+export function resetNotificationBus() {
+    if (busInstance !== null) {
+        busInstance.removeAllListeners();
+    }
+    busInstance = null;
+}

package/dist/packages/core/src/infrastructure/services/notifications/notification-watcher.service.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Notification Watcher Service
+ *
+ * Polls the agent_runs and phase_timings tables to detect status
+ * transitions, dispatching NotificationEvents via the NotificationService
+ * (which handles settings filters, bus fan-out, and desktop dispatch).
+ *
+ * Maintains in-memory tracking of last-seen status per run to avoid
+ * duplicate notifications. Polling starts/stops with start()/stop()
+ * lifecycle methods.
+ *
+ * Design decision: Uses DB polling instead of IPC because the worker
+ * process is spawned detached with IPC disconnected.
+ */
+import type { IAgentRunRepository } from '../../../application/ports/output/agents/agent-run-repository.interface.js';
+import type { IPhaseTimingRepository } from '../../../application/ports/output/agents/phase-timing-repository.interface.js';
+import type { INotificationService } from '../../../application/ports/output/services/notification-service.interface.js';
+export declare class NotificationWatcherService {
+    private readonly runRepository;
+    private readonly phaseTimingRepository;
+    private readonly notificationService;
+    private readonly pollIntervalMs;
+    private readonly trackedRuns;
+    private intervalId;
+    constructor(runRepository: IAgentRunRepository, phaseTimingRepository: IPhaseTimingRepository, notificationService: INotificationService, pollIntervalMs?: number);
+    isRunning(): boolean;
+    start(): void;
+    stop(): void;
+    private poll;
+    private processRuns;
+    private emitStatusEvent;
+    private checkPhaseCompletions;
+    private resolveFeatureName;
+}
+/**
+ * Initialize the notification watcher singleton.
+ * Must be called once during web server startup.
+ *
+ * @throws Error if the watcher is already initialized
+ */
+export declare function initializeNotificationWatcher(runRepository: IAgentRunRepository, phaseTimingRepository: IPhaseTimingRepository, notificationService: INotificationService, pollIntervalMs?: number): void;
+/**
+ * Get the notification watcher singleton.
+ *
+ * @returns The notification watcher service
+ * @throws Error if the watcher hasn't been initialized yet
+ */
+export declare function getNotificationWatcher(): NotificationWatcherService;
+/**
+ * Check if the notification watcher has been initialized.
+ */
+export declare function hasNotificationWatcher(): boolean;
+/**
+ * Reset the notification watcher singleton (for testing purposes only).
+ * Stops the watcher if running before resetting.
+ *
+ * @internal
+ */
+export declare function resetNotificationWatcher(): void;
+//# sourceMappingURL=notification-watcher.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/notifications/notification-watcher.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-watcher.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/notifications/notification-watcher.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAQH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4EAA4E,CAAC;AACtH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+EAA+E,CAAC;AAC5H,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8EAA8E,CAAC;AAmDzH,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsB;IACpD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAyB;IAC/D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAuB;IAC3D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmC;IAC/D,OAAO,CAAC,UAAU,CAA+C;gBAG/D,aAAa,EAAE,mBAAmB,EAClC,qBAAqB,EAAE,sBAAsB,EAC7C,mBAAmB,EAAE,oBAAoB,EACzC,cAAc,GAAE,MAAiC;IAQnD,SAAS,IAAI,OAAO;IAIpB,KAAK,IAAI,IAAI;IAWb,IAAI,IAAI,IAAI;YAOE,IAAI;YAUJ,WAAW;IAoDzB,OAAO,CAAC,eAAe;YAgBT,qBAAqB;IAsBnC,OAAO,CAAC,kBAAkB;CAS3B;AAMD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,mBAAmB,EAClC,qBAAqB,EAAE,sBAAsB,EAC7C,mBAAmB,EAAE,oBAAoB,EACzC,cAAc,CAAC,EAAE,MAAM,GACtB,IAAI,CAWN;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,0BAA0B,CAQnE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAK/C"}

package/dist/packages/core/src/infrastructure/services/notifications/notification-watcher.service.js

@@ -0,0 +1,225 @@
+/**
+ * Notification Watcher Service
+ *
+ * Polls the agent_runs and phase_timings tables to detect status
+ * transitions, dispatching NotificationEvents via the NotificationService
+ * (which handles settings filters, bus fan-out, and desktop dispatch).
+ *
+ * Maintains in-memory tracking of last-seen status per run to avoid
+ * duplicate notifications. Polling starts/stops with start()/stop()
+ * lifecycle methods.
+ *
+ * Design decision: Uses DB polling instead of IPC because the worker
+ * process is spawned detached with IPC disconnected.
+ */
+import { AgentRunStatus, NotificationEventType, NotificationSeverity, } from '../../../domain/generated/output.js';
+const DEFAULT_POLL_INTERVAL_MS = 3000;
+const ACTIVE_STATUSES = new Set([
+    AgentRunStatus.pending,
+    AgentRunStatus.running,
+    AgentRunStatus.waitingApproval,
+]);
+const TERMINAL_STATUSES = new Set([
+    AgentRunStatus.completed,
+    AgentRunStatus.failed,
+    AgentRunStatus.cancelled,
+    AgentRunStatus.interrupted,
+]);
+const STATUS_TO_EVENT = {
+    [AgentRunStatus.running]: {
+        eventType: NotificationEventType.AgentStarted,
+        severity: NotificationSeverity.Info,
+    },
+    [AgentRunStatus.waitingApproval]: {
+        eventType: NotificationEventType.WaitingApproval,
+        severity: NotificationSeverity.Warning,
+    },
+    [AgentRunStatus.completed]: {
+        eventType: NotificationEventType.AgentCompleted,
+        severity: NotificationSeverity.Success,
+    },
+    [AgentRunStatus.failed]: {
+        eventType: NotificationEventType.AgentFailed,
+        severity: NotificationSeverity.Error,
+    },
+};
+const EVENT_MESSAGES = {
+    [NotificationEventType.AgentStarted]: 'Feature agent started',
+    [NotificationEventType.WaitingApproval]: 'Feature agent is waiting for approval',
+    [NotificationEventType.AgentCompleted]: 'Feature agent completed successfully',
+    [NotificationEventType.AgentFailed]: 'Feature agent failed',
+};
+export class NotificationWatcherService {
+    runRepository;
+    phaseTimingRepository;
+    notificationService;
+    pollIntervalMs;
+    trackedRuns = new Map();
+    intervalId = null;
+    constructor(runRepository, phaseTimingRepository, notificationService, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS) {
+        this.runRepository = runRepository;
+        this.phaseTimingRepository = phaseTimingRepository;
+        this.notificationService = notificationService;
+        this.pollIntervalMs = pollIntervalMs;
+    }
+    isRunning() {
+        return this.intervalId !== null;
+    }
+    start() {
+        if (this.intervalId !== null)
+            return;
+        // Run first poll immediately
+        void this.poll();
+        this.intervalId = setInterval(() => {
+            void this.poll();
+        }, this.pollIntervalMs);
+    }
+    stop() {
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    async poll() {
+        try {
+            const runs = await this.runRepository.list();
+            await this.processRuns(runs);
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.warn('NotificationWatcherService poll failed:', error);
+        }
+    }
+    async processRuns(runs) {
+        const currentRunIds = new Set();
+        for (const run of runs) {
+            if (!ACTIVE_STATUSES.has(run.status) && !this.trackedRuns.has(run.id)) {
+                // Skip terminal runs we haven't been tracking
+                continue;
+            }
+            currentRunIds.add(run.id);
+            const prevState = this.trackedRuns.get(run.id);
+            if (!prevState) {
+                // New run — track and emit initial status event
+                const featureName = this.resolveFeatureName(run);
+                const newState = {
+                    status: run.status,
+                    completedPhases: new Set(),
+                    featureName,
+                };
+                this.trackedRuns.set(run.id, newState);
+                this.emitStatusEvent(run, newState);
+                // Check for completed phases on first observation
+                await this.checkPhaseCompletions(run.id, newState);
+            }
+            else if (prevState.status !== run.status) {
+                // Status changed — emit event
+                prevState.status = run.status;
+                this.emitStatusEvent(run, prevState);
+                if (TERMINAL_STATUSES.has(run.status)) {
+                    // Run reached terminal state — clean up after emitting
+                    this.trackedRuns.delete(run.id);
+                }
+                else {
+                    // Still active — check for phase completions
+                    await this.checkPhaseCompletions(run.id, prevState);
+                }
+            }
+            else {
+                // Same status — just check for phase completions
+                await this.checkPhaseCompletions(run.id, prevState);
+            }
+        }
+        // Clean up tracking for runs that disappeared from the list
+        for (const trackedId of this.trackedRuns.keys()) {
+            if (!currentRunIds.has(trackedId)) {
+                this.trackedRuns.delete(trackedId);
+            }
+        }
+    }
+    emitStatusEvent(run, state) {
+        const mapping = STATUS_TO_EVENT[run.status];
+        if (!mapping)
+            return;
+        const event = {
+            eventType: mapping.eventType,
+            agentRunId: run.id,
+            featureName: state.featureName,
+            message: EVENT_MESSAGES[mapping.eventType] ?? `Agent status: ${run.status}`,
+            severity: mapping.severity,
+            timestamp: new Date().toISOString(),
+        };
+        this.notificationService.notify(event);
+    }
+    async checkPhaseCompletions(runId, state) {
+        const timings = await this.phaseTimingRepository.findByRunId(runId);
+        for (const timing of timings) {
+            if (timing.completedAt && !state.completedPhases.has(timing.phase)) {
+                state.completedPhases.add(timing.phase);
+                const event = {
+                    eventType: NotificationEventType.PhaseCompleted,
+                    agentRunId: runId,
+                    featureName: state.featureName,
+                    phaseName: timing.phase,
+                    message: `Completed ${timing.phase} phase`,
+                    severity: NotificationSeverity.Info,
+                    timestamp: new Date().toISOString(),
+                };
+                this.notificationService.notify(event);
+            }
+        }
+    }
+    resolveFeatureName(run) {
+        // Feature name resolution from featureId would require IFeatureRepository.
+        // For now, use the agentName or a fallback. The NotificationService or
+        // a higher layer can enrich with the actual feature name if needed.
+        if (run.featureId) {
+            return `Feature ${run.featureId}`;
+        }
+        return `Agent ${run.id}`;
+    }
+}
+// --- Singleton accessors (follows getNotificationBus() pattern) ---
+let watcherInstance = null;
+/**
+ * Initialize the notification watcher singleton.
+ * Must be called once during web server startup.
+ *
+ * @throws Error if the watcher is already initialized
+ */
+export function initializeNotificationWatcher(runRepository, phaseTimingRepository, notificationService, pollIntervalMs) {
+    if (watcherInstance !== null) {
+        throw new Error('Notification watcher already initialized. Cannot re-initialize.');
+    }
+    watcherInstance = new NotificationWatcherService(runRepository, phaseTimingRepository, notificationService, pollIntervalMs);
+}
+/**
+ * Get the notification watcher singleton.
+ *
+ * @returns The notification watcher service
+ * @throws Error if the watcher hasn't been initialized yet
+ */
+export function getNotificationWatcher() {
+    if (watcherInstance === null) {
+        throw new Error('Notification watcher not initialized. Call initializeNotificationWatcher() during web server startup.');
+    }
+    return watcherInstance;
+}
+/**
+ * Check if the notification watcher has been initialized.
+ */
+export function hasNotificationWatcher() {
+    return watcherInstance !== null;
+}
+/**
+ * Reset the notification watcher singleton (for testing purposes only).
+ * Stops the watcher if running before resetting.
+ *
+ * @internal
+ */
+export function resetNotificationWatcher() {
+    if (watcherInstance !== null) {
+        watcherInstance.stop();
+    }
+    watcherInstance = null;
+}

package/dist/packages/core/src/infrastructure/services/notifications/notification.service.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Notification Service
+ *
+ * Implements INotificationService port interface. Fans out notification
+ * events to enabled channels:
+ * - Notification bus (for SSE → in-app toasts and browser notifications)
+ * - Desktop notifier (node-notifier for OS-level notifications)
+ *
+ * Channel enable/disable and event type filters are read from Settings.
+ */
+import type { NotificationEvent } from '../../../domain/generated/output.js';
+import type { INotificationService } from '../../../application/ports/output/services/notification-service.interface.js';
+import type { NotificationBus } from './notification-bus.js';
+import type { DesktopNotifier } from './desktop-notifier.js';
+export declare class NotificationService implements INotificationService {
+    private readonly bus;
+    private readonly desktopNotifier;
+    constructor(bus: NotificationBus, desktopNotifier: DesktopNotifier);
+    notify(event: NotificationEvent): void;
+}
+//# sourceMappingURL=notification.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/notifications/notification.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/notifications/notification.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8EAA8E,CAAC;AAEzH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAU7D,qBAAa,mBAAoB,YAAW,oBAAoB;IAC9D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;gBAEtC,GAAG,EAAE,eAAe,EAAE,eAAe,EAAE,eAAe;IAKlE,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;CAmBvC"}

package/dist/packages/core/src/infrastructure/services/notifications/notification.service.js

@@ -0,0 +1,43 @@
+/**
+ * Notification Service
+ *
+ * Implements INotificationService port interface. Fans out notification
+ * events to enabled channels:
+ * - Notification bus (for SSE → in-app toasts and browser notifications)
+ * - Desktop notifier (node-notifier for OS-level notifications)
+ *
+ * Channel enable/disable and event type filters are read from Settings.
+ */
+import { NotificationEventType } from '../../../domain/generated/output.js';
+import { getSettings } from '../settings.service.js';
+const EVENT_TYPE_TO_CONFIG_KEY = {
+    [NotificationEventType.AgentStarted]: 'agentStarted',
+    [NotificationEventType.PhaseCompleted]: 'phaseCompleted',
+    [NotificationEventType.WaitingApproval]: 'waitingApproval',
+    [NotificationEventType.AgentCompleted]: 'agentCompleted',
+    [NotificationEventType.AgentFailed]: 'agentFailed',
+};
+export class NotificationService {
+    bus;
+    desktopNotifier;
+    constructor(bus, desktopNotifier) {
+        this.bus = bus;
+        this.desktopNotifier = desktopNotifier;
+    }
+    notify(event) {
+        const { notifications } = getSettings();
+        // Check event type filter
+        const configKey = EVENT_TYPE_TO_CONFIG_KEY[event.eventType];
+        if (configKey && !notifications.events[configKey]) {
+            return;
+        }
+        // Emit to bus if in-app or browser channel is enabled
+        if (notifications.inApp.enabled || notifications.browser.enabled) {
+            this.bus.emit('notification', event);
+        }
+        // Dispatch to desktop notifier if desktop channel is enabled
+        if (notifications.desktop.enabled) {
+            this.desktopNotifier.send(event.featureName, event.message);
+        }
+    }
+}

package/dist/src/presentation/cli/commands/ui.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ui.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/ui.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAiB1D;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CA0DzC"}
+{"version":3,"file":"ui.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/ui.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAwB1D;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAkEzC"}

package/dist/src/presentation/cli/commands/ui.command.js

@@ -19,6 +19,7 @@ import { findAvailablePort, DEFAULT_PORT } from '../../../../packages/core/src/i
 import { container } from '../../../../packages/core/src/infrastructure/di/container.js';
 import { setVersionEnvVars } from '../../../../packages/core/src/infrastructure/services/version.service.js';
 import { resolveWebDir } from '../../../../packages/core/src/infrastructure/services/web-server.service.js';
+import { initializeNotificationWatcher, getNotificationWatcher, } from '../../../../packages/core/src/infrastructure/services/notifications/notification-watcher.service.js';
 import { colors, fmt, messages } from '../ui/index.js';
 function parsePort(value) {
     const port = parseInt(value, 10);
@@ -52,6 +53,12 @@ Examples:
             messages.newline();
             const service = container.resolve('IWebServerService');
             await service.start(port, dir, dev);
+            // Start notification watcher to detect agent status transitions
+            const runRepo = container.resolve('IAgentRunRepository');
+            const phaseTimingRepo = container.resolve('IPhaseTimingRepository');
+            const notificationService = container.resolve('INotificationService');
+            initializeNotificationWatcher(runRepo, phaseTimingRepo, notificationService);
+            getNotificationWatcher().start();
             messages.success(`Server ready at ${fmt.code(`http://localhost:${port}`)}`);
             messages.info('Press Ctrl+C to stop');
             messages.newline();
@@ -67,6 +74,7 @@ Examples:
                 // Force exit after 5s if graceful shutdown stalls
                 const forceExit = setTimeout(() => process.exit(0), 5000);
                 forceExit.unref();
+                getNotificationWatcher().stop();
                 await service.stop();
                 process.exit(0);
             };

package/dist/src/presentation/web/app/api/agent-events/route.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SSE API Route: GET /api/agent-events
+ *
+ * Streams agent lifecycle notification events to connected web UI clients
+ * via Server-Sent Events (SSE). This is the first API route in the web UI.
+ *
+ * - Subscribes to the notification event bus (shared in-process singleton)
+ * - Formats events as SSE data frames (event: notification\ndata: JSON\n\n)
+ * - Sends heartbeat comments every 30 seconds to keep connection alive
+ * - Supports optional ?runId query parameter to filter events
+ * - Cleans up listeners and intervals on client disconnect
+ */
+export declare function GET(request: Request): Response;
+//# sourceMappingURL=route.d.ts.map

package/dist/src/presentation/web/app/api/agent-events/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/app/api/agent-events/route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAkBH,wBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CA+D9C"}

package/dist/src/presentation/web/app/api/agent-events/route.js

@@ -0,0 +1,77 @@
+/**
+ * SSE API Route: GET /api/agent-events
+ *
+ * Streams agent lifecycle notification events to connected web UI clients
+ * via Server-Sent Events (SSE). This is the first API route in the web UI.
+ *
+ * - Subscribes to the notification event bus (shared in-process singleton)
+ * - Formats events as SSE data frames (event: notification\ndata: JSON\n\n)
+ * - Sends heartbeat comments every 30 seconds to keep connection alive
+ * - Supports optional ?runId query parameter to filter events
+ * - Cleans up listeners and intervals on client disconnect
+ */
+import { getNotificationBus, hasNotificationBus, } from '../../../../../../packages/core/src/infrastructure/services/notifications/notification-bus.js';
+const HEARTBEAT_INTERVAL_MS = 30_000;
+function formatSSEEvent(event) {
+    return `event: notification\ndata: ${JSON.stringify(event)}\n\n`;
+}
+function formatHeartbeat() {
+    return ': heartbeat\n\n';
+}
+export function GET(request) {
+    const url = new URL(request.url);
+    const runIdFilter = url.searchParams.get('runId');
+    const stream = new ReadableStream({
+        start(controller) {
+            const encoder = new TextEncoder();
+            // Check if bus is available
+            if (!hasNotificationBus()) {
+                controller.close();
+                return;
+            }
+            const bus = getNotificationBus();
+            // Notification event listener
+            const onNotification = (event) => {
+                // Apply runId filter if set
+                if (runIdFilter && event.agentRunId !== runIdFilter) {
+                    return;
+                }
+                try {
+                    controller.enqueue(encoder.encode(formatSSEEvent(event)));
+                }
+                catch {
+                    // Stream may be closed — ignore enqueue errors
+                }
+            };
+            bus.on('notification', onNotification);
+            // Heartbeat to keep connection alive
+            const heartbeatInterval = setInterval(() => {
+                try {
+                    controller.enqueue(encoder.encode(formatHeartbeat()));
+                }
+                catch {
+                    // Stream may be closed — ignore enqueue errors
+                }
+            }, HEARTBEAT_INTERVAL_MS);
+            // Cleanup on client disconnect
+            const cleanup = () => {
+                bus.removeListener('notification', onNotification);
+                clearInterval(heartbeatInterval);
+                try {
+                    controller.close();
+                }
+                catch {
+                    // Stream may already be closed
+                }
+            };
+            request.signal.addEventListener('abort', cleanup, { once: true });
+        },
+    });
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+        },
+    });
+}

package/dist/src/presentation/web/app/page.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/app/page.tsx"],"names":[],"mappings":"AAQA,6EAA6E;AAC7E,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAqBvC,wBAA8B,QAAQ,qDAsFrC"}
+{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/app/page.tsx"],"names":[],"mappings":"AAWA,6EAA6E;AAC7E,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAqBvC,wBAA8B,QAAQ,qDAmFrC"}