@0xmaxma/claude-gateway 1.3.23 → 1.3.25

package/dist/api/router.js

@@ -150,35 +150,6 @@ async function verifyTelegramToken(token) {
         return null;
     }
 }
-/**
- * Non-blocking Telegram getUpdates check.
- * Returns match details + nextOffset on code match, { nextOffset } on no match, null on error.
- * Always advancing the offset ensures we never re-process seen messages across poll calls.
- */
-async function checkTelegramCode(token, expectedCode, offset) {
-    try {
-        const url = `${TELEGRAM_API_BASE}/bot${token}/getUpdates?offset=${offset}&timeout=0&limit=100`;
-        const res = await fetch(url);
-        const data = await res.json();
-        if (!data.ok)
-            return null;
-        let nextOffset = offset;
-        for (const upd of data.result) {
-            nextOffset = upd.update_id + 1;
-            if (upd.message?.chat.type === 'private' &&
-                upd.message.text?.trim().toUpperCase() === expectedCode.toUpperCase()) {
-                const chatId = String(upd.message.chat.id);
-                const senderId = upd.message.from ? String(upd.message.from.id) : chatId;
-                return { found: true, chatId, senderId, nextOffset };
-            }
-        }
-        return { found: false, nextOffset };
-    }
-    catch (err) {
-        console.error('[wizard/verify] getUpdates failed:', err.message);
-        return null;
-    }
-}
 // ---------------------------------------------------------------------------
 // In-memory rate limiter for media uploads (per API key)
 // ---------------------------------------------------------------------------
@@ -506,6 +477,18 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             telegram_token_preview: cfg.telegram?.botToken ? maskToken(cfg.telegram.botToken) : null,
             discord_token_preview: cfg.discord?.botToken ? maskToken(cfg.discord.botToken) : null,
             telegram_dm_policy: cfg.telegram?.botToken ? readTelegramAccess(id).dmPolicy : null,
+            // Orthogonal pairing toggle (mirrors line_pairing below). Absent ⇒ on.
+            telegram_pairing: cfg.telegram?.botToken ? readTelegramAccess(id).pairing : null,
+            // Group tier (mirrors line_group_* below). Null when Telegram not connected.
+            telegram_group_policy: cfg.telegram?.botToken ? readTelegramAccess(id).groupPolicy : null,
+            telegram_group_allowlist: cfg.telegram?.botToken ? readTelegramAccess(id).groupAllowlist : null,
+            telegram_require_mention: cfg.telegram?.botToken ? readTelegramAccess(id).requireMention : null,
+            discord_dm_policy: cfg.discord?.botToken ? readDiscordAccess(id).dmPolicy : null,
+            discord_pairing: cfg.discord?.botToken ? readDiscordAccess(id).pairing : null,
+            // Discord approves at guild level — guildAllowlist IS the group allowlist.
+            discord_group_policy: cfg.discord?.botToken ? readDiscordAccess(id).groupPolicy : null,
+            discord_guild_allowlist: cfg.discord?.botToken ? readDiscordAccess(id).guildAllowlist : null,
+            discord_require_mention: cfg.discord?.botToken ? readDiscordAccess(id).requireMention : null,
             line_connected: !!cfg.line?.channelSecret,
             line_token_preview: cfg.line?.channelAccessToken ? maskToken(cfg.line.channelAccessToken) : null,
             line_webhook_path: cfg.line?.channelSecret ? `/webhooks/line/${id}` : null,
