@0xmaxma/claude-gateway 1.8.12 → 1.8.14

package/dist/api/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/api/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAW,QAAQ,EAAE,MAAM,SAAS,CAAC;AAOpD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,EAAe,WAAW,EAAe,MAAM,UAAU,CAAC;AAoFtF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAExD;AAMD,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAEtD;AAuED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CA4CjD;AAmTD,wBAAgB,eAAe,CAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACtC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACtC,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,CAAC,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,WAAW,EAAE,GACrB,MAAM,CAq+HR"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/api/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAW,QAAQ,EAAE,MAAM,SAAS,CAAC;AAOpD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,EAAe,WAAW,EAAe,MAAM,UAAU,CAAC;AAoFtF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAExD;AAMD,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAEtD;AAuED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CA4CjD;AAmUD,wBAAgB,eAAe,CAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACtC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACtC,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,CAAC,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,WAAW,EAAE,GACrB,MAAM,CAytIR"}

package/dist/api/router.js

@@ -449,6 +449,20 @@ const TELEGRAM_API_BASE = process.env.TELEGRAM_API_BASE ?? 'https://api.telegram
 /** Max simultaneous wizard/start Claude subprocesses to prevent resource exhaustion. */
 let wizardStartsInFlight = 0;
 const WIZARD_MAX_CONCURRENT = 2;
+/**
+ * Max simultaneous describe/rewrite Claude subprocesses. Kept separate from
+ * wizardStartsInFlight so a burst of rewrite calls can't starve wizard-start
+ * slots (or vice versa) — the two features don't share a concurrency budget.
+ */
+let rewritesInFlight = 0;
+const REWRITE_MAX_CONCURRENT = 2;
+/**
+ * Max input length for a describe/rewrite. A real "describe your agent" draft is
+ * far shorter than this; the cap keeps an oversized payload from pinning a Claude
+ * subprocess for the full 120s timeout (two such requests would occupy both
+ * REWRITE_MAX_CONCURRENT slots and block everyone else).
+ */
+const REWRITE_MAX_TEXT_LENGTH = 8000;
 /** Call Claude --print with stdin prompt; resolves with stdout on exit 0. */
 function runClaude(prompt, timeoutMs = 120000) {
     return new Promise((resolve, reject) => {
@@ -994,6 +1008,13 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             whatsapp_cloud_dm_allowlist: cfg.whatsapp_cloud?.appSecret ? (cfg.whatsapp_cloud?.dmAllowlist ?? []) : null,
             whatsapp_cloud_pairing: cfg.whatsapp_cloud?.appSecret ? (cfg.whatsapp_cloud?.pairing ?? true) : null,
             whatsapp_cloud_templates_enabled: cfg.whatsapp_cloud?.appSecret ? (cfg.whatsapp_cloud?.templatesEnabled ?? false) : null,
+            // WeChat — "connected" is LIVE manager state (a linked QR session),
+            // never config-derived (there is no credential field to check — see
+            // AgentConfig.wechat's doc comment). DM-only: no group_* fields exist.
+            wechat_connected: agentRunners.get(id)?.getWeChatStatus?.()?.status === 'linked',
+            wechat_dm_policy: cfg.wechat?.dmPolicy ?? null,
+            wechat_dm_allowlist: cfg.wechat?.dmAllowlist ?? [],
+            wechat_pairing: cfg.wechat?.pairing ?? true,
         }));
         res.json({ agents });
     });
@@ -1362,6 +1383,64 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             expiresAt: new Date(state.expiresAt).toISOString(),
         });
     });
