@provos/ironcurtain 0.4.0 → 0.5.0

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

@@ -5,9 +5,9 @@
  * - WebSocket connection to signal-cli-rest-api with reconnect + exponential backoff
  * - Message routing: authorization, identity verification, escalation replies,
  *   control commands, and session forwarding
- * - Session lifecycle: creates transport+session on demand, cleans up on end
+ * - Multi-session lifecycle: creates transport+session on demand, cleans up on end
  * - Identity verification with TTL cache (5 min), fail-closed
- * - Escalation state with race prevention
+ * - Escalation state with race prevention (per-session)
  * - Message sending via POST /v2/send with text_mode: "styled"
  */
 import { createSession } from '../session/index.js';
@@ -16,7 +16,7 @@ import { loadUserConfig } from '../config/user-config.js';
 import { resolveSignalConfig } from './signal-config.js';
 import { SignalSessionTransport } from './signal-transport.js';
 import { markdownToSignal } from './markdown-to-signal.js';
-import { formatBudgetMessage, formatBudgetSummary, splitMessage, SIGNAL_MAX_MESSAGE_LENGTH } from './format.js';
+import { formatBudgetMessage, formatBudgetSummary, 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). */
@@ -32,25 +32,38 @@ export class SignalBotDaemon {
     reconnectAttempts = 0;
     static MAX_RECONNECT_DELAY_MS = 30_000;
     static BASE_RECONNECT_DELAY_MS = 1_000;
-    // Session state - at most one active session at a time
-    activeSession = null;
-    activeTransport = null;
-    messageInFlight = false;
-    // Escalation state - owned by the daemon because the daemon routes
-    // "approve"/"deny" messages before they reach the transport.
-    pendingEscalationId = null;
-    escalationResolving = false;
+    // Multi-session state
+    sessions = new Map();
+    currentLabel = null;
+    nextLabel = 1;
+    maxConcurrentSessions;
     // Identity verification state
     identityLocked = false;
     lastIdentityCheckMs = 0;
     // Message deduplication for drainMissedMessages()
     recentTimestamps = new Set();
+    // Serializes session-mutating operations (/new, /quit) so that
+    // routeToSession() sees the updated currentLabel after the operation completes.
+    // Without this, the fire-and-forget WebSocket handler can process a user message
+    // concurrently with /new, routing it to the old session.
+    sessionOpInProgress = Promise.resolve();
     // Resolves when the daemon should exit (shutdown() called)
     exitResolve = null;
     constructor(options) {
         this.config = options.config;
         this.containerManager = options.containerManager;
         this.mode = options.mode;
+        this.maxConcurrentSessions = options.config.maxConcurrentSessions;
+    }
+    /**
+     * Schedules a session-mutating operation (/new, /quit) so that
+     * concurrent routeToSession() calls wait for it to complete.
+     * Operations are chained to prevent interleaving.
+     */
+    scheduleSessionOp(op) {
+        this.sessionOpInProgress = this.sessionOpInProgress.then(op).catch((err) => {
+            logger.error(`[Signal Daemon] Session operation failed: ${String(err)}`);
+        });
     }
     /**
      * Starts the daemon. Returns a promise that resolves when
@@ -67,14 +80,20 @@ export class SignalBotDaemon {
         });
     }
     /**
-     * Initiates graceful shutdown. Ends the active session,
+     * Initiates graceful shutdown. Ends all active sessions,
      * closes the WebSocket, and unblocks start().
      */
     async shutdown() {
         logger.info('[Signal Daemon] Shutting down...');
         this.closed = true;
         await this.sendSignalMessage('IronCurtain bot is shutting down. Goodbye.').catch(() => { });
-        await this.endCurrentSession();
+        // 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)}`);
+        })));
         if (this.ws) {
             this.ws.close();
             this.ws = null;
@@ -180,26 +199,56 @@ export class SignalBotDaemon {
         // Escalation replies: approve/deny (also accept /approve, /deny)
         if (this.handleEscalationReply(text))
             return;
-        // Control commands: /quit, /new, /budget, /help
+        // Control commands: /quit, /new, /sessions, /switch, /budget, /help
         if (this.handleControlCommand(text))
             return;
         // Regular message -> route to session
         await this.routeToSession(text);
     }
     /**
-     * Routes a user message to the active session. Creates a new
+     * Routes a user message to the current 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.
      */
     async routeToSession(text) {
-        if (this.messageInFlight) {
-            await this.sendSignalMessage('Still processing previous message, please wait...');
+        // Wait for any pending session operation (/new, /quit) to complete
+        // before routing, so we see the updated currentLabel.
+        await this.sessionOpInProgress;
+        // Parse optional #N prefix for one-shot routing
+        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);
+            if (!managed) {
+                await this.sendSignalMessage(`No session #${targetLabel}.`);
+                return;
+            }
+            await this.forwardToSession(managed, messageText);
             return;
         }
-        // Create session on demand
-        if (!this.activeSession) {
+        // Create session on demand if none exists.
+        // Serialize through scheduleSessionOp so concurrent messages don't
+        // race to create multiple sessions.
+        if (this.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) {
+                            await this.startNewSession();
+                        }
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    }
+                });
+            });
             try {
-                await this.startNewSession();
+                await createOp;
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -207,31 +256,47 @@ export class SignalBotDaemon {
                 return;
             }
         }
