@netnodeag/kraftwerk 0.65.0 → 0.67.0

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>>)[];

package/dist/server/api/hub.js

@@ -0,0 +1,32 @@
+import * as z from "zod";
+import { tildify } from "../../core/instances.js";
+import { currentHub } from "../hub-context.js";
+import { fail, route } from "./router.js";
+const Root = z.object({ root: z.string().min(1, "root is required") });
+/** What a hub serves (server.ts Hub): the machine's open workspaces, and opening or closing one. Need no workspace. */
+export const hubRoutes = [
+    // The folder is this machine's business; a paired device sees names and addresses.
+    route({ name: "hub.list", method: "GET", path: "/api/hub", summary: "the workspaces this kraftwerk serves: slug, name, address" }, async (c) => {
+        const hub = currentHub();
+        return {
+            daemon: hub.daemon,
+            port: hub.port,
+            workspaces: hub.list().map((o) => ({
+                slug: o.slug,
+                name: o.name,
+                url: o.url,
+                ...(o.aliasPort ? { aliasPort: o.aliasPort } : {}),
+                ...(c.trust.kind === "local" ? { root: o.root, rootLabel: tildify(o.root) } : {}),
+            })),
+        };
+    }),
+    route({ name: "hub.open", method: "POST", path: "/api/hub/open", summary: "serve a workspace {root} next to the others", access: "local", body: Root, errors: 400 }, async (c) => {
+        const { root } = await c.body();
+        const o = await currentHub().open(root);
+        return { slug: o.slug, name: o.name, url: o.url, ...(o.aliasPort ? { aliasPort: o.aliasPort } : {}) };
+    }),
+    route({ name: "hub.close", method: "POST", path: "/api/hub/close", summary: "stop serving a workspace {root}; the others keep running", access: "local", body: Root }, async (c) => {
+        const { root } = await c.body();
+        return (await currentHub().close(root)) ? { ok: true } : fail(404, "not open here");
+    }),
+];

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

