chainlesschain 0.66.0 → 0.132.0

package/src/commands/sso.js

@@ -42,6 +42,33 @@ import {
   listIdentityMappings,
   checkIdentityConflict,
   getStats,
+  PROVIDER_MATURITY_V2 as PMV2,
+  LOGIN_LIFECYCLE_V2 as LLV2,
+  registerProviderV2,
+  activateProviderV2,
+  deprecateProviderV2,
+  retireProviderV2,
+  touchProviderV2,
+  getProviderV2,
+  listProvidersV2,
+  createLoginV2,
+  startLoginV2,
+  completeLoginV2,
+  failLoginV2,
+  cancelLoginV2,
+  getLoginV2,
+  listLoginsV2,
+  autoDeprecateIdleProvidersV2,
+  autoFailStuckLoginsV2,
+  getSsoManagerStatsV2,
+  setMaxActiveProvidersPerOwnerV2,
+  setMaxPendingLoginsPerProviderV2,
+  setProviderIdleMsV2,
+  setLoginStuckMsV2,
+  getMaxActiveProvidersPerOwnerV2,
+  getMaxPendingLoginsPerProviderV2,
+  getProviderIdleMsV2,
+  getLoginStuckMsV2,
 } from "../lib/sso-manager.js";
 
 function _dbFromCtx(cmd) {
@@ -76,7 +103,8 @@ export function registerSsoCommand(program) {
     .description(
       "SSO enterprise authentication — SAML / OAuth2 / OIDC (Phase 14)",
     )
-    .hook("preAction", async (thisCommand) => {
+    .hook("preAction", async (thisCommand, actionCommand) => {
+      if (actionCommand && actionCommand.name().endsWith("-v2")) return;
       const db = await _prepare(thisCommand);
       thisCommand._db = db;
     });
@@ -795,4 +823,161 @@ export function registerSsoCommand(program) {
         await shutdown();
       }
     });
+
+  // ===== V2 Commands (cli 0.130.0) =====
+  const _v2json = (o) => console.log(JSON.stringify(o, null, 2));
+  sso
+    .command("provider-maturities-v2")
+    .description("List V2 provider maturity states")
+    .action(() => Object.values(PMV2).forEach((s) => console.log(s)));
+  sso
+    .command("login-lifecycles-v2")
+    .description("List V2 login lifecycle states")
+    .action(() => Object.values(LLV2).forEach((s) => console.log(s)));
+  sso
+    .command("stats-v2")
+    .description("V2 stats")
+    .action(() => _v2json(getSsoManagerStatsV2()));
+  sso
+    .command("config-v2")
+    .description("V2 config")
+    .action(() => {
+      console.log(
+        `maxActiveProvidersPerOwner: ${getMaxActiveProvidersPerOwnerV2()}`,
+      );
+      console.log(
+        `maxPendingLoginsPerProvider: ${getMaxPendingLoginsPerProviderV2()}`,
+      );
+      console.log(`providerIdleMs: ${getProviderIdleMsV2()}`);
+      console.log(`loginStuckMs: ${getLoginStuckMsV2()}`);
+    });
+  sso
+    .command("set-max-active-providers-v2 <n>")
+    .description("Set V2 active provider cap")
+    .action((n) => {
+      setMaxActiveProvidersPerOwnerV2(Number(n));
+      console.log("ok");
+    });
+  sso
+    .command("set-max-pending-logins-v2 <n>")
+    .description("Set V2 pending login cap")
+    .action((n) => {
+      setMaxPendingLoginsPerProviderV2(Number(n));
+      console.log("ok");
+    });
+  sso
+    .command("set-provider-idle-ms-v2 <n>")
+    .description("Set V2 provider idle ms")
+    .action((n) => {
+      setProviderIdleMsV2(Number(n));
+      console.log("ok");
+    });
+  sso
+    .command("set-login-stuck-ms-v2 <n>")
+    .description("Set V2 login stuck ms")
+    .action((n) => {
+      setLoginStuckMsV2(Number(n));
+      console.log("ok");
+    });
+  sso
+    .command("register-provider-v2 <id>")
+    .description("V2 register provider")
+    .requiredOption("-o, --owner <o>")
+    .requiredOption("-p, --protocol <p>")
+    .option("-d, --display-name <n>")
+    .action((id, opts) =>
+      _v2json(
+        registerProviderV2({
+          id,
+          owner: opts.owner,
+          protocol: opts.protocol,
+          displayName: opts.displayName,
+        }),
+      ),
+    );
+  sso
+    .command("activate-provider-v2 <id>")
+    .description("V2 activate provider")
+    .action((id) => _v2json(activateProviderV2(id)));
+  sso
+    .command("deprecate-provider-v2 <id>")
+    .description("V2 deprecate provider")
+    .action((id) => _v2json(deprecateProviderV2(id)));
+  sso
+    .command("retire-provider-v2 <id>")
+    .description("V2 retire provider")
+    .action((id) => _v2json(retireProviderV2(id)));
+  sso
+    .command("touch-provider-v2 <id>")
+    .description("V2 touch provider")
+    .action((id) => _v2json(touchProviderV2(id)));
+  sso
+    .command("get-provider-v2 <id>")
+    .description("V2 get provider")
+    .action((id) => _v2json(getProviderV2(id)));
+  sso
+    .command("list-providers-v2")
+    .description("V2 list providers")
+    .option("-o, --owner <o>")
+    .option("-s, --status <s>")
+    .option("-p, --protocol <p>")
+    .action((opts) => _v2json(listProvidersV2(opts)));
+  sso
+    .command("create-login-v2 <id>")
+    .description("V2 create login")
+    .requiredOption("-p, --provider-id <p>")
+    .option("-s, --subject <s>")
+    .action((id, opts) =>
+      _v2json(
+        createLoginV2({
+          id,
+          providerId: opts.providerId,
+          subject: opts.subject,
+        }),
+      ),
+    );
+  sso
+    .command("start-login-v2 <id>")
+    .description("V2 start login")
+    .action((id) => _v2json(startLoginV2(id)));
+  sso
+    .command("complete-login-v2 <id>")
+    .description("V2 complete login")
+    .action((id) => _v2json(completeLoginV2(id)));
+  sso
+    .command("fail-login-v2 <id>")
+    .description("V2 fail login")
+    .option("-e, --error <e>")
+    .action((id, opts) => _v2json(failLoginV2(id, opts.error)));
+  sso
+    .command("cancel-login-v2 <id>")
+    .description("V2 cancel login")
+    .action((id) => _v2json(cancelLoginV2(id)));
+  sso
+    .command("get-login-v2 <id>")
+    .description("V2 get login")
+    .action((id) => _v2json(getLoginV2(id)));
+  sso
+    .command("list-logins-v2")
+    .description("V2 list logins")
+    .option("-p, --provider-id <p>")
+    .option("-s, --status <s>")
+    .option("-S, --subject <s>")
+    .action((opts) =>
+      _v2json(
+        listLoginsV2({
+          providerId: opts.providerId,
+          status: opts.status,
+          subject: opts.subject,
+        }),
+      ),
+    );
+  sso
+    .command("auto-deprecate-idle-providers-v2")
+    .description("V2 auto-deprecate idle")
+    .action(() => _v2json(autoDeprecateIdleProvidersV2()));
+  sso
+    .command("auto-fail-stuck-logins-v2")
+    .description("V2 auto-fail stuck")
+    .action(() => _v2json(autoFailStuckLoginsV2()));
 }

package/src/commands/stress.js

@@ -15,6 +15,22 @@ import {
   analyzeBottlenecks,
   generateCapacityPlan,
   listLoadLevels,
+  // V2
+  RUN_STATUS_V2,
+  LEVEL_NAME_V2,
+  BOTTLENECK_KIND_V2,
+  BOTTLENECK_SEVERITY_V2,
+  STRESS_DEFAULT_MAX_CONCURRENT,
+  setMaxConcurrentTests,
+  getMaxConcurrentTests,
+  getActiveTestCount,
+  startStressTestV2,
+  completeStressTest,
+  stopStressTestV2,
+  failStressTest,
+  setRunStatus,
+  recommendLevelV2,
+  getStressStatsV2,
 } from "../lib/stress-tester.js";
 
 function _dbFromCtx(ctx) {
@@ -249,4 +265,218 @@ export function registerStressCommand(program) {
         }
       }
     });
