@netnodeag/kraftwerk 0.65.0 → 0.66.0

package/dist/core/instances.js

@@ -3,8 +3,10 @@ import { createHash } from "node:crypto";
 import fsSync, { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { absolutePath, isDir, resolveWorkspace } from "../config.js";
+import { absolutePath, isDir, resolveWorkspace, slugFromFolder, workspaceSlug } from "../config.js";
 import { selfCommand } from "./self-command.js";
+import { DAEMON_PORT, daemonCall, findDaemon } from "./daemon.js";
+import { currentWorkspace } from "./workspace.js";
 /**
  * Two registries under ~/.kraftwerk, two lifecycles:
  *
@@ -31,9 +33,16 @@ const workspacesDir = () => path.join(kwHome(), "workspaces");
 /** Where the records lived before 0.49 (`kraftwerk projects`); moved over once, see migrateRegistry. */
 export const legacyWorkspacesDir = () => path.join(kwHome(), "projects");
 const logsDir = () => path.join(kwHome(), "logs");
-const selfFile = () => path.join(instancesDir(), `${process.pid}.json`);
-let selfPort = null;
-let selfRoot = null;
+const own = new Map();
+/** The workspace the caller runs in (a request, a timer), or null outside any. */
+function currentRoot() {
+    try {
+        return currentWorkspace().root;
+    }
+    catch {
+        return null;
+    }
+}
 /** File name of a root's record: a hash of the absolute root, the same under the old and the new directory. */
 export const workspaceRecordName = (root) => `${createHash("sha1").update(absolutePath(root)).digest("hex").slice(0, 16)}.json`;
 const recordFile = (root) => path.join(workspacesDir(), workspaceRecordName(root));
@@ -43,42 +52,61 @@ export const tildify = (p) => {
     return p === home || p.startsWith(home + path.sep) ? "~" + p.slice(home.length) : p;
 };
 /* ---------- instances (ephemeral) ---------- */
-/** Write this instance's registry file (call once the server listens). */
-export async function registerInstance(port, root) {
-    selfPort = port;
-    selfRoot = absolutePath(root);
+/**
+ * Write a served workspace's registry file (call once the server listens).
+ * A daemon's workspaces carry their slug and address and get a file each;
+ * a standalone server keeps the one `<pid>.json` it always had.
+ */
+export async function registerInstance(port, root, opts = {}) {
+    const abs = absolutePath(root);
+    const file = path.join(instancesDir(), opts.hub ? `${process.pid}-${workspaceRecordName(abs)}` : `${process.pid}.json`);
+    const url = opts.url ?? `http://localhost:${port}`;
+    const mine = { port, url, file };
+    own.set(abs, mine);
     try {
         await fs.mkdir(instancesDir(), { recursive: true });
-        const rec = { pid: process.pid, port, startedAt: new Date().toISOString(), root: selfRoot };
-        await fs.writeFile(selfFile(), JSON.stringify(rec));
+        const rec = { pid: process.pid, port, startedAt: new Date().toISOString(), root: abs, ...(opts.hub ? { url, slug: opts.slug, hub: true } : {}) };
+        await fs.writeFile(file, JSON.stringify(rec));
+        // Closed while this wrote (an open and a close in quick succession): the file must not outlive it.
+        if (own.get(abs) !== mine)
+            await fs.unlink(file).catch(() => { });
     }
     catch { } // best-effort — without it discovery just won't see us
+    cache = null;
+    wsCache.clear();
 }
-/** Where this instance answers, as the switcher links it (null before listen). */
-export const currentInstanceUrl = () => (selfPort ? `http://localhost:${selfPort}` : null);
-/** Remove this instance's registry file. Sync so exit handlers can call it. */
-export function unregisterInstance() {
-    try {
-        fsSync.unlinkSync(selfFile());
+/** Where the current workspace answers, as the switcher links it (null before listen). */
+export const currentInstanceUrl = () => own.get(currentRoot() ?? "")?.url ?? null;
+/** Remove a served workspace's registry file — every one this process wrote when no root is given. Sync so exit handlers can call it. */
+export function unregisterInstance(root) {
+    const roots = root ? [absolutePath(root)] : [...own.keys()];
+    for (const r of roots) {
+        try {
+            fsSync.unlinkSync(own.get(r)?.file ?? "");
+        }
+        catch { }
+        own.delete(r);
     }
-    catch { }
+    cache = null;
+    wsCache.clear();
 }
 /**
  * Probe one registered port: is a kraftwerk inspector answering? `probe=1`
  * tells the other side to skip its own discovery — two instances probing
  * each other's /api/meta must not recurse.
  */
-async function probe(port) {
+async function probe(port, slug) {
     // `listen(port, "localhost")` binds one address family, whichever the
     // resolver returns first (::1 on this platform), so an instance started
     // with KRAFTWERK_UI_HOST=localhost or ::1 is not on 127.0.0.1. A refused
     // connection returns at once, so the second try costs nothing when the
     // first one answers.
-    return (await probeAt("127.0.0.1", port)) ?? (await probeAt("[::1]", port));
+    return (await probeAt("127.0.0.1", port, slug)) ?? (await probeAt("[::1]", port, slug));
 }
-async function probeAt(host, port) {
+async function probeAt(host, port, slug) {
     try {
-        const r = await fetch(`http://${host}:${port}/api/meta?probe=1`, {
+        // A daemon's workspace answers under its slug; the path form needs no name resolution.
+        const r = await fetch(`http://${host}:${port}${slug ? `/w/${slug}` : ""}/api/meta?probe=1`, {
             signal: AbortSignal.timeout(400),
         });
         if (!r.ok)
@@ -110,7 +138,7 @@ let cache = null;
  */
 export async function discoverInstances(opts = {}) {
     if (!opts.fresh && cache && Date.now() - cache.at < 5_000)
-        return cache.entries;
+        return notSelf(cache.entries);
     let files;
     try {
         files = await fs.readdir(instancesDir());
@@ -128,21 +156,25 @@ export async function discoverInstances(opts = {}) {
         catch {
             return null;
         }
-        if (rec.pid === process.pid || rec.port === selfPort)
-            return null;
-        const found = await probe(rec.port);
+        const found = await probe(rec.port, rec.hub ? rec.slug : undefined);
         if (!found) {
             if (!opts.readOnly)
                 await fs.unlink(path.join(instancesDir(), f)).catch(() => { }); // stale — prune
             return null;
         }
-        return { ...found, root: rec.root, pid: rec.pid };
+        return { ...found, root: rec.root, pid: rec.pid, ...(rec.hub ? { url: rec.url ?? found.url, slug: rec.slug, hub: true } : {}) };
     }));
     const entries = probed
         .filter((e) => e != null)
         .sort((a, b) => a.name.localeCompare(b.name));
     cache = { at: Date.now(), entries };
-    return entries;
+    return notSelf(entries);
+}
+/** Leave out the asking workspace itself (an older instance file without a root: by this process and port). */
+function notSelf(entries) {
+    const me = currentRoot();
+    const port = me ? own.get(me)?.port : undefined;
+    return entries.filter((e) => (e.root ? e.root !== me : !(e.pid === process.pid && e.url === `http://localhost:${port}`)));
 }
 /* ---------- workspaces (durable) ---------- */
 let migrated = null;
@@ -182,6 +214,7 @@ async function readRecord(file) {
             return null;
         return {
             root: rec.root,
+            ...(typeof rec.slug === "string" ? { slug: rec.slug } : {}),
             firstSeen: rec.firstSeen ?? rec.lastStarted ?? "",
             lastStarted: rec.lastStarted ?? rec.firstSeen ?? "",
             lastStopped: rec.lastStopped,
@@ -197,14 +230,19 @@ async function readRecord(file) {
 }
 /** Upsert the project record for a root (call on every inspector start). */
 export async function registerWorkspace(root) {
-    await migrateRegistry();
     const abs = absolutePath(root);
+    // Where it goes is decided now: the registry of the home this was called in, whatever HOME is by the time it writes.
+    const dir = workspacesDir();
+    const file = path.join(dir, workspaceRecordName(abs));
+    await migrateRegistry();
     const now = new Date().toISOString();
     try {
-        await fs.mkdir(workspacesDir(), { recursive: true });
-        const prev = await readRecord(recordFile(abs));
+        await fs.mkdir(dir, { recursive: true });
+        const prev = await readRecord(file);
+        const slug = await resolveWorkspace(abs).then(workspaceSlug, () => slugFromFolder(path.basename(abs)));
         const rec = {
             root: abs,
+            slug,
             firstSeen: prev?.firstSeen || now,
             lastStarted: now,
             startCount: (prev?.startCount ?? 0) + 1,
@@ -212,7 +250,7 @@ export async function registerWorkspace(root) {
             ...(prev?.channels ? { channels: prev.channels } : {}),
             ...(prev?.projects ? { projects: prev.projects } : {}),
         };
-        await fs.writeFile(recordFile(abs), JSON.stringify(rec, null, 2));
+        await fs.writeFile(file, JSON.stringify(rec, null, 2));
     }
     catch { } // best-effort, like the instance file
 }
@@ -241,17 +279,17 @@ async function syncWorkspaceList(root, key, list) {
 export const syncWorkspaceAgents = (root, agents) => syncWorkspaceList(root, "agents", agents);
 export const syncWorkspaceChannels = (root, channels) => syncWorkspaceList(root, "channels", channels);
 export const syncWorkspaceProjects = (root, projects) => syncWorkspaceList(root, "projects", projects);
-/** Stamp lastStopped on clean shutdown. Sync so exit handlers can call it. */
-export function markWorkspaceStopped() {
-    if (!selfRoot)
-        return;
-    try {
-        const file = recordFile(selfRoot);
-        const rec = JSON.parse(fsSync.readFileSync(file, "utf8"));
-        rec.lastStopped = new Date().toISOString();
-        fsSync.writeFileSync(file, JSON.stringify(rec, null, 2));
+/** Stamp lastStopped on a clean stop — every workspace this process serves when no root is given. Sync so exit handlers can call it. */
+export function markWorkspaceStopped(root) {
+    for (const r of root ? [absolutePath(root)] : [...own.keys()]) {
+        try {
+            const file = recordFile(r);
+            const rec = JSON.parse(fsSync.readFileSync(file, "utf8"));
+            rec.lastStopped = new Date().toISOString();
+            fsSync.writeFileSync(file, JSON.stringify(rec, null, 2));
+        }
+        catch { }
     }
-    catch { }
 }
 /** All known workspaces, most recently started first. */
 export async function listWorkspaceRecords() {
@@ -268,6 +306,13 @@ export async function listWorkspaceRecords() {
         .filter((r) => r != null)
         .sort((a, b) => b.lastStarted.localeCompare(a.lastStarted));
 }
+/** A record's slug: as registered, or (records from before 0.66) its folder name made into one. */
+export const recordSlug = (r) => r.slug ?? slugFromFolder(path.basename(r.root));
+/** Other registered workspaces with this slug — two workspaces cannot share an address. */
+export async function slugClashes(slug, root) {
+    const abs = absolutePath(root);
+    return (await listWorkspaceRecords()).filter((r) => r.root !== abs && recordSlug(r) === slug);
+}
 /** Drop a workspace record (the root itself is untouched) — from the legacy directory too, see migrateRegistry. */
 export async function forgetWorkspace(root) {
     await migrateRegistry();
@@ -310,7 +355,8 @@ async function describeRoot(root) {
         return fallback;
     }
 }
-let wsCache = null;
+/** Per asking workspace: each leaves itself out of its list. */
+const wsCache = new Map();
 /**
  * The switcher's view: every known project joined with the live instances,
  * plus running instances with no project record yet. The calling instance
@@ -318,13 +364,15 @@ let wsCache = null;
  * discoverInstances — /api/meta is polled and this stats every root.
  */
 export async function discoverWorkspaces() {
-    if (wsCache && Date.now() - wsCache.at < 5_000)
-        return wsCache.entries;
+    const me = currentRoot() ?? "";
+    const hit = wsCache.get(me);
+    if (hit && Date.now() - hit.at < 5_000)
+        return hit.entries;
     const [projects, live] = await Promise.all([listWorkspaceRecords(), discoverInstances()]);
     const liveByRoot = new Map(live.filter((i) => i.root).map((i) => [i.root, i]));
     const consumed = new Set();
     const entries = (await Promise.all(projects
-        .filter((p) => p.root !== selfRoot)
+        .filter((p) => p.root !== me)
         .map(async (p) => {
         const base = { root: p.root, rootLabel: tildify(p.root), lastStarted: p.lastStarted, lastStopped: p.lastStopped };
         let running = liveByRoot.get(p.root);
@@ -371,7 +419,7 @@ export async function discoverWorkspaces() {
             return a.live ? -1 : 1;
         return (b.lastStarted ?? "").localeCompare(a.lastStarted ?? "") || a.name.localeCompare(b.name);
     });
-    wsCache = { at: Date.now(), entries };
+    wsCache.set(me, { at: Date.now(), entries });
     return entries;
 }
 const countDirs = async (dir, marker) => {
@@ -403,25 +451,27 @@ const countEntries = async (dir) => {
 export async function listWorkspacesDetailed() {
     const others = await discoverWorkspaces();
     const all = [...others];
-    if (selfRoot && selfPort) {
-        const d = await describeRoot(selfRoot);
-        const rec = await readRecord(recordFile(selfRoot));
+    const me = currentRoot();
+    const mine = me ? own.get(me) : undefined;
+    if (me && mine) {
+        const d = await describeRoot(me);
+        const rec = await readRecord(recordFile(me));
         all.unshift({
             name: d.name,
             icon: d.icon,
             color: d.color,
             named: d.named,
-            url: `http://localhost:${selfPort}`,
+            url: mine.url,
             live: true,
-            root: selfRoot,
-            rootLabel: tildify(selfRoot),
+            root: me,
+            rootLabel: tildify(me),
             exists: true,
             lastStarted: rec?.lastStarted,
             lastStopped: rec?.lastStopped,
         });
     }
     return Promise.all(all.map(async (e) => {
-        const current = !!selfRoot && e.root === selfRoot;
+        const current = !!me && e.root === me;
         const base = { ...e, current, state: e.live ? "running" : "stopped" };
         if (!e.root)
             return base;
@@ -476,15 +526,25 @@ export async function startWorkspace(root) {
     if (!exists)
         return { ok: false, error: `not a project directory (missing or moved): ${abs}` };
     const url = `http://localhost:${port}`;
-    if (abs === selfRoot)
+    if (abs === currentRoot())
         return { ok: false, url, live: true, error: "that is this workspace" };
     // Already running, or the port is taken by another kraftwerk?
-    cache = wsCache = null;
+    cache = null;
+    wsCache.clear();
     const live = await discoverInstances();
     const byRoot = live.find((i) => i.root === abs);
     if (byRoot)
         return { ok: true, url: byRoot.url, live: true };
-    if (port === selfPort)
+    // The machine runs a daemon: it serves this workspace next to the others.
+    const daemon = await findDaemon();
+    if (daemon) {
+        const r = await daemonCall(daemon.port, "open", abs).catch((err) => ({ ok: false, status: 0, data: { error: err.message } }));
+        cache = null;
+        wsCache.clear();
+        return r.ok ? { ok: true, url: r.data.url, live: true, pid: daemon.pid } : { ok: false, error: r.data.error ?? `the daemon refused (${r.status})` };
+    }
+    const mine = own.get(currentRoot() ?? "");
+    if (mine && port === mine.port)
         return { ok: false, url, error: `port ${port} is used by this workspace` };
     const byPort = live.find((i) => i.url === url);
     if (byPort)
@@ -526,7 +586,8 @@ export async function startWorkspace(root) {
         if (exited)
             return { ok: false, url, pid: child.pid, log, error: `kraftwerk ui ${exited}` };
         if (await probe(port)) {
-            cache = wsCache = null;
+            cache = null;
+            wsCache.clear();
             return { ok: true, url, live: true, pid: child.pid, log };
         }
     }
@@ -534,20 +595,30 @@ export async function startWorkspace(root) {
 }
 /* ---------- stop a project ---------- */
 /**
- * Stop a running workspace: SIGTERM to its server process, which
- * unregisters, stamps lastStopped and exits; the `kraftwerk ui` supervisor
- * follows. Matched by root, or by url for instances from older versions
- * that registered no root. Waits up to ~5s for the port to go quiet.
+ * Stop a running workspace. A daemon's workspace is closed there — the
+ * daemon and every other workspace in it keep running. A standalone one
+ * gets SIGTERM to its server process, which unregisters, stamps
+ * lastStopped and exits; the `kraftwerk ui` supervisor follows. Matched by
+ * root, or by url for instances from older versions that registered no
+ * root. Waits up to ~5s for it to go quiet.
  */
 export async function stopWorkspace(target) {
-    if (target.root && absolutePath(target.root) === selfRoot) {
+    if (target.root && absolutePath(target.root) === currentRoot()) {
         return { ok: false, error: "that is this workspace — stop it from its own terminal or pid" };
     }
-    cache = wsCache = null;
+    cache = null;
+    wsCache.clear();
     const live = await discoverInstances();
     const inst = live.find((i) => (target.root && i.root === absolutePath(target.root)) || (target.url && i.url === target.url));
     if (!inst)
         return { ok: false, error: "not running" };
+    if (inst.hub && inst.root) {
+        const port = Number(new URL(inst.url).port) || DAEMON_PORT;
+        const r = await daemonCall(port, "close", inst.root).catch((err) => ({ ok: false, status: 0, data: { error: err.message } }));
+        cache = null;
+        wsCache.clear();
+        return r.ok ? { ok: true } : { ok: false, error: r.data.error ?? `the daemon refused (${r.status})` };
+    }
     try {
         process.kill(inst.pid, "SIGTERM");
     }
@@ -559,7 +630,8 @@ export async function stopWorkspace(target) {
     while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, 250));
         if (!(await probe(port))) {
-            cache = wsCache = null;
+            cache = null;
+            wsCache.clear();
             return { ok: true };
         }
     }

package/dist/core/routines.d.ts

@@ -76,4 +76,10 @@ export declare function runRoutineNow(slug: string, id: string): Promise<{
 }>;
 /** Start the current workspace's scheduler; safe to call more than once. Ticks run in that workspace. */
 export declare function startRoutineScheduler(): void;
+/** Stop the current workspace's scheduler (the workspace closes): no routine of it fires any more. */
+export declare function stopRoutineScheduler(): void;
+/** Whether the current workspace's scheduler runs (tests, the hub's view). */
+export declare const routineSchedulerRunning: () => boolean;
+/** The current workspace's scheduler timer, or null — for tests that check it really stops (a cleared slot would read null either way). */
+export declare const routineSchedulerTimer: () => ReturnType<typeof setInterval> | null;
 export {};

package/dist/core/routines.js

@@ -305,3 +305,14 @@ export function startRoutineScheduler() {
     s.timer = setInterval(() => void tick().catch(() => { }), 20_000);
     s.timer.unref?.();
 }
+/** Stop the current workspace's scheduler (the workspace closes): no routine of it fires any more. */
+export function stopRoutineScheduler() {
+    const s = scheduler();
+    if (s.timer)
+        clearInterval(s.timer);
+    s.timer = null;
+}
+/** Whether the current workspace's scheduler runs (tests, the hub's view). */
+export const routineSchedulerRunning = () => scheduler().timer !== null;
+/** The current workspace's scheduler timer, or null — for tests that check it really stops (a cleared slot would read null either way). */
+export const routineSchedulerTimer = () => scheduler().timer;

package/dist/core/runner.js

@@ -2,10 +2,11 @@ import { spawn, spawnSync } from "node:child_process";
 import { mkdirSync, openSync, closeSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { workspaceRoot } from "./context.js";
-import { perWorkspace } from "./workspace.js";
+import { perWorkspace, workspaceOpen } from "./workspace.js";
 import { RUN_ID_RE, getRun, safeRunDir } from "./runs.js";
 import { pushNotification } from "./notifications.js";
 import { newRunId } from "../workflow.js";
+import { workspaceEnv } from "./env.js";
 /**
  * Workflow trigger for the web UI. The inspector stays decoupled from the
  * framework runtime: it shells out to `npx kraftwerk run` in the consumer
@@ -54,7 +55,7 @@ export function triggerRun(opts) {
         cwd: workspaceRoot(),
         detached: true,
         stdio: ["ignore", log, log],
-        env: { ...process.env, FORCE_COLOR: "0" },
+        env: { ...workspaceEnv(), FORCE_COLOR: "0" },
     });
     child.unref();
     closeSync(log);
@@ -66,13 +67,16 @@ export function triggerRun(opts) {
     // framework wrote a trace (missing env var, npx failure) shows as failed
     // instead of running until the stale timeout.
     child.on("exit", (code, signal) => {
-        launchers().delete(runId);
         try {
             writeFileSync(path.join(runDir, "trigger.json"), JSON.stringify({ exitCode: code ?? 1, signal, finishedAt: new Date().toISOString() }, null, 2) + "\n");
         }
         catch {
             /* run dir removed meanwhile */
         }
+        // A run outlives its workspace closing (it is detached): the file above is all it leaves then.
+        if (!workspaceOpen())
+            return;
+        launchers().delete(runId);
         void getRun(runId)
             .then((run) => {
             const ok = run?.status === "ok";

package/dist/core/vibeables.d.ts

@@ -140,3 +140,5 @@ export declare function startDev(slug: string): Promise<VibeableStatus>;
 export declare function stopDev(slug: string): Promise<VibeableStatus>;
 /** Server shutdown: no dev server may outlive the inspector. */
 export declare function disposeAllDevs(): void;
+/** The current workspace's dev servers and file watchers end (the workspace closes). */
+export declare function disposeWorkspaceDevs(): void;

package/dist/core/vibeables.js

@@ -6,9 +6,10 @@ import path from "node:path";
 import { parse } from "yaml";
 import { resolveWorkspace, vibeablesRootFor } from "../config.js";
 import { workspaceRoot } from "./context.js";
-import { perWorkspace } from "./workspace.js";
+import { perWorkspace, workspaceOpen } from "./workspace.js";
 import { moveToTrash } from "./trash.js";
 import { newestMtime } from "./mtime.js";
+import { workspaceEnv } from "./env.js";
 export const VIBEABLE_CONFIG_FILE = "vibeable.yml";
 const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 export function safeVibeableSlug(slug) {
@@ -353,7 +354,7 @@ async function startDevNow(slug) {
         detached: process.platform !== "win32",
         stdio: ["ignore", "pipe", "pipe"],
         env: {
-            ...process.env,
+            ...workspaceEnv(),
             PORT: String(port),
             BASE_PATH: basePath,
             PUBLIC_URL: basePath,
@@ -371,19 +372,22 @@ async function startDevNow(slug) {
         pushLog(d, Buffer.from(`spawn failed: ${err.message}\n`));
         d.exitCode = null;
         d.ready = false;
-        broadcast(slug, { type: "dev", dev: devView(slug) });
+        if (workspaceOpen())
+            broadcast(slug, { type: "dev", dev: devView(slug) });
     });
     child.on("exit", (code) => {
         d.exitCode = code;
         d.ready = false;
         pushLog(d, Buffer.from(`[exited with ${code ?? "signal"}]\n`));
-        broadcast(slug, { type: "dev", dev: devView(slug) });
+        // Closing the workspace ends its dev servers: their exit then has nobody to tell.
+        if (workspaceOpen())
+            broadcast(slug, { type: "dev", dev: devView(slug) });
     });
     broadcast(slug, { type: "dev", dev: devView(slug) });
     // Readiness runs in the background; the pane follows the dev events.
     void (async () => {
         const until = Date.now() + READY_TIMEOUT;
-        while (Date.now() < until && d.exitCode === undefined && devs().get(slug) === d) {
+        while (Date.now() < until && d.exitCode === undefined && workspaceOpen() && devs().get(slug) === d) {
             if (await probe(port)) {
                 d.ready = true;
                 broadcast(slug, { type: "dev", dev: devView(slug) });
@@ -432,3 +436,11 @@ export function disposeAllDevs() {
             if (d.exitCode === undefined)
                 killGroup(d, "SIGTERM");
 }
+/** The current workspace's dev servers and file watchers end (the workspace closes). */
+export function disposeWorkspaceDevs() {
+    for (const d of devs().values())
+        if (d.exitCode === undefined)
+            killGroup(d, "SIGTERM");
+    for (const slug of [...channels().keys()])
+        dropChannel(slug);
+}

package/dist/core/workspace.d.ts

@@ -18,19 +18,32 @@
 export declare class Workspace {
     readonly root: string;
     readonly outputDir: string;
+    /** Its address on this machine (kraftwerk.yml `slug`, else the folder name), when known. */
+    readonly slug?: string;
+    /** Its `.env` (parsed, not applied — see env.ts); {} when none was given. */
+    readonly env: Record<string, string>;
     private readonly slots;
     /** `root` defaults to the parent of the output dir (wrong for nested output dirs — pass it when known). */
     constructor(opts: {
         outputDir: string;
         root?: string;
+        slug?: string;
+        env?: Record<string, string>;
     });
     /** Run `fn` (and everything it starts) in this workspace. */
     run<T>(fn: () => T): T;
+    /** Closed (no longer served): its state is gone and may not come back — see close(). */
+    get closed(): boolean;
+    private isClosed;
     slot<T>(key: object, init: () => T): T;
+    /** No longer served: sweeps over all workspaces (shutdown, the idle reaper) skip it. Its slots are dropped. */
+    close(): void;
     peek<T>(key: object): T | undefined;
 }
 /** The workspace a single-workspace process serves; used outside any `ws.run`. */
 export declare function setDefaultWorkspace(ws: Workspace): Workspace;
+/** Whether the caller's workspace is still served (a background loop checks before its next round); true outside any. */
+export declare function workspaceOpen(): boolean;
 export declare function currentWorkspace(): Workspace;
 export interface PerWorkspace<T> {
     /** The current workspace's value, created on first use. */

package/dist/core/workspace.js

@@ -20,22 +20,42 @@ import path from "node:path";
 export class Workspace {
     root;
     outputDir;
+    /** Its address on this machine (kraftwerk.yml `slug`, else the folder name), when known. */
+    slug;
+    /** Its `.env` (parsed, not applied — see env.ts); {} when none was given. */
+    env;
     slots = new Map();
     /** `root` defaults to the parent of the output dir (wrong for nested output dirs — pass it when known). */
     constructor(opts) {
         this.outputDir = path.resolve(opts.outputDir);
         this.root = opts.root ? path.resolve(opts.root) : path.dirname(this.outputDir);
+        this.slug = opts.slug;
+        this.env = opts.env ?? {};
         known.add(this);
     }
     /** Run `fn` (and everything it starts) in this workspace. */
     run(fn) {
         return storage.run(this, fn);
     }
+    /** Closed (no longer served): its state is gone and may not come back — see close(). */
+    get closed() {
+        return this.isClosed;
+    }
+    isClosed = false;
     slot(key, init) {
+        // Something still running for a closed workspace (a fetch in flight, a heartbeat) must not bring its state back.
+        if (this.isClosed)
+            throw new Error("workspace closed");
         if (!this.slots.has(key))
             this.slots.set(key, init());
         return this.slots.get(key);
     }
+    /** No longer served: sweeps over all workspaces (shutdown, the idle reaper) skip it. Its slots are dropped. */
+    close() {
+        this.isClosed = true;
+        known.delete(this);
+        this.slots.clear();
+    }
     peek(key) {
         return this.slots.get(key);
     }
@@ -48,6 +68,11 @@ export function setDefaultWorkspace(ws) {
     fallback = ws;
     return ws;
 }
+/** Whether the caller's workspace is still served (a background loop checks before its next round); true outside any. */
+export function workspaceOpen() {
+    const ws = storage.getStore() ?? fallback;
+    return !ws?.closed;
+}
 export function currentWorkspace() {
     const ws = storage.getStore() ?? fallback;
     if (!ws)

package/dist/server/api/hub.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod";
+/** What a hub serves (server.ts Hub): the machine's open workspaces, and opening or closing one. Need no workspace. */
+export declare const hubRoutes: (import("./router.js").Route<"hub.close", {
+    ok: boolean;
+}, "/api/hub/close", z.ZodObject<{
+    root: z.ZodString;
+}, z.core.$strip>> | import("./router.js").Route<"hub.list", {
+    daemon: boolean;
+    port: number;
+    workspaces: {
+        slug: string;
+        name: string;
+        url: string;
+        aliasPort?: number | undefined;
+        root?: string | undefined;
+        rootLabel?: string | undefined;
+    }[];
+}, "/api/hub", undefined> | import("./router.js").Route<"hub.open", {
+    slug: string;
+    name: string;
+    url: string;
+    aliasPort?: number | undefined;
+}, "/api/hub/open", z.ZodObject<{
+    root: z.ZodString;
+}, z.core.$strip>>)[];