opencode-copilot-account-switcher 0.13.6 → 0.14.0

package/dist/wechat/bridge.js

@@ -0,0 +1,180 @@
+import { connect } from "./broker-client.js";
+import { connectOrSpawnBroker } from "./broker-launcher.js";
+import { buildSessionDigest, groupPermissionsBySession, groupQuestionsBySession, pickRecentSessions, } from "./session-digest.js";
+const DEFAULT_LIVE_READ_TIMEOUT_MS = 2_000;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 10_000;
+function toSafeInstanceID(input) {
+    const normalized = input.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+    if (normalized.length === 0) {
+        return `wechat-${process.pid}`;
+    }
+    return normalized.slice(0, 64);
+}
+function toProjectName(project) {
+    if (typeof project?.name === "string" && project.name.trim().length > 0) {
+        return project.name.trim();
+    }
+    if (typeof project?.id === "string" && project.id.trim().length > 0) {
+        return project.id.trim();
+    }
+    return undefined;
+}
+function toDirectory(inputDirectory) {
+    if (typeof inputDirectory === "string" && inputDirectory.trim().length > 0) {
+        return inputDirectory;
+    }
+    return process.cwd();
+}
+function toInstanceName(projectName, directory) {
+    if (projectName) {
+        return projectName;
+    }
+    const parts = directory.split(/[\\/]+/).filter((part) => part.length > 0);
+    return parts.at(-1) ?? `wechat-${process.pid}`;
+}
+function toInstanceID(projectName, directory) {
+    const seed = projectName ?? directory;
+    return toSafeInstanceID(seed);
+}
+function withTimeout(task, timeoutMs, name) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(new Error(`${name} timed out in ${timeoutMs}ms`));
+        }, timeoutMs);
+        void Promise.resolve()
+            .then(task)
+            .then((value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        })
+            .catch((error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+export function createWechatBridge(input) {
+    const collectStatusSnapshot = async () => {
+        const liveReadTimeoutMs = typeof input.liveReadTimeoutMs === "number" && Number.isFinite(input.liveReadTimeoutMs)
+            ? Math.max(1, Math.floor(input.liveReadTimeoutMs))
+            : DEFAULT_LIVE_READ_TIMEOUT_MS;
+        const unavailable = new Set();
+        const [sessionListResult, statusResult, questionResult, permissionResult] = await Promise.allSettled([
+            withTimeout(() => input.client.session.list(), liveReadTimeoutMs, "session.list"),
+            withTimeout(() => input.client.session.status(), liveReadTimeoutMs, "session.status"),
+            withTimeout(() => input.client.question.list(), liveReadTimeoutMs, "question.list"),
+            withTimeout(() => input.client.permission.list(), liveReadTimeoutMs, "permission.list"),
+        ]);
+        const sessions = sessionListResult.status === "fulfilled" ? sessionListResult.value : [];
+        const recentSessions = pickRecentSessions(sessions, 3);
+        if (sessionListResult.status === "rejected") {
+            unavailable.add("sessionStatus");
+        }
+        const statusBySession = statusResult.status === "fulfilled"
+            ? statusResult.value
+            : (unavailable.add("sessionStatus"), {});
+        const questionsBySession = questionResult.status === "fulfilled"
+            ? groupQuestionsBySession(questionResult.value)
+            : (unavailable.add("questionList"), groupQuestionsBySession([]));
+        const permissionsBySession = permissionResult.status === "fulfilled"
+            ? groupPermissionsBySession(permissionResult.value)
+            : (unavailable.add("permissionList"), groupPermissionsBySession([]));
+        const sessionDigests = await Promise.all(recentSessions.map(async (session) => {
+            const [todoResult, messagesResult] = await Promise.allSettled([
+                withTimeout(() => input.client.session.todo(session.id), liveReadTimeoutMs, `session.todo:${session.id}`),
+                withTimeout(() => input.client.session.messages(session.id), liveReadTimeoutMs, `session.messages:${session.id}`),
+            ]);
+            const sessionUnavailable = [];
+            const todos = todoResult.status === "fulfilled" ? todoResult.value : (sessionUnavailable.push("todo"), []);
+            const messages = messagesResult.status === "fulfilled"
+                ? messagesResult.value
+                : (sessionUnavailable.push("messages"), []);
+            return buildSessionDigest({
+                session,
+                statusBySession,
+                questionsBySession,
+                permissionsBySession,
+                todos,
+                messages,
+                unavailable: sessionUnavailable,
+            });
+        }));
+        return {
+            instanceID: input.instanceID,
+            instanceName: input.instanceName,
+            pid: input.pid,
+            projectName: input.projectName,
+            directory: input.directory,
+            collectedAt: Date.now(),
+            sessions: sessionDigests,
+            unavailable: unavailable.size > 0 ? [...unavailable] : undefined,
+        };
+    };
+    return {
+        collectStatusSnapshot,
+    };
+}
+export async function createWechatBridgeLifecycle(input, deps = {}) {
+    if (input.statusCollectionEnabled !== true) {
+        return {
+            close: async () => { },
+        };
+    }
+    const connectOrSpawnBrokerImpl = deps.connectOrSpawnBrokerImpl ?? connectOrSpawnBroker;
+    const connectImpl = deps.connectImpl ?? connect;
+    const setIntervalImpl = deps.setIntervalImpl ?? setInterval;
+    const clearIntervalImpl = deps.clearIntervalImpl ?? clearInterval;
+    const directory = toDirectory(input.directory);
+    const projectName = toProjectName(input.project);
+    const instanceID = toInstanceID(projectName, directory);
+    const bridge = createWechatBridge({
+        instanceID,
+        instanceName: toInstanceName(projectName, directory),
+        pid: process.pid,
+        projectName,
+        directory,
+        client: input.client,
+    });
+    const broker = await connectOrSpawnBrokerImpl();
+    const brokerClient = await connectImpl(broker.endpoint, { bridge });
+    try {
+        await brokerClient.registerInstance({
+            instanceID,
+            pid: process.pid,
+        });
+    }
+    catch (error) {
+        await brokerClient.close().catch(() => { });
+        throw error;
+    }
+    const heartbeatIntervalMs = typeof input.heartbeatIntervalMs === "number" && Number.isFinite(input.heartbeatIntervalMs)
+        ? Math.max(1_000, Math.floor(input.heartbeatIntervalMs))
+        : DEFAULT_HEARTBEAT_INTERVAL_MS;
+    const timer = setIntervalImpl(() => {
+        void brokerClient.heartbeat().catch(() => { });
+    }, heartbeatIntervalMs);
+    let closed = false;
+    return {
+        close: async () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            clearIntervalImpl(timer);
+            await brokerClient.close().catch(() => { });
+        },
+    };
+}

package/dist/wechat/broker-client.d.ts

@@ -0,0 +1,33 @@
+import { type BrokerEnvelope } from "./protocol.js";
+import type { WechatBridge } from "./bridge.js";
+type RegisterMeta = {
+    instanceID: string;
+    pid: number;
+};
+export type RegisterAck = {
+    sessionToken: string;
+    registeredAt: number;
+    brokerPid: number;
+};
+type SessionSnapshot = {
+    instanceID: string;
+    sessionToken: string;
+    registeredAt: number;
+    brokerPid: number;
+};
+type BrokerClient = {
+    ping: () => Promise<BrokerEnvelope>;
+    registerInstance: (meta: RegisterMeta) => Promise<RegisterAck>;
+    heartbeat: () => Promise<BrokerEnvelope>;
+    getSessionSnapshot: () => SessionSnapshot | null;
+    close: () => Promise<void>;
+};
+export type CollectStatusInput = {
+    requestId: string;
+};
+export type BrokerClientOptions = {
+    onCollectStatus?: (input: CollectStatusInput) => Promise<unknown> | unknown;
+    bridge?: WechatBridge;
+};
+export declare function connect(endpoint: string, options?: BrokerClientOptions): Promise<BrokerClient>;
+export {};

package/dist/wechat/broker-client.js

@@ -0,0 +1,257 @@
+import net from "node:net";
+import { parseEnvelopeLine, serializeEnvelope, } from "./protocol.js";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isResponseForRequest(response, requestId) {
+    if (response.id === requestId) {
+        return true;
+    }
+    if (response.id.endsWith(`-${requestId}`)) {
+        return true;
+    }
+    if (response.type === "error") {
+        const payload = response.payload;
+        return payload.requestId === requestId;
+    }
+    return false;
+}
+export async function connect(endpoint, options = {}) {
+    if (options.bridge && options.onCollectStatus) {
+        throw new Error("broker client options are ambiguous: provide either bridge or onCollectStatus");
+    }
+    const socket = net.createConnection(endpoint);
+    let sequence = 0;
+    let pendingResolve = null;
+    let pendingReject = null;
+    let pendingRequestId = null;
+    let buffer = "";
+    let connected = false;
+    let closed = false;
+    let session = null;
+    const connectedReady = new Promise((resolve, reject) => {
+        socket.once("connect", () => {
+            connected = true;
+            resolve();
+        });
+        socket.once("error", reject);
+    });
+    socket.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                break;
+            }
+            const frame = buffer.slice(0, newlineIndex + 1);
+            buffer = buffer.slice(newlineIndex + 1);
+            if (pendingResolve) {
+                try {
+                    const parsed = parseEnvelopeLine(frame);
+                    if (parsed.type === "collectStatus") {
+                        handleCollectStatus(parsed);
+                        continue;
+                    }
+                    if (pendingRequestId && !isResponseForRequest(parsed, pendingRequestId)) {
+                        continue;
+                    }
+                    const resolve = pendingResolve;
+                    pendingResolve = null;
+                    pendingReject = null;
+                    pendingRequestId = null;
+                    resolve(parsed);
+                }
+                catch (error) {
+                    const reject = pendingReject;
+                    pendingResolve = null;
+                    pendingReject = null;
+                    pendingRequestId = null;
+                    reject?.(error);
+                }
+            }
+            else {
+                try {
+                    const parsed = parseEnvelopeLine(frame);
+                    if (parsed.type === "collectStatus") {
+                        handleCollectStatus(parsed);
+                    }
+                }
+                catch {
+                    // ignore unsolicited invalid frames when no pending request exists
+                }
+            }
+        }
+    });
+    socket.on("error", (error) => {
+        if (pendingReject) {
+            const reject = pendingReject;
+            pendingResolve = null;
+            pendingReject = null;
+            pendingRequestId = null;
+            reject(error);
+        }
+    });
+    socket.on("close", () => {
+        connected = false;
+        closed = true;
+        session = null;
+        if (pendingReject) {
+            const reject = pendingReject;
+            pendingResolve = null;
+            pendingReject = null;
+            pendingRequestId = null;
+            reject(new Error("broker connection closed"));
+        }
+    });
+    await connectedReady;
+    function nextRequestId(prefix) {
+        sequence += 1;
+        return `${prefix}-${Date.now()}-${sequence}`;
+    }
+    function sendStatusSnapshot(requestId, snapshot) {
+        if (!session) {
+            return;
+        }
+        const envelope = {
+            id: nextRequestId("statusSnapshot"),
+            type: "statusSnapshot",
+            instanceID: session.instanceID,
+            sessionToken: session.sessionToken,
+            payload: {
+                requestId,
+                snapshot,
+            },
+        };
+        socket.write(serializeEnvelope(envelope));
+    }
+    function handleCollectStatus(envelope) {
+        const payload = envelope.payload;
+        if (!isNonEmptyString(payload.requestId)) {
+            return;
+        }
+        const hasBridge = options.bridge !== undefined;
+        const hasHook = options.onCollectStatus !== undefined;
+        if (!hasBridge && !hasHook) {
+            return;
+        }
+        const collectPromise = hasBridge
+            ? options.bridge.collectStatusSnapshot()
+            : options.onCollectStatus({ requestId: payload.requestId });
+        void Promise.resolve(collectPromise)
+            .then((snapshot) => {
+            sendStatusSnapshot(payload.requestId, snapshot);
+        })
+            .catch(() => {
+            // swallow collect handler errors to keep socket alive
+        });
+    }
+    async function send(envelope) {
+        if (!connected || closed) {
+            throw new Error("broker connection closed");
+        }
+        if (pendingResolve) {
+            throw new Error("broker client has pending request");
+        }
+        return new Promise((resolve, reject) => {
+            pendingResolve = resolve;
+            pendingReject = reject;
+            pendingRequestId = envelope.id;
+            socket.write(serializeEnvelope(envelope));
+        });
+    }
+    return {
+        async ping() {
+            return send({
+                id: nextRequestId("ping"),
+                type: "ping",
+                payload: {},
+            });
+        },
+        async registerInstance(meta) {
+            const instanceID = meta.instanceID;
+            if (!isNonEmptyString(instanceID)) {
+                throw new Error("invalid instanceID");
+            }
+            if (!isFiniteNumber(meta.pid)) {
+                throw new Error("invalid pid");
+            }
+            const response = await send({
+                id: nextRequestId("register"),
+                type: "registerInstance",
+                instanceID,
+                payload: { pid: meta.pid },
+            });
+            if (response.type !== "registerAck") {
+                throw new Error("register failed");
+            }
+            const payload = response.payload;
+            if (!isNonEmptyString(payload.sessionToken)) {
+                throw new Error("registerAck missing sessionToken");
+            }
+            if (!isFiniteNumber(payload.registeredAt)) {
+                throw new Error("registerAck missing registeredAt");
+            }
+            if (!isFiniteNumber(payload.brokerPid)) {
+                throw new Error("registerAck missing brokerPid");
+            }
+            session = {
+                instanceID,
+                sessionToken: payload.sessionToken,
+                registeredAt: payload.registeredAt,
+                brokerPid: payload.brokerPid,
+            };
+            return {
+                sessionToken: session.sessionToken,
+                registeredAt: session.registeredAt,
+                brokerPid: session.brokerPid,
+            };
+        },
+        async heartbeat() {
+            if (!session) {
+                throw new Error("missing broker session");
+            }
+            return send({
+                id: nextRequestId("heartbeat"),
+                type: "heartbeat",
+                instanceID: session.instanceID,
+                sessionToken: session.sessionToken,
+                payload: {},
+            });
+        },
+        getSessionSnapshot() {
+            if (!session) {
+                return null;
+            }
+            return { ...session };
+        },
+        async close() {
+            if (closed) {
+                return;
+            }
+            if (socket.destroyed) {
+                closed = true;
+                connected = false;
+                session = null;
+                return;
+            }
+            const closePromise = new Promise((resolve) => {
+                socket.once("close", () => resolve());
+            });
+            socket.end();
+            await Promise.race([
+                closePromise,
+                new Promise((resolve) => {
+                    setTimeout(() => {
+                        if (!socket.destroyed) {
+                            socket.destroy();
+                        }
+                        resolve();
+                    }, 200);
+                }),
+            ]);
+        },
+    };
+}

