@actiondock/cli 2.0.9 → 2.0.11-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/cli",
-  "version": "2.0.9",
+  "version": "2.0.11-beta.0",
   "description": "ActionDock CLI facade for developing, testing, building, and exporting standalone Agent Actions and Skills",
   "type": "module",
   "bin": {
@@ -28,12 +28,12 @@
     "build": "bun build ./src/index.ts --outdir ./dist --target bun"
   },
   "dependencies": {
-    "@actiondock/builder": "^2.0.9",
-    "@actiondock/core": "^2.0.9",
-    "@actiondock/mcp": "^2.0.9",
-    "@actiondock/runtime-cli": "^2.0.9",
-    "@actiondock/runtime-node": "^2.0.9",
-    "@actiondock/sdk": "^2.0.9",
+    "@actiondock/builder": "2.0.11-beta.0",
+    "@actiondock/core": "2.0.11-beta.0",
+    "@actiondock/mcp": "2.0.11-beta.0",
+    "@actiondock/runtime-cli": "2.0.11-beta.0",
+    "@actiondock/runtime-node": "2.0.11-beta.0",
+    "@actiondock/sdk": "2.0.11-beta.0",
     "commander": "^13.1.0",
     "tsx": "^4.19.3"
   },

package/src/commands/action/create.ts

@@ -0,0 +1,129 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import {
+  findProjectRoot,
+  getPackageSlug,
+  loadManifest,
+  loadProjectConfig,
+  saveManifest,
+} from "@actiondock/core";
+import { ExecutionError } from "@actiondock/runtime-cli";
+import type { Command } from "commander";
+
+export function registerActionCreateCommand(actionCmd: Command): void {
+  actionCmd
+    .command("create <id>")
+    .alias("new")
+    .description("Scaffold a new Action definition file")
+    .option("-d, --desc <description>", "Action description")
+    .option("-f, --file <filePath>", "Target file path relative to actions dir")
+    .action(async (id, options) => {
+      const root = findProjectRoot();
+      if (!root) {
+        throw new ExecutionError("Not in an ActionDock project (actiondock.json not found)");
+      }
+      try {
+        const config = loadProjectConfig(root);
+        const actionsDir = resolve(root, config.actionsDir || "actions");
+        if (!existsSync(actionsDir)) {
+          mkdirSync(actionsDir, { recursive: true });
+        }
+
+        const cleanName = getPackageSlug(id);
+        const targetRelFile = options.file || `${cleanName}.ts`;
+        const targetFullFile = resolve(actionsDir, targetRelFile);
+
+        if (existsSync(targetFullFile)) {
+          throw new ExecutionError(`Target action file already exists at ${targetFullFile}`);
+        }
+
+        const desc = options.desc || `Action ${id}`;
+        const template = `import { defineAction } from "@actiondock/sdk";
+
+export interface Input {
+  exampleParam?: string;
+}
+
+export interface Output {
+  success: boolean;
+  result?: unknown;
+}
+
+export default defineAction<Input, Output>({
+  id: "${id}",
+  description: "${desc}",
+
+  inputSchema: {
+    type: "object",
+    properties: {
+      exampleParam: {
+        type: "string",
+        description: "Example parameter description",
+      },
+    },
+    required: [],
+  },
+
+  outputSchema: {
+    type: "object",
+    properties: {
+      success: { type: "boolean" },
+      result: {},
+    },
+    required: ["success"],
+  },
+
+  async run(input, ctx) {
+    ctx.log.info("Running ${id}", input);
+
+    // Access config: ctx.config.get("MY_CONFIG")
+    // Access state:  await ctx.state.get("my_key") / await ctx.state.set("my_key", val)
+    // Call action:   await ctx.actions.invoke(otherAction, input)
+
+    return {
+      success: true,
+      result: input.exampleParam || "done",
+    };
+  },
+});
+`;
+
+        writeFileSync(targetFullFile, template, "utf-8");
+
+        const manifest = loadManifest(root) || { schemaVersion: 1, actions: {}, assets: [] };
+        manifest.actions = manifest.actions || {};
+        manifest.actions[id] = {
+          entry: join(config.actionsDir || "actions", targetRelFile),
+          description: desc,
+          inputSchema: {
+            type: "object",
+            properties: {
+              exampleParam: {
+                type: "string",
+                description: "Example parameter description",
+              },
+            },
+            required: [],
+          },
+          outputSchema: {
+            type: "object",
+            properties: {
+              success: { type: "boolean" },
+              result: {},
+            },
+            required: ["success"],
+          },
+          uses: [],
+          tags: [],
+        };
+        saveManifest(root, manifest);
+
+        console.log(`[OK] Created Action '${id}' at ${targetFullFile}`);
+        console.log(`\nTo run this action:`);
+        console.log(`  ad action run ${id} --input '{"exampleParam": "hello"}'`);
+      } catch (err: any) {
+        if (err instanceof ExecutionError) throw err;
+        throw new ExecutionError(err.message);
+      }
+    });
+}

