@actiondock/cli 2.0.9 → 2.0.11-beta.0

package/src/commands/action/show.ts

@@ -0,0 +1,128 @@
+import {
+  fetchRemoteActionShow,
+  loadManifest,
+  loadProjectConfig,
+  resolveActionProject,
+  resolvePackageRoot,
+  resolveTarget,
+} from "@actiondock/core";
+import {
+  ArgumentError,
+  ExecutionError,
+  getEffectiveOptions,
+  renderResult,
+} from "@actiondock/runtime-cli";
+import type { Command } from "commander";
+
+export function registerActionShowCommand(actionCmd: Command): void {
+  actionCmd
+    .command("show <id>")
+    .alias("describe")
+    .description("Show action definition, schema, and description")
+    .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("--json", "Output as JSON")
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (id, rawOptions, cmd) => {
+      try {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        if (!id) {
+          throw new ArgumentError("Action ID is required for show/describe");
+        }
+
+        const target = resolveTarget({
+          profile: options.profile,
+          server: options.server,
+          token: options.token,
+        });
+
+        if (target.type === "remote") {
+          const detail = await fetchRemoteActionShow(
+            target.serverUrl!,
+            id,
+            target.token
+          );
+          renderResult(detail, {
+            json: options.json,
+            envelope: options.envelope,
+            humanFormatter: () => {
+              const lines = [`Action:      ${detail.id}`];
+              if (detail.packageId) lines.push(`Package:     ${detail.packageId}`);
+              if (detail.description) lines.push(`Description: ${detail.description}`);
+              if (detail.inputSchema) {
+                lines.push("\nInput Schema:", JSON.stringify(detail.inputSchema, null, 2));
+              }
+              if (detail.outputSchema) {
+                lines.push("\nOutput Schema:", JSON.stringify(detail.outputSchema, null, 2));
+              }
+              return lines.join("\n");
+            },
+          });
+          return;
+        }
+
+        let showTarget = 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`
+            );
+          }
+          showTarget = `${options.package}/${id}`;
+        }
+
+        let resolved;
+        try {
+          resolved = await resolveActionProject(showTarget);
+        } 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);
+        }
+
+        const manifest = loadManifest(resolved.projectRoot);
+        const actionMeta = manifest?.actions?.[resolved.actionId];
+
+        if (!actionMeta) {
+          throw new ArgumentError(
+            `Action '${resolved.actionId}' not found in package '${resolved.packageId}'`
+          );
+        }
+
+        const payload = {
+          id: resolved.actionId,
+          packageId: resolved.packageId,
+          projectRoot: resolved.projectRoot,
+          description: actionMeta.description,
+          inputSchema: actionMeta.inputSchema,
+          outputSchema: actionMeta.outputSchema,
+        };
+
+        renderResult(payload, {
+          json: options.json,
+          envelope: options.envelope,
+          humanFormatter: () => {
+            const lines = [
+              `Action:      ${resolved.actionId}`,
+              `Package:     ${resolved.packageId} (${resolved.projectRoot})`,
+            ];
+            if (actionMeta.description) lines.push(`Description: ${actionMeta.description}`);
+            if (actionMeta.inputSchema) {
+              lines.push("\nInput Schema:", JSON.stringify(actionMeta.inputSchema, null, 2));
+            }
+            if (actionMeta.outputSchema) {
+              lines.push("\nOutput Schema:", JSON.stringify(actionMeta.outputSchema, null, 2));
+            }
+            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/sync.ts

@@ -0,0 +1,76 @@
+import { findProjectRoot, syncManifest } from "@actiondock/core";
+import { ExecutionError, getEffectiveOptions, renderResult } from "@actiondock/runtime-cli";
+import type { Command } from "commander";
+
+export function registerActionSyncCommand(actionCmd: Command): void {
+  actionCmd
+    .command("sync")
+    .description("Synchronize action metadata manifest with TypeScript definitions")
+    .option("--check", "Check if manifest is synchronized without modifying files")
+    .option("--no-prune", "Do not remove deleted actions from manifest")
+    .option("--json", "Output as JSON")
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (rawOptions, cmd) => {
+      const options = getEffectiveOptions(rawOptions, cmd);
+      const root = findProjectRoot();
+      if (!root) {
+        throw new ExecutionError("Not in an ActionDock project (actiondock.json not found)");
+      }
+
+      try {
+        const result = await syncManifest(root, {
+          check: Boolean(options.check),
+          prune: options.prune !== false,
+        });
+
+        renderResult(result, {
+          json: options.json,
+          envelope: options.envelope,
+          humanFormatter: () => {
+            const lines: string[] = [];
+            if (options.check) {
+              if (result.inSync) {
+                lines.push("[OK] actiondock.manifest.json is up to date.");
+              } else {
+                lines.push("[FAIL] actiondock.manifest.json is out of sync with action definitions:\n");
+                if (result.added.length > 0) {
+                  lines.push(`  - Added actions:   ${result.added.join(", ")}`);
+                }
+                if (result.updated.length > 0) {
+                  lines.push(`  - Updated actions: ${result.updated.join(", ")}`);
+                }
+                if (result.removed.length > 0) {
+                  lines.push(`  - Removed actions: ${result.removed.join(", ")}`);
+                }
+                lines.push("\nRun 'ad action sync' to synchronize metadata manifest.");
+              }
+            } else {
+              if (result.inSync) {
+                lines.push(`[OK] actiondock.manifest.json is already up to date (${result.unchanged.length} action(s)).`);
+              } else {
+                lines.push("[OK] Successfully synchronized actiondock.manifest.json:\n");
+                if (result.added.length > 0) {
+                  lines.push(`  - Added:   ${result.added.join(", ")}`);
+                }
+                if (result.updated.length > 0) {
+                  lines.push(`  - Updated: ${result.updated.join(", ")}`);
+                }
+                if (result.removed.length > 0) {
+                  lines.push(`  - Removed: ${result.removed.join(", ")}`);
+                }
+                lines.push(`\nManifest updated at ${result.manifestPath}`);
+              }
+            }
+            return lines.join("\n");
+          },
+        });
+
+        if (options.check && !result.inSync) {
+          process.exitCode = 1;
+        }
+      } catch (err: any) {
+        if (err instanceof ExecutionError) throw err;
+        throw new ExecutionError(err.message);
+      }
+    });
+}

package/src/commands/action/validate.ts

@@ -0,0 +1,102 @@
+import {
+  findProjectRoot,
+  loadActions,
+  loadProjectConfig,
+  resolvePackageRoot,
+  validateSchema,
+} from "@actiondock/core";
+import {
+  ArgumentError,
+  ExecutionError,
+  getEffectiveOptions,
+  renderResult,
+} from "@actiondock/runtime-cli";
+import type { Command } from "commander";
+
+export function registerActionValidateCommand(actionCmd: Command): void {
+  actionCmd
+    .command("validate [id]")
+    .description("Validate action schemas and definitions")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("--json", "Output as JSON")
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (id, rawOptions, cmd) => {
+      const options = getEffectiveOptions(rawOptions, cmd);
+      let root: string | null = null;
+      if (options.package) {
+        root = resolvePackageRoot(options.package);
+        if (!root) {
+          throw new ArgumentError(
+            `Package '${options.package}' not found in linked packages or path`
+          );
+        }
+      } else {
+        root = findProjectRoot();
+      }
+
+      if (!root) {
+        throw new ArgumentError("Not in an ActionDock project (actiondock.json not found)");
+      }
+
+      try {
+        const config = loadProjectConfig(root);
+        const actions = await loadActions(root, config.actionsDir);
+
+        const toValidate = id ? [actions.get(id)].filter(Boolean) : Array.from(actions.values());
+        if (id && toValidate.length === 0) {
+          throw new ArgumentError(`Action '${id}' not found in project`);
+        }
+
+        const results: Array<{ id: string; valid: boolean; errors: string[] }> = [];
+
+        for (const act of toValidate as any[]) {
+          const errors: string[] = [];
+          if (!act.id) errors.push("Missing id property");
+          if (!act.run || typeof act.run !== "function") errors.push("Missing run method");
+          if (act.inputSchema) {
+            validateSchema(act.inputSchema, {});
+            if (typeof act.inputSchema !== "object") {
+              errors.push("Invalid inputSchema object");
+            }
+          }
+          if (act.outputSchema) {
+            if (typeof act.outputSchema !== "object") {
+              errors.push("Invalid outputSchema object");
+            }
+          }
+          results.push({
+            id: act.id,
+            valid: errors.length === 0,
+            errors,
+          });
+        }
+
+        const allValid = results.every((r) => r.valid);
+        renderResult(
+          { valid: allValid, results },
+          {
+            json: options.json,
+            envelope: options.envelope,
+            humanFormatter: () => {
+              const lines: string[] = [];
+              for (const r of results) {
+                if (r.valid) {
+                  lines.push(`[OK] ${r.id}: Valid`);
+                } else {
+                  lines.push(`[FAIL] ${r.id}: ${r.errors.join(", ")}`);
+                }
+              }
+              return lines.join("\n");
+            },
+          }
+        );
+
+        if (!allValid) {
+          process.exitCode = 1;
+        }
+      } catch (err: any) {
+        if (err instanceof ArgumentError || err instanceof ExecutionError) throw err;
+        throw new ExecutionError(err.message);
+      }
+    });
+}