@netnodeag/kraftwerk 0.75.0 → 0.75.1

package/dist/cli/daemon-control.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, openSync, promises as fs } from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
-import { daemonLogPath, findDaemon, readDaemonFile } from "../core/daemon.js";
+import { daemonLogPath, daemonState, findDaemon, readDaemonFile } from "../core/daemon.js";
 import { tildify } from "../core/instances.js";
 import { selfCommand } from "../core/self-command.js";
 import { getPkgVersion } from "../server/version.js";
@@ -42,7 +42,7 @@ const ago = (iso) => {
 };
 async function getJson(port, p) {
     try {
-        const r = await fetch(`http://127.0.0.1:${port}${p}`, { signal: AbortSignal.timeout(2000) });
+        const r = await fetch(`http://127.0.0.1:${port}${p}`, { signal: AbortSignal.timeout(3000) });
         return r.ok ? (await r.json()) : null;
     }
     catch {
@@ -62,10 +62,14 @@ async function tail(n) {
     }
 }
 async function status() {
-    const [running, rec, installed] = await Promise.all([findDaemon(), readDaemonFile(), getPkgVersion()]);
+    const [found, rec, installed] = await Promise.all([daemonState(), readDaemonFile(), getPkgVersion()]);
     const base = { installed, loginItem: daemonLoginItem() !== null, log: daemonLogPath() };
-    if (!running)
+    if (found.state === "stopped")
         return { running: false, ...base };
+    const running = found;
+    if (found.state === "busy") {
+        return { running: true, busy: true, ...base, pid: found.pid, port: found.port, ...(rec?.version ? { version: rec.version } : {}), ...(rec?.startedAt ? { startedAt: rec.startedAt } : {}) };
+    }
     const [hub, relay] = await Promise.all([
         getJson(running.port, "/api/hub"),
         getJson(running.port, "/api/devices/relay"),
@@ -87,7 +91,12 @@ export async function daemonStatus(opts) {
         console.log(JSON.stringify(s, null, 2));
         process.exit(s.running ? 0 : NOT_RUNNING);
     }
-    if (s.running) {
+    if (s.busy) {
+        const up = ago(s.startedAt);
+        console.log(`${chalk.yellow("●")} kraftwerk daemon ${chalk.yellow("running, but slow to answer")} ${chalk.dim(`pid ${s.pid}, port ${s.port}${up ? `, up ${up}` : ""}${s.version ? `, ${s.version}` : ""}`)}`);
+        console.log(chalk.dim("  its process lives and holds its port — busy (agents at work, a loaded machine); ask again in a moment"));
+    }
+    else if (s.running) {
         const up = ago(s.startedAt);
         const behind = s.version && s.version !== s.installed ? chalk.yellow(` — ${s.installed} is installed: \`kraftwerk daemon restart\``) : "";
         console.log(`${chalk.green("●")} kraftwerk daemon ${chalk.green("running")} ${chalk.dim(`pid ${s.pid}${up ? `, up ${up}` : ""}${s.version ? `, ${s.version}` : ""}`)}${behind}`);
@@ -138,9 +147,10 @@ async function launch(port) {
     return "background";
 }
 export async function startDaemon(opts) {
-    const running = await findDaemon();
-    if (running) {
-        console.log(`${chalk.green("✔")} the daemon already runs ${chalk.dim(`(pid ${running.pid}, http://localhost:${running.port})`)}`);
+    const running = await daemonState();
+    if (running.state !== "stopped") {
+        const busy = running.state === "busy" ? ", busy — slow to answer right now" : "";
+        console.log(`${chalk.green("✔")} the daemon already runs ${chalk.dim(`(pid ${running.pid}, http://localhost:${running.port}${busy})`)}`);
         return;
     }
     const how = await launch(opts.port);
@@ -157,9 +167,10 @@ export async function startDaemon(opts) {
 }
 /** Stop it: its supervisor first (else it would start the daemon again), then wait until it is gone. */
 async function stopRunning() {
-    const [running, rec] = await Promise.all([findDaemon(), readDaemonFile()]);
-    if (!running)
+    const [found, rec] = await Promise.all([daemonState(), readDaemonFile()]);
+    if (found.state === "stopped")
         return false;
+    const running = found;
     const target = rec?.pid === running.pid && alive(rec.supervisor) ? rec.supervisor : running.pid;
     process.kill(target, "SIGTERM");
     const gone = await until(async () => !alive(running.pid) && !alive(target) && (await findDaemon()) === null, 20_000);
@@ -182,9 +193,15 @@ export async function stopDaemon() {
 }
 /** Restart: the running daemon relaunches itself with the current install (its supervisor stays); none running — start one. */
 export async function restartDaemon(opts) {
-    const running = await findDaemon();
-    if (!running)
+    const found = await daemonState();
+    if (found.state === "stopped")
         return startDaemon(opts);
+    if (found.state === "busy") {
+        // It does not answer, so it cannot be asked to relaunch: stopping it is the only way (its agents are interrupted).
+        await stopRunning();
+        return startDaemon(opts);
+    }
+    const running = found;
     // The restart route lives in every workspace (the daemon's root answers machine routes only); any open one will do.
     const hub = await getJson(running.port, "/api/hub");
     const slug = hub?.workspaces?.[0]?.slug;

package/dist/cli/daemon-login.js

@@ -3,7 +3,7 @@ import { existsSync, promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import chalk from "chalk";
-import { daemonLogPath, findDaemon } from "../core/daemon.js";
+import { daemonLogPath, daemonState } from "../core/daemon.js";
 import { selfCommand } from "../core/self-command.js";
 import { tildify } from "../core/instances.js";
 /**
@@ -72,8 +72,8 @@ export async function installDaemon(opts) {
     await fs.writeFile(file, renderPlist([cmd, ...args], env, logPath()));
     // An older version of the item is replaced: unload it first (an error just means it was not loaded).
     spawnSync(launchctl(), ["bootout", `${domain()}/${LAUNCH_LABEL}`], { stdio: "ignore" });
-    const running = await findDaemon();
-    if (running) {
+    const running = await daemonState();
+    if (running.state !== "stopped") {
         // Loading now would start a second daemon, which refuses to run. launchd loads the file at the next login.
         console.log(`${chalk.green("✔")} login item installed: ${chalk.dim(tildify(file))}`);
         console.log(chalk.dim(`  a daemon already runs (pid ${running.pid}); from the next login on, launchd starts it`));

package/dist/cli/daemon.js

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import { DAEMON_PORT, findDaemon, lastOpenRoots, setDaemonVersion, writeDaemonFile } from "../core/daemon.js";
+import { DAEMON_PORT, daemonState, lastOpenRoots, setDaemonVersion, writeDaemonFile } from "../core/daemon.js";
 import { tildify } from "../core/instances.js";
 import { networkUrls } from "../server/bind.js";
 import { startPushWatcher } from "../server/push.js";
@@ -22,9 +22,10 @@ export async function runDaemon(opts) {
         process.env.KRAFTWERK_UI_HOST ||= "0.0.0.0";
     if (process.env.KRAFTWERK_UI_SUPERVISED !== "1")
         return supervise(["daemon", ...(opts.port ? ["--port", opts.port] : [])], "the daemon");
-    const running = await findDaemon();
-    if (running && running.pid !== process.pid) {
-        console.error(chalk.red(`✖ a kraftwerk daemon already runs (pid ${running.pid}, port ${running.port})`));
+    // A busy one counts too: a second daemon would only crash on its port.
+    const running = await daemonState();
+    if (running.state !== "stopped" && running.pid !== process.pid) {
+        console.error(chalk.red(`✖ a kraftwerk daemon already runs (pid ${running.pid}, port ${running.port}${running.state === "busy" ? ", busy right now" : ""})`));
         process.exit(1);
     }
     const port = Number(opts.port ?? process.env.KRAFTWERK_DAEMON_PORT ?? DAEMON_PORT);

package/dist/cli/doctor.js

@@ -9,7 +9,7 @@ import { applyDotenv, DOTENV_FILE } from "../dotenv.js";
 import { legacyFindings, versionLt } from "./doctor-legacy.js";
 import { listDevices } from "../core/devices.js";
 import { slugClashes } from "../core/instances.js";
-import { findDaemon } from "../core/daemon.js";
+import { daemonState } from "../core/daemon.js";
 import { daemonLoginItem } from "./daemon-login.js";
 import { readRelaySettings } from "../server/relay.js";
 const ICONS = {
@@ -214,9 +214,10 @@ export async function runDoctor(cwd) {
         report("warn", "KRAFTWERK_UI_TRUST_NETWORK=1", "anyone who reaches the UI over the network uses it without pairing — unset it and pair devices instead (`kraftwerk devices pair`)");
     report("info", devices.length ? `${devices.length} paired device(s)` : "no paired devices", devices.length ? devices.map((d) => d.name).join(", ") : "a phone or another computer can use kraftwerk once paired: `kraftwerk ui --lan`, then `kraftwerk devices pair`");
     // The daemon: whether one runs, and whether it starts at login.
-    const daemon = await findDaemon();
+    const state = await daemonState();
+    const daemon = state.state === "stopped" ? null : state;
     const loginItem = daemonLoginItem();
-    report("info", daemon ? `kraftwerk daemon running on :${daemon.port}` : "no kraftwerk daemon running", loginItem
+    report("info", !daemon ? "no kraftwerk daemon running" : daemon.state === "busy" ? `kraftwerk daemon running on :${daemon.port}, but slow to answer (busy)` : `kraftwerk daemon running on :${daemon.port}`, loginItem
         ? daemon
             ? "starts at login · `kraftwerk daemon status` for more"
             : "starts at login, but not running now · `kraftwerk daemon start`, `kraftwerk daemon logs` says why it stopped"

package/dist/core/daemon.d.ts

@@ -29,10 +29,24 @@ export declare function lastOpenRoots(): Promise<string[]>;
 /** The daemon file as the last daemon left it; null without one. */
 export declare function readDaemonFile(): Promise<DaemonFile | null>;
 /** The running daemon (its file, and a hub that answers on its port), or null. */
-export declare function findDaemon(): Promise<{
+export declare function findDaemon(timeoutMs?: number): Promise<{
     pid: number;
     port: number;
 } | null>;
+export type DaemonState = {
+    state: "running" | "busy";
+    pid: number;
+    port: number;
+} | {
+    state: "stopped";
+};
+/**
+ * Whether a daemon runs, telling a slow one from a stopped one: "busy" is a
+ * daemon whose process lives and whose port is taken but that did not answer
+ * in time. A busy daemon is never "stopped" — starting another would only
+ * crash on the taken port, and restarting it would interrupt its agents.
+ */
+export declare function daemonState(timeoutMs?: number): Promise<DaemonState>;
 /** Ask the daemon to open or close a workspace (this machine's request: local trust). */
 export declare function daemonCall<T>(port: number, verb: "open" | "close", root: string): Promise<{
     ok: boolean;

package/dist/core/daemon.js

@@ -1,4 +1,5 @@
 import { promises as fs } from "node:fs";
+import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 /**
@@ -47,18 +48,20 @@ export async function readDaemonFile() {
         return null;
     }
 }
+/**
+ * How long a daemon may take to answer before it counts as not there. A
+ * daemon under load (agents at work, a busy machine) can take a second or
+ * two; 0.8 s once read such a one as stopped.
+ */
+const ANSWER_MS = 3000;
 /** The running daemon (its file, and a hub that answers on its port), or null. */
-export async function findDaemon() {
-    let rec;
-    try {
-        rec = JSON.parse(await fs.readFile(daemonFile(), "utf8"));
-    }
-    catch {
+export async function findDaemon(timeoutMs = ANSWER_MS) {
+    const rec = await readDaemonFile();
+    if (!rec)
         return null;
-    }
     try {
         // Every kraftwerk server answers /api/hub; only the daemon says it is one (a standalone `kraftwerk ui` may sit on that port now).
-        const r = await fetch(`http://127.0.0.1:${rec.port}/api/hub`, { signal: AbortSignal.timeout(800) });
+        const r = await fetch(`http://127.0.0.1:${rec.port}/api/hub`, { signal: AbortSignal.timeout(timeoutMs) });
         const body = r.ok ? (await r.json()) : null;
         return body?.daemon === true ? { pid: rec.pid, port: rec.port } : null;
     }
@@ -66,6 +69,41 @@ export async function findDaemon() {
         return null;
     }
 }
+const pidAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM: it exists, it is just not ours to signal.
+        return err.code === "EPERM";
+    }
+};
+const portTaken = (port) => new Promise((resolve) => {
+    const sock = net.connect({ host: "127.0.0.1", port });
+    const done = (taken) => {
+        sock.destroy();
+        resolve(taken);
+    };
+    sock.setTimeout(1000, () => done(true)); // accepted nothing yet, refused nothing either: something holds it
+    sock.once("connect", () => done(true));
+    sock.once("error", () => done(false));
+});
+/**
+ * Whether a daemon runs, telling a slow one from a stopped one: "busy" is a
+ * daemon whose process lives and whose port is taken but that did not answer
+ * in time. A busy daemon is never "stopped" — starting another would only
+ * crash on the taken port, and restarting it would interrupt its agents.
+ */
+export async function daemonState(timeoutMs = ANSWER_MS) {
+    const found = await findDaemon(timeoutMs);
+    if (found)
+        return { state: "running", ...found };
+    const rec = await readDaemonFile();
+    if (rec && pidAlive(rec.pid) && (await portTaken(rec.port)))
+        return { state: "busy", pid: rec.pid, port: rec.port };
+    return { state: "stopped" };
+}
 /** Ask the daemon to open or close a workspace (this machine's request: local trust). */
 export async function daemonCall(port, verb, root) {
     const r = await fetch(`http://127.0.0.1:${port}/api/hub/${verb}`, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netnodeag/kraftwerk",
-  "version": "0.75.0",
+  "version": "0.75.1",
   "description": "Open-source agentic workspace for teams — where people and AI agents get work done together: agents (Claude Code, Codex, Pi), skills, shared knowledge, repeatable workflows, and deterministic verification",
   "keywords": [
     "agents",