opencode-oncall 0.1.0

package/dist/wechat/command-parser.d.ts

@@ -0,0 +1,18 @@
+export type WechatSlashCommand = {
+    type: "status";
+} | {
+    type: "todo";
+} | {
+    type: "reply";
+    handle: string;
+    text: string;
+} | {
+    type: "recover";
+    handle?: string;
+} | {
+    type: "allow";
+    handle: string;
+    reply: "once" | "always" | "reject";
+    message?: string;
+};
+export declare function parseWechatSlashCommand(input: string): WechatSlashCommand | null;

package/dist/wechat/command-parser.js

@@ -0,0 +1,58 @@
+export function parseWechatSlashCommand(input) {
+    if (typeof input !== "string") {
+        return null;
+    }
+    const normalized = input.trim();
+    if (normalized === "/status") {
+        return { type: "status" };
+    }
+    if (normalized === "/todo") {
+        return { type: "todo" };
+    }
+    const parts = normalized.split(/\s+/);
+    const command = parts[0];
+    if (command === "/reply") {
+        if (parts.length < 3) {
+            return null;
+        }
+        const handle = parts[1];
+        const textParts = parts.slice(2);
+        const text = textParts.join(" ").trim();
+        if (!handle || !text) {
+            return null;
+        }
+        return { type: "reply", handle, text };
+    }
+    if (command === "/recover") {
+        if (parts.length === 1) {
+            return { type: "recover" };
+        }
+        if (parts.length !== 2) {
+            return null;
+        }
+        const handle = parts[1];
+        if (!handle) {
+            return null;
+        }
+        return { type: "recover", handle };
+    }
+    if (command === "/allow") {
+        if (parts.length < 3) {
+            return null;
+        }
+        const handle = parts[1];
+        const rawReply = parts[2];
+        const messageParts = parts.slice(3);
+        if (!handle || !rawReply) {
+            return null;
+        }
+        if (rawReply !== "once" && rawReply !== "always" && rawReply !== "reject") {
+            return null;
+        }
+        const message = messageParts.join(" ").trim();
+        return message.length > 0
+            ? { type: "allow", handle, reply: rawReply, message }
+            : { type: "allow", handle, reply: rawReply };
+    }
+    return null;
+}

package/dist/wechat/compat/jiti-loader.d.ts

@@ -0,0 +1,27 @@
+export type JitiLoader = (path: string) => unknown;
+type CreateJiti = (id: string | URL, options?: Record<string, unknown>) => JitiLoader;
+type JitiImport = (specifier: string) => Promise<unknown> | unknown;
+type JitiResolve = (specifier: string) => string;
+type JitiRequire = (specifier: string) => unknown;
+type ModuleImport = (specifier: string) => Promise<unknown>;
+type JitiNamespace = {
+    createJiti?: unknown;
+    default?: unknown;
+    "module.exports"?: unknown;
+};
+export declare function resolveCreateJiti(namespace: JitiNamespace): CreateJiti;
+export declare function resolveJitiEsmEntry(resolveImpl?: JitiResolve): string;
+export declare function resolveJitiCjsEntry(resolveImpl?: JitiResolve): string;
+export declare function hasBunRuntime(bunVersion?: string | undefined): boolean;
+export declare function wrapCreateJiti(createJiti: CreateJiti): CreateJiti;
+export declare function loadJiti(importImpl?: JitiImport, resolveImpl?: JitiResolve, requireImpl?: JitiRequire): Promise<{
+    createJiti: CreateJiti;
+}>;
+export declare function loadModuleWithTsFallback(modulePath: string, options?: {
+    bunVersion?: string | undefined;
+    importImpl?: ModuleImport;
+    loadJitiImpl?: typeof loadJiti;
+    parentURL?: string | URL;
+    jitiOptions?: Record<string, unknown>;
+}): Promise<unknown>;
+export {};

package/dist/wechat/compat/jiti-loader.js

