@actiondock/cli 2.0.0

package/src/commands/profile.ts

@@ -0,0 +1,263 @@
+import {
+  addProfile,
+  checkRemoteHealth,
+  filterWithFallbackInfo,
+  getProfile,
+  listProfiles,
+  loadProfiles,
+  maskSecretValue,
+  removeProfile,
+  resolveProfileToken,
+  resolveTarget,
+  toSnakeUpperCase,
+  useProfile,
+} from "@actiondock/core";
+import { Command } from "commander";
+import { resolveIntent } from "../utils/filter";
+
+export function registerProfileCommands(program: Command): void {
+  const profileCmd = program
+    .command("profile")
+    .description("Manage multi-cloud and remote execution profiles");
+
+  // ac profile list
+  profileCmd
+    .command("list [patterns...]")
+    .description("List all configured profiles")
+    .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+    .option("--reveal, --show-secrets", "Reveal plain text values for tokens")
+    .option("--no-fallback", "Disable fallback to full list when no items match intent")
+    .option("--json", "Output as JSON")
+    .action((patterns, options) => {
+      try {
+        const effectiveIntent = resolveIntent(options.intent, patterns);
+        const shouldFallback = options.fallback !== false;
+        const reveal = Boolean(options.reveal || options.showSecrets);
+
+        const list = listProfiles();
+        const enriched = list.map((p) => {
+          const resolved = resolveProfileToken(p.name, p.entry);
+          return {
+            name: p.name,
+            isCurrent: p.isCurrent,
+            serverUrl: p.entry.serverUrl,
+            description: p.entry.description || "",
+            tokenEnv: p.entry.tokenEnv,
+            tokenConfigured: resolved.source !== "none",
+            tokenSource: resolved.source,
+            token: reveal ? resolved.token : (resolved.token ? maskSecretValue(resolved.token) : undefined),
+          };
+        });
+
+        const filterRes = filterWithFallbackInfo(
+          enriched,
+          effectiveIntent,
+          [(p) => p.name, (p) => p.serverUrl, (p) => p.description, (p) => p.tokenSource],
+          shouldFallback
+        );
+
+        if (options.json) {
+          console.log(JSON.stringify(filterRes.items, null, 2));
+        } else {
+          console.log("ActionDock Execution Profiles:\n");
+          if (filterRes.isFallback && effectiveIntent) {
+            console.log(`(No profiles matched intent '${effectiveIntent}', showing all profiles)\n`);
+          }
+          for (const item of filterRes.items) {
+            const currentMarker = item.isCurrent ? "* " : "  ";
+            let tokenInfo = "";
+            if (item.tokenSource === "tokenEnv") {
+              tokenInfo = ` [token: env(${item.tokenEnv})]`;
+            } else if (item.tokenSource === "profileEnv") {
+              tokenInfo = ` [token: env(ACTIONDOCK_${toSnakeUpperCase(item.name)}_TOKEN)]`;
+            } else if (item.tokenSource === "profile") {
+              tokenInfo = ` [token: stored in profile]`;
+            } else if (item.tokenSource === "globalEnv") {
+              tokenInfo = ` [token: env(ACTIONDOCK_TOKEN)]`;
+            }
+
+            if (reveal && item.token) {
+              tokenInfo += ` = ${item.token}`;
+            }
+
+            const desc = item.description ? ` - ${item.description}` : "";
+            console.log(
+              `${currentMarker}${item.name.padEnd(20)} ${item.serverUrl}${tokenInfo}${desc}`
+            );
+          }
+          console.log(
+            "\nUse 'ac profile use <name>' to switch or 'ac run <action> --profile <name>' to execute on a specific target."
+          );
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ac profile add <name>
+  profileCmd
+    .command("add <name>")
+    .description("Add or update a remote execution profile")
+    .requiredOption("-s, --server <url>", "Remote ActionDock server URL (e.g. http://1.2.3.4:5177)")
+    .option("-t, --token <token>", "Authentication token for the remote server (deprecated; prefer --token-env)")
+    .option("--token-env <env>", "Environment variable name containing the authentication token")
+    .option("-d, --desc <description>", "Description of this profile/machine")
+    .action((name, options) => {
+      try {
+        if (options.token) {
+          console.warn(
+            "Warning: storing tokens directly in profiles.json is deprecated. Use --token-env or standard environment variables (e.g. ACTIONDOCK_<PROFILE>_TOKEN) instead."
+          );
+        }
+        addProfile(name, {
+          serverUrl: options.server,
+          token: options.token,
+          tokenEnv: options.tokenEnv,
+          description: options.desc,
+        });
+        console.log(`[OK] Profile '${name}' configured for server: ${options.server}`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ac profile use <name>
+  profileCmd
+    .command("use <name>")
+    .description("Switch active default profile")
+    .action((name) => {
+      try {
+        useProfile(name);
+        console.log(`[OK] Active profile switched to '${name}'`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ac profile show [name]
+  profileCmd
+    .command("show [name]")
+    .description("Display details of a profile (defaults to active profile)")
+    .option("--reveal, --show-secrets", "Reveal plain text values for tokens")
+    .option("--json", "Output as JSON")
+    .action((name, options) => {
+      try {
+        const config = loadProfiles();
+        const targetName = name || config.currentProfile || "local";
+        const entry = getProfile(targetName);
+        const reveal = Boolean(options.reveal || options.showSecrets);
+
+        if (!entry && targetName !== "local") {
+          console.error(`Error: Profile '${targetName}' not found.`);
+          process.exit(1);
+        }
+
+        const resolved = resolveProfileToken(targetName, entry);
+        const displayToken = reveal
+          ? resolved.token
+          : (resolved.token ? maskSecretValue(resolved.token) : undefined);
+
+        const data = {
+          name: targetName,
+          isCurrent: config.currentProfile === targetName,
+          serverUrl: entry?.serverUrl || "local",
+          tokenConfigured: resolved.source !== "none",
+          tokenSource: resolved.source,
+          tokenEnv: entry?.tokenEnv,
+          token: displayToken,
+          description: entry?.description || "",
+        };
+
+        if (options.json) {
+          console.log(JSON.stringify(data, null, 2));
+        } else {
+          console.log(`Profile:      ${data.name}${data.isCurrent ? " (Active)" : ""}`);
+          console.log(`Server URL:   ${data.serverUrl}`);
+          let sourceDetail = "None";
+          if (data.tokenSource === "tokenEnv") {
+            sourceDetail = `Environment Variable ($${data.tokenEnv})`;
+          } else if (data.tokenSource === "profileEnv") {
+            sourceDetail = `Profile Environment Variable ($ACTIONDOCK_${toSnakeUpperCase(data.name)}_TOKEN)`;
+          } else if (data.tokenSource === "profile") {
+            sourceDetail = "Stored in profiles.json (Deprecated)";
+          } else if (data.tokenSource === "globalEnv") {
+            sourceDetail = "Global Environment Variable ($ACTIONDOCK_TOKEN)";
+          }
+          console.log(`Auth Source:  ${sourceDetail}`);
+          if (data.tokenConfigured) {
+            console.log(`Token Value:  ${data.token}`);
+          }
+          if (data.description) {
+            console.log(`Description:  ${data.description}`);
+          }
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ac profile rm / remove <name>
+  profileCmd
+    .command("rm <name>")
+    .alias("remove")
+    .description("Remove a profile")
+    .action((name) => {
+      try {
+        if (name === "local") {
+          console.error("Error: Cannot remove built-in 'local' profile");
+          process.exit(1);
+        }
+        const removed = removeProfile(name);
+        if (!removed) {
+          console.error(`Error: Profile '${name}' not found`);
+          process.exit(1);
+        }
+        console.log(`[OK] Profile '${name}' removed`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ac profile test [name]
+  profileCmd
+    .command("test [name]")
+    .description("Test connection latency and health of a profile")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const target = resolveTarget({ profile: name });
+        if (target.type === "local") {
+          if (options.json) {
+            console.log(JSON.stringify({ ok: true, type: "local", message: "Local execution" }, null, 2));
+          } else {
+            console.log(`Target profile '${target.profileName || "local"}' is local (runs in local Bun runtime).`);
+          }
+          return;
+        }
+
+        const health = await checkRemoteHealth(target.serverUrl!, target.token);
+        if (options.json) {
+          console.log(JSON.stringify(health, null, 2));
+        } else {
+          if (health.ok) {
+            console.log(
+              `[OK] Connected to ${target.serverUrl} (${health.latencyMs}ms) - Version: ${health.version}, Status: ${health.status}`
+            );
+          } else {
+            console.error(
+              `[FAIL] Connection to ${target.serverUrl} failed (${health.latencyMs}ms): ${health.error}`
+            );
+            process.exit(1);
+          }
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/runs.ts

@@ -0,0 +1,319 @@
+import { existsSync } from "node:fs";
+import {
+  cancelRemoteRun,
+  createStorage,
+  fetchRemoteRun,
+  filterWithFallbackInfo,
+  findProjectRoot,
+  listLinkedPackages,
+  loadProjectConfig,
+  resolvePackageRoot,
+  resolveTarget,
+} from "@actiondock/core";
+import { Command } from "commander";
+import { resolveIntent } from "../utils/filter";
+
+function printRunRecord(run: any): void {
+  console.log(`Run:          ${run.id}`);
+  console.log(`Action:       ${run.actionId}`);
+  if (run.packageId) console.log(`Package:      ${run.packageId}`);
+  console.log(`Status:       ${run.status}`);
+  if (run.parentRunId) console.log(`Parent Run:   ${run.parentRunId}`);
+  console.log(`Started:      ${run.startedAt}`);
+  if (run.finishedAt) console.log(`Finished:     ${run.finishedAt}`);
+
+  console.log("\nInput:");
+  console.log(JSON.stringify(run.input, null, 2));
+
+  if (run.output !== undefined) {
+    console.log("\nOutput:");
+    console.log(JSON.stringify(run.output, null, 2));
+  }
+
+  if (run.error) {
+    console.log("\nError:");
+    console.log(JSON.stringify(run.error, null, 2));
+  }
+}
+
+export function registerRunsCommands(program: Command): void {
+  const runsCmd = program
+    .command("runs")
+    .description("Inspect action execution history");
+
+  // runs list
+  runsCmd
+    .command("list [patterns...]")
+    .description("List recent execution records (in current project or linked packages)")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+    .option("-a, --action <actionId>", "Filter by action ID")
+    .option("-n, --limit <count>", "Maximum number of records to return", "20")
+    .option("--no-fallback", "Disable fallback to full list when no items match intent")
+    .option("--json", "Output as JSON")
+    .action((patterns, options) => {
+      try {
+        const effectiveIntent = resolveIntent(options.intent, patterns);
+        const shouldFallback = options.fallback !== false;
+        const limit = Number.parseInt(options.limit, 10) || 20;
+
+        const targetRoot = options.package
+          ? resolvePackageRoot(options.package)
+          : findProjectRoot();
+
+        if (options.package && !targetRoot) {
+          console.error(`Error: Package '${options.package}' not found in linked packages or path`);
+          process.exit(1);
+        }
+
+        if (targetRoot) {
+          const projConfig = loadProjectConfig(targetRoot);
+          const storage = createStorage(projConfig.id, { projectRoot: targetRoot });
+          const records = storage.listRuns({
+            actionId: options.action,
+            limit,
+          });
+          storage.close();
+
+          const filterRes = filterWithFallbackInfo(
+            records,
+            effectiveIntent,
+            [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.error?.message],
+            shouldFallback
+          );
+
+          if (options.json) {
+            console.log(JSON.stringify(filterRes.items, null, 2));
+          } else {
+            console.log(`Execution Runs in ${projConfig.id} (${filterRes.items.length}):\n`);
+            if (filterRes.isFallback && effectiveIntent) {
+              console.log(`(No runs matched intent '${effectiveIntent}', showing all runs)\n`);
+            }
+            console.log(
+              `  ${"RUN ID".padEnd(38)} ${"ACTION".padEnd(24)} ${"STATUS".padEnd(10)} ${"STARTED"}`
+            );
+            console.log("  " + "-".repeat(90));
+            for (const r of filterRes.items) {
+              const time = r.startedAt.replace("T", " ").slice(0, 19);
+              console.log(
+                `  ${r.id.padEnd(38)} ${r.actionId.padEnd(24)} ${r.status.padEnd(10)} ${time}`
+              );
+            }
+          }
+          return;
+        }
+
+        // Outside project: List recent runs across all linked packages
+        const linkedList = listLinkedPackages();
+        if (linkedList.length === 0) {
+          console.log("No ActionDock project in current directory, and no packages linked.");
+          console.log("Run 'ac link' inside an Action package to register it.");
+          return;
+        }
+
+        let allRecords: any[] = [];
+        for (const pkg of linkedList) {
+          if (!existsSync(pkg.path)) continue;
+          try {
+            const projConfig = loadProjectConfig(pkg.path);
+            const storage = createStorage(projConfig.id, { projectRoot: pkg.path });
+            const records = storage.listRuns({
+              actionId: options.action,
+              limit,
+            });
+            storage.close();
+            for (const r of records) {
+              allRecords.push({ ...r, packageId: projConfig.id });
+            }
+          } catch {
+            // Ignore broken linked package
+          }
+        }
+
+        // Sort by startedAt desc
+        allRecords.sort((a, b) => (b.startedAt > a.startedAt ? 1 : b.startedAt < a.startedAt ? -1 : 0));
+        allRecords = allRecords.slice(0, limit);
+
+        const filterRes = filterWithFallbackInfo(
+          allRecords,
+          effectiveIntent,
+          [(r) => r.id, (r) => r.actionId, (r) => r.packageId, (r) => r.status, (r) => r.error?.message],
+          shouldFallback
+        );
+
+        if (options.json) {
+          console.log(JSON.stringify(filterRes.items, null, 2));
+        } else {
+          console.log(`Execution Runs across Linked Packages (${filterRes.items.length}):\n`);
+          if (filterRes.isFallback && effectiveIntent) {
+            console.log(`(No runs matched intent '${effectiveIntent}', showing all runs)\n`);
+          }
+          console.log(
+            `  ${"RUN ID".padEnd(38)} ${"PACKAGE".padEnd(20)} ${"ACTION".padEnd(22)} ${"STATUS".padEnd(10)} ${"STARTED"}`
+          );
+          console.log("  " + "-".repeat(110));
+          for (const r of filterRes.items) {
+            const time = r.startedAt.replace("T", " ").slice(0, 19);
+            console.log(
+              `  ${r.id.padEnd(38)} ${(r.packageId || "").padEnd(20)} ${r.actionId.padEnd(22)} ${r.status.padEnd(10)} ${time}`
+            );
+          }
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // runs show
+  runsCmd
+    .command("show <id>")
+    .description("Show details of a specific execution run (searches current project or linked packages)")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-p, --profile <name>", "Query run against a specific profile")
+    .option("-s, --server <url>", "Remote server URL")
+    .option("-t, --token <token>", "Auth token for remote server")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      let target;
+      try {
+        target = resolveTarget({
+          profile: options.profile,
+          server: options.server,
+          token: options.token,
+        });
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+
+      if (target.type === "remote") {
+        try {
+          const run = await fetchRemoteRun(target.serverUrl!, id, target.token);
+          if (options.json) {
+            console.log(JSON.stringify(run, null, 2));
+          } else {
+            printRunRecord(run);
+          }
+          return;
+        } catch (err: any) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
+      }
+
+      // Local show
+      try {
+        let foundRun: any = null;
+
+        if (options.package) {
+          const targetRoot = resolvePackageRoot(options.package);
+          if (!targetRoot) {
+            console.error(`Error: Package '${options.package}' not found in linked packages or path`);
+            process.exit(1);
+          }
+          const projConfig = loadProjectConfig(targetRoot);
+          const storage = createStorage(projConfig.id, { projectRoot: targetRoot });
+          foundRun = storage.getRun(id);
+          storage.close();
+          if (foundRun && !foundRun.packageId) {
+            foundRun.packageId = projConfig.id;
+          }
+        } else {
+          // 1. Try current project root if exists
+          const currentRoot = findProjectRoot();
+          if (currentRoot) {
+            try {
+              const projConfig = loadProjectConfig(currentRoot);
+              const storage = createStorage(projConfig.id, { projectRoot: currentRoot });
+              foundRun = storage.getRun(id);
+              storage.close();
+              if (foundRun && !foundRun.packageId) {
+                foundRun.packageId = projConfig.id;
+              }
+            } catch {}
+          }
+
+          // 2. If not found in current project, search across all linked packages
+          if (!foundRun) {
+            const linkedList = listLinkedPackages();
+            for (const pkg of linkedList) {
+              if (!existsSync(pkg.path)) continue;
+              try {
+                const projConfig = loadProjectConfig(pkg.path);
+                const storage = createStorage(projConfig.id, { projectRoot: pkg.path });
+                const r = storage.getRun(id);
+                storage.close();
+                if (r) {
+                  foundRun = { ...r, packageId: projConfig.id };
+                  break;
+                }
+              } catch {}
+            }
+          }
+        }
+
+        if (!foundRun) {
+          console.error(`Error: Run record '${id}' not found in current project or any linked packages`);
+          process.exit(1);
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify(foundRun, null, 2));
+        } else {
+          printRunRecord(foundRun);
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // runs cancel
+  runsCmd
+    .command("cancel <id>")
+    .description("Cancel a running action execution on a remote server")
+    .option("-p, --profile <name>", "Execute cancel against a specific profile")
+    .option("-s, --server <url>", "Remote server URL")
+    .option("-t, --token <token>", "Auth token for remote server")
+    .option("-r, --reason <reason>", "Reason for cancellation")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      let target;
+      try {
+        target = resolveTarget({
+          profile: options.profile,
+          server: options.server,
+          token: options.token,
+        });
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+
+      if (target.type === "local") {
+        console.error(
+          "Error: 'ac runs cancel' is only supported for remote execution targets. Use --profile <name> or --server <url>."
+        );
+        process.exit(1);
+      }
+
+      try {
+        const result = await cancelRemoteRun(
+          target.serverUrl!,
+          id,
+          target.token,
+          options.reason
+        );
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Run '${id}' cancellation requested (Status: ${result.status}).`);
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}
+

package/src/commands/serve.ts

@@ -0,0 +1,101 @@
+import { resolve } from "node:path";
+import { findProjectRoot, loadProjectConfig, startActionDockServer } from "@actiondock/core";
+import { Command } from "commander";
+import { parseByteSize } from "../utils/bytes";
+
+export function registerServeCommand(program: Command): void {
+  program
+    .command("serve")
+    .description("Start the ActionDock lightweight HTTP Runner server for remote execution")
+    .option("-p, --port <port>", "Port to listen on (default: 5177)", "5177")
+    .option("-H, --host <host>", "Host address to bind to (default: 127.0.0.1)", "127.0.0.1")
+    .option("-t, --token <token>", "Authentication token for securing the endpoint (or set ACTIONDOCK_TOKEN)")
+    .option("--allow-insecure-no-auth", "Allow non-loopback host binding without authentication token (INSECURE)")
+    .option(
+      "--cors-origin <origin>",
+      "Allowed CORS origin (can be specified multiple times)",
+      (val: string, prev: string[] = []) => [...prev, val],
+      []
+    )
+    .option("--max-body <size>", "Maximum allowed JSON request body size (e.g. 1mb, 500kb)", "1mb")
+    .option("--expose-debug-info", "Expose project root path in health and info responses")
+    .option("-d, --dir <path>", "Project root directory (default: current working directory)")
+    .action(async (options) => {
+      const port = parseInt(options.port, 10) || 5177;
+      const host = options.host || "127.0.0.1";
+      const token = options.token || process.env.ACTIONDOCK_TOKEN;
+      const allowInsecureNoAuth = Boolean(options.allowInsecureNoAuth);
+      const corsOrigins = options.corsOrigin && options.corsOrigin.length > 0 ? options.corsOrigin : undefined;
+      const exposeDebugInfo = Boolean(options.exposeDebugInfo);
+
+      let maxBodyBytes: number | undefined;
+      if (options.maxBody) {
+        try {
+          maxBodyBytes = parseByteSize(options.maxBody);
+        } catch (err: any) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
+      }
+
+      const projectRoot = options.dir
+        ? resolve(options.dir)
+        : findProjectRoot(process.cwd());
+
+      let projectName = "Global Registry Mode";
+      let packageId = "none";
+
+      if (projectRoot) {
+        try {
+          const config = loadProjectConfig(projectRoot);
+          projectName = `${config.name} (${config.id})`;
+          packageId = config.id;
+        } catch {
+          // fallback
+        }
+      }
+
+      try {
+        const server = startActionDockServer({
+          port,
+          host,
+          token,
+          allowInsecureNoAuth,
+          corsOrigins,
+          maxBodyBytes,
+          exposeDebugInfo,
+          projectRoot: projectRoot || undefined,
+        });
+
+        console.log(`\n======================================================`);
+        console.log(`  ActionDock 2.0 HTTP Runner Server`);
+        console.log(`======================================================`);
+        console.log(`  * Listening on:    http://${host}:${server.port}`);
+        console.log(`  * Project:         ${projectName}`);
+        if (projectRoot && exposeDebugInfo) {
+          console.log(`  * Root Path:       ${projectRoot}`);
+        }
+        console.log(`  * Authentication:  ${token ? "Bearer Token / Query Token Enabled" : "Disabled (Public/Local)"}`);
+        console.log(`  * CORS Origins:    ${corsOrigins ? corsOrigins.join(", ") : "Disabled (Default)"}`);
+        console.log(`  * Max Body Size:   ${options.maxBody || "1mb"}`);
+        console.log(`  * Health Endpoint: http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${server.port}/api/v1/health`);
+        console.log(`======================================================\n`);
+        console.log(`Server is ready to accept remote 'ac run' requests.`);
+        console.log(`Press Ctrl+C to terminate.\n`);
+
+        // Keep process running
+        process.on("SIGINT", () => {
+          console.log("\nStopping ActionDock server...");
+          server.stop();
+          process.exit(0);
+        });
+        process.on("SIGTERM", () => {
+          server.stop();
+          process.exit(0);
+        });
+      } catch (err: any) {
+        console.error(`Failed to start ActionDock server: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}