opencode-copilot-account-switcher 0.13.6 → 0.14.0

package/dist/wechat/compat/openclaw-public-helpers.d.ts

@@ -0,0 +1,101 @@
+export declare const OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES: {
+    readonly stateDir: "@tencent-weixin/openclaw-weixin/src/storage/state-dir.ts";
+    readonly syncBuf: "@tencent-weixin/openclaw-weixin/src/storage/sync-buf.ts";
+    readonly getUpdates: "@tencent-weixin/openclaw-weixin/src/api/api.ts";
+    readonly sendMessageWeixin: "@tencent-weixin/openclaw-weixin/src/messaging/send.ts";
+};
+type WeixinQrGateway = {
+    loginWithQrStart: (input?: unknown) => unknown;
+    loginWithQrWait: (input?: unknown) => unknown;
+};
+export type OpenClawWeixinPublicEntry = {
+    packageJsonPath: string;
+    packageRoot: string;
+    extensions: string[];
+    entryRelativePath: string;
+    entryAbsolutePath: string;
+};
+declare function resolveOpenClawWeixinPublicEntry(): Promise<OpenClawWeixinPublicEntry>;
+declare function loadLatestWeixinAccountState(): Promise<{
+    accountId: string;
+    token: string;
+    baseUrl: string;
+    getUpdatesBuf?: string;
+} | null>;
+type PublicWeixinMessageItem = {
+    type?: number;
+    text_item?: {
+        text?: string;
+    };
+};
+export type PublicWeixinMessage = {
+    message_id?: number;
+    from_user_id?: string;
+    context_token?: string;
+    create_time_ms?: number;
+    item_list?: PublicWeixinMessageItem[];
+};
+export type PublicWeixinSendMessage = (params: {
+    to: string;
+    text: string;
+    opts: {
+        baseUrl: string;
+        token: string;
+        contextToken?: string;
+    };
+}) => Promise<{
+    messageId: string;
+}>;
+export type PublicWeixinPersistGetUpdatesBuf = (params: {
+    accountId: string;
+    getUpdatesBuf: string;
+}) => Promise<void>;
+export type OpenClawWeixinPublicHelpers = {
+    entry: OpenClawWeixinPublicEntry;
+    pluginId: string;
+    qrGateway: WeixinQrGateway;
+    latestAccountState: {
+        accountId: string;
+        token: string;
+        baseUrl: string;
+        getUpdatesBuf?: string;
+    } | null;
+    getUpdates: (params: {
+        baseUrl: string;
+        token?: string;
+        get_updates_buf?: string;
+        timeoutMs?: number;
+    }) => Promise<{
+        msgs?: PublicWeixinMessage[];
+        get_updates_buf?: string;
+    }>;
+    sendMessageWeixin: PublicWeixinSendMessage;
+    persistGetUpdatesBuf?: PublicWeixinPersistGetUpdatesBuf;
+};
+type OpenClawWeixinPublicHelpersLoaders = {
+    resolveOpenClawWeixinPublicEntry?: typeof resolveOpenClawWeixinPublicEntry;
+    loadPublicWeixinQrGateway?: () => Promise<{
+        gateway: WeixinQrGateway;
+        pluginId?: string;
+    }>;
+    loadLatestWeixinAccountState?: typeof loadLatestWeixinAccountState;
+    loadPublicWeixinHelpers?: typeof loadPublicWeixinHelpers;
+    loadPublicWeixinSendHelper?: typeof loadPublicWeixinSendHelper;
+};
+declare function loadPublicWeixinHelpers(): Promise<{
+    getUpdates: (params: {
+        baseUrl: string;
+        token?: string;
+        get_updates_buf?: string;
+        timeoutMs?: number;
+    }) => Promise<{
+        msgs?: PublicWeixinMessage[];
+        get_updates_buf?: string;
+    }>;
+}>;
+declare function loadPublicWeixinSendHelper(): Promise<{
+    sendMessageWeixin: PublicWeixinSendMessage;
+}>;
+export declare function loadOpenClawWeixinPublicHelpers(loaders?: OpenClawWeixinPublicHelpersLoaders): Promise<OpenClawWeixinPublicHelpers>;
+export type OpenClawWeixinPublicHelpersLoaderOptions = OpenClawWeixinPublicHelpersLoaders;
+export {};

