@netnodeag/kraftwerk 0.65.0 → 0.66.0

package/dist/core/chat/sessions.d.ts

@@ -1,7 +1,7 @@
 import type { Attachment, ChatAgentId, ChatMeta, ChatScope, ElicitationAnswer, StoredChatEvent } from "./types.js";
 import { type Channel } from "../channels.js";
 export { agentFilesContext, agentJournalContext, agentVibeablesContext, vibeableContext } from "./context.js";
-export { disposeAllBackends } from "./state.js";
+export { disposeAllBackends, disposeWorkspaceBackends } from "./state.js";
 /**
  * The folder the agent is actually spawned in. A vibeable that was removed
  * leaves meta.cwd pointing nowhere; spawning there fails, so fall back to

package/dist/core/chat/sessions.js

@@ -12,7 +12,7 @@ import { expandSkillInvocation, scopeContext } from "./context.js";
 import { ensureBackend } from "./seats.js";
 import { MAIN, chatLabel, chatStates, dropBackend, dropSeat, emit, forgetFailedResume, isBusy, isUnattended, lastEventText, loadState, mainSeat, newSeat, ownerLabel, routineRef } from "./state.js";
 export { agentFilesContext, agentJournalContext, agentVibeablesContext, vibeableContext } from "./context.js";
-export { disposeAllBackends } from "./state.js";
+export { disposeAllBackends, disposeWorkspaceBackends } from "./state.js";
 /**
  * Chats: what the API does with them — create, post, steer, answer, fork,
  * rename, delete, subscribe. The pieces live beside it: the live state and

package/dist/core/chat/state.d.ts

@@ -77,5 +77,7 @@ export declare function forgetFailedResume(state: ChatState, seat: Seat): void;
 export declare function dropBackend(state: ChatState): void;
 /** Server shutdown: no agent subprocess may outlive the inspector. */
 export declare function disposeAllBackends(): void;
+/** The current workspace's agent processes end (the workspace closes); transcripts stay on disk. */
+export declare function disposeWorkspaceBackends(): void;
 export declare function loadState(id: string): Promise<ChatState | null>;
 export declare function emit(state: ChatState, ev: ChatEvent, from?: Author): StoredChatEvent;

package/dist/core/chat/state.js

@@ -134,6 +134,11 @@ export function disposeAllBackends() {
     for (const [ws, states] of chatStates.entries())
         ws.run(() => states.forEach((state) => dropBackend(state)));
 }
+/** The current workspace's agent processes end (the workspace closes); transcripts stay on disk. */
+export function disposeWorkspaceBackends() {
+    for (const state of chatStates().values())
+        dropBackend(state);
+}
 export async function loadState(id) {
     const existing = chatStates().get(id);
     if (existing)

package/dist/core/daemon.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The machine's kraftwerk daemon: one process (`kraftwerk daemon`) serving
+ * every open workspace, each by its slug (`<slug>.localhost:<port>`,
+ * `/w/<slug>/`). It writes ~/.kraftwerk/daemon.json while it runs, so the CLI
+ * (`kraftwerk ui`) and other kraftwerks (the switcher's start/stop) hand
+ * workspaces to it instead of starting a server of their own. The file
+ * outlives the daemon on purpose: it lists what was open, and the next start
+ * (a reboot, a self-update) opens it again. Whether a daemon runs is told by
+ * asking it (findDaemon), never by the file alone.
+ */
+export declare const DAEMON_PORT = 1980;
+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 running daemon (its file, and a hub that answers on its port), or null. */
+export declare function findDaemon(): Promise<{
+    pid: number;
+    port: number;
+} | null>;
+/** 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;
+    status: number;
+    data: T & {
+        error?: string;
+    };
+}>;

package/dist/core/daemon.js

@@ -0,0 +1,61 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * The machine's kraftwerk daemon: one process (`kraftwerk daemon`) serving
+ * every open workspace, each by its slug (`<slug>.localhost:<port>`,
+ * `/w/<slug>/`). It writes ~/.kraftwerk/daemon.json while it runs, so the CLI
+ * (`kraftwerk ui`) and other kraftwerks (the switcher's start/stop) hand
+ * workspaces to it instead of starting a server of their own. The file
+ * outlives the daemon on purpose: it lists what was open, and the next start
+ * (a reboot, a self-update) opens it again. Whether a daemon runs is told by
+ * asking it (findDaemon), never by the file alone.
+ */
+export const DAEMON_PORT = 1980;
+const daemonFile = () => path.join(os.homedir(), ".kraftwerk", "daemon.json");
+const startedAt = new Date().toISOString();
+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 }));
+    await fs.rename(tmp, daemonFile());
+}
+/** What the last daemon served, to open again; [] without a file. */
+export async function lastOpenRoots() {
+    try {
+        const rec = JSON.parse(await fs.readFile(daemonFile(), "utf8"));
+        return Array.isArray(rec.open) ? rec.open.filter((r) => typeof r === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** 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 {
+        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 body = r.ok ? (await r.json()) : null;
+        return body?.daemon === true ? { pid: rec.pid, port: rec.port } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 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}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ root }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    return { ok: r.ok, status: r.status, data: (await r.json().catch(() => ({}))) };
+}

package/dist/core/env.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The environment a workspace's processes run with: this process's, plus
+ * the workspace's own `.env` (dotenv.ts for the precedence — a value set in
+ * the shell wins, unless an earlier kraftwerk process injected it from a
+ * `.env`). Everything a workspace spawns — agents, workflow runs, app dev
+ * servers, git — takes its environment from here, never from process.env
+ * directly: one process may serve several workspaces, and one team's
+ * `.env` must not reach another's agents.
+ *
+ * With one workspace per process the CLI has already applied that
+ * workspace's `.env` to process.env, so the result is the same as before.
+ */
+/** Read `<root>/.env` (parsed, not applied); {} without one. Read when a workspace is served — a changed file applies on restart, as before. */
+export declare function readWorkspaceDotenv(root: string): Record<string, string>;
+/** The current workspace's environment (outside any workspace: process.env). */
+export declare function workspaceEnv(): NodeJS.ProcessEnv;

