chainlesschain 0.51.0 → 0.81.0

package/src/commands/inference.js

@@ -9,6 +9,11 @@ import {
   TASK_STATUS,
   PRIVACY_MODE,
   DEFAULT_CONFIG,
+  NODE_STATUS_V2,
+  TASK_STATUS_V2,
+  PRIVACY_MODE_V2,
+  INFERENCE_DEFAULT_MAX_CONCURRENT_TASKS_PER_NODE,
+  INFERENCE_DEFAULT_HEARTBEAT_TIMEOUT_MS,
   ensureInferenceTables,
   registerNode,
   unregisterNode,
@@ -22,6 +27,20 @@ import {
   getTask,
   listTasks,
   getSchedulerStats,
+  setMaxConcurrentTasksPerNode,
+  getMaxConcurrentTasksPerNode,
+  setHeartbeatTimeoutMs,
+  getHeartbeatTimeoutMs,
+  getActiveTasksPerNode,
+  submitTaskV2,
+  dispatchTaskV2,
+  startTask,
+  completeTaskV2,
+  failTaskV2,
+  setTaskStatus,
+  autoMarkOfflineNodes,
+  findEligibleNodes,
+  getInferenceStatsV2,
 } from "../lib/inference-network.js";
 
 function _dbFromCtx(cmd) {
@@ -300,5 +319,304 @@ export function registerInferenceCommand(program) {
       if (t.avgDurationMs > 0) console.log(`Avg latency: ${t.avgDurationMs}ms`);
     });
 
+  /* ──────────────────────────────────────────────────
+   *  V2 — Phase 67 surface
+   * ────────────────────────────────────────────────── */
+
+  inf
+    .command("node-statuses-v2")
+    .description("List V2 node statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(NODE_STATUS_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      for (const s of v) console.log(`  ${s}`);
+    });
+
+  inf
+    .command("task-statuses-v2")
+    .description("List V2 task statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(TASK_STATUS_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      for (const s of v) console.log(`  ${s}`);
+    });
+
+  inf
+    .command("privacy-modes-v2")
+    .description("List V2 privacy modes")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(PRIVACY_MODE_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      for (const m of v) console.log(`  ${m}`);
+    });
+
+  inf
+    .command("default-max-concurrent-tasks")
+    .description("Show default per-node concurrent task cap")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = INFERENCE_DEFAULT_MAX_CONCURRENT_TASKS_PER_NODE;
+      if (opts.json)
+        return console.log(JSON.stringify({ default: v }, null, 2));
+      console.log(v);
+    });
+
+  inf
+    .command("max-concurrent-tasks")
+    .description("Show current per-node concurrent task cap")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = getMaxConcurrentTasksPerNode();
+      if (opts.json) return console.log(JSON.stringify({ max: v }, null, 2));
+      console.log(v);
+    });
+
+  inf
+    .command("set-max-concurrent-tasks <n>")
+    .description("Set per-node concurrent task cap")
+    .option("--json", "JSON output")
+    .action((n, opts) => {
+      try {
+        setMaxConcurrentTasksPerNode(Number(n));
+        const v = getMaxConcurrentTasksPerNode();
+        if (opts.json) return console.log(JSON.stringify({ max: v }, null, 2));
+        console.log(`Max concurrent tasks per node: ${v}`);
+      } catch (e) {
+        if (opts.json)
+          return console.log(JSON.stringify({ error: e.message }, null, 2));
+        console.error(`Error: ${e.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  inf
+    .command("active-task-count <node-id>")
+    .description("Show current active tasks for a node")
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const v = getActiveTasksPerNode(nodeId);
+      if (opts.json)
+        return console.log(JSON.stringify({ nodeId, active: v }, null, 2));
+      console.log(v);
+    });
+
+  inf
+    .command("heartbeat-timeout")
+    .description("Show current heartbeat timeout (ms)")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = getHeartbeatTimeoutMs();
+      if (opts.json)
+        return console.log(JSON.stringify({ timeoutMs: v }, null, 2));
+      console.log(v);
+    });
+
+  inf
+    .command("set-heartbeat-timeout <ms>")
+    .description("Set heartbeat timeout (ms)")
+    .option("--json", "JSON output")
+    .action((ms, opts) => {
+      try {
+        setHeartbeatTimeoutMs(Number(ms));
+        const v = getHeartbeatTimeoutMs();
+        if (opts.json)
+          return console.log(JSON.stringify({ timeoutMs: v }, null, 2));
+        console.log(`Heartbeat timeout: ${v}ms`);
+      } catch (e) {
+        if (opts.json)
+          return console.log(JSON.stringify({ error: e.message }, null, 2));
+        console.error(`Error: ${e.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  inf
+    .command("submit-v2 <model>")
+    .description("Submit task (V2, creates queued no assignment)")
+    .option("-i, --input <text>", "Input data")
+    .option("-p, --priority <n>", "Priority (1-10)", parseInt)
+    .option("-m, --mode <mode>", "Privacy mode")
+    .option("--json", "JSON output")
+    .action((model, opts) => {
+      const db = _dbFromCtx(inf);
+      try {
+        const t = submitTaskV2(db, {
+          model,
+          input: opts.input,
+          privacyMode: opts.mode,
+          priority: opts.priority,
+        });
+        if (opts.json) return console.log(JSON.stringify(t, null, 2));
+        console.log(`Task submitted: ${t.id}`);
+        console.log(`Status: ${t.status}`);
+      } catch (e) {
+        if (opts.json)
+          return console.log(JSON.stringify({ error: e.message }, null, 2));
+        console.error(`Error: ${e.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  inf
+    .command("dispatch-v2 <task-id>")
+    .description("Dispatch queued task to online node")
+    .option("-n, --node <id>", "Specific node id (else least-loaded)")
+    .option("--json", "JSON output")
+    .action((taskId, opts) => {
+      const db = _dbFromCtx(inf);
+      try {
+        const t = dispatchTaskV2(db, taskId, { nodeId: opts.node });
+        if (opts.json) return console.log(JSON.stringify(t, null, 2));
+        console.log(`Dispatched ${t.id} → ${t.assigned_node}`);
+      } catch (e) {
+        if (opts.json)
+          return console.log(JSON.stringify({ error: e.message }, null, 2));
+        console.error(`Error: ${e.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  inf
+    .command("start-task <task-id>")
+    .description("Start dispatched task (dispatched → running)")
+    .option("--json", "JSON output")
+    .action((taskId, opts) => {
+      const db = _dbFromCtx(inf);
+      try {
+        const t = startTask(db, taskId);
+        if (opts.json) return console.log(JSON.stringify(t, null, 2));
+        console.log(`Task started at ${t.started_at}`);
+      } catch (e) {
+        if (opts.json)
+          return console.log(JSON.stringify({ error: e.message }, null, 2));
+        console.error(`Error: ${e.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  inf
+    .command("complete-v2 <task-id>")
+    .description("Complete running task (running → complete)")
+    .option("-o, --output <text>", "Task output")
+    .option("-d, --duration <ms>", "Duration in ms", parseInt)
+    .option("--json", "JSON output")
+    .action((taskId, opts) => {
+      const db = _dbFromCtx(inf);
+      try {
+        const t = completeTaskV2(db, taskId, {
+          output: opts.output,
+          durationMs: opts.duration,
+        });
+        if (opts.json) return console.log(JSON.stringify(t, null, 2));
+        console.log(`Completed ${t.id} (${t.duration_ms}ms)`);
+      } catch (e) {
+        if (opts.json)
+          return console.log(JSON.stringify({ error: e.message }, null, 2));
+        console.error(`Error: ${e.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  inf
+    .command("fail-v2 <task-id>")
+    .description("Fail task (any non-terminal → failed)")
+    .option("-e, --error <text>", "Error message")
+    .option("--json", "JSON output")
+    .action((taskId, opts) => {
+      const db = _dbFromCtx(inf);
+      try {
+        const t = failTaskV2(db, taskId, { error: opts.error });
+        if (opts.json) return console.log(JSON.stringify(t, null, 2));
+        console.log(`Failed ${t.id}: ${t.error_message || ""}`);
+      } catch (e) {
+        if (opts.json)
+          return console.log(JSON.stringify({ error: e.message }, null, 2));
+        console.error(`Error: ${e.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  inf
+    .command("set-task-status <task-id> <status>")
+    .description("Generic state-machine-guarded task status setter")
+    .option("-o, --output <text>", "Patch: output")
+    .option("-d, --duration <ms>", "Patch: durationMs", parseInt)
+    .option("-e, --error <text>", "Patch: errorMessage")
+    .option("--json", "JSON output")
+    .action((taskId, status, opts) => {
+      const db = _dbFromCtx(inf);
+      const patch = {};
+      if (opts.output !== undefined) patch.output = opts.output;
+      if (opts.duration !== undefined) patch.durationMs = opts.duration;
+      if (opts.error !== undefined) patch.errorMessage = opts.error;
+      try {
+        const t = setTaskStatus(db, taskId, status, patch);
+        if (opts.json) return console.log(JSON.stringify(t, null, 2));
+        console.log(`Task ${t.id} → ${t.status}`);
+      } catch (e) {
+        if (opts.json)
+          return console.log(JSON.stringify({ error: e.message }, null, 2));
+        console.error(`Error: ${e.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  inf
+    .command("auto-offline")
+    .description("Mark nodes with stale heartbeat as offline")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(inf);
+      const offlined = autoMarkOfflineNodes(db);
+      if (opts.json) return console.log(JSON.stringify(offlined, null, 2));
+      if (offlined.length === 0) return console.log("No stale nodes.");
+      for (const n of offlined)
+        console.log(`  ${n.node_id.padEnd(20)} → offline`);
+    });
+
+  inf
+    .command("eligible-nodes")
+    .description("List online, under-cap nodes matching capability")
+    .option("-c, --capability <cap>", "Required capability")
+    .option("-m, --mode <mode>", "Privacy mode (reserved)")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const nodes = findEligibleNodes({
+        capability: opts.capability,
+        privacyMode: opts.mode,
+      });
+      if (opts.json) return console.log(JSON.stringify(nodes, null, 2));
+      if (nodes.length === 0) return console.log("No eligible nodes.");
+      for (const n of nodes)
+        console.log(
+          `  ${n.node_id.padEnd(20)} load=${getActiveTasksPerNode(n.id)}  ${n.id.slice(0, 8)}`,
+        );
+    });
+
+  inf
+    .command("stats-v2")
+    .description("V2 inference statistics (all-enum-key zero init)")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const s = getInferenceStatsV2();
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      console.log(`Nodes: ${s.totalNodes}  Tasks: ${s.totalTasks}`);
+      console.log(`Max concurrent/node: ${s.maxConcurrentTasksPerNode}`);
+      console.log(`Heartbeat timeout:   ${s.heartbeatTimeoutMs}ms`);
+      console.log(`Avg duration:        ${s.avgDurationMs}ms`);
+      console.log("Nodes by status:");
+      for (const [k, v] of Object.entries(s.nodesByStatus))
+        console.log(`  ${k.padEnd(12)} ${v}`);
+      console.log("Tasks by status:");
+      for (const [k, v] of Object.entries(s.tasksByStatus))
+        console.log(`  ${k.padEnd(12)} ${v}`);
+      console.log("Tasks by privacy:");
+      for (const [k, v] of Object.entries(s.tasksByPrivacyMode))
+        console.log(`  ${k.padEnd(12)} ${v}`);
+    });
+
   program.addCommand(inf);
 }

package/src/commands/lowcode.js

@@ -20,7 +20,22 @@ import {
   exportApp,
   listApps,
   deployApp,
+  // Phase 93 V2 surface
+  COMPONENT_CATEGORY,
+  DATASOURCE_TYPE,
+  APP_STATUS,
+  listComponentsV2,
+  registerDataSourceV2,
+  testDataSourceConnection,
+  updateAppStatus,
+  archiveApp,
+  getStatusHistory,
+  cloneApp,
+  exportAppJSON,
+  importAppJSON,
+  getLowcodeStatsV2,
 } from "../lib/app-builder.js";
+import fs from "fs";
 
 export function registerLowcodeCommand(program) {
   const lowcode = program
@@ -305,6 +320,347 @@ export function registerLowcodeCommand(program) {
       }
     });
 
+  // ─── Phase 93 V2 subcommands ────────────────────────────────
+
+  // lowcode categories
+  lowcode
+    .command("categories")
+    .description("List component categories (V2)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const categories = Object.values(COMPONENT_CATEGORY);
+      if (options.json) {
+        console.log(JSON.stringify(categories, null, 2));
+      } else {
+        logger.log(chalk.bold("Component Categories:"));
+        for (const c of categories) logger.log(`  ${chalk.cyan(c)}`);
+      }
+    });
+
+  // lowcode datasource-types
+  lowcode
+    .command("datasource-types")
+    .description("List supported data source types (V2)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const types = Object.values(DATASOURCE_TYPE);
+      if (options.json) {
+        console.log(JSON.stringify(types, null, 2));
+      } else {
+        logger.log(chalk.bold("Data Source Types:"));
+        for (const t of types) logger.log(`  ${chalk.cyan(t)}`);
+      }
+    });
+
+  // lowcode statuses
+  lowcode
+    .command("statuses")
+    .description("List canonical app statuses (V2)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const statuses = Object.values(APP_STATUS);
+      if (options.json) {
+        console.log(JSON.stringify(statuses, null, 2));
+      } else {
+        logger.log(chalk.bold("App Statuses:"));
+        for (const s of statuses) logger.log(`  ${chalk.cyan(s)}`);
+      }
+    });
+
+  // lowcode components-v2
+  lowcode
+    .command("components-v2")
+    .description("List built-in components with category filter (V2)")
+    .option("-c, --category <cat>", "Filter by category")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      try {
+        const list = listComponentsV2(
+          options.category ? { category: options.category } : {},
+        );
+        if (options.json) {
+          console.log(JSON.stringify(list, null, 2));
+        } else {
+          logger.log(chalk.bold(`Components (${list.length}):`));
+          for (const c of list) {
+            logger.log(
+              `  ${chalk.cyan(c.name)} [${c.category}] props: ${c.props.join(", ")}`,
+            );
+          }
+        }
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode datasource-v2 <app-id> <name> <type>
+  lowcode
+    .command("datasource-v2")
+    .description("Register a validated data source (V2)")
+    .argument("<app-id>", "Application ID")
+    .argument("<name>", "Data source name")
+    .argument("<type>", "Type: rest|graphql|database|csv")
+    .option("--config <json>", "Config as JSON string", "{}")
+    .action(async (appId, name, type, options) => {
+      const spinner = ora("Registering data source...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        let config;
+        try {
+          config = JSON.parse(options.config);
+        } catch (_err) {
+          config = {};
+        }
+
+        const result = registerDataSourceV2(db, {
+          appId,
+          name,
+          type,
+          config,
+        });
+        spinner.succeed(
+          `Data source "${chalk.cyan(name)}" registered (${type})`,
+        );
+        logger.log(`  ID: ${chalk.gray(result.id)}`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode test-connection <datasource-id>
+  lowcode
+    .command("test-connection")
+    .description("Heuristic connection check for a data source (V2)")
+    .argument("<datasource-id>", "Data source ID")
+    .option("--json", "Output as JSON")
+    .action((dsId, options) => {
+      const result = testDataSourceConnection(dsId);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        const icon = result.ok ? chalk.green("✓") : chalk.red("✗");
+        logger.log(
+          `${icon} ${chalk.cyan(dsId)} (${result.type || "?"}): ${result.reason}`,
+        );
+      }
+    });
+
+  // lowcode set-status <app-id> <status>
+  lowcode
+    .command("set-status")
+    .description("Update app status with validated transition (V2)")
+    .argument("<app-id>", "Application ID")
+    .argument("<status>", "New status: draft|published|archived")
+    .action(async (appId, status) => {
+      const spinner = ora(`Transitioning to ${status}...`).start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const result = updateAppStatus(db, { appId, status });
+        spinner.succeed(
+          `${chalk.cyan(appId)}: ${result.previous} → ${chalk.bold(result.status)}`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode archive <app-id>
+  lowcode
+    .command("archive")
+    .description("Archive an application (V2)")
+    .argument("<app-id>", "Application ID")
+    .action(async (appId) => {
+      const spinner = ora("Archiving...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        archiveApp(db, appId);
+        spinner.succeed(`${chalk.cyan(appId)} archived`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode status-history <app-id>
+  lowcode
+    .command("status-history")
+    .description("Show status transition history for an app (V2)")
+    .argument("<app-id>", "Application ID")
+    .option("--json", "Output as JSON")
+    .action((appId, options) => {
+      const hist = getStatusHistory(appId);
+      if (options.json) {
+        console.log(JSON.stringify(hist, null, 2));
+      } else if (hist.length === 0) {
+        logger.info("No status transitions recorded");
+      } else {
+        logger.log(chalk.bold(`Status History (${hist.length}):`));
+        for (const h of hist) {
+          logger.log(`  ${chalk.gray(h.at)}  ${h.from} → ${chalk.cyan(h.to)}`);
+        }
+      }
+    });
+
+  // lowcode clone <source-id>
+  lowcode
+    .command("clone")
+    .description("Clone an application (V2)")
+    .argument("<source-id>", "Source app ID")
+    .option("--name <name>", "New name for the clone")
+    .action(async (sourceId, options) => {
+      const spinner = ora("Cloning...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const result = cloneApp(db, {
+          sourceId,
+          newName: options.name,
+        });
+        spinner.succeed(`Cloned ${chalk.cyan(sourceId)} → ${result.clonedId}`);
+        logger.log(`  Name: ${result.name}`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode export-json <app-id>
+  lowcode
+    .command("export-json")
+    .description("Export an app as canonical JSON (V2)")
+    .argument("<app-id>", "Application ID")
+    .option("-o, --output <file>", "Write to file instead of stdout")
+    .action(async (appId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const result = exportAppJSON(db, appId);
+        const json = JSON.stringify(result, null, 2);
+        if (options.output) {
+          fs.writeFileSync(options.output, json, "utf-8");
+          logger.log(chalk.green(`Wrote ${options.output}`));
+        } else {
+          console.log(json);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode import-json <file>
+  lowcode
+    .command("import-json")
+    .description("Import an app from a canonical JSON file (V2)")
+    .argument("<file>", "Path to JSON export")
+    .action(async (file) => {
+      const spinner = ora("Importing...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const raw = fs.readFileSync(file, "utf-8");
+        const json = JSON.parse(raw);
+        const result = importAppJSON(db, json);
+        spinner.succeed(
+          `Imported "${chalk.cyan(result.name)}" → ${result.importedId}`,
+        );
+        logger.log(`  Data sources: ${result.dataSources}`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode stats-v2
+  lowcode
+    .command("stats-v2")
+    .description("Low-code platform statistics (V2)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const stats = getLowcodeStatsV2(db);
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          logger.log(chalk.bold("Low-Code Stats (V2):"));
+          logger.log(`  Total apps:    ${chalk.cyan(stats.totalApps)}`);
+          logger.log(`  By status:     ${JSON.stringify(stats.byStatus)}`);
+          logger.log(`  By platform:   ${JSON.stringify(stats.byPlatform)}`);
+          logger.log(
+            `  Data sources:  ${stats.dataSources.total} (${JSON.stringify(stats.dataSources.byType)})`,
+          );
+          logger.log(`  Components:    ${stats.componentsAvailable}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
   // lowcode deploy <app-id>
   lowcode
     .command("deploy")