@@ -668,15 +651,54 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
         try {
             const raw = fs.readFileSync(accessFile, 'utf8');
             const parsed = JSON.parse(raw);
+            // Migrate the legacy 4-value dmPolicy (pairing folded in) to the split
+            // model. SECURITY: a legacy 'allowlist' file was locked down → pairing:false
+            // (an absent pairing on an existing file means pre-split); 'pairing' → mint on.
+            // Mirrors migrateAccess() in mcp/tools/telegram/pure.ts — keep in sync.
+            const legacy = parsed.dmPolicy;
+            let dmPolicy;
+            let pairing;
+            if (legacy === 'pairing') {
+                dmPolicy = 'allowlist';
+                pairing = true;
+            }
+            else {
+                dmPolicy = legacy ?? 'allowlist';
+                pairing = parsed.pairing ?? false;
+            }
+            // Group tier: flatten legacy per-group `groups` map to a flat allowlist,
+            // behavior-preserving (groups were closed-by-default). Mirrors pure.ts.
+            // A group's per-user `allowFrom` override has no flat-model equivalent,
+            // but it's a real restriction — preserve it (mirrors
+            // deriveLegacyGroupAllowFrom in pure.ts, keep in sync) rather than
+            // silently dropping it and widening the group to every member.
+            const groupAllowlist = parsed.groupAllowlist ?? Object.keys(parsed.groups ?? {});
+            const groupPolicy = parsed.groupPolicy ?? 'allowlist';
+            const requireMention = parsed.requireMention ?? true;
+            let legacyGroupAllowFrom = parsed.legacyGroupAllowFrom;
+            if (!legacyGroupAllowFrom && parsed.groups) {
+                const derived = {};
+                for (const [groupId, g] of Object.entries(parsed.groups)) {
+                    if (g.allowFrom && g.allowFrom.length > 0)
+                        derived[groupId] = [...g.allowFrom];
+                }
+                if (Object.keys(derived).length > 0)
+                    legacyGroupAllowFrom = derived;
+            }
             return {
-                dmPolicy: parsed.dmPolicy ?? 'pairing',
+                dmPolicy,
+                pairing,
                 allowFrom: parsed.allowFrom ?? [],
-                groups: parsed.groups ?? {},
+                groupPolicy,
+                groupAllowlist,
+                requireMention,
+                legacyGroupAllowFrom,
                 pending: parsed.pending ?? {},
             };
         }
         catch {
-            return { dmPolicy: 'pairing', allowFrom: [], groups: {}, pending: {} };
+            // Brand-new agent (no file): closed base + pairing on (capture owner id).
+            return { dmPolicy: 'allowlist', pairing: true, allowFrom: [], groupPolicy: 'allowlist', groupAllowlist: [], requireMention: true, pending: {} };
         }
     }
     function writeTelegramAccess(agentId, access) {
@@ -689,6 +711,70 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             throw new Error(`Failed to write Telegram access config: ${err.message}`);
         }
     }
