@netnodeag/kraftwerk 0.33.0 → 0.34.1

package/dist/cli/projects.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import chalk from "chalk";
 import Table from "cli-table3";
-import { discoverWorkspaces, forgetProject, startProject, tildify, } from "../inspector/instances.js";
+import { discoverWorkspaces, forgetProject, startProject, stopProject, tildify, } from "../inspector/instances.js";
 /**
  * `kraftwerk projects` — every project that ever ran the inspector on this
  * machine (~/.kraftwerk/projects), joined with what is running right now.
@@ -9,9 +9,11 @@ import { discoverWorkspaces, forgetProject, startProject, tildify, } from "../in
  *
  *   kraftwerk projects                 list: name, root, running/stopped
  *   kraftwerk projects start <ref>     relaunch `kraftwerk ui` in that root, detached
+ *   kraftwerk projects stop <ref>      SIGTERM a running UI (also ones started in a terminal)
  *   kraftwerk projects forget <ref>    drop the record (the folder stays)
  *
- * <ref> is a project name, the root's folder name, or the root path.
+ * <ref> is a project name, the root's folder name, the root path, or a
+ * port / localhost:port for running instances that recorded no root.
  */
 const fmtAgo = (iso) => {
     if (!iso)
@@ -38,28 +40,31 @@ const status = (e) => {
     const clean = !!e.lastStopped && !!e.lastStarted && e.lastStopped >= e.lastStarted;
     return clean ? chalk.dim("stopped") : chalk.yellow("died");
 };
-async function resolveRef(ref) {
-    const all = (await discoverWorkspaces()).filter((e) => e.root);
+/** Match a ref against known workspaces; `needRoot` excludes rootless live instances (start/forget need a root). */
+async function resolveRef(ref, needRoot = true) {
+    const all = (await discoverWorkspaces()).filter((e) => e.root || !needRoot);
     const abs = path.resolve(ref);
+    const port = /^\d+$/.test(ref) ? `http://localhost:${ref}` : `http://${ref.replace(/^https?:\/\//, "")}`;
     const hits = all.filter((e) => e.root === abs ||
         e.root === ref ||
         e.name === ref ||
-        path.basename(e.root) === ref);
+        (e.root && path.basename(e.root) === ref) ||
+        e.url === port);
     if (hits.length === 1)
         return hits[0];
     if (hits.length === 0) {
         console.error(chalk.red(`No known project "${ref}". See \`kraftwerk projects\`.`));
         process.exit(2);
     }
-    console.error(chalk.red(`"${ref}" is ambiguous — use the root path:`));
+    console.error(chalk.red(`"${ref}" is ambiguous — use the root path or port:`));
     for (const h of hits)
-        console.error(`  ${h.root}`);
+        console.error(`  ${h.root ?? h.url}`);
     process.exit(2);
 }
 export function registerProjectCommands(program) {
     const projects = program
         .command("projects")
-        .description("Known kraftwerk projects on this machine: list, start a stopped UI, forget");
+        .description("Known kraftwerk projects on this machine: list, start a stopped UI, stop a running one, forget");
     projects
         .command("list", { isDefault: true })
         .description("List known projects with their root and whether the UI is running")
@@ -109,6 +114,23 @@ export function registerProjectCommands(program) {
         console.log(`${chalk.green("✔")} ${entry.name} ${r.live ? "running" : "starting"}: ${chalk.cyan(r.url)}` +
             chalk.dim(` (pid ${r.pid}${r.log ? `, log ${tildify(r.log)}` : ""})`));
     });
+    projects
+        .command("stop")
+        .description("Stop a running UI (SIGTERM to its server; works for terminal-started ones too)")
+        .argument("<ref>", "Project name, folder name, root path, or port")
+        .action(async (ref) => {
+        const entry = await resolveRef(ref, false);
+        if (!entry.live) {
+            console.log(chalk.dim(`${entry.name} is not running.`));
+            return;
+        }
+        const r = await stopProject({ root: entry.root, url: entry.url });
+        if (!r.ok) {
+            console.error(chalk.red(`Could not stop ${entry.name}: ${r.error}`));
+            process.exit(1);
+        }
+        console.log(`${chalk.green("✔")} ${entry.name} stopped ${chalk.dim(`(${entry.url.replace(/^https?:\/\//, "")})`)}`);
+    });
     projects
         .command("forget")
         .description("Remove a project from the registry (its folder is untouched)")

package/dist/inspector/instances.d.ts

@@ -14,6 +14,8 @@ export interface DiscoveredInstance {
     icon?: string;
     live: true;
     root?: string;
+    /** Server process id (what to signal to stop it). */
+    pid: number;
 }
 /**
  * One workspace as the switcher shows it: a known project (running or
@@ -56,6 +58,31 @@ export declare function forgetProject(root: string): Promise<boolean>;
  * discoverInstances — /api/meta is polled and this stats every root.
  */
 export declare function discoverWorkspaces(): Promise<WorkspaceEntry[]>;
+export type WorkspaceState = "running" | "stopped" | "died" | "missing" | "orphaned";
+/** A workspace with everything the admin screen shows. */
+export interface WorkspaceDetail extends WorkspaceEntry {
+    /** The instance answering this request. */
+    current?: boolean;
+    /** kraftwerk.yml present in the root itself (not inherited from an ancestor). */
+    hasConfig?: boolean;
+    /** The root directory itself is gone (vs. still there but no longer a project). */
+    dirGone?: boolean;
+    state: WorkspaceState;
+    firstSeen?: string;
+    startCount?: number;
+    counts?: {
+        agents: number;
+        workflows: number;
+        runs: number;
+        chats: number;
+    };
+}
+/**
+ * Every workspace including this one, with config presence, counts of
+ * what lives in the root, and a single derived state. Not cached — the
+ * admin screen polls slowly and wants fresh counts.
+ */
+export declare function listWorkspacesDetailed(): Promise<WorkspaceDetail[]>;
 export interface StartResult {
     ok: boolean;
     url?: string;
@@ -74,3 +101,16 @@ export interface StartResult {
  * straight to it.
  */
 export declare function startProject(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.
+ */
+export declare function stopProject(target: {
+    root?: string;
+    url?: string;
+}): Promise<{
+    ok: boolean;
+    error?: string;
+}>;

package/dist/inspector/instances.js

@@ -109,7 +109,7 @@ export async function discoverInstances() {
             await fs.unlink(path.join(INSTANCES_DIR, f)).catch(() => { }); // stale — prune
             return null;
         }
-        return { ...found, root: rec.root };
+        return { ...found, root: rec.root, pid: rec.pid };
     }));
     const entries = probed
         .filter((e) => e != null)
@@ -264,6 +264,92 @@ export async function discoverWorkspaces() {
     wsCache = { at: Date.now(), entries };
     return entries;
 }
+const countDirs = async (dir, marker) => {
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith("."));
+        if (!marker)
+            return dirs.length;
+        const flags = await Promise.all(dirs.map((d) => fs.stat(path.join(dir, d.name, marker)).then(() => true, () => false)));
+        return flags.filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+};
+const countEntries = async (dir) => {
+    try {
+        return (await fs.readdir(dir)).filter((n) => !n.startsWith(".")).length;
+    }
+    catch {
+        return 0;
+    }
+};
+/**
+ * Every workspace including this one, with config presence, counts of
+ * what lives in the root, and a single derived state. Not cached — the
+ * admin screen polls slowly and wants fresh counts.
+ */
+export async function listWorkspacesDetailed() {
+    const others = await discoverWorkspaces();
+    const all = [...others];
+    if (selfRoot && selfPort) {
+        const d = await describeRoot(selfRoot);
+        const rec = await readProject(projectFile(selfRoot));
+        all.unshift({
+            name: d.name,
+            icon: d.icon,
+            url: `http://localhost:${selfPort}`,
+            live: true,
+            root: selfRoot,
+            rootLabel: tildify(selfRoot),
+            exists: true,
+            lastStarted: rec?.lastStarted,
+            lastStopped: rec?.lastStopped,
+        });
+    }
+    return Promise.all(all.map(async (e) => {
+        const current = !!selfRoot && e.root === selfRoot;
+        const base = { ...e, current, state: e.live ? "running" : "stopped" };
+        if (!e.root)
+            return base;
+        const rec = await readProject(projectFile(e.root));
+        base.firstSeen = rec?.firstSeen;
+        base.startCount = rec?.startCount;
+        // "missing" = the folder is gone; "orphaned" = it is still there but
+        // no longer a project of its own (kraftwerk.yml removed, or it now
+        // resolves to an ancestor). Both are removable from the registry.
+        const dirGone = !(await isDir(e.root));
+        base.dirGone = dirGone;
+        if (!e.live) {
+            if (dirGone)
+                base.state = "missing";
+            else if (e.exists === false)
+                base.state = "orphaned";
+            else if (!(rec?.lastStopped && rec.lastStarted && rec.lastStopped >= rec.lastStarted))
+                base.state = "died";
+        }
+        if (e.exists === false) {
+            base.hasConfig = false;
+            return base;
+        }
+        try {
+            const project = await resolveProject(e.root);
+            base.hasConfig = !!project.configPath && path.dirname(project.configPath) === path.resolve(e.root);
+            const [agents, workflows, runs, chats] = await Promise.all([
+                countDirs(path.resolve(project.root, project.config.agents ?? "agents"), "agent.yml"),
+                project.workflowsRoot ? countDirs(project.workflowsRoot, "workflow.yml") : Promise.resolve(0),
+                countDirs(path.join(project.outputDir, "runs")),
+                countEntries(path.join(project.outputDir, "chats")),
+            ]);
+            base.counts = { agents, workflows, runs, chats };
+        }
+        catch {
+            base.hasConfig = false;
+        }
+        return base;
+    }));
+}
 /**
  * Launch `kraftwerk ui` for a root as a detached process (selfCommand:
  * the bin this process runs from), logging to ~/.kraftwerk/logs/<key>.log.
@@ -334,3 +420,36 @@ export async function startProject(root) {
     }
     return { ok: true, url, live: false, pid: child.pid, log };
 }
+/* ---------- 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.
+ */
+export async function stopProject(target) {
+    if (target.root && path.resolve(target.root) === selfRoot) {
+        return { ok: false, error: "that is this workspace — stop it from its own terminal or pid" };
+    }
+    cache = wsCache = null;
+    const live = await discoverInstances();
+    const inst = live.find((i) => (target.root && i.root === path.resolve(target.root)) || (target.url && i.url === target.url));
+    if (!inst)
+        return { ok: false, error: "not running" };
+    try {
+        process.kill(inst.pid, "SIGTERM");
+    }
+    catch (err) {
+        return { ok: false, error: `could not signal pid ${inst.pid}: ${err.message}` };
+    }
+    const port = Number(new URL(inst.url).port);
+    const deadline = Date.now() + 5_000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 250));
+        if (!(await probe(port))) {
+            cache = wsCache = null;
+            return { ok: true };
+        }
+    }
+    return { ok: false, error: `pid ${inst.pid} still answers on ${inst.url} after 5s` };
+}

package/dist/inspector/server.js

@@ -10,7 +10,7 @@ import { cancelChat, createChat, deleteChat, disposeAllBackends, getChat, listCh
 import { bundleDetail, conceptDetail, createBundle, knowledgeIndex, putConcept, verifyFromUi, } from "./knowledge.js";
 import { deleteMember, getMember, listMembers, saveMember, setMemberArchived, teamRoot, } from "./team.js";
 import { deleteAgentSkill, getSkill, listAgentSkills, listSkills, readSkill, saveAgentSkill, skillsRoot, } from "./skills.js";
-import { discoverWorkspaces, forgetProject, markProjectStopped, registerInstance, registerProject, startProject, tildify, unregisterInstance, } from "./instances.js";
+import { discoverWorkspaces, forgetProject, listWorkspacesDetailed, markProjectStopped, registerInstance, registerProject, startProject, stopProject, tildify, unregisterInstance, } from "./instances.js";
 import { getSettings, saveSettings } from "./settings.js";
 import { deleteRoutine, routineStatuses, runRoutineNow, saveRoutine, startRoutineScheduler, } from "./routines.js";
 /**
@@ -123,6 +123,10 @@ async function handleApi(req, res, url) {
             switcher,
         });
     }
+    // GET /api/projects — every known workspace incl. this one, with state + counts (admin screen)
+    if (seg.length === 2 && seg[1] === "projects" && method === "GET") {
+        return json(res, await listWorkspacesDetailed());
+    }
     // POST /api/projects/start {root} — launch `kraftwerk ui` for a known
     // project as a detached process (the switcher's Start button).
     if (seg.length === 3 && seg[1] === "projects" && seg[2] === "start" && method === "POST") {
@@ -137,6 +141,19 @@ async function handleApi(req, res, url) {
             return json(res, { error: err.message }, 400);
         }
     }
+    // POST /api/projects/stop {root | url} — SIGTERM a running workspace's server
+    if (seg.length === 3 && seg[1] === "projects" && seg[2] === "stop" && method === "POST") {
+        try {
+            const target = JSON.parse(await readBody(req));
+            if (!target.root && !target.url)
+                return json(res, { error: "root or url required" }, 400);
+            const result = await stopProject(target);
+            return json(res, result, result.ok ? 200 : 409);
+        }
+        catch (err) {
+            return json(res, { error: err.message }, 400);
+        }
+    }
     // POST /api/projects/forget {root} — drop a project from the registry
     if (seg.length === 3 && seg[1] === "projects" && seg[2] === "forget" && method === "POST") {
         try {