chainlesschain 0.81.0 → 0.132.0

package/src/commands/automation.js

@@ -33,6 +33,37 @@ import {
   FLOW_STATUS,
   EXECUTION_STATUS,
   TRIGGER_TYPE,
+  AUTOMATION_MATURITY_V2,
+  EXECUTION_LIFECYCLE_V2,
+  getMaxActiveAutomationsPerOwnerV2,
+  setMaxActiveAutomationsPerOwnerV2,
+  getMaxRunningExecutionsPerAutomationV2,
+  setMaxRunningExecutionsPerAutomationV2,
+  getAutomationIdleMsV2,
+  setAutomationIdleMsV2,
+  getExecutionStuckMsV2,
+  setExecutionStuckMsV2,
+  registerAutomationV2,
+  getAutomationV2,
+  listAutomationsV2,
+  setAutomationStatusV2,
+  activateAutomationV2,
+  pauseAutomationV2,
+  retireAutomationV2,
+  touchAutomationV2,
+  getActiveAutomationCountV2,
+  createExecutionV2,
+  getExecutionV2 as getExecutionV2Surface,
+  listExecutionsV2,
+  setExecutionStatusV2,
+  startExecutionV2,
+  succeedExecutionV2,
+  failExecutionV2,
+  cancelExecutionV2,
+  getRunningExecutionCountV2,
+  autoPauseIdleAutomationsV2,
+  autoFailStuckExecutionsV2,
+  getAutomationEngineStatsV2,
 } from "../lib/automation-engine.js";
 
 function _dbFromCtx(cmd) {
@@ -68,7 +99,8 @@ export function registerAutomationCommand(program) {
       .description(
         "Workflow automation engine — 12 SaaS connectors + triggers (Phase 96)",
       )
-      .hook("preAction", async (thisCommand) => {
+      .hook("preAction", async (thisCommand, actionCommand) => {
+        if (actionCommand && actionCommand.name().endsWith("-v2")) return;
         const db = await _prepare(thisCommand);
         thisCommand._db = db;
       });
@@ -651,4 +683,242 @@ function _wire(root) {
         await shutdown();
       }
     });
+
+  // ── V2 Surface ──
+
+  const outV2 = (obj) => console.log(JSON.stringify(obj, null, 2));
+  const tryRunV2 = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  };
+
+  root
+    .command("automation-maturities-v2")
+    .description("List V2 automation maturity states")
+    .action(() => outV2(Object.values(AUTOMATION_MATURITY_V2)));
+
+  root
+    .command("execution-lifecycles-v2")
+    .description("List V2 execution lifecycle states")
+    .action(() => outV2(Object.values(EXECUTION_LIFECYCLE_V2)));
+
+  root
+    .command("stats-v2")
+    .description("V2 automation engine stats")
+    .action(() => outV2(getAutomationEngineStatsV2()));
+
+  root
+    .command("get-max-active-automations-v2")
+    .description("Get max active automations per owner (V2)")
+    .action(() =>
+      outV2({
+        maxActiveAutomationsPerOwner: getMaxActiveAutomationsPerOwnerV2(),
+      }),
+    );
+
+  root
+    .command("set-max-active-automations-v2 <n>")
+    .description("Set max active automations per owner (V2)")
+    .action((n) =>
+      tryRunV2(() => {
+        setMaxActiveAutomationsPerOwnerV2(Number(n));
+        outV2({
+          maxActiveAutomationsPerOwner: getMaxActiveAutomationsPerOwnerV2(),
+        });
+      }),
+    );
+
+  root
+    .command("get-max-running-executions-v2")
+    .description("Get max running executions per automation (V2)")
+    .action(() =>
+      outV2({
+        maxRunningExecutionsPerAutomation:
+          getMaxRunningExecutionsPerAutomationV2(),
+      }),
+    );
+
+  root
+    .command("set-max-running-executions-v2 <n>")
+    .description("Set max running executions per automation (V2)")
+    .action((n) =>
+      tryRunV2(() => {
+        setMaxRunningExecutionsPerAutomationV2(Number(n));
+        outV2({
+          maxRunningExecutionsPerAutomation:
+            getMaxRunningExecutionsPerAutomationV2(),
+        });
+      }),
+    );
+
+  root
+    .command("get-automation-idle-ms-v2")
+    .description("Get automation idle threshold (V2)")
+    .action(() => outV2({ automationIdleMs: getAutomationIdleMsV2() }));
+
+  root
+    .command("set-automation-idle-ms-v2 <ms>")
+    .description("Set automation idle threshold (V2)")
+    .action((ms) =>
+      tryRunV2(() => {
+        setAutomationIdleMsV2(Number(ms));
+        outV2({ automationIdleMs: getAutomationIdleMsV2() });
+      }),
+    );
+
+  root
+    .command("get-execution-stuck-ms-v2")
+    .description("Get execution stuck threshold (V2)")
+    .action(() => outV2({ executionStuckMs: getExecutionStuckMsV2() }));
+
+  root
+    .command("set-execution-stuck-ms-v2 <ms>")
+    .description("Set execution stuck threshold (V2)")
+    .action((ms) =>
+      tryRunV2(() => {
+        setExecutionStuckMsV2(Number(ms));
+        outV2({ executionStuckMs: getExecutionStuckMsV2() });
+      }),
+    );
+
+  root
+    .command("active-automation-count-v2 <ownerId>")
+    .description("Active automation count for owner (V2)")
+    .action((ownerId) =>
+      outV2({ ownerId, count: getActiveAutomationCountV2(ownerId) }),
+    );
+
+  root
+    .command("running-execution-count-v2 <automationId>")
+    .description("Running execution count for automation (V2)")
+    .action((automationId) =>
+      outV2({
+        automationId,
+        count: getRunningExecutionCountV2(automationId),
+      }),
+    );
+
+  root
+    .command("register-automation-v2 <id>")
+    .description("Register a V2 automation")
+    .requiredOption("-o, --owner <id>", "owner id")
+    .requiredOption("-n, --name <name>", "automation name")
+    .action((id, opts) =>
+      tryRunV2(() =>
+        outV2(
+          registerAutomationV2(id, { ownerId: opts.owner, name: opts.name }),
+        ),
+      ),
+    );
+
+  root
+    .command("get-automation-v2 <id>")
+    .description("Get a V2 automation")
+    .action((id) => outV2(getAutomationV2(id)));
+
+  root
+    .command("list-automations-v2")
+    .description("List V2 automations")
+    .option("-o, --owner <id>", "filter by owner")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      outV2(listAutomationsV2({ ownerId: opts.owner, status: opts.status })),
+    );
+
+  root
+    .command("set-automation-status-v2 <id> <next>")
+    .description("Set V2 automation status")
+    .action((id, next) =>
+      tryRunV2(() => outV2(setAutomationStatusV2(id, next))),
+    );
+
+  root
+    .command("activate-automation-v2 <id>")
+    .description("Activate a V2 automation")
+    .action((id) => tryRunV2(() => outV2(activateAutomationV2(id))));
+
+  root
+    .command("pause-automation-v2 <id>")
+    .description("Pause a V2 automation")
+    .action((id) => tryRunV2(() => outV2(pauseAutomationV2(id))));
+
+  root
+    .command("retire-automation-v2 <id>")
+    .description("Retire a V2 automation")
+    .action((id) => tryRunV2(() => outV2(retireAutomationV2(id))));
+
+  root
+    .command("touch-automation-v2 <id>")
+    .description("Touch a V2 automation")
+    .action((id) => tryRunV2(() => outV2(touchAutomationV2(id))));
+
+  root
+    .command("create-execution-v2 <id>")
+    .description("Create a V2 execution")
+    .requiredOption("-a, --automation <id>", "automation id")
+    .action((id, opts) =>
+      tryRunV2(() =>
+        outV2(createExecutionV2(id, { automationId: opts.automation })),
+      ),
+    );
+
+  root
+    .command("get-execution-v2 <id>")
+    .description("Get a V2 execution")
+    .action((id) => outV2(getExecutionV2Surface(id)));
+
+  root
+    .command("list-executions-v2")
+    .description("List V2 executions")
+    .option("-a, --automation <id>", "filter by automation")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      outV2(
+        listExecutionsV2({
+          automationId: opts.automation,
+          status: opts.status,
+        }),
+      ),
+    );
+
+  root
+    .command("set-execution-status-v2 <id> <next>")
+    .description("Set V2 execution status")
+    .action((id, next) =>
+      tryRunV2(() => outV2(setExecutionStatusV2(id, next))),
+    );
+
+  root
+    .command("start-execution-v2 <id>")
+    .description("Start a V2 execution")
+    .action((id) => tryRunV2(() => outV2(startExecutionV2(id))));
+
+  root
+    .command("succeed-execution-v2 <id>")
+    .description("Succeed a V2 execution")
+    .action((id) => tryRunV2(() => outV2(succeedExecutionV2(id))));
+
+  root
+    .command("fail-execution-v2 <id>")
+    .description("Fail a V2 execution")
+    .action((id) => tryRunV2(() => outV2(failExecutionV2(id))));
+
+  root
+    .command("cancel-execution-v2 <id>")
+    .description("Cancel a V2 execution")
+    .action((id) => tryRunV2(() => outV2(cancelExecutionV2(id))));
+
+  root
+    .command("auto-pause-idle-automations-v2")
+    .description("Auto-pause idle V2 automations")
+    .action(() => outV2(autoPauseIdleAutomationsV2()));
+
+  root
+    .command("auto-fail-stuck-executions-v2")
+    .description("Auto-fail stuck V2 executions")
+    .action(() => outV2(autoFailStuckExecutionsV2()));
 }

