opencode-copilot-account-switcher 0.14.14 → 0.14.15

package/dist/wechat/broker-client.js

@@ -1,4 +1,4 @@
-import net from "node:net";
+import { createBrokerSocket } from "./broker-endpoint.js";
 import { parseEnvelopeLine, serializeEnvelope, } from "./protocol.js";
 function isNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
@@ -23,7 +23,7 @@ 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);
+    const socket = createBrokerSocket(endpoint);
     let sequence = 0;
     let pendingResolve = null;
     let pendingReject = null;

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

@@ -0,0 +1,21 @@
+import net from "node:net";
+type BrokerEndpointOptions = {
+    platform?: NodeJS.Platform;
+    stateRoot?: string;
+    now?: () => number;
+    random?: () => number;
+};
+type ParsedBrokerEndpoint = {
+    kind: "tcp";
+    host: string;
+    port: number;
+} | {
+    kind: "path";
+    path: string;
+};
+export declare function isTcpBrokerEndpoint(endpoint: string): boolean;
+export declare function createDefaultBrokerEndpoint(options?: BrokerEndpointOptions): string;
+export declare function parseBrokerEndpoint(endpoint: string): ParsedBrokerEndpoint;
+export declare function createBrokerSocket(endpoint: string): net.Socket;
+export declare function listenOnBrokerEndpoint(server: net.Server, endpoint: string): Promise<string>;
+export {};

package/dist/wechat/broker-endpoint.js

@@ -0,0 +1,78 @@
+import net from "node:net";
+import path from "node:path";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+export function isTcpBrokerEndpoint(endpoint) {
+    return endpoint.startsWith("tcp://");
+}
+export function createDefaultBrokerEndpoint(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const stateRoot = options.stateRoot ?? ".";
+    const now = options.now ?? Date.now;
+    const random = options.random ?? Math.random;
+    const suffix = `${now()}-${random().toString(16).slice(2)}`;
+    if (platform === "win32") {
+        return "tcp://127.0.0.1:0";
+    }
+    return path.join(stateRoot, `broker-${suffix}.sock`);
+}
+export function parseBrokerEndpoint(endpoint) {
+    if (!isTcpBrokerEndpoint(endpoint)) {
+        return {
+            kind: "path",
+            path: endpoint,
+        };
+    }
+    const parsed = new URL(endpoint);
+    if (parsed.protocol !== "tcp:") {
+        throw new Error(`unsupported broker endpoint protocol: ${parsed.protocol}`);
+    }
+    if (!isNonEmptyString(parsed.hostname)) {
+        throw new Error("tcp broker endpoint host is required");
+    }
+    const port = Number(parsed.port);
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw new Error("tcp broker endpoint port is invalid");
+    }
+    return {
+        kind: "tcp",
+        host: parsed.hostname,
+        port,
+    };
+}
+export function createBrokerSocket(endpoint) {
+    const parsed = parseBrokerEndpoint(endpoint);
+    if (parsed.kind === "tcp") {
+        return net.createConnection({
+            host: parsed.host,
+            port: parsed.port,
+        });
+    }
+    return net.createConnection(parsed.path);
+}
+export async function listenOnBrokerEndpoint(server, endpoint) {
+    const parsed = parseBrokerEndpoint(endpoint);
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        if (parsed.kind === "tcp") {
+            server.listen({ host: parsed.host, port: parsed.port }, () => {
+                server.off("error", reject);
+                resolve();
+            });
+            return;
+        }
+        server.listen(parsed.path, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    if (parsed.kind === "path") {
+        return parsed.path;
+    }
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("tcp broker endpoint failed to resolve bound address");
+    }
+    return `tcp://${address.address}:${address.port}`;
+}

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

