@0xmaxma/claude-gateway 1.1.9 → 1.2.0

package/dist/api/router.js

@@ -51,6 +51,11 @@ const MAX_MESSAGE_LENGTH = 10000;
 const DEFAULT_TIMEOUT_MS = 60000;
 const AGENT_ID_RE = /^[a-z][a-z0-9_-]{1,31}$/;
 const SAFE_FILENAME_RE = /^[a-zA-Z0-9._\-() ]+$/;
+function maskToken(token) {
+    if (token.length <= 12)
+        return '•'.repeat(token.length);
+    return token.slice(0, 8) + '•••••' + token.slice(-4);
+}
 /** Detect MIME type from file magic bytes (first 12 bytes). */
 function detectMimeFromMagic(header) {
     if (header[0] === 0xFF && header[1] === 0xD8 && header[2] === 0xFF)
@@ -323,8 +328,8 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
         const timeoutMs = typeof timeout_ms === 'number' && timeout_ms > 0 && timeout_ms <= 600000
             ? timeout_ms
             : DEFAULT_TIMEOUT_MS;
-        // Slash command dispatch — runs instead of sending to Claude
-        if (message.trim().startsWith('/')) {
+        // Built-in command dispatch — only intercept known commands, let everything else reach Claude
+        if (runner_1.AgentRunner.isApiBuiltinCommand(message.trim())) {
             try {
                 const result = await runner.executeApiCommand(sessionId, chatIdStr, message.trim());
                 res.json({ command: message.trim(), session_id: sessionId, result });
@@ -455,6 +460,11 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             model: cfg.claude?.model ?? null,
             allow_tools: cfg.allow_tools ?? false,
             avatarUrl: cfg.avatar ? `/api/v1/agents/${id}/avatar` : null,
+            telegram_connected: !!cfg.telegram?.botToken,
+            discord_connected: !!cfg.discord?.botToken,
+            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,
         }));
         res.json({ agents });
     });
@@ -544,6 +554,19 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             }
             return;
         }
+        // Update in-memory agentConfigs immediately so GET /api/v1/agents returns the new agent
+        // without waiting for the file watcher (~500ms debounce).
+        agentConfigs.set(id, {
+            id,
+            description: description.trim(),
+            workspace: workspaceAbs,
+            env: path.join(workspaceAbs, '.env'),
+            claude: {
+                model: typeof model === 'string' && model.trim() ? model.trim() : 'claude-sonnet-4-6',
+                dangerouslySkipPermissions: false,
+                extraFlags: [],
+            },
+        });
         // Config written successfully — now create workspace directory and stub files.
         const stubFiles = {
             'AGENTS.md': `# Agent: ${id}\n\n${description.trim()}\n`,
@@ -575,6 +598,40 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             ? path.join(path.dirname(configPath), 'agents')
             : path.join(os.homedir(), '.claude-gateway', 'agents');
     }
