@netnodeag/kraftwerk 0.71.1 → 0.73.0

package/README.md

@@ -70,8 +70,13 @@ login:
 
 ```bash
 kraftwerk daemon                       # the machine's kraftwerk, on http://localhost:1980
+kraftwerk daemon start                 # or in the background (`kraftwerk daemon -d`)
 kraftwerk daemon install               # or: start it at login from now on (macOS; `uninstall` undoes it)
 
+kraftwerk daemon status                # does it run? pid, uptime, version, workspaces, remote access
+kraftwerk daemon logs -f               # what it says (a daemon in the background writes ~/.kraftwerk/logs/daemon.log)
+kraftwerk daemon restart               # relaunch it with the current install; `daemon stop` stops it
+
 cd ~/work/team-blau && kraftwerk ui    # opens this workspace in the daemon:
                                        #   http://team-blau.localhost:1980
 cd ~/work/relaunch && kraftwerk ui     #   http://relaunch.localhost:1980
@@ -246,6 +251,7 @@ kraftwerk knowledge                     # Knowledge: OKF bundles (list/get/put/v
 kraftwerk ui                            # start this workspace: http://localhost:1981 (or open it in the daemon); --port, --lan, --standalone
 kraftwerk daemon                        # one kraftwerk for every open workspace: http://<slug>.localhost:1980; --port, --lan
 kraftwerk daemon install                # start the daemon at login (macOS LaunchAgent); --lan, --port; `daemon uninstall` removes it
+kraftwerk daemon status                 # whether it runs (exit 3 when not; --json); daemon start|stop|restart; daemon logs [-n N] [-f]
 kraftwerk workspaces                    # every workspace on this machine; workspaces start|stop|forget <ref>
 kraftwerk devices                       # paired devices (a phone, another computer); devices pair|revoke
 kraftwerk remote on|off|pair            # reach this machine from anywhere through the relay, end to end encrypted
@@ -452,6 +458,13 @@ Everything between the phone and the machine is end to end encrypted:
 - One trust remains: the remote page's code comes from the cloud that serves
   it. A native app will remove that.
 
+**Push notifications.** The kraftwerk iOS app gets a notification when
+something new needs you: an approval, a question from an agent, a failed run
+or routine. Each paired phone gives the machine a key of its own, and the
+machine seals every notification with it. The relay and Apple pass along only
+"Something needs you" and the badge count. The app opens the sealed text on
+the phone. Turning notifications off on the phone, or unpairing it, stops them.
+
 The machine's key and its relay secret live in `~/.kraftwerk/relay.json`
 (owner only). The daemon must run (`kraftwerk daemon install`), and the Mac
 must be awake.

package/dist/cli/daemon-control.d.ts

@@ -0,0 +1,15 @@
+export declare function daemonStatus(opts: {
+    json?: boolean;
+}): Promise<void>;
+export declare function startDaemon(opts: {
+    port?: string;
+}): Promise<void>;
+export declare function stopDaemon(): Promise<void>;
+/** Restart: the running daemon relaunches itself with the current install (its supervisor stays); none running — start one. */
+export declare function restartDaemon(opts: {
+    port?: string;
+}): Promise<void>;
+export declare function daemonLogs(opts: {
+    lines?: string;
+    follow?: boolean;
+}): Promise<void>;

package/dist/cli/daemon-control.js

@@ -0,0 +1,228 @@
+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 { tildify } from "../core/instances.js";
+import { selfCommand } from "../core/self-command.js";
+import { getPkgVersion } from "../server/version.js";
+import { daemonLoginItem, startLoginItem } from "./daemon-login.js";
+/**
+ * `kraftwerk daemon status | start | stop | restart | logs`: the daemon from
+ * the outside, without a terminal of its own. `start` (and `kraftwerk daemon
+ * -d`) runs it in the background — through the login item when one is
+ * installed, else as a detached process — writing to the daemon log, which
+ * `logs` shows (`-f` follows). `status` asks the daemon itself, never the
+ * file alone, and exits 3 when none runs (as `systemctl status` does), so a
+ * script can tell.
+ */
+const NOT_RUNNING = 3;
+const alive = (pid) => {
+    if (!pid)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const ago = (iso) => {
+    const ms = iso ? Date.now() - Date.parse(iso) : NaN;
+    if (!Number.isFinite(ms) || ms < 0)
+        return "";
+    const m = Math.floor(ms / 60_000);
+    if (m < 1)
+        return "just now";
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.floor(m / 60);
+    return h < 24 ? `${h}h ${m % 60}m` : `${Math.floor(h / 24)}d ${h % 24}h`;
+};
+async function getJson(port, p) {
+    try {
+        const r = await fetch(`http://127.0.0.1:${port}${p}`, { signal: AbortSignal.timeout(2000) });
+        return r.ok ? (await r.json()) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The last lines of the daemon log ([] without one). */
+async function tail(n) {
+    try {
+        const lines = (await fs.readFile(daemonLogPath(), "utf8")).split("\n");
+        if (lines.at(-1) === "")
+            lines.pop();
+        return lines.slice(-n);
+    }
+    catch {
+        return [];
+    }
+}
+async function status() {
+    const [running, rec, installed] = await Promise.all([findDaemon(), readDaemonFile(), getPkgVersion()]);
+    const base = { installed, loginItem: daemonLoginItem() !== null, log: daemonLogPath() };
+    if (!running)
+        return { running: false, ...base };
+    const [hub, relay] = await Promise.all([
+        getJson(running.port, "/api/hub"),
+        getJson(running.port, "/api/devices/relay"),
+    ]);
+    return {
+        running: true,
+        ...base,
+        pid: running.pid,
+        port: running.port,
+        ...(rec?.version ? { version: rec.version } : {}),
+        ...(rec?.startedAt ? { startedAt: rec.startedAt } : {}),
+        workspaces: (hub?.workspaces ?? []).map(({ slug, name, url }) => ({ slug, name, url })),
+        ...(relay?.enabled ? { remote: { state: relay.state ?? "unknown", ...(relay.url ? { url: relay.url } : {}), clients: relay.clients ?? 0 } } : {}),
+    };
+}
+export async function daemonStatus(opts) {
+    const s = await status();
+    if (opts.json) {
+        console.log(JSON.stringify(s, null, 2));
+        process.exit(s.running ? 0 : NOT_RUNNING);
+    }
+    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}`);
+        console.log(`  ${chalk.cyan(`http://localhost:${s.port}`)} · ${s.workspaces?.length ?? 0} workspace${s.workspaces?.length === 1 ? "" : "s"} open`);
+        for (const w of s.workspaces ?? [])
+            console.log(`    ${w.name} ${chalk.dim(w.url)}`);
+        if (s.remote) {
+            const ok = s.remote.state === "connected";
+            const devices = ok ? chalk.dim(` · ${s.remote.clients} device connection${s.remote.clients === 1 ? "" : "s"} now`) : "";
+            console.log(`  remote access: ${ok ? chalk.green("connected") : chalk.yellow(s.remote.state)}${s.remote.url ? chalk.dim(` through ${s.remote.url}`) : ""}${devices}`);
+        }
+    }
+    else {
+        console.log(`${chalk.red("○")} kraftwerk daemon ${chalk.red("not running")}`);
+        const last = await tail(400);
+        const crash = [...last].reverse().find((l) => /crashed:|stopped unexpectedly/.test(l));
+        if (crash)
+            console.log(chalk.dim(`  last trouble in the log: ${crash.trim().slice(0, 200)}`));
+        console.log(chalk.dim("  `kraftwerk daemon start` starts it in the background"));
+    }
+    console.log(chalk.dim(`  login item: ${s.loginItem ? "starts at login" : "not installed (`kraftwerk daemon install` starts it at login)"}`));
+    console.log(chalk.dim(`  log: ${tildify(s.log)} · \`kraftwerk daemon logs -f\` follows it`));
+    if (!s.running)
+        process.exit(NOT_RUNNING);
+}
+/** Wait until `ok` holds (polling), up to `ms`; whether it did. */
+async function until(ok, ms) {
+    const end = Date.now() + ms;
+    while (Date.now() < end) {
+        if (await ok())
+            return true;
+        await new Promise((r) => setTimeout(r, 300));
+    }
+    return ok();
+}
+/** Start it in the background: the login item when installed (launchd owns it then), else a detached process writing to the log. */
+async function launch(port) {
+    if (daemonLoginItem() && !port && startLoginItem())
+        return "login item";
+    const log = daemonLogPath();
+    mkdirSync(path.dirname(log), { recursive: true });
+    const out = openSync(log, "a");
+    const { cmd, args } = selfCommand(["daemon", ...(port ? ["--port", port] : [])]);
+    const child = spawn(cmd, args, { detached: true, stdio: ["ignore", out, out], cwd: process.env.HOME, env: { ...process.env, FORCE_COLOR: "0" } });
+    child.unref();
+    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})`)}`);
+        return;
+    }
+    const how = await launch(opts.port);
+    process.stdout.write(chalk.dim(`starting the daemon (${how}) …`));
+    const up = await until(async () => (await findDaemon()) !== null, 45_000);
+    process.stdout.write("\n");
+    if (!up) {
+        console.error(chalk.red("✖ the daemon did not come up — its log says:"));
+        for (const l of await tail(15))
+            console.error(chalk.dim(`  ${l}`));
+        process.exit(1);
+    }
+    await daemonStatus({});
+}
+/** 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)
+        return false;
+    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);
+    if (!gone) {
+        for (const pid of [target, running.pid])
+            if (alive(pid))
+                process.kill(pid, "SIGKILL");
+        await until(async () => (await findDaemon()) === null, 5_000);
+    }
+    return true;
+}
+export async function stopDaemon() {
+    if (!(await stopRunning())) {
+        console.log(chalk.dim("No daemon running."));
+        return;
+    }
+    console.log(`${chalk.green("✔")} daemon stopped`);
+    if (daemonLoginItem())
+        console.log(chalk.dim("  it starts again at the next login (`kraftwerk daemon uninstall` stops that)"));
+}
+/** 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)
+        return startDaemon(opts);
+    // 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;
+    const asked = !!slug &&
+        (await fetch(`http://127.0.0.1:${running.port}/w/${encodeURIComponent(slug)}/api/restart`, { method: "POST", signal: AbortSignal.timeout(5000) }).then((r) => r.ok, () => false));
+    if (!asked) {
+        // Not supervised (an old daemon, a foreground one started oddly): stop it and start a new one.
+        await stopRunning();
+        return startDaemon(opts);
+    }
+    process.stdout.write(chalk.dim("restarting the daemon …"));
+    const back = await until(async () => {
+        const d = await findDaemon();
+        return d !== null && d.pid !== running.pid;
+    }, 45_000);
+    process.stdout.write("\n");
+    if (!back) {
+        console.error(chalk.red("✖ the daemon did not come back — its log says:"));
+        for (const l of await tail(15))
+            console.error(chalk.dim(`  ${l}`));
+        process.exit(1);
+    }
+    await daemonStatus({});
+}
+export async function daemonLogs(opts) {
+    const log = daemonLogPath();
+    const n = Math.max(1, Number(opts.lines ?? 50) || 50);
+    if (!existsSync(log)) {
+        console.log(chalk.dim(`No daemon log yet (${tildify(log)}): a daemon in the background writes it — one in a terminal writes there instead.`));
+        if (!opts.follow)
+            return;
+        mkdirSync(path.dirname(log), { recursive: true });
+        await fs.appendFile(log, "");
+    }
+    if (!opts.follow) {
+        for (const l of await tail(n))
+            console.log(l);
+        return;
+    }
+    // tail -F keeps following when the file is replaced; Ctrl-C ends it.
+    const child = spawn("tail", ["-n", String(n), "-F", log], { stdio: "inherit" });
+    await new Promise((resolve) => child.once("exit", () => resolve()));
+}

package/dist/cli/daemon-login.d.ts

@@ -15,5 +15,7 @@ export declare function installDaemon(opts: {
     lan?: boolean;
 }): Promise<void>;
 export declare function uninstallDaemon(): Promise<void>;
+/** Start the login item's daemon now (`kraftwerk daemon start`): load the item, or kick it when loaded; false when launchctl refused. */
+export declare function startLoginItem(): boolean;
 /** For doctor: whether the login item is installed. */
 export declare const daemonLoginItem: () => string | null;

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 { findDaemon } from "../core/daemon.js";
+import { daemonLogPath, findDaemon } from "../core/daemon.js";
 import { selfCommand } from "../core/self-command.js";
 import { tildify } from "../core/instances.js";
 /**
@@ -17,7 +17,7 @@ import { tildify } from "../core/instances.js";
  */
 export const LAUNCH_LABEL = "ch.netnode.kraftwerk.daemon";
 const plistPath = () => path.join(os.homedir(), "Library", "LaunchAgents", `${LAUNCH_LABEL}.plist`);