+    function getDiscordStateDir(agentId) {
+        const agentsBase = getAgentsBaseDir();
+        const cfg = agentConfigs.get(agentId);
+        const workspace = cfg?.workspace
+            ? (cfg.workspace.startsWith('~') ? path.join(os.homedir(), cfg.workspace.slice(1)) : cfg.workspace)
+            : path.join(agentsBase, agentId, 'workspace');
+        return path.join(workspace, '.discord-state');
+    }
+    function readDiscordAccess(agentId) {
+        const accessFile = path.join(getDiscordStateDir(agentId), 'access.json');
+        try {
+            const raw = fs.readFileSync(accessFile, 'utf8');
+            const parsed = JSON.parse(raw);
+            // Migrate the legacy fused dmPolicy ('pairing' folded pairing in) to the
+            // split model. SECURITY: a legacy 'allowlist' file was locked down →
+            // pairing:false (an absent pairing on an existing file means pre-split);
+            // 'pairing' → mint on. Mirrors migrateAccess() in
+            // mcp/tools/discord/access.ts — keep in sync.
+            const legacy = parsed.dmPolicy;
+            let dmPolicy;
+            let pairing;
+            if (legacy === 'pairing') {
+                dmPolicy = 'allowlist';
+                pairing = true;
+            }
+            else {
+                dmPolicy = legacy ?? 'allowlist';
+                pairing = parsed.pairing ?? false;
+            }
+            // Guild tier migration is behavior-preserving: today an empty
+            // guildAllowlist means "deliver to all guilds" → derive 'open' when empty,
+            // 'allowlist' when non-empty; requireMention defaults false for existing
+            // files (no prior mention gate). Mirrors discord/access.ts migrateAccess.
+            const guildAllowlist = parsed.guildAllowlist ?? [];
+            const groupPolicy = parsed.groupPolicy
+                ?? (guildAllowlist.length > 0 ? 'allowlist' : 'open');
+            const requireMention = parsed.requireMention ?? false;
+            return {
+                dmPolicy,
+                pairing,
+                allowFrom: parsed.allowFrom ?? [],
+                groupPolicy,
+                requireMention,
+                guildAllowlist,
+                channelAllowlist: parsed.channelAllowlist ?? [],
+                roleAllowlist: parsed.roleAllowlist ?? [],
+                pending: parsed.pending ?? {},
+            };
+        }
+        catch {
+            // Brand-new agent (no file): secure defaults (mirrors defaultAccess()).
+            return { dmPolicy: 'allowlist', pairing: true, allowFrom: [], groupPolicy: 'allowlist', requireMention: true, guildAllowlist: [], channelAllowlist: [], roleAllowlist: [], pending: {} };
+        }
+    }
+    function writeDiscordAccess(agentId, access) {
+        const stateDir = getDiscordStateDir(agentId);
+        try {
+            fs.mkdirSync(stateDir, { recursive: true });
+            fs.writeFileSync(path.join(stateDir, 'access.json'), JSON.stringify(access, null, 2));
+        }
+        catch (err) {
+            throw new Error(`Failed to write Discord access config: ${err.message}`);
+        }
+    }
     /**
      * POST /api/v1/agents/wizard/start
      * Start wizard: call Claude to generate workspace files, return wizardId + preview.
@@ -988,101 +1074,68 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
                 return;
             }
         }
-        const pairingCode = (0, crypto_1.randomBytes)(3).toString('hex').toUpperCase();
-        wizard_state_1.wizardStore.update(wizardId, {
-            step: 'pairing',
-            channel: channel,
-            botToken,
-            pairingCode,
-            updateOffset: 0,
-        });
-        res.json({
-            channel,
-            botName,
-            pairingCode,
-            instruction: `Send this code as a DM to ${botName} to complete pairing`,
-        });
-    });
-    /**
-     * POST /api/v1/agents/wizard/:wizardId/channel/verify
-     * Poll for pairing code. Client polls this endpoint until { success: true }.
-     */
-    router.post('/v1/agents/wizard/:wizardId/channel/verify', auth, async (req, res) => {
-        const apiKey = req.apiKey;
-        if (!(0, auth_1.isAdmin)(apiKey)) {
-            res.status(403).json({ error: 'Admin key required' });
-            return;
-        }
+        // Token-only connect: persist the bot token to the agent config now. The
+        // wizard no longer mints/relays a pairing code — pairing is incoming-first
+        // and happens later on the edit-page Channels card (user DMs the bot → code
+        // lands in Pending → admin approves). This mirrors the LINE flow.
         if (!configPath) {
             res.status(501).json({ error: 'Agent management not available (no configPath)' });
             return;
         }
-        const { wizardId } = req.params;
-        const wizard = wizard_state_1.wizardStore.get(wizardId);
-        if (!wizard) {
-            res.status(404).json({ error: 'Wizard not found or expired' });
-            return;
-        }
-        if (wizard.step !== 'pairing') {
-            res.status(409).json({ error: `Expected step 'pairing', got '${wizard.step}'` });
-            return;
-        }
-        if (wizard.channel !== 'telegram') {
-            res.status(501).json({ error: 'Discord pairing verification via API is not yet supported' });
-            return;
-        }
-        const result = await checkTelegramCode(wizard.botToken, wizard.pairingCode, wizard.updateOffset ?? 0);
-        // Always advance offset on non-error responses to avoid re-processing seen messages
-        if (!result) {
-            // Network/API error — keep current offset; client may retry
-            res.json({ success: false, pending: true });
-            return;
-        }
-        if (!result.found) {
-            wizard_state_1.wizardStore.update(wizardId, { updateOffset: result.nextOffset });
-            res.json({ success: false, pending: true });
-            return;
-        }
-        // Code matched — commit config first, then advance offset so a retry can still succeed
-        // if the config write failed mid-way
         try {
             await writeAgentsToConfig(configPath, (agents) => {
                 const agent = agents.find((a) => a.id === wizard.agentId);
-                if (agent)
-                    agent.telegram = { botToken: wizard.botToken };
+                if (agent) {
+                    if (channel === 'telegram')
+                        agent.telegram = { botToken };
+                    else
+                        agent.discord = { botToken };
+                }
             });
         }
         catch (err) {
             res.status(500).json({ error: `Failed to update config: ${err.message}` });
             return;
         }
-        wizard_state_1.wizardStore.update(wizardId, { updateOffset: result.nextOffset, step: 'complete' });
-        const agentsBase = getAgentsBaseDir();
-        const telegramStateDir = path.join(agentsBase, wizard.agentId, 'workspace', '.telegram-state');
-        try {
-            fs.mkdirSync(telegramStateDir, { recursive: true });
-            const access = JSON.stringify({ dmPolicy: 'allowlist', allowFrom: [result.senderId], groups: {}, pending: {} }, null, 2);
-            await fsp.writeFile(path.join(telegramStateDir, 'access.json'), access, { mode: 0o600 });
-        }
-        catch (err) {
-            console.error(`[wizard] access.json write failed for '${wizard.agentId}': ${err.message}`);
-        }
-        try {
-            await fetch(`${TELEGRAM_API_BASE}/bot${wizard.botToken}/sendMessage`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ chat_id: result.chatId, text: "You're connected! Send me a message to get started." }),
-            });
+        // Seed a secure access.json immediately for a brand-new Discord connection.
+        // Without this, the receiver's env-derived fallback (DISCORD_GUILD_ALLOWLIST
+        // empty ⇒ groupPolicy 'open') answers in any server with no pairing/approval —
+        // only DMs were ever gated. Skip if a file already exists (don't clobber a
+        // prior connect/reconnect).
+        if (channel === 'discord') {
+            const accessFile = path.join(getDiscordStateDir(wizard.agentId), 'access.json');
+            if (!fs.existsSync(accessFile)) {
+                try {
+                    writeDiscordAccess(wizard.agentId, {
+                        dmPolicy: 'allowlist', pairing: true, allowFrom: [],
+                        groupPolicy: 'allowlist', requireMention: true,
+                        guildAllowlist: [], channelAllowlist: [], roleAllowlist: [], pending: {},
+                    });
+                }
+                catch { /* non-fatal — receiver still has a (less safe) env fallback */ }
+            }
         }
