qq-codex-bridge 0.1.3 → 0.1.4

package/dist/apps/weixin-gateway/src/cli.js

@@ -0,0 +1,446 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { ZodError } from "zod";
+import { loadWeixinGatewayConfigFromEnv } from "./config.js";
+import { WeixinGatewayMessageStore } from "./message-store.js";
+import { createWeixinGatewayServer } from "./server.js";
+import { forwardWeixinInboundToBridge, runWeixinLoginFlow as runWeixinLoginFlowImpl, WeixinClient } from "./weixin-client.js";
+import { WeixinGatewayStateStore } from "./state.js";
+export async function runCli(rawArgs, deps = {}) {
+    const args = rawArgs.filter((arg) => arg.length > 0 && arg !== "--");
+    const cwd = deps.cwd ?? process.cwd();
+    const env = deps.env ?? process.env;
+    const packageRoot = deps.packageRoot ?? findPackageRoot(path.dirname(fileURLToPath(import.meta.url)));
+    const fetchFn = deps.fetchFn ?? fetch;
+    const writeStdout = deps.writeStdout ?? ((line) => console.log(line));
+    const writeStderr = deps.writeStderr ?? ((line) => console.error(line));
+    const parsedArgs = parseCliArgs(args);
+    if (!parsedArgs) {
+        writeStderr(`[qq-codex-weixin-gateway] 未知命令：${args.join(" ")}`);
+        printHelp(writeStdout);
+        return 1;
+    }
+    if (parsedArgs.command === "init") {
+        return initEnvTemplate({ cwd, packageRoot, writeStdout, writeStderr });
+    }
+    if (parsedArgs.command === "help") {
+        printHelp(writeStdout);
+        return 0;
+    }
+    const envFilePath = path.join(cwd, ".env");
+    if (fs.existsSync(envFilePath)) {
+        const loadEnvFile = deps.loadEnvFile ?? process.loadEnvFile.bind(process);
+        loadEnvFile(envFilePath);
+    }
+    try {
+        const config = loadWeixinGatewayConfigFromEnv(env);
+        const stateStore = deps.createStateStore?.(config.stateFilePath)
+            ?? new WeixinGatewayStateStore(config.stateFilePath);
+        const runWeixinLoginFlow = deps.runWeixinLoginFlow ?? runWeixinLoginFlowImpl;
+        const selectedAccountId = parsedArgs.accountId ?? config.accountId;
+        if (parsedArgs.command === "login") {
+            const result = await runWeixinLoginFlow({
+                accountId: selectedAccountId,
+                force: parsedArgs.forceLogin,
+                onQrCode: (url) => {
+                    writeStdout(`[qq-codex-weixin-gateway] 二维码地址：${url}`);
+                    writeStdout("[qq-codex-weixin-gateway] 请在浏览器打开二维码地址并使用微信扫码确认。");
+                },
+                config,
+                stateStore: stateStore,
+                fetchFn
+            });
+            if (result.qrcodeUrl) {
+                writeStdout(`[qq-codex-weixin-gateway] 微信扫码登录成功，accountId=${result.accountId}`);
+            }
+            else {
+                writeStdout(`[qq-codex-weixin-gateway] 账号 ${result.accountId} 已存在可用登录态，baseUrl=${result.baseUrl}`);
+            }
+            return 0;
+        }
+        if (parsedArgs.command === "logout") {
+            stateStore.clearStoredAccount(selectedAccountId);
+            writeStdout(`[qq-codex-weixin-gateway] 已清理账号 ${selectedAccountId} 的登录态`);
+            return 0;
+        }
+        const service = await startWeixinGatewayService({
+            cwd,
+            env,
+            packageRoot,
+            fetchFn,
+            loadEnvFile: deps.loadEnvFile,
+            createMessageStore: deps.createMessageStore,
+            createStateStore: deps.createStateStore,
+            createServer: deps.createServer,
+            createWeixinClient: deps.createWeixinClient,
+            watchStateFile: deps.watchStateFile,
+            writeStdout,
+            writeStderr
+        });
+        process.once("SIGINT", () => {
+            void service.shutdown().finally(() => {
+                process.exit(0);
+            });
+        });
+        process.once("SIGTERM", () => {
+            void service.shutdown().finally(() => {
+                process.exit(0);
+            });
+        });
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            writeStderr(`[qq-codex-weixin-gateway] 配置无效：${error.issues.map((issue) => issue.message).join("; ")}`);
+            return 1;
+        }
+        writeStderr(`[qq-codex-weixin-gateway] fatal: ${error instanceof Error ? error.message : String(error)}`);
+        if (error instanceof Error && error.stack) {
+            writeStderr(`  stack: ${error.stack}`);
+        }
+        return 1;
+    }
+}
+export async function startWeixinGatewayService(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const packageRoot = options.packageRoot ?? findPackageRoot(path.dirname(fileURLToPath(import.meta.url)));
+    const fetchFn = options.fetchFn ?? fetch;
+    const writeStdout = options.writeStdout ?? ((line) => console.log(line));
+    const writeStderr = options.writeStderr ?? ((line) => console.error(line));
+    const envFilePath = path.join(cwd, ".env");
+    if (fs.existsSync(envFilePath)) {
+        const loadEnvFile = options.loadEnvFile ?? process.loadEnvFile.bind(process);
+        loadEnvFile(envFilePath);
+    }
+    void packageRoot;
+    const config = loadWeixinGatewayConfigFromEnv(env);
+    const createMessageStore = options.createMessageStore
+        ?? ((filePath, limit) => new WeixinGatewayMessageStore(filePath, limit));
+    const messageStores = Object.fromEntries(config.accounts.map((account) => [
+        account.accountId,
+        createMessageStore(account.messageStorePath, config.recentMessageLimit)
+    ]));
+    const messageStore = {
+        append: (message) => {
+            const accountId = resolveOutboundAccountId({
+                accountId: message.accountId,
+                accountKey: message.accountKey
+            }, config.accountId);
+            const store = messageStores[accountId] ?? messageStores[config.accountId] ?? Object.values(messageStores)[0];
+            store?.append(message);
+        },
+        listRecent: () => Object.values(messageStores)
+            .flatMap((store) => store.listRecent())
+            .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))
+            .slice(0, config.recentMessageLimit)
+    };
+    const stateStore = options.createStateStore?.(config.stateFilePath)
+        ?? new WeixinGatewayStateStore(config.stateFilePath);
+    const activeClients = new Map();
+    const activeClientKeys = new Map();
+    const closeActiveClient = async (accountId) => {
+        const activeClient = activeClients.get(accountId);
+        if (!activeClient) {
+            activeClientKeys.delete(accountId);
+            return;
+        }
+        activeClients.delete(accountId);
+        activeClientKeys.delete(accountId);
+        await activeClient.close();
+    };
+    const resolveRuntimeAccount = (account) => stateStore.resolveRuntimeAccount(account.accountId, {
+        token: account.token,
+        baseUrl: account.baseUrl
+    });
+    const createWeixinClient = options.createWeixinClient
+        ?? ((clientOptions) => new WeixinClient({
+            ...clientOptions,
+            stateStore: clientOptions.stateStore,
+            fetchFn: clientOptions.fetchFn
+        }));
+    const refreshWeixinClient = async (reason) => {
+        const expectedAccountIds = new Set(config.accounts.map((account) => account.accountId));
+        for (const account of config.accounts) {
+            const runtimeAccount = resolveRuntimeAccount(account);
+            const nextClientKey = runtimeAccount
+                ? `${runtimeAccount.accountId}|${runtimeAccount.baseUrl}|${runtimeAccount.token}`
+                : "";
+            if (!runtimeAccount) {
+                if (activeClients.has(account.accountId)) {
+                    writeStdout(`[qq-codex-weixin-gateway] 未找到微信登录态，已停用 long-poll client { accountId: ${account.accountId} }`);
+                    await closeActiveClient(account.accountId);
+                }
+                continue;
+            }
+            if (activeClients.has(account.accountId) && activeClientKeys.get(account.accountId) === nextClientKey) {
+                continue;
+            }
+            await closeActiveClient(account.accountId);
+            const nextClient = createWeixinClient({
+                accountId: runtimeAccount.accountId,
+                baseUrl: runtimeAccount.baseUrl,
+                token: runtimeAccount.token,
+                longPollTimeoutMs: config.longPollTimeoutMs,
+                apiTimeoutMs: config.apiTimeoutMs,
+                stateStore,
+                fetchFn,
+                onInboundMessage: async (message) => {
+                    await forwardWeixinInboundToBridge(fetchFn, {
+                        bridgeBaseUrl: config.bridgeBaseUrl,
+                        bridgeWebhookPath: account.bridgeWebhookPath,
+                        accountKey: `weixin:${account.accountId}`
+                    }, message);
+                }
+            });
+            activeClients.set(account.accountId, nextClient);
+            activeClientKeys.set(account.accountId, nextClientKey);
+            void nextClient.connect();
+            writeStdout(`[qq-codex-weixin-gateway] 微信 client 已连接 { reason: ${reason}, accountId: ${runtimeAccount.accountId}, baseUrl: ${runtimeAccount.baseUrl} }`);
+        }
+        for (const accountId of [...activeClients.keys()]) {
+            if (!expectedAccountIds.has(accountId)) {
+                await closeActiveClient(accountId);
+            }
+        }
+    };
+    const outboundSender = {
+        sendTextMessage: async ({ accountKey, accountId, peerId, chatType, text, replyToMessageId }) => {
+            const targetAccountId = resolveOutboundAccountId({ accountKey, accountId }, config.accountId);
+            const activeClient = activeClients.get(targetAccountId);
+            if (!activeClient) {
+                throw new Error(`weixin gateway has no active logged-in client for account ${targetAccountId}`);
+            }
+            const contextToken = stateStore.getContextToken(activeClient.accountId, peerId);
+            await activeClient.sendTextMessage(peerId, text, contextToken || null);
+            console.log("[weixin-gateway] delivered outbound message", {
+                accountId: targetAccountId,
+                peerId,
+                chatType,
+                hasContextToken: Boolean(contextToken),
+                replyToMessageId
+            });
+        },
+        sendMessage: async ({ accountKey, accountId, peerId, chatType, content, mediaArtifacts, replyToMessageId }) => {
+            const targetAccountId = resolveOutboundAccountId({ accountKey, accountId }, config.accountId);
+            const activeClient = activeClients.get(targetAccountId);
+            if (!activeClient) {
+                throw new Error(`weixin gateway has no active logged-in client for account ${targetAccountId}`);
+            }
+            const contextToken = stateStore.getContextToken(activeClient.accountId, peerId);
+            await activeClient.sendMessage({
+                peerId,
+                chatType,
+                ...(content ? { content } : {}),
+                ...(mediaArtifacts?.length ? { mediaArtifacts } : {}),
+                contextToken: contextToken || null
+            });
+            console.log("[weixin-gateway] delivered outbound message", {
+                accountId: targetAccountId,
+                peerId,
+                chatType,
+                hasContextToken: Boolean(contextToken),
+                replyToMessageId,
+                mediaCount: mediaArtifacts?.length ?? 0
+            });
+        }
+    };
+    const server = options.createServer?.({
+        config,
+        messageStore,
+        fetchFn,
+        outboundSender
+    })
+        ?? createWeixinGatewayServer({
+            config,
+            messageStore,
+            fetchFn,
+            outboundSender
+        });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(config.listenPort, config.listenHost, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    await refreshWeixinClient("startup");
+    const shouldWatchStateFile = options.watchStateFile !== false;
+    if (shouldWatchStateFile) {
+        fs.watchFile(config.stateFilePath, { interval: config.stateWatchIntervalMs }, async (current, previous) => {
+            if (current.mtimeMs === previous.mtimeMs) {
+                return;
+            }
+            try {
+                stateStore.reload();
+                await refreshWeixinClient("state-file-change");
+            }
+            catch (error) {
+                writeStderr(`[qq-codex-weixin-gateway] 刷新微信状态失败：${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    writeStdout(`[qq-codex-weixin-gateway] ready { listenHost: ${config.listenHost}, listenPort: ${config.listenPort}, accounts: ${config.accounts.map((account) => account.accountId).join(",")}, loggedIn: ${activeClients.size} }`);
+    return {
+        shutdown: async () => {
+            fs.unwatchFile(config.stateFilePath);
+            await Promise.all([...activeClients.keys()].map((accountId) => closeActiveClient(accountId)));
+            await new Promise((resolve) => server.close(() => resolve()));
+        },
+        status: {
+            channel: "weixin",
+            enabled: config.enabled,
+            listenHost: config.listenHost,
+            listenPort: config.listenPort,
+            loggedIn: activeClients.size > 0,
+            accountId: config.accountId,
+            accountIds: config.accounts.map((account) => account.accountId),
+            loggedInAccountIds: [...activeClients.keys()]
+        }
+    };
+}
+export async function runCliFromProcess() {
+    process.exitCode = await runCli(process.argv.slice(2));
+}
+function initEnvTemplate(options) {
+    const targetPath = path.join(options.cwd, ".env.weixin-gateway");
+    if (fs.existsSync(targetPath)) {
+        options.writeStderr(`[qq-codex-weixin-gateway] 配置文件已存在：${targetPath}`);
+        return 1;
+    }
+    const template = [
+        "WEIXIN_ENABLED=true",
+        "WEIXIN_ACCOUNT_ID=default",
+        "WEIXIN_BASE_URL=https://ilinkai.weixin.qq.com",
+        "# WEIXIN_TOKEN=",
+        "WEIXIN_LONG_POLL_TIMEOUT_MS=35000",
+        "WEIXIN_API_TIMEOUT_MS=15000",
+        "WEIXIN_GATEWAY_STATE_FILE_PATH=runtime/weixin-gateway-state.json",
+        "WEIXIN_LOGIN_BASE_URL=https://ilinkai.weixin.qq.com",
+        "WEIXIN_BOT_TYPE=3",
+        "WEIXIN_QR_FETCH_TIMEOUT_MS=10000",
+        "WEIXIN_QR_POLL_TIMEOUT_MS=35000",
+        "WEIXIN_QR_TOTAL_TIMEOUT_MS=480000",
+        "WEIXIN_GATEWAY_STATE_WATCH_INTERVAL_MS=1000",
+        "WEIXIN_GATEWAY_LISTEN_HOST=127.0.0.1",
+        "WEIXIN_GATEWAY_LISTEN_PORT=3200",
+        "WEIXIN_GATEWAY_BRIDGE_BASE_URL=http://127.0.0.1:3100",
+        "WEIXIN_GATEWAY_BRIDGE_WEBHOOK_PATH=/webhooks/weixin",
+        "# WEIXIN_GATEWAY_EXPECTED_TOKEN=your-token",
+        "WEIXIN_GATEWAY_MESSAGE_STORE_PATH=runtime/weixin-gateway-messages.ndjson",
+        "WEIXIN_GATEWAY_RECENT_MESSAGE_LIMIT=100",
+        ""
+    ].join("\n");
+    fs.writeFileSync(targetPath, template, "utf8");
+    options.writeStdout(`[qq-codex-weixin-gateway] 已生成真实微信网关配置：${targetPath}`);
+    options.writeStdout("[qq-codex-weixin-gateway] 你也可以直接把这些变量写进项目根目录的 .env。");
+    return 0;
+}
+function resolveOutboundAccountId(target, fallbackAccountId) {
+    const explicitAccountId = String(target.accountId ?? "").trim();
+    if (explicitAccountId) {
+        return explicitAccountId;
+    }
+    const accountKey = String(target.accountKey ?? "").trim();
+    if (accountKey.startsWith("weixin:")) {
+        const accountId = accountKey.slice("weixin:".length).trim();
+        if (accountId) {
+            return accountId;
+        }
+    }
+    return fallbackAccountId;
+}
+function printHelp(writeStdout) {
+    writeStdout("qq-codex-weixin-gateway");
+    writeStdout("");
+    writeStdout("用法：");
+    writeStdout("  qq-codex-weixin-gateway                         启动真实微信网关（long-poll + 本地转发）");
+    writeStdout("  qq-codex-weixin-gateway init                    生成 .env.weixin-gateway 模板");
+    writeStdout("  qq-codex-weixin-gateway --weixin-login          发起微信扫码登录");
+    writeStdout("  qq-codex-weixin-gateway --weixin-login-force    强制重新扫码登录");
+    writeStdout("  qq-codex-weixin-gateway --weixin-logout         清理微信登录态");
+    writeStdout("  qq-codex-weixin-gateway help                    查看帮助");
+}
+function findPackageRoot(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        if (fs.existsSync(path.join(currentDir, "package.json"))) {
+            return currentDir;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            throw new Error(`Unable to locate package root from ${startDir}`);
+        }
+        currentDir = parentDir;
+    }
+}
+function parseCliArgs(args) {
+    if (args.length === 0) {
+        return {
+            command: "serve",
+            forceLogin: false
+        };
+    }
+    if (args.length === 1 && (args[0] === "help" || args[0] === "-h" || args[0] === "--help")) {
+        return {
+            command: "help",
+            forceLogin: false
+        };
+    }
+    if (args.length === 1 && args[0] === "init") {
+        return {
+            command: "init",
+            forceLogin: false
+        };
+    }
+    let command = null;
+    let accountId;
+    let forceLogin = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--weixin-login") {
+            command = "login";
+            continue;
+        }
+        if (arg === "--weixin-login-force") {
+            command = "login";
+            forceLogin = true;
+            continue;
+        }
+        if (arg === "--weixin-logout") {
+            command = "logout";
+            continue;
+        }
+        if (arg === "--weixin-account") {
+            accountId = args[index + 1];
+            index += 1;
+            continue;
+        }
+        return null;
+    }
+    if (!command) {
+        return null;
+    }
+    return {
+        command,
+        accountId,
+        forceLogin
+    };
+}
+const isEntrypoint = (() => {
+    const entrypoint = process.argv[1];
+    if (!entrypoint) {
+        return false;
+    }
+    try {
+        return fileURLToPath(import.meta.url) === path.resolve(entrypoint);
+    }
+    catch {
+        return false;
+    }
+})();
+if (isEntrypoint) {
+    void runCliFromProcess();
+}

package/dist/apps/weixin-gateway/src/config.js

@@ -0,0 +1,135 @@
+import { z } from "zod";
+const weixinGatewayAccountConfigSchema = z.object({
+    accountId: z.string().min(1),
+    bridgeWebhookPath: z.string().startsWith("/"),
+    baseUrl: z.string().url(),
+    token: z.string().min(1).nullable(),
+    messageStorePath: z.string().min(1)
+});
+export const weixinGatewayConfigSchema = z.object({
+    listenHost: z.string().min(1),
+    listenPort: z.number().int().positive(),
+    bridgeBaseUrl: z.string().url(),
+    bridgeWebhookPath: z.string().startsWith("/"),
+    expectedBearerToken: z.string().min(1).nullable(),
+    messageStorePath: z.string().min(1),
+    recentMessageLimit: z.number().int().positive(),
+    enabled: z.boolean(),
+    accountId: z.string().min(1),
+    baseUrl: z.string().url(),
+    token: z.string().min(1).nullable(),
+    longPollTimeoutMs: z.number().int().positive(),
+    apiTimeoutMs: z.number().int().positive(),
+    stateFilePath: z.string().min(1),
+    loginBaseUrl: z.string().url(),
+    loginBotType: z.string().min(1),
+    qrFetchTimeoutMs: z.number().int().positive(),
+    qrPollTimeoutMs: z.number().int().positive(),
+    qrTotalTimeoutMs: z.number().int().positive(),
+    stateWatchIntervalMs: z.number().int().positive(),
+    accounts: z.array(weixinGatewayAccountConfigSchema).min(1)
+});
+export function loadWeixinGatewayConfigFromEnv(env) {
+    const fallbackAccount = {
+        accountId: env.WEIXIN_ACCOUNT_ID ?? "default",
+        bridgeWebhookPath: env.WEIXIN_GATEWAY_BRIDGE_WEBHOOK_PATH
+            ?? env.WEIXIN_WEBHOOK_PATH
+            ?? "/webhooks/weixin",
+        baseUrl: env.WEIXIN_BASE_URL ?? "https://ilinkai.weixin.qq.com",
+        token: env.WEIXIN_TOKEN ?? null,
+        messageStorePath: env.WEIXIN_GATEWAY_MESSAGE_STORE_PATH
+            ?? "runtime/weixin-gateway-messages.ndjson"
+    };
+    return weixinGatewayConfigSchema.parse({
+        listenHost: env.WEIXIN_GATEWAY_LISTEN_HOST ?? "127.0.0.1",
+        listenPort: Number(env.WEIXIN_GATEWAY_LISTEN_PORT ?? "3200"),
+        bridgeBaseUrl: env.WEIXIN_GATEWAY_BRIDGE_BASE_URL
+            ?? `http://${env.QQ_CODEX_LISTEN_HOST ?? "127.0.0.1"}:${env.QQ_CODEX_LISTEN_PORT ?? "3100"}`,
+        bridgeWebhookPath: env.WEIXIN_GATEWAY_BRIDGE_WEBHOOK_PATH
+            ?? env.WEIXIN_WEBHOOK_PATH
+            ?? "/webhooks/weixin",
+        expectedBearerToken: env.WEIXIN_GATEWAY_EXPECTED_TOKEN ?? env.WEIXIN_EGRESS_TOKEN ?? null,
+        messageStorePath: env.WEIXIN_GATEWAY_MESSAGE_STORE_PATH
+            ?? "runtime/weixin-gateway-messages.ndjson",
+        recentMessageLimit: Number(env.WEIXIN_GATEWAY_RECENT_MESSAGE_LIMIT ?? "100"),
+        enabled: env.WEIXIN_ENABLED !== "false",
+        accountId: env.WEIXIN_ACCOUNT_ID ?? "default",
+        baseUrl: env.WEIXIN_BASE_URL ?? "https://ilinkai.weixin.qq.com",
+        token: env.WEIXIN_TOKEN ?? null,
+        longPollTimeoutMs: Number(env.WEIXIN_LONG_POLL_TIMEOUT_MS ?? "35000"),
+        apiTimeoutMs: Number(env.WEIXIN_API_TIMEOUT_MS ?? "15000"),
+        stateFilePath: env.WEIXIN_GATEWAY_STATE_FILE_PATH ?? "runtime/weixin-gateway-state.json",
+        loginBaseUrl: env.WEIXIN_LOGIN_BASE_URL ?? "https://ilinkai.weixin.qq.com",
+        loginBotType: env.WEIXIN_BOT_TYPE ?? "3",
+        qrFetchTimeoutMs: Number(env.WEIXIN_QR_FETCH_TIMEOUT_MS ?? "10000"),
+        qrPollTimeoutMs: Number(env.WEIXIN_QR_POLL_TIMEOUT_MS ?? "35000"),
+        qrTotalTimeoutMs: Number(env.WEIXIN_QR_TOTAL_TIMEOUT_MS ?? String(8 * 60 * 1000)),
+        stateWatchIntervalMs: Number(env.WEIXIN_GATEWAY_STATE_WATCH_INTERVAL_MS ?? "1000"),
+        accounts: resolveGatewayAccounts(env, fallbackAccount)
+    });
+}
+function resolveGatewayAccounts(env, fallback) {
+    const jsonAccounts = parseJsonArray(env.WEIXIN_GATEWAY_ACCOUNTS_JSON ?? env.WEIXIN_ACCOUNTS_JSON);
+    if (jsonAccounts) {
+        return jsonAccounts.map((item, index) => {
+            const record = asRecord(item);
+            const accountId = stringValue(record.accountId ?? record.id, `account${index + 1}`);
+            return {
+                accountId,
+                bridgeWebhookPath: stringValue(record.bridgeWebhookPath ?? record.webhookPath, `/webhooks/weixin/${accountId}`),
+                baseUrl: stringValue(record.baseUrl, fallback.baseUrl),
+                token: nullableString(record.token ?? record.weixinToken),
+                messageStorePath: stringValue(record.messageStorePath, `runtime/weixin-gateway-messages-${safePathSegment(accountId)}.ndjson`)
+            };
+        });
+    }
+    const accountIds = splitList(env.WEIXIN_GATEWAY_ACCOUNT_IDS ?? env.WEIXIN_ACCOUNT_IDS);
+    if (accountIds.length > 0) {
+        return accountIds.map((accountId, index) => {
+            const suffix = envNameSuffix(accountId);
+            return {
+                accountId,
+                bridgeWebhookPath: env[`WEIXIN_GATEWAY_${suffix}_BRIDGE_WEBHOOK_PATH`]
+                    ?? env[`WEIXIN_${suffix}_WEBHOOK_PATH`]
+                    ?? `/webhooks/weixin/${accountId}`,
+                baseUrl: env[`WEIXIN_${suffix}_BASE_URL`] ?? fallback.baseUrl,
+                token: env[`WEIXIN_${suffix}_TOKEN`] ?? (index === 0 ? fallback.token : null),
+                messageStorePath: env[`WEIXIN_GATEWAY_${suffix}_MESSAGE_STORE_PATH`]
+                    ?? `runtime/weixin-gateway-messages-${safePathSegment(accountId)}.ndjson`
+            };
+        });
+    }
+    return [fallback];
+}
+function parseJsonArray(value) {
+    if (!value?.trim()) {
+        return null;
+    }
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : null;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringValue(value, fallback) {
+    const text = String(value ?? "").trim();
+    return text || fallback;
+}
+function nullableString(value) {
+    const text = String(value ?? "").trim();
+    return text || null;
+}
+function splitList(value) {
+    return (value ?? "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function envNameSuffix(value) {
+    return value.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+}
+function safePathSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_") || "default";
+}

package/dist/apps/weixin-gateway/src/dev.js

@@ -0,0 +1,2 @@
+import { runCliFromProcess } from "./cli.js";
+void runCliFromProcess();

package/dist/apps/weixin-gateway/src/message-store.js

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+import path from "node:path";
+export class WeixinGatewayMessageStore {
+    filePath;
+    limit;
+    messages = [];
+    constructor(filePath, limit) {
+        this.filePath = filePath;
+        this.limit = limit;
+        this.loadFromDisk();
+    }
+    append(message) {
+        this.messages.push(message);
+        this.trimToLimit();
+        this.persistLine(message);
+    }
+    listRecent() {
+        return [...this.messages].reverse();
+    }
+    loadFromDisk() {
+        if (!fs.existsSync(this.filePath)) {
+            return;
+        }
+        const content = fs.readFileSync(this.filePath, "utf8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                this.messages.push(parsed);
+            }
+            catch {
+                // ignore malformed historical lines
+            }
+        }
+        this.trimToLimit();
+    }
+    persistLine(message) {
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        fs.appendFileSync(this.filePath, `${JSON.stringify(message)}\n`, "utf8");
+    }
+    trimToLimit() {
+        if (this.messages.length <= this.limit) {
+            return;
+        }
+        this.messages.splice(0, this.messages.length - this.limit);
+    }
+}