+    /**
+     * POST /api/v1/agents/describe/rewrite
+     * Re-write a rough "describe your agent" draft into cleaner, moderately
+     * clarified text. Stateless: no wizardId/agentId involved, single string
+     * in, single string out.
+     */
+    router.post('/v1/agents/describe/rewrite', auth, async (req, res) => {
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        const body = req.body;
+        const { text } = body;
+        if (!text || typeof text !== 'string' || !text.trim()) {
+            res.status(400).json({ error: 'text is required' });
+            return;
+        }
+        if (text.length > REWRITE_MAX_TEXT_LENGTH) {
+            res.status(400).json({ error: `text too long (max ${REWRITE_MAX_TEXT_LENGTH} characters)` });
+            return;
+        }
+        if (rewritesInFlight >= REWRITE_MAX_CONCURRENT) {
+            res.status(429).json({ error: 'Too many re-write requests in progress, please retry later' });
+            return;
+        }
+        let rawOutput;
+        rewritesInFlight++;
+        try {
+            rawOutput = await runClaude((0, create_agent_prompts_1.buildRewriteDescriptionPrompt)(text.trim()));
+        }
+        catch (err) {
+            console.error(`[api] describe/rewrite failed: ${err.message}`);
+            res.status(500).json({ error: 'Failed to re-write description' });
+            return;
+        }
+        finally {
+            rewritesInFlight--;
+        }
+        let rewritten = rawOutput.trim();
+        // Strip a wrapping code fence if the model added one, regardless of the
+        // language hint (```markdown, ```md, ```text, ```plaintext, ```html, …) or
+        // none at all. Requires the opening fence to sit on its own line so inline
+        // backticks in a single-line answer are never mistaken for a wrapper; the
+        // closing newline is optional and CRLF is tolerated.
+        const fenceMatch = rewritten.match(/^```[^\r\n`]*\r?\n([\s\S]*?)\r?\n?```\s*$/);
+        if (fenceMatch)
+            rewritten = (fenceMatch[1] ?? '').trim();
+        // Claude occasionally returns an empty/whitespace-only completion. Never
+        // answer 200 with an empty string: the frontend would overwrite the user's
+        // draft with nothing and silently destroy their input. Surface an error so
+        // the client can keep the original text and let the user retry.
+        if (!rewritten) {
+            res.status(502).json({ error: 'Re-write produced no output, please try again' });
+            return;
+        }
+        res.status(200).json({ text: rewritten });
+    });
     /**
      * PUT /api/v1/agents/wizard/:wizardId/avatar
      * Upload avatar into wizard state (in-memory until confirm).
@@ -1688,7 +1767,7 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
             return;
         }
         const body = req.body;
-        const { name, description, model, allow_tools, telegram_bot_token, discord_bot_token, line_channel_access_token, line_channel_secret, line_dm_policy, line_dm_allowlist, line_group_policy, line_group_allowlist, line_require_mention, line_pairing, slack_bot_token, slack_signing_secret, slack_dm_policy, slack_dm_allowlist, slack_group_policy, slack_group_allowlist, slack_require_mention, slack_pairing, connectors, whatsapp_account_id, whatsapp_dm_policy, whatsapp_dm_allowlist, whatsapp_group_policy, whatsapp_group_allowlist, whatsapp_require_mention, whatsapp_pairing, whatsapp_cloud_access_token, whatsapp_cloud_phone_number_id, whatsapp_cloud_app_secret, whatsapp_cloud_verify_token, whatsapp_cloud_dm_policy, whatsapp_cloud_dm_allowlist, whatsapp_cloud_pairing, whatsapp_cloud_templates_enabled } = body;
+        const { name, description, model, allow_tools, telegram_bot_token, discord_bot_token, line_channel_access_token, line_channel_secret, line_dm_policy, line_dm_allowlist, line_group_policy, line_group_allowlist, line_require_mention, line_pairing, slack_bot_token, slack_signing_secret, slack_dm_policy, slack_dm_allowlist, slack_group_policy, slack_group_allowlist, slack_require_mention, slack_pairing, connectors, whatsapp_account_id, whatsapp_dm_policy, whatsapp_dm_allowlist, whatsapp_group_policy, whatsapp_group_allowlist, whatsapp_require_mention, whatsapp_pairing, whatsapp_cloud_access_token, whatsapp_cloud_phone_number_id, whatsapp_cloud_app_secret, whatsapp_cloud_verify_token, whatsapp_cloud_dm_policy, whatsapp_cloud_dm_allowlist, whatsapp_cloud_pairing, whatsapp_cloud_templates_enabled, wechat_dm_policy, wechat_dm_allowlist, wechat_pairing } = body;
         if (name !== undefined && name !== null && typeof name !== 'string') {
             res.status(400).json({ error: 'name must be a string or null' });
             return;
@@ -1840,6 +1919,29 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
         const slackAccessTouched = slack_dm_policy !== undefined || slack_dm_allowlist !== undefined ||
             slack_group_policy !== undefined || slack_group_allowlist !== undefined || slack_require_mention !== undefined ||
             slack_pairing !== undefined;
+        // WeChat — DM-only access control (no credential, no group tier: see
+        // AgentConfig.wechat's doc comment for why). Unlike LINE/Slack's access
+        // fields, this is NOT gated on an existing wechat block already being
+        // present — linking happens out-of-band (QR scan, via the /wechat/link
+        // route below) and never touches config.json, so policy must be settable
+        // independent of link status.
+        if (wechat_dm_policy !== undefined && wechat_dm_policy !== null &&
+            !(typeof wechat_dm_policy === 'string' && ['open', 'allowlist', 'disabled'].includes(wechat_dm_policy))) {
+            res.status(400).json({ error: "wechat_dm_policy must be 'open', 'allowlist', 'disabled', or null" });
+            return;
+        }
+        if (wechat_dm_allowlist !== undefined && wechat_dm_allowlist !== null &&
+            !(Array.isArray(wechat_dm_allowlist) && wechat_dm_allowlist.every((u) => typeof u === 'string'))) {
+            res.status(400).json({ error: 'wechat_dm_allowlist must be an array of strings or null' });
+            return;
+        }
+        if (wechat_pairing !== undefined && wechat_pairing !== null &&
+            typeof wechat_pairing !== 'boolean') {
+            res.status(400).json({ error: 'wechat_pairing must be a boolean or null' });
+            return;
+        }
+        const wechatAccessTouched = wechat_dm_policy !== undefined || wechat_dm_allowlist !== undefined ||
+            wechat_pairing !== undefined;
         // connectors: a partial map of { [connectorId]: { enabled: boolean } } to merge.
         const connectorPatch = {};
         if (connectors !== undefined) {
@@ -2159,6 +2261,31 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
                         }
                     }
                 }
+                // WeChat access fields — get-or-create `agent.wechat` (not gated on it
+                // already existing, unlike LINE/Slack: see the validation block above
+                // for why).
+                if (wechatAccessTouched) {
+                    const existing = agent.wechat ?? {};
+                    if (wechat_dm_policy !== undefined) {
+                        if (wechat_dm_policy === null)
+                            delete existing.dmPolicy;
+                        else
+                            existing.dmPolicy = wechat_dm_policy;
+                    }
+                    if (wechat_dm_allowlist !== undefined) {
+                        if (wechat_dm_allowlist === null)
+                            delete existing.dmAllowlist;
+                        else
+                            existing.dmAllowlist = wechat_dm_allowlist;
+                    }
+                    if (wechat_pairing !== undefined) {
+                        if (wechat_pairing === null)
+                            delete existing.pairing;
+                        else
+                            existing.pairing = wechat_pairing;
+                    }
+                    agent.wechat = existing;
+                }
                 if (connectors !== undefined) {
                     const existing = agent.connectors ?? {};
                     agent.connectors = { ...existing, ...connectorPatch };
@@ -2420,6 +2547,38 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
                     (0, pending_senders_1.clearPendingSender)('slack', agentId, id);
             }
         }
+        if (wechatAccessTouched) {
+            const existing = cfg.wechat ?? {};
+            if (wechat_dm_policy !== undefined) {
+                if (wechat_dm_policy === null)
+                    delete existing.dmPolicy;
+                else
+                    existing.dmPolicy = wechat_dm_policy;
+            }
+            if (wechat_dm_allowlist !== undefined) {
+                if (wechat_dm_allowlist === null)
+                    delete existing.dmAllowlist;
+                else
+                    existing.dmAllowlist = wechat_dm_allowlist;
+            }
+            if (wechat_pairing !== undefined) {
+                if (wechat_pairing === null)
+                    delete existing.pairing;
+                else
+                    existing.pairing = wechat_pairing;
+            }
+            cfg.wechat = existing;
+            // WeChat has no receiver/webhook to start/stop — WeChatManager reads
+            // access control live off the agent config on every inbound message
+            // (see AgentRunner.handleWeChatInboundMessage); just keep it in sync.
+            agentRunners.get(agentId)?.updateAgentConfig(cfg);
+            // Anyone just added to an allowlist is now allowed — drop them from the
+            // in-memory knock list so the discovery UI stops surfacing them.
+            if (Array.isArray(wechat_dm_allowlist)) {
+                for (const userId of wechat_dm_allowlist)
+                    (0, pending_senders_1.clearPendingSender)('wechat', agentId, userId);
+            }
+        }
         if (connectors !== undefined) {
             const before = cfg.connectors ?? {};
             const merged = { ...before, ...connectorPatch };
@@ -2592,6 +2751,10 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
                 whatsapp_cloud_dm_allowlist: cfg.whatsapp_cloud?.appSecret ? (cfg.whatsapp_cloud?.dmAllowlist ?? []) : null,
                 whatsapp_cloud_pairing: cfg.whatsapp_cloud?.appSecret ? (cfg.whatsapp_cloud?.pairing ?? true) : null,
                 whatsapp_cloud_templates_enabled: cfg.whatsapp_cloud?.appSecret ? (cfg.whatsapp_cloud?.templatesEnabled ?? false) : null,
+                wechat_connected: agentRunners.get(agentId)?.getWeChatStatus?.()?.status === 'linked',
+                wechat_dm_policy: cfg.wechat?.dmPolicy ?? null,
+                wechat_dm_allowlist: cfg.wechat?.dmAllowlist ?? [],
+                wechat_pairing: cfg.wechat?.pairing ?? true,
             },
         });
     });
@@ -2868,6 +3031,151 @@ function createApiRouter(agentRunners, agentConfigs, apiKeys, configPath, models
         (0, pending_senders_1.clearPendingSender)('slack', agentId, senderId);
         res.json({ ok: true });
     });
+    /**
+     * GET /api/v1/agents/:agentId/wechat/status
+     * Live link status — status/qr straight from the in-process WeChatManager,
+     * never config-derived (there is no credential field to derive it from —
+     * see AgentConfig.wechat's doc comment). Polled by the web UI during
+     * linking and while showing the connected card. Requires write access
+     * (same as every other channel's connect surface), not just read. Mirrors
+     * WhatsApp's `/whatsapp/status` route shape, once that channel lands.
+     */
+    router.get('/v1/agents/:agentId/wechat/status', auth, (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.canWriteAgent)(apiKey, agentId)) {
+            res.status(403).json({ error: 'Write permission required' });
+            return;
+        }
+        const runner = agentRunners.get(agentId);
+        if (!runner) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        res.json(runner.getWeChatStatus());
+    });
+    /**
+     * POST /api/v1/agents/:agentId/wechat/link
+     * Start (or restart) a QR-code linking flow. Returns once linked or once
+     * the attempt window elapses — unlike WhatsApp's fire-and-forget
+     * `/whatsapp/link`, there is no separate pairing-code path to race against,
+     * so the client can simply await this and then re-check `/status` once.
+     */
+    router.post('/v1/agents/:agentId/wechat/link', auth, async (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.canWriteAgent)(apiKey, agentId)) {
+            res.status(403).json({ error: 'Write permission required' });
+            return;
+        }
+        const runner = agentRunners.get(agentId);
+        if (!runner) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        try {
+            await runner.startWeChatLinking();
+            res.json({ ok: true, status: runner.getWeChatStatus() });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * POST /api/v1/agents/:agentId/wechat/unlink
+     * Logout and wipe the linked session. The user must scan fresh afterward.
+     */
+    router.post('/v1/agents/:agentId/wechat/unlink', auth, async (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.canWriteAgent)(apiKey, agentId)) {
+            res.status(403).json({ error: 'Write permission required' });
+            return;
+        }
+        const runner = agentRunners.get(agentId);
+        if (!runner) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        await runner.unlinkWeChat();
+        res.json({ ok: true });
+    });
+    /**
+     * POST /api/v1/agents/:agentId/wechat/send
+     * INTERNAL — called by the `wechat_reply` MCP tool (via GATEWAY_API_URL/
+     * GATEWAY_API_KEY, same as every other MCP subprocess reaches the
+     * gateway), never by the web UI. Exists because the manager's live iLink
+     * session/credentials only exist inside this process — same reasoning
+     * WhatsApp's `/whatsapp/send` route documents for its Baileys socket.
+     */
+    router.post('/v1/agents/:agentId/wechat/send', auth, async (req, res) => {
+        const { agentId } = req.params;
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.canWriteAgent)(apiKey, agentId)) {
+            res.status(403).json({ error: 'Write permission required' });
+            return;
+        }
+        const runner = agentRunners.get(agentId);
+        if (!runner) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        const { to_id, text } = req.body;
+        if (typeof to_id !== 'string' || !to_id) {
+            res.status(400).json({ error: 'to_id is required' });
+            return;
+        }
+        if (typeof text !== 'string' || !text) {
+            res.status(400).json({ error: 'text is required' });
+            return;
+        }
+        try {
+            await runner.sendWeChatMessage(to_id, text);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * GET /api/v1/agents/:agentId/wechat/pending
+     * Recently denied WeChat senders (Tier 1 allowlist discovery aid). Admin
+     * only. Mirrors GET .../line/pending exactly, keyed under the 'wechat'
+     * channel namespace in the shared pending-senders store.
+     */
+    router.get('/v1/agents/:agentId/wechat/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;
+        }
+        res.json({ senders: (0, pending_senders_1.getPendingSenders)('wechat', agentId) });
+    });
+    /**
+     * DELETE /api/v1/agents/:agentId/wechat/pending/:senderId
+     * Dismiss one knock from the in-memory pending list (admin only). Mirrors
+     * DELETE .../line/pending/:senderId exactly. The id is an iLink sender id,
+     * so no format validation.
+     */
+    router.delete('/v1/agents/:agentId/wechat/pending/:senderId', auth, (req, res) => {
+        const apiKey = req.apiKey;
+        if (!(0, auth_1.isAdmin)(apiKey)) {
+            res.status(403).json({ error: 'Admin key required' });
+            return;
+        }
+        const { agentId, senderId } = req.params;
+        if (!agentConfigs.has(agentId)) {
+            res.status(404).json({ error: `Agent '${agentId}' not found` });
+            return;
+        }
+        (0, pending_senders_1.clearPendingSender)('wechat', agentId, senderId);
+        res.json({ ok: true });
+    });
     /**
      * GET /api/v1/agents/:agentId/whatsapp/pending?account_id=...
      * Recently denied WhatsApp senders/groups (Tier 1/3 discovery aid) for ONE