@@ -1,3 +1,4 @@
+import { createDefaultBrokerEndpoint } from "./broker-endpoint.js";
 type BrokerMetadata = {
     pid: number;
     endpoint: string;
@@ -24,5 +25,5 @@ type LaunchOptions = {
     pingImpl?: (endpoint: string) => Promise<boolean>;
     onLockAcquired?: (lock: LaunchLockContent) => void;
 };
+export { createDefaultBrokerEndpoint };
 export declare function connectOrSpawnBroker(options?: LaunchOptions): Promise<BrokerMetadata>;
-export {};

package/dist/wechat/broker-launcher.js

@@ -1,9 +1,9 @@
-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 { createBrokerSocket, createDefaultBrokerEndpoint } from "./broker-endpoint.js";
 import { wechatStateRoot } from "./state-paths.js";
 import { parseEnvelopeLine, serializeEnvelope } from "./protocol.js";
 const DEFAULT_BACKOFF_MS = 250;
@@ -17,6 +17,7 @@ function isFiniteNumber(value) {
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+export { createDefaultBrokerEndpoint };
 async function readCurrentPackageVersion() {
     try {
         const packageJsonPath = new URL("../../package.json", import.meta.url);
@@ -57,7 +58,7 @@ async function readBrokerMetadata(filePath) {
 }
 async function defaultPingImpl(endpoint) {
     return new Promise((resolve) => {
-        const socket = net.createConnection(endpoint);
+        const socket = createBrokerSocket(endpoint);
         let buffer = "";
         const timer = setTimeout(() => {
             socket.destroy();
@@ -162,13 +163,7 @@ export async function connectOrSpawnBroker(options = {}) {
     const expectedVersion = options.expectedVersion ?? await readCurrentPackageVersion();
     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`);
-    });
+    const endpointFactory = options.endpointFactory ?? (() => createDefaultBrokerEndpoint({ stateRoot }));
     await mkdir(stateRoot, { recursive: true, mode: 0o700 });
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
         const running = await isBrokerAlive(brokerJsonFile, pingImpl, expectedVersion);

package/dist/wechat/broker-server.js

@@ -1,6 +1,7 @@
 import net from "node:net";
 import path from "node:path";
 import { chmod, mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { createBrokerSocket, isTcpBrokerEndpoint, listenOnBrokerEndpoint } from "./broker-endpoint.js";
 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";
@@ -378,7 +379,7 @@ async function handleMessage(envelope, socket) {
     writeError(socket, "notImplemented", `${envelope.type} is not implemented`, requestId);
 }
 async function tightenEndpointPermission(endpoint) {
-    if (process.platform === "win32") {
+    if (process.platform === "win32" || isTcpBrokerEndpoint(endpoint)) {
         return;
     }
     await chmod(endpoint, WECHAT_FILE_MODE);
@@ -389,7 +390,7 @@ async function tightenEndpointPermission(endpoint) {
 }
 async function ensureCurrentUserCanAccess(endpoint) {
     await new Promise((resolve, reject) => {
-        const probe = net.createConnection(endpoint);
+        const probe = createBrokerSocket(endpoint);
         probe.once("connect", () => {
             probe.end();
             resolve();
@@ -398,7 +399,7 @@ async function ensureCurrentUserCanAccess(endpoint) {
     });
 }
 async function prepareEndpoint(endpoint) {
-    if (process.platform === "win32") {
+    if (process.platform === "win32" || isTcpBrokerEndpoint(endpoint)) {
         return;
     }
     await mkdir(path.dirname(endpoint), { recursive: true, mode: WECHAT_DIR_MODE });
@@ -438,16 +439,10 @@ export async function startBrokerServer(endpoint) {
             }
         });
     });
-    await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(endpoint, () => {
-            server.off("error", reject);
-            resolve();
-        });
-    });
+    const boundEndpoint = await listenOnBrokerEndpoint(server, endpoint);
     try {
-        await tightenEndpointPermission(endpoint);
-        await ensureCurrentUserCanAccess(endpoint);
+        await tightenEndpointPermission(boundEndpoint);
+        await ensureCurrentUserCanAccess(boundEndpoint);
     }
     catch (error) {
         await new Promise((resolve) => {
@@ -528,13 +523,13 @@ export async function startBrokerServer(endpoint) {
         await new Promise((resolve) => {
             server.close(() => resolve());
         });
-        if (process.platform !== "win32") {
+        if (process.platform !== "win32" && !isTcpBrokerEndpoint(endpoint)) {
             await rm(endpoint, { force: true });
         }
         clearRuntimeState();
     };
     return {
-        endpoint,
+        endpoint: boundEndpoint,
         startedAt: Date.now(),
         collectStatus,
         handleWechatSlashCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.14.14",
+  "version": "0.14.15",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",