-const logPath = () => path.join(os.homedir(), ".kraftwerk", "logs", "daemon.log");
+const logPath = daemonLogPath;
 /** A stand-in launchctl (tests); the real one otherwise. */
 const launchctl = () => process.env.KRAFTWERK_LAUNCHCTL || "launchctl";
 const domain = () => `gui/${os.userInfo().uid}`;
@@ -102,5 +102,12 @@ export async function uninstallDaemon() {
     await fs.rm(file, { force: true });
     console.log(`${chalk.green("✔")} login item removed ${chalk.dim(`(${tildify(file)})`)}`);
 }
+/** Start the login item's daemon now (`kraftwerk daemon start`): load the item, or kick it when loaded; false when launchctl refused. */
+export function startLoginItem() {
+    const kick = spawnSync(launchctl(), ["kickstart", `${domain()}/${LAUNCH_LABEL}`], { stdio: "ignore" });
+    if (kick.status === 0)
+        return true;
+    return spawnSync(launchctl(), ["bootstrap", domain(), plistPath()], { stdio: "ignore" }).status === 0;
+}
 /** For doctor: whether the login item is installed. */
 export const daemonLoginItem = () => (existsSync(plistPath()) ? plistPath() : null);

package/dist/cli/daemon.js

@@ -1,12 +1,14 @@
 import chalk from "chalk";
