@netnodeag/kraftwerk 0.38.0 → 0.39.0

package/dist/inspector/server.js

@@ -6,7 +6,7 @@ import { resolveProject } from "../config.js";
 import { listRuns, getRun, readRunFile } from "./runs.js";
 import { listWorkflows, getWorkflow } from "./workflows.js";
 import { dockerStatus, triggerRun, stopRun } from "./runner.js";
-import { cancelChat, createChat, deleteChat, disposeAllBackends, getChat, listChats, postMessage, resolvePermission, subscribeChat, } from "./chat/sessions.js";
+import { cancelChat, createChat, deleteChat, disposeAllBackends, getChat, listChats, postMessage, resolvePermission, setChatVibeable, subscribeChat, } from "./chat/sessions.js";
 import { bundleDetail, conceptDetail, createBundle, knowledgeIndex, putConcept, verifyFromUi, } from "./knowledge.js";
 import { deleteAgent, getAgent, listAgents, saveAgent, setAgentArchived, agentsRoot, } from "./agents.js";
 import { deleteAgentSkill, getSkill, listAgentSkills, listSkills, readSkill, saveAgentSkill, skillsRoot, } from "./skills.js";
@@ -14,6 +14,7 @@ import { discoverWorkspaces, forgetProject, listWorkspacesDetailed, markProjectS
 import { gitCommit, gitDiff, gitFetch, gitPull, gitPush, gitStatus, startGitSync, } from "./git.js";
 import { getSettings, saveSettings } from "./settings.js";
 import { addRepo, listRepos, openRepos, removeRepo, updateRepo } from "./repos.js";
+import { createVibeable, deleteVibeable, disposeAllDevs, listVibeables, openVibeables, resolveVibeable, serveVibeable, startDev, stopDev, subscribeVibeable, vibeableStatus, } from "./vibeables.js";
 import { searchAgents } from "./search.js";
 import { deleteRoutine, routineStatuses, runRoutineNow, saveRoutine, startRoutineScheduler, } from "./routines.js";
 /**
@@ -219,6 +220,7 @@ async function handleApi(req, res, url) {
             projectRootLabel: tildify(project?.root ?? getProjectRoot()),
             git: (project?.config.git && project.config.git.enabled !== false) === true,
             repos: (project?.config.repos && project.config.repos.enabled !== false) === true,
+            vibeables: (project?.config.vibeables && project.config.vibeables.enabled !== false) === true,
             switcher,
         });
     }
@@ -273,6 +275,75 @@ async function handleApi(req, res, url) {
             return json(res, { error: err.message }, 400);
         }
     }
+    // GET /api/vibeables — every app folder under the vibeables root | POST {name} — create one with the starter
+    if (seg.length === 2 && seg[1] === "vibeables") {
+        if (method === "GET")
+            return json(res, await listVibeables());
+        if (method === "POST") {
+            if ((await openVibeables()).off)
+                return json(res, { error: "vibeables are off" }, 409);
+            try {
+                const body = JSON.parse(await readBody(req));
+                return json(res, await createVibeable(typeof body.name === "string" ? body.name : ""), 201);
+            }
+            catch (err) {
+                return json(res, { error: err.message }, 400);
+            }
+        }
+    }
+    const vibeableError = (err) => {
+        const msg = err.message;
+        return [/^no vibeable/.test(msg) ? 404 : /are off/.test(msg) ? 409 : 400, { error: msg }];
+    };
+    // GET /api/vibeables/<slug> — how the app previews: mode, static url, dev server state | DELETE — remove the folder
+    if (seg.length === 3 && seg[1] === "vibeables") {
+        try {
+            if (method === "GET")
+                return json(res, await vibeableStatus(seg[2]));
+            if (method === "DELETE") {
+                await deleteVibeable(seg[2]);
+                return json(res, { ok: true });
+            }
+        }
+        catch (err) {
+            const [status, body] = vibeableError(err);
+            return json(res, body, status);
+        }
+    }
+    // GET /api/vibeables/<slug>/events — SSE: file changes (debounced) and dev-server state
+    if (seg.length === 4 && seg[1] === "vibeables" && seg[3] === "events" && method === "GET") {
+        let dir;
+        try {
+            dir = (await resolveVibeable(seg[2])).dir;
+        }
+        catch (err) {
+            const [status, body] = vibeableError(err);
+            return json(res, body, status);
+        }
+        res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive" });
+        res.write(":ok\n\n");
+        const unsubscribe = subscribeVibeable(seg[2], dir, (ev) => res.write(`data: ${JSON.stringify(ev)}\n\n`));
+        const heartbeat = setInterval(() => res.write(":hb\n\n"), 25_000);
+        req.on("close", () => {
+            clearInterval(heartbeat);
+            unsubscribe();
+        });
+        return;
+    }
+    // POST /api/vibeables/<slug>/dev/{start,stop} — the app's dev command
+    if (seg.length === 5 && seg[1] === "vibeables" && seg[3] === "dev" && method === "POST") {
+        try {
+            if (seg[4] === "start")
+                return json(res, await startDev(seg[2]));
+            if (seg[4] === "stop")
+                return json(res, await stopDev(seg[2]));
+            return json(res, { error: "not found" }, 404);
+        }
+        catch (err) {
+            const [status, body] = vibeableError(err);
+            return json(res, body, status);
+        }
+    }
     // POST /api/repos/<slug>/update — fetch, fast-forward when clean
     if (seg.length === 4 && seg[1] === "repos" && seg[3] === "update" && method === "POST") {
         try {
@@ -380,6 +451,7 @@ async function handleApi(req, res, url) {
         json(res, { ok: true });
         setTimeout(() => {
             disposeAllBackends();
+            disposeAllDevs();
             process.exit(RESTART_EXIT_CODE);
         }, 150);
         return;
@@ -770,6 +842,18 @@ async function handleApi(req, res, url) {
         });
         return;
     }
+    // POST /api/chats/:id/vibeable {slug | null} — open an app in the chat's preview pane (cwd follows), or close it
+    if (seg.length === 4 && seg[1] === "chats" && seg[3] === "vibeable" && method === "POST") {
+        try {
+            const body = JSON.parse((await readBody(req)) || "{}");
+            const slug = body.slug == null || body.slug === "" ? null : String(body.slug);
+            const result = await setChatVibeable(seg[2], slug);
+            return result.error ? json(res, { error: result.error }, result.status ?? 400) : json(res, result.meta);
+        }
+        catch (err) {
+            return json(res, { error: err.message }, 400);
+        }
+    }
     // POST /api/chats/:id/{message,permission,cancel}
     if (seg.length === 4 && seg[1] === "chats" && method === "POST") {
         let body = {};
@@ -840,6 +924,7 @@ export function startInspector(opts) {
     for (const sig of ["SIGINT", "SIGTERM"]) {
         process.once(sig, () => {
             disposeAllBackends();
+            disposeAllDevs();
             unregisterInstance();
             markProjectStopped();
             process.exit(sig === "SIGINT" ? 130 : 143);
@@ -847,6 +932,7 @@ export function startInspector(opts) {
     }
     process.once("exit", (code) => {
         disposeAllBackends();
+        disposeAllDevs();
         unregisterInstance();
         // A self-restart (new version) is not a stop — the project stays "running".
         if (code !== RESTART_EXIT_CODE)
@@ -859,6 +945,9 @@ export function startInspector(opts) {
                 return json(res, { error: "unexpected Host header" }, 421);
             if (url.pathname.startsWith("/api/"))
                 await handleApi(req, res, url);
+            // /vibeables/<slug>/… is an app's own files, served for the preview pane.
+            else if (url.pathname === "/vibeables" || url.pathname.startsWith("/vibeables/"))
+                await serveVibeable(req, res, url);
             else
                 await serveStatic(res, opts.staticDir, url.pathname);
         }

package/dist/inspector/settings.d.ts

@@ -1,7 +1,7 @@
 import { type ProjectConfig, type SwitcherEntry } from "../config.js";
 /**
  * Workspace settings: read kraftwerk.yml for the UI and write the
- * UI-editable subset (name, icon, switcher, git, repos) back. Edits go through the
+ * UI-editable subset (name, icon, switcher, git, repos, vibeables) back. Edits go through the
  * yaml Document API so comments and every other key survive untouched;
  * a missing kraftwerk.yml is created at the project root on first save.
  */
@@ -28,6 +28,8 @@ export interface SaveSettingsInput {
     git?: GitSettingsInput;
     /** Omitted = untouched. Same rules as git: off with defaults = no block. */
     repos?: ReposSettingsInput;
+    /** Omitted = untouched. Same shape and rules as repos. */
+    vibeables?: ReposSettingsInput;
 }
 export interface ReposSettingsInput {
     enabled: boolean;

package/dist/inspector/settings.js

@@ -1,7 +1,8 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { parseDocument } from "yaml";
-import { ignoreEntryFor, REPOS_DEFAULT_ROOT, resolveProject } from "../config.js";
+import { ignoreEntryFor, REPOS_DEFAULT_ROOT, resolveProject, VIBEABLES_DEFAULT_ROOT } from "../config.js";
+import { ensureVibeablesRoot } from "./vibeables.js";
 import { getProjectRoot } from "./context.js";
 import { ensureReposRoot } from "./repos.js";
 const GIT_DEFAULTS = { remote: "origin", interval: 300, autosync: "pull" };
@@ -70,18 +71,19 @@ function cleanGit(value) {
         return null;
     return { enabled: false, ...out };
 }
-/** The repos block to write; null when the feature is off and nothing else is set. */
-function cleanRepos(value, projectRoot) {
+/** The repos or vibeables block to write; null when the feature is off and nothing else is set. */
+function cleanRootBlock(block, value, projectRoot) {
     if (typeof value !== "object" || value === null)
-        throw new Error("repos must be an object");
+        throw new Error(`${block} must be an object`);
     if (typeof value.enabled !== "boolean")
-        throw new Error("repos.enabled must be true or false");
+        throw new Error(`${block}.enabled must be true or false`);
     const out = {};
     const root = typeof value.root === "string" ? value.root.trim().replace(/\/+$/, "") : "";
     if (root && !ignoreEntryFor(projectRoot, root)) {
-        throw new Error('repos.root must be a directory inside the project (not ".", ".." or an absolute path outside it)');
+        throw new Error(`${block}.root must be a directory inside the project (not ".", ".." or an absolute path outside it)`);
     }
-    if (root && root !== REPOS_DEFAULT_ROOT)
+    const dflt = block === "repos" ? REPOS_DEFAULT_ROOT : VIBEABLES_DEFAULT_ROOT;
+    if (root && root !== dflt)
         out.root = root;
     if (value.enabled)
         return out;
@@ -128,16 +130,25 @@ export async function saveSettings(input) {
             doc.set("git", git);
     }
     if (input.repos !== undefined) {
-        const repos = cleanRepos(input.repos, project.root);
+        const repos = cleanRootBlock("repos", input.repos, project.root);
         if (repos === null)
             doc.delete("repos");
         else
             doc.set("repos", repos);
     }
+    if (input.vibeables !== undefined) {
+        const vibeables = cleanRootBlock("vibeables", input.vibeables, project.root);
+        if (vibeables === null)
+            doc.delete("vibeables");
+        else
+            doc.set("vibeables", vibeables);
+    }
     await fs.writeFile(configPath, doc.toString());
     // Turning repositories on prepares the folder so the first clone and the
     // workspace git both find it in the right state.
     if (input.repos?.enabled)
         await ensureReposRoot().catch(() => { });
+    if (input.vibeables?.enabled)
+        await ensureVibeablesRoot().catch(() => { });
     return getSettings();
 }

package/dist/inspector/vibeables.d.ts

@@ -0,0 +1,152 @@
+import http from "node:http";
+import { type Project } from "../config.js";
+/**
+ * Vibeables: small applications built live in a chat. The agent edits the
+ * folder, the user watches the result in a preview pane next to the thread
+ * — lovable-style, but for whatever ad-hoc software the user needs: a
+ * dashboard, a slideshow, a tracker with its own backend.
+ *
+ * A vibeable is one folder under the vibeables root (`vibeables.root` in
+ * kraftwerk.yml, default kraftwerk-data/vibeables/). Like agents and knowledge it is part
+ * of the workspace: versioned by the workspace git, no repository of its
+ * own. The folder is the registry — whatever directory is under the root
+ * is a vibeable, whoever created it.
+ *
+ * Two ways to run one, chosen by the folder itself:
+ *
+ * - static (default): the inspector serves the folder at /vibeables/<slug>/
+ *   — index.html in, no build step. A file watcher tells the pane to reload.
+ * - dev: `vibeable.yml` names a `dev` command (npm run dev, node server.js).
+ *   The inspector spawns it with PORT set and the pane embeds that server;
+ *   anything with a build tool, a backend or a database lives here.
+ *
+ * Static files go out under a CSP sandbox: the code is what the agent
+ * wrote, and it must not act on the inspector API as the user. Nothing here
+ * has a shell in the middle except the dev command, which is the user's own
+ * choice in their own workspace.
+ */
+export interface VibeableConfig {
+    /** Command that starts a dev server; gets PORT in its environment. */
+    dev?: string;
+    /** Port the dev command listens on. Default: a free port, passed as PORT. */
+    port?: number;
+    /** Folder served in static mode, relative to the vibeable. Default: the vibeable itself. */
+    dir?: string;
+}
+export interface VibeableInfo {
+    /** Folder name under the root; the id everywhere. */
+    slug: string;
+    /** Absolute path of the folder. */
+    path: string;
+    /** index.html exists in the served folder, so the static preview renders something. */
+    hasIndex: boolean;
+    /** Dev command from vibeable.yml, when declared. */
+    dev?: string;
+    /** Set when vibeable.yml exists but is unusable. */
+    configError?: string;
+    /** Newest change inside the folder (node_modules and dot entries excluded). */
+    updatedAt?: string;
+}
+export interface VibeablesView {
+    enabled: boolean;
+    root?: string;
+    vibeables: VibeableInfo[];
+    /** Set when the feature is off or the root cannot be read. */
+    error?: string;
+}
+export interface VibeableDev {
+    command: string;
+    port: number;
+    /** The process is alive. */
+    running: boolean;
+    /** The server answered HTTP on its port. */
+    ready: boolean;
+    pid?: number;
+    startedAt: string;
+    /** Set once the process ended. */
+    exitCode?: number | null;
+    /** Last lines of stdout + stderr. */
+    log: string[];
+}
+export interface VibeableStatus {
+    slug: string;
+    /** Absolute folder path. */
+    path: string;
+    /** Absolute folder served in static mode. */
+    dir: string;
+    /** What the pane shows right now: the dev server once it runs, the static folder otherwise. */
+    mode: "static" | "dev";
+    /** Static preview url, relative to the inspector. */
+    url: string;
+    config: VibeableConfig;
+    /** Set when vibeable.yml exists but is unusable; static mode still works. */
+    configError?: string;
+    dev?: VibeableDev;
+}
+export type VibeableEvent = {
+    type: "change";
+    files: string[];
+} | {
+    type: "dev";
+    dev: VibeableDev;
+} | {
+    type: "error";
+    message: string;
+};
+export declare const VIBEABLE_CONFIG_FILE = "vibeable.yml";
+export declare function safeVibeableSlug(slug: string): string;
+/** The files a fresh vibeable starts with: a page that renders, and the config template. */
+export declare function vibeableStarter(name: string): Record<string, string>;
+/** Resolve the project and its vibeables block. `off` when the feature is not on. */
+export declare function openVibeables(): Promise<{
+    project?: Project;
+    root?: string;
+    off?: boolean;
+    error?: string;
+}>;
+/** Make sure the root exists; runs when the feature is switched on. */
+export declare function ensureVibeablesRoot(): Promise<void>;
+interface Resolved {
+    slug: string;
+    dir: string;
+    servedDir: string;
+    config: VibeableConfig;
+    configError?: string;
+}
+/** The folder behind a slug, or throw `no vibeable "<slug>"`. */
+export declare function resolveVibeable(slug: string): Promise<Resolved>;
+/** Every folder under the root, alphabetically. Dot folders and odd names are skipped. */
+export declare function listVibeables(): Promise<VibeablesView>;
+/**
+ * Create <root>/<name> with the starter files. The folder is claimed with a
+ * plain mkdir first: it fails when anything is there already, so two
+ * creates of the same name cannot both win.
+ */
+export declare function createVibeable(name: string): Promise<VibeableInfo>;
+/** Delete a vibeable folder. Its history stays in the workspace git. */
+export declare function deleteVibeable(slug: string): Promise<void>;
+export declare function vibeableStatus(slug: string): Promise<VibeableStatus>;
+/**
+ * GET /vibeables/<slug>/<file>. Dot segments (.env, .git) are never served;
+ * a directory answers with its index.html, and a directory url without the
+ * trailing slash redirects so the page's relative links resolve.
+ */
+export declare function serveVibeable(req: http.IncomingMessage, res: http.ServerResponse, url: URL): Promise<void>;
+/**
+ * Stream a vibeable's events: file changes (debounced, node_modules and
+ * the like excluded) and dev-server state. The watcher exists while
+ * someone listens. `fs.watch` recursive covers macOS and Linux on Node 20+;
+ * where it cannot watch, the pane still has its manual reload.
+ */
+export declare function subscribeVibeable(slug: string, dir: string, fn: (ev: VibeableEvent) => void): () => void;
+/**
+ * Start the vibeable's dev command. Idempotent while it runs. The child
+ * leads its own process group so stopping it also stops what it spawned
+ * (npm → vite → esbuild).
+ */
+export declare function startDev(slug: string): Promise<VibeableStatus>;
+/** SIGTERM the dev process group, SIGKILL what is still there after 3 s. */
+export declare function stopDev(slug: string): Promise<VibeableStatus>;
+/** Server shutdown: no dev server may outlive the inspector. */
+export declare function disposeAllDevs(): void;
+export {};