@actiondock/cli 2.0.1 → 2.0.3

package/src/commands/info.ts

@@ -191,16 +191,6 @@ export function registerInfoCommand(program: Command): void {
     .option("--json", "Output information as JSON")
     .action(async (patterns: string[] = [], options: any) => {
       try {
-        if (options.tree) {
-          const status = getRegistryStatus();
-          if (options.json) {
-            console.log(JSON.stringify(status, null, 2));
-          } else {
-            printRegistryTree(status);
-          }
-          return;
-        }
-
         const effectiveIntent = resolveIntent(options.intent, patterns);
         const shouldFallback = options.fallback !== false;
 
@@ -214,121 +204,110 @@ export function registerInfoCommand(program: Command): void {
         if (target.type === "remote") {
           const remoteInfo = await fetchRemoteInfo(
             target.serverUrl!,
-            target.token
+            target.token,
+            {
+              intent: effectiveIntent,
+              package: options.package,
+              tree: Boolean(options.tree),
+            }
           );
 
           if (options.json) {
-            if (Array.isArray(remoteInfo.linkedPackages) && effectiveIntent) {
-              const filterRes = filterWithFallbackInfo(
-                remoteInfo.linkedPackages,
-                effectiveIntent,
-                [
-                  (p: any) => p.id,
-                  (p: any) => p.name,
-                  (p: any) => p.description,
-                  (p: any) => p.path,
-                  (p: any) => p.actions,
-                  (p: any) => p.playbooks,
-                ],
-                shouldFallback
-              );
-              console.log(
-                JSON.stringify(
-                  {
-                    ...remoteInfo,
-                    linkedPackages: filterRes.items,
-                    isFallback: filterRes.isFallback,
-                  },
-                  null,
-                  2
-                )
-              );
-            } else {
-              console.log(JSON.stringify(remoteInfo, null, 2));
+            console.log(JSON.stringify(remoteInfo, null, 2));
+            return;
+          }
+
+          console.log(
+            `Remote ActionDock Server: ${target.serverUrl}${target.profileName ? ` (Profile: ${target.profileName})` : ""}\n`
+          );
+
+          // Remote Tree
+          if (remoteInfo.type === "tree" || (options.tree && remoteInfo.workspaces)) {
+            printRegistryTree(remoteInfo);
+            return;
+          }
+
+          // Remote Package Detail
+          if (remoteInfo.type === "package_detail" || (remoteInfo.id && !remoteInfo.packages)) {
+            console.log(`ActionDock Project: ${remoteInfo.name || remoteInfo.id} (${remoteInfo.id})`);
+            console.log(`Version:     ${remoteInfo.version || "unknown"}`);
+            if (remoteInfo.description) console.log(`Description: ${remoteInfo.description}`);
+            if (remoteInfo.path || remoteInfo.projectRoot) {
+              console.log(`Root:        ${remoteInfo.path || remoteInfo.projectRoot}`);
             }
-          } else {
-            console.log(
-              `Remote ActionDock Server: ${target.serverUrl}${target.profileName ? ` (Profile: ${target.profileName})` : ""}`
-            );
-            if (remoteInfo.id) {
-              if (effectiveIntent) {
-                const match = filterWithFallbackInfo(
-                  [remoteInfo],
-                  effectiveIntent,
-                  [
-                    (r: any) => r.id,
-                    (r: any) => r.name,
-                    (r: any) => r.description,
-                    (r: any) => r.actions,
-                    (r: any) => r.playbooks,
-                  ],
-                  shouldFallback
-                );
-                if (match.matchedCount === 0 && !shouldFallback) {
-                  console.error(
-                    `Error: Remote project '${remoteInfo.id}' did not match intent '${effectiveIntent}'`
-                  );
-                  process.exit(1);
-                }
-              }
-              console.log(
-                `Project:     ${remoteInfo.name || remoteInfo.id} (${remoteInfo.id})`
-              );
-              console.log(`Version:     ${remoteInfo.version || "unknown"}`);
-              if (remoteInfo.description) {
-                console.log(`Description: ${remoteInfo.description}`);
-              }
-              if (Array.isArray(remoteInfo.actions)) {
-                console.log(`\nActions (${remoteInfo.actions.length}):`);
-                for (const actId of remoteInfo.actions) {
-                  console.log(`  - ${actId}`);
-                }
-              }
-              if (Array.isArray(remoteInfo.playbooks)) {
-                console.log(`\nPlaybooks (${remoteInfo.playbooks.length}):`);
-                for (const pbId of remoteInfo.playbooks) {
-                  console.log(`  - ${pbId}`);
-                }
+
+            const actions = remoteInfo.actionsDetail || remoteInfo.actions || [];
+            console.log(`\nActions (${remoteInfo.actionsCount || actions.length}):`);
+            for (const act of actions) {
+              if (typeof act === "string") {
+                console.log(`  - ${act}`);
+              } else {
+                console.log(`  - ${(act.id || "").padEnd(28)} ${act.description || ""}`);
               }
-            } else if (Array.isArray(remoteInfo.linkedPackages)) {
-              let list = remoteInfo.linkedPackages;
-              let isFallback = false;
-              if (effectiveIntent) {
-                const filterRes = filterWithFallbackInfo(
-                  list,
-                  effectiveIntent,
-                  [
-                    (p: any) => p.id,
-                    (p: any) => p.name,
-                    (p: any) => p.description,
-                    (p: any) => p.path,
-                    (p: any) => p.actions,
-                    (p: any) => p.playbooks,
-                  ],
-                  shouldFallback
-                );
-                if (filterRes.matchedCount === 0 && !shouldFallback) {
-                  console.error(
-                    `Error: No remote packages matched intent '${effectiveIntent}'`
-                  );
-                  process.exit(1);
-                }
-                list = filterRes.items;
-                isFallback = filterRes.isFallback;
+            }
+
+            const playbooks = remoteInfo.playbooksDetail || remoteInfo.playbooks || [];
+            console.log(`\nPlaybooks (${remoteInfo.playbooksCount || playbooks.length}):`);
+            for (const pb of playbooks) {
+              if (typeof pb === "string") {
+                console.log(`  - ${pb}`);
+              } else {
+                console.log(`  - ${(pb.id || "").padEnd(28)} ${pb.description || ""}`);
               }
-              console.log(`Version:     ${remoteInfo.version || "2.0.0"}`);
-              if (isFallback && effectiveIntent) {
+            }
+
+            const declared = remoteInfo.configDeclared || {};
+            const declaredKeys = Object.keys(declared);
+            if (declaredKeys.length > 0) {
+              console.log(`\nDeclared Config Keys:`);
+              for (const k of declaredKeys) {
+                const item = declared[k];
+                const isSec = item?.secret ? " [secret]" : "";
+                const def =
+                  item?.default !== undefined
+                    ? ` (default: ${JSON.stringify(item.default)})`
+                    : "";
                 console.log(
-                  `\n(No remote packages matched intent '${effectiveIntent}', showing all linked packages)`
+                  `  - ${k.padEnd(24)} ${item?.description || ""}${def}${isSec}`
                 );
               }
-              console.log(`\nLinked Packages (${list.length}):`);
-              for (const pkg of list) {
-                console.log(`  - ${pkg.id} (${pkg.path})`);
-              }
-            } else {
-              console.log(JSON.stringify(remoteInfo, null, 2));
             }
+            return;
+          }
+
+          // Remote Package List
+          const packages = remoteInfo.packages || remoteInfo.linkedPackages || [];
+          if (Array.isArray(packages)) {
+            console.log(`Remote ActionDock Packages (${packages.length}):\n`);
+            for (const p of packages) {
+              console.log(`* ${p.name || p.id} (${p.id}) v${p.version || "unknown"}`);
+              if (p.path) console.log(`  Path:      ${p.path}`);
+              if (p.description) console.log(`  Desc:      ${p.description}`);
+              const actNames = Array.isArray(p.actions)
+                ? p.actions.map((a: any) => (typeof a === "string" ? a : a.id)).join(", ")
+                : "";
+              const pbNames = Array.isArray(p.playbooks)
+                ? p.playbooks.map((pb: any) => (typeof pb === "string" ? pb : pb.id)).join(", ")
+                : "";
+              console.log(`  Actions (${p.actionsCount || (p.actions ? p.actions.length : 0)}):   ${actNames || "(none)"}`);
+              console.log(`  Playbooks (${p.playbooksCount || (p.playbooks ? p.playbooks.length : 0)}): ${pbNames || "(none)"}`);
+              console.log("");
+            }
+            console.log("Tip: Run 'ad info <package-id> --server <url>' to view detailed package configuration and schema.");
+            return;
+          }
+
+          console.log(JSON.stringify(remoteInfo, null, 2));
+          return;
+        }
+
+        // Local Tree
+        if (options.tree) {
+          const status = getRegistryStatus();
+          if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+          } else {
+            printRegistryTree(status);
           }
           return;
         }

package/src/commands/playbook.ts

@@ -1,13 +1,18 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import {
+  fetchRemotePlaybooks,
+  fetchRemotePlaybookShow,
   filterWithFallbackInfo,
   findProjectRoot,
   listLinkedPackages,
   loadActions,
+  loadManifest,
   loadPlaybooks,
   loadProjectConfig,
+  resolveActionProject,
   resolvePlaybookProject,
+  resolveTarget,
 } from "@actiondock/core";
 import type { PlaybookDefinition } from "@actiondock/core";
 import { Command } from "commander";
@@ -23,13 +28,45 @@ export function registerPlaybookCommands(program: Command): void {
     .command("list [patterns...]")
     .description("List playbooks in current project or linked packages")
     .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>", "Query against a specific profile")
+    .option("-s, --server <url>", "Remote server URL")
+    .option("-t, --token <token>", "Auth token for remote server")
     .option("--no-fallback", "Disable fallback to full list when no items match intent")
     .option("--json", "Output as JSON")
-    .action((patterns, options) => {
+    .action(async (patterns, options) => {
       try {
         const effectiveIntent = resolveIntent(options.intent, patterns);
         const shouldFallback = options.fallback !== false;
 
+        const target = resolveTarget({
+          profile: options.profile,
+          server: options.server,
+          token: options.token,
+        });
+
+        if (target.type === "remote") {
+          const remotePbs = await fetchRemotePlaybooks(target.serverUrl!, target.token, {
+            intent: effectiveIntent,
+            package: options.package,
+          });
+          if (options.json) {
+            console.log(JSON.stringify(remotePbs, null, 2));
+            return;
+          }
+          console.log(
+            `Playbooks on remote server ${target.serverUrl}${target.profileName ? ` (Profile: ${target.profileName})` : ""}:\n`
+          );
+          if (remotePbs.length === 0) {
+            console.log("  (No playbooks found)");
+          } else {
+            for (const p of remotePbs) {
+              console.log(`  ${p.id.padEnd(24)} ${p.description} (Package: ${p.packageId})`);
+            }
+          }
+          return;
+        }
+
         const root = findProjectRoot();
         if (root) {
           const config = loadProjectConfig(root);
@@ -228,9 +265,35 @@ This playbook provides task execution guidance for AI Agents.
   pbCmd
     .command("show <id>")
     .description("Show playbook content and metadata (from current project or linked packages)")
+    .option("-p, --profile <name>", "Query 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((id, options) => {
+    .action(async (id, options) => {
       try {
+        const target = resolveTarget({
+          profile: options.profile,
+          server: options.server,
+          token: options.token,
+        });
+
+        if (target.type === "remote") {
+          const pb = await fetchRemotePlaybookShow(target.serverUrl!, id, target.token);
+          if (options.json) {
+            console.log(JSON.stringify(pb, null, 2));
+            return;
+          }
+          console.log(`Playbook:    ${pb.id} (Package: ${pb.packageId})`);
+          if (pb.description) console.log(`Description: ${pb.description}`);
+          if (pb.actions && pb.actions.length > 0) {
+            console.log(`Actions:     ${pb.actions.join(", ")}`);
+          }
+          if (pb.filePath) console.log(`File:        ${pb.filePath}\n`);
+          console.log("--- Content ---");
+          console.log(pb.content);
+          return;
+        }
+
         const resolved = resolvePlaybookProject(id);
         const pb = resolved.playbook;
 
@@ -307,7 +370,18 @@ This playbook provides task execution guidance for AI Agents.
 
         for (const target of targets) {
           const config = loadProjectConfig(target.root);
-          const actions = await loadActions(target.root, config.actionsDir);
+          let actionIds = new Set<string>();
+          const manifest = loadManifest(target.root);
+          if (manifest?.actions) {
+            actionIds = new Set(Object.keys(manifest.actions));
+          } else {
+            try {
+              const actions = await loadActions(target.root, config.actionsDir, { autoInstall: false });
+              actionIds = new Set(actions.keys());
+            } catch {
+              // Ignore action loading failure during validation
+            }
+          }
 
           for (const pb of target.playbooks) {
             if (!pb) continue;
@@ -319,8 +393,13 @@ This playbook provides task execution guidance for AI Agents.
 
             if (pb.actions) {
               for (const actId of pb.actions) {
-                if (!actions.has(actId)) {
-                  warnings.push(`Referenced action '${actId}' not found in package '${target.packageId}'`);
+                if (actionIds.has(actId)) {
+                  continue;
+                }
+                try {
+                  await resolveActionProject(actId, target.root);
+                } catch (err: any) {
+                  warnings.push(err.message);
                 }
               }
             }

package/src/commands/profile.ts

@@ -235,7 +235,7 @@ export function registerProfileCommands(program: Command): void {
           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).`);
+            console.log(`Target profile '${target.profileName || "local"}' is local (runs in local runtime).`);
           }
           return;
         }

package/src/commands/runs.ts

@@ -1,8 +1,10 @@
 import { existsSync } from "node:fs";
 import {
   cancelRemoteRun,
+  clearRemoteRuns,
   createStorage,
   fetchRemoteRun,
+  fetchRemoteRuns,
   filterWithFallbackInfo,
   findProjectRoot,
   listLinkedPackages,
@@ -49,14 +51,50 @@ export function registerRunsCommands(program: Command): void {
     .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("-p, --profile <name>", "Query against a specific profile")
+    .option("-s, --server <url>", "Remote server URL")
+    .option("-t, --token <token>", "Auth token for remote server")
     .option("--no-fallback", "Disable fallback to full list when no items match intent")
     .option("--json", "Output as JSON")
-    .action((patterns, options) => {
+    .action(async (patterns, options) => {
       try {
         const effectiveIntent = resolveIntent(options.intent, patterns);
         const shouldFallback = options.fallback !== false;
         const limit = Number.parseInt(options.limit, 10) || 20;
 
+        const target = resolveTarget({
+          profile: options.profile,
+          server: options.server,
+          token: options.token,
+        });
+
+        if (target.type === "remote") {
+          const res = await fetchRemoteRuns(target.serverUrl!, target.token, {
+            packageId: options.package,
+            actionId: options.action,
+            intent: effectiveIntent,
+            limit,
+          });
+          if (options.json) {
+            console.log(JSON.stringify(res.items, null, 2));
+            return;
+          }
+          console.log(
+            `Execution Runs on remote server ${target.serverUrl}${target.profileName ? ` (Profile: ${target.profileName})` : ""} (${res.items.length}):\n`
+          );
+          console.log(
+            `  ${"RUN ID".padEnd(38)} ${"ACTION".padEnd(24)} ${"STATUS".padEnd(10)} ${"STARTED"}`
+          );
+          console.log("  " + "-".repeat(90));
+          for (const r of res.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;
+        }
+
         const targetRoot = options.package
           ? resolvePackageRoot(options.package)
           : findProjectRoot();
@@ -315,5 +353,57 @@ export function registerRunsCommands(program: Command): void {
         process.exit(1);
       }
     });
+
+  // runs clear
+  runsCmd
+    .command("clear")
+    .description("Clear execution run records (locally or on remote server)")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-a, --action <actionId>", "Filter by action ID")
+    .option("-p, --profile <name>", "Target profile")
+    .option("-s, --server <url>", "Remote server URL")
+    .option("-t, --token <token>", "Auth token for remote server")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const target = resolveTarget({
+          profile: options.profile,
+          server: options.server,
+          token: options.token,
+        });
+
+        if (target.type === "remote") {
+          const res = await clearRemoteRuns(target.serverUrl!, target.token, {
+            packageId: options.package,
+            actionId: options.action,
+          });
+          if (options.json) {
+            console.log(JSON.stringify(res, null, 2));
+          } else {
+            console.log(`Cleared ${res.clearedCount} execution run(s) on remote server.`);
+          }
+          return;
+        }
+
+        const targetRoot = options.package
+          ? resolvePackageRoot(options.package)
+          : findProjectRoot();
+
+        if (targetRoot) {
+          const projConfig = loadProjectConfig(targetRoot);
+          const storage = createStorage(projConfig.id, { projectRoot: targetRoot });
+          const count = storage.clearRuns({ actionId: options.action });
+          storage.close();
+          if (options.json) {
+            console.log(JSON.stringify({ ok: true, clearedCount: count }, null, 2));
+          } else {
+            console.log(`Cleared ${count} execution run(s) in package '${projConfig.id}'.`);
+          }
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }
 

package/src/commands/serve.ts

@@ -1,5 +1,7 @@
 import { resolve } from "node:path";
 import { findProjectRoot, loadProjectConfig, startActionDockServer } from "@actiondock/core";
+import { createActionDockMcpServer } from "@actiondock/mcp";
+import { createMcpHandler } from "@modelcontextprotocol/server";
 import { Command } from "commander";
 import { parseByteSize } from "../utils/bytes";
 
@@ -19,6 +21,7 @@ export function registerServeCommand(program: Command): void {
     )
     .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("--no-mcp", "Disable unified MCP protocol endpoint at /mcp")
     .option("-d, --dir <path>", "Project root directory (default: current working directory)")
     .action(async (options) => {
       const port = parseInt(options.port, 10) || 5177;
@@ -55,6 +58,30 @@ export function registerServeCommand(program: Command): void {
         }
       }
 
+      let mcpHandler: ((req: Request) => Promise<Response | null | undefined>) | undefined;
+      const enableMcp = options.mcp !== false;
+      if (enableMcp) {
+        try {
+          const handler = createMcpHandler(
+            () => {
+              return createActionDockMcpServer({
+                projectRoot: projectRoot || undefined,
+              });
+            },
+            {
+              onerror: (err) => {
+                process.stderr.write(`[MCP HTTP Error] ${err?.message || String(err)}\n`);
+              },
+            }
+          );
+          mcpHandler = async (req: Request) => {
+            return handler.fetch(req);
+          };
+        } catch {
+          // 忽略 MCP 初始化异常
+        }
+      }
+
       try {
         const server = startActionDockServer({
           port,
@@ -64,6 +91,8 @@ export function registerServeCommand(program: Command): void {
           corsOrigins,
           maxBodyBytes,
           exposeDebugInfo,
+          enableMcp,
+          mcpHandler,
           projectRoot: projectRoot || undefined,
         });
 
@@ -79,6 +108,9 @@ export function registerServeCommand(program: Command): void {
         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`);
+        if (enableMcp) {
+          console.log(`  * MCP Endpoint:    http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${server.port}/mcp`);
+        }
         console.log(`======================================================\n`);
         console.log(`Server is ready to accept remote 'ad run' requests.`);
         console.log(`Press Ctrl+C to terminate.\n`);