@netnodeag/kraftwerk 0.61.0 → 0.63.0

package/dist/inspector/notifications.js

@@ -2,32 +2,38 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { getOutputDir } from "./context.js";
+import { perWorkspace } from "./workspace.js";
+import { touch } from "./live.js";
 const MAX_ITEMS = 200;
 const BODY_MAX = 280;
-let cache = null;
-let writeChain = Promise.resolve();
+/** The in-memory copy and the write queue, one per workspace. */
+const store = perWorkspace(() => ({ cache: null, writeChain: Promise.resolve() }));
 const file = () => path.join(getOutputDir(), "notifications.json");
 async function load() {
-    if (cache)
-        return cache;
+    const st = store();
+    if (st.cache)
+        return st.cache;
     try {
         const parsed = JSON.parse(await fs.readFile(file(), "utf8"));
-        cache = Array.isArray(parsed) ? parsed : [];
+        st.cache = Array.isArray(parsed) ? parsed : [];
     }
     catch {
-        cache = [];
+        st.cache = [];
     }
-    return cache;
+    return st.cache;
 }
 function persist(items) {
-    cache = items;
-    writeChain = writeChain
+    const st = store();
+    const [dir, target] = [getOutputDir(), file()];
+    st.cache = items;
+    touch();
+    st.writeChain = st.writeChain
         .then(async () => {
-        await fs.mkdir(getOutputDir(), { recursive: true });
+        await fs.mkdir(dir, { recursive: true });
         // Write-then-rename: a reader (the UI, a test) never sees a half-written file.
-        const tmp = `${file()}.${process.pid}.tmp`;
+        const tmp = `${target}.${process.pid}.tmp`;
         await fs.writeFile(tmp, JSON.stringify(items, null, 2));
-        await fs.rename(tmp, file());
+        await fs.rename(tmp, target);
     })
         .catch(() => { });
 }
@@ -92,5 +98,5 @@ export async function clearNotifications() {
 }
 /** Tests / project switches: forget the in-memory copy so the next read hits disk. */
 export function resetNotificationsCache() {
-    cache = null;
+    store().cache = null;
 }

package/dist/inspector/routines.d.ts

@@ -49,10 +49,31 @@ export interface SaveRoutineInput {
 }
 export declare function saveRoutine(slug: string, input: SaveRoutineInput): Promise<Routine>;
 export declare function deleteRoutine(slug: string, id: string): Promise<void>;
+/**
+ * Whether a routine's prompt names a workflow: its slug or its name as a whole word
+ * ("Run the daily-ceo-report workflow", "Run helpdesk workflow"). Routines are an
+ * agent's prompts, so this is how a workflow learns it runs on a schedule.
+ */
+export declare function mentionsWorkflow(prompt: string, w: {
+    slug: string;
+    name?: string;
+}): boolean;
+/** Every agent's routines with their run state, each with the workflows its prompt names (GET /api/routines). */
+export declare function allRoutines(workflows: {
+    slug: string;
+    name?: string;
+}[]): Promise<(RoutineStatus & {
+    agent: {
+        slug: string;
+        name: string;
+        emoji: string;
+    };
+    workflows: string[];
+})[]>;
 export declare function routineStatuses(slug: string): Promise<RoutineStatus[]>;
 export declare function runRoutineNow(slug: string, id: string): Promise<{
     chatId: string;
 }>;
-/** Start the in-process scheduler; safe to call more than once. */
+/** Start the current workspace's scheduler; safe to call more than once. Ticks run in that workspace. */
 export declare function startRoutineScheduler(): void;
 export {};

package/dist/inspector/routines.js