@@ -337,7 +337,29 @@ export declare const routes: (Route<"agents.addJournal", {
 }>, "/api/git/pull", undefined> | Route<"git.push", import("./router.js").Reply<{
     ok: boolean;
     error?: string;
-}>, "/api/git/push", undefined> | Route<"git.status", import("../../core/git.js").GitStatus, "/api/git", undefined> | Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept", undefined> | Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge", z.ZodObject<{
+}>, "/api/git/push", undefined> | Route<"git.status", import("../../core/git.js").GitStatus, "/api/git", undefined> | Route<"hub.close", {
+    ok: boolean;
+}, "/api/hub/close", z.ZodObject<{
+    root: z.ZodString;
+}, z.core.$strip>> | 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> | Route<"hub.open", {
+    slug: string;
+    name: string;
+    url: string;
+    aliasPort?: number | undefined;
+}, "/api/hub/open", z.ZodObject<{
+    root: z.ZodString;
+}, z.core.$strip>> | Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept", undefined> | Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge", z.ZodObject<{
     name: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>> | Route<"knowledge.delete", {
     ok: boolean;
@@ -348,6 +370,7 @@ export declare const routes: (Route<"agents.addJournal", {
     id: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>> | Route<"meta.get", {
     workspaceName: string;
+    workspaceSlug: string;
     workspaceIcon: string;
     workspaceColor: string;
     workspaceNamed: boolean;
@@ -458,7 +481,11 @@ export declare const routes: (Route<"agents.addJournal", {
     runs: import("../../core/runs.js").RunListItem[];
 }, "/api/runs", undefined> | Route<"runs.stop", {
     stopped: boolean;
-}, "/api/runs/:id/stop", undefined> | Route<"search.agents", import("../../core/search.js").AgentSearch, "/api/search/agents", undefined> | Route<"server.restart", {
+}, "/api/runs/:id/stop", undefined> | Route<"search.agents", {
+    workspaces: (import("../../core/search.js").WorkspaceAgents & {
+        here?: true;
+    })[];
+}, "/api/search/agents", undefined> | Route<"server.restart", {
     ok: boolean;
 }, "/api/restart", undefined> | Route<"settings.get", import("../../core/settings.js").SettingsView, "/api/settings", undefined> | Route<"settings.save", import("../../core/settings.js").SettingsView, "/api/settings", z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -554,7 +581,12 @@ export declare const routes: (Route<"agents.addJournal", {
     ok: boolean;
 }, "/api/workspaces/forget", z.ZodObject<{
     root: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>> | Route<"workspaces.list", import("../../core/instances.js").WorkspaceDetail[], "/api/workspaces", undefined> | Route<"workspaces.start", import("./router.js").Reply<import("../../core/instances.js").StartResult>, "/api/workspaces/start", z.ZodObject<{
+}, z.core.$strip>> | Route<"workspaces.list", (import("../../core/instances.js").WorkspaceDetail & {
+    here?: true;
+})[], "/api/workspaces", undefined> | Route<"workspaces.start", import("./router.js").Reply<import("../../core/instances.js").StartResult & {
+    slug?: string;
+    here?: true;
+}>, "/api/workspaces/start", z.ZodObject<{
     root: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>> | Route<"workspaces.stop", import("./router.js").Reply<{
     ok: boolean;

package/dist/server/api/index.js

@@ -4,6 +4,7 @@ import { attentionRoutes } from "./attention.js";
 import { channelRoutes } from "./channels.js";
 import { chatRoutes } from "./chats.js";
 import { deviceRoutes } from "./devices.js";
+import { hubRoutes } from "./hub.js";
 import { fileRoutes } from "./files.js";
 import { gitRoutes } from "./git.js";
 import { knowledgeRoutes } from "./knowledge.js";
@@ -34,6 +35,7 @@ const domainRoutes = [
     ...gitRoutes,
     ...vibeableRoutes,
     ...deviceRoutes,
+    ...hubRoutes,
 ];
 const protocolRoute = route({ name: "protocol.get", method: "GET", path: "/api/protocol", summary: "the protocol version and every route", access: "public" }, async () => ({
     version: PROTOCOL_VERSION,

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

@@ -1,4 +1,5 @@
 import type { Workspace } from "../../core/workspace.js";
+import type { Hub } from "../server.js";
 import type { Trust } from "../trust.js";
 import type { Socket } from "../ws.js";
 /**
@@ -6,4 +7,11 @@ import type { Socket } from "../ws.js";
  * been revoked since it connected): a device whose answer is no longer
  * `device` is disconnected at once (close code 4401).
  */
-export declare function serveSocket(conn: Socket, workspace: Workspace, version: string, trust: Trust, recheck: () => Promise<Trust>): void;
+/**
+ * `workspaceOf` finds the workspace a message is for: its `ws` (a slug), or
+ * the connection's own (the one the socket was opened for) when it names
+ * none. A daemon's socket opened at its root has no workspace of its own:
+ * there, a message without `ws` reaches only the machine's routes (hub,
+ * devices, protocol).
+ */
+export declare function serveSocket(conn: Socket, workspaceOf: (slug?: string) => Workspace | undefined, version: string, trust: Trust, recheck: () => Promise<Trust>, hub: Hub): void;

package/dist/server/api/socket.js

@@ -1,6 +1,7 @@
 import { subscribeChat } from "../../core/chat/sessions.js";
 import { watch } from "../live.js";
 import { resolveVibeable, subscribeVibeable } from "../../core/vibeables.js";
+import { MACHINE_ROUTES, runInHub } from "../hub-context.js";
 import { apiRouter, PROTOCOL_VERSION, routes } from "./index.js";
 /**
  * The control plane over one WebSocket (`/api/ws`): every JSON route by
@@ -30,7 +31,14 @@ const RECHECK_MS = 5_000;
  * been revoked since it connected): a device whose answer is no longer
  * `device` is disconnected at once (close code 4401).
  */
-export function serveSocket(conn, workspace, version, trust, recheck) {
+/**
+ * `workspaceOf` finds the workspace a message is for: its `ws` (a slug), or
+ * the connection's own (the one the socket was opened for) when it names
+ * none. A daemon's socket opened at its root has no workspace of its own:
+ * there, a message without `ws` reaches only the machine's routes (hub,
+ * devices, protocol).
+ */
+export function serveSocket(conn, workspaceOf, version, trust, recheck, hub) {
     const trustKey = trust.kind === "device" ? `device:${trust.device.id}` : trust.kind;
     const stops = new Map();
     const send = (msg) => conn.send(JSON.stringify(msg));
@@ -72,6 +80,8 @@ export function serveSocket(conn, workspace, version, trust, recheck) {
             return unsubscribe();
         stops.set(key, unsubscribe);
     }
+    /** A refusal answered the way the message expects one (its id, watch or sub key). */
+    const refuse = (msg, status, error) => send({ id: msg.id, ...(typeof msg.watch === "string" ? { watch: msg.watch } : {}), ...(typeof msg.sub === "string" ? { sub: msg.sub } : {}), status, data: { error }, error });
     async function handle(msg) {
         if (typeof msg.call === "string") {
             const r = await apiRouter.invoke(msg.call, objectOf(msg.input), trust);
@@ -129,17 +139,27 @@ export function serveSocket(conn, workspace, version, trust, recheck) {
             return send({ error: "invalid JSON" });
         }
         // Every message runs in the connection's workspace, whatever started the read; a revoked device's message runs nowhere.
-        void workspace
-            .run(async () => {
+        const slug = typeof msg.ws === "string" ? msg.ws : undefined;
+        const ws = workspaceOf(slug);
+        if (msg.ws !== undefined && !ws)
+            return refuse(msg, 404, `no workspace "${String(msg.ws)}" here`);
+        if (!ws && !(typeof msg.call === "string" && MACHINE_ROUTES.test(msg.call)))
+            return refuse(msg, 404, "name a workspace: `ws` on the message");
+        const run = (fn) => runInHub(hub, () => (ws ? ws.run(fn) : fn()));
+        void run(async () => {
             if (await stillPaired())
                 await handle(msg);
-        })
-            .catch((err) => send({ id: msg.id, error: err.message }));
+        }).catch((err) => send({ id: msg.id, error: err.message }));
     });
     conn.onClose(() => {
         clearInterval(watchdog);
-        for (const fn of stops.values())
-            fn();
+        // A subscription of a workspace that closed meanwhile has nothing left to let go of.
+        for (const fn of stops.values()) {
+            try {
+                fn();
+            }
+            catch { }
+        }
         stops.clear();
     });
     send({ hello: { protocol: PROTOCOL_VERSION, version } });

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

@@ -1,7 +1,14 @@
 import * as z from "zod";
+import { type StartResult } from "../../core/instances.js";
+/** A start's answer; `here` (with its slug) when the hub answering serves it now. */
+type StartReply = StartResult & {
+    slug?: string;
+    here?: true;
+};
 /** The workspace itself: identity and features, settings, the other workspaces, updates. */
 export declare const workspaceRoutes: (import("./router.js").Route<"meta.get", {
     workspaceName: string;
+    workspaceSlug: string;
     workspaceIcon: string;
     workspaceColor: string;
     workspaceNamed: boolean;
@@ -25,7 +32,11 @@ export declare const workspaceRoutes: (import("./router.js").Route<"meta.get", {
     publicUrl: string;
     cloud: import("../cloud.js").CloudStatus;
     switcher: import("../../config.js").SwitcherEntry[];
-}, "/api/meta", undefined> | import("./router.js").Route<"search.agents", import("../../core/search.js").AgentSearch, "/api/search/agents", undefined> | import("./router.js").Route<"server.restart", {
+}, "/api/meta", undefined> | import("./router.js").Route<"search.agents", {
+    workspaces: (import("../../core/search.js").WorkspaceAgents & {
+        here?: true;
+    })[];
+}, "/api/search/agents", undefined> | import("./router.js").Route<"server.restart", {
     ok: boolean;
 }, "/api/restart", undefined> | import("./router.js").Route<"settings.get", import("../../core/settings.js").SettingsView, "/api/settings", undefined> | import("./router.js").Route<"settings.save", import("../../core/settings.js").SettingsView, "/api/settings", z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -90,7 +101,9 @@ export declare const workspaceRoutes: (import("./router.js").Route<"meta.get", {
     ok: boolean;
 }, "/api/workspaces/forget", z.ZodObject<{
     root: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>> | import("./router.js").Route<"workspaces.list", import("../../core/instances.js").WorkspaceDetail[], "/api/workspaces", undefined> | import("./router.js").Route<"workspaces.start", import("./router.js").Reply<import("../../core/instances.js").StartResult>, "/api/workspaces/start", z.ZodObject<{
+}, z.core.$strip>> | import("./router.js").Route<"workspaces.list", (import("../../core/instances.js").WorkspaceDetail & {
+    here?: true;
+})[], "/api/workspaces", undefined> | import("./router.js").Route<"workspaces.start", import("./router.js").Reply<StartReply>, "/api/workspaces/start", z.ZodObject<{
     root: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>> | import("./router.js").Route<"workspaces.stop", import("./router.js").Reply<{
     ok: boolean;
@@ -99,3 +112,4 @@ export declare const workspaceRoutes: (import("./router.js").Route<"meta.get", {
     root: z.ZodOptional<z.ZodString>;
     url: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>)[];
+export {};

package/dist/server/api/workspace.js

@@ -1,10 +1,11 @@
 import path from "node:path";
 import * as z from "zod";
-import { resolveWorkspace } from "../../config.js";
+import { absolutePath, resolveWorkspace, slugFromFolder, workspaceSlug } from "../../config.js";
 import { disposeAllBackends } from "../../core/chat/sessions.js";
 import { cloudStatus } from "../cloud.js";
 import { workspaceRoot } from "../../core/context.js";
 import { discoverWorkspaces, forgetWorkspace, listWorkspacesDetailed, startWorkspace, stopWorkspace, tildify } from "../../core/instances.js";
+import { currentHub } from "../hub-context.js";
 import { searchAgents } from "../../core/search.js";
 import { getSettings, saveSettings } from "../../core/settings.js";
 import { canSelfUpdate, startUpdate, updateStatus } from "../../core/update.js";
@@ -32,6 +33,26 @@ const SettingsFields = z.looseObject({
     vibeables: RootBlock.optional(),
     projects: RootBlock.optional(),
 });
+/**
+ * Mark the workspaces the hub answering this request serves — or, a daemon,
+ * would serve once started (it opens a stopped one next to the others, at
+ * <slug>.localhost:<its port>) — as `here`. The UI links those in the form
+ * the page itself was reached by: a paired phone on the network cannot
+ * resolve <slug>.localhost, so it gets /w/<slug>/ on the address it used.
+ */
+function placeInHub(entries) {
+    const hub = currentHub();
+    const served = new Set(hub.list().map((o) => o.root));
+    return entries.map((e) => {
+        if (!e.root || !e.slug)
+            return e;
+        if (served.has(e.root))
+            return { ...e, here: true };
+        if (hub.daemon && !e.live && e.exists !== false)
+            return { ...e, here: true, url: `http://${e.slug}.localhost:${hub.port}` };
+        return e;
+    });
+}
 /** The workspace itself: identity and features, settings, the other workspaces, updates. */
 export const workspaceRoutes = [
     // ?probe=1 marks a discovery probe from another instance: answer identity
@@ -42,7 +63,7 @@ export const workspaceRoutes = [
         const name = ws?.config.name ?? (ws ? path.basename(ws.root) : "");
         const root = ws?.root ?? workspaceRoot();
         const manual = ws?.config.switcher ?? [];
-        const discovered = c.query.get("probe") === "1" ? [] : await discoverWorkspaces();
+        const discovered = c.query.get("probe") === "1" ? [] : placeInHub(await discoverWorkspaces());
         // Manual switcher entries keep their configured name/icon; discovered
         // workspaces that duplicate one (same url, running) only contribute
         // the live flag. Stopped workspaces never collide — they carry a root,
@@ -56,6 +77,7 @@ export const workspaceRoutes = [
         ];
         const identity = {
             workspaceName: name,
+            workspaceSlug: ws ? workspaceSlug(ws) : slugFromFolder(path.basename(root)),
             workspaceIcon: ws?.config.icon ?? "",
             workspaceColor: ws?.config.color ?? "",
             workspaceNamed: !!ws?.config.name,
@@ -88,12 +110,23 @@ export const workspaceRoutes = [
     }),
     route({ name: "settings.get", method: "GET", path: "/api/settings", summary: "kraftwerk.yml, parsed, with resolved paths" }, async () => getSettings()),
     route({ name: "settings.save", method: "PUT", path: "/api/settings", summary: "write the UI-editable subset of kraftwerk.yml", errors: 400, body: SettingsFields }, async (c) => saveSettings((await c.body()))),
-    route({ name: "workspaces.list", method: "GET", path: "/api/workspaces", summary: "every known workspace incl. this one, with state and counts" }, async () => listWorkspacesDetailed()),
+    route({ name: "workspaces.list", method: "GET", path: "/api/workspaces", summary: "every known workspace incl. this one, with state and counts" }, async () => placeInHub(await listWorkspacesDetailed())),
     // Launches `kraftwerk ui` for a known workspace as a detached process (the switcher's Start button).
     route({ name: "workspaces.start", method: "POST", path: "/api/workspaces/start", summary: "start a known workspace {root}", errors: 400, body: z.object({ root: z.string().optional() }) }, async (c) => {
         const { root } = await c.body();
         if (!root)
             fail(400, "root required");
+        // A daemon opens it itself, next to the workspace asking.
+        const hub = currentHub();
+        if (hub.daemon) {
+            try {
+                const o = await hub.open(absolutePath(root));
+                return reply(200, { ok: true, url: o.url, slug: o.slug, here: true, live: true, pid: process.pid });
+            }
+            catch (err) {
+                return reply(409, { ok: false, error: err.message });
+            }
+        }
         const result = await startWorkspace(root);
         return reply(result.ok ? 200 : 409, result);
     }),
@@ -101,6 +134,13 @@ export const workspaceRoutes = [
         const target = await c.body();
         if (!target.root && !target.url)
             fail(400, "root or url required");
+        // One the hub answering serves (not the one asking): closed right here.
+        const hub = currentHub();
+        const open = target.root ? hub.list().find((o) => o.root === absolutePath(target.root)) : undefined;
+        if (hub.daemon && open && open.root !== workspaceRoot()) {
+            await hub.close(open.root);
+            return reply(200, { ok: true });
+        }
         const result = await stopWorkspace(target);
         return reply(result.ok ? 200 : 409, result);
     }),
@@ -110,7 +150,7 @@ export const workspaceRoutes = [
             fail(400, "root required");
         return { ok: await forgetWorkspace(root) };
     }),
-    route({ name: "search.agents", method: "GET", path: "/api/search/agents", summary: "active agents and channels of every reachable workspace (⌘K)" }, async () => searchAgents()),
+    route({ name: "search.agents", method: "GET", path: "/api/search/agents", summary: "active agents and channels of every reachable workspace (⌘K)" }, async () => searchAgents().then((r) => ({ workspaces: placeInHub(r.workspaces) }))),
     route({ name: "update.check", method: "GET", path: "/api/update-check", summary: "the latest version on the npm registry" }, async () => {
         const name = await getPkgName();
         const current = await getDiskVersion();

package/dist/server/cloud.d.ts

@@ -38,7 +38,7 @@ export declare const cloudStatus: () => CloudStatus;
  * registration attempt (success or not); the heartbeat loop runs on its
  * own afterwards.
  */
-export declare function startCloudSync(port: number, version: string): Promise<void>;
+export declare function startCloudSync(url: string, version: string): Promise<void>;
 /** Stop the heartbeat loop (server close, tests). */
 export declare function stopCloudSync(): void;
 /**
@@ -47,3 +47,7 @@ export declare function stopCloudSync(): void;
  * this, and a slow cloud must not hold the process.
  */
 export declare function cloudGoodbye(): Promise<void>;
+/** Every served workspace: stop its heartbeat (the server closes). */
+export declare function stopAllCloudSync(): void;
+/** Every served workspace says goodbye, in parallel (still bounded per workspace). */
+export declare function cloudGoodbyeAll(): Promise<void>;