@chrisromp/copilot-bridge 0.8.5 → 0.9.1

package/dist/index.js

@@ -6,12 +6,11 @@ import { formatEvent, formatPermissionRequest, formatUserInputRequest } from './
 import { WorkspaceWatcher, initWorkspace, getWorkspacePath } from './core/workspace-manager.js';
 import { MattermostAdapter } from './channels/mattermost/adapter.js';
 import { StreamingHandler } from './channels/mattermost/streaming.js';
-import { getChannelPrefs, getAllChannelSessions, closeDb, listPermissionRulesForScope, removePermissionRule, clearPermissionRules } from './state/store.js';
+import { getChannelPrefs, setChannelPrefs, getAllChannelSessions, closeDb, listPermissionRulesForScope, removePermissionRule, clearPermissionRules, getTaskHistory } from './state/store.js';
 import { extractThreadRequest, resolveThreadRoot } from './core/thread-utils.js';
 import { initScheduler, stopAll as stopScheduler, listJobs, removeJob, pauseJob, resumeJob, formatInTimezone, describeCron } from './core/scheduler.js';
 import { markBusy, markIdle, markIdleImmediate, isBusy, waitForChannelIdle, cancelIdleDebounce } from './core/channel-idle.js';
 import { LoopDetector, MAX_IDENTICAL_CALLS } from './core/loop-detector.js';
-import { getTaskHistory } from './state/store.js';
 import { checkUserAccess } from './core/access-control.js';
 import { createLogger, setLogLevel } from './logger.js';
 import fs from 'node:fs';
@@ -19,6 +18,9 @@ import path from 'node:path';
 const log = createLogger('bridge');
 // Active streaming responses, keyed by channelId
 const activeStreams = new Map(); // channelId → streamKey
+// Preserve thread context across turn_end stream finalization so auto-started
+// streams stay in the same thread.
+const channelThreadRoots = new Map(); // channelId → threadRootId
 // Track channels where the initial "Working..." has been posted (reset on new user message)
 const initialStreamPosted = new Set();
 // Activity feed: a single edit-in-place message accumulating tool call lines per channel
@@ -558,11 +560,21 @@ async function handleMidTurnMessage(msg, sessionManager, platformName, botName)
             return;
         }
         if (lower === '/remember' || lower === '/always approve') {
-            sessionManager.resolvePermission(msg.channelId, true, true);
+            if (sessionManager.isHookPermission(msg.channelId)) {
+                sessionManager.resolvePermission(msg.channelId, true);
+            }
+            else {
+                sessionManager.resolvePermission(msg.channelId, true, true);
+            }
             return;
         }
         if (lower === '/always deny') {
-            sessionManager.resolvePermission(msg.channelId, false, true);
+            if (sessionManager.isHookPermission(msg.channelId)) {
+                sessionManager.resolvePermission(msg.channelId, false);
+            }
+            else {
+                sessionManager.resolvePermission(msg.channelId, false, true);
+            }
             return;
         }
         // Unrecognized text or slash commands — auto-deny the permission and
@@ -589,6 +601,7 @@ async function handleMidTurnMessage(msg, sessionManager, platformName, botName)
                 await resolved.streaming.cancelStream(stopStreamKey);
                 activeStreams.delete(msg.channelId);
             }
+            channelThreadRoots.delete(msg.channelId);
             await finalizeActivityFeed(msg.channelId, adapter);
             await sessionManager.abortSession(msg.channelId);
             markIdleImmediate(msg.channelId);
@@ -601,6 +614,7 @@ async function handleMidTurnMessage(msg, sessionManager, platformName, botName)
                 await resolved.streaming.cancelStream(oldStreamKey);
                 activeStreams.delete(msg.channelId);
             }
+            channelThreadRoots.delete(msg.channelId);
             await finalizeActivityFeed(msg.channelId, adapter);
             loopDetector.reset(msg.channelId);
             await sessionManager.newSession(msg.channelId);
@@ -773,6 +787,7 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                     await streaming.cancelStream(oldStreamKey);
                     activeStreams.delete(msg.channelId);
                 }