+    function getTelegramStateDir(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, '.telegram-state');
+    }
+    function readTelegramAccess(agentId) {
+        const accessFile = path.join(getTelegramStateDir(agentId), 'access.json');
+        try {
+            const raw = fs.readFileSync(accessFile, 'utf8');
+            const parsed = JSON.parse(raw);
+            return {
+                dmPolicy: parsed.dmPolicy ?? 'pairing',
+                allowFrom: parsed.allowFrom ?? [],
+                groups: parsed.groups ?? {},
+                pending: parsed.pending ?? {},
+            };
+        }
+        catch {
+            return { dmPolicy: 'pairing', allowFrom: [], groups: {}, pending: {} };
+        }
+    }
+    function writeTelegramAccess(agentId, access) {
+        const stateDir = getTelegramStateDir(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 Telegram access config: ${err.message}`);
+        }
+    }
     /**
      * POST /api/v1/agents/wizard/start
      * Start wizard: call Claude to generate workspace files, return wizardId + preview.
@@ -799,6 +856,17 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             });
             return;
         }
+        // Update in-memory agentConfigs immediately so GET /api/v1/agents returns the new agent
+        // without waiting for the file watcher (~500ms debounce).
+        agentConfigs.set(agentId, {
+            id: agentId,
+            description: wizard.prompt.slice(0, 200).trim(),
+            workspace: workspaceDirAbs,
+            env: path.join(workspaceDirAbs, '.env'),
+            claude: { model: defaultModel, dangerouslySkipPermissions: false, extraFlags: [] },
+            ...(wizard.signatureEmoji ? { signatureEmoji: wizard.signatureEmoji } : {}),
+            ...(avatarFilename ? { avatar: avatarFilename } : {}),
+        });
         wizard_state_1.wizardStore.update(wizardId, { step: 'confirmed' });
         const avatarUrl = avatarFilename ? `/api/v1/agents/${agentId}/avatar` : null;
         res.json({
@@ -951,6 +1019,12 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             });
         }
         catch { /* non-fatal */ }
+        // Hot-start the receiver so the agent responds immediately without a gateway restart
+        const runner = agentRunners.get(wizard.agentId);
+        if (runner) {
+            runner.updateAgentConfig({ ...runner.getAgentConfig(), telegram: { botToken: wizard.botToken } });
+            runner.startTelegramReceiver();
+        }
         wizard_state_1.wizardStore.delete(wizardId);
         res.json({ success: true, agentId: wizard.agentId });
     });
@@ -1000,7 +1074,7 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             return;
         }
         const body = req.body;
-        const { description, model, allow_tools } = body;
+        const { description, model, allow_tools, telegram_bot_token, discord_bot_token } = body;
         if (description !== undefined && (typeof description !== 'string' || !description.trim())) {
             res.status(400).json({ error: 'description must be a non-empty string' });
             return;
@@ -1013,6 +1087,14 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             res.status(400).json({ error: 'allow_tools must be a boolean' });
             return;
         }
+        if (telegram_bot_token !== undefined && telegram_bot_token !== null && typeof telegram_bot_token !== 'string') {
+            res.status(400).json({ error: 'telegram_bot_token must be a string or null' });
+            return;
+        }
+        if (discord_bot_token !== undefined && discord_bot_token !== null && typeof discord_bot_token !== 'string') {
+            res.status(400).json({ error: 'discord_bot_token must be a string or null' });
+            return;
+        }
         try {
             await writeAgentsToConfig(configPath, (agents) => {
                 const agent = agents.find((a) => a.id === agentId);
@@ -1027,6 +1109,23 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
                 }
                 if (allow_tools !== undefined)
                     agent.allow_tools = allow_tools;
+                if (telegram_bot_token !== undefined) {
+                    if (telegram_bot_token === null || telegram_bot_token === '') {
+                        delete agent.telegram;
+                    }
+                    else {
+                        agent.telegram = { botToken: telegram_bot_token.trim() };
+                    }
+                }
+                if (discord_bot_token !== undefined) {
+                    if (discord_bot_token === null || discord_bot_token === '') {
+                        delete agent.discord;
+                    }
+                    else {
+                        const existing = agent.discord;
+                        agent.discord = { ...(existing ?? {}), botToken: discord_bot_token.trim() };
+                    }
+                }
             });
         }
         catch (err) {
@@ -1041,7 +1140,289 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             cfg.claude.model = model.trim();
         if (allow_tools !== undefined)
             cfg.allow_tools = allow_tools;
-        res.json({ agent: { id: agentId, description: cfg.description, model: cfg.claude?.model, allow_tools: cfg.allow_tools ?? false } });
+        if (telegram_bot_token !== undefined) {
+            const token = typeof telegram_bot_token === 'string' ? telegram_bot_token.trim() : null;
+            if (token) {
+                cfg.telegram = { botToken: token };
+                // Hot-start receiver if not already running
+                const runner = agentRunners.get(agentId);
+                if (runner) {
+                    runner.updateAgentConfig(cfg);
+                    runner.startTelegramReceiver();
+                }
+            }
+            else {
+                delete cfg.telegram;
+                agentRunners.get(agentId)?.stopTelegramReceiver();
+            }
+        }
+        if (discord_bot_token !== undefined) {
+            const token = typeof discord_bot_token === 'string' ? discord_bot_token.trim() : null;
+            if (token) {
+                cfg.discord = { ...(cfg.discord ?? {}), botToken: token };
+                // Hot-start receiver if not already running
+                const runner = agentRunners.get(agentId);
+                if (runner) {
+                    runner.updateAgentConfig(cfg);
+                    runner.startDiscordReceiver();
+                }
+            }
+            else {
+                delete cfg.discord;
+                agentRunners.get(agentId)?.stopDiscordReceiver();
+            }
+        }
+        res.json({
+            agent: {
+                id: agentId,
+                description: cfg.description,
+                model: cfg.claude?.model,
+                allow_tools: cfg.allow_tools ?? false,
+                telegram_connected: !!cfg.telegram?.botToken,
+                discord_connected: !!cfg.discord?.botToken,
+                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,
+            },
+        });
+    });
+    /**
+     * GET /api/v1/agents/:agentId/telegram/pending
+     * List pending Telegram pairing requests (non-expired).
+     */
+    router.get('/v1/agents/:agentId/telegram/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 = readTelegramAccess(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 {
+                writeTelegramAccess(agentId, access);
+            }
+            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 }));
+        res.json({ pending });
+    });
+    /**
+     * POST /api/v1/agents/:agentId/telegram/approve
+     * Approve a pending Telegram pairing by code.
+     */
+    router.post('/v1/agents/:agentId/telegram/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 = readTelegramAccess(agentId);
+        const entry = access.pending[code];
+        if (!entry || entry.expiresAt < Date.now()) {
+            res.status(404).json({ error: 'Pairing code not found or expired' });
+            return;
+        }
+        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);
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to approve pairing: ${err.message}` });
+            return;
+        }
+        res.json({ ok: true, senderId: entry.senderId });
+    });
+    /**
+     * POST /api/v1/agents/:agentId/telegram/deny
+     * Deny and remove a pending Telegram pairing by code.
+     */
+    router.post('/v1/agents/:agentId/telegram/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 = readTelegramAccess(agentId);
+        if (!access.pending[code]) {
+            res.status(404).json({ error: 'Pairing code not found' });
+            return;
+        }
+        delete access.pending[code];
+        try {
+            writeTelegramAccess(agentId, access);
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to deny pairing: ${err.message}` });
+            return;
+        }
+        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.
+     */
+    router.post('/v1/agents/:agentId/telegram/init-pairing', 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 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' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            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' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            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(', ')}` });
+            return;
+        }
+        const access = readTelegramAccess(agentId);
+        access.dmPolicy = dmPolicy;
+        try {
+            writeTelegramAccess(agentId, access);
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to update policy: ${err.message}` });
+            return;
+        }
+        res.json({ ok: true, dmPolicy });
+    });
+    /**
+     * GET /api/v1/agents/:agentId/telegram/allowlist
+     * Return all users in allowFrom for an agent's Telegram channel.
+     */
+    router.get('/v1/agents/:agentId/telegram/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({ allowFrom: access.allowFrom });
+    });
+    /**
+     * DELETE /api/v1/agents/:agentId/telegram/allow/:userId
+     * Remove a user from the allowFrom list. Admin only.
+     */
+    router.delete('/v1/agents/:agentId/telegram/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 Telegram user ID' });
+            return;
+        }
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const access = readTelegramAccess(agentId);
+        access.allowFrom = access.allowFrom.filter((id) => id !== userId);
+        try {
+            writeTelegramAccess(agentId, access);
+        }
+        catch (err) {
+            res.status(500).json({ error: `Failed to update allowlist: ${err.message}` });
+            return;
+        }
+        res.json({ ok: true });
     });
     /**
      * DELETE /api/v1/agents/:agentId