package/dist/wechat/compat/openclaw-public-helpers.js

@@ -0,0 +1,207 @@
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { createJiti } from "jiti";
+export const OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES = {
+    stateDir: "@tencent-weixin/openclaw-weixin/src/storage/state-dir.ts",
+    syncBuf: "@tencent-weixin/openclaw-weixin/src/storage/sync-buf.ts",
+    getUpdates: "@tencent-weixin/openclaw-weixin/src/api/api.ts",
+    sendMessageWeixin: "@tencent-weixin/openclaw-weixin/src/messaging/send.ts",
+};
+let publicJitiLoader = null;
+function requireField(condition, message) {
+    if (!condition) {
+        throw new Error(`[wechat-compat] ${message}`);
+    }
+}
+function getPublicJiti() {
+    if (publicJitiLoader) {
+        return publicJitiLoader;
+    }
+    publicJitiLoader = createJiti(import.meta.url, {
+        interopDefault: true,
+        extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
+    });
+    return publicJitiLoader;
+}
+function hasQrLoginMethods(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.loginWithQrStart === "function" && typeof candidate.loginWithQrWait === "function";
+}
+async function resolveOpenClawWeixinPublicEntry() {
+    const require = createRequire(import.meta.url);
+    const packageName = "@tencent-weixin/openclaw-weixin";
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageJsonRaw = await readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonRaw);
+    const extensions = Array.isArray(packageJson.openclaw?.extensions)
+        ? packageJson.openclaw?.extensions.filter((it) => typeof it === "string")
+        : [];
+    requireField(extensions.length > 0, `${packageName} openclaw.extensions[0] is required`);
+    const entryRelativePath = extensions[0];
+    requireField(Boolean(entryRelativePath?.startsWith("./")), `${packageName} openclaw.extensions[0] must start with ./`);
+    const packageRoot = path.dirname(packageJsonPath);
+    const entryAbsolutePath = path.resolve(packageRoot, entryRelativePath);
+    return {
+        packageJsonPath,
+        packageRoot,
+        extensions,
+        entryRelativePath,
+        entryAbsolutePath,
+    };
+}
+async function loadOpenClawWeixinDefaultExport() {
+    const entry = await resolveOpenClawWeixinPublicEntry();
+    const moduleNamespace = getPublicJiti()(entry.entryAbsolutePath);
+    const plugin = moduleNamespace.default;
+    if (!plugin || typeof plugin !== "object" || typeof plugin.register !== "function") {
+        throw new Error("[wechat-compat] @tencent-weixin/openclaw-weixin public entry default export is missing register(api)");
+    }
+    return plugin;
+}
+async function loadPublicWeixinQrGateway() {
+    const registeredPayloads = [];
+    const compatHostApi = {
+        runtime: {
+            channelRuntime: {
+                mode: "guided-smoke",
+            },
+            gateway: {
+                startAccount: {
+                    source: "guided-smoke",
+                },
+            },
+        },
+        registerChannel(payload) {
+            registeredPayloads.push(payload);
+        },
+        registerCli() { },
+    };
+    const plugin = await loadOpenClawWeixinDefaultExport();
+    plugin.register(compatHostApi);
+    for (const payload of registeredPayloads) {
+        const payloadPlugin = payload?.plugin;
+        const gateway = payloadPlugin && typeof payloadPlugin === "object" ? payloadPlugin.gateway : null;
+        if (hasQrLoginMethods(gateway)) {
+            return { gateway, pluginId: plugin.id ?? "unknown" };
+        }
+        if (hasQrLoginMethods(payloadPlugin)) {
+            return { gateway: payloadPlugin, pluginId: plugin.id ?? "unknown" };
+        }
+    }
+    throw new Error("registerChannel did not expose weixin gateway loginWithQrStart/loginWithQrWait");
+}
+async function loadLatestWeixinAccountState() {
+    const require = createRequire(import.meta.url);
+    const stateDirModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.stateDir);
+    const stateDirModule = getPublicJiti()(stateDirModulePath);
+    const stateDir = stateDirModule.resolveStateDir?.();
+    if (!stateDir) {
+        return null;
+    }
+    const accountsIndexPath = path.join(stateDir, "openclaw-weixin", "accounts.json");
+    let accountIds = [];
+    try {
+        const raw = await readFile(accountsIndexPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            accountIds = parsed.filter((item) => typeof item === "string" && item.trim().length > 0);
+        }
+    }
+    catch {
+        return null;
+    }
+    const accountId = accountIds.at(-1);
+    if (!accountId) {
+        return null;
+    }
+    try {
+        const accountFilePath = path.join(stateDir, "openclaw-weixin", "accounts", `${accountId}.json`);
+        const accountRaw = await readFile(accountFilePath, "utf8");
+        const account = JSON.parse(accountRaw);
+        const syncBufModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.syncBuf);
+        const syncBufModule = getPublicJiti()(syncBufModulePath);
+        if (typeof account.token !== "string" || account.token.trim().length === 0) {
+            return null;
+        }
+        const syncBufFilePath = syncBufModule.getSyncBufFilePath?.(accountId);
+        const persistedGetUpdatesBuf = syncBufFilePath ? syncBufModule.loadGetUpdatesBuf?.(syncBufFilePath) : undefined;
+        return {
+            accountId,
+            token: account.token,
+            baseUrl: typeof account.baseUrl === "string" && account.baseUrl.trim().length > 0 ? account.baseUrl : "https://ilinkai.weixin.qq.com",
+            getUpdatesBuf: typeof persistedGetUpdatesBuf === "string" ? persistedGetUpdatesBuf : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function missingHelperError(helperName) {
+    return new Error(`[wechat-compat] required helper missing: ${helperName}`);
+}
+async function loadPublicWeixinHelpers() {
+    const require = createRequire(import.meta.url);
+    const getUpdatesModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.getUpdates);
+    const getUpdatesModule = getPublicJiti()(getUpdatesModulePath);
+    if (typeof getUpdatesModule.getUpdates !== "function") {
+        throw new Error("public getUpdates helper unavailable");
+    }
+    return {
+        getUpdates: getUpdatesModule.getUpdates,
+    };
+}
+async function loadPublicWeixinSendHelper() {
+    const require = createRequire(import.meta.url);
+    const sendModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.sendMessageWeixin);
+    const sendModule = getPublicJiti()(sendModulePath);
+    if (typeof sendModule.sendMessageWeixin !== "function") {
+        throw new Error("public sendMessageWeixin helper unavailable");
+    }
+    return {
+        sendMessageWeixin: sendModule.sendMessageWeixin,
+    };
+}
+async function loadPublicWeixinSyncBufHelpers() {
+    const require = createRequire(import.meta.url);
+    const syncBufModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.syncBuf);
+    const syncBufModule = getPublicJiti()(syncBufModulePath);
+    if (typeof syncBufModule.getSyncBufFilePath !== "function" || typeof syncBufModule.saveGetUpdatesBuf !== "function") {
+        return {};
+    }
+    return {
+        persistGetUpdatesBuf: async ({ accountId, getUpdatesBuf }) => {
+            const filePath = syncBufModule.getSyncBufFilePath(accountId);
+            syncBufModule.saveGetUpdatesBuf(filePath, getUpdatesBuf);
+        },
+    };
+}
+export async function loadOpenClawWeixinPublicHelpers(loaders = {}) {
+    const entry = await (loaders.resolveOpenClawWeixinPublicEntry ?? resolveOpenClawWeixinPublicEntry)();
+    const qrGatewayResult = await (loaders.loadPublicWeixinQrGateway ?? loadPublicWeixinQrGateway)();
+    const latestAccountState = await (loaders.loadLatestWeixinAccountState ?? loadLatestWeixinAccountState)();
+    const publicHelpers = await (loaders.loadPublicWeixinHelpers ?? loadPublicWeixinHelpers)();
+    const sendHelper = await (loaders.loadPublicWeixinSendHelper ?? loadPublicWeixinSendHelper)();
+    const syncBufHelpers = await loadPublicWeixinSyncBufHelpers();
+    if (typeof qrGatewayResult?.gateway?.loginWithQrStart !== "function" || typeof qrGatewayResult?.gateway?.loginWithQrWait !== "function") {
+        throw missingHelperError("qrGateway");
+    }
+    if (typeof publicHelpers?.getUpdates !== "function") {
+        throw missingHelperError("getUpdates");
+    }
+    if (typeof sendHelper?.sendMessageWeixin !== "function") {
+        throw missingHelperError("sendMessageWeixin");
+    }
+    return {
+        entry,
+        pluginId: typeof qrGatewayResult.pluginId === "string" && qrGatewayResult.pluginId.length > 0 ? qrGatewayResult.pluginId : "unknown",
+        qrGateway: qrGatewayResult.gateway,
+        latestAccountState,
+        getUpdates: publicHelpers.getUpdates,
+        sendMessageWeixin: sendHelper.sendMessageWeixin,
+        persistGetUpdatesBuf: syncBufHelpers.persistGetUpdatesBuf,
+    };
+}

