instar 0.24.34 → 0.25.1

package/dist/commands/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA0PH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA+lCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAurGtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA0PH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAsnCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAu2GtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}

package/dist/commands/server.js

@@ -1019,6 +1019,24 @@ async function ensureSlackAttentionChannel(slack, state) {
         console.error(`  Failed to create Slack Attention channel: ${err}`);
     }
 }
+/**
+ * Ensure a Slack updates channel exists — for version updates and feature announcements.
+ */
+async function ensureSlackUpdatesChannel(slack, state) {
+    const existingChannelId = state.get('slack-updates-channel');
+    if (existingChannelId)
+        return;
+    try {
+        const agentName = slack.config?.workspaceName?.replace(/-agent$/, '') || 'agent';
+        const channelId = await slack.createChannel(`${agentName}-sys-updates`);
+        state.set('slack-updates-channel', channelId);
+        await slack.sendToChannel(channelId, `Updates channel active. Version updates, new features, and system announcements will appear here.`);
+        console.log(`  Created Slack Updates channel: ${channelId}`);
+    }
+    catch (err) {
+        console.error(`  Failed to create Slack Updates channel: ${err}`);
+    }
+}
 /**
  * Ensure the Agent Updates topic exists — for version updates, feature announcements, etc.
  * Separates informational updates from critical attention items.
@@ -1259,8 +1277,8 @@ export async function startServer(options) {
                 topicId: resolvedTopicId,
             }).catch(() => { });
         }
-        // Slack: send IMMEDIATE notifications to attention channel (batching deferred to future)
-        if (tier === 'IMMEDIATE' && _slackAdapter) {
+        // Slack: send all notification tiers to attention channel
+        if (_slackAdapter) {
             const slackAttentionChannel = _notifyState?.get('slack-attention-channel');
             if (slackAttentionChannel) {
                 _slackAdapter.sendToChannel(slackAttentionChannel, message).catch(() => { });
@@ -2218,8 +2236,46 @@ export async function startServer(options) {
                     const channelId = message.channel.identifier;
                     const isDM = message.metadata?.isDM;
                     const senderName = message.metadata?.senderName || 'User';
-                    // Build injection tag
-                    const prefix = `[slack:${channelId}]`;
+                    // Sentinel intercept — classify message for emergency stop/pause
+                    if (sentinel) {
+                        try {
+                            const classification = await sentinel.classify(message.content);
+                            if (classification.category === 'emergency-stop') {
+                                // Kill all sessions
+                                const sessions = sessionManager.listRunningSessions();
+                                for (const s of sessions) {
+                                    try {
+                                        sessionManager.killSession(s.id);
+                                    }
+                                    catch { /* ok */ }
+                                }
+                                slackAdapter.sendToChannel(channelId, '🛑 Emergency stop — all sessions killed.').catch(() => { });
+                                return;
+                            }
+                            else if (classification.category === 'pause') {
+                                const existingSession = slackAdapter.getSessionForChannel(channelId);
+                                if (existingSession) {
+                                    sessionManager.sendKey(existingSession, 'Escape');
+                                    slackAdapter.sendToChannel(channelId, '⏸️ Session paused.').catch(() => { });
+                                }
+                                return;
+                            }
+                        }
+                        catch { /* fail-open — if Sentinel errors, process message normally */ }
+                    }
+                    // Build injection tag with sender info (matches Telegram's buildInjectionTag pattern)
+                    const slackUserId = message.metadata?.slackUserId;
+                    // Sanitize sender name at injection boundary (prevents injection attacks)
+                    const safeSenderName = senderName
+                        ? senderName.replace(/[\x00-\x1f\x7f]/g, '').replace(/\s+/g, ' ').replace(/["\[\]]/g, '').trim().slice(0, 64) || 'User'
+                        : undefined;
+                    let prefix = `[slack:${channelId}]`;
+                    if (safeSenderName && slackUserId) {
+                        prefix = `[slack:${channelId} from ${safeSenderName} (uid:${slackUserId})]`;
+                    }
+                    else if (safeSenderName) {
+                        prefix = `[slack:${channelId} from ${safeSenderName}]`;
+                    }
                     // Write context file for the session
                     const tmpDir = '/tmp/instar-slack';
                     fs.mkdirSync(tmpDir, { recursive: true });
@@ -2267,7 +2323,18 @@ export async function startServer(options) {
                         }
                         return `[User sent a file — it has been saved to ${docPath}. Read the file to view its contents]`;
                     });
