qq-codex-bridge 0.1.2 → 0.1.4

package/dist/apps/chatgpt-desktop-cli/src/cli.js

@@ -0,0 +1,191 @@
+import { ChatgptDesktopDriver } from "../../../packages/adapters/chatgpt-desktop/src/driver.js";
+function printJson(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function printError(msg) {
+    process.stderr.write(msg + "\n");
+}
+const BOOL_FLAGS = new Set(["json", "help"]);
+function parseArgs(argv) {
+    const [, , command = "help", ...rest] = argv;
+    const args = [];
+    const flags = {};
+    for (let i = 0; i < rest.length; i++) {
+        const tok = rest[i];
+        if (tok.startsWith("--")) {
+            const key = tok.slice(2);
+            if (BOOL_FLAGS.has(key)) {
+                flags[key] = true;
+            }
+            else {
+                const next = rest[i + 1];
+                if (next !== undefined && !next.startsWith("--")) {
+                    flags[key] = next;
+                    i++;
+                }
+                else {
+                    flags[key] = true;
+                }
+            }
+        }
+        else {
+            args.push(tok);
+        }
+    }
+    return { command, args, flags };
+}
+async function cmdHealth(driver, flags) {
+    const result = await driver.health();
+    if (flags["json"]) {
+        printJson(result);
+    }
+    else {
+        console.log(`App running:   ${result.appRunning}`);
+        console.log(`Accessibility: ${result.accessibility}`);
+        console.log(`Cache dir:     ${result.cacheDirFound}`);
+        console.log(`Frontmost:     ${result.frontmost}`);
+        console.log(`Overall OK:    ${result.ok}`);
+    }
+    process.exit(result.ok ? 0 : 1);
+}
+async function cmdAsk(driver, args, flags) {
+    const prompt = args[0];
+    if (!prompt) {
+        printError("Usage: chatgpt-desktop ask [--json] [--session <key>] <prompt>");
+        process.exit(1);
+    }
+    const input = {
+        mode: "text",
+        prompt,
+        sessionKey: typeof flags["session"] === "string" ? flags["session"] : undefined,
+        timeoutMs: typeof flags["timeout"] === "string" ? Number(flags["timeout"]) : undefined
+    };
+    const result = await driver.run(input);
+    if (flags["json"]) {
+        printJson(result);
+    }
+    else if (result.ok) {
+        console.log(result.text);
+    }
+    else {
+        printError(`Error [${result.errorCode}]: ${result.message}`);
+    }
+    process.exit(result.ok ? 0 : 1);
+}
+async function cmdImage(driver, args, flags) {
+    const prompt = args[0];
+    if (!prompt) {
+        printError("Usage: chatgpt-desktop image [--json] [--out-dir <dir>] [--session <key>] <prompt>");
+        process.exit(1);
+    }
+    const outDir = typeof flags["out-dir"] === "string" ? flags["out-dir"] : undefined;
+    const input = {
+        mode: "image",
+        prompt,
+        sessionKey: typeof flags["session"] === "string" ? flags["session"] : undefined,
+        timeoutMs: typeof flags["timeout"] === "string" ? Number(flags["timeout"]) : undefined
+    };
+    const result = await driver.run(input);
+    if (flags["json"]) {
+        printJson(result);
+    }
+    else if (result.ok) {
+        for (const m of result.media) {
+            console.log(m.localPath);
+        }
+        if (result.text)
+            console.log(result.text);
+    }
+    else {
+        printError(`Error [${result.errorCode}]: ${result.message}`);
+    }
+    void outDir; // outDir is passed via driver opts at construction time; noted for future use
+    process.exit(result.ok ? 0 : 1);
+}
+async function cmdImages(driver, args, flags) {
+    const prompt = args[0];
+    if (!prompt) {
+        printError("Usage: chatgpt-desktop images [--json] [--count <n>] [--out-dir <dir>] <prompt>");
+        process.exit(1);
+    }
+    const count = typeof flags["count"] === "string" ? Math.max(1, parseInt(flags["count"], 10)) : 1;
+    const results = [];
+    let anyFailed = false;
+    for (let i = 0; i < count; i++) {
+        const input = {
+            mode: "image",
+            prompt: `${prompt} (第 ${i + 1} 张，共 ${count} 张)`,
+            sessionKey: typeof flags["session"] === "string" ? flags["session"] : undefined,
+            timeoutMs: typeof flags["timeout"] === "string" ? Number(flags["timeout"]) : undefined
+        };
+        const result = await driver.run(input);
+        results.push(result);
+        if (!result.ok)
+            anyFailed = true;
+    }
+    if (flags["json"]) {
+        printJson(results);
+    }
+    else {
+        for (const r of results) {
+            if (r.ok) {
+                for (const m of r.media)
+                    console.log(m.localPath);
+            }
+            else {
+                printError(`Error [${r.errorCode}]: ${r.message}`);
+            }
+        }
+    }
+    process.exit(anyFailed ? 1 : 0);
+}
+function printHelp() {
+    console.log(`chatgpt-desktop <command> [options]
+
+Commands:
+  health                    Check App, accessibility and cache dir
+  ask <prompt>              Send a text message and print reply
+  image <prompt>            Generate an image and print local path
+  images --count N <prompt> Generate N images serially
+
+Options:
+  --json                    Output JSON
+  --session <key>           Session key for conversation continuity
+  --out-dir <dir>           Output directory for images
+  --timeout <ms>            Override reply timeout in milliseconds
+  --count <n>               Number of images (images command only)
+`);
+}
+async function main() {
+    const { command, args, flags } = parseArgs(process.argv);
+    const outDir = typeof flags["out-dir"] === "string" ? flags["out-dir"] : undefined;
+    const driver = new ChatgptDesktopDriver({ destDir: outDir });
+    switch (command) {
+        case "health":
+            await cmdHealth(driver, flags);
+            break;
+        case "ask":
+        case "chat":
+            await cmdAsk(driver, args, flags);
+            break;
+        case "image":
+            await cmdImage(driver, args, flags);
+            break;
+        case "images":
+            await cmdImages(driver, args, flags);
+            break;
+        case "help":
+        case "--help":
+        case "-h":
+            printHelp();
+            break;
+        default:
+            printError(`Unknown command: ${command}`);
+            printHelp();
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

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();
+}