opencode-oncall 0.1.0

package/dist/plugin.js

@@ -0,0 +1,115 @@
+import { appendFile } from "node:fs/promises";
+import { buildPluginHooks, isBridgeCapableBrokerOwnerInput, } from "./plugin-hooks.js";
+import { readWechatSettingsStore } from "./settings-store.js";
+import { buildWechatSettingsMenuEntry, loadWechatMenuItems, } from "./ui/wechat-menu.js";
+import { connectOrSpawnBroker } from "./wechat/broker-launcher.js";
+import { brokerStartupDiagnosticsPath, ensureWechatStateLayout, } from "./wechat/state-paths.js";
+let brokerEnsurePromiseInProcess;
+let brokerEnsureSucceededInProcess = false;
+function toWechatBrokerConnection(value) {
+    if (value &&
+        typeof value === "object" &&
+        typeof value.endpoint === "string") {
+        return { endpoint: value.endpoint };
+    }
+    throw new Error("Wechat broker 启动结果缺少 endpoint");
+}
+function formatBrokerStartupError(error) {
+    if (error instanceof Error)
+        return error.stack ?? `${error.name}: ${error.message}`;
+    if (typeof error === "string")
+        return error;
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+async function recordBrokerStartupFailure(input) {
+    const line = JSON.stringify({
+        at: new Date().toISOString(),
+        provider: "opencode-wechat",
+        reason: formatBrokerStartupError(input.error),
+    });
+    try {
+        await ensureWechatStateLayout();
+        await appendFile(input.diagnosticsPath, `${line}\n`, "utf8");
+    }
+    catch { }
+    try {
+        await input.showToast?.({
+            body: {
+                message: `Wechat broker 启动失败，已写入诊断文件：${input.diagnosticsPath}`,
+                variant: "warning",
+            },
+        });
+    }
+    catch { }
+}
+export function buildWechatPluginMetadata() {
+    return {
+        settingsEntry: buildWechatSettingsMenuEntry(),
+    };
+}
+async function ensureBrokerStarted(input) {
+    if (!brokerEnsurePromiseInProcess) {
+        const starter = input.ensureWechatBrokerStarted ?? connectOrSpawnBroker;
+        const promise = Promise.resolve()
+            .then(() => starter())
+            .then((result) => toWechatBrokerConnection(result))
+            .then((connection) => {
+            brokerEnsureSucceededInProcess = true;
+            return connection;
+        });
+        brokerEnsurePromiseInProcess = promise;
+        void promise
+            .catch((error) => recordBrokerStartupFailure({
+            diagnosticsPath: input.diagnosticsPath,
+            error,
+            showToast: input.showToast,
+        }))
+            .finally(() => {
+            if (brokerEnsurePromiseInProcess === promise)
+                brokerEnsurePromiseInProcess = undefined;
+        });
+    }
+    return brokerEnsurePromiseInProcess;
+}
+export const OpenCodeWechat = async (input) => {
+    const diagnosticsPath = brokerStartupDiagnosticsPath();
+    const testSeams = input;
+    const showToast = testSeams.client?.tui?.showToast;
+    const injectedEnsureBroker = testSeams.ensureWechatBrokerStarted;
+    const createWechatBridgeLifecycleImpl = testSeams.createWechatBridgeLifecycleImpl;
+    await readWechatSettingsStore().catch(() => undefined);
+    await loadWechatMenuItems().catch(() => []);
+    let initialWechatBrokerPromise;
+    if (isBridgeCapableBrokerOwnerInput({
+        client: input.client,
+        serverUrl: input.serverUrl,
+    }) &&
+        !brokerEnsureSucceededInProcess) {
+        initialWechatBrokerPromise = ensureBrokerStarted({
+            ensureWechatBrokerStarted: injectedEnsureBroker,
+            diagnosticsPath,
+            showToast,
+        });
+    }
+    return buildPluginHooks({
+        client: input.client,
+        project: input.project,
+        directory: input.directory,
+        serverUrl: input.serverUrl,
+        initialWechatBrokerPromise,
+        createWechatBridgeLifecycleImpl,
+        onFallbackToast: showToast
+            ? (payload) => showToast({
+                body: {
+                    message: payload.message,
+                    variant: "warning",
+                },
+            }).then(() => undefined)
+            : undefined,
+    });
+};

package/dist/settings-store.d.ts

@@ -0,0 +1,50 @@
+export type WechatBinding = {
+    accountId: string;
+    userId?: string;
+    name?: string;
+    enabled?: boolean;
+    configured?: boolean;
+    boundAt?: number;
+};
+export type WechatSettings = {
+    primaryBinding?: WechatBinding;
+    notifications: {
+        enabled: boolean;
+        question: boolean;
+        permission: boolean;
+        sessionError: boolean;
+        retryError: boolean;
+    };
+    future?: {
+        accounts?: WechatBinding[];
+    };
+};
+export type WechatSettingsStore = {
+    wechat: WechatSettings;
+};
+export type WechatNotificationDispatchSettings = {
+    targetUserId?: string;
+    targetAccountId?: string;
+    notifications: WechatSettings["notifications"];
+};
+export declare function normalizeWechatSettingsStore(input: unknown): WechatSettingsStore;
+export declare function settingsPath(): string;
+export declare function readWechatSettingsStore(options?: {
+    filePath?: string;
+    legacySettingsFilePath?: string;
+}): Promise<WechatSettingsStore>;
+export declare function readWechatSettingsStoreSync(): WechatSettingsStore | undefined;
+export declare function writeWechatSettingsStore(store: WechatSettingsStore, options?: {
+    filePath?: string;
+}): Promise<void>;
+export declare function readWechatNotificationDispatchSettings(options?: {
+    filePath?: string;
+    legacySettingsFilePath?: string;
+}): Promise<WechatNotificationDispatchSettings>;
+export type CommonSettingsStore = WechatSettingsStore;
+export type WechatMenuSettings = WechatSettings;
+export declare const readCommonSettingsStore: typeof readWechatSettingsStore;
+export declare const readCommonSettingsStoreSync: typeof readWechatSettingsStoreSync;
+export declare const writeCommonSettingsStore: typeof writeWechatSettingsStore;
+export declare const commonSettingsPath: typeof settingsPath;
+export declare const normalizeCommonSettingsStore: typeof normalizeWechatSettingsStore;

package/dist/settings-store.js

@@ -0,0 +1,214 @@
+import { constants as fsConstants } from "node:fs";
+import { access, copyFile, mkdir, readdir, readFile, stat, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { opencodeWechatConfigDir, wechatBridgeDiagnosticsPath, wechatBrokerStateStorePath, wechatDeadLetterDir, wechatInstancesDir, wechatLatestAccountPath, wechatLegacyConfigDir, wechatLegacySettingsPath, wechatNotificationsDir, wechatOperatorPath, wechatRequestsDir, wechatSettingsPath, wechatStatusRuntimeDiagnosticsPath, wechatTokensDir, } from "./store-paths.js";
+const STATE_COPY_TARGETS = [
+    ["operator.json", wechatOperatorPath],
+    ["broker-state-store.json", wechatBrokerStateStorePath],
+    ["latest-account.json", wechatLatestAccountPath],
+    ["tokens", wechatTokensDir],
+    ["requests", wechatRequestsDir],
+    ["notifications", wechatNotificationsDir],
+    ["dead-letter", wechatDeadLetterDir],
+    ["instances", wechatInstancesDir],
+    ["wechat-bridge.diagnostics.jsonl", wechatBridgeDiagnosticsPath],
+    [
+        "wechat-status-runtime.diagnostics.jsonl",
+        wechatStatusRuntimeDiagnosticsPath,
+    ],
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function booleanOrDefault(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function normalizeWechatBinding(input) {
+    if (!isRecord(input) ||
+        typeof input.accountId !== "string" ||
+        input.accountId.length === 0) {
+        return undefined;
+    }
+    return {
+        accountId: input.accountId,
+        ...(typeof input.userId === "string" ? { userId: input.userId } : {}),
+        ...(typeof input.name === "string" ? { name: input.name } : {}),
+        ...(typeof input.enabled === "boolean" ? { enabled: input.enabled } : {}),
+        ...(typeof input.configured === "boolean"
+            ? { configured: input.configured }
+            : {}),
+        ...(typeof input.boundAt === "number" && Number.isFinite(input.boundAt)
+            ? { boundAt: input.boundAt }
+            : {}),
+    };
+}
+function normalizeFutureAccounts(input) {
+    if (!isRecord(input) || !Array.isArray(input.accounts))
+        return undefined;
+    const accounts = input.accounts
+        .map((account) => normalizeWechatBinding(account))
+        .filter((account) => Boolean(account));
+    return accounts.length > 0 ? { accounts } : undefined;
+}
+function normalizeWechatSettings(input) {
+    const source = isRecord(input) ? input : {};
+    const notificationsSource = isRecord(source.notifications)
+        ? source.notifications
+        : {};
+    const primaryBinding = normalizeWechatBinding(source.primaryBinding);
+    const future = normalizeFutureAccounts(source.future);
+    return {
+        ...(primaryBinding ? { primaryBinding } : {}),
+        notifications: {
+            enabled: booleanOrDefault(notificationsSource.enabled, true),
+            question: booleanOrDefault(notificationsSource.question, true),
+            permission: booleanOrDefault(notificationsSource.permission, true),
+            sessionError: booleanOrDefault(notificationsSource.sessionError, true),
+            retryError: booleanOrDefault(notificationsSource.retryError, true),
+        },
+        ...(future ? { future } : {}),
+    };
+}
+export function normalizeWechatSettingsStore(input) {
+    const source = isRecord(input) ? input : {};
+    return {
+        wechat: normalizeWechatSettings(source.wechat),
+    };
+}
+function migrateLegacySettings(input) {
+    const source = isRecord(input) ? input : {};
+    const nestedWechat = normalizeWechatSettings(source.wechat);
+    const notificationsSource = isRecord(source.wechat) && isRecord(source.wechat.notifications)
+        ? source.wechat.notifications
+        : {};
+    return {
+        wechat: {
+            ...(nestedWechat.primaryBinding
+                ? { primaryBinding: nestedWechat.primaryBinding }
+                : {}),
+            notifications: {
+                enabled: booleanOrDefault(notificationsSource.enabled, source.wechatNotificationsEnabled !== false),
+                question: booleanOrDefault(notificationsSource.question, source.wechatQuestionNotifyEnabled !== false),
+                permission: booleanOrDefault(notificationsSource.permission, source.wechatPermissionNotifyEnabled !== false),
+                sessionError: booleanOrDefault(notificationsSource.sessionError, source.wechatSessionErrorNotifyEnabled !== false),
+                retryError: booleanOrDefault(notificationsSource.retryError, source.wechatRetryErrorNotifyEnabled !== false),
+            },
+            ...(nestedWechat.future ? { future: nestedWechat.future } : {}),
+        },
+    };
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath, fsConstants.F_OK);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function readJsonFile(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function copyDirectory(source, target) {
+    await mkdir(target, { recursive: true });
+    const entries = await readdir(source, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourcePath = path.join(source, entry.name);
+        const targetPath = path.join(target, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(sourcePath, targetPath);
+            continue;
+        }
+        if (entry.isFile()) {
+            await mkdir(path.dirname(targetPath), { recursive: true });
+            await copyFile(sourcePath, targetPath, fsConstants.COPYFILE_EXCL).catch((error) => {
+                if (error.code !== "EEXIST")
+                    throw error;
+            });
+        }
+    }
+}
+async function copyLegacyPath(relativePath, targetPath) {
+    const sourcePath = path.join(wechatLegacyConfigDir(), relativePath);
+    let info;
+    try {
+        info = await stat(sourcePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    if (info.isDirectory()) {
+        await copyDirectory(sourcePath, targetPath);
+        return;
+    }
+    if (info.isFile()) {
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await copyFile(sourcePath, targetPath, fsConstants.COPYFILE_EXCL).catch((error) => {
+            if (error.code !== "EEXIST")
+                throw error;
+        });
+    }
+}
+async function migrateLegacyWechatState() {
+    await mkdir(opencodeWechatConfigDir(), { recursive: true });
+    for (const [relativePath, targetPath] of STATE_COPY_TARGETS) {
+        await copyLegacyPath(relativePath, targetPath());
+    }
+}
+export function settingsPath() {
+    return wechatSettingsPath();
+}
+export async function readWechatSettingsStore(options) {
+    const filePath = options?.filePath ?? wechatSettingsPath();
+    const current = await readJsonFile(filePath);
+    if (current !== undefined) {
+        return normalizeWechatSettingsStore(current);
+    }
+    const legacyFilePath = options?.legacySettingsFilePath ?? wechatLegacySettingsPath();
+    const legacy = await readJsonFile(legacyFilePath);
+    const migrated = migrateLegacySettings(legacy);
+    if (legacy !== undefined || (await pathExists(wechatLegacyConfigDir()))) {
+        await migrateLegacyWechatState();
+        await writeWechatSettingsStore(migrated, { filePath });
+    }
+    return migrated;
+}
+export function readWechatSettingsStoreSync() {
+    return undefined;
+}
+export async function writeWechatSettingsStore(store, options) {
+    const filePath = options?.filePath ?? wechatSettingsPath();
+    const normalized = normalizeWechatSettingsStore(store);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(normalized, null, 2), {
+        mode: 0o600,
+    });
+}
+export async function readWechatNotificationDispatchSettings(options) {
+    const settings = await readWechatSettingsStore(options);
+    return {
+        ...(typeof settings.wechat.primaryBinding?.userId === "string"
+            ? { targetUserId: settings.wechat.primaryBinding.userId }
+            : {}),
+        ...(typeof settings.wechat.primaryBinding?.accountId === "string"
+            ? { targetAccountId: settings.wechat.primaryBinding.accountId }
+            : {}),
+        notifications: settings.wechat.notifications,
+    };
+}
+export const readCommonSettingsStore = readWechatSettingsStore;
+export const readCommonSettingsStoreSync = readWechatSettingsStoreSync;
+export const writeCommonSettingsStore = writeWechatSettingsStore;
+export const commonSettingsPath = settingsPath;
+export const normalizeCommonSettingsStore = normalizeWechatSettingsStore;

package/dist/store-paths.d.ts

@@ -0,0 +1,16 @@
+export declare function opencodeWechatConfigDir(): string;
+export declare function wechatSettingsPath(): string;
+export declare function wechatLegacySettingsPath(): string;
+export declare function wechatLegacyConfigDir(): string;
+export declare function wechatOperatorPath(): string;
+export declare function wechatBrokerStateStorePath(): string;
+export declare function wechatLatestAccountPath(): string;
+export declare function wechatRequestsDir(): string;
+export declare function wechatNotificationsDir(): string;
+export declare function wechatDeadLetterDir(): string;
+export declare function wechatInstancesDir(): string;
+export declare function wechatTokensDir(): string;
+export declare function wechatBridgeDiagnosticsPath(): string;
+export declare function wechatStatusRuntimeDiagnosticsPath(): string;
+export declare function commonSettingsPath(): string;
+export declare function wechatConfigDir(): string;

package/dist/store-paths.js

@@ -0,0 +1,61 @@
+import os from "node:os";
+import path from "node:path";
+import { xdgConfig } from "xdg-basedir";
+function configBaseDir() {
+    const override = process.env.XDG_CONFIG_HOME;
+    if (typeof override === "string" && override.trim().length > 0) {
+        return override.trim();
+    }
+    return xdgConfig ?? path.join(os.homedir(), ".config");
+}
+function opencodeConfigDir() {
+    return path.join(configBaseDir(), "opencode");
+}
+export function opencodeWechatConfigDir() {
+    return path.join(opencodeConfigDir(), "opencode-wechat");
+}
+export function wechatSettingsPath() {
+    return path.join(opencodeWechatConfigDir(), "settings.json");
+}
+export function wechatLegacySettingsPath() {
+    return path.join(opencodeConfigDir(), "account-switcher", "settings.json");
+}
+export function wechatLegacyConfigDir() {
+    return path.join(opencodeConfigDir(), "account-switcher", "wechat");
+}
+export function wechatOperatorPath() {
+    return path.join(opencodeWechatConfigDir(), "operator.json");
+}
+export function wechatBrokerStateStorePath() {
+    return path.join(opencodeWechatConfigDir(), "broker-state-store.json");
+}
+export function wechatLatestAccountPath() {
+    return path.join(opencodeWechatConfigDir(), "latest-account.json");
+}
+export function wechatRequestsDir() {
+    return path.join(opencodeWechatConfigDir(), "requests");
+}
+export function wechatNotificationsDir() {
+    return path.join(opencodeWechatConfigDir(), "notifications");
+}
+export function wechatDeadLetterDir() {
+    return path.join(opencodeWechatConfigDir(), "dead-letter");
+}
+export function wechatInstancesDir() {
+    return path.join(opencodeWechatConfigDir(), "instances");
+}
+export function wechatTokensDir() {
+    return path.join(opencodeWechatConfigDir(), "tokens");
+}
+export function wechatBridgeDiagnosticsPath() {
+    return path.join(opencodeWechatConfigDir(), "wechat-bridge.diagnostics.jsonl");
+}
+export function wechatStatusRuntimeDiagnosticsPath() {
+    return path.join(opencodeWechatConfigDir(), "wechat-status-runtime.diagnostics.jsonl");
+}
+export function commonSettingsPath() {
+    return wechatSettingsPath();
+}
+export function wechatConfigDir() {
+    return opencodeWechatConfigDir();
+}

package/dist/ui/wechat-menu.d.ts

@@ -0,0 +1,26 @@
+import type { WechatSettingsStore } from "../settings-store.js";
+import type { OperatorBinding } from "../wechat/operator-store.js";
+export type WechatSettingsMenuEntry = {
+    title: "OpenCode WeChat";
+    value: "opencode-wechat.settings";
+    category: "OpenCode";
+};
+export type WechatMenuActionType = "wechat-bind" | "wechat-rebind" | "toggle-wechat-notifications" | "toggle-wechat-question-notifications" | "toggle-wechat-permission-notifications" | "toggle-wechat-session-error-notifications" | "toggle-wechat-retry-error-notifications" | "wechat-export-debug-bundle-sanitized" | "wechat-export-debug-bundle-full" | "wechat-openclaw-dry-run-command";
+export type WechatMenuItem = {
+    label: string;
+    value: WechatMenuActionType | "noop";
+    hint?: string;
+    disabled?: boolean;
+};
+export type BuildWechatMenuInput = {
+    settings?: WechatSettingsStore;
+    operatorBinding?: OperatorBinding;
+    readSettings?: () => Promise<WechatSettingsStore>;
+    readOperatorBinding?: () => Promise<OperatorBinding | undefined>;
+};
+export declare function buildWechatSettingsMenuEntry(): WechatSettingsMenuEntry;
+export declare function buildWechatMenuItems(input: {
+    settings: WechatSettingsStore;
+    operatorBinding?: OperatorBinding;
+}): WechatMenuItem[];
+export declare function loadWechatMenuItems(input?: BuildWechatMenuInput): Promise<WechatMenuItem[]>;

package/dist/ui/wechat-menu.js

@@ -0,0 +1,90 @@
+import { readWechatSettingsStore } from "../settings-store.js";
+import { readOperatorBinding } from "../wechat/operator-store.js";
+function enabledLabel(value) {
+    return value ? "已开启" : "已关闭";
+}
+function bindingRows(binding) {
+    if (!binding) {
+        return [{ label: "当前绑定状态：未绑定", value: "noop", disabled: true }];
+    }
+    const accountId = "accountId" in binding ? binding.accountId : binding.wechatAccountId;
+    return [
+        { label: "当前绑定状态：已绑定", value: "noop", disabled: true },
+        { label: `accountId: ${accountId}`, value: "noop", disabled: true },
+        ...("name" in binding && binding.name
+            ? [
+                {
+                    label: `name: ${binding.name}`,
+                    value: "noop",
+                    disabled: true,
+                },
+            ]
+            : []),
+        ...(binding.userId
+            ? [
+                {
+                    label: `userId: ${binding.userId}`,
+                    value: "noop",
+                    disabled: true,
+                },
+            ]
+            : []),
+    ];
+}
+export function buildWechatSettingsMenuEntry() {
+    return {
+        title: "OpenCode WeChat",
+        value: "opencode-wechat.settings",
+        category: "OpenCode",
+    };
+}
+export function buildWechatMenuItems(input) {
+    const notifications = input.settings.wechat.notifications;
+    const binding = input.settings.wechat.primaryBinding ?? input.operatorBinding;
+    const bindAction = binding
+        ? "wechat-rebind"
+        : "wechat-bind";
+    return [
+        ...bindingRows(binding),
+        { label: binding ? "重绑微信" : "绑定微信", value: bindAction },
+        {
+            label: `微信通知总开关：${enabledLabel(notifications.enabled)}`,
+            value: "toggle-wechat-notifications",
+        },
+        {
+            label: `question 通知：${enabledLabel(notifications.question)}`,
+            value: "toggle-wechat-question-notifications",
+        },
+        {
+            label: `permission 通知：${enabledLabel(notifications.permission)}`,
+            value: "toggle-wechat-permission-notifications",
+        },
+        {
+            label: `session error 通知：${enabledLabel(notifications.sessionError)}`,
+            value: "toggle-wechat-session-error-notifications",
+        },
+        {
+            label: `retry-error 通知：${enabledLabel(notifications.retryError)}`,
+            value: "toggle-wechat-retry-error-notifications",
+        },
+        {
+            label: "导出脱敏 debug bundle",
+            value: "wechat-export-debug-bundle-sanitized",
+        },
+        {
+            label: "导出完整 debug bundle",
+            value: "wechat-export-debug-bundle-full",
+        },
+        {
+            label: "显示 OpenClaw dry-run 命令",
+            value: "wechat-openclaw-dry-run-command",
+            hint: "npm run wechat:smoke:real-account -- --dry-run",
+        },
+    ];
+}
+export async function loadWechatMenuItems(input = {}) {
+    const settings = input.settings ?? (await (input.readSettings ?? readWechatSettingsStore)());
+    const operatorBinding = input.operatorBinding ??
+        (await (input.readOperatorBinding ?? readOperatorBinding)());
+    return buildWechatMenuItems({ settings, operatorBinding });
+}

package/dist/wechat/bind-flow.d.ts

@@ -0,0 +1,29 @@
+import type { WechatSettingsStore } from "../settings-store.js";
+import { loadOpenClawWeixinBindHelpers } from "./compat/openclaw-bind-helpers.js";
+import { bindOperator, readOperatorBinding, rebindOperator, resetOperatorBinding } from "./operator-store.js";
+type BindAction = "wechat-bind" | "wechat-rebind";
+type WechatBindFlowResult = {
+    accountId: string;
+    userId: string;
+    name?: string;
+    enabled?: boolean;
+    configured?: boolean;
+    boundAt: number;
+};
+type WechatBindFlowInput = {
+    action: BindAction;
+    loadPublicHelpers?: typeof loadOpenClawWeixinBindHelpers;
+    bindOperator?: typeof bindOperator;
+    rebindOperator?: typeof rebindOperator;
+    readOperatorBinding?: typeof readOperatorBinding;
+    resetOperatorBinding?: typeof resetOperatorBinding;
+    readCommonSettings: () => Promise<WechatSettingsStore>;
+    writeCommonSettings: (settings: WechatSettingsStore) => Promise<void>;
+    writeLine?: (line: string) => Promise<void>;
+    renderQrTerminal?: (input: {
+        value: string;
+    }) => Promise<string | undefined>;
+    now?: () => number;
+};
+export declare function runWechatBindFlow(input: WechatBindFlowInput): Promise<WechatBindFlowResult>;
+export {};