chainlesschain 0.66.0 → 0.132.0

package/src/commands/terraform.js

@@ -12,6 +12,22 @@ import {
   createWorkspace,
   planRun,
   listRuns,
+  // V2
+  RUN_STATUS_V2,
+  RUN_TYPE_V2,
+  WORKSPACE_STATUS_V2,
+  TERRAFORM_DEFAULT_MAX_CONCURRENT,
+  setMaxConcurrentRuns,
+  getMaxConcurrentRuns,
+  createWorkspaceV2,
+  setWorkspaceStatus,
+  archiveWorkspace,
+  planRunV2,
+  setRunStatus,
+  cancelRun,
+  failRun,
+  getActiveRunCount,
+  getTerraformStatsV2,
 } from "../lib/terraform-manager.js";
 
 export function registerTerraformCommand(program) {
@@ -145,4 +161,233 @@ export function registerTerraformCommand(program) {
         process.exit(1);
       }
     });
+
+  /* ── V2 Subcommands (Phase 56) ──────────────────────────── */
+
+  const withDb = async (fn) => {
+    const ctx = await bootstrap({ verbose: program.opts().verbose });
+    if (!ctx.db) {
+      logger.error("Database not available");
+      process.exit(1);
+    }
+    try {
+      const db = ctx.db.getDatabase();
+      ensureTerraformTables(db);
+      return await fn(db);
+    } finally {
+      await shutdown();
+    }
+  };
+
+  terraform
+    .command("run-statuses")
+    .description("List RUN_STATUS_V2 enum values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(RUN_STATUS_V2), null, 2));
+    });
+
+  terraform
+    .command("run-types")
+    .description("List RUN_TYPE_V2 enum values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(RUN_TYPE_V2), null, 2));
+    });
+
+  terraform
+    .command("workspace-statuses")
+    .description("List WORKSPACE_STATUS_V2 enum values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(WORKSPACE_STATUS_V2), null, 2));
+    });
+
+  terraform
+    .command("default-max-concurrent")
+    .description("Show TERRAFORM_DEFAULT_MAX_CONCURRENT")
+    .action(() => {
+      console.log(TERRAFORM_DEFAULT_MAX_CONCURRENT);
+    });
+
+  terraform
+    .command("active-run-count")
+    .description("Show current active (non-terminal) run count")
+    .action(() => {
+      console.log(getActiveRunCount());
+    });
+
+  terraform
+    .command("set-max-concurrent <n>")
+    .description("Set max concurrent runs")
+    .action(async (n) => {
+      try {
+        const value = setMaxConcurrentRuns(Number(n));
+        logger.success(`maxConcurrentRuns = ${value}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  terraform
+    .command("max-concurrent")
+    .description("Show current max concurrent runs")
+    .action(() => {
+      console.log(getMaxConcurrentRuns());
+    });
+
+  terraform
+    .command("create-workspace-v2 <name>")
+    .description("Create workspace (V2, unique-name enforced)")
+    .option("-d, --description <text>", "Workspace description")
+    .option("--tf-version <version>", "Terraform version")
+    .option("--auto-apply", "Enable auto-apply")
+    .option("--providers <list>", "Comma-separated providers")
+    .action(async (name, options) => {
+      await withDb(async (db) => {
+        try {
+          const ws = createWorkspaceV2(db, {
+            name,
+            description: options.description,
+            terraformVersion: options.tfVersion,
+            autoApply: options.autoApply,
+            providers: options.providers
+              ? options.providers.split(",").map((s) => s.trim())
+              : undefined,
+          });
+          logger.success("Workspace created (V2)");
+          logger.log(`  ID:     ${chalk.cyan(ws.id)}`);
+          logger.log(`  Name:   ${ws.name}`);
+          logger.log(`  Status: ${ws.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("set-workspace-status <workspace-id> <status>")
+    .description("Set workspace status (state-machine guarded)")
+    .action(async (workspaceId, status) => {
+      await withDb(async (db) => {
+        try {
+          const result = setWorkspaceStatus(db, workspaceId, status);
+          logger.success(
+            `Workspace ${workspaceId.slice(0, 8)} → ${result.status}`,
+          );
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("archive-workspace <workspace-id>")
+    .description("Archive a workspace (shortcut)")
+    .action(async (workspaceId) => {
+      await withDb(async (db) => {
+        try {
+          const result = archiveWorkspace(db, workspaceId);
+          logger.success(`Workspace archived: ${result.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("plan-run-v2 <workspace-id>")
+    .description("Create a V2 run (pending state, concurrency-limited)")
+    .option("-t, --run-type <type>", "Run type: plan|apply|destroy", "plan")
+    .option("--triggered-by <who>", "Who triggered the run")
+    .action(async (workspaceId, options) => {
+      await withDb(async (db) => {
+        try {
+          const run = planRunV2(db, {
+            workspaceId,
+            runType: options.runType,
+            triggeredBy: options.triggeredBy,
+          });
+          logger.success("Run created (V2)");
+          logger.log(`  ID:     ${chalk.cyan(run.id)}`);
+          logger.log(`  Type:   ${run.runType}`);
+          logger.log(`  Status: ${run.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("set-run-status <run-id> <status>")
+    .description("Set run status (state-machine guarded)")
+    .option("--plan-output <text>", "Plan output summary")
+    .option("--apply-output <text>", "Apply output summary")
+    .option("--resources-added <n>", "Resources added count")
+    .option("--resources-changed <n>", "Resources changed count")
+    .option("--resources-destroyed <n>", "Resources destroyed count")
+    .option("--error-message <text>", "Error message")
+    .action(async (runId, status, options) => {
+      await withDb(async (db) => {
+        try {
+          const patch = {};
+          if (options.planOutput) patch.planOutput = options.planOutput;
+          if (options.applyOutput) patch.applyOutput = options.applyOutput;
+          if (options.resourcesAdded !== undefined)
+            patch.resourcesAdded = Number(options.resourcesAdded);
+          if (options.resourcesChanged !== undefined)
+            patch.resourcesChanged = Number(options.resourcesChanged);
+          if (options.resourcesDestroyed !== undefined)
+            patch.resourcesDestroyed = Number(options.resourcesDestroyed);
+          if (options.errorMessage) patch.errorMessage = options.errorMessage;
+          const run = setRunStatus(db, runId, status, patch);
+          logger.success(`Run ${runId.slice(0, 8)} → ${run.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("cancel-run <run-id>")
+    .description("Cancel a run (shortcut)")
+    .action(async (runId) => {
+      await withDb(async (db) => {
+        try {
+          const run = cancelRun(db, runId);
+          logger.success(`Run cancelled: ${run.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("fail-run <run-id> <error-message>")
+    .description("Mark a run as errored (shortcut)")
+    .action(async (runId, errorMessage) => {
+      await withDb(async (db) => {
+        try {
+          const run = failRun(db, runId, errorMessage);
+          logger.success(`Run errored: ${run.errorMessage}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("stats-v2")
+    .description("Show V2 terraform stats")
+    .action(async () => {
+      await withDb(async () => {
+        const stats = getTerraformStatsV2();
+        console.log(JSON.stringify(stats, null, 2));
+      });
+    });
 }

package/src/commands/tokens.js

@@ -11,6 +11,37 @@ import {
   getTodayStats,
   getCostBreakdown,
   getRecentUsage,
+  BUDGET_MATURITY_V2,
+  USAGE_RECORD_LIFECYCLE_V2,
+  getMaxActiveBudgetsPerOwnerV2,
+  setMaxActiveBudgetsPerOwnerV2,
+  getMaxPendingRecordsPerBudgetV2,
+  setMaxPendingRecordsPerBudgetV2,
+  getBudgetIdleMsV2,
+  setBudgetIdleMsV2,
+  getRecordStuckMsV2,
+  setRecordStuckMsV2,
+  registerBudgetV2,
+  getBudgetV2,
+  listBudgetsV2,
+  setBudgetStatusV2,
+  activateBudgetV2,
+  suspendBudgetV2,
+  archiveBudgetV2,
+  touchBudgetV2,
+  getActiveBudgetCountV2,
+  createUsageRecordV2,
+  getUsageRecordV2,
+  listUsageRecordsV2,
+  setUsageRecordStatusV2,
+  recordUsageV2,
+  billUsageV2,
+  rejectUsageV2,
+  refundUsageV2,
+  getPendingRecordCountV2,
+  autoSuspendIdleBudgetsV2,
+  autoRejectStaleRecordsV2,
+  getTokenTrackerStatsV2,
 } from "../lib/token-tracker.js";
 import {
   getCacheStats,
@@ -211,4 +242,242 @@ export function registerTokensCommand(program) {
         process.exit(1);
       }
     });
+
+  // ── V2 Surface ──
+
+  const out = (json, obj) => {
+    if (json) console.log(JSON.stringify(obj, null, 2));
+    else console.log(JSON.stringify(obj, null, 2));
+  };
+  const tryRun = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  };
+
+  tokens
+    .command("budget-maturities-v2")
+    .description("List V2 budget maturity states")
+    .action(() => out(true, Object.values(BUDGET_MATURITY_V2)));
+
+  tokens
+    .command("usage-record-lifecycles-v2")
+    .description("List V2 usage record lifecycle states")
+    .action(() => out(true, Object.values(USAGE_RECORD_LIFECYCLE_V2)));
+
+  tokens
+    .command("stats-v2")
+    .description("V2 token-tracker stats")
+    .action(() => out(true, getTokenTrackerStatsV2()));
+
+  tokens
+    .command("get-max-active-budgets-v2")
+    .description("Get max active budgets per owner (V2)")
+    .action(() =>
+      out(true, { maxActiveBudgetsPerOwner: getMaxActiveBudgetsPerOwnerV2() }),
+    );
+
+  tokens
+    .command("set-max-active-budgets-v2 <n>")
+    .description("Set max active budgets per owner (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxActiveBudgetsPerOwnerV2(Number(n));
+        out(true, {
+          maxActiveBudgetsPerOwner: getMaxActiveBudgetsPerOwnerV2(),
+        });
+      }),
+    );
+
+  tokens
+    .command("get-max-pending-records-v2")
+    .description("Get max pending records per budget (V2)")
+    .action(() =>
+      out(true, {
+        maxPendingRecordsPerBudget: getMaxPendingRecordsPerBudgetV2(),
+      }),
+    );
+
+  tokens
+    .command("set-max-pending-records-v2 <n>")
+    .description("Set max pending records per budget (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxPendingRecordsPerBudgetV2(Number(n));
+        out(true, {
+          maxPendingRecordsPerBudget: getMaxPendingRecordsPerBudgetV2(),
+        });
+      }),
+    );
+
+  tokens
+    .command("get-budget-idle-ms-v2")
+    .description("Get budget idle threshold (V2)")
+    .action(() => out(true, { budgetIdleMs: getBudgetIdleMsV2() }));
+
+  tokens
+    .command("set-budget-idle-ms-v2 <ms>")
+    .description("Set budget idle threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setBudgetIdleMsV2(Number(ms));
+        out(true, { budgetIdleMs: getBudgetIdleMsV2() });
+      }),
+    );
+
+  tokens
+    .command("get-record-stuck-ms-v2")
+    .description("Get record stuck threshold (V2)")
+    .action(() => out(true, { recordStuckMs: getRecordStuckMsV2() }));
+
+  tokens
+    .command("set-record-stuck-ms-v2 <ms>")
+    .description("Set record stuck threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setRecordStuckMsV2(Number(ms));
+        out(true, { recordStuckMs: getRecordStuckMsV2() });
+      }),
+    );
+
+  tokens
+    .command("active-budget-count-v2 <ownerId>")
+    .description("Active budget count for owner (V2)")
+    .action((ownerId) =>
+      out(true, { ownerId, count: getActiveBudgetCountV2(ownerId) }),
+    );
+
+  tokens
+    .command("pending-record-count-v2 <budgetId>")
+    .description("Pending record count for budget (V2)")
+    .action((budgetId) =>
+      out(true, { budgetId, count: getPendingRecordCountV2(budgetId) }),
+    );
+
+  tokens
+    .command("register-budget-v2 <id>")
+    .description("Register a V2 budget")
+    .requiredOption("-o, --owner <id>", "owner id")
+    .requiredOption("-l, --label <label>", "budget label")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(
+          true,
+          registerBudgetV2(id, { ownerId: opts.owner, label: opts.label }),
+        ),
+      ),
+    );
+
+  tokens
+    .command("get-budget-v2 <id>")
+    .description("Get a V2 budget")
+    .action((id) => out(true, getBudgetV2(id)));
+
+  tokens
+    .command("list-budgets-v2")
+    .description("List V2 budgets")
+    .option("-o, --owner <id>", "filter by owner")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(true, listBudgetsV2({ ownerId: opts.owner, status: opts.status })),
+    );
+
+  tokens
+    .command("set-budget-status-v2 <id> <next>")
+    .description("Set V2 budget status")
+    .action((id, next) => tryRun(() => out(true, setBudgetStatusV2(id, next))));
+
+  tokens
+    .command("activate-budget-v2 <id>")
+    .description("Activate a V2 budget")
+    .action((id) => tryRun(() => out(true, activateBudgetV2(id))));
+
+  tokens
+    .command("suspend-budget-v2 <id>")
+    .description("Suspend a V2 budget")
+    .action((id) => tryRun(() => out(true, suspendBudgetV2(id))));
+
+  tokens
+    .command("archive-budget-v2 <id>")
+    .description("Archive a V2 budget")
+    .action((id) => tryRun(() => out(true, archiveBudgetV2(id))));
+
+  tokens
+    .command("touch-budget-v2 <id>")
+    .description("Touch a V2 budget")
+    .action((id) => tryRun(() => out(true, touchBudgetV2(id))));
+
+  tokens
+    .command("create-usage-record-v2 <id>")
+    .description("Create a V2 usage record")
+    .requiredOption("-b, --budget <id>", "budget id")
+    .requiredOption("-u, --units <n>", "usage units")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(
+          true,
+          createUsageRecordV2(id, {
+            budgetId: opts.budget,
+            units: Number(opts.units),
+          }),
+        ),
+      ),
+    );
+
+  tokens
+    .command("get-usage-record-v2 <id>")
+    .description("Get a V2 usage record")
+    .action((id) => out(true, getUsageRecordV2(id)));
+
+  tokens
+    .command("list-usage-records-v2")
+    .description("List V2 usage records")
+    .option("-b, --budget <id>", "filter by budget")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(
+        true,
+        listUsageRecordsV2({ budgetId: opts.budget, status: opts.status }),
+      ),
+    );
+
+  tokens
+    .command("set-usage-record-status-v2 <id> <next>")
+    .description("Set V2 usage record status")
+    .action((id, next) =>
+      tryRun(() => out(true, setUsageRecordStatusV2(id, next))),
+    );
+
+  tokens
+    .command("record-usage-v2 <id>")
+    .description("Mark V2 usage record recorded")
+    .action((id) => tryRun(() => out(true, recordUsageV2(id))));
+
+  tokens
+    .command("bill-usage-v2 <id>")
+    .description("Bill V2 usage record")
+    .action((id) => tryRun(() => out(true, billUsageV2(id))));
+
+  tokens
+    .command("reject-usage-v2 <id>")
+    .description("Reject V2 usage record")
+    .action((id) => tryRun(() => out(true, rejectUsageV2(id))));
+
+  tokens
+    .command("refund-usage-v2 <id>")
+    .description("Refund V2 usage record")
+    .action((id) => tryRun(() => out(true, refundUsageV2(id))));
+
+  tokens
+    .command("auto-suspend-idle-budgets-v2")
+    .description("Auto-suspend idle V2 budgets")
+    .action(() => out(true, autoSuspendIdleBudgetsV2()));
+
+  tokens
+    .command("auto-reject-stale-records-v2")
+    .description("Auto-reject stale V2 records")
+    .action(() => out(true, autoRejectStaleRecordsV2()));
 }