opencode-oncall 0.1.0

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

@@ -0,0 +1,33 @@
+type CompatHostApi = {
+    runtime?: {
+        channelRuntime?: unknown;
+        gateway?: {
+            startAccount?: unknown;
+        };
+    };
+    registerChannel?: (input: unknown) => void;
+    registerCli?: (handler: unknown, options?: unknown) => void;
+};
+type OpenClawWeixinPlugin = {
+    id?: string;
+    register(api: CompatHostApi): void;
+};
+export type OpenClawWeixinPublicEntry = {
+    packageJsonPath: string;
+    packageRoot: string;
+    extensions: string[];
+    entryRelativePath: string;
+    entryAbsolutePath: string;
+};
+export declare function resolveOpenClawWeixinPublicEntry(): Promise<OpenClawWeixinPublicEntry>;
+export declare function loadOpenClawWeixinDefaultExport(): Promise<OpenClawWeixinPlugin>;
+export declare function loadRegisteredWeixinPluginPayloads(): Promise<Array<{
+    plugin?: unknown;
+}>>;
+export declare function loadRegisteredWeixinPluginContext(): Promise<{
+    pluginId: string;
+    payloads: Array<{
+        plugin?: unknown;
+    }>;
+}>;
+export {};

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

@@ -0,0 +1,62 @@
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { loadModuleWithTsFallback } from "./jiti-loader.js";
+function requireField(condition, message) {
+    if (!condition) {
+        throw new Error(`[wechat-compat] ${message}`);
+    }
+}
+export 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,
+    };
+}
+export async function loadOpenClawWeixinDefaultExport() {
+    const entry = await resolveOpenClawWeixinPublicEntry();
+    const moduleNamespace = await loadModuleWithTsFallback(entry.entryAbsolutePath, { parentURL: import.meta.url });
+    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;
+}
+export async function loadRegisteredWeixinPluginPayloads() {
+    const context = await loadRegisteredWeixinPluginContext();
+    return context.payloads;
+}
+export async function loadRegisteredWeixinPluginContext() {
+    const payloads = [];
+    const plugin = await loadOpenClawWeixinDefaultExport();
+    plugin.register({
+        runtime: {
+            channelRuntime: { mode: "guided-smoke" },
+            gateway: { startAccount: { source: "guided-smoke" } },
+        },
+        registerChannel(payload) {
+            payloads.push(payload);
+        },
+        registerCli() { },
+    });
+    return {
+        pluginId: typeof plugin.id === "string" && plugin.id.trim().length > 0 ? plugin.id : "wechat-openclaw-weixin",
+        payloads,
+    };
+}

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

