@sma1lboy/kobe 0.5.11 → 0.5.13

package/dist/bin/kobed.js

@@ -99,30 +99,36 @@ class KobeDaemonClient {
   nextId = 1;
   pending = new Map;
   handlers = new Map;
+  lifecycleHandlers = new Map;
+  connecting = null;
+  disposed = false;
   constructor(socketPath) {
     this.socketPath = socketPath;
   }
   connect() {
     if (this.socket)
       return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const socket = connect(this.socketPath);
-      this.socket = socket;
-      socket.once("connect", resolve);
-      socket.once("error", reject);
-      socket.on("data", (chunk) => this.onData(chunk.toString("utf8")));
-      socket.on("close", () => {
-        this.socket = null;
-        for (const pending of this.pending.values())
-          pending.reject(new Error("daemon connection closed"));
-        this.pending.clear();
-      });
-    });
+    if (this.disposed)
+      return Promise.reject(new Error("daemon client disposed"));
+    if (this.connecting)
+      return this.connecting;
+    const p = this.openSocket();
+    this.connecting = p;
+    const cleanup = () => {
+      if (this.connecting === p)
+        this.connecting = null;
+    };
+    p.then(cleanup, cleanup);
+    return p;
   }
   close() {
+    this.disposed = true;
     this.socket?.end();
     this.socket = null;
   }
+  forceDisconnect() {
+    this.socket?.destroy();
+  }
   on(name, handler) {
     let set = this.handlers.get(name);
     if (!set) {
@@ -136,6 +142,19 @@ class KobeDaemonClient {
         this.handlers.delete(name);
     };
   }
+  onLifecycle(name, handler) {
+    let set = this.lifecycleHandlers.get(name);
+    if (!set) {
+      set = new Set;
+      this.lifecycleHandlers.set(name, set);
+    }
+    set.add(handler);
+    return () => {
+      set?.delete(handler);
+      if (set?.size === 0)
+        this.lifecycleHandlers.delete(name);
+    };
+  }
   async request(name, payload) {
     await this.connect();
     const socket = this.socket;
@@ -148,6 +167,44 @@ class KobeDaemonClient {
     socket.write(frameToLine({ type: "request", id, name, payload }));
     return promise;
   }
+  openSocket() {
+    return new Promise((resolve, reject) => {
+      const socket = connect(this.socketPath);
+      this.socket = socket;
+      const onConnect = () => {
+        socket.off("error", onError);
+        resolve();
+      };
+      const onError = (err) => {
+        socket.off("connect", onConnect);
+        if (this.socket === socket)
+          this.socket = null;
+        reject(err);
+      };
+      socket.once("connect", onConnect);
+      socket.once("error", onError);
+      socket.on("data", (chunk) => this.onData(chunk.toString("utf8")));
+      socket.on("close", () => this.onSocketClose(socket));
+    });
+  }
+  onSocketClose(which) {
+    if (this.socket !== which && this.socket !== null)
+      return;
+    this.socket = null;
+    for (const pending of this.pending.values())
+      pending.reject(new Error("daemon connection closed"));
+    this.pending.clear();
+    this.emitLifecycle("close");
+  }
+  emitLifecycle(name) {
+    for (const handler of this.lifecycleHandlers.get(name) ?? []) {
+      try {
+        handler();
+      } catch (err) {
+        console.error(`[kobe] lifecycle handler for "${name}" threw:`, err);
+      }
+    }
+  }
   onData(chunk) {
     this.buffer += chunk;
     let nl = this.buffer.indexOf(`
@@ -192,11 +249,10 @@ import { spawn } from "child_process";
 import { existsSync } from "fs";
 import { dirname, join as join2, resolve } from "path";
 import { fileURLToPath } from "url";
-async function connectOrStartDaemon() {
+async function ensureDaemonReachable() {
   const socketPath = defaultDaemonSocketPath();
-  const client = new KobeDaemonClient(socketPath);
-  if (await canConnect(client))
-    return client;
+  if (await testCanConnect(socketPath))
+    return socketPath;
   const { entry, runWithBun } = resolveKobedEntry();
   const child = runWithBun ? spawn(process.execPath, [entry, "start"], {
     detached: true,
@@ -211,24 +267,26 @@ async function connectOrStartDaemon() {
   const deadline = Date.now() + 5000;
   let lastErr;
   while (Date.now() < deadline) {
-    const next = new KobeDaemonClient(socketPath);
-    try {
-      await next.connect();
-      return next;
-    } catch (err) {
-      lastErr = err;
-      next.close();
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
-    }
+    if (await testCanConnect(socketPath))
+      return socketPath;
+    await new Promise((resolveTimer) => setTimeout(resolveTimer, 100));
   }
-  throw new Error(`kobe: daemon did not start at ${socketPath}: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
+  throw new Error(`kobe: daemon did not start at ${socketPath}: ${lastErr instanceof Error ? lastErr.message : "timeout"}`);
 }
-async function canConnect(client) {
+async function connectOrStartDaemon() {
+  const socketPath = await ensureDaemonReachable();
+  const client = new KobeDaemonClient(socketPath);
+  await client.connect();
+  return client;
+}
+async function testCanConnect(socketPath) {
+  const probe = new KobeDaemonClient(socketPath);
   try {
-    await client.connect();
+    await probe.connect();
+    probe.close();
     return true;
   } catch {
-    client.close();
+    probe.close();
     return false;
   }
 }