+                channelThreadRoots.delete(msg.channelId);
                 await finalizeActivityFeed(msg.channelId, adapter);
                 loopDetector.reset(msg.channelId);
                 await sessionManager.newSession(msg.channelId);
@@ -786,6 +801,7 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                     await streaming.cancelStream(stopStreamKey);
                     activeStreams.delete(msg.channelId);
                 }
+                channelThreadRoots.delete(msg.channelId);
                 await finalizeActivityFeed(msg.channelId, adapter);
                 await sessionManager.abortSession(msg.channelId);
                 await adapter.sendMessage(msg.channelId, '🛑 Task stopped.', { threadRootId: threadRoot });
@@ -1096,15 +1112,28 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
             case 'skills': {
                 const skills = sessionManager.getSkillInfo(msg.channelId);
                 const mcpInfo = sessionManager.getMcpServerInfo(msg.channelId);
+                const hooksInfo = sessionManager.getHooksInfo(msg.channelId);
                 const lines = ['🧰 **Skills & Tools**', ''];
                 if (skills.length > 0) {
-                    lines.push('**Skills**');
-                    for (const s of skills) {
-                        const desc = s.description ? ` — ${s.description}` : '';
-                        const flag = s.pending ? ' ⏳ _reload to activate_' : '';
-                        lines.push(`• \`${s.name}\`${desc} _(${s.source})_${flag}`);
+                    const active = skills.filter(s => !s.disabled);
+                    const disabled = skills.filter(s => s.disabled);
+                    if (active.length > 0) {
+                        lines.push('🟢 **Active Skills**');
+                        for (const s of active) {
+                            const desc = s.description ? ` — ${s.description}` : '';
+                            const flag = s.pending ? ' ⏳ _reload to activate_' : '';
+                            lines.push(`• \`${s.name}\`${desc} _(${s.source})_${flag}`);
+                        }
+                        lines.push('');
+                    }
+                    if (disabled.length > 0) {
+                        lines.push('🔴 **Disabled Skills**');
+                        for (const s of disabled) {
+                            const desc = s.description ? ` — ${s.description}` : '';
+                            lines.push(`• \`${s.name}\`${desc} _(${s.source})_`);
+                        }
+                        lines.push('');
                     }
-                    lines.push('');
                 }
                 if (mcpInfo.length > 0) {
                     lines.push('**MCP Servers**');
@@ -1114,6 +1143,14 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                     }
                     lines.push('');
                 }
+                if (hooksInfo.length > 0) {
+                    lines.push('**Hooks**');
+                    for (const h of hooksInfo) {
+                        const count = h.commandCount > 1 ? ` (${h.commandCount} commands)` : '';
+                        lines.push(`• \`${h.hookType}\`${count} _(${h.source})_`);
+                    }
+                    lines.push('');
+                }
                 // Fetch built-in tools from SDK
                 const sdkTools = await sessionManager.listSessionTools(msg.channelId);
                 if (sdkTools.length > 0) {
@@ -1130,6 +1167,79 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                 await adapter.sendMessage(msg.channelId, lines.join('\n'), { threadRootId: threadRoot });
                 break;
             }
+            case 'skill_toggle': {
+                const { action: toggleAction, targets } = cmdResult.payload;
+                const skills = sessionManager.getSkillInfo(msg.channelId);
+                const prefs = getChannelPrefs(msg.channelId);
+                const currentDisabled = new Set(prefs?.disabledSkills ?? []);
+                // Handle "all" keyword (only valid as sole target)
+                if (targets.some(t => t.toLowerCase() === 'all')) {
+                    if (targets.length > 1) {
+                        await adapter.sendMessage(msg.channelId, '⚠️ `all` cannot be combined with other skill names.', { threadRootId: threadRoot });
+                        break;
+                    }
+                    if (toggleAction === 'disable') {
+                        const allNames = [...new Set(skills.map(s => s.name))];
+                        setChannelPrefs(msg.channelId, { disabledSkills: allNames });
+                        await adapter.sendMessage(msg.channelId, `🔴 Disabled all ${allNames.length} skills. Use \`/reload\` to apply.`, { threadRootId: threadRoot });
+                    }
+                    else {
+                        setChannelPrefs(msg.channelId, { disabledSkills: [] });
+                        await adapter.sendMessage(msg.channelId, `🟢 Enabled all skills. Use \`/reload\` to apply.`, { threadRootId: threadRoot });
+                    }
+                    break;
+                }
+                const matched = [];
+                const notFound = [];
+                const ambiguous = [];
+                for (const target of targets) {
+                    const lower = target.toLowerCase();
+                    const exact = skills.find(s => s.name.toLowerCase() === lower);
+                    if (exact) {
+                        if (toggleAction === 'disable')
+                            currentDisabled.add(exact.name);
+                        else
+                            currentDisabled.delete(exact.name);
+                        matched.push(exact.name);
+                        continue;
+                    }
+                    const substringMatches = skills.filter(s => s.name.toLowerCase().includes(lower));
+                    if (substringMatches.length === 1) {
+                        const skill = substringMatches[0];
+                        if (toggleAction === 'disable')
+                            currentDisabled.add(skill.name);
+                        else
+                            currentDisabled.delete(skill.name);
+                        matched.push(skill.name);
+                    }
+                    else if (substringMatches.length > 1) {
+                        ambiguous.push(`"${target}" matches: ${substringMatches.map(s => `\`${s.name}\``).join(', ')}`);
+                    }
+                    else {
+                        notFound.push(target);
+                    }
+                }
+                if (matched.length > 0) {
+                    setChannelPrefs(msg.channelId, { disabledSkills: [...currentDisabled] });
+                }
+                const lines = [];
+                if (matched.length > 0) {
+                    const verb = toggleAction === 'disable' ? '🔴 Disabled' : '🟢 Enabled';
+                    const names = matched.map(n => `\`${n}\``).join(', ');
+                    lines.push(`${verb} ${names}.`);
+                }
+                if (ambiguous.length > 0) {
+                    lines.push(`⚠️ Ambiguous: ${ambiguous.join('; ')}`);
+                }
+                if (notFound.length > 0) {
+                    lines.push(`❌ No match: ${notFound.map(n => `"${n}"`).join(', ')}`);
+                }
+                if (matched.length > 0) {
+                    lines.push('Use `/reload` to apply.');
+                }
+                await adapter.sendMessage(msg.channelId, lines.join(' '), { threadRootId: threadRoot });
+                break;
+            }
             case 'mcp': {
                 const mcpInfo = sessionManager.getMcpServerInfo(msg.channelId);
                 if (mcpInfo.length === 0) {
@@ -1353,13 +1463,15 @@ async function handleReaction(reaction, sessionManager, platformName, botName) {
         }
     }
     else if (reaction.emoji === 'floppy_disk') {
-        if (sessionManager.resolvePermission(reaction.channelId, true, true)) {
-            await adapter.sendMessage(reaction.channelId, '💾 Approved + remembered via reaction.');
+        const isHook = sessionManager.isHookPermission(reaction.channelId);
+        if (sessionManager.resolvePermission(reaction.channelId, true, !isHook)) {
+            await adapter.sendMessage(reaction.channelId, isHook ? '✅ Approved via reaction.' : '💾 Approved + remembered via reaction.');
         }
     }
     else if (reaction.emoji === 'no_entry_sign') {
-        if (sessionManager.resolvePermission(reaction.channelId, false, true)) {
-            await adapter.sendMessage(reaction.channelId, '🚫 Denied + remembered via reaction.');
+        const isHook = sessionManager.isHookPermission(reaction.channelId);
+        if (sessionManager.resolvePermission(reaction.channelId, false, !isHook)) {
+            await adapter.sendMessage(reaction.channelId, isHook ? '❌ Denied via reaction.' : '🚫 Denied + remembered via reaction.');
         }
     }
 }
@@ -1398,19 +1510,23 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
     if (event.type === 'bridge.permission_request') {
         const streamKey = activeStreams.get(channelId);
         const threadRootId = streamKey ? streaming.getStreamThreadRootId(streamKey) : undefined;
+        if (threadRootId)
+            channelThreadRoots.set(channelId, threadRootId);
         if (streamKey) {
             await streaming.finalizeStream(streamKey);
             activeStreams.delete(channelId);
         }
         await finalizeActivityFeed(channelId, adapter);
-        const { toolName, serverName, input, commands } = event.data;
-        const formatted = formatPermissionRequest(toolName, input, commands, serverName);
+        const { toolName, serverName, input, commands, hookReason, fromHook } = event.data;
+        const formatted = formatPermissionRequest(toolName, input, commands, serverName, hookReason, fromHook);
         await adapter.sendMessage(channelId, formatted, { threadRootId });
         return;
     }
     if (event.type === 'bridge.user_input_request') {
         const streamKey = activeStreams.get(channelId);
         const threadRootId = streamKey ? streaming.getStreamThreadRootId(streamKey) : undefined;
+        if (threadRootId)
+            channelThreadRoots.set(channelId, threadRootId);
         if (streamKey) {
             await streaming.finalizeStream(streamKey);
             activeStreams.delete(channelId);
@@ -1479,7 +1595,8 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
                 const initialContent = event.type === 'assistant.message'
                     ? formatted.content
                     : (formatted.content || undefined);
-                const newKey = await streaming.startStream(channelId, undefined, initialContent);
+                const savedThreadRoot = channelThreadRoots.get(channelId);
+                const newKey = await streaming.startStream(channelId, savedThreadRoot, initialContent);
                 activeStreams.set(channelId, newKey);
             }
             else {
@@ -1532,6 +1649,7 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
         case 'error':
             markIdleImmediate(channelId);
             nudgePending.delete(channelId);
+            channelThreadRoots.delete(channelId);
             if (streamKey) {
                 await streaming.cancelStream(streamKey, formatted.content);
                 activeStreams.delete(channelId);
@@ -1541,6 +1659,21 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
             }
             break;
         case 'status':
+            // Finalize active stream on turn_start if it has content from a previous
+            // turn or between-turn events (e.g., subagent results arriving after
+            // turn_end). This complements turn_end finalization by catching content
+            // that arrives outside turn boundaries.
+            if (event.type === 'assistant.turn_start' && streamKey && streaming.hasContent(streamKey)) {
+                const threadRootId = streaming.getStreamThreadRootId(streamKey);
+                if (threadRootId) {
+                    channelThreadRoots.set(channelId, threadRootId);
+                }
+                else {
+                    channelThreadRoots.delete(channelId);
+                }
+                await streaming.finalizeStream(streamKey);
+                activeStreams.delete(channelId);
+            }
             // Send subagent status messages to chat
             if (formatted.content) {
                 if (streamKey) {
@@ -1549,14 +1682,31 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
                 }
                 await adapter.sendMessage(channelId, formatted.content);
             }
+            // Finalize stream on turn_end if it has content — preserves multi-turn
+            // messages so each turn's text gets its own chat message instead of being
+            // overwritten by the next turn's replaceContent().
+            // Only finalize when the stream has real content to avoid "Working..." churn.
+            if (event.type === 'assistant.turn_end') {
+                if (streamKey && streaming.hasContent(streamKey)) {
+                    // Preserve thread context for the next auto-started stream
+                    const threadRootId = streaming.getStreamThreadRootId(streamKey);
+                    if (threadRootId) {
+                        channelThreadRoots.set(channelId, threadRootId);
+                    }
+                    else {
+                        channelThreadRoots.delete(channelId);
+                    }
+                    await streaming.finalizeStream(streamKey);
+                    activeStreams.delete(channelId);
+                }
+            }
             // Finalize stream when the session goes idle (all turns complete).
-            // turn_end fires between tool cycles — DON'T finalize there or we get
-            // duplicate "Working..." messages from auto-starting new streams.
             if (event.type === 'session.idle') {
                 markIdle(channelId);
                 nudgePending.delete(channelId);
                 await finalizeActivityFeed(channelId, adapter);
                 initialStreamPosted.delete(channelId);
+                channelThreadRoots.delete(channelId);
                 if (streamKey) {
                     log.info(`Session idle, finalizing stream for ${channelId.slice(0, 8)}...`);
                     await streaming.finalizeStream(streamKey);