@netnodeag/kraftwerk 0.75.1 → 0.77.0

package/dist/core/routines.js

@@ -1,11 +1,13 @@
-import { promises as fs } from "node:fs";
+import { promises as fs, realpathSync } from "node:fs";
 import path from "node:path";
 import { parse, stringify } from "yaml";
-import { getOutputDir } from "./context.js";
+import { getOutputDir, workspaceRoot } from "./context.js";
 import { perWorkspace } from "./workspace.js";
 import { getAgent, listAgents, safeAgentSlug, agentsRoot } from "./agents.js";
 import { chatAwaitingApproval, createChat, postMessage } from "./chat/sessions.js";
 import { pushNotification } from "./notifications.js";
+import { isIdentityString, localIdentity, readIdentity, identityString } from "./identity.js";
+import { gitCommit, repoRootFor } from "./git.js";
 /* ---------- cron ---------- */
 const ALIASES = {
     "@hourly": "0 * * * *",
@@ -100,8 +102,26 @@ function normalizeRoutine(raw) {
         schedule: String(raw.schedule ?? ""),
         prompt: String(raw.prompt ?? ""),
         enabled: raw.enabled !== false,
+        ...(typeof raw.runs_on === "string" && raw.runs_on.trim() ? { runsOn: raw.runs_on.trim() } : {}),
+        ...(typeof raw.private === "boolean" ? { private: raw.private } : {}),
     };
 }
+/** The file's own spelling: snake_case `runs_on`, optional keys only when set. */
+function serializeRoutine(r) {
+    return {
+        id: r.id,
+        name: r.name,
+        schedule: r.schedule,
+        prompt: r.prompt,
+        enabled: r.enabled,
+        ...(r.runsOn ? { runs_on: r.runsOn } : {}),
+        ...(r.private !== undefined ? { private: r.private } : {}),
+    };
+}
+/** Why a runs_on value is refused, or undefined. */
+function runsOnError(value) {
+    return isIdentityString(value) ? undefined : `runs_on must be <handle>@<machine> (lowercase letters, digits, ".", "_", "-"), got "${value}"`;
+}
 export async function listRoutines(slug) {
     let raw;
     try {
@@ -117,7 +137,7 @@ export async function listRoutines(slug) {
         .filter(Boolean);
 }
 async function writeRoutines(slug, routines) {
-    await fs.writeFile(await routinesFile(slug), stringify(routines));
+    await fs.writeFile(await routinesFile(slug), stringify(routines.map(serializeRoutine)));
 }
 export async function saveRoutine(slug, input) {
     const name = input.name?.trim();
@@ -134,15 +154,26 @@ export async function saveRoutine(slug, input) {
             .slice(0, 48);
     if (!id)
         throw new Error("name must contain at least one letter or digit");
+    const given = typeof input.runsOn === "string" ? input.runsOn.trim() : input.runsOn;
+    if (given) {
+        const err = runsOnError(given);
+        if (err)
+            throw new Error(err);
+    }
+    const routines = await listRoutines(slug);
+    const i = routines.findIndex((r) => r.id === id);
+    const existing = i >= 0 ? routines[i] : undefined;
+    const runsOn = given === undefined ? (existing ? existing.runsOn : await localIdentity()) : given || undefined;
+    const priv = input.private ?? existing?.private;
     const routine = {
         id,
         name,
         schedule: input.schedule.trim(),
         prompt: input.prompt,
         enabled: input.enabled !== false,
+        ...(runsOn ? { runsOn } : {}),
+        ...(priv !== undefined ? { private: priv } : {}),
     };
-    const routines = await listRoutines(slug);
-    const i = routines.findIndex((r) => r.id === id);
     if (i >= 0)
         routines[i] = routine;
     else
@@ -191,13 +222,19 @@ export async function allRoutines(workflows) {
     }))));
     return per.flat();
 }