-        const session = this.activeSession;
-        if (!session)
+        if (this.currentLabel === null)
+            return;
+        const managed = this.sessions.get(this.currentLabel);
+        if (!managed)
             return;
-        this.messageInFlight = true;
+        await this.forwardToSession(managed, messageText);
+    }
+    /**
+     * Forwards a message to a specific managed session. Handles
+     * in-flight guards, BudgetExhaustedError, and response formatting.
+     */
+    async forwardToSession(managed, text) {
+        logger.info(`[Signal Daemon] Routing message to session #${managed.label} ` +
+            `(currentLabel=${this.currentLabel}, sessions=${[...this.sessions.keys()].join(',')}, ` +
+            `transportLabel=${managed.transport.sessionLabel})`);
+        if (managed.messageInFlight) {
+            await this.sendSignalMessage(prefixWithLabel('Still processing previous message, please wait...', managed.label, this.sessions.size));
+            return;
+        }
+        managed.messageInFlight = true;
         try {
-            const response = await session.sendMessage(text);
+            const response = await managed.transport.forwardMessage(text);
             const styledText = markdownToSignal(response);
-            await this.sendSignalMessage(styledText);
+            await this.sendSignalMessage(prefixWithLabel(styledText, managed.label, this.sessions.size));
         }
         catch (error) {
             if (error instanceof BudgetExhaustedError) {
-                const status = session.getBudgetStatus();
-                await this.sendSignalMessage(`Session budget exhausted: ${error.message}\n` +
+                const status = managed.session.getBudgetStatus();
+                await this.sendSignalMessage(prefixWithLabel(`Session budget exhausted: ${error.message}\n` +
                     formatBudgetSummary(status) +
                     '\n' +
-                    'Send a new message to start a fresh session.');
-                await this.endCurrentSession();
+                    'Send a new message to start a fresh session.', managed.label, this.sessions.size));
+                await this.endSession(managed.label);
             }
             else {
                 const message = error instanceof Error ? error.message : String(error);
-                await this.sendSignalMessage(`Error: ${message}`);
+                await this.sendSignalMessage(prefixWithLabel(`Error: ${message}`, managed.label, this.sessions.size));
             }
         }
         finally {
-            this.messageInFlight = false;
+            managed.messageInFlight = false;
         }
     }
     // --- Session lifecycle ---