-        catch { /* non-fatal */ }
-        // Hot-start the receiver so the agent responds immediately without a gateway restart
+        wizard_state_1.wizardStore.update(wizardId, {
+            step: 'complete',
+            channel: channel,
+            botToken,
+        });
+        // Hot-start the receiver so the bot comes online immediately without a
+        // gateway restart. The first DM from the owner then produces a pairing code
+        // they approve on the edit-page Channels card.
         const runner = agentRunners.get(wizard.agentId);
         if (runner) {
-            runner.updateAgentConfig({ ...runner.getAgentConfig(), telegram: { botToken: wizard.botToken } });
-            runner.startTelegramReceiver();
+            const base = runner.getAgentConfig();
+            if (channel === 'telegram') {
+                runner.updateAgentConfig({ ...base, telegram: { botToken } });
+                runner.startTelegramReceiver();
+            }
+            else {
+                runner.updateAgentConfig({ ...base, discord: { botToken } });
+                runner.startDiscordReceiver();
+            }
         }
-        wizard_state_1.wizardStore.delete(wizardId);
-        res.json({ success: true, agentId: wizard.agentId });
+        res.json({ channel, botName, connected: true });
     });
     /**
      * POST /api/v1/agents/wizard/:wizardId/complete
@@ -1342,7 +1395,24 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
         if (discord_bot_token !== undefined) {
             const token = typeof discord_bot_token === 'string' ? discord_bot_token.trim() : null;
             if (token) {
+                const isNewConnection = !cfg.discord?.botToken;
                 cfg.discord = { ...(cfg.discord ?? {}), botToken: token };
+                // Seed a secure access.json for a brand-new connection — see matching
+                // comment on the wizard /channel handler for why this can't be left to
+                // the receiver's env-derived fallback.
+                if (isNewConnection) {
+                    const accessFile = path.join(getDiscordStateDir(agentId), 'access.json');
+                    if (!fs.existsSync(accessFile)) {
+                        try {
+                            writeDiscordAccess(agentId, {
+                                dmPolicy: 'allowlist', pairing: true, allowFrom: [],
+                                groupPolicy: 'allowlist', requireMention: true,
+                                guildAllowlist: [], channelAllowlist: [], roleAllowlist: [], pending: {},
+                            });
+                        }
+                        catch { /* non-fatal — receiver still has a (less safe) env fallback */ }
+                    }
+                }
                 // Hot-start receiver if not already running
                 const runner = agentRunners.get(agentId);
                 if (runner) {
@@ -1429,6 +1499,15 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
                 telegram_token_preview: cfg.telegram?.botToken ? maskToken(cfg.telegram.botToken) : null,
                 discord_token_preview: cfg.discord?.botToken ? maskToken(cfg.discord.botToken) : null,
                 telegram_dm_policy: cfg.telegram?.botToken ? readTelegramAccess(agentId).dmPolicy : null,
+                telegram_pairing: cfg.telegram?.botToken ? readTelegramAccess(agentId).pairing : null,
+                telegram_group_policy: cfg.telegram?.botToken ? readTelegramAccess(agentId).groupPolicy : null,
+                telegram_group_allowlist: cfg.telegram?.botToken ? readTelegramAccess(agentId).groupAllowlist : null,
+                telegram_require_mention: cfg.telegram?.botToken ? readTelegramAccess(agentId).requireMention : null,
+                discord_dm_policy: cfg.discord?.botToken ? readDiscordAccess(agentId).dmPolicy : null,
+                discord_pairing: cfg.discord?.botToken ? readDiscordAccess(agentId).pairing : null,
+                discord_group_policy: cfg.discord?.botToken ? readDiscordAccess(agentId).groupPolicy : null,
+                discord_guild_allowlist: cfg.discord?.botToken ? readDiscordAccess(agentId).guildAllowlist : null,
+                discord_require_mention: cfg.discord?.botToken ? readDiscordAccess(agentId).requireMention : null,
                 line_connected: !!cfg.line?.channelSecret,
                 line_token_preview: cfg.line?.channelAccessToken ? maskToken(cfg.line.channelAccessToken) : null,
                 line_webhook_path: cfg.line?.channelSecret ? `/webhooks/line/${agentId}` : null,
@@ -1461,12 +1540,15 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             catch { /* non-fatal cleanup */ }
         }
         const pending = Object.entries(access.pending)
