@actiondock/cli 2.0.11-beta.0 → 2.0.12

package/src/commands/action/show.ts

@@ -1,128 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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);
-      }
-    });
-}

package/src/commands/build.ts

@@ -1,56 +0,0 @@
-import { buildProject } from "@actiondock/builder";
-import { findProjectRoot, resolvePackageRoot } from "@actiondock/core";
-import { ExecutionError } from "@actiondock/runtime-cli";
-import { Command } from "commander";
-
-export function registerBuildCommand(program: Command): void {
-  program
-    .command("build")
-    .description("Build project actions into a single standalone executable")
-    .option("-P, --package <id>", "Target package ID or path")
-    .option("-t, --target <target>", "Target compilation platform (e.g. bun, linux-x64, darwin-arm64, windows-x64)")
-    .option("-o, --out <path>", "Output executable path")
-    .option("-a, --actions <actions...>", "Only build specific action(s) into the standalone binary")
-    .option("-m, --minify", "Minify bundled JavaScript (default: true)", true)
-    .option("--no-minify", "Disable JavaScript minification")
-    .option("--bytecode", "Compile JavaScript to bytecode for faster startup (default: true)", true)
-    .option("--no-bytecode", "Disable bytecode compilation")
-    .action(async (options) => {
-      const root = options.package
-        ? resolvePackageRoot(options.package)
-        : findProjectRoot();
-
-      if (!root) {
-        if (options.package) {
-          throw new ExecutionError(`Package '${options.package}' not found in linked packages or path`);
-        }
-        throw new ExecutionError(
-          "Not in an ActionDock project (actiondock.json not found).\nPlease specify -P, --package <id> or cd into a project directory."
-        );
-      }
-
-      console.log("Building standalone executable...");
-
-      let result;
-      try {
-        result = await buildProject({
-          projectRoot: root,
-          target: options.target,
-          outfile: options.out,
-          minify: options.minify,
-          bytecode: options.bytecode,
-          actions: options.actions,
-        });
-      } catch (err: any) {
-        throw new ExecutionError(`Build failed: ${err.message}`);
-      }
-
-      console.log(`[OK] Successfully compiled ${result.packageId} (v${result.version})`);
-      console.log(`  Target:     ${result.target}`);
-      console.log(`  Actions:    ${result.actions.join(", ")}`);
-      console.log(`  Executable: ${result.executablePath}`);
-      if (result.metadataPath) {
-        console.log(`  Metadata:   ${result.metadataPath}`);
-      }
-    });
-}