-                    const bootstrapMessage = `${prefix} ${transformedContent} (IMPORTANT: Read ${ctxPath} for thread history and Slack relay instructions — you MUST relay your response back.)`;
+                    const FILE_THRESHOLD = 500;
+                    const fullMessage = `${prefix} ${transformedContent} (IMPORTANT: Read ${ctxPath} for thread history and Slack relay instructions — you MUST relay your response back.)`;
+                    // Long messages: write to temp file and inject reference (matches Telegram pattern)
+                    let bootstrapMessage;
+                    if (fullMessage.length > FILE_THRESHOLD) {
+                        const msgFilePath = path.join(tmpDir, `msg-${channelId}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}.txt`);
+                        fs.writeFileSync(msgFilePath, fullMessage);
+                        bootstrapMessage = `${prefix} [Long message saved to ${msgFilePath} — read it to see the full message]`;
+                    }
+                    else {
+                        bootstrapMessage = fullMessage;
+                    }
                     // Check for existing session bound to this channel
                     const existingSession = slackAdapter.getSessionForChannel(channelId);
                     if (existingSession) {
@@ -2292,13 +2359,13 @@ export async function startServer(options) {
                                 // Fall through to respawn below — registerChannelSession will be called with new session name
                             }
                             else {
-                                // Session is ready — inject the message
+                                // Session is ready — inject via SessionManager (handles idle timer reset + bracketed paste)
                                 try {
-                                    const { execSync } = await import('node:child_process');
-                                    const msgFile = path.join(tmpDir, `inject-${Date.now()}.txt`);
-                                    fs.writeFileSync(msgFile, bootstrapMessage);
-                                    execSync(`tmux send-keys -t '=${existingSession}:' "$(cat '${msgFile}')" Enter`, { timeout: 5000 });
-                                    fs.unlinkSync(msgFile);
+                                    sessionManager.injectMessage(existingSession, bootstrapMessage);
+                                    // Track for stall detection
+                                    slackAdapter.trackMessageInjection(channelId, existingSession, message.content);
+                                    // Delivery confirmation
+                                    slackAdapter.sendToChannel(channelId, '✓ Delivered').catch(() => { });
                                 }
                                 catch (injectErr) {
                                     console.error(`[slack→session] Injection failed: ${injectErr instanceof Error ? injectErr.message : injectErr}`);
@@ -2320,6 +2387,7 @@ export async function startServer(options) {
                         const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage, targetSession, { resumeSessionId });
                         if (newSessionName) {
                             slackAdapter.registerChannelSession(channelId, newSessionName);
+                            slackAdapter.trackMessageInjection(channelId, newSessionName, message.content);
                             console.log(`[slack→session] ${resumeSessionId ? 'Resumed' : 'Spawned'} "${newSessionName}" for channel ${channelId}`);
                         }
                     }
@@ -2330,17 +2398,100 @@ export async function startServer(options) {
                 await slackAdapter.start();
                 _slackAdapter = slackAdapter;
                 console.log(pc.green(`  Slack connected (workspace: ${slackConfig.config.workspaceName || 'unknown'})`));
-                // Ensure Slack attention channel exists
+                // Ensure Slack system channels exist
                 ensureSlackAttentionChannel(slackAdapter, state).catch(err => {
                     console.error(`[server] Failed to ensure Slack Attention channel: ${err}`);
                 });
+                ensureSlackUpdatesChannel(slackAdapter, state).catch(err => {
+                    console.error(`[server] Failed to ensure Slack Updates channel: ${err}`);
+                });
                 // Wire stall detection — route stall alerts to Slack attention channel
-                slackAdapter.onStallDetected = (channelId, sessionName, messageText) => {
+                slackAdapter.onStallDetected = (channelId, sessionName, messageText, injectedAt) => {
                     const slackAttentionChannel = state.get('slack-attention-channel');
                     if (slackAttentionChannel) {
-                        slackAdapter.sendToChannel(slackAttentionChannel, `Stall detected in session "${sessionName}" (channel ${channelId}). Message may not have been answered: "${messageText.slice(0, 100)}"`).catch(() => { });
+                        slackAdapter.sendToChannel(slackAttentionChannel, `⚠️ Stall detected in session "${sessionName}" (channel ${channelId}). Message may not have been answered: "${messageText.slice(0, 100)}"`).catch(() => { });
+                    }
+                    // Also notify in the originating channel
+                    slackAdapter.sendToChannel(channelId, `⚠️ The session appears to have stalled. Use \`!restart\` to restart or \`!interrupt\` to nudge it.`).catch(() => { });
+                };
+                // Wire voice transcription (reuses Telegram's provider resolution: Groq → OpenAI)
+                slackAdapter.transcribeVoice = async (filePath) => {
+                    const providers = {
+                        groq: { envKey: 'GROQ_API_KEY', baseUrl: 'https://api.groq.com/openai/v1', model: 'whisper-large-v3' },
+                        openai: { envKey: 'OPENAI_API_KEY', baseUrl: 'https://api.openai.com/v1', model: 'whisper-1' },
+                    };
+                    let provider = null;
+                    const explicit = slackConfig.config.audioTranscriptionProvider;
+                    if (explicit && providers[explicit.toLowerCase()]) {
+                        const p = providers[explicit.toLowerCase()];
+                        const apiKey = process.env[p.envKey];
+                        if (apiKey)
+                            provider = { apiKey, baseUrl: p.baseUrl, model: p.model };
+                    }
+                    if (!provider) {
+                        for (const [, p] of Object.entries(providers)) {
+                            const apiKey = process.env[p.envKey];
+                            if (apiKey) {
+                                provider = { apiKey, baseUrl: p.baseUrl, model: p.model };
+                                break;
+                            }
+                        }
+                    }
+                    if (!provider)
+                        throw new Error('No voice transcription provider. Set GROQ_API_KEY or OPENAI_API_KEY.');
+                    const formData = new FormData();
+                    const fileBuffer = fs.readFileSync(filePath);
+                    const blob = new Blob([fileBuffer], { type: 'audio/ogg' });
+                    formData.append('file', blob, path.basename(filePath));
+                    formData.append('model', provider.model);
+                    const controller = new AbortController();
+                    const timer = setTimeout(() => controller.abort(), 60_000);
+                    try {
+                        const response = await fetch(`${provider.baseUrl}/audio/transcriptions`, {
+                            method: 'POST',
+                            headers: { Authorization: `Bearer ${provider.apiKey}` },
+                            body: formData,
+                            signal: controller.signal,
+                        });
+                        if (!response.ok)
+                            throw new Error(`Transcription API error (${response.status}): ${await response.text()}`);
+                        const data = await response.json();
+                        return data.text;
                     }
+                    finally {
+                        clearTimeout(timer);
+                    }
+                };
+                // Start stall detection timer
+                const stallTimeout = slackConfig.config.stallTimeoutMinutes ?? 5;
+                if (stallTimeout > 0) {
+                    slackAdapter.startStallDetection(stallTimeout * 60 * 1000);
+                }
+                // Wire session management callbacks for slash commands
+                slackAdapter.onInterruptSession = async (sessionName) => {
+                    return sessionManager.sendKey(sessionName, 'Escape');
+                };
+                slackAdapter.onRestartSession = async (sessionName, channelId) => {
+                    try {
+                        const stuckSession = sessionManager.listRunningSessions().find(s => s.tmuxSession === sessionName);
+                        if (stuckSession) {
+                            sessionManager.killSession(stuckSession.id);
+                        }
+                    }
+                    catch { /* ok if already dead */ }
+                };
+                slackAdapter.onListSessions = () => {
+                    return sessionManager.listRunningSessions().map(s => ({
+                        name: s.name,
+                        tmuxSession: s.tmuxSession,
+                        status: s.status,
+                        alive: sessionManager.isSessionAlive(s.tmuxSession),
+                    }));
                 };
+                slackAdapter.onIsSessionAlive = (tmuxSession) => {
+                    return sessionManager.isSessionAlive(tmuxSession);
+                };
+                // Standby commands will be wired after PresenceProxy is initialized (below)
             }
             catch (err) {
                 const reason = err instanceof Error ? err.message : String(err);
@@ -2453,14 +2604,25 @@ export async function startServer(options) {
         if (_topicResumeMap && telegram) {
             sessionManager.on('beforeSessionKill', (session) => {
                 try {
+                    // Save Telegram topic resume UUID
                     const topicId = telegram.getTopicForSession(session.tmuxSession);
-                    if (!topicId)
-                        return;
-                    // Use authoritative claudeSessionId from hook events, fall back to mtime heuristic
-                    const uuid = _topicResumeMap.findUuidForSession(session.tmuxSession, session.claudeSessionId ?? undefined);
-                    if (uuid) {
-                        _topicResumeMap.save(topicId, uuid, session.tmuxSession);
-                        console.log(`[beforeSessionKill] Saved resume UUID ${uuid} for topic ${topicId} (session: ${session.name}, source: ${session.claudeSessionId ? 'hook' : 'mtime'})`);
+                    if (topicId) {
+                        const uuid = _topicResumeMap.findUuidForSession(session.tmuxSession, session.claudeSessionId ?? undefined);
+                        if (uuid) {
+                            _topicResumeMap.save(topicId, uuid, session.tmuxSession);
+                            console.log(`[beforeSessionKill] Saved resume UUID ${uuid} for topic ${topicId} (session: ${session.name}, source: ${session.claudeSessionId ? 'hook' : 'mtime'})`);
+                        }
+                    }
+                    // Save Slack channel resume UUID
+                    if (_slackAdapter) {
+                        const channelId = _slackAdapter.getChannelForSession(session.tmuxSession);
+                        if (channelId) {
+                            const uuid = _topicResumeMap.findUuidForSession(session.tmuxSession, session.claudeSessionId ?? undefined);
+                            if (uuid) {
+                                _slackAdapter.saveChannelResume(channelId, uuid, session.tmuxSession);
+                                console.log(`[beforeSessionKill] Saved Slack resume UUID ${uuid} for channel ${channelId} (session: ${session.name})`);
+                            }
+                        }
                     }
                 }
                 catch (err) {
@@ -3095,6 +3257,14 @@ export async function startServer(options) {
             slackProxyChannelMap.set(syntheticId, channelId);
             return syntheticId;
         }
+        // Pre-populate the Slack proxy channel map from existing channel registry
+        // so PresenceProxy state recovery can resolve synthetic IDs on restart
+        if (_slackAdapter) {
+            const registry = _slackAdapter.getChannelRegistry();
+            for (const channelId of Object.keys(registry)) {
+                slackChannelToSyntheticId(channelId);
+            }
+        }
         let presenceProxy;
         if (sharedIntelligence && telegram) {
             try {
@@ -3224,18 +3394,35 @@ export async function startServer(options) {
                     });
                 };
                 presenceProxy.start();
-                // Wire Slack's onMessageLogged into PresenceProxy (if Slack is active)
+                // Wire Slack's onMessageLogged into PresenceProxy + TopicMemory (if Slack is active)
                 if (_slackAdapter) {
                     const existingSlackCallback = _slackAdapter.onMessageLogged;
                     _slackAdapter.onMessageLogged = (entry) => {
                         if (existingSlackCallback) {
                             existingSlackCallback(entry);
                         }
+                        // TopicMemory dual-write (matches Telegram's insertMessage pattern)
+                        // TopicMemory uses numeric topicId; for Slack we use the synthetic hash
+                        if (entry.channelId && topicMemory) {
+                            const synId = slackChannelToSyntheticId(String(entry.channelId));
+                            topicMemory.insertMessage({
+                                messageId: typeof entry.messageId === 'number' ? entry.messageId : 0,
+                                topicId: synId,
+                                text: entry.text,
+                                fromUser: entry.fromUser,
+                                timestamp: entry.timestamp,
+                                sessionName: entry.sessionName,
+                                senderName: entry.senderName,
+                            });
+                        }
+                        // Clear stall tracking when agent responds in this channel
+                        if (!entry.fromUser && entry.channelId) {
+                            _slackAdapter.clearStallTracking(String(entry.channelId));
+                        }
                         // Convert Slack channelId to synthetic numeric ID for PresenceProxy
                         if (!entry.channelId)
                             return;
                         const syntheticId = slackChannelToSyntheticId(String(entry.channelId));
-                        console.log(`[slack-proxy] onMessageLogged: channel=${entry.channelId} syntheticId=${syntheticId} fromUser=${entry.fromUser} text="${(entry.text || '').slice(0, 40)}"`);
                         presenceProxy.onMessageLogged({
                             messageId: typeof entry.messageId === 'number' ? entry.messageId : parseInt(String(entry.messageId), 10) || 0,
                             channelId: syntheticId.toString(),
@@ -3248,6 +3435,11 @@ export async function startServer(options) {
                         });
                     };
                     console.log(pc.green('  Presence Proxy wired to Slack'));
+                    // Wire standby commands for Slack (unstick, quiet, resume, restart)
+                    _slackAdapter.onStandbyCommand = async (channelId, command, userId) => {
+                        const syntheticId = slackChannelToSyntheticId(channelId);
+                        return presenceProxy.handleCommand(syntheticId, command, parseInt(userId, 10) || 0);
+                    };
                 }
                 console.log(pc.green('  Presence Proxy enabled (🔭 [Standby])'));
             }