@provos/ironcurtain 0.5.1 → 0.7.0

package/dist/signal/signal-bot-daemon.js

@@ -9,14 +9,19 @@
  * - Identity verification with TTL cache (5 min), fail-closed
  * - Escalation state with race prevention (per-session)
  * - Message sending via POST /v2/send with text_mode: "styled"
+ *
+ * Session state is owned by SessionManager (injected via constructor).
+ * This class only handles Signal-specific concerns: WebSocket, identity,
+ * message parsing, and command dispatch.
  */
 import { createSession } from '../session/index.js';
 import { loadConfig } from '../config/index.js';
 import { loadUserConfig } from '../config/user-config.js';
 import { resolveSignalConfig } from './signal-config.js';
+import { SessionManager } from '../session/session-manager.js';
 import { SignalSessionTransport } from './signal-transport.js';
 import { markdownToSignal } from './markdown-to-signal.js';
-import { formatBudgetMessage, formatBudgetSummary, formatSessionList, prefixWithLabel, splitMessage, SIGNAL_MAX_MESSAGE_LENGTH, } from './format.js';
+import { formatBudgetMessage, formatBudgetSummary, formatJobList, formatSessionList, prefixWithLabel, splitMessage, SIGNAL_MAX_MESSAGE_LENGTH, } from './format.js';
 import { BudgetExhaustedError } from '../session/errors.js';
 import * as logger from '../logger.js';
 /** How often to proactively verify the recipient's identity key (ms). */