package/dist/wechat/broker-entry.d.ts

@@ -0,0 +1,17 @@
+import { type WechatStatusRuntime } from "./wechat-status-runtime.js";
+type BrokerWechatStatusRuntimeLifecycle = {
+    start: () => Promise<void>;
+    close: () => Promise<void>;
+};
+type BrokerWechatStatusRuntimeLifecycleDeps = {
+    createStatusRuntime?: (deps: {
+        onSlashCommand: (input: {
+            command: import("./command-parser.js").WechatSlashCommand;
+        }) => Promise<string>;
+    }) => WechatStatusRuntime;
+    handleWechatSlashCommand?: (command: import("./command-parser.js").WechatSlashCommand) => Promise<string>;
+    onRuntimeError?: (error: unknown) => void;
+};
+export declare function shouldEnableBrokerWechatStatusRuntime(env?: NodeJS.ProcessEnv): boolean;
+export declare function createBrokerWechatStatusRuntimeLifecycle(deps?: BrokerWechatStatusRuntimeLifecycleDeps): BrokerWechatStatusRuntimeLifecycle;
+export {};

package/dist/wechat/broker-entry.js

@@ -0,0 +1,182 @@
+import path from "node:path";
+import process from "node:process";
+import { readFileSync, rmSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { startBrokerServer } from "./broker-server.js";
+import { WECHAT_FILE_MODE, wechatStateRoot } from "./state-paths.js";
+import { createWechatStatusRuntime } from "./wechat-status-runtime.js";
+async function readPackageVersion() {
+    const packageJsonPath = new URL("../../package.json", import.meta.url);
+    return readFile(packageJsonPath, "utf8")
+        .then((raw) => {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version === "string" && parsed.version.trim().length > 0) {
+            return parsed.version;
+        }
+        return "unknown";
+    })
+        .catch(() => "unknown");
+}
+function parseEndpointArg(argv) {
+    const prefix = "--endpoint=";
+    const endpointArg = argv.find((item) => item.startsWith(prefix));
+    if (!endpointArg) {
+        throw new Error("missing --endpoint argument");
+    }
+    const endpoint = endpointArg.slice(prefix.length);
+    if (!endpoint) {
+        throw new Error("missing --endpoint argument");
+    }
+    return endpoint;
+}
+function parseStateRootArg(argv) {
+    const prefix = "--state-root=";
+    const arg = argv.find((item) => item.startsWith(prefix));
+    if (!arg) {
+        return wechatStateRoot();
+    }
+    const stateRoot = arg.slice(prefix.length);
+    if (!stateRoot) {
+        throw new Error("missing --state-root argument");
+    }
+    return stateRoot;
+}
+function brokerStatePathForRoot(stateRoot) {
+    return path.join(stateRoot, "broker.json");
+}
+async function writeBrokerState(state, stateRoot) {
+    await mkdir(stateRoot, { recursive: true, mode: 0o700 });
+    const filePath = brokerStatePathForRoot(stateRoot);
+    await writeFile(filePath, JSON.stringify(state, null, 2), { mode: WECHAT_FILE_MODE });
+}
+export function shouldEnableBrokerWechatStatusRuntime(env = process.env) {
+    return env.WECHAT_BROKER_ENABLE_STATUS_RUNTIME === "1";
+}
+export function createBrokerWechatStatusRuntimeLifecycle(deps = {}) {
+    const onRuntimeError = deps.onRuntimeError ?? ((error) => console.error(error));
+    const handleWechatSlashCommand = deps.handleWechatSlashCommand ??
+        (async (command) => {
+            if (command.type === "status") {
+                return "命令暂未实现：/status";
+            }
+            return `命令暂未实现：/${command.command}`;
+        });
+    const createStatusRuntime = deps.createStatusRuntime ??
+        ((statusRuntimeDeps) => createWechatStatusRuntime({
+            onSlashCommand: async ({ command }) => statusRuntimeDeps.onSlashCommand({ command }),
+            onRuntimeError,
+        }));
+    let runtime = null;
+    return {
+        start: async () => {
+            if (runtime) {
+                return;
+            }
+            const created = createStatusRuntime({
+                onSlashCommand: async ({ command }) => handleWechatSlashCommand(command),
+            });
+            runtime = created;
+            try {
+                await created.start();
+            }
+            catch (error) {
+                onRuntimeError(error);
+            }
+        },
+        close: async () => {
+            if (!runtime) {
+                return;
+            }
+            const active = runtime;
+            runtime = null;
+            await active.close().catch((error) => {
+                onRuntimeError(error);
+            });
+        },
+    };
+}
+function removeOwnedBrokerStateFileSync(ownership, stateRoot) {
+    try {
+        const filePath = brokerStatePathForRoot(stateRoot);
+        const raw = readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.pid !== ownership.pid || parsed.startedAt !== ownership.startedAt) {
+            return;
+        }
+        rmSync(filePath, { force: true });
+    }
+    catch {
+        // ignore cleanup errors on shutdown
+    }
+}
+async function run() {
+    const args = process.argv.slice(2);
+    const endpoint = parseEndpointArg(args);
+    const stateRoot = parseStateRootArg(args);
+    const server = await startBrokerServer(endpoint);
+    const version = await readPackageVersion();
+    const state = {
+        pid: process.pid,
+        endpoint: server.endpoint,
+        startedAt: server.startedAt,
+        version,
+    };
+    await writeBrokerState(state, stateRoot);
+    const wechatRuntimeLifecycle = createBrokerWechatStatusRuntimeLifecycle({
+        handleWechatSlashCommand: server.handleWechatSlashCommand,
+    });
+    if (shouldEnableBrokerWechatStatusRuntime()) {
+        await wechatRuntimeLifecycle.start();
+    }
+    const ownership = {
+        pid: state.pid,
+        startedAt: state.startedAt,
+    };
+    let shuttingDown = false;
+    const shutdown = async (exitCode = 0) => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        removeOwnedBrokerStateFileSync(ownership, stateRoot);
+        await wechatRuntimeLifecycle.close();
+        await server.close();
+        process.exit(exitCode);
+    };
+    process.once("SIGINT", () => {
+        void shutdown(0);
+    });
+    process.once("SIGTERM", () => {
+        void shutdown(0);
+    });
+    if (process.env.WECHAT_BROKER_EXIT_ON_STDIN_EOF === "1") {
+        process.stdin.on("end", () => {
+            void shutdown(0);
+        });
+        process.stdin.resume();
+    }
+    process.once("uncaughtException", (error) => {
+        console.error(error);
+        void shutdown(1);
+    });
+    process.once("unhandledRejection", (error) => {
+        console.error(error);
+        void shutdown(1);
+    });
+    process.on("exit", () => {
+        removeOwnedBrokerStateFileSync(ownership, stateRoot);
+    });
+}
+function isDirectRun() {
+    if (!process.argv[1]) {
+        return false;
+    }
+    return path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
+}
+if (isDirectRun()) {
+    void run().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/wechat/broker-launcher.d.ts

@@ -0,0 +1,27 @@
+type BrokerMetadata = {
+    pid: number;
+    endpoint: string;
+    startedAt: number;
+    version: string;
+};
+type LaunchLockContent = {
+    pid: number;
+    acquiredAt: number;
+    lockId: string;
+};
+type LaunchOptions = {
+    stateRoot?: string;
+    brokerJsonPath?: string;
+    launchLockPath?: string;
+    backoffMs?: number;
+    maxAttempts?: number;
+    endpointFactory?: () => string;
+    spawnImpl?: (endpoint: string, stateRoot: string) => {
+        pid?: number | undefined;
+        unref?: (() => void) | undefined;
+    };
+    pingImpl?: (endpoint: string) => Promise<boolean>;
+    onLockAcquired?: (lock: LaunchLockContent) => void;
+};
+export declare function connectOrSpawnBroker(options?: LaunchOptions): Promise<BrokerMetadata>;
+export {};