package/src/commands/codegen.js

@@ -20,8 +20,52 @@ import {
   getScaffold,
   listScaffolds,
   getCodeAgentStats,
+
+  // Phase 86 V2
+  AGENT_MATURITY_V2,
+  GEN_JOB_V2,
+  getDefaultMaxActiveAgentsPerOwnerV2,
+  getMaxActiveAgentsPerOwnerV2,
+  setMaxActiveAgentsPerOwnerV2,
+  getDefaultMaxRunningJobsPerOwnerV2,
+  getMaxRunningJobsPerOwnerV2,
+  setMaxRunningJobsPerOwnerV2,
+  getDefaultAgentIdleMsV2,
+  getAgentIdleMsV2,
+  setAgentIdleMsV2,
+  getDefaultJobStuckMsV2,
+  getJobStuckMsV2,
+  setJobStuckMsV2,
+  registerAgentV2,
+  getAgentV2,
+  setAgentMaturityV2,
+  activateAgent,
+  deprecateAgent,
+  retireAgent,
+  touchAgentInvocation,
+  enqueueGenJobV2,
+  getGenJobV2,
+  setGenJobStatusV2,
+  startGenJob,
+  succeedGenJob,
+  failGenJob,
+  cancelGenJob,
+  getActiveAgentCount,
+  getRunningJobCount,
+  autoRetireIdleAgents,
+  autoFailStuckGenJobs,
+  getCodeAgentStatsV2,
 } from "../lib/code-agent.js";
 
