opencode-copilot-account-switcher 0.13.6 → 0.14.0

package/dist/wechat/broker-launcher.js

@@ -0,0 +1,191 @@
+import net from "node:net";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rm } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { wechatStateRoot } from "./state-paths.js";
+import { parseEnvelopeLine, serializeEnvelope } from "./protocol.js";
+const DEFAULT_BACKOFF_MS = 250;
+const DEFAULT_MAX_ATTEMPTS = 20;
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readBrokerMetadata(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isFiniteNumber(parsed.pid) || !isNonEmptyString(parsed.endpoint) || !isFiniteNumber(parsed.startedAt)) {
+            return null;
+        }
+        return {
+            pid: parsed.pid,
+            endpoint: parsed.endpoint,
+            startedAt: parsed.startedAt,
+            version: isNonEmptyString(parsed.version) ? parsed.version : "unknown",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function defaultPingImpl(endpoint) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection(endpoint);
+        let buffer = "";
+        const timer = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, 500);
+        socket.once("error", () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+        socket.once("connect", () => {
+            socket.write(serializeEnvelope({ id: `launcher-ping-${Date.now()}`, type: "ping", payload: {} }));
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString("utf8");
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            clearTimeout(timer);
+            socket.end();
+            try {
+                const response = parseEnvelopeLine(buffer.slice(0, newlineIndex + 1));
+                resolve(response.type === "pong");
+            }
+            catch {
+                resolve(false);
+            }
+        });
+    });
+}
+async function readLaunchLock(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isFiniteNumber(parsed.pid) || !isFiniteNumber(parsed.acquiredAt) || !isNonEmptyString(parsed.lockId)) {
+            return null;
+        }
+        return {
+            pid: parsed.pid,
+            acquiredAt: parsed.acquiredAt,
+            lockId: parsed.lockId,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function acquireLaunchLock(filePath) {
+    const lock = {
+        pid: process.pid,
+        acquiredAt: Date.now(),
+        lockId: randomUUID(),
+    };
+    try {
+        const handle = await open(filePath, "wx", 0o600);
+        await handle.writeFile(JSON.stringify(lock, null, 2), "utf8");
+        await handle.close();
+        return lock;
+    }
+    catch (error) {
+        if (error.code !== "EEXIST") {
+            throw error;
+        }
+        const existing = await readLaunchLock(filePath);
+        if (existing && isProcessAlive(existing.pid)) {
+            return null;
+        }
+        await rm(filePath, { force: true });
+        return null;
+    }
+}
+async function isBrokerAlive(brokerFilePath, pingImpl) {
+    const metadata = await readBrokerMetadata(brokerFilePath);
+    if (!metadata) {
+        return null;
+    }
+    const ok = await pingImpl(metadata.endpoint);
+    if (!ok) {
+        return null;
+    }
+    return metadata;
+}
+function defaultSpawnImpl(endpoint, stateRoot) {
+    const entry = fileURLToPath(new URL("./broker-entry.js", import.meta.url));
+    const child = spawn(process.execPath, [entry, `--endpoint=${endpoint}`, `--state-root=${stateRoot}`], {
+        cwd: path.resolve(fileURLToPath(new URL("../..", import.meta.url))),
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    return child;
+}
+export async function connectOrSpawnBroker(options = {}) {
+    const stateRoot = options.stateRoot ?? wechatStateRoot();
+    const brokerJsonFile = options.brokerJsonPath ?? path.join(stateRoot, "broker.json");
+    const launchLockFile = options.launchLockPath ?? path.join(stateRoot, "launch.lock");
+    const backoffMs = options.backoffMs ?? DEFAULT_BACKOFF_MS;
+    const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    const pingImpl = options.pingImpl ?? defaultPingImpl;
+    const spawnImpl = options.spawnImpl ?? defaultSpawnImpl;
+    const endpointFactory = options.endpointFactory ?? (() => {
+        const suffix = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        if (process.platform === "win32") {
+            return `\\\\.\\pipe\\wechat-broker-${process.pid}-${suffix}`;
+        }
+        return path.join(stateRoot, `broker-${suffix}.sock`);
+    });
+    await mkdir(stateRoot, { recursive: true, mode: 0o700 });
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        const running = await isBrokerAlive(brokerJsonFile, pingImpl);
+        if (running) {
+            return running;
+        }
+        const lock = await acquireLaunchLock(launchLockFile);
+        if (!lock) {
+            await delay(backoffMs);
+            continue;
+        }
+        options.onLockAcquired?.(lock);
+        try {
+            const secondCheck = await isBrokerAlive(brokerJsonFile, pingImpl);
+            if (secondCheck) {
+                return secondCheck;
+            }
+            const endpoint = endpointFactory();
+            const child = spawnImpl(endpoint, stateRoot);
+            void child?.unref?.();
+            for (let n = 0; n < 20; n += 1) {
+                await delay(100);
+                const spawned = await isBrokerAlive(brokerJsonFile, pingImpl);
+                if (spawned) {
+                    return spawned;
+                }
+            }
+            throw new Error("spawned broker did not become available");
+        }
+        finally {
+            await rm(launchLockFile, { force: true });
+        }
+    }
+    throw new Error("broker unavailable");
+}

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

@@ -0,0 +1,25 @@
+import type { WechatSlashCommand } from "./command-parser.js";
+export declare const DEFAULT_HEARTBEAT_TIMEOUT_MS = 30000;
+export declare const DEFAULT_STATUS_COLLECT_WINDOW_MS = 1500;
+type AggregatedStatusInstance = {
+    instanceID: string;
+    status: "ok";
+    snapshot: unknown;
+} | {
+    instanceID: string;
+    status: "timeout/unreachable";
+};
+type CollectStatusResult = {
+    requestId: string;
+    instances: AggregatedStatusInstance[];
+    reply: string;
+};
+export type BrokerServerHandle = {
+    endpoint: string;
+    startedAt: number;
+    collectStatus: () => Promise<CollectStatusResult>;
+    handleWechatSlashCommand: (command: WechatSlashCommand) => Promise<string>;
+    close: () => Promise<void>;
+};
+export declare function startBrokerServer(endpoint: string): Promise<BrokerServerHandle>;
+export {};