chainlesschain 0.163.5 → 0.163.7

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

package/src/commands/background-session.js

@@ -9,6 +9,7 @@ import {
 } from "../lib/collaboration-run-store.js";
 import { readSessionHostResumeState } from "../lib/session-host-snapshot.js";
 import executionBroker from "../lib/process-execution-broker/index.js";
+import { registerSchedulerDaemonCommands } from "./scheduler-daemon.js";
 
 export function buildBackgroundDispatchArgs(prompt) {
   return ["agent", "--bg", `--print=${prompt}`];
@@ -100,6 +101,21 @@ export function formatBackgroundAgentDetails(
     );
   }
   if (session.phase) lines.push(`  phase: ${session.phase}`);
+  if (session.pendingQuestion) {
+    const prompt = String(
+      session.pendingQuestion.prompt || session.pendingQuestion.question || "",
+    )
+      .replace(/\s+/gu, " ")
+      .trim()
+      .slice(0, 240);
+    lines.push(`  needsInput: ${prompt || "question pending"}`);
+  }
+  if (session.needsInputIncident) {
+    const incident = session.needsInputIncident;
+    lines.push(
+      `  needsInputIncident: ${incident.incidentId || "-"} status=${incident.status || "?"} notification=${incident.notification?.status || "?"}`,
+    );
+  }
   if (session.pr?.number) {
     lines.push(
       `  pr: #${session.pr.number}${session.pr.state ? ` ${session.pr.state}` : ""}${session.pr.url ? `  ${session.pr.url}` : ""}`,
@@ -120,6 +136,19 @@ export function formatBackgroundAgentDetails(
   lines.push("", "Commands:");
   lines.push(`  cc attach ${session.id}`);
   lines.push(`  cc logs ${session.id} -n 100`);
+  if (
+    ["failed", "unconfigured"].includes(
+      session.needsInputIncident?.notification?.status,
+    )
+  ) {
+    lines.push(`  cc daemon notify-needs-input ${session.id}`);
+  } else if (
+    ["delivering", "outcome_unknown", "partial"].includes(
+      session.needsInputIncident?.notification?.status,
+    )
+  ) {
+    lines.push(`  cc daemon notify-needs-input ${session.id} --force`);
+  }
   if (session.status === "running") {
     lines.push(`  cc daemon stop ${session.id}`);
   }
@@ -275,6 +304,49 @@ export async function replyBackgroundAgent(id, prompt, dependencies = {}) {
   }
 }
 
+export async function retryBackgroundNeedsInputNotification(
+  id,
+  options = {},
+  dependencies = {},
+) {
+  const sessionId = String(id || "").trim();
+  if (!sessionId) throw new Error("background agent id is required");
+  const supervisor = dependencies.supervisor || (await loadSupervisor());
+  const state = supervisor.readBackgroundAgentState(sessionId);
+  if (!state) throw new Error(`Background agent not found: ${sessionId}`);
+  if (!state.needsInputIncident) {
+    throw new Error(
+      `Background agent ${sessionId} has no needs-input incident`,
+    );
+  }
+  const result = await supervisor.deliverBackgroundNeedsInputNotification(
+    sessionId,
+    {
+      retry: true,
+      force: options.force === true,
+      ...(dependencies.notify ? { notify: dependencies.notify } : {}),
+    },
+  );
+  if (!result.applied) {
+    const error = new Error(
+      result.reason === "delivery_in_progress"
+        ? `Needs-input notification is already being delivered for ${sessionId}`
+        : result.reason === "delivery_not_retryable"
+          ? `Needs-input notification for ${sessionId} is not safely retryable; use --force only after accepting possible duplicate delivery`
+          : `Background agent ${sessionId} no longer has a pending needs-input incident`,
+    );
+    error.code = "BACKGROUND_NEEDS_INPUT_NOTIFICATION_NOT_RETRYABLE";
+    error.reason = result.reason;
+    throw error;
+  }
+  return {
+    id: sessionId,
+    incidentId: result.incident?.incidentId || null,
+    incidentStatus: result.incident?.status || null,
+    notification: result.incident?.notification || null,
+  };
+}
+
 export const LOG_TRUNCATION_NOTICE =
   "--- log truncated/rotated, resuming from tail ---";
 const TRUNCATION_RESUME_TAIL_BYTES = 4096;
@@ -825,7 +897,36 @@ export function registerBackgroundSessionCommands(program) {
 
   const daemon = program
     .command("daemon")
-    .description("Inspect and stop background agent supervisor sessions");
+    .description("Manage background agent and scheduler services");
+
+  registerSchedulerDaemonCommands(daemon);
+
+  daemon
+    .command("notify-needs-input <id>")
+    .description(
+      "Retry a durable needs-input notification for a background run",
+    )
+    .option(
+      "--force",
+      "Retry an ambiguous or already-delivered notification (may duplicate)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const result = await retryBackgroundNeedsInputNotification(id, options);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else {
+          logger.log(
+            chalk.green(
+              `Needs-input notification ${result.notification?.status || "settled"} for ${id}`,
+            ),
+          );
+        }
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
 
   daemon
     .command("status")

package/src/commands/chat.js

@@ -4,8 +4,16 @@
  */
 
 import { createAgentRuntimeFactory } from "../runtime/runtime-factory.js";
+import { assertChatSessionUsageAdmission } from "../lib/chat-session-admission.js";
 
-export function registerChatCommand(program) {
+export { assertChatSessionUsageAdmission } from "../lib/chat-session-admission.js";
+
+export function registerChatCommand(program, dependencies = {}) {
+  const createRuntimeFactory =
+    dependencies.createAgentRuntimeFactory || createAgentRuntimeFactory;
+  const assertUsageAdmission =
+    dependencies.assertChatSessionUsageAdmission ||
+    assertChatSessionUsageAdmission;
   program
     .command("chat")
     .description("Start an interactive AI chat session")
@@ -22,7 +30,8 @@ export function registerChatCommand(program) {
     )
     .option("--session <id>", "Resume a previous session (agent mode)")
     .action(async (options) => {
-      const factory = createAgentRuntimeFactory();
+      if (!options.agent) assertUsageAdmission(options.session);
+      const factory = createRuntimeFactory();
       const runtimeOptions = {
         model: options.model,
         provider: options.provider,