-import { DAEMON_PORT, findDaemon, lastOpenRoots, writeDaemonFile } from "../core/daemon.js";
+import { DAEMON_PORT, findDaemon, lastOpenRoots, setDaemonVersion, writeDaemonFile } from "../core/daemon.js";
 import { tildify } from "../core/instances.js";
 import { networkUrls } from "../server/bind.js";
-import { applyRelay } from "../server/relay.js";
+import { startPushWatcher } from "../server/push.js";
+import { applyRelay, relayPush } from "../server/relay.js";
 import { startHub } from "../server/server.js";
 import { getPkgVersion } from "../server/version.js";
 import { ensureBuilt, supervise } from "./ui.js";
 import { installDaemon, uninstallDaemon } from "./daemon-login.js";
+import { daemonLogs, daemonStatus, restartDaemon, startDaemon, stopDaemon } from "./daemon-control.js";
 /**
  * `kraftwerk daemon` — the machine's kraftwerk: one process serving every
  * open workspace, each at `<slug>.localhost:<port>` (and its own port, when
@@ -26,6 +28,7 @@ export async function runDaemon(opts) {
         process.exit(1);
     }
     const port = Number(opts.port ?? process.env.KRAFTWERK_DAEMON_PORT ?? DAEMON_PORT);
+    setDaemonVersion(await getPkgVersion());
     const reopen = await lastOpenRoots();
     const hub = await startHub({
         port,
@@ -42,13 +45,15 @@ export async function runDaemon(opts) {
             console.log(`${chalk.yellow("⚠")} not reopened: ${tildify(root)} — ${err.message}`);
         }
     }
-    console.log(`${chalk.green("✔")} kraftwerk daemon on ${chalk.cyan(`http://localhost:${hub.port}`)} ${chalk.dim(`(pid ${process.pid})`)}`);
+    console.log(`${chalk.green("✔")} kraftwerk daemon on ${chalk.cyan(`http://localhost:${hub.port}`)} ${chalk.dim(`(pid ${process.pid}, ${new Date().toISOString()})`)}`);
     for (const o of hub.list())
         console.log(`  ${chalk.cyan(o.url)} ${chalk.dim(o.name)}${o.aliasPort ? chalk.dim(` · also :${o.aliasPort}`) : ""}`);
     if (!hub.list().length)
         console.log(chalk.dim("  no workspace open yet — `kraftwerk ui` in a workspace folder opens it here"));
     // The relay (`kraftwerk remote on`): devices reach this machine from anywhere, end to end encrypted.
     const relay = await applyRelay(hub.port, await getPkgVersion(), (line) => console.log(chalk.dim(line)));
+    // What needs you, pushed to the phones that asked (through the relay, sealed per device).
+    startPushWatcher(hub, relayPush);
     if (relay.state !== "off")
         console.log(`${chalk.green("✔")} Reachable from anywhere through ${chalk.cyan(relay.url ?? "")} ${chalk.dim("(`kraftwerk remote pair` pairs a device)")}`);
     const lan = networkUrls(hub.port);
@@ -61,9 +66,53 @@ export function registerDaemonCommand(program) {
         .description("Run the machine's kraftwerk: one process serving every open workspace at <slug>.localhost; install it as a login item")
         .option("--port <port>", `Port (default: KRAFTWERK_DAEMON_PORT, else ${DAEMON_PORT})`)
         .option("--lan", "Listen on the network too, for paired devices")
+        .option("-d, --detach", "Run in the background (same as `kraftwerk daemon start`)")
+        .addHelpText("after", `
+In the background:
+  kraftwerk daemon start        start it (the login item when installed), output to the daemon log
+  kraftwerk daemon status       whether it runs: pid, uptime, version, workspaces, remote access
+  kraftwerk daemon logs -f      its log, followed
+  kraftwerk daemon restart      relaunch it with the current install
+  kraftwerk daemon stop         stop it`)
         .action(async (opts) => {
+        if (opts.detach)
+            return startDaemon(opts);
         await runDaemon(opts);
     });
+    daemon
+        .command("status")
+        .description("Whether the daemon runs: pid, uptime, version, workspaces, remote access (exit 3 when not)")
+        .option("--json", "As JSON")
+        .action(async (opts) => {
+        await daemonStatus(opts);
+    });
+    daemon
+        .command("start")
+        .description("Start the daemon in the background (the login item when installed), writing to the daemon log")
+        .option("--port <port>", `Port (default: KRAFTWERK_DAEMON_PORT, else ${DAEMON_PORT})`)
+        .action(async (opts) => {
+        await startDaemon({ port: opts.port ?? daemon.opts().port });
+    });
+    daemon
+        .command("stop")
+        .description("Stop the running daemon")
+        .action(async () => {
+        await stopDaemon();
+    });
+    daemon
+        .command("restart")
+        .description("Relaunch the daemon with the current install (starts one when none runs)")
+        .action(async () => {
+        await restartDaemon({});
+    });
+    daemon
+        .command("logs")
+        .description("Show the daemon log (a daemon in the background writes it)")
+        .option("-n, --lines <n>", "How many lines", "50")
+        .option("-f, --follow", "Keep following it (Ctrl-C ends)")
+        .action(async (opts) => {
+        await daemonLogs(opts);
+    });
     daemon
         .command("install")
         .description("Start the daemon at login (macOS LaunchAgent), and now unless one runs")

package/dist/cli/doctor.js

@@ -217,7 +217,9 @@ export async function runDoctor(cwd) {
     const daemon = await findDaemon();
     const loginItem = daemonLoginItem();
     report("info", daemon ? `kraftwerk daemon running on :${daemon.port}` : "no kraftwerk daemon running", loginItem
-        ? "starts at login (`kraftwerk daemon uninstall` removes that)"
+        ? 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"
         : process.platform === "darwin"
             ? "`kraftwerk daemon install` starts it at login"
             : daemon

package/dist/cli/ui.js

@@ -98,8 +98,9 @@ export async function runUi(cwd, opts) {
 /**
  * Respawn loop around the real server. Spawns this same bin script via the
  * current node (selfCommand) — works identically for global installs,
- * local node_modules, npx, and a file: dev checkout. Any exit other than
- * RESTART_EXIT_CODE ends the loop. A SIGTERM/SIGINT to the supervisor is
+ * local node_modules, npx, and a file: dev checkout. RESTART_EXIT_CODE
+ * relaunches; so does a crash once the server was up (with a growing
+ * pause); any other exit ends the loop. A SIGTERM/SIGINT to the supervisor is
  * forwarded to the server, so `kill <supervisor pid>` (what `kraftwerk
  * workspaces start` reports) takes the whole UI down; Ctrl-C signals the
  * foreground group and reaches both anyway.
@@ -110,12 +111,18 @@ async function superviseUi(opts) {
 /** The respawn loop for any long-running kraftwerk process (`ui`, `daemon`): see superviseUi. */
 export async function supervise(argv, what) {
     const { cmd, args } = selfCommand(argv);
+    let backoff = 1000;
     for (;;) {
+        const started = Date.now();
         const child = spawn(cmd, args, {
             stdio: "inherit",
-            env: { ...process.env, KRAFTWERK_UI_SUPERVISED: "1" },
+            env: { ...process.env, KRAFTWERK_UI_SUPERVISED: "1", KRAFTWERK_SUPERVISOR_PID: String(process.pid) },
         });
-        const forward = (sig) => () => child.kill(sig);
+        let stopping = false;
+        const forward = (sig) => () => {
+            stopping = true;
+            child.kill(sig);
+        };
         const handlers = { SIGTERM: forward("SIGTERM"), SIGINT: forward("SIGINT") };
         process.on("SIGTERM", handlers.SIGTERM);
         process.on("SIGINT", handlers.SIGINT);
@@ -124,13 +131,28 @@ export async function supervise(argv, what) {
         });
         process.off("SIGTERM", handlers.SIGTERM);
         process.off("SIGINT", handlers.SIGINT);
-        if (result.code !== RESTART_EXIT_CODE) {
-            // A signal-killed server is not a clean exit — say so in the exit code
-            // (128 + signal, the shell convention) so callers can tell.
-            if (result.signal)
-                process.exit(128 + (os.constants.signals[result.signal] ?? 1));
-            process.exit(result.code ?? 1);
+        if (result.code === RESTART_EXIT_CODE) {
+            console.log(chalk.dim(`↻ relaunching ${what} with the current install ...`));
+            backoff = 1000;
+            continue;
         }
-        console.log(chalk.dim(`↻ relaunching ${what} with the current install ...`));
+        // A crash after it was up (not asked to stop, not a clean exit): start it again, waiting longer each time it keeps crashing.
+        // One that fails right at start (a taken port, a second daemon) would only fail again — that exits, as before.
+        const ran = Date.now() - started;
+        const crashed = !stopping && result.code !== 0 && ran >= Number(process.env.KRAFTWERK_RESTART_AFTER_MS ?? 10_000);
+        if (crashed) {
+            if (ran > 120_000)
+                backoff = 1000;
+            const how = result.signal ? `signal ${result.signal}` : `exit ${result.code}`;
+            console.error(chalk.yellow(`↻ ${new Date().toISOString()} ${what} stopped unexpectedly (${how}) — starting it again in ${backoff / 1000}s`));
+            await new Promise((r) => setTimeout(r, backoff));
+            backoff = Math.min(backoff * 2, 60_000);
+            continue;
+        }
+        // A signal-killed server is not a clean exit — say so in the exit code
+        // (128 + signal, the shell convention) so callers can tell.
+        if (result.signal)
+            process.exit(128 + (os.constants.signals[result.signal] ?? 1));
+        process.exit(result.code ?? 1);
     }
 }