@@ -0,0 +1,70 @@
+import { loadOpenClawAccountHelpers, type WeixinAccountHelpers } from "./openclaw-account-helpers.js";
+import { loadRegisteredWeixinPluginContext, loadRegisteredWeixinPluginPayloads, resolveOpenClawWeixinPublicEntry, type OpenClawWeixinPublicEntry } from "./openclaw-public-entry.js";
+import { type WeixinQrGateway } from "./openclaw-qr-gateway.js";
+import { loadOpenClawUpdatesAndSendHelpers, type PublicWeixinMessage, type PublicWeixinSendMessage } from "./openclaw-updates-send.js";
+import { loadLatestWeixinAccountState, loadOpenClawSyncBufHelper, type PublicWeixinPersistGetUpdatesBuf } from "./openclaw-sync-buf.js";
+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";
+};
+export type OpenClawWeixinPublicHelpers = {
+    entry: OpenClawWeixinPublicEntry;
+    pluginId: string;
+    qrGateway: WeixinQrGateway;
+    accountHelpers: WeixinAccountHelpers;
+    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;
+    loadRegisteredWeixinPluginContext?: typeof loadRegisteredWeixinPluginContext;
+    loadRegisteredWeixinPluginPayloads?: typeof loadRegisteredWeixinPluginPayloads;
+    loadOpenClawQrGateway?: (payloads: Array<{
+        plugin?: unknown;
+    }>) => Promise<{
+        gateway: WeixinQrGateway;
+        pluginId: string;
+    }>;
+    loadPublicWeixinQrGateway?: () => Promise<{
+        gateway: WeixinQrGateway;
+        pluginId?: string;
+    }>;
+    loadLatestWeixinAccountState?: typeof loadLatestWeixinAccountState;
+    loadOpenClawAccountHelpers?: typeof loadOpenClawAccountHelpers;
+    loadOpenClawUpdatesAndSendHelpers?: typeof loadOpenClawUpdatesAndSendHelpers;
+    loadOpenClawSyncBufHelper?: typeof loadOpenClawSyncBufHelper;
+    loadPublicWeixinHelpers?: () => Promise<{
+        getUpdates: (params: {
+            baseUrl: string;
+            token?: string;
+            get_updates_buf?: string;
+            timeoutMs?: number;
+        }) => Promise<{
+            msgs?: PublicWeixinMessage[];
+            get_updates_buf?: string;
+        }>;
+    }>;
+    loadPublicWeixinSendHelper?: () => Promise<{
+        sendMessageWeixin: PublicWeixinSendMessage;
+    }>;
+};
+export declare function loadOpenClawWeixinPublicHelpers(loaders?: OpenClawWeixinPublicHelpersLoaders): Promise<OpenClawWeixinPublicHelpers>;
+export type OpenClawWeixinPublicHelpersLoaderOptions = OpenClawWeixinPublicHelpersLoaders;
+export type { PublicWeixinMessage, PublicWeixinSendMessage, PublicWeixinPersistGetUpdatesBuf };

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

@@ -0,0 +1,68 @@
+import { loadOpenClawAccountHelpers } from "./openclaw-account-helpers.js";
+import { loadRegisteredWeixinPluginContext, resolveOpenClawWeixinPublicEntry, } from "./openclaw-public-entry.js";
+import { loadOpenClawQrGateway } from "./openclaw-qr-gateway.js";
+import { loadOpenClawUpdatesAndSendHelpers, } from "./openclaw-updates-send.js";
+import { loadLatestWeixinAccountState, loadOpenClawSyncBufHelper, } from "./openclaw-sync-buf.js";
+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",
+};
+function missingHelperError(helperName) {
+    return new Error(`[wechat-compat] required helper missing: ${helperName}`);
+}
+export async function loadOpenClawWeixinPublicHelpers(loaders = {}) {
+    const entry = await (loaders.resolveOpenClawWeixinPublicEntry ?? resolveOpenClawWeixinPublicEntry)();
+    const qrGatewayResult = loaders.loadPublicWeixinQrGateway
+        ? await loaders.loadPublicWeixinQrGateway()
+        : await (async () => {
+            if (loaders.loadRegisteredWeixinPluginContext) {
+                const context = await loaders.loadRegisteredWeixinPluginContext();
+                return (loaders.loadOpenClawQrGateway ?? loadOpenClawQrGateway)(context.payloads, { pluginId: context.pluginId });
+            }
+            const context = await loadRegisteredWeixinPluginContext();
+            return (loaders.loadOpenClawQrGateway ?? loadOpenClawQrGateway)(context.payloads, { pluginId: context.pluginId });
+        })();
+    const accountHelpers = await (loaders.loadOpenClawAccountHelpers ?? loadOpenClawAccountHelpers)();
+    const latestAccountState = await (loaders.loadLatestWeixinAccountState ?? loadLatestWeixinAccountState)({
+        stateDirModulePath: OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.stateDir,
+        syncBufModulePath: OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.syncBuf,
+    });
+    const updatesSend = loaders.loadOpenClawUpdatesAndSendHelpers
+        ? await loaders.loadOpenClawUpdatesAndSendHelpers()
+        : await (async () => {
+            const defaults = await loadOpenClawUpdatesAndSendHelpers();
+            const maybeUpdates = loaders.loadPublicWeixinHelpers ? await loaders.loadPublicWeixinHelpers() : undefined;
+            const maybeSend = loaders.loadPublicWeixinSendHelper ? await loaders.loadPublicWeixinSendHelper() : undefined;
+            return {
+                getUpdates: loaders.loadPublicWeixinHelpers ? maybeUpdates?.getUpdates : defaults.getUpdates,
+                sendMessageWeixin: loaders.loadPublicWeixinSendHelper ? maybeSend?.sendMessageWeixin : defaults.sendMessageWeixin,
+            };
+        })();
+    const syncBufHelpers = await (loaders.loadOpenClawSyncBufHelper ?? loadOpenClawSyncBufHelper)();
+    if (typeof qrGatewayResult?.gateway?.loginWithQrStart !== "function" || typeof qrGatewayResult?.gateway?.loginWithQrWait !== "function") {
+        throw missingHelperError("qrGateway");
+    }
+    if (typeof updatesSend?.getUpdates !== "function") {
+        throw missingHelperError("getUpdates");
+    }
+    if (typeof accountHelpers?.listAccountIds !== "function" ||
+        typeof accountHelpers?.resolveAccount !== "function" ||
+        typeof accountHelpers?.describeAccount !== "function") {
+        throw missingHelperError("accountHelpers");
+    }
+    if (typeof updatesSend?.sendMessageWeixin !== "function") {
+        throw missingHelperError("sendMessageWeixin");
+    }
+    return {
+        entry,
+        pluginId: typeof qrGatewayResult.pluginId === "string" && qrGatewayResult.pluginId.length > 0 ? qrGatewayResult.pluginId : "unknown",
+        qrGateway: qrGatewayResult.gateway,
+        accountHelpers,
+        latestAccountState,
+        getUpdates: updatesSend.getUpdates,
+        sendMessageWeixin: updatesSend.sendMessageWeixin,
+        persistGetUpdatesBuf: syncBufHelpers.persistGetUpdatesBuf,
+    };
+}