@@ -2,6 +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 { 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";
@@ -166,6 +167,30 @@ async function writeState(state) {
     await fs.mkdir(getOutputDir(), { recursive: true });
     await fs.writeFile(stateFile(), JSON.stringify(state, null, 2));
 }
+/**
+ * Whether a routine's prompt names a workflow: its slug or its name as a whole word
+ * ("Run the daily-ceo-report workflow", "Run helpdesk workflow"). Routines are an
+ * agent's prompts, so this is how a workflow learns it runs on a schedule.
+ */
+export function mentionsWorkflow(prompt, w) {
+    const text = prompt.toLowerCase();
+    return [w.slug, w.name].some((n) => {
+        if (!n?.trim())
+            return false;
+        const esc = n.trim().toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return new RegExp(`(^|[^a-z0-9_-])${esc}($|[^a-z0-9_-])`).test(text);
+    });
+}
+/** Every agent's routines with their run state, each with the workflows its prompt names (GET /api/routines). */
+export async function allRoutines(workflows) {
+    const agents = (await listAgents()).filter((a) => !a.archived);
+    const per = await Promise.all(agents.map(async (a) => (await routineStatuses(a.slug).catch(() => [])).map((r) => ({
+        ...r,
+        agent: { slug: a.slug, name: a.name, emoji: a.emoji },
+        workflows: workflows.filter((w) => mentionsWorkflow(r.prompt, w)).map((w) => w.slug),
+    }))));
+    return per.flat();
+}
 export async function routineStatuses(slug) {
     const [routines, state] = await Promise.all([listRoutines(slug), readState()]);
     return routines.map((r) => {
@@ -227,7 +252,8 @@ export async function runRoutineNow(slug, id) {
     }
 }
 /* ---------- scheduler ---------- */
-let timer = null;
+/** The scheduler's timer, one per workspace. */
+const scheduler = perWorkspace(() => ({ timer: null }));
 async function tick() {
     const now = new Date();
     const p = (n) => String(n).padStart(2, "0");
@@ -271,10 +297,11 @@ async function tick() {
     if (dirty)
         await writeState(state);
 }
-/** Start the in-process scheduler; safe to call more than once. */
+/** Start the current workspace's scheduler; safe to call more than once. Ticks run in that workspace. */
 export function startRoutineScheduler() {
-    if (timer)
+    const s = scheduler();
+    if (s.timer)
         return;
-    timer = setInterval(() => void tick().catch(() => { }), 20_000);
-    timer.unref?.();
+    s.timer = setInterval(() => void tick().catch(() => { }), 20_000);
+    s.timer.unref?.();
 }

package/dist/inspector/runner.js

@@ -2,6 +2,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { mkdirSync, openSync, closeSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { getProjectRoot } from "./context.js";
+import { perWorkspace } from "./workspace.js";
 import { RUN_ID_RE, getRun, safeRunDir } from "./runs.js";
 import { pushNotification } from "./notifications.js";
 import { newRunId } from "../workflow.js";
@@ -29,7 +30,7 @@ export function dockerStatus() {
     return { available: true, image: image.status === 0 };
 }
 /** Launchers this inspector started and that have not exited yet, by run id. */
-const live = new Map();
+const launchers = perWorkspace(() => new Map());
 export function triggerRun(opts) {
     if (opts.sandbox) {
         const docker = dockerStatus();
@@ -57,7 +58,7 @@ export function triggerRun(opts) {
     });
     child.unref();
     closeSync(log);
-    live.set(runId, child);
+    launchers().set(runId, child);
     // Detached, but as long as the inspector lives it still hears the exit:
     // that is when the run's outcome goes to the bell (read from the trace,
     // the exit code alone does not say whether a gate blocked). The exit
@@ -65,7 +66,7 @@ export function triggerRun(opts) {
     // framework wrote a trace (missing env var, npx failure) shows as failed
     // instead of running until the stale timeout.
     child.on("exit", (code, signal) => {
-        live.delete(runId);
+        launchers().delete(runId);
         try {
             writeFileSync(path.join(runDir, "trigger.json"), JSON.stringify({ exitCode: code ?? 1, signal, finishedAt: new Date().toISOString() }, null, 2) + "\n");
         }
@@ -93,7 +94,7 @@ export function stopRun(runId) {
         return false;
     // A local run this inspector launched: the launcher is detached into its
     // own process group, so the negative pid ends npx and the framework under it.
-    const child = live.get(runId);
+    const child = launchers().get(runId);
     if (child?.pid && child.exitCode == null) {
         try {
             process.kill(-child.pid, "SIGTERM");

package/dist/inspector/server.d.ts

@@ -1,6 +1,6 @@
 import http from "node:http";
-/** Exit code the `kraftwerk ui` supervisor treats as "relaunch me". */
-export declare const RESTART_EXIT_CODE = 75;
+import { RESTART_EXIT_CODE } from "./version.js";
+export { RESTART_EXIT_CODE };
 export interface InspectorOptions {
     outputDir: string;
     staticDir: string;