package/dist/wechat/compat/openclaw-smoke.d.ts

@@ -0,0 +1,48 @@
+import { type SlashOnlyCommand } from "./slash-guard.js";
+import { type OpenClawWeixinPublicHelpers, type OpenClawWeixinPublicHelpersLoaderOptions } from "./openclaw-public-helpers.js";
+type SmokeMode = "self-test" | "real-account";
+type OpenClawSmokeHarnessOptions = {
+    mode: SmokeMode;
+};
+type PublicHelpersLoader = (options?: OpenClawWeixinPublicHelpersLoaderOptions) => Promise<OpenClawWeixinPublicHelpers>;
+type RunOpenClawSmokeOptions = {
+    loadOpenClawWeixinPublicHelpers?: PublicHelpersLoader;
+    publicHelpersOptions?: OpenClawWeixinPublicHelpersLoaderOptions;
+    inputs?: string[];
+    dryRun?: boolean;
+    argv?: string[];
+};
+type SmokeGuardRejectResult = {
+    route: "guard-reject";
+    message: string;
+};
+type SmokeHostSelfTestResult = {
+    route: "public-self-test";
+    status: "loaded";
+    pluginId: string;
+};
+type SmokeStubResult = {
+    route: "stub";
+    command: SlashOnlyCommand;
+    argument: string;
+    stubReason: "stage-a-command-stub";
+    mode: SmokeMode;
+};
+type SmokeRealAccountDryRunResult = {
+    route: "real-account-dry-run";
+    binding: "skipped";
+    requiredEnvVars: readonly string[];
+    missingEnvVars: readonly string[];
+    manualSteps: readonly string[];
+    artifactPaths: readonly string[];
+};
+export type OpenClawSmokeHandleResult = SmokeGuardRejectResult | SmokeHostSelfTestResult | SmokeStubResult | SmokeRealAccountDryRunResult;
+export type OpenClawSmokeHarness = {
+    handleIncomingText(input: string): Promise<OpenClawSmokeHandleResult>;
+};
+export declare function resolveRealAccountDryRunFlag(options?: Pick<RunOpenClawSmokeOptions, "dryRun" | "argv">): boolean;
+export declare function createRealAccountDryRunPreparation(): SmokeRealAccountDryRunResult;
+export declare function sanitizeOpenClawEvidenceSample(input: string): string;
+export declare function createOpenClawSmokeHarness(options: OpenClawSmokeHarnessOptions): OpenClawSmokeHarness;
+export declare function runOpenClawSmoke(mode: SmokeMode, options?: RunOpenClawSmokeOptions): Promise<OpenClawSmokeHandleResult[]>;
+export {};