package/dist/wechat/compat/openclaw-qr-gateway.d.ts

@@ -0,0 +1,15 @@
+export type WeixinQrGateway = {
+    loginWithQrStart: (input?: unknown) => unknown;
+    loginWithQrWait: (input?: unknown) => unknown;
+};
+type OpenClawQrGatewayPayload = {
+    plugin?: unknown;
+};
+export declare function createOpenClawQrGateway(source: WeixinQrGateway): WeixinQrGateway;
+export declare function loadOpenClawQrGateway(payloads: OpenClawQrGatewayPayload[], options?: {
+    pluginId?: string;
+}): Promise<{
+    gateway: WeixinQrGateway;
+    pluginId: string;
+}>;
+export {};

package/dist/wechat/compat/openclaw-qr-gateway.js

@@ -0,0 +1,39 @@
+function toObjectInput(input) {
+    return input && typeof input === "object" ? input : {};
+}
+function hasQrLoginMethods(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.loginWithQrStart === "function" && typeof candidate.loginWithQrWait === "function";
+}
+export function createOpenClawQrGateway(source) {
+    return {
+        async loginWithQrStart(input) {
+            return source.loginWithQrStart(toObjectInput(input));
+        },
+        async loginWithQrWait(input) {
+            return source.loginWithQrWait(toObjectInput(input));
+        },
+    };
+}
+export async function loadOpenClawQrGateway(payloads, options = {}) {
+    for (const payload of payloads) {
+        const payloadPlugin = payload?.plugin;
+        const resolvedPluginId = typeof options.pluginId === "string" && options.pluginId.trim().length > 0
+            ? options.pluginId
+            : typeof payloadPlugin?.id === "string" &&
+                String(payloadPlugin.id).trim().length > 0
+                ? String(payloadPlugin.id)
+                : "unknown";
+        const gateway = payloadPlugin && typeof payloadPlugin === "object" ? payloadPlugin.gateway : null;
+        if (hasQrLoginMethods(gateway)) {
+            return {
+                gateway: createOpenClawQrGateway(gateway),
+                pluginId: resolvedPluginId,
+            };
+        }
+    }
+    throw new Error("registerChannel did not expose weixin gateway loginWithQrStart/loginWithQrWait");
+}

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/openclaw-sync-buf.d.ts