package/dist/core/env.js

@@ -0,0 +1,45 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { DOTENV_FILE, DOTENV_MARKER, parseDotenv } from "../dotenv.js";
+import { currentWorkspace } from "./workspace.js";
+/**
+ * The environment a workspace's processes run with: this process's, plus
+ * the workspace's own `.env` (dotenv.ts for the precedence — a value set in
+ * the shell wins, unless an earlier kraftwerk process injected it from a
+ * `.env`). Everything a workspace spawns — agents, workflow runs, app dev
+ * servers, git — takes its environment from here, never from process.env
+ * directly: one process may serve several workspaces, and one team's
+ * `.env` must not reach another's agents.
+ *
+ * With one workspace per process the CLI has already applied that
+ * workspace's `.env` to process.env, so the result is the same as before.
+ */
+/** Read `<root>/.env` (parsed, not applied); {} without one. Read when a workspace is served — a changed file applies on restart, as before. */
+export function readWorkspaceDotenv(root) {
+    try {
+        return parseDotenv(readFileSync(path.join(root, DOTENV_FILE), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+/** The current workspace's environment (outside any workspace: process.env). */
+export function workspaceEnv() {
+    let dotenv;
+    try {
+        dotenv = currentWorkspace().env;
+    }
+    catch {
+        return { ...process.env };
+    }
+    const env = { ...process.env };
+    const injected = new Set((process.env[DOTENV_MARKER] ?? "").split(",").filter(Boolean));
+    // What another workspace's .env put into this process is not this workspace's.
+    for (const key of injected)
+        if (!(key in dotenv))
+            delete env[key];
+    for (const [key, value] of Object.entries(dotenv))
+        if (!process.env[key] || injected.has(key))
+            env[key] = value;
+    return env;
+}

package/dist/core/git.d.ts

@@ -146,3 +146,5 @@ export declare function gitPush(): Promise<{
  * out) before the next one starts, or a short interval piles up processes.
  */
 export declare function startGitSync(): void;
+/** Stop the current workspace's background sync (the workspace closes). A tick in flight finishes, then stops. */
+export declare function stopGitSync(): void;

package/dist/core/git.js

@@ -4,7 +4,8 @@ import path from "node:path";
 import { projectsRootFor, reposRootFor, resolveWorkspace, vibeablesRootFor, isSafeGitName } from "../config.js";
 import { ENV_FILE } from "../runner/docker.js";
 import { getOutputDir, workspaceRoot } from "./context.js";
-import { perWorkspace } from "./workspace.js";
+import { perWorkspace, workspaceOpen } from "./workspace.js";
+import { workspaceEnv } from "./env.js";
 /**
  * Workspace git sync. Several people run kraftwerk against one git repo, so
  * knowledge, agents, skills, channels and workflows travel between them like
@@ -65,7 +66,7 @@ const MAX_BLOCKED = 200;
  * terminal read that never returns, and the inspector hangs with it.
  */
 const gitEnv = (extra) => ({
-    ...process.env,
+    ...workspaceEnv(),
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: "",
     SSH_ASKPASS: "",
@@ -341,6 +342,8 @@ const gitState = perWorkspace(() => ({
     timer: null,
     ticking: false,
     lastRun: 0,
+    /** Set when the workspace closes: a tick in flight does not schedule the next one. */
+    stopped: false,
 }));
 /** Invalidate the status cache after anything that changes the repo. */
 const touched = () => {
@@ -643,10 +646,19 @@ const RECHECK_MS = 60_000;
  * out) before the next one starts, or a short interval piles up processes.
  */
 export function startGitSync() {
+    gitState().stopped = false;
     if (gitState().timer || gitState().ticking)
         return;
     schedule(0);
 }
+/** Stop the current workspace's background sync (the workspace closes). A tick in flight finishes, then stops. */
+export function stopGitSync() {
+    const s = gitState();
+    s.stopped = true;
+    if (s.timer)
+        clearTimeout(s.timer);
+    s.timer = null;
+}
 function schedule(ms) {
     const timer = setTimeout(() => void tick(), ms);
     timer.unref?.();
@@ -671,8 +683,12 @@ async function tick() {
         // A failed tick is retried at the next one; the status carries lastError.
     }
     finally {
-        gitState().ticking = false;
-        schedule(next);
+        // The workspace may have closed while git ran: then its state is gone and nothing is scheduled.
+        if (workspaceOpen()) {
+            gitState().ticking = false;
+            if (!gitState().stopped)
+                schedule(next);
+        }
     }
 }
 async function sync(repo) {

package/dist/core/instances.d.ts

@@ -6,6 +6,8 @@ export declare const legacyWorkspacesDir: () => string;
 /** Durable per-project record. The root is the key; everything else derives from it. */
 export interface WorkspaceRecord {
     root: string;
+    /** The workspace's address on this machine (kraftwerk.yml `slug`, else its folder name), as of its last start. */
+    slug?: string;
     firstSeen: string;
     lastStarted: string;
     /** Set on clean shutdown; older than lastStarted means the last run died. */
@@ -29,10 +31,14 @@ export interface DiscoveredInstance {
     named?: boolean;
     live: true;
     root?: string;
-    /** Server process id (what to signal to stop it). */
+    /** Server process id (what to signal to stop it — unless `hub`). */
     pid: number;
     /** The kraftwerk version the instance runs. */
     version?: string;
+    /** Its slug, when a daemon serves it. */
+    slug?: string;
+    /** Served by a daemon next to other workspaces: stopped by closing it there. */
+    hub?: boolean;
 }
 /**
  * One workspace as the switcher shows it: a known project (running or
@@ -60,12 +66,20 @@ export interface WorkspaceEntry {
 export declare const workspaceRecordName: (root: string) => string;
 /** ~/… for display. */
 export declare const tildify: (p: string) => string;
-/** Write this instance's registry file (call once the server listens). */
-export declare function registerInstance(port: number, root: string): Promise<void>;
-/** Where this instance answers, as the switcher links it (null before listen). */
+/**
+ * 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 declare function registerInstance(port: number, root: string, opts?: {
+    url?: string;
+    slug?: string;
+    hub?: boolean;
+}): Promise<void>;
+/** Where the current workspace answers, as the switcher links it (null before listen). */
 export declare const currentInstanceUrl: () => string | null;
-/** Remove this instance's registry file. Sync so exit handlers can call it. */
-export declare function unregisterInstance(): void;
+/** 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 declare function unregisterInstance(root?: string): void;
 /**
  * All other running instances, verified live. Cached briefly — /api/meta is
  * polled. `fresh` probes now; `readOnly` leaves the records of instances that
@@ -80,10 +94,14 @@ export declare function registerWorkspace(root: string): Promise<void>;
 export declare const syncWorkspaceAgents: (root: string, agents: AgentSummary[]) => Promise<void>;
 export declare const syncWorkspaceChannels: (root: string, channels: ChannelSummary[]) => Promise<void>;
 export declare const syncWorkspaceProjects: (root: string, projects: ProjectHit[]) => Promise<void>;
-/** Stamp lastStopped on clean shutdown. Sync so exit handlers can call it. */
-export declare function markWorkspaceStopped(): void;
+/** Stamp lastStopped on a clean stop — every workspace this process serves when no root is given. Sync so exit handlers can call it. */
+export declare function markWorkspaceStopped(root?: string): void;
 /** All known workspaces, most recently started first. */
 export declare function listWorkspaceRecords(): Promise<WorkspaceRecord[]>;
+/** A record's slug: as registered, or (records from before 0.66) its folder name made into one. */
+export declare const recordSlug: (r: WorkspaceRecord) => string;
+/** Other registered workspaces with this slug — two workspaces cannot share an address. */
+export declare function slugClashes(slug: string, root: string): Promise<WorkspaceRecord[]>;
 /** Drop a workspace record (the root itself is untouched) — from the legacy directory too, see migrateRegistry. */
 export declare function forgetWorkspace(root: string): Promise<boolean>;
 /**
@@ -137,10 +155,12 @@ export interface StartResult {
  */
 export declare function startWorkspace(root: string): Promise<StartResult>;
 /**
- * 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 declare function stopWorkspace(target: {
     root?: string;