@qwen-code/channel-base 0.19.7 → 0.19.8

package/dist/ChannelBase.js

@@ -1,6 +1,7 @@
 import { basename, join } from 'node:path';
 import { BlockStreamer } from './BlockStreamer.js';
 import { GroupGate } from './GroupGate.js';
+import { DmGate } from './DmGate.js';
 import { GroupHistoryStore } from './group-history-store.js';
 import { SenderGate } from './SenderGate.js';
 import { PairingStore } from './PairingStore.js';
@@ -53,6 +54,7 @@ export class ChannelBase {
     config;
     bridge;
     groupGate;
+    dmGate;
     gate;
     router;
     name;
@@ -88,6 +90,16 @@ export class ChannelBase {
     bridgeSessionDiedListener = (event) => {
         this.onSessionDied(event.sessionId);
     };
+    bridgePermissionRequestListener = (event) => {
+        void this.dispatchPermissionRequest(event).catch((err) => {
+            process.stderr.write(`[${this.name}] permission relay failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(err)}\n`);
+        });
+    };
+    bridgePermissionResolvedListener = (event) => {
+        this.dispatchPermissionResolved(event);
+    };
+    pendingPermissions = new Map();
+    pendingPermissionsByChat = new Map();
     channelLoopToolHandler = {
         canHandle: (sessionId) => this.router.getTarget(sessionId)?.channelName === this.name,
         create: (sessionId, input) => this.createLoopFromTool(sessionId, input),
@@ -119,6 +131,83 @@ export class ChannelBase {
         }
         this.onToolCall(chatId, event);
     }
+    async dispatchPermissionRequest(event) {
+        const target = this.permissionTargetForEvent(event);
+        if (!target) {
+            try {
+                await this.bridge.respondToPermission?.(event.requestId, {
+                    outcome: { outcome: 'cancelled' },
+                });
+            }
+            catch (respondErr) {
+                process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}\n`);
+            }
+            return;
+        }
+        this.removePendingPermission(event.requestId);
+        const pending = {
+            requestId: event.requestId,
+            sessionId: event.sessionId,
+            target,
+            request: event.request,
+        };
+        this.pendingPermissions.set(event.requestId, pending);
+        const chatKey = this.permissionChatKey(target);
+        const requestIds = this.pendingPermissionsByChat.get(chatKey) ?? [];
+        requestIds.push(event.requestId);
+        this.pendingPermissionsByChat.set(chatKey, requestIds);
+        try {
+            const text = this.formatPermissionRequest(pending);
+            if (target.threadId !== undefined &&
+                this.supportsProactiveSend() &&
+                this.supportsProactiveTarget(target)) {
+                await this.pushProactive(target, text);
+            }
+            else {
+                await this.sendMessage(target.chatId, text);
+            }
+        }
+        catch (err) {
+            this.removePendingPermission(event.requestId);
+            try {
+                await this.bridge.respondToPermission?.(event.requestId, {
+                    outcome: { outcome: 'cancelled' },
+                });
+            }
+            catch (respondErr) {
+                process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}\n`);
+            }
+            throw err;
+        }
+    }
+    permissionTargetForEvent(event) {
+        const routeTarget = this.router.getTarget(event.sessionId);
+        if (!routeTarget || routeTarget.channelName !== this.name) {
+            return undefined;
+        }
+        const active = this.activePrompts.get(event.sessionId);
+        if (!active) {
+            return routeTarget;
+        }
+        const target = {
+            channelName: routeTarget.channelName,
+            senderId: active.senderId ?? routeTarget.senderId,
+            chatId: active.chatId,
+        };
+        if (active.threadId !== undefined) {
+            target.threadId = active.threadId;
+        }
+        if (active.isGroup !== undefined) {
+            target.isGroup = active.isGroup;
+        }
+        else if (routeTarget.isGroup !== undefined) {
+            target.isGroup = routeTarget.isGroup;
+        }
+        return target;
+    }
+    dispatchPermissionResolved(event) {
+        this.removePendingPermission(event.requestId);
+    }
     constructor(name, config, bridge, options) {
         this.name = name;
         this.config = config;
@@ -132,6 +221,7 @@ export class ChannelBase {
             join(getGlobalQwenDir(), 'channels', `${encodeURIComponent(name)}-group-history.jsonl`));
         this.loopController = options?.loopController;
         this.groupGate = new GroupGate(config.groupPolicy, config.groups);
+        this.dmGate = new DmGate(config.dmPolicy);
         const pairingStore = config.senderPolicy === 'pairing' ? new PairingStore(name) : undefined;
         this.gate = new SenderGate(config.senderPolicy, config.allowedUsers, pairingStore);
         this.router =
@@ -261,6 +351,7 @@ export class ChannelBase {
         if (this.registerBridgeEvents) {
             this.detachBridgeEvents(this.bridge);
         }
+        this.clearPendingPermissions();
         this.router.setBridge(bridge);
         this.bridge = bridge;
         if (this.loopController) {
@@ -360,6 +451,8 @@ export class ChannelBase {
                 done,
                 resolve: doneResolve,
                 chatId: job.target.chatId,
+                threadId: job.target.threadId,
+                isGroup: job.target.isGroup,
                 messageId: job.id,
                 senderId: job.target.senderId,
                 senderName: job.createdBy,
@@ -667,14 +760,19 @@ export class ChannelBase {
     onSessionDied(sessionId) {
         this.router.removeSessionId(sessionId);
         this.instructedSessions.delete(sessionId);
+        this.removePendingPermissionsForSession(sessionId);
     }
     attachBridgeEvents(bridge) {
         bridge.on('toolCall', this.bridgeToolCallListener);
         bridge.on('sessionDied', this.bridgeSessionDiedListener);
+        bridge.on('permissionRequest', this.bridgePermissionRequestListener);
+        bridge.on('permissionResolved', this.bridgePermissionResolvedListener);
     }
     detachBridgeEvents(bridge) {
         bridge.off('toolCall', this.bridgeToolCallListener);
         bridge.off('sessionDied', this.bridgeSessionDiedListener);
+        bridge.off('permissionRequest', this.bridgePermissionRequestListener);
+        bridge.off('permissionResolved', this.bridgePermissionResolvedListener);
     }
     /**
      * Called when a prompt actually begins processing (inside the session queue).
@@ -741,6 +839,217 @@ export class ChannelBase {
             return true;
         });
     }
+    permissionChatKey(target) {
+        return `${target.chatId}\0${target.threadId ?? ''}`;
+    }
+    pendingPermissionIdsForChatKey(chatKey) {
+        const requestIds = this.pendingPermissionsByChat.get(chatKey);
+        if (!requestIds) {
+            return [];
+        }
+        const live = requestIds.filter((id) => this.pendingPermissions.has(id));
+        if (live.length === 0) {
+            this.pendingPermissionsByChat.delete(chatKey);
+        }
+        else if (live.length !== requestIds.length) {
+            this.pendingPermissionsByChat.set(chatKey, live);
+        }
+        return live;
+    }
+    removePendingPermission(requestId) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+            return;
+        }
+        this.pendingPermissions.delete(requestId);
+        const chatKey = this.permissionChatKey(pending.target);
+        const requestIds = this.pendingPermissionsByChat.get(chatKey);
+        if (!requestIds) {
+            return;
+        }
+        const remaining = requestIds.filter((id) => id !== requestId);
+        if (remaining.length === 0) {
+            this.pendingPermissionsByChat.delete(chatKey);
+        }
+        else {
+            this.pendingPermissionsByChat.set(chatKey, remaining);
+        }
+    }
+    removePendingPermissionsForSession(sessionId) {
+        const requestIds = Array.from(this.pendingPermissions)
+            .filter(([, pending]) => pending.sessionId === sessionId)
+            .map(([requestId]) => requestId);
+        for (const requestId of requestIds) {
+            this.removePendingPermission(requestId);
+        }
+    }
+    clearPendingPermissions() {
+        this.pendingPermissions.clear();
+        this.pendingPermissionsByChat.clear();
+    }
+    pendingPermissionForEnvelope(envelope, args) {
+        const trimmed = args.trim();
+        if (trimmed) {
+            const explicit = this.pendingPermissions.get(trimmed);
+            if (explicit &&
+                this.canEnvelopeAnswerPendingPermission(envelope, explicit)) {
+                return { kind: 'found', pending: explicit };
+            }
+            return { kind: 'none', explicit: true };
+        }
+        const requestIds = this.pendingPermissionIdsForChatKey(this.permissionChatKey(envelope));
+        if (requestIds.length === 0) {
+            return { kind: 'none', explicit: false };
+        }
+        const matching = requestIds
+            .map((id) => this.pendingPermissions.get(id))
+            .filter((pending) => pending !== undefined &&
+            this.canEnvelopeAnswerPendingPermission(envelope, pending));
+        if (matching.length === 0) {
+            return { kind: 'none', explicit: false };
+        }
+        if (matching.length > 1) {
+            return {
+                kind: 'ambiguous',
+                requestIds: matching.map((pending) => pending.requestId),
+            };
+        }
+        return { kind: 'found', pending: matching[0] };
+    }
+    canEnvelopeAnswerPendingPermission(envelope, pending) {
+        return (pending.target.chatId === envelope.chatId &&
+            pending.target.threadId === envelope.threadId &&
+            (this.isSharedSessionTarget(pending.target) ||
+                pending.target.senderId === envelope.senderId));
+    }
+    formatPermissionRequest(pending) {
+        const { toolCall } = pending.request;
+        const title = sanitizeQuotedText(toolCall.title || 'Tool use', 160);
+        const alwaysOption = this.approvalAlwaysOption(pending);
+        const replies = [
+            '/approve        allow once',
+            ...(alwaysOption ? [`/approve-always ${alwaysOption.label}`] : []),
+            '/deny           deny',
+        ];
+        const lines = [
+            'Permission required to run a tool',
+            '',
+            'Command:',
+            title,
+            '',
+            'Reply with:',
+            ...replies,
+        ];
+        return lines.join('\n');
+    }
+    approvalOptionId(pending) {
+        const options = pending.request.options;
+        return (options.find((option) => option.kind === 'allow_once')?.optionId ??
+            options.find((option) => option.optionId === 'proceed_once' &&
+                option.kind === undefined)?.optionId);
+    }
+    approvalAlwaysOption(pending) {
+        const options = pending.request.options.filter((option) => option.kind === 'allow_always');
+        const option = this.findScopedAlwaysOption(options, 'project') ??
+            this.findScopedAlwaysOption(options, 'user') ??
+            options[0];
+        if (!option) {
+            return undefined;
+        }
+        return {
+            optionId: option.optionId,
+            label: this.approvalAlwaysLabel(option),
+        };
+    }
+    findScopedAlwaysOption(options, scope) {
+        return options.find((option) => option.optionId === `proceed_always_${scope}`);
+    }
+    approvalAlwaysLabel(option) {
+        if (option.optionId === 'proceed_always_project') {
+            return 'always allow for this project';
+        }
+        if (option.optionId === 'proceed_always_user') {
+            return 'always allow for this user';
+        }
+        return 'always allow';
+    }
+    denialResponse(pending) {
+        const option = pending.request.options.find((candidate) => candidate.kind === 'reject_once') ??
+            pending.request.options.find((candidate) => candidate.optionId === 'cancel' &&
+                candidate.kind === undefined);
+        if (option) {
+            return { outcome: { outcome: 'selected', optionId: option.optionId } };
+        }
+        return { outcome: { outcome: 'cancelled' } };
+    }
+    async handlePermissionResponseCommand(envelope, args, decision) {
+        if (!this.isAuthorizedForSharedSession(envelope)) {
+            await this.sendMessage(envelope.chatId, 'Only authorized members can answer permission requests in this shared session.');
+            return true;
+        }
+        const lookup = this.pendingPermissionForEnvelope(envelope, args);
+        if (lookup.kind === 'ambiguous') {
+            const requestList = lookup.requestIds
+                .slice(0, 6)
+                .map((id) => {
+                const pending = this.pendingPermissions.get(id);
+                const title = pending
+                    ? `: ${sanitizeQuotedText(pending.request.toolCall.title || 'Tool use', 160)}`
+                    : '';
+                return `- ${sanitizeQuotedText(id, 128)}${title}`;
+            })
+                .join('\n');
+            await this.sendMessage(envelope.chatId, `Multiple permission requests are pending for this chat. Reply with /${decision} <request-id>.\n${requestList}`);
+            return true;
+        }
+        if (lookup.kind === 'none') {
+            await this.sendMessage(envelope.chatId, lookup.explicit
+                ? 'No pending permission request with that id for this chat.'
+                : 'No pending permission request for this chat.');
+            return true;
+        }
+        if (!this.bridge.respondToPermission) {
+            await this.sendMessage(envelope.chatId, 'Permission relay is not available for this session.');
+            return true;
+        }
+        const { pending } = lookup;
+        const response = (() => {
+            if (decision === 'deny') {
+                return this.denialResponse(pending);
+            }
+            const optionId = decision === 'approve'
+                ? this.approvalOptionId(pending)
+                : this.approvalAlwaysOption(pending)?.optionId;
+            return optionId
+                ? { outcome: { outcome: 'selected', optionId } }
+                : undefined;
+        })();
+        if (!response) {
+            await this.sendMessage(envelope.chatId, decision === 'approve-always'
+                ? 'This permission request has no always-allow option.'
+                : 'This permission request has no approvable option.');
+            return true;
+        }
+        let accepted;
+        try {
+            accepted = await this.bridge.respondToPermission(pending.requestId, response);
+        }
+        catch (err) {
+            this.removePendingPermission(pending.requestId);
+            process.stderr.write(`[${this.name}] permission response failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}\n`);
+            await this.sendMessage(envelope.chatId, 'Failed to answer the permission request.');
+            return true;
+        }
+        this.removePendingPermission(pending.requestId);
+        await this.sendMessage(envelope.chatId, accepted
+            ? decision === 'approve'
+                ? 'Permission approved.'
+                : decision === 'approve-always'
+                    ? 'Permission approved always.'
+                    : 'Permission denied.'
+            : 'Permission request is no longer pending.');
+        return true;
+    }
     /** Register shared slash commands. Called from constructor. */
     registerSharedCommands() {
         const doClear = async (envelope) => {
@@ -760,6 +1069,7 @@ export class ChannelBase {
                     // already queued onto this session sees a stale generation and bails
                     // instead of running bridge.prompt() against the cleared session.
                     this.sessionGenerations.set(id, (this.sessionGenerations.get(id) ?? 0) + 1);
+                    this.removePendingPermissionsForSession(id);
                     // Cancel an in-flight turn (and drop its buffered follow-ups) before
                     // purging, so a running prompt can't deliver a stale response into —
                     // or resurrect via collect-drain — the just-cleared session.
@@ -858,6 +1168,9 @@ export class ChannelBase {
         this.registerCommand('clear', clearHandler);
         this.registerCommand('reset', clearHandler);
         this.registerCommand('new', clearHandler);
+        this.registerCommand('approve', (envelope, args) => this.handlePermissionResponseCommand(envelope, args, 'approve'));
+        this.registerCommand('approve-always', (envelope, args) => this.handlePermissionResponseCommand(envelope, args, 'approve-always'));
+        this.registerCommand('deny', (envelope, args) => this.handlePermissionResponseCommand(envelope, args, 'deny'));
         this.registerCommand('remember-channel', async (envelope, args) => {
             const text = args.trim();
             if (text === '') {
@@ -936,6 +1249,9 @@ export class ChannelBase {
                     : '/clear — Clear your session (aliases: /reset, /new)',
                 '/who — Show current session & workspace',
                 '/status — Show session info',
+                '/approve [request-id] — Approve a pending permission request',
+                '/approve-always [request-id] — Always approve a pending permission request',
+                '/deny [request-id] — Deny a pending permission request',
             ];
             // Platform-specific commands (registered by adapters, not shared ones)
             const sharedCmds = new Set([
@@ -943,6 +1259,9 @@ export class ChannelBase {
                 'clear',
                 'reset',
                 'new',
+                'approve',
+                'approve-always',
+                'deny',
                 'remember-channel',
                 'channel-memory',
                 'forget-channel',
@@ -1309,6 +1628,7 @@ export class ChannelBase {
             isReplyToBot: true,
         };
         return (this.groupGate.check(envelope).allowed &&
+            this.dmGate.check(envelope).allowed &&
             this.gate.isAllowed(normalizedTarget.senderId) &&
             this.isAuthorizedForSharedSession(envelope));
     }
@@ -1800,6 +2120,10 @@ export class ChannelBase {
             }
             return false;
         }
+        const dmResult = this.dmGate.check(envelope);
+        if (!dmResult.allowed) {
+            return false;
+        }
         const result = this.gate.check(envelope.senderId, envelope.senderName);
         if (!result.allowed) {
             if (result.pairingCode !== undefined) {
@@ -2170,6 +2494,8 @@ export class ChannelBase {
                 done,
                 resolve: doneResolve,
                 chatId: envelope.chatId,
+                threadId: envelope.threadId,
+                isGroup: envelope.isGroup,
                 messageId: envelope.messageId,
                 senderId: envelope.senderId,
                 senderName: envelope.senderName,