-            .map(([code, p]) => ({ code, senderId: p.senderId, chatId: p.chatId, createdAt: p.createdAt, expiresAt: p.expiresAt }));
+            .map(([code, p]) => ({ code, senderId: p.senderId, chatId: p.chatId, createdAt: p.createdAt, expiresAt: p.expiresAt, kind: p.kind ?? 'dm' }));
         res.json({ pending });
     });
     /**
      * POST /api/v1/agents/:agentId/telegram/approve
-     * Approve a pending Telegram pairing by code.
+     * Approve a pending Telegram pairing by code. Kind-aware (mirrors LINE): a
+     * 'group' knock moves its chatId into groupAllowlist (no approved/ handshake —
+     * a group has no single recipient); a 'dm' knock allowlists the sender and
+     * drops the approved/<senderId> file so the receiver sends a confirmation.
      */
     router.post('/v1/agents/:agentId/telegram/approve', auth, (req, res) => {
         const { agentId } = req.params;
@@ -1490,20 +1572,29 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             res.status(404).json({ error: 'Pairing code not found or expired' });
             return;
         }
-        if (!access.allowFrom.includes(entry.senderId))
-            access.allowFrom.push(entry.senderId);
+        const isGroup = entry.kind === 'group';
+        if (isGroup) {
+            if (!access.groupAllowlist.includes(entry.chatId))
+                access.groupAllowlist.push(entry.chatId);
+        }
+        else {
+            if (!access.allowFrom.includes(entry.senderId))
+                access.allowFrom.push(entry.senderId);
+        }
         delete access.pending[code];
         try {
             writeTelegramAccess(agentId, access);
-            const approvedDir = path.join(getTelegramStateDir(agentId), 'approved');
-            fs.mkdirSync(approvedDir, { recursive: true });
-            fs.writeFileSync(path.join(approvedDir, entry.senderId), entry.chatId);
+            if (!isGroup) {
+                const approvedDir = path.join(getTelegramStateDir(agentId), 'approved');
+                fs.mkdirSync(approvedDir, { recursive: true });
+                fs.writeFileSync(path.join(approvedDir, entry.senderId), entry.chatId);
+            }
         }
         catch (err) {
             res.status(500).json({ error: `Failed to approve pairing: ${err.message}` });
             return;
         }
-        res.json({ ok: true, senderId: entry.senderId });
+        res.json({ ok: true, senderId: entry.senderId, groupId: isGroup ? entry.chatId : undefined });
     });
     /**
      * POST /api/v1/agents/:agentId/telegram/deny
@@ -1541,10 +1632,13 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
         res.json({ ok: true });
     });
     /**
-     * POST /api/v1/agents/:agentId/telegram/init-pairing
-     * Write sentinel file so the next private message auto-approves sender as owner.
+     * PATCH /api/v1/agents/:agentId/telegram/policy
+     * Update the Telegram DM policy, the orthogonal pairing toggle, the group
+     * policy, and/or the group mention gate.
+     * Body: { dmPolicy?, pairing?, groupPolicy?: 'open'|'allowlist'|'disabled', requireMention?: boolean }.
+     * At least one field must be present; each is applied only if provided.
      */
