@netnodeag/kraftwerk 0.75.1 → 0.77.0

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

@@ -27,7 +27,9 @@ export declare const routes: (Route<"agents.addJournal", {
 }, "/api/agents/:slug/journal", z.ZodObject<{
     entry: z.ZodDefault<z.ZodString>;
     kind: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>> | Route<"agents.archive", import("../../core/agents.js").AgentDetail, "/api/agents/:slug/archive", z.ZodObject<{
+}, z.core.$strip>> | Route<"agents.adoptRoutine", import("../../core/routines.js").AdoptResult & {
+    routine: import("../../core/routines.js").RoutineStatus;
+}, "/api/agents/:slug/routines/:id/adopt", undefined> | Route<"agents.archive", import("../../core/agents.js").AgentDetail, "/api/agents/:slug/archive", z.ZodObject<{
     archived: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>> | Route<"agents.create", import("../../core/agents.js").AgentDetail, "/api/agents", z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -78,6 +80,8 @@ export declare const routes: (Route<"agents.addJournal", {
     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>> | Route<"agents.saveSkill", import("../../core/skills.js").SkillInfo & {
     content: string;
 }, "/api/agents/:slug/skills", z.ZodObject<{
@@ -287,7 +291,70 @@ export declare const routes: (Route<"agents.addJournal", {
     ok: true;
 }, "/api/chats/:id/task-stop", z.ZodObject<{
     taskId: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>> | Route<"devices.code", {
+}, z.core.$strip>> | 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>> | 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> | 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> | 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> | Route<"devices.code", {
     code: string;
     expiresAt: string;
     urls: string[];
@@ -303,16 +370,16 @@ export declare const routes: (Route<"agents.addJournal", {
     code: z.ZodString;
     name: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>> | 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> | Route<"devices.revoke", {
     ok: boolean;
 }, "/api/devices/:id", undefined> | Route<"devices.self", {
@@ -328,16 +395,16 @@ export declare const routes: (Route<"agents.addJournal", {
     }>;
     key: z.ZodString;
 }, z.core.$strip>> | 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>;
@@ -399,7 +466,12 @@ export declare const routes: (Route<"agents.addJournal", {
     aliasPort?: number | undefined;
 }, "/api/hub/open", z.ZodObject<{
     root: z.ZodString;
-}, z.core.$strip>> | Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept", undefined> | Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge", z.ZodObject<{
+}, z.core.$strip>> | Route<"identity.get", {
+    handle: string;
+    machine: string;
+    identity: string;
+    previous: string[];
+}, "/api/identity", undefined> | Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept", undefined> | Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge", z.ZodObject<{
     name: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>> | Route<"knowledge.delete", {
     ok: boolean;
@@ -430,7 +502,22 @@ export declare const routes: (Route<"agents.addJournal", {
     vibeables: boolean;
     projects: boolean;
     publicUrl: string;
-    cloud: import("../cloud.js").CloudStatus;
+    cloud: {
+        included: 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;
+    };
     switcher: import("../../config.js").SwitcherEntry[];
 }, "/api/meta", undefined> | Route<"notifications.clear", {
     ok: boolean;
@@ -497,7 +584,9 @@ export declare const routes: (Route<"agents.addJournal", {
     error?: string;
     off?: boolean;
     repo?: import("../../core/repos.js").RepoInfo;
-}>, "/api/repos/:slug/update", undefined> | Route<"routines.list", {
+}>, "/api/repos/:slug/update", undefined> | Route<"routines.adopt", import("../../core/routines.js").AdoptResult, "/api/routines/adopt", z.ZodObject<{
+    retired: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>> | Route<"routines.list", {
     routines: (import("../../core/routines.js").RoutineStatus & {
         agent: {
             slug: string;

package/dist/server/api/index.js

@@ -3,6 +3,7 @@ import { agentRoutes } from "./agents.js";
 import { attentionRoutes } from "./attention.js";
 import { channelRoutes } from "./channels.js";
 import { chatRoutes } from "./chats.js";
+import { cloudRoutes } from "./cloud.js";
 import { deviceRoutes } from "./devices.js";
 import { hubRoutes } from "./hub.js";
 import { fileRoutes } from "./files.js";
@@ -35,6 +36,7 @@ const domainRoutes = [
     ...gitRoutes,
     ...vibeableRoutes,
     ...deviceRoutes,
+    ...cloudRoutes,
     ...hubRoutes,
 ];
 const protocolRoute = route({ name: "protocol.get", method: "GET", path: "/api/protocol", summary: "the protocol version and every route", access: "public" }, async () => ({

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

@@ -1,6 +1,8 @@
 import * as z from "zod";
 /** Workflows, their runs, and the routines that start them. */
-export declare const runRoutes: (import("./router.js").Route<"routines.list", {
+export declare const runRoutes: (import("./router.js").Route<"routines.adopt", import("../../core/routines.js").AdoptResult, "/api/routines/adopt", z.ZodObject<{
+    retired: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>> | import("./router.js").Route<"routines.list", {
     routines: (import("../../core/routines.js").RoutineStatus & {
         agent: {
             slug: string;

package/dist/server/api/runs.js

@@ -2,7 +2,7 @@ import { promises as fs } from "node:fs";
 import * as z from "zod";
 import { getOutputDir } from "../../core/context.js";
 import { decide } from "../../core/decisions.js";
-import { allRoutines } from "../../core/routines.js";
+import { adoptUnassigned, allRoutines } from "../../core/routines.js";
 import { dockerStatus, stopRun, triggerRun } from "../../core/runner.js";
 import { deleteRun, getRun, listRuns, readRunFile, safeRunDir } from "../../core/runs.js";
 import { deleteWorkflow, getWorkflow, listWorkflows } from "../../core/workflows.js";
@@ -59,6 +59,14 @@ export const runRoutes = [
     route({ name: "routines.list", method: "GET", path: "/api/routines", summary: "every agent's routines with run state and the workflows each one names" }, async () => ({
         routines: await allRoutines((await listWorkflows()).workflows),
     })),
+    route({
+        name: "routines.adopt",
+        method: "POST",
+        path: "/api/routines/adopt",
+        summary: "run these here: every enabled routine without runs_on (and, with {retired: true}, those naming a retired identity) gets this machine; routines.yml committed",
+        errors: 400,
+        body: z.object({ retired: z.boolean().default(false) }),
+    }, async (c) => adoptUnassigned({ retired: (await c.body()).retired })),
     route({ name: "runs.list", method: "GET", path: "/api/runs", summary: "every run in the output dir" }, async () => ({ outputDir: getOutputDir(), runs: await listRuns() })),
     route({ name: "runs.get", method: "GET", path: "/api/runs/:id", summary: "one run: phases, gates, files" }, async (c) => (await validRun(getRun(c.params.id))) ?? fail(404, "not found")),
     route({ name: "runs.fileText", method: "GET", path: "/api/runs/:id/text", summary: "one run file's text ?name=, tail-capped" }, async (c) => {

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

@@ -6,7 +6,12 @@ type StartReply = StartResult & {
     here?: true;
 };
 /** The workspace itself: identity and features, settings, the other workspaces, updates. */
-export declare const workspaceRoutes: (import("./router.js").Route<"meta.get", {
+export declare const workspaceRoutes: (import("./router.js").Route<"identity.get", {
+    handle: string;
+    machine: string;
+    identity: string;
+    previous: string[];
+}, "/api/identity", undefined> | import("./router.js").Route<"meta.get", {
     workspaceName: string;
     workspaceSlug: string;
     workspaceIcon: string;
@@ -30,7 +35,22 @@ export declare const workspaceRoutes: (import("./router.js").Route<"meta.get", {
     projects: boolean;
     /** @deprecated Always "": the Cloudflare Tunnel that set it was removed in 0.65. Removed with protocol 2. */
     publicUrl: string;
-    cloud: import("../cloud.js").CloudStatus;
+    cloud: {
+        included: 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;
+    };
     switcher: import("../../config.js").SwitcherEntry[];
 }, "/api/meta", undefined> | import("./router.js").Route<"search.agents", {
     workspaces: (import("../../core/search.js").WorkspaceAgents & {

package/dist/server/api/workspace.js

@@ -11,6 +11,7 @@ import { getSettings, saveSettings } from "../../core/settings.js";
 import { canSelfUpdate, startUpdate, updateStatus } from "../../core/update.js";
 import { getDiskVersion, getPkgName, getPkgVersion, RESTART_EXIT_CODE, supervised } from "../version.js";
 import { disposeAllDevs } from "../../core/vibeables.js";
+import { identityString, readIdentity } from "../../core/identity.js";
 import { fail, reply, route } from "./router.js";
 /** A feature block with a folder (repos, vibeables, projects); saveSettings checks the root. Nested blocks are plain objects: saveSettings reads only these fields. */
 const RootBlock = z.object({ enabled: z.boolean(), root: z.string().optional() });
@@ -104,10 +105,15 @@ export const workspaceRoutes = [
             projects: (ws?.config.projects && ws.config.projects.enabled !== false) === true,
             /** @deprecated Always "": the Cloudflare Tunnel that set it was removed in 0.65. Removed with protocol 2. */
             publicUrl: "",
-            cloud: cloudStatus(),
+            // The machine's cloud record (only the daemon registers one); `included`: this workspace rides along (no cloud.enabled: false veto).
+            cloud: { ...cloudStatus(), included: ws?.config.cloud?.enabled !== false },
             switcher,
         };
     }),
+    route({ name: "identity.get", method: "GET", path: "/api/identity", summary: "this machine's identity (handle@machine) — what routines name in runs_on" }, async () => {
+        const id = await readIdentity();
+        return { handle: id.handle, machine: id.machine, identity: identityString(id), previous: id.previous };
+    }),
     route({ name: "settings.get", method: "GET", path: "/api/settings", summary: "kraftwerk.yml, parsed, with resolved paths" }, async () => getSettings()),
     route({ name: "settings.save", method: "PUT", path: "/api/settings", summary: "write the UI-editable subset of kraftwerk.yml", errors: 400, body: SettingsFields }, async (c) => saveSettings((await c.body()))),
     route({ name: "workspaces.list", method: "GET", path: "/api/workspaces", summary: "every known workspace incl. this one, with state and counts" }, async () => placeInHub(await listWorkspacesDetailed())),

package/dist/server/cloud.d.ts

@@ -1,53 +1,85 @@
+import { type CloudUrlSource } from "../core/cloud.js";
 /**
- * The cloud manager client: kraftwerk.yml `cloud:` makes this instance
- * register with the kraftwerk cloud when the inspector starts and heartbeat
- * while it runs — the same record ~/.kraftwerk/instances holds locally,
- * kept on a server so an admin (and, with an account token, the user)
- * sees every instance across machines.
+ * The machine client: the daemon registers THIS MACHINE with the kraftwerk
+ * cloud once and heartbeats while it runs; the workspaces it serves ride
+ * along as children of that record (see core/cloud.ts for the contract and
+ * the settings). One per process, and only the daemon starts it
+ * (startMachineCloud from `kraftwerk daemon`): a standalone `kraftwerk ui`
+ * and test fixtures never talk to the cloud.
  *
- * Identity: the first registration hands out an id + secret, stored under
- * ~/.kraftwerk/cloud/<hash(url, root)>.json and presented on every later
- * call, so a restart updates the record instead of creating a new one.
- * When the cloud does not recognise the id (data reset) it hands out a
- * fresh one and the file is rewritten.
- *
- * Everything is best-effort: a cloud that is down never affects the UI.
- * The status is reported in /api/meta so the UI can show it.
+ *   start      ensure the machine key (relay.json, relay stays off), drop the
+ *              retired per-workspace identities (~/.kraftwerk/cloud/), and,
+ *              unless cloud.json or KRAFTWERK_CLOUD_URL=off says no, register
+ *              — anonymous: the answer carries a claim code until someone
+ *              claims the machine (`kraftwerk login`, or the code in the UI)
+ *   heartbeat  every `interval` the cloud asked for; the workspace list rides
+ *              along whenever it changed (opened, closed, vetoed, claimed).
+ *              A claim made in the cloud arrives in the answer
+ *   privacy    while unclaimed, entries carry name/slug/ws-id only — no
+ *              roots; once claimed, roots too
+ *   recovery   a cloud that no longer knows the machine (data reset) gets a
+ *              fresh registration; a cloud that is down is retried at the
+ *              same cadence and never affects the UI
+ *   goodbye    on shutdown (bounded), and when `kraftwerk cloud off` reaches
+ *              the running daemon
  */
 export type CloudState = "off" | "connecting" | "connected" | "error";
 export interface CloudStatus {
     url: string;
     state: CloudState;
-    /** Last error message while connecting or heartbeating. */
+    /** Why it is off, when it is. */
+    reason?: string;
+    /** Where the URL came from (env, cloud.json, a deprecated kraftwerk.yml cloud.url, the default). */
+    source?: CloudUrlSource;
+    /** Last error message while registering or heartbeating. */
     error?: string;
-    /** Instance id in the cloud once registered. */
+    /** The machine's id in the cloud (its relay id). */
     id?: string;
-    /** Email of the linked kraftwerk account, when a token was presented and accepted. */
+    /** This machine's handle@machine. */
+    machine?: string;
+    /** Email of the account that claimed the machine; null while unclaimed. */
     account?: string | null;
-    /** Effective seconds between heartbeats (the cloud may raise the configured one). */
+    /** Effective seconds between heartbeats (what the cloud asked for). */
     interval?: number;
+    /** Last successful register or heartbeat. */
     lastSeen?: string;
-    /** XXXX-XXXX the user types into the cloud UI to claim this instance; null once claimed. */
+    /** XXXX-XXXX that claims this machine in the cloud; null once claimed. */
     claimCode?: string | null;
-    /** The cloud page that claims this instance after sign-in. */
+    /** The cloud page that claims this machine after sign-in. */
     claimUrl?: string | null;
+    /** Workspaces reported (vetoed ones left out). */
+    workspaces?: number;
 }
+/** What the daemon serves right now. */
+export type WorkspaceSource = () => Array<{
+    root: string;
+    slug: string;
+    name: string;
+}>;
 export declare const cloudStatus: () => CloudStatus;
 /**
- * Start the client once the inspector listens. Resolves after the first
- * registration attempt (success or not); the heartbeat loop runs on its
- * own afterwards.
+ * Start the machine client (the daemon, once its workspaces are open).
+ * Resolves after the first registration attempt; the heartbeat runs on its
+ * own afterwards. A second start in the same process is ignored.
+ */
+export declare function startMachineCloud(opts: {
+    version: string;
+    workspaces: WorkspaceSource;
+    owner?: unknown;
+}): Promise<CloudStatus>;
+/**
+ * Settings changed (`kraftwerk cloud on|off`, a URL): turn the client on or
+ * off to match; off says goodbye first. Without a started client (a
+ * standalone server) nothing happens.
  */
-export declare function startCloudSync(url: string, version: string): Promise<void>;
-/** Stop the heartbeat loop (server close, tests). */
-export declare function stopCloudSync(): void;
+export declare function applyMachineCloud(): Promise<CloudStatus>;
+/** A round now (the CLI's `login` waits for a claim): registers when needed, else heartbeats. */
+export declare function syncMachineCloud(): Promise<CloudStatus>;
+/** Release the claim (`kraftwerk logout`): the cloud hands out a fresh claim code. */
+export declare function unlinkMachineCloud(): Promise<CloudStatus>;
 /**
- * Tell the cloud we are going away, so the record flips to "stopped" now
- * instead of after the grace period. Bounded: an exit handler waits for
- * this, and a slow cloud must not hold the process.
+ * Stop the client and tell the cloud the machine is going away (bounded:
+ * an exit handler waits for this). `owner`: only the client that owner
+ * started (a hub stopping in a test leaves another's alone).
  */
-export declare function cloudGoodbye(): Promise<void>;
-/** Every served workspace: stop its heartbeat (the server closes). */
-export declare function stopAllCloudSync(): void;
-/** Every served workspace says goodbye, in parallel (still bounded per workspace). */
-export declare function cloudGoodbyeAll(): Promise<void>;
+export declare function stopMachineCloud(owner?: unknown): Promise<void>;