package/src/commands/action/index.ts

@@ -0,0 +1,27 @@
+import type { Command } from "commander";
+import { registerActionCreateCommand } from "./create";
+import { registerActionListCommand } from "./list";
+import { executeAction, registerActionRunCommand } from "./run";
+import { registerActionShowCommand } from "./show";
+import { registerActionSyncCommand } from "./sync";
+import { registerActionValidateCommand } from "./validate";
+
+export { executeAction };
+
+/**
+ * 注册 Action 相关的 CLI 命令集合（包括 list, describe, run, create, sync, validate 以及顶层 run 别名）。
+ * 
+ * @param program Commander 根程序对象
+ */
+export function registerActionCommands(program: Command): void {
+  const actionCmd = program
+    .command("action")
+    .description("Manage and execute Actions");
+
+  registerActionListCommand(actionCmd);
+  registerActionCreateCommand(actionCmd);
+  registerActionSyncCommand(actionCmd);
+  registerActionShowCommand(actionCmd);
+  registerActionValidateCommand(actionCmd);
+  registerActionRunCommand(actionCmd, program);
+}

package/src/commands/action/list.ts

@@ -0,0 +1,247 @@
+import { existsSync } from "node:fs";
+import {
+  fetchRemoteActions,
+  filterWithFallbackInfo,
+  findProjectRoot,
+  listLinkedPackages,
+  loadManifest,
+  loadProjectConfig,
+  resolvePackageRoot,
+  resolveTarget,
+} from "@actiondock/core";
+import { ArgumentError, ExecutionError, getEffectiveOptions, renderResult } from "@actiondock/runtime-cli";
+import type { Command } from "commander";
+import { resolveIntent } from "../../utils/filter";
+
+export function registerActionListCommand(actionCmd: Command): void {
+  actionCmd
+    .command("list [patterns...]")
+    .description("List actions in current project, linked packages, or remote profile")
+    .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-p, --profile <name>", "Execute or query against a specific profile")
+    .option("-s, --server <url>", "Remote server URL")
+    .option("-t, --token <token>", "Auth token for remote server")
+    .option("--fallback", "Enable fallback to full list when no items match intent")
+    .option("--no-fallback", "Disable fallback to full list when no items match intent")
+    .option("--json", "Output as JSON")
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (patterns, rawOptions, cmd) => {
+      try {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const effectiveIntent = resolveIntent(options.intent, patterns);
+        const isMachine = Boolean(options.json || options.envelope);
+        const fallbackExplicit = options.fallback === true || (Array.isArray(process.argv) && process.argv.includes("--fallback"));
+        const shouldFallback = isMachine ? fallbackExplicit : options.fallback !== false;
+
+        const target = resolveTarget({
+          profile: options.profile,
+          server: options.server,
+          token: options.token,
+        });
+
+        if (target.type === "remote") {
+          let list = await fetchRemoteActions(
+            target.serverUrl!,
+            target.token,
+            effectiveIntent
+          );
+
+          let isFallback = false;
+          if (list.length === 0 && effectiveIntent && shouldFallback) {
+            list = await fetchRemoteActions(target.serverUrl!, target.token);
+            isFallback = true;
+          }
+
+          if (isFallback && isMachine) {
+            renderResult(
+              { items: list, isFallback: true, matchedCount: 0 },
+              { json: options.json, envelope: options.envelope }
+            );
+            return;
+          }
+
+          renderResult(list, {
+            json: options.json,
+            envelope: options.envelope,
+            humanFormatter: () => {
+              const lines = [
+                `Actions on remote server ${target.serverUrl}${target.profileName ? ` (Profile: ${target.profileName})` : ""}:\n`,
+              ];
+              if (isFallback && effectiveIntent) {
+                lines.push(`(No remote actions matched intent '${effectiveIntent}', showing all actions)\n`);
+              }
+              for (const a of list) {
+                lines.push(`  ${a.id.padEnd(28)} ${a.description}`);
+              }
+              return lines.join("\n");
+            },
+          });
+          return;
+        }
+
+        let targetRoot: string | null = null;
+        if (options.package) {
+          targetRoot = resolvePackageRoot(options.package);
+          if (!targetRoot) {
+            throw new ArgumentError(
+              `Package '${options.package}' not found in linked packages or path`
+            );
+          }
+        } else {
+          targetRoot = findProjectRoot();
+        }
+
+        if (targetRoot) {
+          const config = loadProjectConfig(targetRoot);
+          const manifest = loadManifest(targetRoot);
+          const rawList = manifest?.actions
+            ? Object.entries(manifest.actions).map(([actId, a]) => ({
+                id: actId,
+                description: a.description || "",
+                packageId: config.id,
+              }))
+            : [];
+
+          const filterRes = filterWithFallbackInfo(
+            rawList,
+            effectiveIntent,
+            [(a) => a.id, (a) => a.description, (a) => a.packageId],
+            shouldFallback
+          );
+
+          if (filterRes.isFallback && isMachine) {
+            renderResult(
+              { items: filterRes.items, isFallback: true, matchedCount: 0 },
+              { json: options.json, envelope: options.envelope }
+            );
+            return;
+          }
+
+          renderResult(filterRes.items, {
+            json: options.json,
+            envelope: options.envelope,
+            humanFormatter: () => {
+              const lines = [`Actions in ${config.id} (${targetRoot}):\n`];
+              if (filterRes.isFallback && effectiveIntent) {
+                lines.push(`(No actions matched intent '${effectiveIntent}', showing all actions)\n`);
+              }
+              for (const a of filterRes.items) {
+                lines.push(`  ${a.id.padEnd(28)} ${a.description}`);
+              }
+              return lines.join("\n");
+            },
+          });
+          return;
+        }
+
+        // List actions across all linked packages
+        const linkedList = listLinkedPackages();
+        if (linkedList.length === 0) {
+          renderResult([], {
+            json: options.json,
+            envelope: options.envelope,
+            humanFormatter: () =>
+              "No ActionDock project in current directory, and no packages linked.\nRun 'ad link' inside an Action package to register it.",
+          });
+          return;
+        }
+
+        const aggregated: Array<{
+          packageId: string;
+          packageName: string;
+          path: string;
+          actions: Array<{ id: string; description: string }>;
+        }> = [];
+
+        for (const pkg of linkedList) {
+          if (!existsSync(pkg.path)) continue;
+          try {
+            const config = loadProjectConfig(pkg.path);
+            const manifest = loadManifest(pkg.path);
+            const pkgActions = manifest?.actions
+              ? Object.entries(manifest.actions).map(([actId, a]) => ({
+                  id: actId,
+                  description: a.description || "",
+                }))
+              : [];
+
+            aggregated.push({
+              packageId: pkg.id,
+              packageName: pkg.name,
+              path: pkg.path,
+              actions: pkgActions,
+            });
+          } catch {
+            // Ignore broken linked package
+          }
+        }
+
+        let filteredPackages: typeof aggregated = [];
+        let isFallback = false;
+        if (!effectiveIntent) {
+          filteredPackages = aggregated;
+        } else {
+          for (const pkg of aggregated) {
+            const pkgMatches = filterWithFallbackInfo(
+              [pkg],
+              effectiveIntent,
+              [(p) => p.packageId, (p) => p.packageName, (p) => p.path],
+              false
+            ).matchedCount > 0;
+
+            if (pkgMatches) {
+              filteredPackages.push(pkg);
+            } else {
+              const matchedActions = filterWithFallbackInfo(
+                pkg.actions,
+                effectiveIntent,
+                [(a) => a.id, (a) => a.description],
+                false
+              ).items;
+
+              if (matchedActions.length > 0) {
+                filteredPackages.push({
+                  ...pkg,
+                  actions: matchedActions,
+                });
+              }
+            }
+          }
+
+          if (filteredPackages.length === 0 && shouldFallback) {
+            filteredPackages = aggregated;
+            isFallback = true;
+          }
+        }
+
+        if (isFallback && isMachine) {
+          renderResult(
+            { packages: filteredPackages, isFallback: true, matchedCount: 0 },
+            { json: options.json, envelope: options.envelope }
+          );
+          return;
+        }
+
+        renderResult(filteredPackages, {
+          json: options.json,
+          envelope: options.envelope,
+          humanFormatter: () => {
+            const lines = ["Linked Action Packages:\n"];
+            for (const pkg of filteredPackages) {
+              lines.push(`* Package: ${pkg.packageId} (${pkg.path})`);
+              for (const a of pkg.actions) {
+                lines.push(`    - ${a.id.padEnd(26)} ${a.description}`);
+              }
+            }
+            return lines.join("\n");
+          },
+        });
+      } catch (err: any) {
+        if (err instanceof ArgumentError || err instanceof ExecutionError) {
+          throw err;
+        }
+        throw new ExecutionError(err.message);
+      }
+    });
+}