@@ -0,0 +1,118 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+function isCreateJiti(value) {
+    return typeof value === "function";
+}
+export function resolveCreateJiti(namespace) {
+    if (isCreateJiti(namespace)) {
+        return namespace;
+    }
+    if (isCreateJiti(namespace.createJiti)) {
+        return namespace.createJiti;
+    }
+    if (isCreateJiti(namespace.default)) {
+        return namespace.default;
+    }
+    if (isCreateJiti(namespace["module.exports"])) {
+        return namespace["module.exports"];
+    }
+    if (namespace.default &&
+        typeof namespace.default === "object" &&
+        isCreateJiti(namespace.default.createJiti)) {
+        return namespace.default.createJiti;
+    }
+    if (namespace.default &&
+        typeof namespace.default === "object" &&
+        isCreateJiti(namespace.default.default)) {
+        return namespace.default.default;
+    }
+    if (namespace.default &&
+        typeof namespace.default === "object" &&
+        isCreateJiti(namespace.default["module.exports"])) {
+        return namespace.default["module.exports"];
+    }
+    const topLevelKeys = namespace && typeof namespace === "object" ? Object.keys(namespace).join(",") : typeof namespace;
+    const defaultValue = namespace?.default;
+    const defaultKeys = defaultValue && typeof defaultValue === "object" ? Object.keys(defaultValue).join(",") : typeof defaultValue;
+    throw new Error(`[wechat-compat] createJiti export unavailable (keys=${topLevelKeys}; default=${defaultKeys})`);
+}
+export function resolveJitiEsmEntry(resolveImpl = createRequire(import.meta.url).resolve) {
+    const packageJsonPath = resolveImpl("jiti/package.json");
+    return pathToFileURL(path.join(path.dirname(packageJsonPath), "lib", "jiti.cjs")).href;
+}
+export function resolveJitiCjsEntry(resolveImpl = createRequire(import.meta.url).resolve) {
+    const packageJsonPath = resolveImpl("jiti/package.json");
+    return path.join(path.dirname(packageJsonPath), "lib", "jiti.cjs");
+}
+function onJitiError(error) {
+    throw error;
+}
+const nativeImport = (id) => import(id);
+const DEFAULT_JITI_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"];
+function isTypeScriptModulePath(modulePath) {
+    return /\.(ts|tsx|mts|cts)$/i.test(modulePath);
+}
+export function hasBunRuntime(bunVersion = process.versions?.bun) {
+    return typeof bunVersion === "string" && bunVersion.length > 0;
+}
+export function wrapCreateJiti(createJiti) {
+    const requireFromJiti = createRequire(resolveJitiEsmEntry());
+    let transformImpl;
+    const lazyTransform = (...args) => {
+        if (!transformImpl) {
+            transformImpl = requireFromJiti("../dist/babel.cjs");
+        }
+        return transformImpl(...args);
+    };
+    return (id, options = {}) => {
+        const nextOptions = typeof options.transform === "function"
+            ? options
+            : { ...options, transform: lazyTransform };
+        return createJiti(id, nextOptions, {
+            onError: onJitiError,
+            nativeImport,
+            createRequire,
+        });
+    };
+}
+export async function loadJiti(importImpl = (specifier) => import(specifier), resolveImpl = createRequire(import.meta.url).resolve, requireImpl = createRequire(import.meta.url)) {
+    try {
+        const required = requireImpl("jiti");
+        return {
+            createJiti: wrapCreateJiti(resolveCreateJiti(required)),
+        };
+    }
+    catch {
+        // Fall back to import() when require-based loading is unavailable.
+    }
+    try {
+        const namespace = await Promise.resolve(importImpl("jiti"));
+        return {
+            createJiti: wrapCreateJiti(resolveCreateJiti(namespace)),
+        };
+    }
+    catch {
+        const namespace = await Promise.resolve(importImpl(resolveJitiEsmEntry(resolveImpl)));
+        return {
+            createJiti: wrapCreateJiti(resolveCreateJiti(namespace)),
+        };
+    }
+}
+export async function loadModuleWithTsFallback(modulePath, options = {}) {
+    const moduleUrl = pathToFileURL(modulePath).href;
+    const importImpl = options.importImpl ?? nativeImport;
+    // Even under Bun, TS entrypoints inside node_modules can transitively hit ESM/CJS
+    // interop edges (for example openclaw -> json5 default import). Jiti keeps that
+    // path stable for the WeChat compat loader.
+    if (hasBunRuntime(options.bunVersion) && !isTypeScriptModulePath(modulePath)) {
+        return await importImpl(moduleUrl);
+    }
+    const { createJiti } = await (options.loadJitiImpl ?? loadJiti)();
+    const loader = createJiti(options.parentURL ?? import.meta.url, {
+        interopDefault: true,
+        extensions: DEFAULT_JITI_EXTENSIONS,
+        ...(options.jitiOptions ?? {}),
+    });
+    return loader(modulePath);
+}

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