+
+  // ---------- V2 (Phase 59) ----------
+  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();
+      ensureStressTables(db);
+      return await fn(db);
+    } finally {
+      await shutdown();
+    }
+  };
+
+  stress
+    .command("run-statuses")
+    .description("List RUN_STATUS_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(RUN_STATUS_V2), null, 2));
+    });
+
+  stress
+    .command("level-names")
+    .description("List LEVEL_NAME_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(LEVEL_NAME_V2), null, 2));
+    });
+
+  stress
+    .command("bottleneck-kinds")
+    .description("List BOTTLENECK_KIND_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(BOTTLENECK_KIND_V2), null, 2));
+    });
+
+  stress
+    .command("bottleneck-severities")
+    .description("List BOTTLENECK_SEVERITY_V2 values")
+    .action(() => {
+      console.log(
+        JSON.stringify(Object.values(BOTTLENECK_SEVERITY_V2), null, 2),
+      );
+    });
+
+  stress
+    .command("default-max-concurrent")
+    .description("Show STRESS_DEFAULT_MAX_CONCURRENT")
+    .action(() => {
+      console.log(STRESS_DEFAULT_MAX_CONCURRENT);
+    });
+
+  stress
+    .command("max-concurrent")
+    .description("Show current max concurrent test limit")
+    .action(() => {
+      console.log(getMaxConcurrentTests());
+    });
+
+  stress
+    .command("active-test-count")
+    .description("Show current active (RUNNING) test count")
+    .action(() => {
+      console.log(getActiveTestCount());
+    });
+
+  stress
+    .command("set-max-concurrent <n>")
+    .description("Set max concurrent test admission limit")
+    .action((n) => {
+      try {
+        const v = setMaxConcurrentTests(Number(n));
+        logger.success(`maxConcurrentTests=${v}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("start-v2")
+    .description("Start a V2 stress run (RUNNING, no metrics until complete)")
+    .option(
+      "-l, --level <level>",
+      "Load level (light|medium|heavy|extreme)",
+      "medium",
+    )
+    .option("-c, --concurrency <n>", "Override concurrency", parseInt)
+    .option("-r, --rps <n>", "Override requests per second", parseInt)
+    .option("-d, --duration <ms>", "Override duration in ms", parseInt)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        await withDb((db) => {
+          const run = startStressTestV2(db, {
+            level: options.level,
+            concurrency: options.concurrency,
+            requestsPerSecond: options.rps,
+            duration: options.duration,
+          });
+          if (options.json) {
+            console.log(JSON.stringify(run, null, 2));
+          } else {
+            logger.success(
+              `Started ${run.testId.slice(0, 8)} [${run.loadLevel}] → ${run.status}`,
+            );
+          }
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("complete <test-id>")
+    .description("Complete a RUNNING run and compute metrics")
+    .option("--json", "Output as JSON")
+    .action(async (testId, options) => {
+      try {
+        await withDb((db) => {
+          const r = completeStressTest(db, testId);
+          if (options.json) {
+            console.log(JSON.stringify(r, null, 2));
+          } else {
+            logger.success(
+              `${r.testId.slice(0, 8)} → ${r.status} (tps=${r.result.tps})`,
+            );
+          }
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("stop-v2 <test-id>")
+    .description("Stop a RUNNING run (→ STOPPED)")
+    .action(async (testId) => {
+      try {
+        await withDb((db) => {
+          const r = stopStressTestV2(db, testId);
+          logger.success(`${r.testId.slice(0, 8)} → ${r.status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("fail <test-id> <error-message>")
+    .description("Fail a RUNNING run with an error message (→ FAILED)")
+    .action(async (testId, errorMessage) => {
+      try {
+        await withDb((db) => {
+          const r = failStressTest(db, testId, errorMessage);
+          logger.success(
+            `${r.testId.slice(0, 8)} → ${r.status} (${r.errorMessage})`,
+          );
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("set-status <test-id> <status>")
+    .description("Transition run to a given status (state-machine guarded)")
+    .option("--error-message <msg>", "Attach error message (for failed)")
+    .action(async (testId, status, options) => {
+      try {
+        await withDb((db) => {
+          const patch = {};
+          if (options.errorMessage) patch.errorMessage = options.errorMessage;
+          const r = setRunStatus(db, testId, status, patch);
+          logger.success(`${r.testId.slice(0, 8)} → ${r.status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("recommend-level <target-rps>")
+    .description("Recommend the largest built-in level ≤ targetRps")
+    .option("--json", "Output as JSON")
+    .action((targetRps, options) => {
+      try {
+        const level = recommendLevelV2(Number(targetRps));
+        if (options.json) {
+          console.log(JSON.stringify(level, null, 2));
+        } else {
+          logger.log(
+            `  ${chalk.cyan(level.name)}  concurrency=${level.concurrency} rps=${level.requestsPerSecond} duration=${level.duration}ms`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("stats-v2")
+    .description("Show aggregate V2 stats (byStatus/byLevel/bottlenecks)")
+    .action(() => {
+      console.log(JSON.stringify(getStressStatsV2(), null, 2));
+    });
 }

package/src/commands/sync.js

@@ -16,6 +16,35 @@ import {
   clearSyncData,
   registerResource,
   getAllSyncStates,
+  RESOURCE_MATURITY_V2,
+  SYNC_RUN_V2,
+  getMaxActiveResourcesPerOwnerV2,
+  setMaxActiveResourcesPerOwnerV2,
+  getMaxRunningRunsPerResourceV2,
+  setMaxRunningRunsPerResourceV2,
+  getResourceIdleMsV2,
+  setResourceIdleMsV2,
+  getRunStuckMsV2,
+  setRunStuckMsV2,
+  getActiveResourceCountV2,
+  getRunningRunCountV2,
+  registerResourceV2,
+  getResourceV2,
+  listResourcesV2,
+  activateResourceV2,
+  pauseResourceV2,
+  archiveResourceV2,
+  touchResourceV2,
+  createSyncRunV2,
+  getSyncRunV2,
+  listSyncRunsV2,
+  startSyncRunV2,
+  succeedSyncRunV2,
+  failSyncRunV2,
+  cancelSyncRunV2,
+  autoArchiveIdleResourcesV2,
+  autoFailStuckSyncRunsV2,
+  getSyncManagerStatsV2,
 } from "../lib/sync-manager.js";
 
 export function registerSyncCommand(program) {
@@ -246,4 +275,231 @@ export function registerSyncCommand(program) {
         process.exit(1);
       }
     });
+
+  // ─────────────────────────────────────────────────────────────
+  // V2 Surface — resource + sync-run lifecycle (in-memory, throwing API)
+  // ─────────────────────────────────────────────────────────────
+
+  sync
+    .command("resource-maturities-v2")
+    .description("List V2 resource maturity states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const v = Object.values(RESOURCE_MATURITY_V2);
+      if (options.json) console.log(JSON.stringify(v));
+      else logger.log(v.join(", "));
+    });
+
+  sync
+    .command("run-lifecycles-v2")
+    .description("List V2 sync-run lifecycle states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const v = Object.values(SYNC_RUN_V2);
+      if (options.json) console.log(JSON.stringify(v));
+      else logger.log(v.join(", "));
+    });
+
+  sync
+    .command("stats-v2")
+    .description("Show V2 sync stats")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const stats = getSyncManagerStatsV2();
+      if (options.json) console.log(JSON.stringify(stats, null, 2));
+      else logger.log(JSON.stringify(stats, null, 2));
+    });
+
+  sync
+    .command("get-max-active-resources-v2")
+    .description("Get max active resources per owner")
+    .action(() => logger.log(String(getMaxActiveResourcesPerOwnerV2())));
+  sync
+    .command("set-max-active-resources-v2 <n>")
+    .description("Set max active resources per owner")
+    .action((n) => {
+      setMaxActiveResourcesPerOwnerV2(Number(n));
+      logger.log(String(getMaxActiveResourcesPerOwnerV2()));
+    });
+  sync
+    .command("get-max-running-runs-v2")
+    .description("Get max running runs per resource")
+    .action(() => logger.log(String(getMaxRunningRunsPerResourceV2())));
+  sync
+    .command("set-max-running-runs-v2 <n>")
+    .description("Set max running runs per resource")
+    .action((n) => {
+      setMaxRunningRunsPerResourceV2(Number(n));
+      logger.log(String(getMaxRunningRunsPerResourceV2()));
+    });
+  sync
+    .command("get-resource-idle-ms-v2")
+    .description("Get resource idle ms")
+    .action(() => logger.log(String(getResourceIdleMsV2())));
+  sync
+    .command("set-resource-idle-ms-v2 <ms>")
+    .description("Set resource idle ms")
+    .action((ms) => {
+      setResourceIdleMsV2(Number(ms));
+      logger.log(String(getResourceIdleMsV2()));
+    });
+  sync
+    .command("get-run-stuck-ms-v2")
+    .description("Get run stuck ms")
+    .action(() => logger.log(String(getRunStuckMsV2())));
+  sync
+    .command("set-run-stuck-ms-v2 <ms>")
+    .description("Set run stuck ms")
+    .action((ms) => {
+      setRunStuckMsV2(Number(ms));
+      logger.log(String(getRunStuckMsV2()));
+    });
+
+  sync
+    .command("active-resource-count-v2 <owner>")
+    .description("Count active resources for owner")
+    .action((owner) => logger.log(String(getActiveResourceCountV2(owner))));
+  sync
+    .command("running-run-count-v2 <resourceId>")
+    .description("Count running runs for resource")
+    .action((resourceId) =>
+      logger.log(String(getRunningRunCountV2(resourceId))),
+    );
+
+  sync
+    .command("register-resource-v2 <id>")
+    .description("Register V2 resource (initial=pending)")
+    .requiredOption("-o, --owner <owner>", "owner")
+    .requiredOption("-k, --kind <kind>", "kind (file/note/...)")
+    .option("-m, --metadata <json>", "metadata JSON", "{}")
+    .action((id, opts) => {
+      const meta = JSON.parse(opts.metadata);
+      const r = registerResourceV2(id, {
+        owner: opts.owner,
+        kind: opts.kind,
+        metadata: meta,
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  sync
+    .command("get-resource-v2 <id>")
+    .description("Get V2 resource by id")
+    .action((id) => {
+      const r = getResourceV2(id);
+      if (!r) {
+        logger.error(`resource ${id} not found`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  sync
+    .command("list-resources-v2")
+    .description("List V2 resources")
+    .option("-o, --owner <owner>", "filter by owner")
+    .option("-k, --kind <kind>", "filter by kind")
+    .option("-s, --status <state>", "filter by status")
+    .action((opts) => {
+      const out = listResourcesV2({
+        owner: opts.owner,
+        kind: opts.kind,
+        status: opts.status,
+      });
+      console.log(JSON.stringify(out, null, 2));
+    });
+
+  sync
+    .command("activate-resource-v2 <id>")
+    .description("Transition resource → active")
+    .action((id) =>
+      console.log(JSON.stringify(activateResourceV2(id), null, 2)),
+    );
+  sync
+    .command("pause-resource-v2 <id>")
+    .description("Transition resource → paused")
+    .action((id) => console.log(JSON.stringify(pauseResourceV2(id), null, 2)));
+  sync
+    .command("archive-resource-v2 <id>")
+    .description("Transition resource → archived (terminal)")
+    .action((id) =>
+      console.log(JSON.stringify(archiveResourceV2(id), null, 2)),
+    );
+  sync
+    .command("touch-resource-v2 <id>")
+    .description("Update resource lastSeenAt")
+    .action((id) => console.log(JSON.stringify(touchResourceV2(id), null, 2)));
+
+  sync
+    .command("create-sync-run-v2 <id>")
+    .description("Create V2 sync run (initial=queued)")
+    .requiredOption("-r, --resource <id>", "resource id")
+    .option("-k, --kind <kind>", "run kind", "push")
+    .option("-m, --metadata <json>", "metadata JSON", "{}")
+    .action((id, opts) => {
+      const meta = JSON.parse(opts.metadata);
+      const j = createSyncRunV2(id, {
+        resourceId: opts.resource,
+        kind: opts.kind,
+        metadata: meta,
+      });
+      console.log(JSON.stringify(j, null, 2));
+    });
+
+  sync
+    .command("get-sync-run-v2 <id>")
+    .description("Get V2 sync run by id")
+    .action((id) => {
+      const j = getSyncRunV2(id);
+      if (!j) {
+        logger.error(`syncRun ${id} not found`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(j, null, 2));
+    });
+
+  sync
+    .command("list-sync-runs-v2")
+    .description("List V2 sync runs")
+    .option("-r, --resource <id>", "filter by resource")
+    .option("-s, --status <state>", "filter by status")
+    .action((opts) => {
+      const out = listSyncRunsV2({
+        resourceId: opts.resource,
+        status: opts.status,
+      });
+      console.log(JSON.stringify(out, null, 2));
+    });
+
+  sync
+    .command("start-sync-run-v2 <id>")
+    .description("Transition sync run → running")
+    .action((id) => console.log(JSON.stringify(startSyncRunV2(id), null, 2)));
+  sync
+    .command("succeed-sync-run-v2 <id>")
+    .description("Transition sync run → succeeded (terminal)")
+    .action((id) => console.log(JSON.stringify(succeedSyncRunV2(id), null, 2)));
+  sync
+    .command("fail-sync-run-v2 <id>")
+    .description("Transition sync run → failed (terminal)")
+    .action((id) => console.log(JSON.stringify(failSyncRunV2(id), null, 2)));
+  sync
+    .command("cancel-sync-run-v2 <id>")
+    .description("Transition sync run → cancelled (terminal)")
+    .action((id) => console.log(JSON.stringify(cancelSyncRunV2(id), null, 2)));
+
+  sync
+    .command("auto-archive-idle-v2")
+    .description("Auto-archive idle resources; output flipped")
+    .action(() => {
+      const flipped = autoArchiveIdleResourcesV2();
+      console.log(JSON.stringify(flipped, null, 2));
+    });
+  sync
+    .command("auto-fail-stuck-runs-v2")
+    .description("Auto-fail stuck running syncs; output flipped")
+    .action(() => {
+      const flipped = autoFailStuckSyncRunsV2();
+      console.log(JSON.stringify(flipped, null, 2));
+    });
 }