@@ -0,0 +1,24 @@
+export type PublicWeixinPersistGetUpdatesBuf = (params: {
+    accountId: string;
+    getUpdatesBuf: string;
+}) => Promise<void>;
+export declare function createOpenClawSyncBufHelper(input: {
+    getSyncBufFilePath: (accountId: string) => string;
+    saveGetUpdatesBuf: (filePath: string, getUpdatesBuf: string) => void;
+}): {
+    persistGetUpdatesBuf: PublicWeixinPersistGetUpdatesBuf;
+};
+export declare function loadOpenClawSyncBufHelper(options?: {
+    syncBufModulePath?: string;
+}): Promise<{
+    persistGetUpdatesBuf: PublicWeixinPersistGetUpdatesBuf;
+}>;
+export declare function loadLatestWeixinAccountState(options?: {
+    stateDirModulePath?: string;
+    syncBufModulePath?: string;
+}): Promise<{
+    accountId: string;
+    token: string;
+    baseUrl: string;
+    getUpdatesBuf?: string;
+} | null>;

package/dist/wechat/compat/openclaw-sync-buf.js

@@ -0,0 +1,80 @@
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { loadModuleWithTsFallback } from "./jiti-loader.js";
+import { readWechatLatestAccountState } from "../latest-account-state-store.js";
+const OPENCLAW_SYNC_BUF_MODULE = "@tencent-weixin/openclaw-weixin/src/storage/sync-buf.ts";
+const OPENCLAW_STATE_DIR_MODULE = "@tencent-weixin/openclaw-weixin/src/storage/state-dir.ts";
+export function createOpenClawSyncBufHelper(input) {
+    return {
+        async persistGetUpdatesBuf({ accountId, getUpdatesBuf }) {
+            const filePath = input.getSyncBufFilePath(accountId);
+            if (typeof filePath !== "string" || filePath.trim().length === 0) {
+                throw new Error("[wechat-compat] sync-buf helper returned invalid file path");
+            }
+            input.saveGetUpdatesBuf(filePath, getUpdatesBuf);
+        },
+    };
+}
+export async function loadOpenClawSyncBufHelper(options = {}) {
+    const require = createRequire(import.meta.url);
+    const syncBufModulePath = require.resolve(options.syncBufModulePath ?? OPENCLAW_SYNC_BUF_MODULE);
+    const syncBufModule = await loadModuleWithTsFallback(syncBufModulePath, { parentURL: import.meta.url });
+    if (typeof syncBufModule.getSyncBufFilePath !== "function" || typeof syncBufModule.saveGetUpdatesBuf !== "function") {
+        throw new Error("[wechat-compat] sync-buf source helper unavailable");
+    }
+    return createOpenClawSyncBufHelper({
+        getSyncBufFilePath: syncBufModule.getSyncBufFilePath,
+        saveGetUpdatesBuf: syncBufModule.saveGetUpdatesBuf,
+    });
+}
+export async function loadLatestWeixinAccountState(options = {}) {
+    const pluginOwned = await readWechatLatestAccountState();
+    if (pluginOwned) {
+        return pluginOwned;
+    }
+    const require = createRequire(import.meta.url);
+    const stateDirModulePath = require.resolve(options.stateDirModulePath ?? OPENCLAW_STATE_DIR_MODULE);
+    const stateDirModule = await loadModuleWithTsFallback(stateDirModulePath, { parentURL: import.meta.url });
+    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(options.syncBufModulePath ?? OPENCLAW_SYNC_BUF_MODULE);
+        const syncBufModule = await loadModuleWithTsFallback(syncBufModulePath, { parentURL: import.meta.url });
+        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;
+    }
+}

package/dist/wechat/compat/openclaw-updates-send.d.ts