+function _parseMetaV2(raw) {
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error("--metadata must be valid JSON");
+  }
+}
+
 function _dbFromCtx(cmd) {
   const root = cmd?.parent?.parent ?? cmd?.parent;
   return root?._db;
@@ -299,5 +343,185 @@ export function registerCodegenCommand(program) {
       }
     });
 
+  /* ═══════════════════════════════════════════════════ *
+   *  Phase 86 V2
+   * ═══════════════════════════════════════════════════ */
+
+  cg.command("agent-maturities-v2")
+    .description("List V2 agent maturity states")
+    .option("--json", "JSON")
+    .action((opts) => {
+      const xs = Object.values(AGENT_MATURITY_V2);
+      if (opts.json) return console.log(JSON.stringify(xs, null, 2));
+      for (const x of xs) console.log(`  ${x}`);
+    });
+
+  cg.command("gen-jobs-v2")
+    .description("List V2 generation-job states")
+    .option("--json", "JSON")
+    .action((opts) => {
+      const xs = Object.values(GEN_JOB_V2);
+      if (opts.json) return console.log(JSON.stringify(xs, null, 2));
+      for (const x of xs) console.log(`  ${x}`);
+    });
+
+  cg.command("default-max-active-agents-per-owner").action(() =>
+    console.log(getDefaultMaxActiveAgentsPerOwnerV2()),
+  );
+  cg.command("max-active-agents-per-owner").action(() =>
+    console.log(getMaxActiveAgentsPerOwnerV2()),
+  );
+  cg.command("set-max-active-agents-per-owner <n>").action((n) =>
+    console.log(setMaxActiveAgentsPerOwnerV2(n)),
+  );
+
+  cg.command("default-max-running-jobs-per-owner").action(() =>
+    console.log(getDefaultMaxRunningJobsPerOwnerV2()),
+  );
+  cg.command("max-running-jobs-per-owner").action(() =>
+    console.log(getMaxRunningJobsPerOwnerV2()),
+  );
+  cg.command("set-max-running-jobs-per-owner <n>").action((n) =>
+    console.log(setMaxRunningJobsPerOwnerV2(n)),
+  );
+
+  cg.command("default-agent-idle-ms").action(() =>
+    console.log(getDefaultAgentIdleMsV2()),
+  );
+  cg.command("agent-idle-ms").action(() => console.log(getAgentIdleMsV2()));
+  cg.command("set-agent-idle-ms <ms>").action((ms) =>
+    console.log(setAgentIdleMsV2(ms)),
+  );
+
+  cg.command("default-job-stuck-ms").action(() =>
+    console.log(getDefaultJobStuckMsV2()),
+  );
+  cg.command("job-stuck-ms").action(() => console.log(getJobStuckMsV2()));
+  cg.command("set-job-stuck-ms <ms>").action((ms) =>
+    console.log(setJobStuckMsV2(ms)),
+  );
+
+  cg.command("active-agent-count")
+    .option("-o, --owner <id>")
+    .action((opts) => console.log(getActiveAgentCount(opts.owner)));
+  cg.command("running-job-count")
+    .option("-o, --owner <id>")
+    .action((opts) => console.log(getRunningJobCount(opts.owner)));
+
+  cg.command("register-agent-v2 <agent-id>")
+    .requiredOption("-o, --owner <id>")
+    .option("-n, --name <name>")
+    .option("-i, --initial-status <s>")
+    .option("--metadata <json>")
+    .action((id, opts) => {
+      const r = registerAgentV2(null, {
+        agentId: id,
+        ownerId: opts.owner,
+        name: opts.name,
+        initialStatus: opts.initialStatus,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  cg.command("agent-v2 <agent-id>").action((id) => {
+    const r = getAgentV2(id);
+    if (!r) {
+      console.error(`Unknown agent: ${id}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(JSON.stringify(r, null, 2));
+  });
+
+  cg.command("set-agent-maturity-v2 <agent-id> <status>")
+    .option("-r, --reason <text>")
+    .option("--metadata <json>")
+    .action((id, status, opts) => {
+      const r = setAgentMaturityV2(null, id, status, {
+        reason: opts.reason,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  for (const [name, fn] of [
+    ["activate-agent", activateAgent],
+    ["deprecate-agent", deprecateAgent],
+    ["retire-agent", retireAgent],
+  ]) {
+    cg.command(`${name} <agent-id>`)
+      .option("-r, --reason <text>")
+      .action((id, opts) => {
+        const r = fn(null, id, opts.reason);
+        console.log(JSON.stringify(r, null, 2));
+      });
+  }
+
+  cg.command("touch-agent-invocation <agent-id>").action((id) =>
+    console.log(JSON.stringify(touchAgentInvocation(id), null, 2)),
+  );
+
+  cg.command("enqueue-gen-job-v2 <job-id>")
+    .requiredOption("-o, --owner <id>")
+    .requiredOption("-a, --agent <id>")
+    .requiredOption("-p, --prompt <text>")
+    .option("--metadata <json>")
+    .action((id, opts) => {
+      const r = enqueueGenJobV2(null, {
+        jobId: id,
+        ownerId: opts.owner,
+        agentId: opts.agent,
+        prompt: opts.prompt,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  cg.command("gen-job-v2 <job-id>").action((id) => {
+    const r = getGenJobV2(id);
+    if (!r) {
+      console.error(`Unknown job: ${id}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(JSON.stringify(r, null, 2));
+  });
+
+  cg.command("set-gen-job-status-v2 <job-id> <status>")
+    .option("-r, --reason <text>")
+    .option("--metadata <json>")
+    .action((id, status, opts) => {
+      const r = setGenJobStatusV2(null, id, status, {
+        reason: opts.reason,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  for (const [name, fn] of [
+    ["start-gen-job", startGenJob],
+    ["succeed-gen-job", succeedGenJob],
+    ["fail-gen-job", failGenJob],
+    ["cancel-gen-job", cancelGenJob],
+  ]) {
+    cg.command(`${name} <job-id>`)
+      .option("-r, --reason <text>")
+      .action((id, opts) => {
+        const r = fn(null, id, opts.reason);
+        console.log(JSON.stringify(r, null, 2));
+      });
+  }
+
+  cg.command("auto-retire-idle-agents").action(() =>
+    console.log(JSON.stringify(autoRetireIdleAgents(null), null, 2)),
+  );
+  cg.command("auto-fail-stuck-gen-jobs").action(() =>
+    console.log(JSON.stringify(autoFailStuckGenJobs(null), null, 2)),
+  );
+  cg.command("stats-v2").action(() =>
+    console.log(JSON.stringify(getCodeAgentStatsV2(), null, 2)),
+  );
+
   program.addCommand(cg);
 }