opencode-oncall 0.1.0

package/dist/wechat/bind-flow.js

@@ -0,0 +1,207 @@
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { loadOpenClawWeixinBindHelpers } from "./compat/openclaw-bind-helpers.js";
+import { loadQrCodeTerminal } from "./compat/qrcode-terminal-loader.js";
+import { writeWechatLatestAccountState } from "./latest-account-state-store.js";
+import { buildOpenClawMenuAccount } from "./openclaw-account-adapter.js";
+import { bindOperator, readOperatorBinding, rebindOperator, resetOperatorBinding, } from "./operator-store.js";
+const DEFAULT_QR_WAIT_TIMEOUT_MS = 480000;
+function pickFirstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function toErrorMessage(error) {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return error.message;
+    }
+    return String(error);
+}
+function pickQrTerminal(value) {
+    return pickFirstNonEmptyString(value?.qrTerminal);
+}
+function pickQrUrl(value) {
+    return pickFirstNonEmptyString(value?.qrDataUrl);
+}
+function isTimeoutWaitResult(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        "status" in value &&
+        String(value.status) === "timeout");
+}
+async function rollbackBinding(action, previousOperatorBinding, persistOperatorRebinding, clearOperatorBinding) {
+    if (action === "wechat-rebind" && previousOperatorBinding) {
+        await persistOperatorRebinding(previousOperatorBinding).catch(() => { });
+        return;
+    }
+    await clearOperatorBinding().catch(() => { });
+}
+function isSameOperatorBinding(left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    return (left.wechatAccountId === right.wechatAccountId &&
+        left.userId === right.userId &&
+        left.boundAt === right.boundAt);
+}
+async function renderQrTerminalDefault(input) {
+    const qrcodeTerminal = loadQrCodeTerminal();
+    return await new Promise((resolve) => {
+        qrcodeTerminal.generate(input.value, { small: true }, (output) => {
+            resolve(typeof output === "string" && output.trim().length > 0
+                ? output
+                : undefined);
+        });
+    });
+}
+export async function runWechatBindFlow(input) {
+    const now = input.now ?? Date.now;
+    const loadPublicHelpers = input.loadPublicHelpers ?? loadOpenClawWeixinBindHelpers;
+    const persistOperatorBinding = input.bindOperator ?? bindOperator;
+    const persistOperatorRebinding = input.rebindOperator ?? rebindOperator;
+    const loadOperatorBinding = input.readOperatorBinding ?? readOperatorBinding;
+    const clearOperatorBinding = input.resetOperatorBinding ?? resetOperatorBinding;
+    const renderQrTerminal = input.renderQrTerminal ?? renderQrTerminalDefault;
+    const writeLine = input.writeLine ??
+        (async (line) => {
+            process.stdout.write(`${line}\n`);
+        });
+    try {
+        const helpers = await loadPublicHelpers();
+        const started = await Promise.resolve(helpers.qrGateway.loginWithQrStart({
+            source: "menu",
+            action: input.action,
+        }));
+        const qrTerminal = pickQrTerminal(started);
+        const qrUrl = pickQrUrl(started);
+        const qrStartMessage = pickFirstNonEmptyString(started?.message, started?.detail, started?.reason);
+        const sessionKey = pickFirstNonEmptyString(started?.sessionKey);
+        if (!sessionKey) {
+            throw new Error("missing sessionKey from qr start");
+        }
+        if (qrTerminal) {
+            await writeLine(qrTerminal);
+        }
+        else if (qrUrl) {
+            const renderedQr = await renderQrTerminal({ value: qrUrl }).catch(() => undefined);
+            if (renderedQr) {
+                await writeLine(renderedQr);
+            }
+            await writeLine(`QR URL fallback: ${qrUrl}`);
+        }
+        else {
+            throw new Error(qrStartMessage || "invalid qr login result: missing qr code or qr url");
+        }
+        const waited = await Promise.resolve(helpers.qrGateway.loginWithQrWait({
+            timeoutMs: DEFAULT_QR_WAIT_TIMEOUT_MS,
+            sessionKey,
+        }));
+        if (isTimeoutWaitResult(waited)) {
+            throw new Error("qr login timed out before completion");
+        }
+        if (waited &&
+            typeof waited === "object" &&
+            "connected" in waited &&
+            waited.connected === false) {
+            throw new Error("qr login did not complete");
+        }
+        const rawAccountId = pickFirstNonEmptyString(waited?.accountId);
+        if (!rawAccountId) {
+            throw new Error("missing accountId after qr login");
+        }
+        const accountId = normalizeAccountId(rawAccountId);
+        const boundAt = now();
+        const previousOperatorBinding = input.action === "wechat-rebind"
+            ? await loadOperatorBinding()
+            : undefined;
+        const userIdFromWait = pickFirstNonEmptyString(waited?.userId);
+        let menuAccount;
+        let boundUserId = "";
+        const botToken = pickFirstNonEmptyString(waited?.botToken);
+        let shouldRollbackBinding = false;
+        let attemptedOperatorBinding;
+        try {
+            const menuAccountState = {
+                accountId,
+                token: "",
+                baseUrl: "https://ilinkai.weixin.qq.com",
+            };
+            menuAccount = await buildOpenClawMenuAccount({
+                latestAccountState: menuAccountState,
+                accountHelpers: helpers.accountHelpers,
+            });
+            const userId = pickFirstNonEmptyString(menuAccount?.userId, userIdFromWait);
+            if (!userId) {
+                throw new Error("missing userId after qr login");
+            }
+            boundUserId = userId;
+            attemptedOperatorBinding = {
+                wechatAccountId: accountId,
+                userId,
+                boundAt,
+            };
+            if (input.action === "wechat-rebind") {
+                shouldRollbackBinding = true;
+                await persistOperatorRebinding(attemptedOperatorBinding);
+            }
+            else {
+                shouldRollbackBinding = true;
+                await persistOperatorBinding(attemptedOperatorBinding);
+            }
+            const settings = await input.readCommonSettings();
+            const currentNotifications = settings.wechat?.notifications;
+            const notifications = {
+                enabled: currentNotifications?.enabled ?? true,
+                question: currentNotifications?.question ?? true,
+                permission: currentNotifications?.permission ?? true,
+                sessionError: currentNotifications?.sessionError ?? true,
+                retryError: currentNotifications?.retryError ?? true,
+            };
+            settings.wechat = {
+                ...settings.wechat,
+                notifications,
+                primaryBinding: {
+                    accountId,
+                    userId,
+                    name: menuAccount?.name,
+                    enabled: menuAccount?.enabled,
+                    configured: menuAccount?.configured,
+                    boundAt,
+                },
+            };
+            await input.writeCommonSettings(settings);
+            if (botToken) {
+                await writeWechatLatestAccountState({
+                    accountId,
+                    token: botToken,
+                    baseUrl: pickFirstNonEmptyString(waited?.baseUrl, menuAccountState.baseUrl) ?? "https://ilinkai.weixin.qq.com",
+                });
+            }
+        }
+        catch (error) {
+            if (shouldRollbackBinding) {
+                const currentOperatorBinding = await loadOperatorBinding().catch(() => undefined);
+                if (isSameOperatorBinding(currentOperatorBinding, attemptedOperatorBinding)) {
+                    await rollbackBinding(input.action, previousOperatorBinding, persistOperatorRebinding, clearOperatorBinding);
+                }
+            }
+            throw error;
+        }
+        return {
+            accountId,
+            userId: boundUserId,
+            name: menuAccount?.name,
+            enabled: menuAccount?.enabled,
+            configured: menuAccount?.configured,
+            boundAt,
+        };
+    }
+    catch (error) {
+        if (input.action === "wechat-rebind") {
+            throw new Error(`wechat rebind failed: ${toErrorMessage(error)}`);
+        }
+        throw new Error(`wechat bind failed: ${toErrorMessage(error)}`);
+    }
+}