@@ -239,10 +304,15 @@ export class SignalBotDaemon {
      * Creates a new 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) {
+            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);
-        this.activeTransport = transport;
+        transport.sessionLabel = label;
         const config = loadConfig();
         const session = await createSession({
             config,
@@ -251,123 +321,282 @@ export class SignalBotDaemon {
             onEscalationExpired: transport.createEscalationExpiredHandler(),
             onDiagnostic: transport.createDiagnosticHandler(),
         });
-        this.activeSession = session;
+        const managed = {
+            label,
+            session,
+            transport,
+            messageInFlight: false,
+            pendingEscalationId: null,
+            escalationResolving: false,
+        };
+        this.sessions.set(label, managed);
+        this.currentLabel = label;
         // Start the transport in the background. When it resolves
         // (session closed/budget exhausted), clean up.
         transport
             .run(session)
             .then(() => {
-            // Transport exited - session is done
-            if (this.activeTransport === transport) {
-                this.activeSession = null;
-                this.activeTransport = null;
+            // Transport exited - remove session if still present
+            if (this.sessions.has(label)) {
+                this.sessions.delete(label);
+                if (this.currentLabel === label) {
+                    this.autoSwitchCurrent();
+                }
             }
         })
             .catch((err) => {
-            logger.error(`[Signal Daemon] Transport error: ${String(err)}`);
+            logger.error(`[Signal Daemon] Transport #${label} error: ${String(err)}`);
         });
-        await this.sendSignalMessage('Started a new session.');
+        await this.sendSignalMessage(prefixWithLabel('Started a new session.', label, this.sessions.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();
+        }
     }
     /**
-     * Ends the current session and cleans up. Awaits session.close()
-     * to ensure resources are released (sandbox, MCP connections, etc.).
-     * Guarded against re-entrance.
+     * Convenience method: ends the current session (if any).
      */
     async endCurrentSession() {
-        if (!this.activeSession)
+        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;
-        const session = this.activeSession;
-        const transport = this.activeTransport;
-        this.activeSession = null;
-        this.activeTransport = null;
-        this.pendingEscalationId = null;
-        this.escalationResolving = false;
-        // Close transport first (resolves run() promise), then session
-        transport?.close();
-        await session.close();
+        }
+        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".
      *
-     * Race condition prevention: escalationResolving flag prevents
-     * concurrent replies. pendingEscalationId is cleared in .finally()
-     * after async resolution completes, not before.
+     * Routes to the session with a pending escalation. If multiple
+     * sessions have pending escalations and no label is specified,
+     * asks for disambiguation.
      */
     handleEscalationReply(text) {
-        if (!this.pendingEscalationId || !this.activeSession)
-            return false;
         const normalized = text.trim().toLowerCase();
-        const isApprove = normalized === 'approve' || normalized === '/approve';
-        const isDeny = normalized === 'deny' || normalized === '/deny';
-        if (!isApprove && !isDeny)
+        // Parse: approve, /approve, approve #2, /approve 2, deny, /deny, etc.
+        const match = normalized.match(/^\/?(approve|deny)(?:\s+#?(\d+))?$/);
+        if (!match)
+            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);
+            }
+        }
+        if (pending.length === 0)
             return false;
-        if (this.escalationResolving) {
-            this.sendSignalMessage('Escalation is being resolved, please wait...').catch(() => { });
+        // Determine target session
+        let target;
+        if (explicitLabel !== null) {
+            target = this.sessions.get(explicitLabel);
+            if (!target?.pendingEscalationId) {
+                this.sendSignalMessage(`Session #${explicitLabel} has no pending escalation.`).catch(() => { });
+                return true;
+            }
+        }
+        else if (pending.length === 1) {
+            target = pending[0];
+        }
+        else {
+            // Multiple pending - need disambiguation
+            const labels = pending.map((m) => `#${m.label}`).join(', ');
+            this.sendSignalMessage(`Multiple escalations pending (${labels}). Specify: \`approve #N\` or \`deny #N\``).catch(() => { });
+            return true;
+        }
+        if (target.escalationResolving) {
+            this.sendSignalMessage(prefixWithLabel('Escalation is being resolved, please wait...', target.label, this.sessions.size)).catch(() => { });
             return true;
         }
         const decision = isApprove ? 'approved' : 'denied';
-        const escalationId = this.pendingEscalationId;
-        this.escalationResolving = true;
-        this.activeSession
+        const escalationId = target.pendingEscalationId;
+        const managed = target;
+        managed.escalationResolving = true;
+        managed.session
             .resolveEscalation(escalationId, decision)
             .then(() => {
-            return this.sendSignalMessage(`Escalation ${decision}.`);
+            return this.sendSignalMessage(prefixWithLabel(`Escalation ${decision}.`, managed.label, this.sessions.size));
         })
             .catch((err) => {
             const msg = err instanceof Error ? err.message : String(err);
-            this.sendSignalMessage(`Escalation error: ${msg}`).catch(() => { });
+            this.sendSignalMessage(prefixWithLabel(`Escalation error: ${msg}`, managed.label, this.sessions.size)).catch(() => { });
         })
             .finally(() => {
-            this.escalationResolving = false;
-            if (this.pendingEscalationId === escalationId) {
-                this.pendingEscalationId = null;
+            managed.escalationResolving = false;
+            if (managed.pendingEscalationId === escalationId) {
+                managed.pendingEscalationId = null;
             }
         });
         return true;
     }
     /** Called by SignalSessionTransport when the session surfaces an escalation. */
-    setPendingEscalation(escalationId) {
-        this.pendingEscalationId = escalationId;
+    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(',')})`);
+        }
     }
     /** Called by SignalSessionTransport when an escalation expires. */
-    clearPendingEscalation() {
-        this.pendingEscalationId = null;
+    clearPendingEscalation(label) {
+        const managed = this.sessions.get(label);
+        if (managed) {
+            managed.pendingEscalationId = null;
+        }
     }
     // --- Control commands ---
     handleControlCommand(text) {
-        const trimmed = text.trim().toLowerCase();
-        switch (trimmed) {
-            case '/quit':
-            case '/exit':
-            case '/new':
-                this.endCurrentSession()
-                    .then(() => {
-                    this.sendSignalMessage('Session ended. Send a message to start a new one.').catch(() => { });
-                })
-                    .catch(() => { });
-                return true;
-            case '/budget': {
-                if (!this.activeSession) {
-                    this.sendSignalMessage('No active session.').catch(() => { });
-                    return true;
+        const lower = text.trim().toLowerCase();
+        // /quit [N] or /exit [N]
+        const quitMatch = lower.match(/^\/(quit|exit)(?:\s+#?(\d+))?$/);
+        if (quitMatch) {
+            const explicitLabel = quitMatch[2] ? parseInt(quitMatch[2], 10) : null;
+            this.scheduleSessionOp(async () => {
+                const labelToEnd = explicitLabel ?? this.currentLabel;
+                if (labelToEnd === null) {
+                    await this.sendSignalMessage('No active session.');
+                    return;
                 }
-                const status = this.activeSession.getBudgetStatus();
-                this.sendSignalMessage(formatBudgetMessage(status)).catch(() => { });
-                return true;
-            }
-            case '/help':
-                this.sendSignalMessage('Commands:\n' +
-                    '  /quit or /new - end current session\n' +
-                    '  /budget - show resource usage\n' +
+                if (!this.sessions.has(labelToEnd)) {
+                    await this.sendSignalMessage(`No session #${labelToEnd}.`);
+                    return;
+                }
+                const wasCurrent = labelToEnd === this.currentLabel;
+                try {
+                    await this.endSession(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}.`);
+                }
+                else if (this.sessions.size > 0) {
+                    await this.sendSignalMessage(`Session #${labelToEnd} ended.`);
+                }
+                else {
+                    await this.sendSignalMessage('Session ended. Send a message to start a new one.');
+                }
+            });
+            return true;
+        }
+        // /new
+        if (lower === '/new') {
+            this.scheduleSessionOp(async () => {
+                try {
+                    await this.startNewSession();
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    await this.sendSignalMessage(msg);
+                }
+            });
+            return true;
+        }
+        // /sessions
+        if (lower === '/sessions') {
+            this.scheduleSessionOp(async () => {
+                const entries = Array.from(this.sessions.values(), (managed) => {
+                    const budget = managed.session.getBudgetStatus();
+                    const maxTokens = budget.limits.maxTotalTokens;
+                    return {
+                        label: managed.label,
+                        turnCount: managed.session.getInfo().turnCount,
+                        budgetPercent: maxTokens ? Math.round((budget.totalTokens / maxTokens) * 100) : 0,
+                    };
+                });
+                await this.sendSignalMessage(formatSessionList(entries, this.currentLabel));
+            });
+            return true;
+        }
+        // /switch N
+        const switchMatch = lower.match(/^\/switch\s+#?(\d+)$/);
+        if (switchMatch) {
+            const label = parseInt(switchMatch[1], 10);
+            this.scheduleSessionOp(async () => {
+                if (!this.sessions.has(label)) {
+                    await this.sendSignalMessage(`No session #${label}.`);
+                }
+                else {
+                    this.currentLabel = label;
+                    await this.sendSignalMessage(`Switched to session #${label}.`);
+                }
+            });
+            return true;
+        }
+        // /budget [N]
+        const budgetMatch = lower.match(/^\/budget(?:\s+#?(\d+))?$/);
+        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;
+                if (label === null) {
+                    await this.sendSignalMessage('No active session.');
+                }
+                else if (!managed) {
+                    await this.sendSignalMessage(`No session #${label}.`);
+                }
+                else {
+                    const status = managed.session.getBudgetStatus();
+                    await this.sendSignalMessage(prefixWithLabel(formatBudgetMessage(status), label, this.sessions.size));
+                }
+            });
+            return true;
+        }
+        // /help
+        if (lower === '/help') {
+            this.scheduleSessionOp(async () => {
+                const sessionLine = this.currentLabel !== null ? `Current session: #${this.currentLabel}` : 'No active session.';
+                await this.sendSignalMessage(sessionLine +
+                    '\n\n' +
+                    'Commands:\n' +
+                    '  /new - start a new session\n' +
+                    '  /sessions - list active sessions\n' +
+                    '  /switch N - switch to session #N\n' +
+                    '  #N <message> - send to session #N without switching\n' +
+                    '  /quit [N] - end session (current or #N)\n' +
+                    '  /budget [N] - show resource usage\n' +
                     '  /help - show this message\n' +
-                    '  approve or /approve - approve pending escalation\n' +
-                    '  deny or /deny - deny pending escalation').catch(() => { });
-                return true;
-            default:
-                return false;
+                    '  approve [#N] - approve pending escalation\n' +
+                    '  deny [#N] - deny pending escalation');
+            });
+            return true;
         }