package/src/commands/action/run.ts

@@ -0,0 +1,197 @@
+import { readFileSync } from "node:fs";
+import {
+  ActionRunner,
+  createStorage,
+  executeRemoteAction,
+  loadActions,
+  loadProjectConfig,
+  resolveActionProject,
+  resolvePackageRoot,
+  resolveTarget,
+} from "@actiondock/core";
+import { ArgumentError, ExecutionError, getEffectiveOptions } from "@actiondock/runtime-cli";
+import type { Command } from "commander";
+import { parseDuration } from "../../utils/duration";
+
+export async function executeAction(id: string, options: any): Promise<void> {
+  let input: unknown = {};
+  if (options.input) {
+    try {
+      input = JSON.parse(options.input);
+    } catch (err: any) {
+      throw new ArgumentError(`Error parsing --input JSON: ${err.message}`);
+    }
+  } else if (options.inputFile) {
+    try {
+      input = JSON.parse(readFileSync(options.inputFile, "utf-8"));
+    } catch (err: any) {
+      throw new ArgumentError(`Error reading --input-file: ${err.message}`);
+    }
+  }
+
+  let timeoutMs: number | undefined;
+  if (options.timeout) {
+    try {
+      timeoutMs = parseDuration(options.timeout);
+    } catch (err: any) {
+      throw new ArgumentError(err.message);
+    }
+  }
+
+  const configOverrides: Record<string, unknown> = {};
+  if (options.config) {
+    const list = Array.isArray(options.config) ? options.config : [options.config];
+    for (const item of list) {
+      const [k, ...v] = item.split("=");
+      if (k) configOverrides[k] = v.join("=");
+    }
+  }
+
+  // Check target (remote profile vs local)
+  let target;
+  try {
+    target = resolveTarget({
+      profile: options.profile,
+      server: options.server,
+      token: options.token,
+    });
+  } catch (err: any) {
+    throw new ExecutionError(err.message);
+  }
+
+  const controller = new AbortController();
+  const sigintHandler = () => {
+    controller.abort(new Error("Interrupted by SIGINT"));
+  };
+  process.once("SIGINT", sigintHandler);
+
+  try {
+    if (target.type === "remote") {
+      try {
+        const result = await executeRemoteAction(target.serverUrl!, id, input, {
+          configOverrides,
+          token: target.token,
+          timeoutMs,
+          signal: controller.signal,
+          async: Boolean(options.async),
+        });
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.ok) {
+          process.exitCode = 1;
+        }
+        return;
+      } catch (err: any) {
+        throw new ExecutionError(err.message);
+      }
+    }
+
+    // Local execution
+    if (options.async) {
+      throw new ExecutionError(
+        "Async execution requires a long-running ActionDock server.\nUse --profile, --server, or start `ad serve`."
+      );
+    }
+
+    let actionTarget = id;
+    if (options.package && !id.includes("/") && !id.includes(":")) {
+      const pkgRoot = resolvePackageRoot(options.package);
+      if (!pkgRoot) {
+        throw new ArgumentError(
+          `Package '${options.package}' not found in linked packages or path`
+        );
+      }
+      actionTarget = `${options.package}/${id}`;
+    }
+
+    let resolvedProjectRoot: string;
+    let resolvedActionId: string;
+
+    try {
+      const resolved = await resolveActionProject(actionTarget);
+      resolvedProjectRoot = resolved.projectRoot;
+      resolvedActionId = resolved.actionId;
+    } catch (err: any) {
+      if (err.message?.includes("not found") || err.message?.includes("no longer exists")) {
+        throw new ArgumentError(err.message);
+      }
+      throw new ExecutionError(err.message);
+    }
+
+    try {
+      const config = loadProjectConfig(resolvedProjectRoot);
+      const actions = await loadActions(resolvedProjectRoot, config.actionsDir);
+      const storage = createStorage(config.id, {
+        projectRoot: resolvedProjectRoot,
+        dataDir: options.dataDir,
+      });
+
+      const runner = new ActionRunner({
+        packageId: config.id,
+        storage,
+        projectConfig: config,
+        configOverrides,
+        actions,
+      });
+
+      const result = await runner.execute(resolvedActionId, input, {
+        signal: controller.signal,
+        timeoutMs,
+      });
+
+      console.log(JSON.stringify(result, null, 2));
+      storage.close();
+
+      if (!result.ok) {
+        process.exitCode = 1;
+      }
+    } catch (err: any) {
+      if (err instanceof ArgumentError) throw err;
+      throw new ExecutionError(err.message);
+    }
+  } finally {
+    process.removeListener("SIGINT", sigintHandler);
+  }
+}
+
+export function registerActionRunCommand(actionCmd: Command, program: Command): void {
+  actionCmd
+    .command("run <id>")
+    .description("Execute an action (from current project, linked packages, or remote profile)")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-i, --input <json>", "Input as JSON string")
+    .option("-f, --input-file <path>", "Input from JSON file")
+    .option("-c, --config <key=value...>", "Temporary config override (repeatable or comma-separated)")
+    .option("-p, --profile <name>", "Execute against a specific profile")
+    .option("-s, --server <url>", "Remote server URL")
+    .option("-t, --token <token>", "Auth token for remote server")
+    .option("--timeout <duration>", "Execution timeout (e.g. 30s, 5m, 500ms)")
+    .option("--async", "Execute asynchronously in background (requires remote server or profile)")
+    .option("--data-dir <path>", "Custom database directory")
+    .option("--json", "Output as JSON")
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (id, rawOptions, cmd) => {
+      const options = getEffectiveOptions(rawOptions, cmd);
+      await executeAction(id, options);
+    });
+
+  // Root level alias: ad run <id>
+  program
+    .command("run <id>")
+    .description("Alias for 'ad action run <id>'")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-i, --input <json>", "Input as JSON string")
+    .option("-f, --input-file <path>", "Input from JSON file")
+    .option("-c, --config <key=value...>", "Temporary config override")
+    .option("-p, --profile <name>", "Execute against a specific profile")
+    .option("-s, --server <url>", "Remote server URL")
+    .option("-t, --token <token>", "Auth token for remote server")
+    .option("--timeout <duration>", "Execution timeout (e.g. 30s, 5m, 500ms)")
+    .option("--async", "Execute asynchronously in background (requires remote server or profile)")
+    .option("--data-dir <path>", "Custom database directory")
+    .option("--json", "Output as JSON")
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (id, rawOptions, cmd) => {
+      const options = getEffectiveOptions(rawOptions, cmd);
+      await executeAction(id, options);
+    });
+}