@@ -0,0 +1,47 @@
+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;
+}>;
+type PublicGetUpdates = (params: {
+    baseUrl: string;
+    token?: string;
+    get_updates_buf?: string;
+    timeoutMs?: number;
+}) => Promise<{
+    msgs?: PublicWeixinMessage[];
+    get_updates_buf?: string;
+}>;
+export declare function createOpenClawUpdatesHelper(getUpdates: PublicGetUpdates): {
+    getUpdates: PublicGetUpdates;
+};
+export declare function createOpenClawSendHelper(sendMessageWeixin: PublicWeixinSendMessage): {
+    sendMessageWeixin: PublicWeixinSendMessage;
+};
+export declare function loadOpenClawUpdatesAndSendHelpers(options?: {
+    getUpdatesModulePath?: string;
+    sendMessageWeixinModulePath?: string;
+}): Promise<{
+    getUpdates: PublicGetUpdates;
+    sendMessageWeixin: PublicWeixinSendMessage;
+}>;
+export {};

package/dist/wechat/compat/openclaw-updates-send.js

@@ -0,0 +1,38 @@
+import { createRequire } from "node:module";
+import { loadModuleWithTsFallback } from "./jiti-loader.js";
+const OPENCLAW_UPDATES_MODULE = "@tencent-weixin/openclaw-weixin/src/api/api.ts";
+const OPENCLAW_SEND_MODULE = "@tencent-weixin/openclaw-weixin/src/messaging/send.ts";
+function toObjectInput(input) {
+    return input && typeof input === "object" ? input : {};
+}
+export function createOpenClawUpdatesHelper(getUpdates) {
+    return {
+        async getUpdates(input) {
+            return getUpdates(toObjectInput(input));
+        },
+    };
+}
+export function createOpenClawSendHelper(sendMessageWeixin) {
+    return {
+        async sendMessageWeixin(input) {
+            return sendMessageWeixin(toObjectInput(input));
+        },
+    };
+}
+export async function loadOpenClawUpdatesAndSendHelpers(options = {}) {
+    const require = createRequire(import.meta.url);
+    const getUpdatesModulePath = require.resolve(options.getUpdatesModulePath ?? OPENCLAW_UPDATES_MODULE);
+    const sendModulePath = require.resolve(options.sendMessageWeixinModulePath ?? OPENCLAW_SEND_MODULE);
+    const getUpdatesModule = await loadModuleWithTsFallback(getUpdatesModulePath, { parentURL: import.meta.url });
+    const sendModule = await loadModuleWithTsFallback(sendModulePath, { parentURL: import.meta.url });
+    if (typeof getUpdatesModule.getUpdates !== "function") {
+        throw new Error("public getUpdates helper unavailable");
+    }
+    if (typeof sendModule.sendMessageWeixin !== "function") {
+        throw new Error("public sendMessageWeixin helper unavailable");
+    }
+    return {
+        ...createOpenClawUpdatesHelper(getUpdatesModule.getUpdates),
+        ...createOpenClawSendHelper(sendModule.sendMessageWeixin),
+    };
+}

package/dist/wechat/compat/qrcode-terminal-loader.d.ts

@@ -0,0 +1,12 @@
+type QrCodeTerminal = {
+    generate(input: string, opts: {
+        small?: boolean;
+    }, cb?: (output: string) => void): void;
+};
+type QrCodeTerminalNamespace = {
+    default?: unknown;
+    generate?: unknown;
+};
+export declare function resolveQrCodeTerminal(namespace: QrCodeTerminalNamespace): QrCodeTerminal;
+export declare function loadQrCodeTerminal(requireImpl?: NodeRequire): QrCodeTerminal;
+export {};

package/dist/wechat/compat/qrcode-terminal-loader.js

@@ -0,0 +1,16 @@
+import { createRequire } from "node:module";
+function isQrCodeTerminal(value) {
+    return Boolean(value && typeof value === "object" && typeof value.generate === "function");
+}
+export function resolveQrCodeTerminal(namespace) {
+    if (isQrCodeTerminal(namespace)) {
+        return namespace;
+    }
+    if (isQrCodeTerminal(namespace.default)) {
+        return namespace.default;
+    }
+    throw new Error("[wechat-compat] qrcode-terminal export unavailable");
+}
+export function loadQrCodeTerminal(requireImpl = createRequire(import.meta.url)) {
+    return resolveQrCodeTerminal(requireImpl("qrcode-terminal"));
+}