package/dist/wechat/bridge.d.ts

@@ -0,0 +1,136 @@
+import type { Message, Part, PermissionRequest, QuestionAnswer, QuestionRequest, Session, SessionStatus, Todo } from "@opencode-ai/sdk/v2";
+import { connect } from "./broker-client.js";
+import { connectOrSpawnBroker } from "./broker-launcher.js";
+import { type SessionDigest } from "./session-digest.js";
+import type { BrokerEnvelope, ReplyMutationResult, WechatNotificationCandidate } from "./protocol.js";
+type SessionMessages = Array<{
+    info: Message;
+    parts: Part[];
+}>;
+type NotificationCandidateSnapshot = {
+    candidates: WechatNotificationCandidate[];
+    authoritative: boolean;
+};
+type SessionLite = Pick<Session, "id" | "title" | "directory" | "time"> & {
+    parentID?: string;
+};
+type SdkFieldsResult<T> = {
+    data: T | undefined;
+    error?: unknown;
+    request?: unknown;
+    response?: unknown;
+};
+type SdkReadResult<T> = T | SdkFieldsResult<T>;
+type WechatBridgeClient = {
+    session: {
+        list: () => Promise<SdkReadResult<SessionLite[]>>;
+        status: () => Promise<SdkReadResult<Record<string, SessionStatus | undefined>>>;
+        todo: (parameters: {
+            sessionID: string;
+        } | string) => Promise<SdkReadResult<Todo[]>>;
+        messages: (parameters: {
+            sessionID: string;
+            limit?: number;
+        } | string) => Promise<SdkReadResult<SessionMessages>>;
+        reply?: (input: {
+            sessionID: string;
+            text: string;
+        }) => Promise<SdkReadResult<unknown>>;
+    };
+    question: {
+        list: () => Promise<SdkReadResult<QuestionRequest[]>>;
+        reply?: (input: {
+            requestID: string;
+            answers: QuestionAnswer[];
+        }) => Promise<SdkReadResult<unknown>>;
+    };
+    permission: {
+        list: () => Promise<SdkReadResult<PermissionRequest[]>>;
+        reply?: (input: {
+            requestID: string;
+            reply: "once" | "always" | "reject";
+            message?: string;
+        }) => Promise<SdkReadResult<unknown>>;
+    };
+};
+export type InstanceUnavailableKind = "sessionStatus" | "questionList" | "permissionList";
+export type WechatInstanceStatusSnapshot = {
+    instanceID: string;
+    instanceName: string;
+    pid: number;
+    projectName?: string;
+    directory: string;
+    collectedAt: number;
+    sessions: SessionDigest[];
+    unavailable?: InstanceUnavailableKind[];
+};
+export type WechatFallbackToast = {
+    wechatAccountId: string;
+    userId: string;
+    message: string;
+    reason: "deliveryFailed";
+    registrationEpoch?: string;
+};
+export type WechatBridgeInput = {
+    instanceID: string;
+    instanceName: string;
+    pid: number;
+    projectName?: string;
+    directory: string;
+    client: WechatBridgeClient;
+    liveReadTimeoutMs?: number;
+    getActiveSessionID?: () => string | undefined;
+    onDiagnosticEvent?: (event: WechatBridgeDiagnosticEvent) => Promise<void> | void;
+    onFallbackToast?: (payload: WechatFallbackToast) => Promise<void> | void;
+};
+export type WechatBridge = {
+    collectStatusSnapshot: () => Promise<WechatInstanceStatusSnapshot>;
+    collectNotificationCandidates: () => Promise<WechatNotificationCandidate[]>;
+    collectNotificationCandidateSnapshot?: () => Promise<NotificationCandidateSnapshot>;
+    resyncBrokerState?: (input?: {
+        reason?: "brokerReconnect" | "manual";
+    }) => Promise<WechatInstanceStatusSnapshot>;
+    handleBrokerEnvelope?: (envelope: BrokerEnvelope) => Promise<ReplyMutationResult | null>;
+};
+export type WechatBridgeLifecycleInput = {
+    client: WechatBridgeClient;
+    project?: {
+        id?: string;
+        name?: string;
+    };
+    directory?: string;
+    serverUrl?: URL;
+    initialBrokerPromise?: Promise<{
+        endpoint: string;
+    }>;
+    statusCollectionEnabled?: boolean;
+    heartbeatIntervalMs?: number;
+    getActiveSessionID?: () => string | undefined;
+    onFallbackToast?: (payload: WechatFallbackToast) => Promise<void> | void;
+};
+export type WechatBridgeLifecycle = {
+    close: () => Promise<void>;
+};
+type WechatBridgeLifecycleDeps = {
+    connectOrSpawnBrokerImpl?: typeof connectOrSpawnBroker;
+    connectImpl?: typeof connect;
+    setIntervalImpl?: typeof setInterval;
+    clearIntervalImpl?: typeof clearInterval;
+};
+type WechatBridgeDiagnosticEvent = {
+    type: "collectStatusCompleted";
+    instanceID: string;
+    durationMs: number;
+    sessionCount: number;
+    unavailable?: InstanceUnavailableKind[];
+} | {
+    type: "bridgeResyncFailed";
+    code: "bridgeResyncFailed";
+    instanceID: string;
+    reason: "brokerReconnect" | "manual";
+    durationMs: number;
+    error: string;
+};
+export declare function createWechatBridge(input: WechatBridgeInput): WechatBridge;
+export declare function createWechatBridgeLifecycle(input: WechatBridgeLifecycleInput, deps?: WechatBridgeLifecycleDeps): Promise<WechatBridgeLifecycle>;
+export {};