@@ -0,0 +1,29 @@
+export type WeixinAccountHelpers = {
+    listAccountIds: () => Promise<string[]>;
+    resolveAccount: (accountId: string) => Promise<{
+        accountId: string;
+        enabled: boolean;
+        configured: boolean;
+        name?: string;
+        userId?: string;
+    }>;
+    describeAccount: (accountIdOrInput: string | {
+        accountId: string;
+    }) => Promise<{
+        accountId: string;
+        enabled: boolean;
+        configured: boolean;
+        name?: string;
+        userId?: string;
+    }>;
+};
+type OpenClawAccountSourceHelpers = {
+    listAccountIds: () => string[] | Promise<string[]>;
+    loadAccount: (accountId: string) => unknown | Promise<unknown>;
+    resolveAccount: (accountId: string) => unknown | Promise<unknown>;
+};
+export declare function createOpenClawAccountHelpers(input: OpenClawAccountSourceHelpers): WeixinAccountHelpers;
+export declare function loadOpenClawAccountHelpers(options?: {
+    accountsModulePath?: string;
+}): Promise<WeixinAccountHelpers>;
+export {};

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

@@ -0,0 +1,60 @@
+import { createRequire } from "node:module";
+import { loadModuleWithTsFallback } from "./jiti-loader.js";
+const OPENCLAW_WEIXIN_ACCOUNTS_MODULE = "@tencent-weixin/openclaw-weixin/src/auth/accounts.ts";
+function asObject(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function deriveEnabled(resolved) {
+    return resolved.enabled === true;
+}
+function isConfigured(resolved) {
+    return resolved.configured === true;
+}
+function toAccountId(input) {
+    return typeof input === "string" ? input : input.accountId;
+}
+export function createOpenClawAccountHelpers(input) {
+    const resolveStableAccount = async (accountId) => {
+        const resolved = asObject(await input.resolveAccount(accountId));
+        const stored = asObject(await input.loadAccount(accountId));
+        return {
+            accountId,
+            enabled: deriveEnabled(resolved),
+            configured: isConfigured(resolved),
+            name: typeof resolved.name === "string" ? resolved.name : undefined,
+            userId: typeof stored.userId === "string" ? stored.userId : undefined,
+        };
+    };
+    return {
+        async listAccountIds() {
+            const ids = await input.listAccountIds();
+            return Array.isArray(ids) ? ids.filter((it) => typeof it === "string" && it.length > 0) : [];
+        },
+        async resolveAccount(accountId) {
+            return resolveStableAccount(accountId);
+        },
+        async describeAccount(accountIdOrInput) {
+            return resolveStableAccount(toAccountId(accountIdOrInput));
+        },
+    };
+}
+export async function loadOpenClawAccountHelpers(options = {}) {
+    const require = createRequire(import.meta.url);
+    const accountsModulePath = require.resolve(options.accountsModulePath ?? OPENCLAW_WEIXIN_ACCOUNTS_MODULE);
+    const accountsModule = await loadModuleWithTsFallback(accountsModulePath, { parentURL: import.meta.url });
+    if (typeof accountsModule.listIndexedWeixinAccountIds !== "function" || typeof accountsModule.loadWeixinAccount !== "function") {
+        throw new Error("[wechat-compat] account source helper unavailable");
+    }
+    return createOpenClawAccountHelpers({
+        listAccountIds: () => accountsModule.listIndexedWeixinAccountIds(),
+        loadAccount: (accountId) => accountsModule.loadWeixinAccount(accountId),
+        resolveAccount: async (accountId) => {
+            const stored = asObject(await accountsModule.loadWeixinAccount(accountId));
+            return {
+                accountId,
+                enabled: stored.enabled === false ? false : true,
+                configured: typeof stored.token === "string" && stored.token.trim().length > 0,
+            };
+        },
+    });
+}

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

@@ -0,0 +1,29 @@
+type WeixinBindQrGateway = {
+    loginWithQrStart: (input?: unknown) => Promise<unknown>;
+    loginWithQrWait: (input?: unknown) => Promise<unknown>;
+};
+type WeixinBindAccountHelpers = {
+    listAccountIds: () => Promise<string[]>;
+    resolveAccount: (accountId: string) => Promise<{
+        accountId: string;
+        enabled: boolean;
+        configured: boolean;
+        name?: string;
+        userId?: string;
+    }>;
+    describeAccount: (accountIdOrInput: string | {
+        accountId: string;
+    }) => Promise<{
+        accountId: string;
+        enabled: boolean;
+        configured: boolean;
+        name?: string;
+        userId?: string;
+    }>;
+};
+export type OpenClawWeixinBindHelpers = {
+    qrGateway: WeixinBindQrGateway;
+    accountHelpers: WeixinBindAccountHelpers;
+};
+export declare function loadOpenClawWeixinBindHelpers(): Promise<OpenClawWeixinBindHelpers>;
+export {};

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

@@ -0,0 +1,169 @@
+import { randomUUID } from "node:crypto";
+import { loadQrCodeTerminal } from "./qrcode-terminal-loader.js";
+const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+const DEFAULT_ILINK_BOT_TYPE = "3";
+const ACTIVE_LOGIN_TTL_MS = 5 * 60_000;
+const QR_LONG_POLL_TIMEOUT_MS = 35_000;
+const activeLogins = new Map();
+function asObject(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function asNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function asPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function isLoginFresh(login) {
+    return Date.now() - login.startedAt < ACTIVE_LOGIN_TTL_MS;
+}
+function purgeExpiredLogins() {
+    for (const [sessionKey, login] of activeLogins) {
+        if (!isLoginFresh(login)) {
+            activeLogins.delete(sessionKey);
+        }
+    }
+}
+async function fetchQrCode(apiBaseUrl, botType) {
+    const base = apiBaseUrl.endsWith("/") ? apiBaseUrl : `${apiBaseUrl}/`;
+    const url = new URL(`ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`, base);
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        throw new Error(`Failed to fetch QR code: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+}
+async function renderQrTerminal(value) {
+    const qrcodeTerminal = loadQrCodeTerminal();
+    return await new Promise((resolve, reject) => {
+        try {
+            qrcodeTerminal.generate(value, { small: true }, (output) => {
+                resolve(typeof output === "string" && output.trim().length > 0 ? output : undefined);
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+async function pollQrStatus(apiBaseUrl, qrcode) {
+    const base = apiBaseUrl.endsWith("/") ? apiBaseUrl : `${apiBaseUrl}/`;
+    const url = new URL(`ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, base);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), QR_LONG_POLL_TIMEOUT_MS);
+    try {
+        const response = await fetch(url.toString(), {
+            headers: { "iLink-App-ClientVersion": "1" },
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        const rawText = await response.text();
+        if (!response.ok) {
+            throw new Error(`Failed to poll QR status: ${response.status} ${response.statusText}`);
+        }
+        const parsed = JSON.parse(rawText);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch (error) {
+        clearTimeout(timer);
+        if (error instanceof Error && error.name === "AbortError") {
+            return { status: "wait" };
+        }
+        throw error;
+    }
+}
+function createAccountHelpers() {
+    async function describeAccount(accountId) {
+        return {
+            accountId,
+            enabled: true,
+            configured: false,
+        };
+    }
+    return {
+        async listAccountIds() {
+            return [];
+        },
+        resolveAccount: describeAccount,
+        async describeAccount(accountIdOrInput) {
+            const accountId = typeof accountIdOrInput === "string" ? accountIdOrInput : accountIdOrInput.accountId;
+            return await describeAccount(accountId);
+        },
+    };
+}
+export async function loadOpenClawWeixinBindHelpers() {
+    const accountHelpers = createAccountHelpers();
+    return {
+        qrGateway: {
+            async loginWithQrStart(input) {
+                const params = asObject(input);
+                const sessionKey = asNonEmptyString(params.accountId) ?? randomUUID();
+                const force = params.force === true;
+                purgeExpiredLogins();
+                const existing = activeLogins.get(sessionKey);
+                if (!force && existing && isLoginFresh(existing) && existing.qrcodeUrl) {
+                    return {
+                        qrcodeUrl: existing.qrcodeUrl,
+                        message: "二维码已就绪，请使用微信扫描。",
+                        sessionKey,
+                    };
+                }
+                const qrResponse = await fetchQrCode(DEFAULT_BASE_URL, DEFAULT_ILINK_BOT_TYPE);
+                activeLogins.set(sessionKey, {
+                    sessionKey,
+                    qrcode: qrResponse.qrcode,
+                    qrcodeUrl: qrResponse.qrcode_img_content,
+                    startedAt: Date.now(),
+                });
+                return {
+                    qrTerminal: await renderQrTerminal(qrResponse.qrcode_img_content).catch(() => undefined),
+                    qrDataUrl: qrResponse.qrcode_img_content,
+                    qrcodeUrl: qrResponse.qrcode_img_content,
+                    message: "使用微信扫描以下二维码，以完成连接。",
+                    sessionKey,
+                };
+            },
+            async loginWithQrWait(input) {
+                const params = asObject(input);
+                const sessionKey = asNonEmptyString(params.sessionKey);
+                if (!sessionKey) {
+                    throw new Error("missing sessionKey from qr wait");
+                }
+                let activeLogin = activeLogins.get(sessionKey);
+                if (!activeLogin) {
+                    return { connected: false, message: "当前没有进行中的登录，请先发起登录。" };
+                }
+                if (!isLoginFresh(activeLogin)) {
+                    activeLogins.delete(sessionKey);
+                    return { connected: false, message: "二维码已过期，请重新生成。" };
+                }
+                const timeoutMs = Math.max(asPositiveNumber(params.timeoutMs) ?? 480_000, 1000);
+                const deadline = Date.now() + timeoutMs;
+                while (Date.now() < deadline) {
+                    const statusResponse = await pollQrStatus(DEFAULT_BASE_URL, activeLogin.qrcode);
+                    const status = asNonEmptyString(statusResponse.status);
+                    if (status === "confirmed") {
+                        activeLogins.delete(sessionKey);
+                        return {
+                            connected: true,
+                            botToken: asNonEmptyString(statusResponse.bot_token),
+                            accountId: asNonEmptyString(statusResponse.ilink_bot_id),
+                            baseUrl: asNonEmptyString(statusResponse.baseurl),
+                            userId: asNonEmptyString(statusResponse.ilink_user_id),
+                            message: "✅ 与微信连接成功！",
+                        };
+                    }
+                    if (status === "expired") {
+                        activeLogins.delete(sessionKey);
+                        return { connected: false, message: "二维码已过期，请重新生成。" };
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    activeLogin = activeLogins.get(sessionKey) ?? activeLogin;
+                }
+                activeLogins.delete(sessionKey);
+                return { connected: false, message: "登录超时，请重试。" };
+            },
+        },
+        accountHelpers,
+    };
+}