package/dist/wechat/compat/openclaw-smoke.js

@@ -0,0 +1,100 @@
+import { guardSlashOnlyInput } from "./slash-guard.js";
+import { loadOpenClawWeixinPublicHelpers, } from "./openclaw-public-helpers.js";
+const REAL_ACCOUNT_REQUIRED_ENV_VARS = [
+    "WECHAT_REAL_ACCOUNT_ID",
+    "WECHAT_DEVICE_ID",
+    "WECHAT_CONTEXT_TOKEN",
+    "WECHAT_BOT_TOKEN",
+];
+const REAL_ACCOUNT_MANUAL_STEPS = [
+    "执行 npm run wechat:smoke:real-account -- --dry-run，确认仅输出准备信息",
+    "确认所有必填环境变量已配置，再执行 npm run wechat:smoke:guided 完成真实账号手测",
+    "按 evidence/README.md 记录 blocked 或 known-unknown，并产出脱敏样本",
+];
+const REAL_ACCOUNT_ARTIFACT_PATHS = [
+    "docs/superpowers/wechat-stage-a/evidence/README.md",
+    "docs/superpowers/wechat-stage-a/api-samples-sanitized.md",
+    "docs/superpowers/wechat-stage-a/go-no-go.md",
+];
+export function resolveRealAccountDryRunFlag(options = {}) {
+    if (options.dryRun === true) {
+        return true;
+    }
+    const argv = options.argv ?? process.argv.slice(2);
+    return argv.includes("--dry-run");
+}
+export function createRealAccountDryRunPreparation() {
+    const missingEnvVars = REAL_ACCOUNT_REQUIRED_ENV_VARS.filter((name) => !process.env[name]?.trim());
+    return {
+        route: "real-account-dry-run",
+        binding: "skipped",
+        requiredEnvVars: [...REAL_ACCOUNT_REQUIRED_ENV_VARS],
+        missingEnvVars,
+        manualSteps: [...REAL_ACCOUNT_MANUAL_STEPS],
+        artifactPaths: [...REAL_ACCOUNT_ARTIFACT_PATHS],
+    };
+}
+export function sanitizeOpenClawEvidenceSample(input) {
+    return input
+        .replace(/(contextToken\s*[=:]\s*)([^\s\n]+)/g, "$1[REDACTED_CONTEXT_TOKEN]")
+        .replace(/("contextToken"\s*:\s*")([^"]+)(")/g, "$1[REDACTED_CONTEXT_TOKEN]$3")
+        .replace(/(context_token\s*[=:]\s*)([^\s\n]+)/gi, "$1[REDACTED_CONTEXT_TOKEN]")
+        .replace(/("context_token"\s*:\s*")([^"]+)(")/gi, "$1[REDACTED_CONTEXT_TOKEN]$3")
+        .replace(/(bot_token\s*[=:]\s*)([^\s\n]+)/gi, "$1[REDACTED_BOT_TOKEN]")
+        .replace(/("bot_token"\s*:\s*")([^"]+)(")/gi, "$1[REDACTED_BOT_TOKEN]$3")
+        .replace(/(authorization\s*:\s*bearer\s+)([^\s\n]+)/gi, "$1[REDACTED_AUTHORIZATION]")
+        .replace(/("authorization"\s*:\s*")Bearer\s+([^"]+)(")/gi, "$1Bearer [REDACTED_AUTHORIZATION]$3")
+        .replace(/(userId\s*[=:]\s*)([^\s\n]+)/gi, "$1[REDACTED_USER_ID]")
+        .replace(/("userId"\s*:\s*")([^"]+)(")/gi, "$1[REDACTED_USER_ID]$3")
+        .replace(/(botId\s*[=:]\s*)([^\s\n]+)/gi, "$1[REDACTED_BOT_ID]")
+        .replace(/("botId"\s*:\s*")([^"]+)(")/gi, "$1[REDACTED_BOT_ID]$3")
+        .replace(/(qrCode\s*[=:]\s*)([^\s\n]+)/gi, "$1[REDACTED_QR_CODE]")
+        .replace(/("qrCode"\s*:\s*")([^"]+)(")/gi, "$1[REDACTED_QR_CODE]$3")
+        .replace(/(deviceId\s*[=:]\s*)([^\s\n]+)/gi, "$1[REDACTED_DEVICE_ID]")
+        .replace(/("deviceId"\s*:\s*")([^"]+)(")/gi, "$1[REDACTED_DEVICE_ID]$3")
+        .replace(/(messageId\s*[=:]\s*)([^\s\n]+)/gi, "$1[REDACTED_MESSAGE_ID]")
+        .replace(/("messageId"\s*:\s*")([^"]+)(")/gi, "$1[REDACTED_MESSAGE_ID]$3")
+        .replace(/(requestId\s*[=:]\s*)([^\s\n]+)/gi, "$1[REDACTED_REQUEST_ID]")
+        .replace(/("requestId"\s*:\s*")([^"]+)(")/gi, "$1[REDACTED_REQUEST_ID]$3");
+}
+export function createOpenClawSmokeHarness(options) {
+    return {
+        async handleIncomingText(input) {
+            const guarded = guardSlashOnlyInput(input);
+            if (!guarded.accepted) {
+                return {
+                    route: "guard-reject",
+                    message: guarded.message,
+                };
+            }
+            return {
+                route: "stub",
+                command: guarded.command,
+                argument: guarded.argument,
+                stubReason: "stage-a-command-stub",
+                mode: options.mode,
+            };
+        },
+    };
+}
+export async function runOpenClawSmoke(mode, options = {}) {
+    const results = [];
+    if (mode === "self-test") {
+        const helpers = await (options.loadOpenClawWeixinPublicHelpers ?? loadOpenClawWeixinPublicHelpers)(options.publicHelpersOptions);
+        results.push({
+            route: "public-self-test",
+            status: "loaded",
+            pluginId: helpers.pluginId,
+        });
+    }
+    if (mode === "real-account") {
+        results.push(createRealAccountDryRunPreparation());
+        return results;
+    }
+    const harness = createOpenClawSmokeHarness({ mode });
+    const inputs = options.inputs ?? ["hello", "/status", "/reply smoke", "/allow once"];
+    for (const input of inputs) {
+        results.push(await harness.handleIncomingText(input));
+    }
+    return results;
+}

package/dist/wechat/compat/slash-guard.d.ts

@@ -0,0 +1,11 @@
+export declare const STAGE_A_SLASH_ONLY_MESSAGE = "\u5F53\u524D\u9636\u6BB5\u4EC5\u652F\u6301\u547D\u4EE4\u578B\u4EA4\u4E92\uFF0C\u8BF7\u53D1\u9001 /status\u3001/reply \u6216 /allow\u3002";
+export type SlashOnlyCommand = "status" | "reply" | "allow";
+export type SlashGuardResult = {
+    accepted: true;
+    command: SlashOnlyCommand;
+    argument: string;
+} | {
+    accepted: false;
+    message: string;
+};
+export declare function guardSlashOnlyInput(input: string): SlashGuardResult;

package/dist/wechat/compat/slash-guard.js

@@ -0,0 +1,24 @@
+export const STAGE_A_SLASH_ONLY_MESSAGE = "当前阶段仅支持命令型交互，请发送 /status、/reply 或 /allow。";
+const ALLOWED_COMMANDS = new Set(["status", "reply", "allow"]);
+export function guardSlashOnlyInput(input) {
+    const normalized = input.trim();
+    if (!normalized.startsWith("/")) {
+        return {
+            accepted: false,
+            message: STAGE_A_SLASH_ONLY_MESSAGE,
+        };
+    }
+    const [commandSegment = "", ...rest] = normalized.slice(1).trim().split(/\s+/);
+    const command = commandSegment.toLowerCase();
+    if (!ALLOWED_COMMANDS.has(command)) {
+        return {
+            accepted: false,
+            message: STAGE_A_SLASH_ONLY_MESSAGE,
+        };
+    }
+    return {
+        accepted: true,
+        command,
+        argument: rest.join(" "),
+    };
+}

package/dist/wechat/handle.d.ts

@@ -0,0 +1,8 @@
+import type { WechatRequestKind } from "./state-paths.js";
+export declare function createRouteKey(input: {
+    kind: WechatRequestKind;
+    requestID: string;
+}): string;
+export declare function normalizeHandle(input: string): string;
+export declare function assertValidHandleInput(input: string): void;
+export declare function createHandle(kind: WechatRequestKind, existingHandles: Iterable<string>): string;

package/dist/wechat/handle.js

@@ -0,0 +1,46 @@
+import crypto from "node:crypto";
+const HANDLE_PREFIX = {
+    question: "q",
+    permission: "p",
+};
+function normalizeRequestID(requestID) {
+    return requestID.trim().toLowerCase();
+}
+export function createRouteKey(input) {
+    const normalized = normalizeRequestID(input.requestID);
+    const digest = crypto.createHash("sha1").update(`${input.kind}:${normalized}`).digest("hex").slice(0, 12);
+    return `${input.kind}-${digest}`;
+}
+export function normalizeHandle(input) {
+    const value = input.trim().toLowerCase();
+    if (!/^[a-z][a-z0-9]*$/.test(value)) {
+        throw new Error("invalid handle format");
+    }
+    return value;
+}
+function isRawRequestIDLike(input) {
+    return /^req(?:uest)?[-_]/i.test(input.trim());
+}
+export function assertValidHandleInput(input) {
+    if (isRawRequestIDLike(input)) {
+        throw new Error("raw requestID cannot be used as handle");
+    }
+    normalizeHandle(input);
+}
+export function createHandle(kind, existingHandles) {
+    const prefix = HANDLE_PREFIX[kind];
+    const seen = new Set();
+    for (const item of existingHandles) {
+        try {
+            seen.add(normalizeHandle(item));
+        }
+        catch {
+            // ignore invalid historical values
+        }
+    }
+    let index = 1;
+    while (seen.has(`${prefix}${index}`)) {
+        index += 1;
+    }
+    return `${prefix}${index}`;
+}

package/dist/wechat/ipc-auth.d.ts

@@ -0,0 +1,6 @@
+import type { BrokerMessageType } from "./protocol.js";
+export declare function createSessionToken(): string;
+export declare function registerConnection(instanceID: string, connectionRef: unknown): string;
+export declare function validateSessionToken(instanceID: string, token: string): boolean;
+export declare function revokeSessionToken(instanceID: string): void;
+export declare function isAuthRequired(type: BrokerMessageType): boolean;

package/dist/wechat/ipc-auth.js

@@ -0,0 +1,39 @@
+import { randomUUID } from "node:crypto";
+const sessionByInstanceID = new Map();
+const TOKEN_FREE_TYPES = ["registerInstance", "ping"];
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+export function createSessionToken() {
+    return randomUUID();
+}
+export function registerConnection(instanceID, connectionRef) {
+    if (!isNonEmptyString(instanceID)) {
+        throw new Error("invalid instanceID");
+    }
+    const token = createSessionToken();
+    sessionByInstanceID.set(instanceID, { token, connectionRef });
+    return token;
+}
+export function validateSessionToken(instanceID, token) {
+    if (!isNonEmptyString(instanceID) || !isNonEmptyString(token)) {
+        return false;
+    }
+    const current = sessionByInstanceID.get(instanceID);
+    if (!current) {
+        return false;
+    }
+    return current.token === token;
+}
+export function revokeSessionToken(instanceID) {
+    if (!isNonEmptyString(instanceID)) {
+        return;
+    }
+    sessionByInstanceID.delete(instanceID);
+}
+export function isAuthRequired(type) {
+    if (TOKEN_FREE_TYPES.includes(type)) {
+        return false;
+    }
+    return true;
+}

package/dist/wechat/operator-store.d.ts

@@ -0,0 +1,8 @@
+export type OperatorBinding = {
+    wechatAccountId: string;
+    userId: string;
+    boundAt: number;
+};
+export declare function readOperatorBinding(): Promise<OperatorBinding | undefined>;
+export declare function bindOperator(input: OperatorBinding): Promise<OperatorBinding>;
+export declare function resetOperatorBinding(): Promise<void>;

package/dist/wechat/operator-store.js

@@ -0,0 +1,59 @@
+import path from "node:path";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { WECHAT_FILE_MODE, ensureWechatStateLayout, operatorStatePath } from "./state-paths.js";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isValidBinding(input) {
+    return (isNonEmptyString(input.wechatAccountId) &&
+        isNonEmptyString(input.userId) &&
+        typeof input.boundAt === "number" &&
+        Number.isFinite(input.boundAt));
+}
+function toBinding(input) {
+    return {
+        wechatAccountId: input.wechatAccountId,
+        userId: input.userId,
+        boundAt: input.boundAt,
+    };
+}
+export async function readOperatorBinding() {
+    try {
+        const raw = await readFile(operatorStatePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isValidBinding(parsed)) {
+            throw new Error("invalid operator binding format");
+        }
+        return toBinding(parsed);
+    }
+    catch (error) {
+        const issue = error;
+        if (issue.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+export async function bindOperator(input) {
+    const next = toBinding(input);
+    if (!isValidBinding(next)) {
+        throw new Error("invalid operator binding format");
+    }
+    const existing = await readOperatorBinding();
+    if (existing && (existing.userId !== next.userId || existing.wechatAccountId !== next.wechatAccountId)) {
+        throw new Error("operator already bound to another user");
+    }
+    await ensureWechatStateLayout();
+    await mkdir(path.dirname(operatorStatePath()), { recursive: true });
+    await writeFile(operatorStatePath(), JSON.stringify(next, null, 2), { mode: WECHAT_FILE_MODE });
+    return next;
+}
+export async function resetOperatorBinding() {
+    try {
+        await unlink(operatorStatePath());
+    }
+    catch (error) {
+        const issue = error;
+        if (issue.code !== "ENOENT")
+            throw error;
+    }
+}