opencode-copilot-account-switcher 0.13.6 → 0.14.0

package/dist/wechat/broker-server.js

@@ -0,0 +1,540 @@
+import net from "node:net";
+import path from "node:path";
+import { chmod, mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { registerConnection, revokeSessionToken, validateSessionToken } from "./ipc-auth.js";
+import { createErrorEnvelope, parseEnvelopeLine, serializeEnvelope, } from "./protocol.js";
+import { WECHAT_DIR_MODE, WECHAT_FILE_MODE, instanceStatePath, instancesDir } from "./state-paths.js";
+import { formatAggregatedStatusReply } from "./status-format.js";
+const FUTURE_MESSAGE_TYPES = new Set([
+    "collectStatus",
+    "replyQuestion",
+    "rejectQuestion",
+    "replyPermission",
+    "showFallbackToast",
+]);
+export const DEFAULT_HEARTBEAT_TIMEOUT_MS = 30_000;
+const DEFAULT_HEARTBEAT_SCAN_INTERVAL_MS = 1_000;
+export const DEFAULT_STATUS_COLLECT_WINDOW_MS = 1_500;
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function getRequestId(envelope) {
+    return envelope.id;
+}
+function writeEnvelope(socket, envelope) {
+    socket.write(serializeEnvelope(envelope));
+}
+function writeError(socket, code, message, requestId) {
+    writeEnvelope(socket, createErrorEnvelope(code, message, requestId));
+}
+function requireAuthorized(envelope) {
+    const instanceID = envelope.instanceID;
+    const sessionToken = envelope.sessionToken;
+    if (!isNonEmptyString(instanceID) || !isNonEmptyString(sessionToken)) {
+        return false;
+    }
+    return validateSessionToken(instanceID, sessionToken);
+}
+const registrationByInstanceID = new Map();
+const instanceIDsBySocket = new Map();
+const snapshotByInstanceID = new Map();
+const snapshotPersistQueueByInstanceID = new Map();
+const pendingCollectStatusByRequestId = new Map();
+function clearRuntimeState() {
+    for (const instanceID of registrationByInstanceID.keys()) {
+        revokeSessionToken(instanceID);
+    }
+    registrationByInstanceID.clear();
+    instanceIDsBySocket.clear();
+    snapshotByInstanceID.clear();
+    snapshotPersistQueueByInstanceID.clear();
+    pendingCollectStatusByRequestId.clear();
+}
+function toPositiveNumber(rawValue, fallback) {
+    if (!isNonEmptyString(rawValue)) {
+        return fallback;
+    }
+    const parsed = Number(rawValue);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return fallback;
+    }
+    return parsed;
+}
+function asObject(value) {
+    if (typeof value !== "object" || value === null) {
+        return {};
+    }
+    return value;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function hasCollectStatusPayload(payload) {
+    return asObject(payload).requestId !== undefined && isNonEmptyString(asObject(payload).requestId);
+}
+function hasStatusSnapshotPayload(payload) {
+    const record = asObject(payload);
+    return isNonEmptyString(record.requestId) && "snapshot" in record;
+}
+function isSafeInstanceID(instanceID) {
+    if (!isNonEmptyString(instanceID)) {
+        return false;
+    }
+    if (instanceID.includes("/") || instanceID.includes("\\")) {
+        return false;
+    }
+    if (instanceID.includes("..")) {
+        return false;
+    }
+    return true;
+}
+function makeConnectedSnapshot(instanceID, payload, now) {
+    const record = asObject(payload);
+    return {
+        instanceID,
+        pid: isFiniteNumber(record.pid) ? record.pid : process.pid,
+        displayName: isNonEmptyString(record.displayName) ? record.displayName : "",
+        projectDir: isNonEmptyString(record.projectDir) ? record.projectDir : "",
+        connectedAt: now,
+        lastHeartbeatAt: now,
+        status: "connected",
+    };
+}
+function serializeSnapshot(snapshot) {
+    if (snapshot.status === "stale") {
+        return {
+            instanceID: snapshot.instanceID,
+            pid: snapshot.pid,
+            displayName: snapshot.displayName,
+            projectDir: snapshot.projectDir,
+            connectedAt: snapshot.connectedAt,
+            lastHeartbeatAt: snapshot.lastHeartbeatAt,
+            status: snapshot.status,
+            staleSince: snapshot.staleSince,
+        };
+    }
+    return {
+        instanceID: snapshot.instanceID,
+        pid: snapshot.pid,
+        displayName: snapshot.displayName,
+        projectDir: snapshot.projectDir,
+        connectedAt: snapshot.connectedAt,
+        lastHeartbeatAt: snapshot.lastHeartbeatAt,
+        status: snapshot.status,
+    };
+}
+async function persistInstanceSnapshot(snapshot) {
+    await mkdir(instancesDir(), { recursive: true, mode: WECHAT_DIR_MODE });
+    await writeFile(instanceStatePath(snapshot.instanceID), JSON.stringify(serializeSnapshot(snapshot), null, 2), {
+        mode: WECHAT_FILE_MODE,
+    });
+}
+function queuePersistSnapshot(snapshot) {
+    const currentChain = snapshotPersistQueueByInstanceID.get(snapshot.instanceID) ?? Promise.resolve();
+    const nextWrite = currentChain.then(() => persistInstanceSnapshot(snapshot));
+    const queueTail = nextWrite.catch(() => { });
+    snapshotPersistQueueByInstanceID.set(snapshot.instanceID, queueTail);
+    return nextWrite;
+}
+async function upsertConnectedSnapshot(instanceID, payload, now) {
+    const next = makeConnectedSnapshot(instanceID, payload, now);
+    snapshotByInstanceID.set(instanceID, next);
+    await queuePersistSnapshot(next);
+    return next;
+}
+async function recoverSnapshotFromHeartbeat(instanceID, now) {
+    const current = snapshotByInstanceID.get(instanceID);
+    if (!current) {
+        const fallback = {
+            instanceID,
+            pid: process.pid,
+            displayName: "",
+            projectDir: "",
+            connectedAt: now,
+            lastHeartbeatAt: now,
+            status: "connected",
+        };
+        snapshotByInstanceID.set(instanceID, fallback);
+        await queuePersistSnapshot(fallback);
+        return;
+    }
+    const next = {
+        instanceID: current.instanceID,
+        pid: current.pid,
+        displayName: current.displayName,
+        projectDir: current.projectDir,
+        connectedAt: current.connectedAt,
+        lastHeartbeatAt: now,
+        status: "connected",
+    };
+    snapshotByInstanceID.set(instanceID, next);
+    await queuePersistSnapshot(next);
+}
+async function markStaleSnapshots(now, heartbeatTimeoutMs) {
+    for (const [instanceID, snapshot] of snapshotByInstanceID.entries()) {
+        if (snapshot.status !== "connected") {
+            continue;
+        }
+        if (now - snapshot.lastHeartbeatAt < heartbeatTimeoutMs) {
+            continue;
+        }
+        const staleSnapshot = {
+            instanceID: snapshot.instanceID,
+            pid: snapshot.pid,
+            displayName: snapshot.displayName,
+            projectDir: snapshot.projectDir,
+            connectedAt: snapshot.connectedAt,
+            lastHeartbeatAt: snapshot.lastHeartbeatAt,
+            status: "stale",
+            staleSince: now,
+        };
+        snapshotByInstanceID.set(instanceID, staleSnapshot);
+        await queuePersistSnapshot(staleSnapshot);
+    }
+}
+function bindSocketInstance(socket, instanceID) {
+    const set = instanceIDsBySocket.get(socket) ?? new Set();
+    set.add(instanceID);
+    instanceIDsBySocket.set(socket, set);
+}
+function unbindSocketInstance(socket, instanceID) {
+    const set = instanceIDsBySocket.get(socket);
+    if (!set) {
+        return;
+    }
+    set.delete(instanceID);
+    if (set.size === 0) {
+        instanceIDsBySocket.delete(socket);
+    }
+}
+function cleanupSocketRegistrations(socket) {
+    const set = instanceIDsBySocket.get(socket);
+    if (!set) {
+        return;
+    }
+    for (const instanceID of set) {
+        const current = registrationByInstanceID.get(instanceID);
+        if (current?.socket === socket) {
+            registrationByInstanceID.delete(instanceID);
+            revokeSessionToken(instanceID);
+        }
+    }
+    instanceIDsBySocket.delete(socket);
+}
+function finalizePendingCollectStatus(requestId) {
+    const pending = pendingCollectStatusByRequestId.get(requestId);
+    if (!pending) {
+        return;
+    }
+    clearTimeout(pending.timer);
+    pendingCollectStatusByRequestId.delete(requestId);
+    const instances = [];
+    for (const instanceID of pending.requestedInstanceIDs) {
+        if (pending.snapshotsByInstanceID.has(instanceID)) {
+            instances.push({
+                instanceID,
+                status: "ok",
+                snapshot: pending.snapshotsByInstanceID.get(instanceID),
+            });
+            continue;
+        }
+        instances.push({
+            instanceID,
+            status: "timeout/unreachable",
+        });
+    }
+    pending.resolve({
+        requestId,
+        instances,
+        reply: formatAggregatedStatusReply({
+            requestId,
+            instances,
+        }),
+    });
+}
+async function handleMessage(envelope, socket) {
+    const requestId = getRequestId(envelope);
+    if (envelope.type === "ping") {
+        writeEnvelope(socket, {
+            id: `pong-${requestId}`,
+            type: "pong",
+            payload: { message: "pong" },
+        });
+        return;
+    }
+    if (envelope.type === "registerInstance") {
+        if (!isSafeInstanceID(envelope.instanceID ?? "")) {
+            writeError(socket, "invalidMessage", "instanceID is required", requestId);
+            return;
+        }
+        const instanceID = envelope.instanceID;
+        const existing = registrationByInstanceID.get(instanceID);
+        if (existing && existing.socket === socket) {
+            try {
+                await upsertConnectedSnapshot(instanceID, envelope.payload, Date.now());
+            }
+            catch {
+                writeError(socket, "brokerUnavailable", "failed to persist instance snapshot", requestId);
+                return;
+            }
+            writeEnvelope(socket, {
+                id: `registerAck-${requestId}`,
+                type: "registerAck",
+                instanceID,
+                payload: {
+                    sessionToken: existing.sessionToken,
+                    registeredAt: existing.registeredAt,
+                    brokerPid: existing.brokerPid,
+                },
+            });
+            return;
+        }
+        const registeredAt = Date.now();
+        try {
+            await upsertConnectedSnapshot(instanceID, envelope.payload, registeredAt);
+        }
+        catch {
+            writeError(socket, "brokerUnavailable", "failed to persist instance snapshot", requestId);
+            return;
+        }
+        const sessionToken = registerConnection(instanceID, { socket });
+        const nextRecord = {
+            socket,
+            sessionToken,
+            registeredAt,
+            brokerPid: process.pid,
+        };
+        registrationByInstanceID.set(instanceID, nextRecord);
+        bindSocketInstance(socket, instanceID);
+        if (existing && existing.socket !== socket) {
+            unbindSocketInstance(existing.socket, instanceID);
+        }
+        writeEnvelope(socket, {
+            id: `registerAck-${requestId}`,
+            type: "registerAck",
+            instanceID,
+            payload: {
+                sessionToken,
+                registeredAt: nextRecord.registeredAt,
+                brokerPid: nextRecord.brokerPid,
+            },
+        });
+        return;
+    }
+    if (envelope.type === "heartbeat") {
+        if (!requireAuthorized(envelope)) {
+            writeError(socket, "unauthorized", "session token is invalid", requestId);
+            return;
+        }
+        try {
+            await recoverSnapshotFromHeartbeat(envelope.instanceID, Date.now());
+        }
+        catch {
+            writeError(socket, "brokerUnavailable", "failed to persist instance snapshot", requestId);
+            return;
+        }
+        writeEnvelope(socket, {
+            id: `pong-${requestId}`,
+            type: "pong",
+            payload: { message: "pong" },
+        });
+        return;
+    }
+    if (envelope.type === "statusSnapshot") {
+        if (!requireAuthorized(envelope)) {
+            writeError(socket, "unauthorized", "session token is invalid", requestId);
+            return;
+        }
+        const payload = envelope.payload;
+        if (!hasStatusSnapshotPayload(payload)) {
+            writeError(socket, "invalidMessage", "statusSnapshot payload is invalid", requestId);
+            return;
+        }
+        const pending = pendingCollectStatusByRequestId.get(payload.requestId);
+        if (!pending) {
+            return;
+        }
+        const sourceInstanceID = envelope.instanceID;
+        if (!isNonEmptyString(sourceInstanceID)) {
+            return;
+        }
+        if (!pending.requestedInstanceIDs.has(sourceInstanceID)) {
+            return;
+        }
+        pending.snapshotsByInstanceID.set(sourceInstanceID, payload.snapshot);
+        if (pending.snapshotsByInstanceID.size >= pending.requestedInstanceIDs.size) {
+            finalizePendingCollectStatus(payload.requestId);
+        }
+        return;
+    }
+    if (FUTURE_MESSAGE_TYPES.has(envelope.type)) {
+        if (!requireAuthorized(envelope)) {
+            writeError(socket, "unauthorized", "session token is invalid", requestId);
+            return;
+        }
+        writeError(socket, "notImplemented", "future message is not implemented", requestId);
+        return;
+    }
+    writeError(socket, "notImplemented", `${envelope.type} is not implemented`, requestId);
+}
+async function tightenEndpointPermission(endpoint) {
+    if (process.platform === "win32") {
+        return;
+    }
+    await chmod(endpoint, WECHAT_FILE_MODE);
+    const info = await stat(endpoint);
+    if ((info.mode & 0o777) !== WECHAT_FILE_MODE) {
+        throw new Error("failed to enforce broker endpoint permission");
+    }
+}
+async function ensureCurrentUserCanAccess(endpoint) {
+    await new Promise((resolve, reject) => {
+        const probe = net.createConnection(endpoint);
+        probe.once("connect", () => {
+            probe.end();
+            resolve();
+        });
+        probe.once("error", reject);
+    });
+}
+async function prepareEndpoint(endpoint) {
+    if (process.platform === "win32") {
+        return;
+    }
+    await mkdir(path.dirname(endpoint), { recursive: true, mode: WECHAT_DIR_MODE });
+    await rm(endpoint, { force: true });
+}
+export async function startBrokerServer(endpoint) {
+    await prepareEndpoint(endpoint);
+    const heartbeatTimeoutMs = toPositiveNumber(process.env.WECHAT_BROKER_HEARTBEAT_TIMEOUT_MS, DEFAULT_HEARTBEAT_TIMEOUT_MS);
+    const heartbeatScanIntervalMs = toPositiveNumber(process.env.WECHAT_BROKER_HEARTBEAT_SCAN_INTERVAL_MS, DEFAULT_HEARTBEAT_SCAN_INTERVAL_MS);
+    const server = net.createServer((socket) => {
+        let buffer = "";
+        let messageChain = Promise.resolve();
+        socket.on("close", () => {
+            cleanupSocketRegistrations(socket);
+        });
+        socket.on("error", () => {
+            cleanupSocketRegistrations(socket);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString("utf8");
+            while (true) {
+                const newlineIndex = buffer.indexOf("\n");
+                if (newlineIndex === -1) {
+                    break;
+                }
+                const line = buffer.slice(0, newlineIndex);
+                buffer = buffer.slice(newlineIndex + 1);
+                try {
+                    const envelope = parseEnvelopeLine(`${line}\n`);
+                    messageChain = messageChain.then(() => handleMessage(envelope, socket)).catch(() => {
+                        // errors are converted to response envelopes in handleMessage
+                    });
+                }
+                catch {
+                    writeError(socket, "invalidMessage", "invalid message line", "unknown");
+                }
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(endpoint, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    try {
+        await tightenEndpointPermission(endpoint);
+        await ensureCurrentUserCanAccess(endpoint);
+    }
+    catch (error) {
+        await new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+        throw error;
+    }
+    const staleScanTimer = setInterval(() => {
+        void markStaleSnapshots(Date.now(), heartbeatTimeoutMs).catch((error) => {
+            console.error("[wechat-broker] failed to persist stale snapshot", error);
+        });
+    }, heartbeatScanIntervalMs);
+    let closed = false;
+    const collectStatus = async () => {
+        const requestId = `collect-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        const requestedInstanceIDs = new Set();
+        for (const [instanceID, record] of registrationByInstanceID.entries()) {
+            if (record.socket.destroyed) {
+                continue;
+            }
+            requestedInstanceIDs.add(instanceID);
+            writeEnvelope(record.socket, {
+                id: `collectStatus-${requestId}-${instanceID}`,
+                type: "collectStatus",
+                instanceID,
+                sessionToken: record.sessionToken,
+                payload: {
+                    requestId,
+                },
+            });
+        }
+        if (requestedInstanceIDs.size === 0) {
+            return {
+                requestId,
+                instances: [],
+                reply: formatAggregatedStatusReply({
+                    requestId,
+                    instances: [],
+                }),
+            };
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                finalizePendingCollectStatus(requestId);
+            }, DEFAULT_STATUS_COLLECT_WINDOW_MS);
+            pendingCollectStatusByRequestId.set(requestId, {
+                requestedInstanceIDs,
+                snapshotsByInstanceID: new Map(),
+                resolve,
+                timer,
+            });
+        });
+    };
+    const handleWechatSlashCommand = async (command) => {
+        if (command.type === "status") {
+            const result = await collectStatus();
+            return result.reply;
+        }
+        return `命令暂未实现：/${command.command}`;
+    };
+    const close = async () => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        clearInterval(staleScanTimer);
+        for (const requestId of pendingCollectStatusByRequestId.keys()) {
+            finalizePendingCollectStatus(requestId);
+        }
+        for (const record of registrationByInstanceID.values()) {
+            if (!record.socket.destroyed) {
+                record.socket.destroy();
+            }
+        }
+        await new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+        if (process.platform !== "win32") {
+            await rm(endpoint, { force: true });
+        }
+        clearRuntimeState();
+    };
+    return {
+        endpoint,
+        startedAt: Date.now(),
+        collectStatus,
+        handleWechatSlashCommand,
+        close,
+    };
+}

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

@@ -0,0 +1,7 @@
+export type WechatSlashCommand = {
+    type: "status";
+} | {
+    type: "unimplemented";
+    command: string;
+};
+export declare function parseWechatSlashCommand(input: string): WechatSlashCommand | null;

package/dist/wechat/command-parser.js

@@ -0,0 +1,16 @@
+export function parseWechatSlashCommand(input) {
+    if (typeof input !== "string") {
+        return null;
+    }
+    const normalized = input.trim();
+    if (normalized === "/status") {
+        return { type: "status" };
+    }
+    if (normalized.startsWith("/")) {
+        const command = normalized.slice(1).split(/\s+/, 1)[0];
+        if (command === "reply" || command === "allow") {
+            return { type: "unimplemented", command };
+        }
+    }
+    return null;
+}