@north-light/crouter 0.3.317 → 0.3.319

package/dist/daemon/api/handlers/crons.js

@@ -1,373 +1 @@
-// Cron handlers (the cron-spec scheduler).
-//
-//   POST   /v1/crons                 arm one cron (server mints the cron_id)
-//   GET    /v1/crons                 the crons in the caller's scope
-//   GET    /v1/crons/:cronId         one cron + its run-log ring
-//   POST   /v1/crons/:cronId/pause   stop firing, keep config + history
-//   POST   /v1/crons/:cronId/resume  re-arm a paused cron
-//   POST   /v1/crons/:cronId/run     fire NOW, out of band (synchronous)
-//   POST   /v1/crons/poke            eligibility poke: re-due every held cron
-//   DELETE /v1/crons/:cronId         cancel one cron (idempotent, kills in-flight run)
-//
-// The CLI resolves timing client-side (parseWhen/parseCadence) and sends the
-// settled fire_at/recur/tz plus its chosen-else-inherited execution context;
-// this handler validates the full arm surface (timing SHAPE and
-// advanceability, enums, env, sink shape + arm-time target existence, anchor
-// coupling), applies spec defaults for the rest, and inserts through the DAO.
-// crtrd is the sole state owner and the CLI is only one of its clients
-// (Northlight Core calls the same routes), so nothing here trusts a
-// client-resolved value it can check itself. Every per-cron route resolves
-// through `requireCron`, which enforces the caller's profile scope. The sink is stored as JSON (`{"node":…}` /
-// `{"spawn":…}` / `{"human":true}` / `{}`); the DTO renders it back to the
-// display spec.
-import { randomUUID } from 'node:crypto';
-import { ApiError } from '../../../api/errors.js';
-import { armCron, cancelCron, getCron, listCrons, listCronRuns, pokeHeldCrons, setCronState, } from '../../../core/canvas/crons.js';
-import { getNode } from '../../../core/canvas/canvas.js';
-import { InputError } from '../../../core/io.js';
-import { nextSlotAfter } from '../../../core/wake.js';
-import { executeCron, markSelfCanceledCronRun } from '../../cron-run.js';
-import { toCronDTO, toCronRunDTO } from '../map.js';
-function requireString(req, field) {
-    const v = req[field];
-    if (typeof v !== 'string' || v.trim() === '') {
-        throw new InputError({
-            error: 'missing_field',
-            message: `cron arm request requires a non-empty "${field}"`,
-            field,
-            next: `Send a non-empty string "${field}".`,
-        });
-    }
-    return v;
-}
-function requireEnum(value, field, allowed, fallback) {
-    if (value === undefined || value === null)
-        return fallback;
-    if (typeof value === 'string' && allowed.includes(value))
-        return value;
-    throw new InputError({
-        error: `bad_${field}`,
-        message: `"${String(value)}" is not a valid ${field}`,
-        field,
-        next: `Use one of: ${allowed.join(', ')}.`,
-    });
-}
-/** Parse + validate the raw sink display spec (`node:<id>` | `spawn:<kind>` |
- *  `human`) into its stored JSON. An armed node target must exist NOW (a later
- *  disappearance is the fire-time failure path, not an arm-time concern). */
-function parseSinkSpec(raw) {
-    if (raw === 'human')
-        return JSON.stringify({ human: true });
-    if (raw.startsWith('node:')) {
-        const id = raw.slice('node:'.length).trim();
-        if (id === '') {
-            throw new InputError({ error: 'bad_sink', message: 'node sink requires a node id', field: 'sink', next: 'Use sink "node:<node-id>".' });
-        }
-        if (getNode(id) === null) {
-            throw new InputError({
-                error: 'sink_node_not_found',
-                message: `sink node ${id} does not exist on the canvas`,
-                field: 'sink',
-                next: 'Name a live node id, or use spawn:<kind> for a delivery that outlives any one node.',
-            });
-        }
-        return JSON.stringify({ node: id });
-    }
-    if (raw.startsWith('spawn:')) {
-        const kind = raw.slice('spawn:'.length).trim();
-        if (kind === '') {
-            throw new InputError({ error: 'bad_sink', message: 'spawn sink requires a node kind', field: 'sink', next: 'Use sink "spawn:<kind>" (e.g. spawn:general).' });
-        }
-        return JSON.stringify({ spawn: kind });
-    }
-    throw new InputError({
-        error: 'bad_sink',
-        message: `"${raw}" is not a valid sink`,
-        field: 'sink',
-        next: 'Use node:<node-id>, spawn:<kind>, or human.',
-    });
-}
-/** The exact instant shape every stored clock column must have: a UTC ISO
- *  timestamp as `Date.prototype.toISOString` emits it. The daemon compares
- *  `fire_at`/`expires_at` LEXICOGRAPHICALLY against `new Date().toISOString()`,
- *  so a value in any other shape (a local-zone offset, a bare date, "soon")
- *  silently arms a row that never fires and never expires. crtrd is the sole
- *  state owner and the CLI is only one of its clients — this is validated here,
- *  not trusted from the client that resolved it. */
-const UTC_ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
-function requireUtcIso(raw, field) {
-    if (!UTC_ISO.test(raw) || Number.isNaN(Date.parse(raw))) {
-        throw new InputError({
-            error: `bad_${field}`,
-            message: `"${raw}" is not a UTC ISO instant`,
-            field,
-            next: 'Send a resolved UTC instant like "2026-06-07T09:00:00.000Z" (the client resolves the time grammar).',
-        });
-    }
-    return raw;
-}
-/** Validate a `recur` the daemon must be able to advance. An unparseable recur
- *  is a row the scheduler cannot slot — reject it at arm time rather than let
- *  it fail at the first fire. */
-function requireRecur(raw) {
-    try {
-        nextSlotAfter(raw, new Date());
-    }
-    catch (err) {
-        throw new InputError({
-            error: 'bad_recur',
-            message: `recur is not advanceable: ${err instanceof Error ? err.message : String(err)}`,
-            field: 'recur',
-            next: 'Send recur JSON the daemon can advance: {"every":"6h"} or {"cron":"0 9 * * *","tz":"America/New_York"}.',
-        });
-    }
-    return raw;
-}
-/** Validate the chosen extra run env: a JSON object of string values, since
- *  that is exactly what the executor can put in a child process env. */
-function requireEnvJson(raw) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        throw new InputError({ error: 'bad_env_json', message: 'env_json is not valid JSON', field: 'env_json', next: 'Send a JSON object of string values, e.g. {"API_BASE":"https://x"}.' });
-    }
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-        throw new InputError({ error: 'bad_env_json', message: 'env_json must be a JSON object', field: 'env_json', next: 'Send a JSON object of string values, e.g. {"API_BASE":"https://x"}.' });
-    }
-    for (const [k, v] of Object.entries(parsed)) {
-        if (typeof v !== 'string') {
-            throw new InputError({ error: 'bad_env_json', message: `env_json value for "${k}" is not a string`, field: 'env_json', next: 'Every env value must be a string.' });
-        }
-    }
-    return raw;
-}
-/** The caller's profile, as declared on the request. Scoping is what this
- *  means: a profile-scoped cron belongs to its profile; a global one is
- *  canvas-home-wide. A caller that declares no profile stands outside every
- *  profile (a plain shell, or a provenance read) and sees the whole canvas
- *  home — this is a namespacing boundary between profiles, not a security
- *  boundary (the profile is client-declared, like `created_by`). */
-function callerProfile(ctx) {
-    const p = ctx.query.get('profile');
-    return p !== null && p.trim() !== '' ? p.trim() : null;
-}
-/** Is this cron in the caller's scope? */
-function inScope(c, caller) {
-    return caller === null || c.scope === 'global' || c.profile === caller;
-}
-/** `POST /v1/crons` — arm one cron. Validates the full spec surface; every
- *  omitted optional takes its spec default. */
-function handleArm(ctx) {
-    const req = (ctx.body ?? {});
-    const name = requireString(req, 'name');
-    const command = requireString(req, 'command');
-    const fireAt = requireUtcIso(requireString(req, 'fire_at'), 'fire_at');
-    const cwd = requireString(req, 'cwd');
-    const recur = typeof req.recur === 'string' && req.recur !== '' ? requireRecur(req.recur) : null;
-    const expiresAt = typeof req.expires_at === 'string' && req.expires_at !== ''
-        ? requireUtcIso(req.expires_at, 'expires_at')
-        : null;
-    const envJson = typeof req.env_json === 'string' && req.env_json !== '' ? requireEnvJson(req.env_json) : null;
-    // Sink: required by the delivering dispositions, meaningless otherwise —
-    // progressive disclosure via the error that names the need. A node sink is
-    // polling its recipient, so unchanged stdout must not wake it again by default.
-    const rawSink = typeof req.sink === 'string' && req.sink.trim() !== '' ? req.sink.trim() : null;
-    const onOutput = requireEnum(req.on_output, 'on_output', ['silent', 'on-failure', 'always', 'on-change'], rawSink?.startsWith('node:') ? 'on-change' : 'on-failure');
-    const overlap = requireEnum(req.overlap, 'overlap', ['skip', 'queue', 'replace'], 'skip');
-    const tier = requireEnum(req.tier, 'tier', ['normal', 'urgent', 'critical'], 'normal');
-    const delivers = onOutput === 'always' || onOutput === 'on-change';
-    if (delivers && rawSink === null) {
-        throw new InputError({
-            error: 'sink_required',
-            message: `on_output "${onOutput}" delivers stdout every qualifying run — it needs a sink`,
-            field: 'sink',
-            next: 'Pass sink node:<node-id> (a living node\'s inbox), spawn:<kind> (birth a fresh node per delivery), or human (the humanloop inbox).',
-        });
-    }
-    if (!delivers && rawSink !== null) {
-        throw new InputError({
-            error: 'sink_unused',
-            message: `on_output "${onOutput}" never delivers stdout — a sink would be dead config`,
-            field: 'sink',
-            next: 'Drop the sink, or use on_output "always"/"on-change" if delivery is the point.',
-        });
-    }
-    const sink = rawSink !== null ? parseSinkSpec(rawSink) : '{}';
-    // Node coupling: an anchor must exist at arm time; cancel_on_wake is the
-    // deadline rule and only means anything WITH an anchor.
-    const anchorNode = typeof req.anchor_node === 'string' && req.anchor_node !== '' ? req.anchor_node : null;
-    if (anchorNode !== null && getNode(anchorNode) === null) {
-        throw new InputError({
-            error: 'anchor_not_found',
-            message: `anchor node ${anchorNode} does not exist on the canvas`,
-            field: 'anchor_node',
-            next: 'Name a live node id, or drop the anchor — an unanchored cron outlives every node.',
-        });
-    }
-    const cancelOnWake = req.cancel_on_wake === true;
-    if (cancelOnWake && anchorNode === null) {
-        throw new InputError({
-            error: 'cancel_on_wake_needs_anchor',
-            message: 'cancel_on_wake couples the cron to a node\'s dormancy — it requires an anchor node',
-            field: 'anchor_node',
-            next: 'Pass anchor_node with the node whose wake should cancel this cron.',
-        });
-    }
-    const runTimeoutS = req.run_timeout_s ?? 300;
-    if (typeof runTimeoutS !== 'number' || !Number.isInteger(runTimeoutS) || runTimeoutS <= 0) {
-        throw new InputError({
-            error: 'bad_run_timeout',
-            message: `run_timeout_s must be a positive integer (got ${String(req.run_timeout_s)})`,
-            field: 'run_timeout_s',
-            next: 'Send the timeout in whole seconds, e.g. 300.',
-        });
-    }
-    // Execution context: chosen (this request) else inherited (whatever the
-    // client resolved from its own node), always snapshotted onto the row.
-    const profile = typeof req.profile === 'string' && req.profile !== '' ? req.profile : null;
-    const scope = requireEnum(req.scope, 'scope', ['profile', 'global'], profile !== null ? 'profile' : 'global');
-    if (scope === 'profile' && profile === null) {
-        throw new InputError({
-            error: 'scope_needs_profile',
-            message: 'scope "profile" names the profile the cron lists and cancels within — it requires a profile',
-            field: 'profile',
-            next: 'Send a profile, or use scope "global" for a canvas-home-wide cron.',
-        });
-    }
-    // A cancel-on-wake arm REPLACES the anchor's pending deadline (armCron does
-    // the displace-then-insert under one canvas write boundary) — at most one
-    // cancel-on-wake cron per anchor, whoever arms it.
-    const cronId = randomUUID();
-    armCron({
-        cron_id: cronId,
-        name,
-        created_by: typeof req.created_by === 'string' && req.created_by !== '' ? req.created_by : null,
-        command,
-        fire_at: fireAt,
-        recur,
-        tz: typeof req.tz === 'string' ? req.tz : null,
-        expires_at: expiresAt,
-        anchor_node: anchorNode,
-        cancel_on_wake: cancelOnWake,
-        cwd,
-        env_json: envJson,
-        profile,
-        scope,
-        run_timeout_s: runTimeoutS,
-        overlap,
-        on_output: onOutput,
-        sink,
-        tier,
-    });
-    return { status: 201, body: toCronDTO(getCron(cronId), null) };
-}
-/** `GET /v1/crons` — the crons in the caller's scope, next-fire order: that
- *  profile's own rows plus every canvas-home-wide global one. A caller that
- *  declares no profile gets the whole canvas home. */
-function handleList(ctx) {
-    const caller = callerProfile(ctx);
-    const rows = caller === null
-        ? listCrons({ all: true })
-        : [...listCrons({ profile: caller }), ...listCrons({ global: true })].sort((a, b) => a.fire_at < b.fire_at ? -1 : a.fire_at > b.fire_at ? 1 : 0);
-    return { status: 200, body: rows.map((c) => toCronDTO(c, lastRunOf(c))) };
-}
-/** The most recent settled run of one cron (recent health for its projection). */
-function lastRunOf(c) {
-    return listCronRuns(c.cron_id)[0] ?? null;
-}
-/** Resolve one cron the caller may see. A cron outside the caller's scope is
- *  404 with the reason named — profiles namespace crons, so "not here" and
- *  "not anywhere" are the same answer to this caller. */
-function requireCron(ctx) {
-    const cronId = ctx.params['cronId'];
-    const c = getCron(cronId);
-    if (c === null)
-        throw new ApiError(404, 'cron_not_found', `no cron ${cronId}`);
-    if (!inScope(c, callerProfile(ctx))) {
-        throw new ApiError(404, 'cron_not_found', `no cron ${cronId} in this profile — it is scoped to another profile`);
-    }
-    return c;
-}
-/** `GET /v1/crons/:cronId` — one cron with its run-log ring (most recent first). */
-function handleShow(ctx) {
-    const c = requireCron(ctx);
-    const runs = listCronRuns(c.cron_id);
-    return { status: 200, body: { cron: toCronDTO(c, runs[0] ?? null), runs: runs.map(toCronRunDTO) } };
-}
-/** `POST /v1/crons/:cronId/pause` — stop firing without losing config/history.
- *  Idempotent on an already-paused row; 404 on a gone one. */
-function handlePause(ctx) {
-    const c = requireCron(ctx);
-    // An already-paused row reports false; pausing is idempotent by contract, so
-    // that is a no-op, not an error — the returned row is the answer either way.
-    setCronState(c.cron_id, 'paused');
-    const updated = getCron(c.cron_id);
-    return { status: 200, body: toCronDTO(updated, lastRunOf(updated)) };
-}
-/** `POST /v1/crons/:cronId/resume` — re-arm a paused cron. fire_at is NOT
- *  touched: a past-due fire fires on the next tick, so an un-wedged cron
- *  proves itself immediately (recurrence then advances naturally). */
-function handleResume(ctx) {
-    const c = requireCron(ctx);
-    setCronState(c.cron_id, 'active');
-    const updated = getCron(c.cron_id);
-    return { status: 200, body: toCronDTO(updated, lastRunOf(updated)) };
-}
-/** `POST /v1/crons/:cronId/run` — fire NOW, out of band. Synchronous: the
- *  response is the settled run record. Does not advance the schedule, does
- *  not consume a one-shot, delivers per disposition, never escalates/pauses.
- *  Works on a paused cron (that is the escalation node's verification path). */
-async function handleRun(ctx) {
-    const c = requireCron(ctx);
-    if (c.run_state === 'running') {
-        throw new ApiError(409, 'cron_running', `cron ${c.cron_id} has a run in flight — wait for it to settle`);
-    }
-    const record = await executeCron(c, { outOfBand: true });
-    if (record === null) {
-        // Lost the idle→running lease race (a scheduled fire or cancel won).
-        throw new ApiError(409, 'cron_running', `cron ${c.cron_id} was claimed by a concurrent run — check \`cron show\` for its result`);
-    }
-    return { status: 200, body: toCronRunDTO(record) };
-}
-/** `POST /v1/crons/poke` — the bare daemon-level eligibility poke: "something
- *  changed; re-check now". Canvas-wide and label-free by design — the caller
- *  (a host platform, an operator's curl) asserts only that eligibility
- *  changed; every held row re-checks its own gate in bash and re-parks if
- *  still blocked. Paused rows are not unparked (pause is user-owned).
- *  Idempotent and free when nothing is held. The count is for the caller's
- *  log line, nothing else. */
-function handlePoke() {
-    const at = new Date().toISOString();
-    return { status: 200, body: { unparked: pokeHeldCrons(at), at } };
-}
-/** `DELETE /v1/crons/:cronId` — cancel one cron. Idempotent: an already-absent
- *  cron is a no-op 204 (`cancelCron` kills any in-flight run process group
- *  before deleting). */
-function handleCancel(ctx) {
-    const cronId = ctx.params['cronId'];
-    const c = getCron(cronId);
-    // Idempotent: an already-absent cron is a no-op. A cron scoped to ANOTHER
-    // profile is equally not-here for this caller — it must not be cancellable.
-    if (c !== null && !inScope(c, callerProfile(ctx))) {
-        throw new ApiError(404, 'cron_not_found', `no cron ${cronId} in this profile — it is scoped to another profile`);
-    }
-    const runId = ctx.query.get('run_id');
-    // Only the currently running process can preserve itself. An arbitrary or
-    // stale run id falls through to the normal cancellation that kills the
-    // process group before removing the row.
-    const preserveRunningProcess = runId !== null && markSelfCanceledCronRun(cronId, runId);
-    cancelCron(cronId, { preserveRunningProcess });
-    return { status: 204 };
-}
-export const cronRoutes = [
-    { method: 'POST', pattern: '/v1/crons', handler: handleArm },
-    { method: 'GET', pattern: '/v1/crons', handler: handleList },
-    { method: 'GET', pattern: '/v1/crons/:cronId', handler: handleShow },
-    { method: 'POST', pattern: '/v1/crons/:cronId/pause', handler: handlePause },
-    { method: 'POST', pattern: '/v1/crons/:cronId/resume', handler: handleResume },
-    { method: 'POST', pattern: '/v1/crons/poke', handler: handlePoke },
-    { method: 'POST', pattern: '/v1/crons/:cronId/run', handler: handleRun },
-    { method: 'DELETE', pattern: '/v1/crons/:cronId', handler: handleCancel },
-];
+var R=Object.defineProperty;var o=(e,n)=>R(e,"name",{value:n,configurable:!0});import{randomUUID as D}from"node:crypto";import{ApiError as d}from"../../../api/errors.js";import{armCron as z,cancelCron as W,getCron as l,listCrons as w,listCronRuns as O,pokeHeldCrons as B,setCronState as $}from"../../../core/canvas/crons.js";import{getNode as I}from"../../../core/canvas/canvas.js";import{InputError as t}from"../../../core/io.js";import{nextSlotAfter as G}from"../../../core/wake.js";import{executeCron as L,markSelfCanceledCronRun as Z}from"../../cron-run.js";import{toCronDTO as f,toCronRunDTO as j}from"../map.js";function h(e,n){const r=e[n];if(typeof r!="string"||r.trim()==="")throw new t({error:"missing_field",message:`cron arm request requires a non-empty "${n}"`,field:n,next:`Send a non-empty string "${n}".`});return r}o(h,"requireString");function _(e,n,r,s){if(e==null)return s;if(typeof e=="string"&&r.includes(e))return e;throw new t({error:`bad_${n}`,message:`"${String(e)}" is not a valid ${n}`,field:n,next:`Use one of: ${r.join(", ")}.`})}o(_,"requireEnum");function H(e){if(e==="human")return JSON.stringify({human:!0});if(e.startsWith("node:")){const n=e.slice(5).trim();if(n==="")throw new t({error:"bad_sink",message:"node sink requires a node id",field:"sink",next:'Use sink "node:<node-id>".'});if(I(n)===null)throw new t({error:"sink_node_not_found",message:`sink node ${n} does not exist on the canvas`,field:"sink",next:"Name a live node id, or use spawn:<kind> for a delivery that outlives any one node."});return JSON.stringify({node:n})}if(e.startsWith("spawn:")){const n=e.slice(6).trim();if(n==="")throw new t({error:"bad_sink",message:"spawn sink requires a node kind",field:"sink",next:'Use sink "spawn:<kind>" (e.g. spawn:general).'});return JSON.stringify({spawn:n})}throw new t({error:"bad_sink",message:`"${e}" is not a valid sink`,field:"sink",next:"Use node:<node-id>, spawn:<kind>, or human."})}o(H,"parseSinkSpec");const Y=/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;function q(e,n){if(!Y.test(e)||Number.isNaN(Date.parse(e)))throw new t({error:`bad_${n}`,message:`"${e}" is not a UTC ISO instant`,field:n,next:'Send a resolved UTC instant like "2026-06-07T09:00:00.000Z" (the client resolves the time grammar).'});return e}o(q,"requireUtcIso");function F(e){try{G(e,new Date)}catch(n){throw new t({error:"bad_recur",message:`recur is not advanceable: ${n instanceof Error?n.message:String(n)}`,field:"recur",next:'Send recur JSON the daemon can advance: {"every":"6h"} or {"cron":"0 9 * * *","tz":"America/New_York"}.'})}return e}o(F,"requireRecur");function K(e){let n;try{n=JSON.parse(e)}catch{throw new t({error:"bad_env_json",message:"env_json is not valid JSON",field:"env_json",next:'Send a JSON object of string values, e.g. {"API_BASE":"https://x"}.'})}if(typeof n!="object"||n===null||Array.isArray(n))throw new t({error:"bad_env_json",message:"env_json must be a JSON object",field:"env_json",next:'Send a JSON object of string values, e.g. {"API_BASE":"https://x"}.'});for(const[r,s]of Object.entries(n))if(typeof s!="string")throw new t({error:"bad_env_json",message:`env_json value for "${r}" is not a string`,field:"env_json",next:"Every env value must be a string."});return e}o(K,"requireEnvJson");function v(e){const n=e.query.get("profile");return n!==null&&n.trim()!==""?n.trim():null}o(v,"callerProfile");function N(e,n){return n===null||e.scope==="global"||e.profile===n}o(N,"inScope");function M(e){const n=e.body??{},r=h(n,"name"),s=h(n,"command"),i=q(h(n,"fire_at"),"fire_at"),C=h(n,"cwd"),T=typeof n.recur=="string"&&n.recur!==""?F(n.recur):null,E=typeof n.expires_at=="string"&&n.expires_at!==""?q(n.expires_at,"expires_at"):null,P=typeof n.env_json=="string"&&n.env_json!==""?K(n.env_json):null,a=typeof n.sink=="string"&&n.sink.trim()!==""?n.sink.trim():null,c=_(n.on_output,"on_output",["silent","on-failure","always","on-change"],a?.startsWith("node:")?"on-change":"on-failure"),A=_(n.overlap,"overlap",["skip","queue","replace"],"skip"),J=_(n.tier,"tier",["normal","urgent","critical"],"normal"),y=c==="always"||c==="on-change";if(y&&a===null)throw new t({error:"sink_required",message:`on_output "${c}" delivers stdout every qualifying run \u2014 it needs a sink`,field:"sink",next:"Pass sink node:<node-id> (a living node's inbox), spawn:<kind> (birth a fresh node per delivery), or human (the humanloop inbox)."});if(!y&&a!==null)throw new t({error:"sink_unused",message:`on_output "${c}" never delivers stdout \u2014 a sink would be dead config`,field:"sink",next:'Drop the sink, or use on_output "always"/"on-change" if delivery is the point.'});const U=a!==null?H(a):"{}",u=typeof n.anchor_node=="string"&&n.anchor_node!==""?n.anchor_node:null;if(u!==null&&I(u)===null)throw new t({error:"anchor_not_found",message:`anchor node ${u} does not exist on the canvas`,field:"anchor_node",next:"Name a live node id, or drop the anchor \u2014 an unanchored cron outlives every node."});const b=n.cancel_on_wake===!0;if(b&&u===null)throw new t({error:"cancel_on_wake_needs_anchor",message:"cancel_on_wake couples the cron to a node's dormancy \u2014 it requires an anchor node",field:"anchor_node",next:"Pass anchor_node with the node whose wake should cancel this cron."});const p=n.run_timeout_s??300;if(typeof p!="number"||!Number.isInteger(p)||p<=0)throw new t({error:"bad_run_timeout",message:`run_timeout_s must be a positive integer (got ${String(n.run_timeout_s)})`,field:"run_timeout_s",next:"Send the timeout in whole seconds, e.g. 300."});const g=typeof n.profile=="string"&&n.profile!==""?n.profile:null,S=_(n.scope,"scope",["profile","global"],g!==null?"profile":"global");if(S==="profile"&&g===null)throw new t({error:"scope_needs_profile",message:'scope "profile" names the profile the cron lists and cancels within \u2014 it requires a profile',field:"profile",next:'Send a profile, or use scope "global" for a canvas-home-wide cron.'});const x=D();return z({cron_id:x,name:r,created_by:typeof n.created_by=="string"&&n.created_by!==""?n.created_by:null,command:s,fire_at:i,recur:T,tz:typeof n.tz=="string"?n.tz:null,expires_at:E,anchor_node:u,cancel_on_wake:b,cwd:C,env_json:P,profile:g,scope:S,run_timeout_s:p,overlap:A,on_output:c,sink:U,tier:J}),{status:201,body:f(l(x),null)}}o(M,"handleArm");function Q(e){const n=v(e);return{status:200,body:(n===null?w({all:!0}):[...w({profile:n}),...w({global:!0})].sort((s,i)=>s.fire_at<i.fire_at?-1:s.fire_at>i.fire_at?1:0)).map(s=>f(s,k(s)))}}o(Q,"handleList");function k(e){return O(e.cron_id)[0]??null}o(k,"lastRunOf");function m(e){const n=e.params.cronId,r=l(n);if(r===null)throw new d(404,"cron_not_found",`no cron ${n}`);if(!N(r,v(e)))throw new d(404,"cron_not_found",`no cron ${n} in this profile \u2014 it is scoped to another profile`);return r}o(m,"requireCron");function V(e){const n=m(e),r=O(n.cron_id);return{status:200,body:{cron:f(n,r[0]??null),runs:r.map(j)}}}o(V,"handleShow");function X(e){const n=m(e);$(n.cron_id,"paused");const r=l(n.cron_id);return{status:200,body:f(r,k(r))}}o(X,"handlePause");function nn(e){const n=m(e);$(n.cron_id,"active");const r=l(n.cron_id);return{status:200,body:f(r,k(r))}}o(nn,"handleResume");async function en(e){const n=m(e);if(n.run_state==="running")throw new d(409,"cron_running",`cron ${n.cron_id} has a run in flight \u2014 wait for it to settle`);const r=await L(n,{outOfBand:!0});if(r===null)throw new d(409,"cron_running",`cron ${n.cron_id} was claimed by a concurrent run \u2014 check \`cron show\` for its result`);return{status:200,body:j(r)}}o(en,"handleRun");function rn(){const e=new Date().toISOString();return{status:200,body:{unparked:B(e),at:e}}}o(rn,"handlePoke");function on(e){const n=e.params.cronId,r=l(n);if(r!==null&&!N(r,v(e)))throw new d(404,"cron_not_found",`no cron ${n} in this profile \u2014 it is scoped to another profile`);const s=e.query.get("run_id"),i=s!==null&&Z(n,s);return W(n,{preserveRunningProcess:i}),{status:204}}o(on,"handleCancel");const hn=[{method:"POST",pattern:"/v1/crons",handler:M},{method:"GET",pattern:"/v1/crons",handler:Q},{method:"GET",pattern:"/v1/crons/:cronId",handler:V},{method:"POST",pattern:"/v1/crons/:cronId/pause",handler:X},{method:"POST",pattern:"/v1/crons/:cronId/resume",handler:nn},{method:"POST",pattern:"/v1/crons/poke",handler:rn},{method:"POST",pattern:"/v1/crons/:cronId/run",handler:en},{method:"DELETE",pattern:"/v1/crons/:cronId",handler:on}];export{hn as cronRoutes};

