opencode-copilot-account-switcher 0.13.5 → 0.14.0

package/dist/wechat/bridge.d.ts

@@ -0,0 +1,69 @@
+import type { Message, Part, PermissionRequest, 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";
+type SessionMessages = Array<{
+    info: Message;
+    parts: Part[];
+}>;
+type SessionLite = Pick<Session, "id" | "title" | "directory" | "time">;
+type WechatBridgeClient = {
+    session: {
+        list: () => Promise<SessionLite[]>;
+        status: () => Promise<Record<string, SessionStatus | undefined>>;
+        todo: (sessionID: string) => Promise<Todo[]>;
+        messages: (sessionID: string) => Promise<SessionMessages>;
+    };
+    question: {
+        list: () => Promise<QuestionRequest[]>;
+    };
+    permission: {
+        list: () => Promise<PermissionRequest[]>;
+    };
+};
+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 WechatBridgeInput = {
+    instanceID: string;
+    instanceName: string;
+    pid: number;
+    projectName?: string;
+    directory: string;
+    client: WechatBridgeClient;
+    liveReadTimeoutMs?: number;
+};
+export type WechatBridge = {
+    collectStatusSnapshot: () => Promise<WechatInstanceStatusSnapshot>;
+};
+export type WechatBridgeLifecycleInput = {
+    client: WechatBridgeClient;
+    project?: {
+        id?: string;
+        name?: string;
+    };
+    directory?: string;
+    serverUrl?: URL;
+    statusCollectionEnabled?: boolean;
+    heartbeatIntervalMs?: number;
+};
+export type WechatBridgeLifecycle = {
+    close: () => Promise<void>;
+};
+type WechatBridgeLifecycleDeps = {
+    connectOrSpawnBrokerImpl?: typeof connectOrSpawnBroker;
+    connectImpl?: typeof connect;
+    setIntervalImpl?: typeof setInterval;
+    clearIntervalImpl?: typeof clearInterval;
+};
+export declare function createWechatBridge(input: WechatBridgeInput): WechatBridge;
+export declare function createWechatBridgeLifecycle(input: WechatBridgeLifecycleInput, deps?: WechatBridgeLifecycleDeps): Promise<WechatBridgeLifecycle>;
+export {};

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 {};