@@ -25,6 +30,7 @@ export class SignalBotDaemon {
     config;
     containerManager;
     mode;
+    sessionManager;
     // WebSocket state
     ws = null;
     baseUrl = '';
@@ -32,10 +38,6 @@ export class SignalBotDaemon {
     reconnectAttempts = 0;
     static MAX_RECONNECT_DELAY_MS = 30_000;
     static BASE_RECONNECT_DELAY_MS = 1_000;
-    // Multi-session state
-    sessions = new Map();
-    currentLabel = null;
-    nextLabel = 1;
     maxConcurrentSessions;
     // Identity verification state
     identityLocked = false;
@@ -54,6 +56,7 @@ export class SignalBotDaemon {
         this.containerManager = options.containerManager;
         this.mode = options.mode;
         this.maxConcurrentSessions = options.config.maxConcurrentSessions;
+        this.sessionManager = options.sessionManager ?? new SessionManager();
     }
     /**
      * Schedules a session-mutating operation (/new, /quit) so that
@@ -66,21 +69,45 @@ export class SignalBotDaemon {
         });
     }
     /**
-     * Starts the daemon. Returns a promise that resolves when
-     * shutdown() is called (e.g., SIGTERM/SIGINT).
+     * Connects the daemon: starts the Docker container, waits for
+     * health, connects WebSocket, and sends the online greeting.
+     * Throws if any step fails (container won't start, health timeout, etc.).
      */
-    async start() {
+    async connect() {
+        logger.info('[Signal Daemon] Ensuring container is running...');
         this.baseUrl = await this.containerManager.ensureRunning();
+        logger.info('[Signal Daemon] Waiting for container health check...');
         await this.containerManager.waitForHealthy(this.baseUrl);
+        logger.info('[Signal Daemon] Connecting WebSocket...');
         await this.connectWebSocket();
-        await this.sendSignalMessage('IronCurtain bot is online. Send a message to begin.');
-        // Block until shutdown
+        // Greeting is best-effort — signal-cli may be healthy but not yet
+        // fully connected to Signal servers (e.g., broken pipe on first send).
+        try {
+            await this.sendSignalMessage('IronCurtain bot is online. Send a message to begin.');
+        }
+        catch (err) {
+            logger.warn(`[Signal Daemon] Greeting failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Blocks until shutdown() is called (e.g., SIGTERM/SIGINT).
+     * Call connect() first to establish the connection.
+     */
+    async run() {
         await new Promise((resolve) => {
             this.exitResolve = resolve;
         });
     }
     /**
-     * Initiates graceful shutdown. Ends all active sessions,
+     * Convenience: connects and then blocks until shutdown.
+     * Used by the standalone `ironcurtain bot` command.
+     */
+    async start() {
+        await this.connect();
+        await this.run();
+    }
+    /**
+     * Initiates graceful shutdown. Ends all Signal sessions,
      * closes the WebSocket, and unblocks start().
      */
     async shutdown() {
@@ -89,10 +116,10 @@ export class SignalBotDaemon {
         await this.sendSignalMessage('IronCurtain bot is shutting down. Goodbye.').catch(() => { });
         // Wait for any in-flight session operations (e.g., /new) to complete
         await this.sessionOpInProgress.catch(() => { });
-        // End all sessions without letting a single failure abort shutdown
-        const labels = [...this.sessions.keys()];
-        await Promise.allSettled(labels.map((label) => this.endSession(label).catch((err) => {
-            logger.error(`[Signal Daemon] Failed to end session #${label} during shutdown: ${String(err)}`);
+        // End all Signal sessions without letting a single failure abort shutdown
+        const signalSessions = this.sessionManager.byKind('signal');
+        await Promise.allSettled(signalSessions.map((managed) => this.sessionManager.end(managed.label).catch((err) => {
+            logger.error(`[Signal Daemon] Failed to end session #${managed.label} during shutdown: ${String(err)}`);
         })));
         if (this.ws) {
             this.ws.close();
@@ -197,21 +224,29 @@ export class SignalBotDaemon {
         if (!text)
             return;
         // Escalation replies: approve/deny (also accept /approve, /deny)
+        // This works across ALL session types (signal + cron)
         if (this.handleEscalationReply(text))
             return;
-        // Control commands: /quit, /new, /sessions, /switch, /budget, /help
+        // Control commands: /quit, /new, /sessions, /switch, /budget, /jobs, /help
         if (this.handleControlCommand(text))
             return;
-        // Regular message -> route to session
+        // Reject unrecognized slash commands rather than forwarding to agent
+        if (text.trimStart().startsWith('/')) {
+            const cmd = text.trim().split(/\s/)[0];
+            await this.sendSignalMessage(`Unknown command: ${cmd}\nSend /help for available commands.`);
+            return;
+        }
+        // Regular message -> route to Signal session
         await this.routeToSession(text);
     }
     /**
-     * Routes a user message to the current session. Creates a new
+     * Routes a user message to the current Signal session. Creates a new
      * session if none exists. Handles BudgetExhaustedError by ending
      * the exhausted session and notifying the user.
      *
      * Supports one-shot `#N` prefix routing: `#2 do something` routes
      * "do something" to session #2 without changing currentLabel.
+     * Only Signal sessions accept forwarded messages.
      */
     async routeToSession(text) {
         // Wait for any pending session operation (/new, /quit) to complete
@@ -221,23 +256,27 @@ export class SignalBotDaemon {
         const { targetLabel, messageText } = parseHashPrefix(text);
         // If #N prefix was used, route directly to that session (no auto-create)
         if (targetLabel !== null) {
-            const managed = this.sessions.get(targetLabel);
+            const managed = this.sessionManager.get(targetLabel);
             if (!managed) {
                 await this.sendSignalMessage(`No session #${targetLabel}.`);
                 return;
             }
+            if (managed.source.kind !== 'signal') {
+                await this.sendSignalMessage(`Session #${targetLabel} is a ${managed.source.kind} session and does not accept messages.`);
+                return;
+            }
             await this.forwardToSession(managed, messageText);
             return;
         }
         // Create session on demand if none exists.
         // Serialize through scheduleSessionOp so concurrent messages don't
         // race to create multiple sessions.
-        if (this.currentLabel === null) {
+        if (this.sessionManager.currentLabel === null) {
             const createOp = new Promise((resolve, reject) => {
                 this.scheduleSessionOp(async () => {
                     try {
                         // Re-check after serialization — another message may have created one
-                        if (this.currentLabel === null) {
+                        if (this.sessionManager.currentLabel === null) {
                             await this.startNewSession();
                         }
                         resolve();
@@ -256,9 +295,10 @@ export class SignalBotDaemon {
                 return;
             }
         }
-        if (this.currentLabel === null)
+        const currentLabel = this.sessionManager.currentLabel;
+        if (currentLabel === null)
             return;
-        const managed = this.sessions.get(this.currentLabel);
+        const managed = this.sessionManager.get(currentLabel);
         if (!managed)
             return;
         await this.forwardToSession(managed, messageText);
@@ -268,18 +308,23 @@ export class SignalBotDaemon {
      * in-flight guards, BudgetExhaustedError, and response formatting.
      */
     async forwardToSession(managed, text) {
+        const transport = managed.transport;
+        const sessionCount = this.sessionManager.size;
         logger.info(`[Signal Daemon] Routing message to session #${managed.label} ` +
-            `(currentLabel=${this.currentLabel}, sessions=${[...this.sessions.keys()].join(',')}, ` +
-            `transportLabel=${managed.transport.sessionLabel})`);
+            `(currentLabel=${this.sessionManager.currentLabel}, sessions=${this.sessionManager
+                .all()
+                .map((m) => m.label)
+                .join(',')}, ` +
+            `transportLabel=${transport.sessionLabel})`);
         if (managed.messageInFlight) {
-            await this.sendSignalMessage(prefixWithLabel('Still processing previous message, please wait...', managed.label, this.sessions.size));
+            await this.sendSignalMessage(prefixWithLabel('Still processing previous message, please wait...', managed.label, sessionCount));
             return;
         }
         managed.messageInFlight = true;
         try {
-            const response = await managed.transport.forwardMessage(text);
+            const response = await transport.forwardMessage(text);
             const styledText = markdownToSignal(response);
-            await this.sendSignalMessage(prefixWithLabel(styledText, managed.label, this.sessions.size));
+            await this.sendSignalMessage(prefixWithLabel(styledText, managed.label, this.sessionManager.size));
         }
         catch (error) {
             if (error instanceof BudgetExhaustedError) {
@@ -287,12 +332,12 @@ export class SignalBotDaemon {
                 await this.sendSignalMessage(prefixWithLabel(`Session budget exhausted: ${error.message}\n` +
                     formatBudgetSummary(status) +
                     '\n' +
-                    'Send a new message to start a fresh session.', managed.label, this.sessions.size));
-                await this.endSession(managed.label);
+                    'Send a new message to start a fresh session.', managed.label, this.sessionManager.size));
+                await this.sessionManager.end(managed.label);
             }
             else {
                 const message = error instanceof Error ? error.message : String(error);
-                await this.sendSignalMessage(prefixWithLabel(`Error: ${message}`, managed.label, this.sessions.size));
+                await this.sendSignalMessage(prefixWithLabel(`Error: ${message}`, managed.label, this.sessionManager.size));
             }
         }
         finally {
@@ -301,18 +346,18 @@ export class SignalBotDaemon {
     }
     // --- Session lifecycle ---
     /**
-     * Creates a new session with a fresh SignalSessionTransport.
+     * Creates a new Signal session with a fresh SignalSessionTransport.
      * Follows the same pattern as index.ts: create transport,
      * wire callbacks, create session, start transport.
      * Returns the label of the new session.
      */
     async startNewSession() {
-        if (this.sessions.size >= this.maxConcurrentSessions) {
+        // Count only Signal sessions toward the concurrency limit
+        const signalSessionCount = this.sessionManager.byKind('signal').length;
+        if (signalSessionCount >= this.maxConcurrentSessions) {
             throw new Error(`Session limit reached (max ${this.maxConcurrentSessions}). Use /quit to end a session first.`);
         }
-        const label = this.nextLabel++;
         const transport = new SignalSessionTransport(this);
-        transport.sessionLabel = label;
         const config = loadConfig();
         const session = await createSession({
             config,
@@ -321,81 +366,36 @@ export class SignalBotDaemon {
             onEscalationExpired: transport.createEscalationExpiredHandler(),
             onDiagnostic: transport.createDiagnosticHandler(),
         });
-        const managed = {
-            label,
-            session,
-            transport,
-            messageInFlight: false,
-            pendingEscalationId: null,
-            escalationResolving: false,
-        };
-        this.sessions.set(label, managed);
-        this.currentLabel = label;
+        const label = this.sessionManager.register(session, transport, { kind: 'signal' });
+        transport.sessionLabel = label;
         // Start the transport in the background. When it resolves
         // (session closed/budget exhausted), clean up.
         transport
             .run(session)
             .then(() => {
             // Transport exited - remove session if still present
-            if (this.sessions.has(label)) {
-                this.sessions.delete(label);
-                if (this.currentLabel === label) {
-                    this.autoSwitchCurrent();
-                }
+            const managed = this.sessionManager.get(label);
+            if (managed) {
+                this.sessionManager.end(label).catch((err) => {
+                    logger.error(`[Signal Daemon] Failed to clean up session #${label}: ${String(err)}`);
+                });
             }
         })
             .catch((err) => {
             logger.error(`[Signal Daemon] Transport #${label} error: ${String(err)}`);
         });
-        await this.sendSignalMessage(prefixWithLabel('Started a new session.', label, this.sessions.size));
+        await this.sendSignalMessage(prefixWithLabel('Started a new session.', label, this.sessionManager.size));
         return label;
     }
-    /**
-     * Ends a specific session by label and cleans up.
-     * If it was the current session, auto-switches to the most recent remaining.
-     */
-    async endSession(label) {
-        const managed = this.sessions.get(label);
-        if (!managed)
-            return;
-        // Close transport first (resolves run() promise), then session.
-        // Only remove from the map after successful close so the session
-        // remains trackable (and retryable) if session.close() fails.
-        managed.transport.close();
-        await managed.session.close();
-        this.sessions.delete(label);
-        if (this.currentLabel === label) {
-            this.autoSwitchCurrent();
-        }
-    }
-    /**
-     * Convenience method: ends the current session (if any).
-     */
-    async endCurrentSession() {
-        if (this.currentLabel === null)
-            return;
-        await this.endSession(this.currentLabel);
-    }
-    /**
-     * Auto-switches currentLabel to the highest remaining label (most recent),
-     * or null if no sessions remain.
-     */
-    autoSwitchCurrent() {
-        if (this.sessions.size === 0) {
-            this.currentLabel = null;
-            return;
-        }
-        this.currentLabel = Math.max(...this.sessions.keys());
-    }
     // --- Escalation handling ---
     /**
      * Checks if the message is an escalation reply.
      * Accepts: approve, deny, /approve, /deny (case-insensitive).
      * Optionally with a session label: "approve #2", "/approve 2".
      *
-     * Routes to the session with a pending escalation. If multiple
-     * sessions have pending escalations and no label is specified,
-     * asks for disambiguation.
+     * Routes to the session with a pending escalation.
+     * Works across ALL session types (signal + cron) so that
+     * `approve #3` from Signal can approve a cron job's escalation.
      */
     handleEscalationReply(text) {
         const normalized = text.trim().toLowerCase();
@@ -405,19 +405,14 @@ export class SignalBotDaemon {
             return false;
         const isApprove = match[1] === 'approve';
         const explicitLabel = match[2] ? parseInt(match[2], 10) : null;
-        // Find sessions with pending escalations
-        const pending = [];
-        for (const managed of this.sessions.values()) {
-            if (managed.pendingEscalationId) {
-                pending.push(managed);
-            }
-        }
+        // Find sessions with pending escalations (across all session types)
+        const pending = this.sessionManager.withPendingEscalation();
         if (pending.length === 0)
             return false;
         // Determine target session
         let target;
         if (explicitLabel !== null) {
-            target = this.sessions.get(explicitLabel);
+            target = this.sessionManager.get(explicitLabel);
             if (!target?.pendingEscalationId) {
                 this.sendSignalMessage(`Session #${explicitLabel} has no pending escalation.`).catch(() => { });
                 return true;
@@ -433,7 +428,7 @@ export class SignalBotDaemon {
             return true;
         }
         if (target.escalationResolving) {
-            this.sendSignalMessage(prefixWithLabel('Escalation is being resolved, please wait...', target.label, this.sessions.size)).catch(() => { });
+            this.sendSignalMessage(prefixWithLabel('Escalation is being resolved, please wait...', target.label, this.sessionManager.size)).catch(() => { });
             return true;
         }
         const decision = isApprove ? 'approved' : 'denied';
@@ -443,11 +438,11 @@ export class SignalBotDaemon {
         managed.session
             .resolveEscalation(escalationId, decision)
             .then(() => {
-            return this.sendSignalMessage(prefixWithLabel(`Escalation ${decision}.`, managed.label, this.sessions.size));
+            return this.sendSignalMessage(prefixWithLabel(`Escalation ${decision}.`, managed.label, this.sessionManager.size));
         })
             .catch((err) => {
             const msg = err instanceof Error ? err.message : String(err);
-            this.sendSignalMessage(prefixWithLabel(`Escalation error: ${msg}`, managed.label, this.sessions.size)).catch(() => { });
+            this.sendSignalMessage(prefixWithLabel(`Escalation error: ${msg}`, managed.label, this.sessionManager.size)).catch(() => { });
         })
             .finally(() => {
             managed.escalationResolving = false;
@@ -459,21 +454,12 @@ export class SignalBotDaemon {
     }
     /** Called by SignalSessionTransport when the session surfaces an escalation. */
     setPendingEscalation(label, escalationId) {
-        const managed = this.sessions.get(label);
-        if (managed) {
-            managed.pendingEscalationId = escalationId;
-            logger.info(`[Signal Daemon] Escalation ${escalationId} set on session #${label}`);
-        }
-        else {
-            logger.error(`[Signal Daemon] setPendingEscalation: no session #${label} in map (keys: ${[...this.sessions.keys()].join(',')})`);
-        }
+        this.sessionManager.setPendingEscalation(label, escalationId);
+        logger.info(`[Signal Daemon] Escalation ${escalationId} set on session #${label}`);
     }
     /** Called by SignalSessionTransport when an escalation expires. */
     clearPendingEscalation(label) {
-        const managed = this.sessions.get(label);
-        if (managed) {
-            managed.pendingEscalationId = null;
-        }
+        this.sessionManager.clearPendingEscalation(label);
     }
     // --- Control commands ---
     handleControlCommand(text) {
@@ -483,28 +469,28 @@ export class SignalBotDaemon {
         if (quitMatch) {
             const explicitLabel = quitMatch[2] ? parseInt(quitMatch[2], 10) : null;
             this.scheduleSessionOp(async () => {
-                const labelToEnd = explicitLabel ?? this.currentLabel;
+                const labelToEnd = explicitLabel ?? this.sessionManager.currentLabel;
                 if (labelToEnd === null) {
                     await this.sendSignalMessage('No active session.');
                     return;
                 }
-                if (!this.sessions.has(labelToEnd)) {
+                if (!this.sessionManager.get(labelToEnd)) {
                     await this.sendSignalMessage(`No session #${labelToEnd}.`);
                     return;
                 }
-                const wasCurrent = labelToEnd === this.currentLabel;
+                const wasCurrent = labelToEnd === this.sessionManager.currentLabel;
                 try {
-                    await this.endSession(labelToEnd);
+                    await this.sessionManager.end(labelToEnd);
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
                     await this.sendSignalMessage(`Failed to end session #${labelToEnd}: ${msg}`);
                     return;
                 }
-                if (wasCurrent && this.sessions.size > 0 && this.currentLabel !== null) {
-                    await this.sendSignalMessage(`Session #${labelToEnd} ended. Switched to #${this.currentLabel}.`);
+                if (wasCurrent && this.sessionManager.size > 0 && this.sessionManager.currentLabel !== null) {
+                    await this.sendSignalMessage(`Session #${labelToEnd} ended. Switched to #${this.sessionManager.currentLabel}.`);
                 }
-                else if (this.sessions.size > 0) {
+                else if (this.sessionManager.size > 0) {
                     await this.sendSignalMessage(`Session #${labelToEnd} ended.`);
                 }
                 else {
@@ -529,7 +515,8 @@ export class SignalBotDaemon {
         // /sessions
         if (lower === '/sessions') {
             this.scheduleSessionOp(async () => {
-                const entries = Array.from(this.sessions.values(), (managed) => {
+                const allSessions = this.sessionManager.all();
+                const entries = allSessions.map((managed) => {
                     const budget = managed.session.getBudgetStatus();
                     const maxTokens = budget.limits.maxTotalTokens;
                     return {
@@ -538,20 +525,24 @@ export class SignalBotDaemon {
                         budgetPercent: maxTokens ? Math.round((budget.totalTokens / maxTokens) * 100) : 0,
                     };
                 });
-                await this.sendSignalMessage(formatSessionList(entries, this.currentLabel));
+                await this.sendSignalMessage(formatSessionList(entries, this.sessionManager.currentLabel));
             });
             return true;
         }
-        // /switch N
+        // /switch N - only switch to Signal sessions
         const switchMatch = lower.match(/^\/switch\s+#?(\d+)$/);
         if (switchMatch) {
             const label = parseInt(switchMatch[1], 10);
             this.scheduleSessionOp(async () => {
-                if (!this.sessions.has(label)) {
+                const managed = this.sessionManager.get(label);
+                if (!managed) {
                     await this.sendSignalMessage(`No session #${label}.`);
                 }
+                else if (managed.source.kind !== 'signal') {
+                    await this.sendSignalMessage(`Session #${label} is a ${managed.source.kind} session and cannot be switched to.`);
+                }
                 else {
-                    this.currentLabel = label;
+                    this.sessionManager.currentLabel = label;
                     await this.sendSignalMessage(`Switched to session #${label}.`);
                 }
             });
@@ -562,8 +553,8 @@ export class SignalBotDaemon {
         if (budgetMatch) {
             const explicitBudgetLabel = budgetMatch[1] ? parseInt(budgetMatch[1], 10) : null;
             this.scheduleSessionOp(async () => {
-                const label = explicitBudgetLabel ?? this.currentLabel;
-                const managed = label !== null ? this.sessions.get(label) : undefined;
+                const label = explicitBudgetLabel ?? this.sessionManager.currentLabel;
+                const managed = label !== null ? this.sessionManager.get(label) : undefined;
                 if (label === null) {
                     await this.sendSignalMessage('No active session.');
                 }
@@ -572,7 +563,29 @@ export class SignalBotDaemon {
                 }
                 else {
                     const status = managed.session.getBudgetStatus();
-                    await this.sendSignalMessage(prefixWithLabel(formatBudgetMessage(status), label, this.sessions.size));
+                    await this.sendSignalMessage(prefixWithLabel(formatBudgetMessage(status), label, this.sessionManager.size));
+                }
+            });
+            return true;
+        }
+        // /jobs
+        if (lower === '/jobs') {
+            this.scheduleSessionOp(async () => {
+                try {
+                    const { sendControlRequest } = await import('../daemon/control-socket.js');
+                    const response = await sendControlRequest({ command: 'list-jobs' });
+                    if (response?.ok) {
+                        const jobs = (response.data ?? []);
+                        await this.sendSignalMessage(formatJobList(jobs));
+                    }
+                    else {
+                        const errMsg = response ? response.error : 'daemon may not be running';
+                        await this.sendSignalMessage(`Failed to query jobs: ${errMsg}`);
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    await this.sendSignalMessage(`Failed to query jobs: ${msg}`);
                 }
             });
             return true;
@@ -580,7 +593,8 @@ export class SignalBotDaemon {
         // /help
         if (lower === '/help') {
             this.scheduleSessionOp(async () => {
-                const sessionLine = this.currentLabel !== null ? `Current session: #${this.currentLabel}` : 'No active session.';
+                const currentLabel = this.sessionManager.currentLabel;
+                const sessionLine = currentLabel !== null ? `Current session: #${currentLabel}` : 'No active session.';
                 await this.sendSignalMessage(sessionLine +
                     '\n\n' +
                     'Commands:\n' +
@@ -590,6 +604,7 @@ export class SignalBotDaemon {
                     '  #N <message> - send to session #N without switching\n' +
                     '  /quit [N] - end session (current or #N)\n' +
                     '  /budget [N] - show resource usage\n' +
+                    '  /jobs - list scheduled cron jobs\n' +
                     '  /help - show this message\n' +
                     '  approve [#N] - approve pending escalation\n' +
                     '  deny [#N] - deny pending escalation');