@netnodeag/kraftwerk 0.34.2 → 0.36.0

package/dist/inspector/instances.js

@@ -20,6 +20,9 @@ import { selfCommand } from "./self-command.js";
  * the root's kraftwerk.yml at read time, so it is always current. A
  * project that is not running can be started again from the switcher or
  * `kraftwerk projects start` — that is what makes a killed UI findable.
+ * The record also carries the project's agent roster (written whenever the
+ * instance reads it), so the ⌘K palette can list every workspace's agents
+ * from a handful of small files without probing anything.
  */
 const HOME = path.join(os.homedir(), ".kraftwerk");
 const INSTANCES_DIR = path.join(HOME, "instances");
@@ -47,6 +50,8 @@ export async function registerInstance(port, root) {
     }
     catch { } // best-effort — without it discovery just won't see us
 }
+/** 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 {
@@ -60,8 +65,16 @@ export function unregisterInstance() {
  * each other's /api/meta must not recurse.
  */
 async function probe(port) {
+    // `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));
+}
+async function probeAt(host, port) {
     try {
-        const r = await fetch(`http://127.0.0.1:${port}/api/meta?probe=1`, {
+        const r = await fetch(`http://${host}:${port}/api/meta?probe=1`, {
             signal: AbortSignal.timeout(400),
         });
         if (!r.ok)
@@ -129,6 +142,7 @@ async function readProject(file) {
             lastStarted: rec.lastStarted ?? rec.firstSeen ?? "",
             lastStopped: rec.lastStopped,
             startCount: rec.startCount ?? 1,
+            ...(Array.isArray(rec.agents) ? { agents: rec.agents } : {}),
         };
     }
     catch {
@@ -147,11 +161,33 @@ export async function registerProject(root) {
             firstSeen: prev?.firstSeen || now,
             lastStarted: now,
             startCount: (prev?.startCount ?? 0) + 1,
+            ...(prev?.agents ? { agents: prev.agents } : {}),
         };
         await fs.writeFile(projectFile(abs), JSON.stringify(rec, null, 2));
     }
     catch { } // best-effort, like the instance file
 }
+let syncedAgents = "";
+/**
+ * Write the roster into the project's record. Called on every roster read
+ * (the UI polls it, routines tick it), so a record only changes when the
+ * roster did. Roots with no record (a CLI run in a project that never
+ * started the inspector) are left alone.
+ */
+export async function syncProjectAgents(root, agents) {
+    const key = `${root}\n${JSON.stringify(agents)}`;
+    if (key === syncedAgents)
+        return;
+    try {
+        const file = projectFile(root);
+        const rec = await readProject(file);
+        if (!rec)
+            return;
+        await fs.writeFile(file, JSON.stringify({ ...rec, agents }, null, 2));
+        syncedAgents = key;
+    }
+    catch { }
+}
 /** Stamp lastStopped on clean shutdown. Sync so exit handlers can call it. */
 export function markProjectStopped() {
     if (!selfRoot)

package/dist/inspector/routines.d.ts

@@ -1,14 +1,14 @@
 /**
- * Routines: per-team-member scheduled prompts — "message your agent every
- * weekday at 9". Definitions live next to the member (git-tracked):
+ * Routines: per-agent scheduled prompts — "message your agent every
+ * weekday at 9". Definitions live next to the agent (git-tracked):
  *
  *   agents/<slug>/routines.yml    # list of { id, name, schedule, prompt, enabled }
  *
  * Runtime state (last run / last session / errors) is run-state, not
  * config, so it lives in <output>/routines-state.json. The scheduler is a
  * plain interval inside the inspector server: each due routine opens a new
- * session (chat) for the member and posts the prompt — the run shows up in
- * the member's sessions sidebar like any conversation. Schedules use
+ * session (chat) for the agent and posts the prompt — the run shows up in
+ * the agent's sessions sidebar like any conversation. Schedules use
  * standard 5-field cron in the server's local time.
  */
 export interface Routine {

package/dist/inspector/routines.js

@@ -2,7 +2,7 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { parse, stringify } from "yaml";
 import { getOutputDir } from "./context.js";
-import { getMember, listMembers, safeMemberSlug, teamRoot } from "./team.js";
+import { getAgent, listAgents, safeAgentSlug, agentsRoot } from "./agents.js";
 import { createChat, postMessage } from "./chat/sessions.js";
 /* ---------- cron ---------- */
 const ALIASES = {
@@ -86,7 +86,7 @@ export function nextRun(schedule, from = new Date()) {
 }
 /* ---------- definition CRUD (agents/<slug>/routines.yml) ---------- */
 async function routinesFile(slug) {
-    return path.join(await teamRoot(), safeMemberSlug(slug), "routines.yml");
+    return path.join(await agentsRoot(), safeAgentSlug(slug), "routines.yml");
 }
 function normalizeRoutine(raw) {
     const id = String(raw.id ?? "").trim();
@@ -179,14 +179,14 @@ export async function routineStatuses(slug) {
     });
 }
 /* ---------- firing ---------- */
-/** Open a fresh session for the member and post the routine's prompt. */
+/** Open a fresh session for the agent and post the routine's prompt. */
 async function fireRoutine(slug, routine) {
-    const member = await getMember(slug);
-    if (!member)
-        throw new Error(`team agent "${slug}" not found`);
+    const def = await getAgent(slug);
+    if (!def)
+        throw new Error(`agent "${slug}" not found`);
     const meta = await createChat({
-        agent: member.harness,
-        scope: { kind: "team", member: slug, routine: routine.id },
+        agent: def.harness,
+        scope: { kind: "agent", slug: slug, routine: routine.id },
         title: `⏰ ${routine.name}`,
     });
     const { error } = await postMessage(meta.id, routine.prompt);
@@ -219,16 +219,16 @@ async function tick() {
     const now = new Date();
     const p = (n) => String(n).padStart(2, "0");
     const minuteKey = `${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())}T${p(now.getHours())}:${p(now.getMinutes())}`;
-    let members;
+    let agents;
     try {
-        members = await listMembers();
+        agents = await listAgents();
     }
     catch {
         return;
     }
     const state = await readState();
     let dirty = false;
-    for (const m of members) {
+    for (const m of agents) {
         for (const r of await listRoutines(m.slug).catch(() => [])) {
             if (!r.enabled)
                 continue;

package/dist/inspector/search.d.ts

@@ -0,0 +1,25 @@
+import { type AgentSummary } from "./agents.js";
+/**
+ * The ⌘K palette: every active agent in every workspace this machine
+ * knows, so a user can jump to one without switching workspaces first.
+ * This instance reads its own roster from disk; the others come from the
+ * project registry, where each instance records its roster whenever it
+ * reads it (see instances.ts). Stopped workspaces are listed too — the
+ * palette starts them on the way to the agent.
+ */
+export interface WorkspaceAgents {
+    name: string;
+    icon?: string;
+    /** Where the workspace's UI lives — hits link to `${url}/#/agents/<slug>`. */
+    url: string;
+    /** Project root (what /api/projects/start takes for a stopped workspace). */
+    root?: string;
+    /** The instance answering this request: hits navigate in place. */
+    current: boolean;
+    live: boolean;
+    agents: AgentSummary[];
+}
+export interface AgentSearch {
+    workspaces: WorkspaceAgents[];
+}
+export declare function searchAgents(): Promise<AgentSearch>;

package/dist/inspector/search.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { resolveProject } from "../config.js";
+import { getProjectRoot } from "./context.js";
+import { listAgents, toSummary } from "./agents.js";
+import { currentInstanceUrl, discoverWorkspaces, listProjects } from "./instances.js";
+export async function searchAgents() {
+    const project = await resolveProject(getProjectRoot()).catch(() => null);
+    const self = {
+        name: project?.config.name ?? path.basename(project?.root ?? getProjectRoot()),
+        icon: project?.config.icon || undefined,
+        url: currentInstanceUrl() ?? "",
+        root: project?.root ?? getProjectRoot(),
+        current: true,
+        live: true,
+        agents: (await listAgents().catch(() => [])).filter((a) => !a.archived).map(toSummary),
+    };
+    const [workspaces, projects] = await Promise.all([discoverWorkspaces(), listProjects()]);
+    const rosters = new Map(projects.map((p) => [p.root, p.agents ?? []]));
+    const others = workspaces
+        .filter((w) => w.root && w.exists !== false)
+        .map((w) => ({
+        name: w.name,
+        icon: w.icon,
+        url: w.url,
+        root: w.root,
+        current: false,
+        live: w.live,
+        agents: rosters.get(w.root) ?? [],
+    }));
+    return { workspaces: [self, ...others] };
+}

package/dist/inspector/server.js

@@ -1,4 +1,4 @@
-import { promises as fs } from "node:fs";
+import { existsSync, promises as fs } from "node:fs";
 import http from "node:http";
 import path from "node:path";
 import { setOutputDir, setProjectRoot, getOutputDir, getProjectRoot } from "./context.js";
@@ -8,10 +8,12 @@ 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 { bundleDetail, conceptDetail, createBundle, knowledgeIndex, putConcept, verifyFromUi, } from "./knowledge.js";
-import { deleteMember, getMember, listMembers, saveMember, setMemberArchived, teamRoot, } from "./team.js";
+import { deleteAgent, getAgent, listAgents, saveAgent, setAgentArchived, agentsRoot, } from "./agents.js";
 import { deleteAgentSkill, getSkill, listAgentSkills, listSkills, readSkill, saveAgentSkill, skillsRoot, } from "./skills.js";
 import { discoverWorkspaces, forgetProject, listWorkspacesDetailed, markProjectStopped, registerInstance, registerProject, startProject, stopProject, tildify, unregisterInstance, } from "./instances.js";
+import { gitCommit, gitDiff, gitFetch, gitPull, gitPush, gitStatus, startGitSync, } from "./git.js";
 import { getSettings, saveSettings } from "./settings.js";
+import { searchAgents } from "./search.js";
 import { deleteRoutine, routineStatuses, runRoutineNow, saveRoutine, startRoutineScheduler, } from "./routines.js";
 /**
  * The inspector server: a plain node:http server with no dependencies.
@@ -57,6 +59,59 @@ function readBody(req) {
         req.on("error", reject);
     });
 }
+/**
+ * Interface to bind. Loopback by default: the UI is unauthenticated and its
+ * chat runs coding agents against the repo, so it must not appear on the LAN
+ * because someone started it on a laptop in a café. Inside a container the
+ * default flips to all interfaces — loopback there would make the published
+ * port unreachable while the in-container health check keeps passing, and
+ * the port mapping (compose publishes to 127.0.0.1) is the boundary anyway.
+ * KRAFTWERK_UI_HOST overrides either way.
+ */
+const IN_CONTAINER = existsSync("/.dockerenv") || existsSync("/run/.containerenv");
+const INSPECTOR_HOST = process.env.KRAFTWERK_UI_HOST || (IN_CONTAINER ? "0.0.0.0" : "127.0.0.1");
+const LOOPBACK_NAMES = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+const LOOPBACK_BIND = LOOPBACK_NAMES.has(INSPECTOR_HOST);
+/**
+ * Whether the Host header names this server. A loopback bind alone does not
+ * keep other sites out: a page on evil.example can re-point that name at
+ * 127.0.0.1 after it loaded (DNS rebinding) and then talk to us as if it
+ * were same-origin — every check that compares Origin to Host passes,
+ * because both say evil.example. So while bound to loopback, only loopback
+ * names are served. Bound elsewhere (a container behind a proxy) the name
+ * is whatever the proxy forwards, and the proxy is the boundary.
+ *
+ * A reverse proxy on the same machine talks to the loopback bind with the
+ * browser's Host, which is not a loopback name. It says so in
+ * X-Forwarded-Host, and that header cannot come from a rebinding page: a
+ * browser only sends it after a CORS preflight, which this server never
+ * answers, and a form post cannot set headers at all.
+ */
+function hostAllowed(req) {
+    if (!LOOPBACK_BIND)
+        return true;
+    if (forwardedHost(req))
+        return true;
+    const host = req.headers.host;
+    if (!host)
+        return true;
+    const name = hostnameOf(host);
+    return LOOPBACK_NAMES.has(name) || name.endsWith(".localhost");
+}
+/** First X-Forwarded-Host value, or undefined when no proxy set one. */
+function forwardedHost(req) {
+    const forwarded = req.headers["x-forwarded-host"];
+    return (Array.isArray(forwarded) ? forwarded[0] : forwarded)?.split(",")[0].trim() || undefined;
+}
+/** "localhost:1981" → "localhost", "[::1]:1981" → "[::1]"; "" when unparsable. */
+function hostnameOf(host) {
+    try {
+        return new URL(`http://${host}`).hostname;
+    }
+    catch {
+        return "";
+    }
+}
 /** Exit code the `kraftwerk ui` supervisor treats as "relaunch me". */
 export const RESTART_EXIT_CODE = 75;
 /** Whether a supervisor is around to respawn us (set by `kraftwerk ui`). */
@@ -87,9 +142,48 @@ async function getPkgName() {
         return "";
     }
 }
+/**
+ * Whether a state-changing request came from this UI rather than from some
+ * other page the user happens to have open. The inspector has no login of
+ * its own: every POST here writes files, commits, pushes, or starts a coding
+ * agent, and a cross-site form post needs no preflight to reach us. Browsers
+ * attach Origin to every POST/PUT/DELETE, form submissions included, so a
+ * mismatch is a forgery. A missing Origin is a non-browser client (curl, a
+ * script), which was never the attack this guards against.
+ */
+function sameOrigin(req) {
+    if (req.headers["sec-fetch-site"] === "cross-site")
+        return false;
+    const origin = req.headers.origin;
+    if (origin === undefined)
+        return true;
+    // A sandboxed iframe or a redirected form sends "null", which matches no host.
+    if (origin === "null")
+        return false;
+    // A reverse proxy that rewrites Host to the upstream (nginx by default)
+    // says who the browser addressed in X-Forwarded-Host. Trusting it is safe
+    // here: a browser cannot set that header without a CORS preflight, which
+    // this API never answers, and a form post cannot set headers at all.
+    const host = forwardedHost(req) || req.headers.host;
+    if (!host)
+        return false;
+    try {
+        // Parse the host under the origin's scheme so a default port written
+        // out by the proxy ("kw.example.com:443") compares equal to the
+        // browser's Origin, which never carries one.
+        const o = new URL(origin);
+        return o.host === new URL(`${o.protocol}//${host}`).host;
+    }
+    catch {
+        return false;
+    }
+}
 async function handleApi(req, res, url) {
     const seg = url.pathname.split("/").filter(Boolean); // ["api", ...]
     const method = req.method ?? "GET";
+    if (method !== "GET" && method !== "HEAD" && !sameOrigin(req)) {
+        return json(res, { error: "cross-origin request refused" }, 403);
+    }
     // GET /api/meta — package version + project name ("environment") for the UI.
     // ?probe=1 marks a discovery probe from another instance: answer identity
     // only, skip our own discovery (two instances must not probe each other
@@ -120,9 +214,46 @@ async function handleApi(req, res, url) {
             projectIcon: project?.config.icon ?? "",
             projectRoot: project?.root ?? getProjectRoot(),
             projectRootLabel: tildify(project?.root ?? getProjectRoot()),
+            git: (project?.config.git && project.config.git.enabled !== false) === true,
             switcher,
         });
     }
+    // GET /api/git — branch, ahead/behind, changed files (the git screen polls
+    // this, so it is cached for a beat; ?fresh=1 bypasses the cache).
+    if (seg.length === 2 && seg[1] === "git" && method === "GET") {
+        return json(res, await gitStatus(url.searchParams.has("fresh")));
+    }
+    // GET /api/git/diff?path= — unified diff for one file
+    if (seg.length === 3 && seg[1] === "git" && seg[2] === "diff" && method === "GET") {
+        const file = url.searchParams.get("path");
+        if (!file)
+            return json(res, { error: "path required" }, 400);
+        return json(res, await gitDiff(file));
+    }
+    // POST /api/git/commit {paths, message} — stage and commit the selection.
+    // Commit and push stay manual; the background timer never writes history.
+    if (seg.length === 3 && seg[1] === "git" && seg[2] === "commit" && method === "POST") {
+        try {
+            const body = JSON.parse(await readBody(req));
+            const paths = Array.isArray(body.paths) ? body.paths.filter((p) => typeof p === "string") : [];
+            const message = typeof body.message === "string" ? body.message : "";
+            const result = await gitCommit(paths, message);
+            return json(res, result, result.ok ? 200 : 409);
+        }
+        catch (err) {
+            return json(res, { error: err.message }, 400);
+        }
+    }
+    // POST /api/git/{fetch,pull,push}
+    if (seg.length === 3 && seg[1] === "git" && method === "POST" && ["fetch", "pull", "push"].includes(seg[2])) {
+        const run = seg[2] === "fetch" ? gitFetch : seg[2] === "pull" ? gitPull : gitPush;
+        const result = await run();
+        return json(res, result, result.ok ? 200 : 409);
+    }
+    // GET /api/search/agents — active agents of every reachable workspace (the ⌘K palette)
+    if (seg.length === 3 && seg[1] === "search" && seg[2] === "agents" && method === "GET") {
+        return json(res, await searchAgents());
+    }
     // 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());
@@ -170,7 +301,7 @@ async function handleApi(req, res, url) {
     if (seg.length === 2 && seg[1] === "settings" && method === "GET") {
         return json(res, await getSettings());
     }
-    // PUT /api/settings — write the UI-editable subset (name, icon, switcher) back
+    // PUT /api/settings — write the UI-editable subset (name, icon, switcher, git) back
     if (seg.length === 2 && seg[1] === "settings" && method === "PUT") {
         try {
             const input = JSON.parse(await readBody(req));
@@ -390,33 +521,33 @@ async function handleApi(req, res, url) {
         const skill = await getSkill(decodeURIComponent(seg[2]));
         return skill ? json(res, skill) : json(res, { error: "not found" }, 404);
     }
-    // GET/POST /api/team — member list / create a member
-    if (seg.length === 2 && seg[1] === "team") {
+    // GET/POST /api/agents — member list / create a member
+    if (seg.length === 2 && seg[1] === "agents") {
         if (method === "GET") {
-            return json(res, { root: await teamRoot(), members: await listMembers() });
+            return json(res, { root: await agentsRoot(), agents: await listAgents() });
         }
         if (method === "POST") {
             try {
                 const body = JSON.parse(await readBody(req));
-                return json(res, await saveMember({ ...body, slug: undefined }));
+                return json(res, await saveAgent({ ...body, slug: undefined }));
             }
             catch (err) {
                 return json(res, { error: err.message }, 400);
             }
         }
     }
-    // POST /api/team/:slug/archive — archive/unarchive a member ({ archived: boolean })
-    if (seg.length === 4 && seg[1] === "team" && seg[3] === "archive" && method === "POST") {
+    // POST /api/agents/:slug/archive — archive/unarchive a member ({ archived: boolean })
+    if (seg.length === 4 && seg[1] === "agents" && seg[3] === "archive" && method === "POST") {
         try {
             const body = JSON.parse(await readBody(req));
-            return json(res, await setMemberArchived(decodeURIComponent(seg[2]), body.archived === true));
+            return json(res, await setAgentArchived(decodeURIComponent(seg[2]), body.archived === true));
         }
         catch (err) {
             return json(res, { error: err.message }, 400);
         }
     }
-    // GET/POST /api/team/:slug/skills — the agent's own skills / create or update one
-    if (seg.length === 4 && seg[1] === "team" && seg[3] === "skills") {
+    // GET/POST /api/agents/:slug/skills — the agent's own skills / create or update one
+    if (seg.length === 4 && seg[1] === "agents" && seg[3] === "skills") {
         const slug = decodeURIComponent(seg[2]);
         try {
             if (method === "GET")
@@ -430,8 +561,8 @@ async function handleApi(req, res, url) {
             return json(res, { error: err.message }, 400);
         }
     }
-    // GET/DELETE /api/team/:slug/skills/:name — one agent skill with content / delete
-    if (seg.length === 5 && seg[1] === "team" && seg[3] === "skills") {
+    // GET/DELETE /api/agents/:slug/skills/:name — one agent skill with content / delete
+    if (seg.length === 5 && seg[1] === "agents" && seg[3] === "skills") {
         const slug = decodeURIComponent(seg[2]);
         const name = decodeURIComponent(seg[4]);
         try {
@@ -450,8 +581,8 @@ async function handleApi(req, res, url) {
             return json(res, { error: err.message }, 400);
         }
     }
-    // GET/POST /api/team/:slug/routines — list (with run state) / upsert
-    if (seg.length === 4 && seg[1] === "team" && seg[3] === "routines") {
+    // GET/POST /api/agents/:slug/routines — list (with run state) / upsert
+    if (seg.length === 4 && seg[1] === "agents" && seg[3] === "routines") {
         const slug = decodeURIComponent(seg[2]);
         try {
             if (method === "GET")
@@ -465,8 +596,8 @@ async function handleApi(req, res, url) {
             return json(res, { error: err.message }, 400);
         }
     }
-    // DELETE /api/team/:slug/routines/:id | POST /api/team/:slug/routines/:id/run
-    if (seg.length >= 5 && seg[1] === "team" && seg[3] === "routines") {
+    // DELETE /api/agents/:slug/routines/:id | POST /api/agents/:slug/routines/:id/run
+    if (seg.length >= 5 && seg[1] === "agents" && seg[3] === "routines") {
         const slug = decodeURIComponent(seg[2]);
         const id = decodeURIComponent(seg[4]);
         try {
@@ -482,20 +613,20 @@ async function handleApi(req, res, url) {
             return json(res, { error: err.message }, 400);
         }
     }
-    // GET/PUT/DELETE /api/team/:slug
-    if (seg.length === 3 && seg[1] === "team") {
+    // GET/PUT/DELETE /api/agents/:slug
+    if (seg.length === 3 && seg[1] === "agents") {
         const slug = decodeURIComponent(seg[2]);
         try {
             if (method === "GET") {
-                const member = await getMember(slug);
-                return member ? json(res, member) : json(res, { error: "not found" }, 404);
+                const agent = await getAgent(slug);
+                return agent ? json(res, agent) : json(res, { error: "not found" }, 404);
             }
             if (method === "PUT") {
                 const body = JSON.parse(await readBody(req));
-                return json(res, await saveMember({ ...body, slug }));
+                return json(res, await saveAgent({ ...body, slug }));
             }
             if (method === "DELETE") {
-                await deleteMember(slug);
+                await deleteAgent(slug);
                 return json(res, { ok: true });
             }
         }
@@ -517,13 +648,13 @@ async function handleApi(req, res, url) {
             }
             let agent = body.agent;
             let scope;
-            if (body.scope?.kind === "team" && body.scope.member) {
-                // Team sessions run on the member's configured harness.
-                const member = await getMember(body.scope.member).catch(() => null);
-                if (!member)
-                    return json(res, { error: "team agent not found" }, 404);
-                scope = { kind: "team", member: member.slug };
-                agent = member.harness;
+            if (body.scope?.kind === "agent" && body.scope.slug) {
+                // Agent sessions run on the agent's configured harness.
+                const def = await getAgent(body.scope.slug).catch(() => null);
+                if (!def)
+                    return json(res, { error: "agent not found" }, 404);
+                scope = { kind: "agent", slug: def.slug };
+                agent = def.harness;
             }
             else if (body.scope?.kind === "run" && body.scope.runId) {
                 scope = { kind: "run", runId: body.scope.runId };
@@ -659,6 +790,7 @@ export function startInspector(opts) {
     if (opts.projectRoot)
         setProjectRoot(opts.projectRoot);
     startRoutineScheduler();
+    startGitSync();
     // Chat agent subprocesses must die with the server — signals bypass
     // "exit" handlers, so hook the signals themselves.
     for (const sig of ["SIGINT", "SIGTERM"]) {
@@ -679,6 +811,8 @@ export function startInspector(opts) {
     const server = http.createServer(async (req, res) => {
         try {
             const url = new URL(req.url ?? "/", "http://localhost");
+            if (!hostAllowed(req))
+                return json(res, { error: "unexpected Host header" }, 421);
             if (url.pathname.startsWith("/api/"))
                 await handleApi(req, res, url);
             else
@@ -690,7 +824,7 @@ export function startInspector(opts) {
     });
     return new Promise((resolve, reject) => {
         server.once("error", reject);
-        server.listen(opts.port, () => {
+        server.listen(opts.port, INSPECTOR_HOST, () => {
             const addr = server.address();
             const port = typeof addr === "object" && addr ? addr.port : opts.port;
             void registerInstance(port, getProjectRoot());

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) back. Edits go through the
+ * UI-editable subset (name, icon, switcher, git) 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.
  */
@@ -22,6 +22,16 @@ export interface SaveSettingsInput {
     icon?: string;
     /** Omitted = untouched; empty list = remove the key. */
     switcher?: SwitcherEntry[];
+    /** Omitted = untouched. See cleanGit for how the block is written. */
+    git?: GitSettingsInput;
+}
+/** The git form as the settings screen posts it. Every field but `enabled` may be blank. */
+export interface GitSettingsInput {
+    enabled: boolean;
+    remote?: string;
+    branch?: string;
+    interval?: number | string;
+    autosync?: "off" | "pull" | "";
 }
 export declare function getSettings(): Promise<SettingsView>;
 export declare function saveSettings(input: SaveSettingsInput): Promise<SettingsView>;

package/dist/inspector/settings.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { parseDocument } from "yaml";
 import { resolveProject } from "../config.js";
 import { getProjectRoot } from "./context.js";
+const GIT_DEFAULTS = { remote: "origin", interval: 300, autosync: "pull" };
 export async function getSettings() {
     const project = await resolveProject(getProjectRoot());
     return {
@@ -31,6 +32,43 @@ function cleanSwitcher(value) {
         return icon ? { name, url, icon } : { name, url };
     });
 }
+/**
+ * The git block to write. Defaults are left out so the file only says what
+ * differs from them, and `enabled: false` keeps the other fields so turning
+ * the feature back on restores them. Returns null when the block should not
+ * exist at all: sync off and nothing else set, which is what no block means.
+ */
+function cleanGit(value) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("git must be an object");
+    if (typeof value.enabled !== "boolean")
+        throw new Error("git.enabled must be true or false");
+    const out = {};
+    const remote = typeof value.remote === "string" ? value.remote.trim() : "";
+    if (remote && remote !== GIT_DEFAULTS.remote)
+        out.remote = remote;
+    const branch = typeof value.branch === "string" ? value.branch.trim() : "";
+    if (branch)
+        out.branch = branch;
+    if (value.interval !== undefined && value.interval !== "") {
+        const n = typeof value.interval === "string" ? Number(value.interval) : value.interval;
+        if (!Number.isInteger(n) || n < 0)
+            throw new Error("git.interval must be a whole number of seconds (0 disables the timer)");
+        if (n !== GIT_DEFAULTS.interval)
+            out.interval = n;
+    }
+    if (value.autosync !== undefined && value.autosync !== "") {
+        if (value.autosync !== "off" && value.autosync !== "pull")
+            throw new Error('git.autosync must be "off" or "pull"');
+        if (value.autosync !== GIT_DEFAULTS.autosync)
+            out.autosync = value.autosync;
+    }
+    if (value.enabled)
+        return out;
+    if (Object.keys(out).length === 0)
+        return null;
+    return { enabled: false, ...out };
+}
 export async function saveSettings(input) {
     if (input.name !== undefined && typeof input.name !== "string")
         throw new Error("name must be a string");
@@ -54,6 +92,13 @@ export async function saveSettings(input) {
     setOrDelete("name", input.name?.trim());
     setOrDelete("icon", input.icon?.trim());
     setOrDelete("switcher", switcher);
+    if (input.git !== undefined) {
+        const git = cleanGit(input.git);
+        if (git === null)
+            doc.delete("git");
+        else
+            doc.set("git", git);
+    }
     await fs.writeFile(configPath, doc.toString());
     return getSettings();
 }