+/** Whether a routine fires on the machine whose identity is `me`: enabled and runs_on exactly that. */
+export const firesHere = (r, me) => r.enabled && r.runsOn === me;
 export async function routineStatuses(slug) {
-    const [routines, state] = await Promise.all([listRoutines(slug), readState()]);
+    const [routines, state, id] = await Promise.all([listRoutines(slug), readState(), readIdentity()]);
+    const me = identityString(id);
     return routines.map((r) => {
         const s = state[`${slug}/${r.id}`] ?? {};
+        const runner = !r.runsOn ? "unassigned" : r.runsOn === me ? "here" : "elsewhere";
         return {
             ...r,
-            ...(r.enabled ? { nextRunAt: nextRun(r.schedule) } : {}),
+            runner,
+            ...(r.runsOn && id.previous.includes(r.runsOn) ? { retired: true } : {}),
+            ...(firesHere(r, me) ? { nextRunAt: nextRun(r.schedule) } : {}),
             ...(s.lastRunAt ? { lastRunAt: s.lastRunAt } : {}),
             ...(s.lastChatId ? { lastChatId: s.lastChatId } : {}),
             ...(s.lastChatId && chatAwaitingApproval(s.lastChatId) ? { awaitingApproval: true } : {}),
@@ -254,48 +291,152 @@ export async function runRoutineNow(slug, id) {
 /* ---------- scheduler ---------- */
 /** The scheduler's timer, one per workspace. */
 const scheduler = perWorkspace(() => ({ timer: null }));
+/**
+ * The routines due at `now` that fire on this machine: enabled, runs_on
+ * exactly this identity, cron matching. Everything else — unassigned,
+ * another machine's, a retired identity's — is never due here.
+ */
+export async function dueRoutines(now, me) {
+    const identity = me ?? (await localIdentity());
+    const out = [];
+    for (const m of await listAgents()) {
+        for (const r of await listRoutines(m.slug).catch(() => [])) {
+            if (!firesHere(r, identity))
+                continue;
+            try {
+                if (cronMatches(parseCron(r.schedule), now))
+                    out.push({ slug: m.slug, routine: r });
+            }
+            catch {
+                // invalid schedule — surfaced by validation on save, skip here
+            }
+        }
+    }
+    return out;
+}
 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 agents;
+    let due;
     try {
-        agents = await listAgents();
+        due = await dueRoutines(now);
     }
     catch {
         return;
     }
+    if (!due.length)
+        return;
     const state = await readState();
     let dirty = false;
-    for (const m of agents) {
-        for (const r of await listRoutines(m.slug).catch(() => [])) {
-            if (!r.enabled)
-                continue;
-            let due = false;
-            try {
-                due = cronMatches(parseCron(r.schedule), now);
+    for (const { slug, routine: r } of due) {
+        const key = `${slug}/${r.id}`;
+        if (state[key]?.lastMinute === minuteKey)
+            continue;
+        state[key] = { ...state[key], lastMinute: minuteKey };
+        dirty = true;
+        try {
+            const chatId = await fireRoutine(slug, r);
+            state[key] = { ...state[key], lastRunAt: now.toISOString(), lastChatId: chatId };
+            delete state[key].lastError;
+        }
+        catch (err) {
+            state[key] = { ...state[key], lastError: err.message };
+            void notifyRoutineFailed(slug, r, err.message);
+        }
+    }
+    if (dirty)
+        await writeState(state);
+}
+/** Every routine in the workspace that has no runner, or names a retired identity of this machine. */
+export async function runnerFindings() {
+    const id = await readIdentity();
+    const out = { unassigned: [], retired: [] };
+    let since = 0;
+    // Archived agents included: the scheduler fires their routines too.
+    for (const a of await listAgents()) {
+        const routines = await listRoutines(a.slug).catch(() => []);
+        let hit = false;
+        for (const r of routines) {
+            if (!r.runsOn && r.enabled) {
+                out.unassigned.push({ agent: a.slug, id: r.id, name: r.name });
+                hit = true;
             }
-            catch {
-                continue; // invalid schedule — surfaced by validation on save, skip here
+            else if (r.runsOn && id.previous.includes(r.runsOn)) {
+                out.retired.push({ agent: a.slug, id: r.id, name: r.name, from: r.runsOn });
+                hit = true;
             }
-            const key = `${m.slug}/${r.id}`;
-            if (!due || state[key]?.lastMinute === minuteKey)
+        }
+        if (hit) {
+            const st = await fs.stat(await routinesFile(a.slug)).catch(() => null);
+            if (st && st.mtimeMs > since)
+                since = st.mtimeMs;
+        }
+    }
+    if (since)
+        out.since = new Date(since).toISOString();
+    return out;
+}
+/**
+ * "Run these here": make this machine the runner of the routines `pick`
+ * selects, write routines.yml and commit just the files it touched — the
+ * commit is what tells the other clones who runs them. A workspace without
+ * git sync, or a commit that fails, keeps the written files and says why.
+ */
+export async function adoptRoutines(pick, message) {
+    const id = await readIdentity();
+    const me = identityString(id);
+    const adopted = [];
+    const written = [];
+    for (const a of await listAgents()) {
+        const routines = await listRoutines(a.slug).catch(() => []);
+        let changed = false;
+        for (const r of routines) {
+            if (r.runsOn === me || !pick(a.slug, r, id.previous))
                 continue;
-            state[key] = { ...state[key], lastMinute: minuteKey };
-            dirty = true;
-            try {
-                const chatId = await fireRoutine(m.slug, r);
-                state[key] = { ...state[key], lastRunAt: now.toISOString(), lastChatId: chatId };
-                delete state[key].lastError;
-            }
-            catch (err) {
-                state[key] = { ...state[key], lastError: err.message };
-                void notifyRoutineFailed(m.slug, r, err.message);
-            }
+            adopted.push({ agent: a.slug, id: r.id, name: r.name, ...(r.runsOn ? { from: r.runsOn } : {}) });
+            r.runsOn = me;
+            changed = true;
+        }
+        if (changed) {
+            await writeRoutines(a.slug, routines);
+            written.push(await routinesFile(a.slug));
         }
     }
-    if (dirty)
-        await writeState(state);
+    const root = workspaceRoot();
+    const files = written.map((f) => path.relative(root, f).split(path.sep).join("/"));
+    if (!written.length)
+        return { runsOn: me, adopted, files, commit: null };
+    return { runsOn: me, adopted, files, commit: await commitFiles(written, message ?? `Routines run on ${me}: ${adopted.map((x) => `${x.agent}/${x.id}`).join(", ")}`) };
+}
+async function commitFiles(abs, message) {
+    const repoRoot = await repoRootFor(path.dirname(abs[0]));
+    if (!repoRoot)
+        return { ok: false, error: "the workspace is not a git repository" };
+    // rev-parse answers with symlinks resolved (/var → /private/var on macOS); the files must be spelled the same way.
+    const real = (p) => {
+        try {
+            return realpathSync.native(p);
+        }
+        catch {
+            return path.resolve(p);
+        }
+    };
+    const rel = abs.map((f) => path.relative(repoRoot, real(f)).split(path.sep).join("/"));
+    return gitCommit(rel, message);
+}
+/** Adopt one routine (whatever its runs_on said). */
+export async function adoptRoutine(slug, id) {
+    const safe = safeAgentSlug(slug);
+    if (!(await listRoutines(safe)).some((r) => r.id === id))
+        throw new Error("routine not found");
+    const result = await adoptRoutines((agent, r) => agent === safe && r.id === id);
+    const routine = (await routineStatuses(safe)).find((r) => r.id === id);
+    return { ...result, routine };
+}
+/** Adopt every enabled routine without runs_on — and, with `retired`, every one naming a retired identity of this machine. */
+export function adoptUnassigned(opts = {}) {
+    return adoptRoutines((_agent, r, previous) => (!r.runsOn && r.enabled) || (!!opts.retired && !!r.runsOn && previous.includes(r.runsOn)));
 }
 /** Start the current workspace's scheduler; safe to call more than once. Ticks run in that workspace. */
 export function startRoutineScheduler() {

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

@@ -5,7 +5,9 @@ export declare const agentRoutes: (import("./router.js").Route<"agents.addJourna
 }, "/api/agents/:slug/journal", z.ZodObject<{
     entry: z.ZodDefault<z.ZodString>;
     kind: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>> | import("./router.js").Route<"agents.archive", import("../../core/agents.js").AgentDetail, "/api/agents/:slug/archive", z.ZodObject<{
+}, z.core.$strip>> | import("./router.js").Route<"agents.adoptRoutine", import("../../core/routines.js").AdoptResult & {
+    routine: import("../../core/routines.js").RoutineStatus;
+}, "/api/agents/:slug/routines/:id/adopt", undefined> | import("./router.js").Route<"agents.archive", import("../../core/agents.js").AgentDetail, "/api/agents/:slug/archive", z.ZodObject<{
     archived: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>> | import("./router.js").Route<"agents.create", import("../../core/agents.js").AgentDetail, "/api/agents", z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -56,6 +58,8 @@ export declare const agentRoutes: (import("./router.js").Route<"agents.addJourna
     schedule: z.ZodOptional<z.ZodString>;
     prompt: z.ZodOptional<z.ZodString>;
     enabled: z.ZodOptional<z.ZodBoolean>;
+    runsOn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    private: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>> | import("./router.js").Route<"agents.saveSkill", import("../../core/skills.js").SkillInfo & {
     content: string;
 }, "/api/agents/:slug/skills", z.ZodObject<{

package/dist/server/api/agents.js

@@ -2,7 +2,7 @@ import * as z from "zod";
 import { agentsRoot, deleteAgent, getAgent, listAgents, saveAgent, setAgentArchived } from "../../core/agents.js";
 import { appendJournal, readJournal } from "../../core/journal.js";
 import { UI_ACTOR } from "../../core/knowledge.js";
-import { deleteRoutine, routineStatuses, runRoutineNow, saveRoutine } from "../../core/routines.js";
+import { adoptRoutine, deleteRoutine, listRoutines, routineStatuses, runRoutineNow, saveRoutine } from "../../core/routines.js";
 import { deleteAgentSkill, listAgentSkills, readSkill, saveAgentSkill } from "../../core/skills.js";
 import { fail, route } from "./router.js";
 /** A member's editable fields. Loose: saveAgent checks values (name, harness, effort) and keeps what it knows. */
@@ -21,13 +21,19 @@ const AgentFields = z.looseObject({
     skills: z.array(z.string()).optional(),
     system: z.string().optional(),
 });
-/** A routine: every field saveRoutine stores (it builds the routine from these alone), so a strict object loses nothing. saveRoutine checks name, prompt and the cron schedule. */
+/**
+ * A routine: every field saveRoutine stores (it builds the routine from these alone), so a strict object loses nothing.
+ * saveRoutine checks name, prompt, the cron schedule and runsOn. runsOn absent keeps the stored runner (a new routine:
+ * this machine); null or "" unassigns it.
+ */
 const RoutineFields = z.object({
     id: z.string().optional(),
     name: z.string().optional(),
     schedule: z.string().optional(),
     prompt: z.string().optional(),
     enabled: z.boolean().optional(),
+    runsOn: z.string().nullable().optional(),
+    private: z.boolean().optional(),
 });
 /** Agents (team members): definition, own skills, journal, routines. */
 export const agentRoutes = [
@@ -92,5 +98,16 @@ export const agentRoutes = [
         await deleteRoutine(c.params.slug, c.params.id);
         return { ok: true };
     }),
+    route({
+        name: "agents.adoptRoutine",
+        method: "POST",
+        path: "/api/agents/:slug/routines/:id/adopt",
+        summary: "run this routine here: runs_on = this machine's identity, routines.yml committed",
+        errors: 400,
+    }, async (c) => {
+        if (!(await listRoutines(c.params.slug)).some((r) => r.id === c.params.id))
+            fail(404, "routine not found");
+        return adoptRoutine(c.params.slug, c.params.id);
+    }),
     route({ name: "agents.runRoutine", method: "POST", path: "/api/agents/:slug/routines/:id/run", summary: "run a routine now", errors: 400 }, async (c) => runRoutineNow(c.params.slug, c.params.id)),
 ];

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

@@ -0,0 +1,72 @@
+import * as z from "zod";
+/**
+ * The machine in the kraftwerk cloud (server/cloud.ts): its record, turning
+ * it on or off, a round now, releasing the claim. What `kraftwerk cloud`,
+ * `login` and `logout` ask the running daemon; a standalone server answers
+ * "off" (only the daemon registers). This machine only: the claim code
+ * claims the machine.
+ */
+export declare const cloudRoutes: (import("./router.js").Route<"cloud.set", {
+    daemon: boolean;
+    url: string;
+    state: import("../cloud.js").CloudState;
+    reason?: string;
+    source?: import("../../core/cloud.js").CloudUrlSource;
+    error?: string;
+    id?: string;
+    machine?: string;
+    account?: string | null;
+    interval?: number;
+    lastSeen?: string;
+    claimCode?: string | null;
+    claimUrl?: string | null;
+    workspaces?: number;
+}, "/api/cloud", z.ZodObject<{
+    enabled: z.ZodBoolean;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> | import("./router.js").Route<"cloud.status", {
+    daemon: boolean;
+    url: string;
+    state: import("../cloud.js").CloudState;
+    reason?: string;
+    source?: import("../../core/cloud.js").CloudUrlSource;
+    error?: string;
+    id?: string;
+    machine?: string;
+    account?: string | null;
+    interval?: number;
+    lastSeen?: string;
+    claimCode?: string | null;
+    claimUrl?: string | null;
+    workspaces?: number;
+}, "/api/cloud", undefined> | import("./router.js").Route<"cloud.sync", {
+    daemon: boolean;
+    url: string;
+    state: import("../cloud.js").CloudState;
+    reason?: string;
+    source?: import("../../core/cloud.js").CloudUrlSource;
+    error?: string;
+    id?: string;
+    machine?: string;
+    account?: string | null;
+    interval?: number;
+    lastSeen?: string;
+    claimCode?: string | null;
+    claimUrl?: string | null;
+    workspaces?: number;
+}, "/api/cloud/sync", undefined> | import("./router.js").Route<"cloud.unlink", {
+    daemon: boolean;
+    url: string;
+    state: import("../cloud.js").CloudState;
+    reason?: string;
+    source?: import("../../core/cloud.js").CloudUrlSource;
+    error?: string;
+    id?: string;
+    machine?: string;
+    account?: string | null;
+    interval?: number;
+    lastSeen?: string;
+    claimCode?: string | null;
+    claimUrl?: string | null;
+    workspaces?: number;
+}, "/api/cloud/unlink", undefined>)[];

package/dist/server/api/cloud.js

@@ -0,0 +1,38 @@
+import * as z from "zod";
+import { writeCloudFile } from "../../core/cloud.js";
+import { applyMachineCloud, cloudStatus, syncMachineCloud, unlinkMachineCloud } from "../cloud.js";
+import { currentHub } from "../hub-context.js";
+import { route } from "./router.js";
+/**
+ * The machine in the kraftwerk cloud (server/cloud.ts): its record, turning
+ * it on or off, a round now, releasing the claim. What `kraftwerk cloud`,
+ * `login` and `logout` ask the running daemon; a standalone server answers
+ * "off" (only the daemon registers). This machine only: the claim code
+ * claims the machine.
+ */
+export const cloudRoutes = [
+    route({ name: "cloud.status", method: "GET", path: "/api/cloud", summary: "the machine's cloud record: state, claim code, account, last heartbeat", access: "local" }, async () => ({
+        daemon: currentHub().daemon === true,
+        ...cloudStatus(),
+    })),
+    route({
+        name: "cloud.set",
+        method: "POST",
+        path: "/api/cloud",
+        summary: "turn the machine's cloud on or off {enabled, url?} (~/.kraftwerk/cloud.json); off says goodbye",
+        access: "local",
+        body: z.object({ enabled: z.boolean(), url: z.string().url().optional() }),
+    }, async (c) => {
+        const { enabled, url } = await c.body();
+        await writeCloudFile({ enabled, url });
+        return { daemon: currentHub().daemon === true, ...(await applyMachineCloud()) };
+    }),
+    route({ name: "cloud.sync", method: "POST", path: "/api/cloud/sync", summary: "register or heartbeat now; answers the record (a claim made in the cloud shows here)", access: "local" }, async () => ({
+        daemon: currentHub().daemon === true,
+        ...(await syncMachineCloud()),
+    })),
+    route({ name: "cloud.unlink", method: "POST", path: "/api/cloud/unlink", summary: "release the machine from its account; the cloud hands out a fresh claim code", access: "local", errors: 400 }, async () => ({
+        daemon: currentHub().daemon === true,
+        ...(await unlinkMachineCloud()),
+    })),
+];

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

@@ -16,16 +16,16 @@ export declare const deviceRoutes: (import("./router.js").Route<"devices.code",
     code: z.ZodString;
     name: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>> | import("./router.js").Route<"devices.relay", {
+    enabled: boolean;
+    url: string | null;
+    fingerprint: string | null;
+    daemon: boolean;
     state: import("../relay.js").RelayState;
     id?: string;
     key?: string;
     error?: string;
     clients: number;
     since?: string;
-    enabled: boolean;
-    url: string | null;
-    fingerprint: string | null;
-    daemon: boolean;
 }, "/api/devices/relay", undefined> | import("./router.js").Route<"devices.revoke", {
     ok: boolean;
 }, "/api/devices/:id", undefined> | import("./router.js").Route<"devices.self", {
@@ -41,16 +41,16 @@ export declare const deviceRoutes: (import("./router.js").Route<"devices.code",
     }>;
     key: z.ZodString;
 }, z.core.$strip>> | import("./router.js").Route<"devices.setRelay", {
+    enabled: boolean;
+    url: string;
+    fingerprint: string;
+    daemon: boolean;
     state: import("../relay.js").RelayState;
     id?: string;
     key?: string;
     error?: string;
     clients: number;
     since?: string;
-    enabled: boolean;
-    url: string;
-    fingerprint: string;
-    daemon: boolean;
 }, "/api/devices/relay", z.ZodObject<{
     enabled: z.ZodBoolean;
     url: z.ZodOptional<z.ZodString>;