+        return false;
     }
     // --- Identity verification ---
     /**
@@ -482,16 +711,14 @@ export function parseSignalEnvelope(data) {
         const parsed = JSON.parse(data);
         if (typeof parsed !== 'object' || parsed === null)
             return null;
-        // json-rpc mode wraps the envelope
         const record = parsed;
-        const envelope = (record.envelope ?? parsed);
-        return envelope;
+        // json-rpc mode wraps the envelope; fall back to the raw object
+        return (record.envelope ?? parsed);
     }
     catch {
         return null;
     }
 }
-/** Normalize a phone number by stripping spaces. */
 export function normalizePhoneNumber(number) {
     return number.replace(/\s+/g, '');
 }
@@ -501,4 +728,15 @@ export function isAuthorizedSender(envelope, recipientNumber) {
         return false;
     return normalizePhoneNumber(sender) === normalizePhoneNumber(recipientNumber);
 }
+/**
+ * Parses an optional `#N` prefix from a message for one-shot session routing.
+ * Pattern: `#N ` at the start, where N is one or more digits, followed by a space.
+ * E.g., `#2 do something` -> { targetLabel: 2, messageText: 'do something' }
+ */
+export function parseHashPrefix(text) {
+    const match = text.match(/^#(\d+) (.*)$/s);
+    if (!match)
+        return { targetLabel: null, messageText: text };
+    return { targetLabel: parseInt(match[1], 10), messageText: match[2] };
+}
 //# sourceMappingURL=signal-bot-daemon.js.map