package/dist/client/routes.d.ts

@@ -44,11 +44,13 @@ export declare const ROUTES: {
     readonly "chats.steer": readonly ["POST", "/api/chats/:id/steer"];
     readonly "chats.stopTask": readonly ["POST", "/api/chats/:id/task-stop"];
     readonly "devices.code": readonly ["POST", "/api/devices/code"];
+    readonly "devices.dropPush": readonly ["DELETE", "/api/devices/push"];
     readonly "devices.list": readonly ["GET", "/api/devices"];
     readonly "devices.pair": readonly ["POST", "/api/pair"];
     readonly "devices.relay": readonly ["GET", "/api/devices/relay"];
     readonly "devices.revoke": readonly ["DELETE", "/api/devices/:id"];
     readonly "devices.self": readonly ["GET", "/api/devices/self"];
+    readonly "devices.setPush": readonly ["POST", "/api/devices/push"];
     readonly "devices.setRelay": readonly ["POST", "/api/devices/relay"];
     readonly "files.delete": readonly ["DELETE", "/api/files"];
     readonly "files.list": readonly ["GET", "/api/files/list"];

package/dist/client/routes.js

@@ -45,11 +45,13 @@ export const ROUTES = {
     "chats.steer": ["POST", "/api/chats/:id/steer"],
     "chats.stopTask": ["POST", "/api/chats/:id/task-stop"],
     "devices.code": ["POST", "/api/devices/code"],
+    "devices.dropPush": ["DELETE", "/api/devices/push"],
     "devices.list": ["GET", "/api/devices"],
     "devices.pair": ["POST", "/api/pair"],
     "devices.relay": ["GET", "/api/devices/relay"],
     "devices.revoke": ["DELETE", "/api/devices/:id"],
     "devices.self": ["GET", "/api/devices/self"],
+    "devices.setPush": ["POST", "/api/devices/push"],
     "devices.setRelay": ["POST", "/api/devices/relay"],
     "files.delete": ["DELETE", "/api/files"],
     "files.list": ["GET", "/api/files/list"],

package/dist/core/daemon.d.ts

@@ -9,9 +9,25 @@
  * asking it (findDaemon), never by the file alone.
  */
 export declare const DAEMON_PORT = 1980;
+export interface DaemonFile {
+    pid: number;
+    port: number;
+    startedAt: string;
+    /** The supervisor around it (`kraftwerk daemon stop` signals that one, so it does not start the daemon again). */
+    supervisor?: number;
+    version?: string;
+    /** The roots it serves — reopened when the daemon starts again (a restart, a self-update). */
+    open?: string[];
+}
+/** The version the running daemon writes into its file (status shows it: the install may be newer than what runs). */
+export declare const setDaemonVersion: (v: string) => void;
+/** Where a daemon in the background (`kraftwerk daemon start`, the login item) writes what it says. */
+export declare const daemonLogPath: () => string;
 export declare function writeDaemonFile(port: number, open: string[]): Promise<void>;
 /** What the last daemon served, to open again; [] without a file. */
 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<{
     pid: number;

package/dist/core/daemon.js

@@ -14,10 +14,18 @@ import path from "node:path";
 export const DAEMON_PORT = 1980;
 const daemonFile = () => path.join(os.homedir(), ".kraftwerk", "daemon.json");
 const startedAt = new Date().toISOString();
+let version;
+/** The version the running daemon writes into its file (status shows it: the install may be newer than what runs). */
+export const setDaemonVersion = (v) => {
+    version = v;
+};
+/** Where a daemon in the background (`kraftwerk daemon start`, the login item) writes what it says. */
+export const daemonLogPath = () => path.join(os.homedir(), ".kraftwerk", "logs", "daemon.log");
 export async function writeDaemonFile(port, open) {
     await fs.mkdir(path.dirname(daemonFile()), { recursive: true });
     const tmp = `${daemonFile()}.${process.pid}.tmp`;
-    await fs.writeFile(tmp, JSON.stringify({ pid: process.pid, port, startedAt, open }));
+    const supervisor = Number(process.env.KRAFTWERK_SUPERVISOR_PID) || undefined;
+    await fs.writeFile(tmp, JSON.stringify({ pid: process.pid, port, startedAt, open, ...(supervisor ? { supervisor } : {}), ...(version ? { version } : {}) }));
     await fs.rename(tmp, daemonFile());
 }
 /** What the last daemon served, to open again; [] without a file. */
@@ -30,6 +38,15 @@ export async function lastOpenRoots() {
         return [];
     }
 }
+/** The daemon file as the last daemon left it; null without one. */
+export async function readDaemonFile() {
+    try {
+        return JSON.parse(await fs.readFile(daemonFile(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
 /** The running daemon (its file, and a hub that answers on its port), or null. */
 export async function findDaemon() {
     let rec;

package/dist/core/devices.d.ts

@@ -15,6 +15,18 @@ export interface Device {
     name: string;
     createdAt: string;
     lastSeenAt?: string;
+    /** Whether the device gets push notifications (its app registered for them). */
+    push?: boolean;
+}
+/**
+ * Where a device's push notifications go: its APNs token and environment, and
+ * the key (32 bytes, base64) the device made for this machine — what is pushed
+ * is sealed with it, so the relay and Apple carry it without reading it.
+ */
+export interface PushTarget {
+    token: string;
+    environment: "sandbox" | "production";
+    key: string;
 }
 /** How long a pairing code works. */
 export declare const PAIR_CODE_TTL_MS: number;
@@ -33,3 +45,12 @@ export declare function deviceForToken(token: string): Promise<Device | null>;
 export declare function listDevices(): Promise<Device[]>;
 /** Unpair a device: its token stops working at once. */
 export declare function revokeDevice(id: string): Promise<boolean>;
+/** Register (or, with null, drop) where a device's push notifications go. */
+export declare function setDevicePush(id: string, target: PushTarget | null): Promise<boolean>;
+/** Every device that gets push notifications, with where they go. */
+export declare function pushTargets(): Promise<Array<{
+    id: string;
+    name: string;
+} & PushTarget>>;
+/** Apple says a token is gone (the app was deleted): stop pushing to it. */
+export declare function dropPushToken(token: string): Promise<void>;