-    router.post('/v1/agents/:agentId/telegram/init-pairing', auth, (req, res) => {
+    router.patch('/v1/agents/:agentId/telegram/policy', auth, (req, res) => {
         const { agentId } = req.params;
         const apiKey = req.apiKey;
         if (!(0, auth_1.isAdmin)(apiKey)) {
@@ -1555,67 +1649,37 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             res.status(404).json({ error: `Agent '${agentId}' not found` });
             return;
         }
-        const stateDir = getTelegramStateDir(agentId);
-        try {
-            fs.mkdirSync(stateDir, { recursive: true });
-            fs.writeFileSync(path.join(stateDir, 'awaiting-owner'), '');
-        }
-        catch (err) {
-            res.status(500).json({ error: `Failed to write sentinel: ${err.message}` });
-            return;
-        }
-        res.json({ ok: true });
-    });
-    /**
-     * GET /api/v1/agents/:agentId/telegram/pairing-status
-     * Returns whether init-pairing sentinel is still active.
-     */
-    router.get('/v1/agents/:agentId/telegram/pairing-status', auth, (req, res) => {
-        const { agentId } = req.params;
-        const apiKey = req.apiKey;
-        if (!(0, auth_1.isAdmin)(apiKey)) {
-            res.status(403).json({ error: 'Admin key required' });
+        const { dmPolicy, pairing, groupPolicy, requireMention } = req.body;
+        const valid = ['open', 'allowlist', 'disabled'];
+        if (dmPolicy !== undefined && !valid.includes(dmPolicy)) {
+            res.status(400).json({ error: `dmPolicy must be one of: ${valid.join(', ')}` });
             return;
         }
-        if (!agentConfigs.has(agentId)) {
-            res.status(404).json({ error: `Agent '${agentId}' not found` });
+        if (pairing !== undefined && typeof pairing !== 'boolean') {
+            res.status(400).json({ error: 'pairing must be a boolean' });
             return;
         }
-        const sentinelPath = path.join(getTelegramStateDir(agentId), 'awaiting-owner');
-        let waiting = false;
-        try {
-            const stat = fs.statSync(sentinelPath);
-            waiting = Date.now() - stat.mtimeMs < 10 * 60 * 1000;
-            if (!waiting)
-                fs.rmSync(sentinelPath, { force: true });
-        }
-        catch { /* ENOENT — not waiting */ }
-        const access = readTelegramAccess(agentId);
-        res.json({ waiting, allowFrom: access.allowFrom });
-    });
-    /**
-     * PATCH /api/v1/agents/:agentId/telegram/policy
-     * Update the Telegram DM policy for an agent.
-     */
-    router.patch('/v1/agents/:agentId/telegram/policy', auth, (req, res) => {
-        const { agentId } = req.params;
-        const apiKey = req.apiKey;
-        if (!(0, auth_1.isAdmin)(apiKey)) {
-            res.status(403).json({ error: 'Admin key required' });
+        if (groupPolicy !== undefined && !valid.includes(groupPolicy)) {
+            res.status(400).json({ error: `groupPolicy must be one of: ${valid.join(', ')}` });
             return;
         }
-        if (!agentConfigs.has(agentId)) {
-            res.status(404).json({ error: `Agent '${agentId}' not found` });
+        if (requireMention !== undefined && typeof requireMention !== 'boolean') {
+            res.status(400).json({ error: 'requireMention must be a boolean' });
             return;
         }
-        const { dmPolicy } = req.body;
-        const valid = ['open', 'pairing', 'allowlist', 'disabled'];
-        if (!dmPolicy || !valid.includes(dmPolicy)) {
-            res.status(400).json({ error: `dmPolicy must be one of: ${valid.join(', ')}` });
+        if (dmPolicy === undefined && pairing === undefined && groupPolicy === undefined && requireMention === undefined) {
+            res.status(400).json({ error: 'provide dmPolicy, pairing, groupPolicy and/or requireMention' });
             return;
         }
         const access = readTelegramAccess(agentId);
-        access.dmPolicy = dmPolicy;
+        if (dmPolicy !== undefined)
+            access.dmPolicy = dmPolicy;
+        if (pairing !== undefined)
+            access.pairing = pairing;
+        if (groupPolicy !== undefined)
+            access.groupPolicy = groupPolicy;
+        if (requireMention !== undefined)
+            access.requireMention = requireMention;
         try {
             writeTelegramAccess(agentId, access);
         }
@@ -1623,7 +1687,7 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             res.status(500).json({ error: `Failed to update policy: ${err.message}` });
             return;
         }
-        res.json({ ok: true, dmPolicy });
+        res.json({ ok: true, dmPolicy: access.dmPolicy, pairing: access.pairing, groupPolicy: access.groupPolicy, requireMention: access.requireMention });
     });
     /**
      * GET /api/v1/agents/:agentId/telegram/allowlist
@@ -1713,6 +1777,333 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
         }
         res.json({ ok: true });
     });
+    /**
+     * GET /api/v1/agents/:agentId/telegram/group/allowlist
+     * Return the allowlisted group ids for an agent's Telegram channel. Admin only.
+     */
+    router.get('/v1/agents/:agentId/telegram/group/allowlist', auth, (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const access = readTelegramAccess(agentId);
+        res.json({ groupAllowlist: access.groupAllowlist });
+    });
+    /**
+     * DELETE /api/v1/agents/:agentId/telegram/group/allow/:groupId
+     * Remove a group from the group allowlist. Admin only. Telegram group ids are
+     * negative (e.g. -1001234567890) so the validation allows a leading minus.
+     */
+    router.delete('/v1/agents/:agentId/telegram/group/allow/:groupId', auth, (req, res) => {
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        const { agentId, groupId } = req.params;
+        if (!/^-?\d+$/.test(groupId)) {
+            res.status(400).json({ error: 'Invalid groupId: must be a numeric Telegram chat ID' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const access = readTelegramAccess(agentId);
+        access.groupAllowlist = access.groupAllowlist.filter((id) => id !== groupId);
+        // Also drop any legacy per-sender restriction for this group so a later
+        // re-add (via a fresh pairing knock) doesn't resurrect a stale allowlist.
+        if (access.legacyGroupAllowFrom)
+            delete access.legacyGroupAllowFrom[groupId];
+        try {
+            writeTelegramAccess(agentId, access);
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to update group allowlist: ${err.message}` });
+            return;
+        }
+        res.json({ ok: true });
+    });
+    /**
+     * GET /api/v1/agents/:agentId/discord/pending
+     * List pending Discord pairing requests (non-expired).
+     */
+    router.get('/v1/agents/:agentId/discord/pending', auth, (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const access = readDiscordAccess(agentId);
+        const now = Date.now();
+        const expired = Object.keys(access.pending).filter((code) => access.pending[code].expiresAt <= now);
+        if (expired.length > 0) {
+            expired.forEach((code) => { delete access.pending[code]; });
+            try {
+                writeDiscordAccess(agentId, access);
+            }
+            catch { /* non-fatal cleanup */ }
+        }
+        const pending = Object.entries(access.pending)
+            .map(([code, p]) => ({ code, senderId: p.senderId, channelId: p.channelId, createdAt: p.createdAt, expiresAt: p.expiresAt, kind: p.kind ?? 'dm', guildId: p.guildId }));
+        res.json({ pending });
+    });
+    /**
+     * POST /api/v1/agents/:agentId/discord/approve
+     * Approve a pending Discord pairing by code. Kind-aware (mirrors LINE): a
+     * 'guild' knock moves its guildId into guildAllowlist (no approved/ handshake
+     * — a guild has no single recipient); a 'dm' knock allowlists the sender and
+     * drops the approved/<senderId> file for the "You're connected!" reply.
+     */
+    router.post('/v1/agents/:agentId/discord/approve', auth, (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const { code } = req.body;
+        if (!code) {
+            res.status(400).json({ error: 'code required' });
+            return;
+        }
+        const access = readDiscordAccess(agentId);
+        const entry = access.pending[code];
+        if (!entry || entry.expiresAt < Date.now()) {
+            res.status(404).json({ error: 'Pairing code not found or expired' });
+            return;
+        }
+        const isGuild = entry.kind === 'guild';
+        if (isGuild) {
+            if (entry.guildId && !access.guildAllowlist.includes(entry.guildId))
+                access.guildAllowlist.push(entry.guildId);
+        }
+        else {
+            if (!access.allowFrom.includes(entry.senderId))
+                access.allowFrom.push(entry.senderId);
+        }
+        delete access.pending[code];
+        try {
+            writeDiscordAccess(agentId, access);
+            if (!isGuild) {
+                // Handshake consumed by module.ts:checkApprovals() — file name is the
+                // senderId, content is the channelId to DM "You're connected!".
+                const approvedDir = path.join(getDiscordStateDir(agentId), 'approved');
+                fs.mkdirSync(approvedDir, { recursive: true });
+                fs.writeFileSync(path.join(approvedDir, entry.senderId), entry.channelId);
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to approve pairing: ${err.message}` });
+            return;
+        }
+        res.json({ ok: true, senderId: entry.senderId, guildId: isGuild ? entry.guildId : undefined });
+    });
+    /**
+     * POST /api/v1/agents/:agentId/discord/deny
+     * Deny and remove a pending Discord pairing by code.
+     */
+    router.post('/v1/agents/:agentId/discord/deny', auth, (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const { code } = req.body;
+        if (!code) {
+            res.status(400).json({ error: 'code required' });
+            return;
+        }
+        const access = readDiscordAccess(agentId);
+        if (!access.pending[code]) {
+            res.status(404).json({ error: 'Pairing code not found' });
+            return;
+        }
+        delete access.pending[code];
+        try {
+            writeDiscordAccess(agentId, access);
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to deny pairing: ${err.message}` });
+            return;
+        }
+        res.json({ ok: true });
+    });
+    /**
+     * PATCH /api/v1/agents/:agentId/discord/policy
+     * Update the Discord DM policy, the orthogonal pairing toggle, the guild
+     * policy, and/or the guild mention gate.
+     * Body: { dmPolicy?, pairing?, groupPolicy?: 'open'|'allowlist'|'disabled', requireMention?: boolean }.
+     * At least one field must be present; each is applied only if provided.
+     */
+    router.patch('/v1/agents/:agentId/discord/policy', auth, (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const { dmPolicy, pairing, groupPolicy, requireMention } = req.body;
+        const valid = ['open', 'allowlist', 'disabled'];
+        if (dmPolicy !== undefined && !valid.includes(dmPolicy)) {
+            res.status(400).json({ error: `dmPolicy must be one of: ${valid.join(', ')}` });
+            return;
+        }
+        if (pairing !== undefined && typeof pairing !== 'boolean') {
+            res.status(400).json({ error: 'pairing must be a boolean' });
+            return;
+        }
+        if (groupPolicy !== undefined && !valid.includes(groupPolicy)) {
+            res.status(400).json({ error: `groupPolicy must be one of: ${valid.join(', ')}` });
+            return;
+        }
+        if (requireMention !== undefined && typeof requireMention !== 'boolean') {
+            res.status(400).json({ error: 'requireMention must be a boolean' });
+            return;
+        }
+        if (dmPolicy === undefined && pairing === undefined && groupPolicy === undefined && requireMention === undefined) {
+            res.status(400).json({ error: 'provide dmPolicy, pairing, groupPolicy and/or requireMention' });
+            return;
+        }
+        const access = readDiscordAccess(agentId);
+        if (dmPolicy !== undefined)
+            access.dmPolicy = dmPolicy;
+        if (pairing !== undefined)
+            access.pairing = pairing;
+        if (groupPolicy !== undefined)
+            access.groupPolicy = groupPolicy;
+        if (requireMention !== undefined)
+            access.requireMention = requireMention;
+        try {
+            writeDiscordAccess(agentId, access);
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to update policy: ${err.message}` });
+            return;
+        }
+        res.json({ ok: true, dmPolicy: access.dmPolicy, pairing: access.pairing, groupPolicy: access.groupPolicy, requireMention: access.requireMention });
+    });
+    /**
+     * GET /api/v1/agents/:agentId/discord/allowlist
+     * Return all users in allowFrom for an agent's Discord channel.
+     */
+    router.get('/v1/agents/:agentId/discord/allowlist', auth, (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const access = readDiscordAccess(agentId);
+        res.json({ allowFrom: access.allowFrom });
+    });
+    /**
+     * DELETE /api/v1/agents/:agentId/discord/allow/:userId
+     * Remove a user from the allowFrom list. Admin only.
+     */
+    router.delete('/v1/agents/:agentId/discord/allow/:userId', auth, (req, res) => {
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        const { agentId, userId } = req.params;
+        if (!/^\d+$/.test(userId)) {
+            res.status(400).json({ error: 'Invalid userId: must be a numeric Discord user ID' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const access = readDiscordAccess(agentId);
+        access.allowFrom = access.allowFrom.filter((id) => id !== userId);
+        try {
+            writeDiscordAccess(agentId, access);
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to update allowlist: ${err.message}` });
+            return;
+        }
+        res.json({ ok: true });
+    });
+    /**
+     * GET /api/v1/agents/:agentId/discord/guild/allowlist
+     * Return the allowlisted guild ids for an agent's Discord channel. Admin only.
+     */
+    router.get('/v1/agents/:agentId/discord/guild/allowlist', auth, (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const access = readDiscordAccess(agentId);
+        res.json({ guildAllowlist: access.guildAllowlist });
+    });
+    /**
+     * DELETE /api/v1/agents/:agentId/discord/guild/allow/:guildId
+     * Remove a guild from the guild allowlist. Admin only. Discord guild ids are
+     * numeric snowflakes (no leading minus).
+     */
+    router.delete('/v1/agents/:agentId/discord/guild/allow/:guildId', auth, (req, res) => {
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        const { agentId, guildId } = req.params;
+        if (!/^\d+$/.test(guildId)) {
+            res.status(400).json({ error: 'Invalid guildId: must be a numeric Discord guild ID' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const access = readDiscordAccess(agentId);
+        access.guildAllowlist = access.guildAllowlist.filter((id) => id !== guildId);
+        try {
+            writeDiscordAccess(agentId, access);
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to update guild allowlist: ${err.message}` });
+            return;
+        }
+        res.json({ ok: true });
+    });
     /**
      * DELETE /api/v1/agents/:agentId
      *