@sma1lboy/kobe 0.5.12 → 0.5.15

package/README.md

@@ -28,11 +28,10 @@ that's the gap kobe fills.
 
 [![npm](https://img.shields.io/npm/v/%40sma1lboy%2Fkobe.svg)](https://www.npmjs.com/package/@sma1lboy/kobe)
 
-You need three things on `PATH`:
+You need two things on `PATH`:
 
 - [**Bun**](https://bun.sh) ≥ 1.0 — kobe's renderer is opentui, which uses Bun-FFI.
 - [**`claude`** CLI](https://docs.anthropic.com/en/docs/claude-code) — the engine kobe drives. Run `claude --version` to confirm it's installed and signed in.
-- **`tmux`** — the embedded terminal pane uses one tmux session per task. On macOS: `brew install tmux`.
 
 Then:
 
@@ -148,9 +147,7 @@ and confirm `claude --version` works in the same shell you launched kobe from.
 **`bun: command not found`** — install [Bun](https://bun.sh) (`curl -fsSL https://bun.sh/install | bash`).
 kobe's renderer requires Bun ≥ 1.0; it does not run under Node.
 
-**The terminal pane is blank / errors about tmux** — install `tmux` (`brew install tmux` on macOS).
-The embedded terminal is one tmux session per task; without `tmux` on `PATH`,
-the pane stays empty but the rest of kobe still works.
+**The terminal pane is blank** — kobe starts your `$SHELL` through Bun's native PTY. Confirm `$SHELL` points at an installed shell, your Bun version supports `Bun.spawn({ terminal })`, and the active task's worktree path still exists. `KOBE_TERMINAL_BACKEND=pipe` is available only as a fallback.
 
 **`posix_spawnp failed` when running `bun run test:behavior`** — on macOS arm64,
 Bun's installer occasionally ships `node-pty`'s prebuilt `spawn-helper` without

package/dist/bin/kobed.js

@@ -1,6 +1,36 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -99,30 +129,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 +172,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 +197,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 +279,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 +297,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;
   }
 }
@@ -2613,9 +2701,6 @@ function kobeStateDir() {
 function kvStatePath() {
   return join5(homeDir(), ".config", "kobe", "state.json");
 }
-function tmuxBin() {
-  return process.env.KOBE_TMUX_BIN ?? "tmux";
-}
 var init_env = () => {};
 
 // src/state/repos.ts