chainlesschain 0.163.4 → 0.163.6

package/src/commands/agenda.js

@@ -29,6 +29,11 @@ import { monitorEventEnvelope, capEventPayload } from "../lib/monitor-event.js";
 import { unattendedDisallowedTools } from "../lib/unattended-action-policy.js";
 import executionBroker from "../lib/process-execution-broker/index.js";
 import { collectWorkspacePluginBinSandboxPolicy } from "../lib/plugin-runtime/bin.js";
+import {
+  AgendaSchedulerBridge,
+  agendaBridgeAction,
+} from "../lib/scheduler-kernel/agenda-adapter.js";
+import { openSchedulerStore } from "../lib/scheduler-kernel/store.js";
 import sharedShellPolicy from "../runtime/coding-agent-shell-policy.cjs";
 
 const { evaluateShellCommandPolicy } = sharedShellPolicy;
@@ -144,6 +149,70 @@ function isExecutionPolicyFailure(error) {
   );
 }
 
+export async function evaluateAgendaMonitor(
+  entry,
+  { runCommand, readWatchedFile, fetchUrl, now },
+) {
+  let output = "";
+  let matched = false;
+  let mtimeMs = null;
+  if (entry.source === "file") {
+    const file = await readWatchedFile(entry.watchFile);
+    output = file.content;
+    mtimeMs = file.mtimeMs ?? null;
+    if (entry.watchChange) {
+      matched =
+        entry.lastMtimeMs != null &&
+        mtimeMs != null &&
+        mtimeMs > entry.lastMtimeMs;
+    } else {
+      matched = entry.stopWhen
+        ? new RegExp(entry.stopWhen).test(file.content)
+        : file.exists;
+    }
+  } else if (entry.source === "http") {
+    const res = await fetchUrl(entry.watchUrl);
+    output = res.body;
+    matched = entry.stopWhen
+      ? new RegExp(entry.stopWhen).test(res.body)
+      : res.ok;
+  } else {
+    const workspaceCwd = resolveMonitorWorkspaceCwd(entry);
+    assertMonitorShellPolicy(entry.command);
+    output = await runCommand(entry.command, { workspaceCwd });
+    matched = entry.stopWhen ? new RegExp(entry.stopWhen).test(output) : false;
+  }
+  if (!matched) return { matched: false, mtimeMs };
+
+  const what =
+    entry.source === "file"
+      ? entry.watchFile
+      : entry.source === "http"
+        ? entry.watchUrl
+        : entry.command;
+  const envelope = monitorEventEnvelope(
+    entry.id,
+    { what, output },
+    { at: now, source: entry.source },
+  );
+  const duplicate =
+    entry.lastEventId != null && entry.lastEventId === envelope.event_id;
+  return {
+    matched: true,
+    mtimeMs,
+    eventId: envelope.event_id,
+    authority: envelope.authority,
+    truncated: envelope.truncated === true,
+    notification: duplicate
+      ? null
+      : {
+          title: entry.notify?.title || `Monitor matched: ${what}`,
+          body: capEventPayload(output, 500).value,
+          level: "success",
+        },
+  };
+}
+
 export function registerAgendaCommand(program) {
   const cmd = program
     .command("agenda")
@@ -228,7 +297,7 @@ export function runAgendaList(options = {}, _deps = {}) {
       e.kind === "wakeup"
         ? new Date(e.dueAt).toISOString()
         : e.kind === "cron"
-          ? `${e.cron} (next ${new Date(e.nextAt).toISOString()})`
+          ? `${e.cron}${e.timeZone ? ` [${e.timeZone}]` : ""} (next ${new Date(e.nextAt).toISOString()})`
           : `${monitorWhat} (next ${new Date(e.nextAt).toISOString()})`;
     const expiry =
       e.expiresAt != null
@@ -339,18 +408,63 @@ export async function runAgendaRun(options = {}, _deps = {}) {
   const readWatchedFile = _deps.readWatchedFile || defaultReadWatchedFile;
   const fetchUrl = _deps.fetchUrl || defaultFetchUrl;
   const notify = _deps.notify || sendAgentNotification;
-  const now = _deps.now ? _deps.now() : Date.now();
+  const clock = _deps.now || Date.now;
+  const now = clock();
   // Retire expired entries BEFORE firing due ones — an expired task never gets
   // a final fire (schedule-planner semantics). Dry-run inspects without mutating.
   const retired = options.dryRun
     ? partitionSchedule(store.list(), { now }).expired
     : store.retireExpired(now);
+  const actions = [];
+  const useSchedulerKernel =
+    !options.dryRun &&
+    (_deps.useSchedulerKernel === true ||
+      _deps.schedulerStore != null ||
+      _deps.store == null);
+  let schedulerEntries = [];
+  if (useSchedulerKernel) {
+    let schedulerStore = _deps.schedulerStore;
+    const ownsSchedulerStore = schedulerStore == null;
+    try {
+      schedulerStore ||= openSchedulerStore();
+      const bridge = new AgendaSchedulerBridge({
+        agendaStore: store,
+        schedulerStore,
+        runAgent: ({ prompt, runPolicy }) => spawnAgent(prompt, runPolicy),
+        runMonitor: ({ entry }) =>
+          evaluateAgendaMonitor(entry, {
+            runCommand,
+            readWatchedFile,
+            fetchUrl,
+            now: clock(),
+          }),
+        notifyMonitor: notify,
+        now: clock,
+        ...(options.leaseMs === undefined
+          ? {}
+          : { leaseMs: Number(options.leaseMs) }),
+        ...(_deps.schedulerOwnerId === undefined
+          ? {}
+          : { ownerId: _deps.schedulerOwnerId }),
+      });
+      schedulerEntries = await bridge.runDue({
+        signal: options.signal || _deps.signal,
+      });
+      for (const scheduled of schedulerEntries) {
+        const action = agendaBridgeAction(scheduled);
+        if (action) actions.push(action);
+      }
+    } finally {
+      if (ownsSchedulerStore) schedulerStore?.close();
+    }
+  }
   const due = options.dryRun
     ? store.due(null, now)
-    : typeof store.claimDue === "function"
-      ? store.claimDue(now, options.leaseMs)
-      : store.due(null, now);
-  const actions = [];
+    : useSchedulerKernel
+      ? []
+      : typeof store.claimDue === "function"
+        ? store.claimDue(now, options.leaseMs)
+        : store.due(null, now);
 
   for (const entry of due) {
     if (options.dryRun) {
@@ -488,7 +602,11 @@ export async function runAgendaRun(options = {}, _deps = {}) {
   if (options.json) {
     log(
       JSON.stringify(
-        { due: due.length, retired: retiredSummary, actions },
+        {
+          due: due.length + schedulerEntries.length,
+          retired: retiredSummary,
+          actions,
+        },
         null,
         2,
       ),

package/src/commands/automation.js

@@ -4,8 +4,30 @@
  */
 
 import chalk from "chalk";
+import {
+  inspectAutomationExecutionAuthority,
+  setAutomationExecutionBudget,
+} from "../lib/automation-execution-authority.js";
+import {
+  buildAutomationCenterProjection,
+  runAutomationCenterAction,
+} from "../lib/automation-center.js";
+import {
+  createAutomationCenterRoutine,
+  editAutomationCenterRoutine,
+  runAutomationCenterRoutineAction,
+} from "../lib/automation-center-routines.js";
 import { logger } from "../lib/logger.js";
 import { parseJsonOption } from "../lib/parse-json-option.js";
+import { AutomationSchedulerBridge } from "../lib/scheduler-kernel/automation-adapter.js";
+import { AutomationEventDispatcher } from "../lib/scheduler-kernel/automation-event-adapter.js";
+import { openSchedulerStore } from "../lib/scheduler-kernel/store.js";
+import {
+  RoutineSchedulerBridge,
+  routineBridgeRunId,
+} from "../lib/scheduler-kernel/routine-adapter.js";
+import { RoutineStore } from "../lib/routine-store.js";
+import { defaultRunAgent } from "./routine.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
   ensureAutomationTables,
@@ -68,8 +90,56 @@ import {
 } from "../lib/automation-engine.js";
 
 function _dbFromCtx(cmd) {
-  const root = cmd?.parent?.parent ?? cmd?.parent;
-  return root?._db;
+  let current = cmd;
+  while (current) {
+    if (current._db) return current._db;
+    current = current.parent;
+  }
+  return null;
+}
+
+async function readBoundedJsonStdin(options, maximum = 80 * 1024) {
+  if (options?.jsonStdin !== true) {
+    throw new Error("--json-stdin is required for routine definitions");
+  }
+  let serialized = "";
+  for await (const chunk of process.stdin) {
+    serialized += chunk;
+    if (Buffer.byteLength(serialized, "utf8") > maximum) {
+      throw new Error(`routine definition exceeds ${maximum} UTF-8 bytes`);
+    }
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    throw new Error("routine definition stdin must be valid JSON");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("routine definition stdin must be a JSON object");
+  }
+  return parsed;
+}
+
+async function triggerCenterRoutine(store, routine) {
+  const schedulerStore = openSchedulerStore();
+  try {
+    const bridge = new RoutineSchedulerBridge({
+      routineStore: store,
+      schedulerStore,
+      runAgent: defaultRunAgent,
+    });
+    const fired = await bridge.trigger(routine);
+    const runId = routineBridgeRunId(fired);
+    if (!runId) {
+      throw new Error(
+        `routine occurrence did not execute: ${fired.result?.status || "unknown"}`,
+      );
+    }
+    return store.getRun(runId) || { runId, status: "unknown" };
+  } finally {
+    schedulerStore.close();
+  }
 }
 
 async function _prepare(cmd) {
@@ -84,6 +154,129 @@ async function _prepare(cmd) {
   return db;
 }
 
+export async function runAutomationScheduled(db, options = {}, _deps = {}) {
+  const log = _deps.log || ((message) => console.log(message));
+  let schedulerStore = _deps.schedulerStore;
+  const ownsSchedulerStore = schedulerStore == null;
+  try {
+    schedulerStore ||= openSchedulerStore();
+    const bridge = new AutomationSchedulerBridge({
+      db,
+      schedulerStore,
+      now: _deps.now || Date.now,
+      ...(_deps.ownerId === undefined ? {} : { ownerId: _deps.ownerId }),
+      ...(options.leaseMs === undefined
+        ? {}
+        : { leaseMs: Number(options.leaseMs) }),
+    });
+    const results = await bridge.runDue({ signal: _deps.signal });
+    const summary = results.map((entry) => ({
+      flow: entry.flow,
+      occurrence: entry.occurrence,
+      status: entry.result?.status ?? "unknown",
+      recovered: entry.recovered === true,
+      deduplicated: entry.deduplicated === true,
+      executionId:
+        typeof entry.result?.result?.id === "string"
+          ? entry.result.result.id
+          : null,
+      error: entry.result?.error ?? null,
+    }));
+    if (options.json) {
+      log(
+        JSON.stringify({ due: summary.length, executions: summary }, null, 2),
+      );
+    } else if (summary.length === 0) {
+      log(chalk.gray("Nothing due."));
+    } else {
+      for (const entry of summary) {
+        const color = entry.status === "succeeded" ? chalk.green : chalk.red;
+        log(
+          color(
+            `${entry.flow} → ${entry.status}${entry.executionId ? ` (${entry.executionId})` : ""}`,
+          ),
+        );
+      }
+    }
+    return summary.some(
+      (entry) =>
+        entry.status !== "succeeded" &&
+        entry.status !== "idle" &&
+        entry.status !== "busy",
+    )
+      ? 1
+      : 0;
+  } finally {
+    if (ownsSchedulerStore) schedulerStore?.close();
+  }
+}
+
+export async function runAutomationChannelEvent(db, options = {}, _deps = {}) {
+  const log = _deps.log || ((message) => console.log(message));
+  let schedulerStore = _deps.schedulerStore;
+  const ownsSchedulerStore = schedulerStore == null;
+  try {
+    schedulerStore ||= openSchedulerStore();
+    const dispatcher = new AutomationEventDispatcher({
+      db,
+      schedulerStore,
+      now: _deps.now || Date.now,
+      ...(_deps.ownerId === undefined ? {} : { ownerId: _deps.ownerId }),
+      ...(options.leaseMs === undefined
+        ? {}
+        : { leaseMs: Number(options.leaseMs) }),
+    });
+    const result = await dispatcher.dispatch(
+      {
+        id: options.eventId,
+        type: "channel.event",
+        origin: options.origin,
+        sender: options.sender || null,
+        text: options.text,
+        meta: options.meta || {},
+        producedAt:
+          options.producedAt === undefined
+            ? Number((_deps.now || Date.now)())
+            : Number(options.producedAt),
+      },
+      { signal: _deps.signal },
+    );
+    const summary = {
+      eventId: result.eventId,
+      matched: result.matched,
+      rejected: result.rejected,
+      executions: result.results.map((entry) => ({
+        flowId: entry.flowId,
+        triggerId: entry.triggerId,
+        occurrenceId: entry.occurrenceId,
+        deduplicated: entry.deduplicated,
+        status: entry.result?.status || "unknown",
+        executionId: entry.result?.result?.id || null,
+        error: entry.result?.error || null,
+      })),
+    };
+    if (options.json) {
+      log(JSON.stringify(summary, null, 2));
+    } else if (summary.matched === 0) {
+      log(
+        chalk.gray(`No scoped automation trigger matched ${summary.eventId}.`),
+      );
+    } else {
+      for (const entry of summary.executions) {
+        const color = entry.status === "succeeded" ? chalk.green : chalk.red;
+        log(
+          color(
+            `${entry.triggerId} → ${entry.status}${entry.executionId ? ` (${entry.executionId})` : ""}`,
+          ),
+        );
+      }
+    }
+    return summary;
+  } finally {
+    if (ownsSchedulerStore) schedulerStore?.close();
+  }
+}
+
 export function registerAutomationCommand(program) {
   const make = (name) => {
     const cmd = program
@@ -92,7 +285,12 @@ export function registerAutomationCommand(program) {
         "Workflow automation engine — 12 SaaS connectors + triggers (Phase 96)",
       )
       .hook("preAction", async (thisCommand, actionCommand) => {
-        if (actionCommand && actionCommand.name().endsWith("-v2")) return;
+        if (
+          actionCommand &&
+          (actionCommand.name().endsWith("-v2") ||
+            actionCommand.name().startsWith("center-routine-"))
+        )
+          return;
         const db = await _prepare(thisCommand);
         thisCommand._db = db;
       });
@@ -241,6 +439,140 @@ function _wire(root) {
       }
     });
 
+  root
+    .command("center-projection")
+    .description("Emit the versioned Automation Center projection for IDEs")
+    .option("-l, --limit <n>", "Maximum flows", "100")
+    .option("--json", "Output as JSON")
+    .action(async (opts, cmd) => {
+      const db = _dbFromCtx(cmd);
+      try {
+        const projection = buildAutomationCenterProjection(db, {
+          limit: Number(opts.limit),
+        });
+        if (opts.json) console.log(JSON.stringify(projection, null, 2));
+        else {
+          logger.info(
+            `${projection.summary.total} items (${projection.summary.flows} flows, ${projection.summary.routines} routines), ${projection.summary.needsAttention} need attention`,
+          );
+          for (const flow of projection.items) {
+            logger.log(
+              `  ${chalk.cyan(flow.id)} ${flow.kind.padEnd(7)} ${flow.status.padEnd(8)} ${flow.name} preflight=${flow.security.state}`,
+            );
+          }
+        }
+      } catch (e) {
+        logger.error(e.message);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
+      }
+    });
+
+  root
+    .command("center-routine-create")
+    .description("Create a revision-gated Routine from JSON stdin")
+    .requiredOption(
+      "--expected-revision <revision>",
+      "Exact Routine catalog revision shown by center-projection",
+    )
+    .requiredOption("--json-stdin", "Read the Routine definition from stdin")
+    .option("--json", "Output as JSON")
+    .action(async (opts) => {
+      try {
+        const result = createAutomationCenterRoutine(new RoutineStore(), {
+          expectedRevision: opts.expectedRevision,
+          definition: await readBoundedJsonStdin(opts),
+        });
+        if (opts.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`Created routine ${result.routineId}`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
+      }
+    });
+
+  root
+    .command("center-routine-edit <routineId>")
+    .description("Edit a revision-gated Routine from JSON stdin")
+    .requiredOption(
+      "--expected-revision <revision>",
+      "Exact Routine item revision shown by center-projection",
+    )
+    .requiredOption("--json-stdin", "Read the Routine definition from stdin")
+    .option("--json", "Output as JSON")
+    .action(async (routineId, opts) => {
+      try {
+        const result = editAutomationCenterRoutine(new RoutineStore(), {
+          routineId,
+          expectedRevision: opts.expectedRevision,
+          definition: await readBoundedJsonStdin(opts),
+        });
+        if (opts.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`Edited routine ${result.routineId}`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
+      }
+    });
+
+  root
+    .command("center-routine-action <routineId> <action>")
+    .description("Run a revision-gated Routine action")
+    .requiredOption(
+      "--expected-revision <revision>",
+      "Exact Routine item revision shown by center-projection",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (routineId, action, opts) => {
+      try {
+        const store = new RoutineStore();
+        const result = await runAutomationCenterRoutineAction(store, {
+          routineId,
+          action,
+          expectedRevision: opts.expectedRevision,
+          triggerRoutine: (routine) => triggerCenterRoutine(store, routine),
+        });
+        if (opts.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`${routineId} ${action} completed`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
+      }
+    });
+
+  root
+    .command("center-action <flowId> <action>")
+    .description("Run a revision-gated Automation Center action")
+    .requiredOption(
+      "--expected-revision <revision>",
+      "Exact flow revision shown by center-projection",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (flowId, action, opts, cmd) => {
+      const db = _dbFromCtx(cmd);
+      try {
+        const result = runAutomationCenterAction(db, {
+          flowId,
+          action,
+          expectedRevision: opts.expectedRevision,
+        });
+        if (opts.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`${flowId} ${action} completed`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
+      }
+    });
+
   root
     .command("show <flowId>")
     .description("Show flow detail")
@@ -360,6 +692,94 @@ function _wire(root) {
       }
     });
 
+  root
+    .command("run-scheduled")
+    .description("Run due cron flows through the durable scheduler kernel")
+    .option("--json", "Output as JSON")
+    .option("--lease-ms <ms>", "Scheduler execution lease in milliseconds")
+    .action(async (opts, cmd) => {
+      const db = _dbFromCtx(cmd);
+      try {
+        const code = await runAutomationScheduled(db, opts);
+        if (code !== 0) process.exitCode = code;
+      } catch (e) {
+        logger.error(e.message);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
+      }
+    });
+
+  root
+    .command("set-execution-budget <flowId>")
+    .description("Set the durable unattended-execution budget for a flow")
+    .requiredOption("--window-ms <ms>", "Fixed budget window in milliseconds")
+    .requiredOption("--max-runs <n>", "Maximum executions per window")
+    .requiredOption(
+      "--max-action-steps <n>",
+      "Maximum connector action steps per window",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (flowId, opts, cmd) => {
+      const db = _dbFromCtx(cmd);
+      try {
+        const budget = setAutomationExecutionBudget(db, flowId, {
+          windowMs: Number(opts.windowMs),
+          maxRuns: Number(opts.maxRuns),
+          maxActionSteps: Number(opts.maxActionSteps),
+        });
+        if (opts.json) console.log(JSON.stringify(budget, null, 2));
+        else {
+          logger.success(`Execution budget set for ${flowId}`);
+          logger.log(
+            `  revision=${budget.revision} window=${budget.windowMs}ms runs=${budget.maxRuns} actionSteps=${budget.maxActionSteps}`,
+          );
+        }
+      } catch (e) {
+        logger.error(e.message);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
+      }
+    });
+
+  root
+    .command("execution-preflight <flowId>")
+    .description(
+      "Check live RBAC connector permissions and durable budget availability",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (flowId, opts, cmd) => {
+      const db = _dbFromCtx(cmd);
+      try {
+        const flow = getFlow(db, flowId);
+        if (!flow) throw new Error(`Flow not found: ${flowId}`);
+        const result = inspectAutomationExecutionAuthority(db, flow);
+        if (opts.json) console.log(JSON.stringify(result, null, 2));
+        else {
+          const color = result.ready ? chalk.green : chalk.red;
+          logger.log(
+            color(`Execution preflight: ${result.ready ? "READY" : "DENIED"}`),
+          );
+          logger.log(`  principal: ${result.snapshot.principalId}`);
+          for (const permission of result.permissions) {
+            logger.log(
+              `  ${permission.allowed ? "ALLOW" : "DENY "} ${permission.permission}`,
+            );
+          }
+          logger.log(
+            `  remaining: runs=${result.window.remainingRuns} actionSteps=${result.window.remainingActionSteps}`,
+          );
+        }
+        if (!result.ready) process.exitCode = 1;
+      } catch (e) {
+        logger.error(e.message);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
+      }
+    });
+
   root
     .command("share <flowId>")
     .description("Record flow share to another org")
@@ -530,6 +950,45 @@ function _wire(root) {
       }
     });
 
+  root
+    .command("dispatch-channel-event")
+    .description(
+      "Dispatch one durable, scope-checked webhook or Telegram event",
+    )
+    .requiredOption(
+      "--event-id <id>",
+      "Stable source event id for deduplication",
+    )
+    .requiredOption("--origin <origin>", "Event origin (webhook|telegram)")
+    .requiredOption("--text <text>", "Inbound event text")
+    .option("--sender <id>", "Inbound sender id")
+    .option("--meta <json>", "Bounded event metadata as JSON")
+    .option("--produced-at <ms>", "Trusted source event epoch milliseconds")
+    .option("--lease-ms <ms>", "Scheduler execution lease milliseconds")
+    .option("--json", "Output as JSON")
+    .action(async (opts, cmd) => {
+      const db = _dbFromCtx(cmd);
+      try {
+        const summary = await runAutomationChannelEvent(db, {
+          ...opts,
+          meta: parseJsonOption(opts.meta, "--meta") || {},
+        });
+        if (
+          summary.rejected.length > 0 ||
+          summary.executions.some(
+            (entry) => !["succeeded", "busy"].includes(entry.status),
+          )
+        ) {
+          process.exitCode = 1;
+        }
+      } catch (e) {
+        logger.error(e.message);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
+      }
+    });
+
   // ─── Execution ────────────────────────────────────────────
 
   root