package/dist/daemon/api/handlers/daemon.js

@@ -1,76 +1 @@
-// Daemon self-management handlers. Today: the handover that replaces `stop`
-// followed by `start` as the way to put a new runtime generation in service.
-//
-// Why this is an API call and not a kill: the caller is almost always an agent's
-// own bash tool, and crtrd's shutdown tears down every broker it launched
-// (invariant 2) — including the caller's. A client-driven `stop` therefore kills
-// the process tree that issued it, so the command can never report its own
-// success, and the resumed agent sees an aborted tool call and re-runs it. Here
-// the daemon answers FIRST and hands over afterwards, so the ack is a settled
-// tool result in the caller's transcript before the SIGTERM lands.
-import { toMigrateStateDTO } from '../map.js';
-import { boundDaemonControl } from '../../control.js';
-function handleRestart() {
-    const control = boundDaemonControl();
-    if (control === null) {
-        // An API server hosted outside a live `runDaemon` (a test harness) has no
-        // process to hand over.
-        throw {
-            status: 503,
-            code: 'daemon_control_unavailable',
-            message: 'this API server is not hosted by a live daemon and cannot hand over',
-        };
-    }
-    const { graceMs } = control.requestHandover();
-    const body = {
-        accepted: true,
-        predecessor_pid: process.pid,
-        predecessor_epoch: control.epoch,
-        grace_ms: graceMs,
-    };
-    // 202: accepted, not yet performed — the handover happens after this response.
-    return { status: 202, body };
-}
-async function handleAdmit(ctx) {
-    if (ctx.body !== undefined) {
-        throw { status: 400, code: 'invalid_request', message: 'admission request must not include a body' };
-    }
-    const control = boundDaemonControl();
-    if (control === null) {
-        throw {
-            status: 503,
-            code: 'daemon_control_unavailable',
-            message: 'this API server is not hosted by a live daemon and cannot admit normal work',
-        };
-    }
-    const body = await control.admitStartup();
-    return { status: 200, body };
-}
-async function handleMigrate(ctx) {
-    const control = boundDaemonControl();
-    if (control === null) {
-        throw {
-            status: 503,
-            code: 'daemon_control_unavailable',
-            message: 'this API server is not hosted by a live daemon and cannot migrate its corpus',
-        };
-    }
-    const body = ctx.body;
-    if (body !== undefined && (typeof body !== 'object' || body === null || Array.isArray(body))) {
-        throw { status: 400, code: 'invalid_request', message: 'migration request body must be an object' };
-    }
-    const raw = (body ?? {});
-    if (raw.dry_run !== undefined && typeof raw.dry_run !== 'boolean') {
-        throw { status: 400, code: 'invalid_request', message: 'dry_run must be a boolean' };
-    }
-    if (raw.dirs !== undefined && (!Array.isArray(raw.dirs) || raw.dirs.some((dir) => typeof dir !== 'string'))) {
-        throw { status: 400, code: 'invalid_request', message: 'dirs must be an array of strings' };
-    }
-    const result = await control.repairMigrations({ dryRun: raw.dry_run === true, dirs: (raw.dirs ?? []) });
-    return { status: 200, body: toMigrateStateDTO(result.result, { resumed: result.resumed, resumeError: result.resumeError }) };
-}
-export const daemonRoutes = [
-    { method: 'POST', pattern: '/v1/daemon/restart', handler: (_ctx) => handleRestart() },
-    { method: 'POST', pattern: '/v1/daemon/migrate', handler: handleMigrate },
-    { method: 'POST', pattern: '/v1/daemon/admit', handler: handleAdmit },
-];
+var i=Object.defineProperty;var s=(e,t)=>i(e,"name",{value:t,configurable:!0});import{toMigrateStateDTO as u}from"../map.js";import{boundDaemonControl as n}from"../../control.js";function c(){const e=n();if(e===null)throw{status:503,code:"daemon_control_unavailable",message:"this API server is not hosted by a live daemon and cannot hand over"};const{graceMs:t}=e.requestHandover();return{status:202,body:{accepted:!0,predecessor_pid:process.pid,predecessor_epoch:e.epoch,grace_ms:t}}}s(c,"handleRestart");async function m(e){if(e.body!==void 0)throw{status:400,code:"invalid_request",message:"admission request must not include a body"};const t=n();if(t===null)throw{status:503,code:"daemon_control_unavailable",message:"this API server is not hosted by a live daemon and cannot admit normal work"};return{status:200,body:await t.admitStartup()}}s(m,"handleAdmit");async function l(e){const t=n();if(t===null)throw{status:503,code:"daemon_control_unavailable",message:"this API server is not hosted by a live daemon and cannot migrate its corpus"};const r=e.body;if(r!==void 0&&(typeof r!="object"||r===null||Array.isArray(r)))throw{status:400,code:"invalid_request",message:"migration request body must be an object"};const o=r??{};if(o.dry_run!==void 0&&typeof o.dry_run!="boolean")throw{status:400,code:"invalid_request",message:"dry_run must be a boolean"};if(o.dirs!==void 0&&(!Array.isArray(o.dirs)||o.dirs.some(d=>typeof d!="string")))throw{status:400,code:"invalid_request",message:"dirs must be an array of strings"};const a=await t.repairMigrations({dryRun:o.dry_run===!0,dirs:o.dirs??[]});return{status:200,body:u(a.result,{resumed:a.resumed,resumeError:a.resumeError})}}s(l,"handleMigrate");const f=[{method:"POST",pattern:"/v1/daemon/restart",handler:s(e=>c(),"handler")},{method:"POST",pattern:"/v1/daemon/migrate",handler:l},{method:"POST",pattern:"/v1/daemon/admit",handler:m}];export{f as daemonRoutes};