@actiondock/cli 2.0.12 → 2.2.0

package/dist/commands/config/set.js

@@ -0,0 +1,85 @@
+import { isSecretConfigKey, loadProjectConfig, resolvePackageRoot, } from "@actiondock/core";
+import { ArgumentError } from "../../errors.js";
+import { writeStdout } from "../../renderer.js";
+import { getEffectiveOptions, withTarget } from "../../utils/index.js";
+import { resolveConfigValueInput } from "../../prompt.js";
+/**
+ * 注册 config set 子命令：写入配置值（支持标准输入与安全提示）。
+ *
+ * @param configCmd config 命令实例
+ * @param context 命令行上下文
+ */
+export function registerConfigSetCommand(configCmd, context) {
+    configCmd
+        .command("set <key> [value]")
+        .description("Set configuration value (supports stdin and secure prompt)")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("-g, --global", "Set in global configuration")
+        .option("-p, --profile <name>", "Configure on a remote target")
+        .option("-s, --server <url>", "Remote server URL")
+        .option("-t, --token <token>", "Auth token for remote server")
+        .option("--stdin", "Read value from standard input")
+        .option("--data-dir <path>", "Custom database storage directory")
+        .action(async (key, rawVal, rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        if (!key) {
+            throw new ArgumentError("Configuration key is required");
+        }
+        let root = null;
+        let projConfig = null;
+        let declaredDef;
+        if (!options.global && !options.profile && !options.server) {
+            root = resolvePackageRoot(options.package);
+            if (root) {
+                try {
+                    projConfig = loadProjectConfig(root);
+                    declaredDef = projConfig.config?.[key];
+                }
+                catch (err) {
+                    // 清单损坏时必须让错误可见：静默忽略会导致写入错误的作用域
+                    throw err;
+                }
+            }
+        }
+        const isSecret = isSecretConfigKey(key, declaredDef);
+        let effectiveValueStr = rawVal;
+        if (effectiveValueStr === undefined || options.stdin) {
+            effectiveValueStr = await resolveConfigValueInput({
+                promptText: `Enter value for '${key}'${isSecret ? " (secret)" : ""}: `,
+                secret: isSecret,
+                context,
+                useStdin: Boolean(options.stdin),
+            });
+        }
+        let parsedVal = effectiveValueStr;
+        try {
+            parsedVal = JSON.parse(effectiveValueStr);
+        }
+        catch {
+            parsedVal = effectiveValueStr;
+        }
+        // 目标解析与写入（远端分支直接写远端作用域，本地分支按全局/项目作用域写入）
+        await withTarget(options, context, async (target, resolved) => {
+            if (resolved.type === "remote") {
+                await target.setConfig(options.package || "", key, parsedVal);
+                writeStdout(`[OK] Configuration '${key}' updated on remote server`, context);
+                return;
+            }
+            if (options.global) {
+                await target.setConfig("global", key, parsedVal);
+                writeStdout(`[OK] Global configuration '${key}' updated`, context);
+                return;
+            }
+            if (!root) {
+                if (options.package) {
+                    throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
+                }
+                await target.setConfig("global", key, parsedVal);
+                writeStdout(`[OK] Global configuration '${key}' updated (no project in current directory)`, context);
+                return;
+            }
+            await target.setConfig(projConfig.id, key, parsedVal);
+            writeStdout(`[OK] Configuration '${key}' updated for package '${projConfig.id}'`, context);
+        });
+    });
+}

package/dist/commands/describe.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册顶层统一 describe 命令：查询指定 Action 的规范结构与模式定义。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export declare function registerDescribeCommand(program: Command, context?: CliContext): void;

package/dist/commands/describe.js

@@ -0,0 +1,68 @@
+import { ArgumentError, ExecutionError } from "../errors.js";
+import { renderActionDetail, renderResult } from "../renderer.js";
+import { getEffectiveOptions, resolveLocalPackageRoot, withTarget, } from "../utils/index.js";
+/**
+ * 注册顶层统一 describe 命令：查询指定 Action 的规范结构与模式定义。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export function registerDescribeCommand(program, context) {
+    program
+        .command("describe <id>")
+        .alias("show")
+        .description("Show action definition, schema, and description")
+        .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("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .option("--data-dir <path>", "Custom database storage directory")
+        .action(async (id, rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        if (!id) {
+            throw new ArgumentError("Action ID is required for describe");
+        }
+        // 目标拓扑解析（仅 local 分支需要包寻址）
+        const targetPackageRoot = resolveLocalPackageRoot(options.package);
+        if (options.package && !targetPackageRoot) {
+            throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
+        }
+        let targetRef = id;
+        if (options.package && !id.includes("/") && !id.includes(":")) {
+            targetRef = `${options.package}/${id}`;
+        }
+        // 通过 Target 门面统一查询 Action 规范
+        await withTarget(options, context, async (target) => {
+            let spec;
+            try {
+                spec = await target.describeAction(targetRef);
+            }
+            catch (err) {
+                const msg = err?.message || String(err);
+                if (msg.includes("not found") || msg.includes("ACTION_NOT_FOUND")) {
+                    throw new ArgumentError(msg);
+                }
+                throw new ExecutionError(msg);
+            }
+            const detail = {
+                id: spec.id,
+                description: spec.description,
+                inputSchema: spec.inputSchema,
+                outputSchema: spec.outputSchema,
+                tags: spec.tags,
+                annotations: spec.annotations,
+                uses: spec.uses,
+                entry: spec.entry,
+                filePath: spec.filePath,
+            };
+            renderResult(detail, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => renderActionDetail(detail),
+                context,
+            });
+        }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true });
+    });
+}

package/dist/commands/doctor.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
-export declare function registerDoctorCommand(program: Command): void;
+import type { CliContext } from "../types.js";
+export declare function registerDoctorCommand(program: Command, context?: CliContext): void;

package/dist/commands/doctor.js

@@ -0,0 +1,82 @@
+import { fetchRemoteDoctor, resolveTarget, runDoctorChecks } from "@actiondock/core";
+import { ExecutionError } from "../errors.js";
+import { renderResult } from "../renderer.js";
+import { getEffectiveOptions } from "../utils/index.js";
+export function registerDoctorCommand(program, context) {
+    program
+        .command("doctor")
+        .description("Check ActionDock environment, registry health, and project diagnostics")
+        .option("-P, --package <id|path>", "Target package ID or directory path for project diagnostics")
+        .option("-p, --profile <name>", "Query doctor diagnostics on a remote target")
+        .option("-s, --server <url>", "Remote server URL")
+        .option("-t, --token <token>", "Auth token for remote server")
+        .option("--json", "Output diagnostics report in JSON format")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action(async (rawOptions, cmd) => {
+        try {
+            const options = getEffectiveOptions(rawOptions, cmd);
+            const target = resolveTarget({
+                profile: options.profile,
+                server: options.server,
+                token: options.token,
+            }, context?.customHome);
+            let report;
+            if (target.type === "remote") {
+                const remoteRes = await fetchRemoteDoctor(target.serverUrl, target.token, options.package);
+                report = remoteRes.report || remoteRes;
+            }
+            else {
+                report = await runDoctorChecks({
+                    packageIdOrPath: options.package,
+                    customHome: context?.customHome,
+                });
+            }
+            renderResult(report, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => {
+                    const lines = [];
+                    const title = target.type === "remote"
+                        ? `[DOCTOR] Remote ActionDock Server Diagnostics (${target.serverUrl}${target.profileName ? ` - Profile: ${target.profileName}` : ""})\n`
+                        : "[DOCTOR] ActionDock System & Project Diagnostics\n";
+                    lines.push(title);
+                    // 1. Runtime & Environment Group
+                    lines.push("[Runtime & Environment]");
+                    const envChecks = (report.checks || []).filter((c) => c.category === "runtime" || c.category === "storage" || c.category === "registry");
+                    for (const c of envChecks) {
+                        const tag = c.status === "ok" ? "[OK]" : c.status === "warn" ? "[WARN]" : "[ERROR]";
+                        lines.push(`  ${tag} ${c.name}: ${c.message}`);
+                        if (c.fix) {
+                            lines.push(`       Fix: ${c.fix}`);
+                        }
+                    }
+                    // 2. Project Group
+                    if (report.hasProject) {
+                        lines.push(`\n[Project: ${report.packageId || "unknown"}] (${report.projectRoot})`);
+                        const projChecks = (report.checks || []).filter((c) => c.category === "project");
+                        for (const c of projChecks) {
+                            const tag = c.status === "ok" ? "[OK]" : c.status === "warn" ? "[WARN]" : "[ERROR]";
+                            lines.push(`  ${tag} ${c.name}: ${c.message}`);
+                            if (c.fix) {
+                                lines.push(`       Fix: ${c.fix}`);
+                            }
+                        }
+                    }
+                    else {
+                        lines.push("\n[Project Context]");
+                        lines.push("  [INFO] Not inside an ActionDock project directory (skipped project checks)");
+                    }
+                    // 3. Summary
+                    lines.push(`\n[Summary] ${report.summary.ok} passed, ${report.summary.warn} warning(s), ${report.summary.error} error(s)`);
+                    return lines.join("\n");
+                },
+            });
+            if (!report.ok) {
+                process.exitCode = 1;
+            }
+        }
+        catch (err) {
+            throw new ExecutionError(`Doctor failed to run diagnostics: ${err.message}`);
+        }
+    });
+}

package/dist/commands/export.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
-export declare function registerExportCommand(program: Command): void;
+import type { CliContext } from "../types.js";
+export declare function registerExportCommand(program: Command, context?: CliContext): void;

package/dist/commands/export.js

@@ -0,0 +1,212 @@
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+import { exportCompositeSkill, exportSkill, exportSkillBatch } from "@actiondock/builder";
+import { discoverProjects, findProjectRoot, listLinkedPackages, resolvePackageRoot } from "@actiondock/core";
+import { ExecutionError } from "../errors.js";
+import { renderResult, writeStdout } from "../renderer.js";
+import { getEffectiveOptions, parseListOption } from "../utils/index.js";
+export function registerExportCommand(program, context) {
+    const exportCmd = program
+        .command("export")
+        .description("Export project artifacts");
+    exportCmd
+        .command("skill")
+        .description("Export Skill directory for AI Agents (default: source; use -m/--mode node for self-contained Node.js directory)")
+        .option("-P, --package <id...>", "Target package ID(s) or path(s) (can be specified multiple times or comma-separated)", parseListOption, [])
+        .option("--workspace", "Export all packages discovered in current workspace")
+        .option("--all", "Export all linked packages from global registry")
+        .option("--bundle [name]", "Export multiple packages as a unified composite Skill bundle (defaults to workspace directory name if omitted)")
+        .option("-m, --mode <mode>", "Skill export mode ('source' or 'node')", "source")
+        .option("-s, --standalone", "Export standalone binary skill (removed)")
+        .option("-t, --target <target>", "Target compilation platform (removed)")
+        .option("--bytecode", "Bytecode compilation (removed)")
+        .option("-o, --out <path>", "Output skill directory")
+        .option("-p, --playbook <playbooks...>", "Only export specific playbook(s) and their dependent actions", parseListOption)
+        .option("-a, --actions <actions...>", "Only export specific action(s)", parseListOption)
+        .option("-z, --archive", "Create a .zip archive of the exported skill")
+        .option("--skill-md <path>", "Use specified existing SKILL.md file instead of auto-generating")
+        .option("--custom-md <path>", "Custom skill declaration (SKILL.custom.md) with slot-marked sections and optional frontmatter description for composite bundles (auto-discovered at workspace root when omitted)")
+        .option("--skill-md-only", "Bundle mode only: regenerate only the composite SKILL.md in place (always regenerates, ignores any existing SKILL.md)")
+        .option("--vendor-deps", "Materialize locked production dependencies into the exported skill")
+        .option("--allow-install-scripts", "Allow lifecycle install scripts to run during dependency materialization")
+        .option("--require-reproducible", "Require reproducible build and fail if install scripts must run")
+        .action(async (rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        // 彻底删除 --standalone 单文件编译选项
+        if (options.standalone || options.target !== undefined || options.bytecode !== undefined) {
+            throw new ExecutionError("The '--standalone' option and binary target flags have been removed in ActionDock 2.0. Please use '--mode node' for self-contained Node.js directory skills, or '--mode source' for source-based skills.", undefined, "UNSUPPORTED_BUILD_MODE");
+        }
+        const mode = options.mode === "node" ? "node" : "source";
+        if (options.bundle && mode === "node") {
+            throw new ExecutionError("Composite Skill export (--bundle) currently only supports source mode. Please use '--mode source' to export as a composite workspace Skill.");
+        }
+        if (options.skillMdOnly && options.bundle === undefined) {
+            throw new ExecutionError("Option --skill-md-only requires composite bundle mode (--bundle).");
+        }
+        const sourceCount = (options.all ? 1 : 0) +
+            (options.workspace ? 1 : 0) +
+            (options.package && options.package.length > 0 ? 1 : 0);
+        if (sourceCount > 1) {
+            throw new ExecutionError("Options -P/--package, --workspace, and --all are mutually exclusive. Please specify only one package selection mode.");
+        }
+        let roots = [];
+        if (options.all) {
+            const linked = listLinkedPackages();
+            roots = linked.map((p) => p.path).filter((p) => existsSync(p));
+            if (roots.length === 0) {
+                throw new ExecutionError("No linked packages found in global registry.");
+            }
+        }
+        else if (options.workspace) {
+            const cwd = process.cwd();
+            const discovered = discoverProjects(cwd);
+            roots = discovered.length > 0 ? discovered : (findProjectRoot(cwd) ? [findProjectRoot(cwd)] : []);
+            if (roots.length === 0) {
+                throw new ExecutionError(`No ActionDock packages found in workspace '${cwd}'.\nMake sure child directories contain actiondock.json.`);
+            }
+        }
+        else if (options.package && options.package.length > 0) {
+            for (const pkgIdOrPath of options.package) {
+                const root = resolvePackageRoot(pkgIdOrPath);
+                if (!root) {
+                    throw new ExecutionError(`Package '${pkgIdOrPath}' not found in linked packages or path`);
+                }
+                if (!roots.includes(root)) {
+                    roots.push(root);
+                }
+            }
+        }
+        else {
+            const root = findProjectRoot();
+            if (root) {
+                roots.push(root);
+            }
+            else {
+                throw new ExecutionError("Not in an ActionDock project (actiondock.json not found).\nPlease specify -P, --package <id>, --workspace, --all, or cd into a project directory.");
+            }
+        }
+        if (roots.length > 1 && (options.actions || options.playbook)) {
+            throw new ExecutionError("Filtering options (--actions, --playbook) can only be used when exporting a single package.");
+        }
+        const isMachine = Boolean(options.json || options.envelope);
+        try {
+            if (options.bundle !== undefined) {
+                const bundleName = typeof options.bundle === "string" && options.bundle.trim()
+                    ? options.bundle.trim()
+                    : basename(process.cwd());
+                if (!isMachine) {
+                    writeStdout(`Exporting composite Skill bundle '${bundleName}' (${roots.length} package${roots.length > 1 ? "s" : ""})...`);
+                }
+                const result = await exportCompositeSkill({
+                    bundleName,
+                    projectRoots: roots,
+                    outDir: options.out,
+                    archive: options.archive,
+                    workspaceRoot: options.workspace ? process.cwd() : undefined,
+                    skillMdPath: options.skillMd,
+                    customMdPath: options.customMd,
+                    skillMdOnly: options.skillMdOnly,
+                });
+                renderResult(result, {
+                    json: isMachine,
+                    envelope: options.envelope,
+                    humanFormatter: () => {
+                        const lines = [];
+                        lines.push(`[OK] Successfully exported Composite Skill: ${result.bundleName}`);
+                        lines.push(`  Packages:   ${result.packagesCount}`);
+                        lines.push(`  Actions:    ${result.actionsCount}`);
+                        lines.push(`  Playbooks:   ${result.playbooksCount}`);
+                        lines.push(`  Skill Dir:  ${result.skillDir}`);
+                        if (result.skillMdFile) {
+                            lines.push(`  SKILL.md:   Regenerated ${result.skillMdFile}`);
+                        }
+                        if (result.usedExistingSkillMd) {
+                            lines.push(`  SKILL.md:   Reused existing file from ${result.usedExistingSkillMd}`);
+                        }
+                        if (result.archivePath) {
+                            lines.push(`  Archive:    ${result.archivePath}`);
+                        }
+                        return lines.join("\n");
+                    },
+                    context,
+                });
+                return;
+            }
+            if (roots.length > 1) {
+                if (!isMachine) {
+                    writeStdout(`Batch exporting ${roots.length} Skill packages...`);
+                }
+                const batchRes = await exportSkillBatch({
+                    projectRoots: roots,
+                    mode,
+                    outDir: options.out,
+                    archive: options.archive,
+                    playbooks: options.playbook,
+                    actions: options.actions,
+                    skillMdPath: options.skillMd,
+                    vendorDeps: options.vendorDeps,
+                    allowInstallScripts: options.allowInstallScripts,
+                    requireReproducible: options.requireReproducible,
+                });
+                renderResult(batchRes, {
+                    json: isMachine,
+                    envelope: options.envelope,
+                    humanFormatter: () => {
+                        const lines = [];
+                        lines.push(`[OK] Successfully batch exported ${batchRes.results.length} Skill packages to: ${batchRes.outDir}`);
+                        for (const res of batchRes.results) {
+                            lines.push(`  - ${res.packageId} (v${res.version}): ${res.actionsCount} actions, ${res.playbooksCount} playbooks -> ${res.skillDir}`);
+                        }
+                        lines.push(`  Total Actions:   ${batchRes.totalActions}`);
+                        lines.push(`  Total Playbooks: ${batchRes.totalPlaybooks}`);
+                        return lines.join("\n");
+                    },
+                    context,
+                });
+                return;
+            }
+            const root = roots[0];
+            if (!isMachine) {
+                writeStdout(`Exporting ${mode === "node" ? "Node.js directory" : "source"} Skill artifact...`);
+            }
+            const result = await exportSkill({
+                projectRoot: root,
+                mode,
+                outDir: options.out,
+                archive: options.archive,
+                playbooks: options.playbook,
+                actions: options.actions,
+                skillMdPath: options.skillMd,
+                vendorDeps: options.vendorDeps,
+                allowInstallScripts: options.allowInstallScripts,
+                requireReproducible: options.requireReproducible,
+            });
+            renderResult(result, {
+                json: isMachine,
+                envelope: options.envelope,
+                humanFormatter: () => {
+                    const lines = [];
+                    lines.push(`[OK] Successfully exported ${result.mode === "node" ? "Node Directory" : "Source"} Skill: ${result.packageId} (v${result.version})`);
+                    lines.push(`  Mode:       ${result.mode}`);
+                    lines.push(`  Actions:    ${result.actionsCount}`);
+                    lines.push(`  Playbooks:  ${result.playbooksCount}`);
+                    lines.push(`  Skill Dir:  ${result.skillDir}`);
+                    if (result.usedExistingSkillMd) {
+                        lines.push(`  SKILL.md:   Reused existing file from ${result.usedExistingSkillMd}`);
+                    }
+                    if (result.archivePath) {
+                        lines.push(`  Archive:    ${result.archivePath}`);
+                    }
+                    return lines.join("\n");
+                },
+                context,
+            });
+        }
+        catch (err) {
+            if (err?.code === "UNSUPPORTED_BUILD_MODE") {
+                throw new ExecutionError(err.message, undefined, "UNSUPPORTED_BUILD_MODE");
+            }
+            throw new ExecutionError(`Export failed: ${err.message}`);
+        }
+    });
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册顶层 generate 代码与类型生成命令。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export declare function registerGenerateCommands(program: Command, context?: CliContext): void;

package/dist/commands/generate.js

@@ -0,0 +1,44 @@
+import { findProjectRoot, writeActionTypes } from "@actiondock/core";
+import { ArgumentError, ExecutionError } from "../errors.js";
+import { renderResult } from "../renderer.js";
+import { getEffectiveOptions } from "../utils/index.js";
+/**
+ * 注册顶层 generate 代码与类型生成命令。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export function registerGenerateCommands(program, context) {
+    const generateCmd = program
+        .command("generate")
+        .description("Generate project artifacts such as TypeScript declarations");
+    generateCmd
+        .command("types")
+        .description("Generate .actiondock/generated/actions.d.ts from actiondock.json schema")
+        .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 ArgumentError("Not in an ActionDock project (actiondock.json not found)");
+        }
+        try {
+            const { filePath, digest } = writeActionTypes(root);
+            const result = {
+                success: true,
+                filePath,
+                digest,
+            };
+            renderResult(result, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => `[OK] Generated action types at ${filePath}\nManifest digest: ${digest}`,
+                context,
+            });
+        }
+        catch (err) {
+            throw new ExecutionError(`Failed to generate types: ${err.message}`);
+        }
+    });
+}

package/dist/commands/index.d.ts

@@ -1,2 +1,32 @@
 import { Command } from "commander";
-export declare function createCliProgram(): Command;
+import type { CliContext } from "../types.js";
+import { registerActionCommands } from "./action/create.js";
+import { registerAddCommand } from "./add.js";
+import { registerBuildCommand } from "./build.js";
+import { registerConfigCommands } from "./config/index.js";
+import { registerDescribeCommand } from "./describe.js";
+import { registerDoctorCommand } from "./doctor.js";
+import { registerExportCommand } from "./export.js";
+import { registerGenerateCommands } from "./generate.js";
+import { registerInfoCommand } from "./info.js";
+import { registerInitCommand } from "./init.js";
+import { registerLinkCommands } from "./link.js";
+import { registerListCommand } from "./list.js";
+import { registerMcpCommands } from "./mcp.js";
+import { registerNewCommands } from "./new.js";
+import { registerPackCommand } from "./pack.js";
+import { registerPlaybookCommands } from "./playbook.js";
+import { registerProfileCommands } from "./profile.js";
+import { registerRemoveCommand } from "./remove.js";
+import { registerRunCommand } from "./run.js";
+import { registerRunsCommands } from "./runs.js";
+import { registerServeCommand } from "./serve.js";
+import { registerStateCommands } from "./state.js";
+import { registerTestCommand } from "./test.js";
+import { registerValidateCommand } from "./validate.js";
+/**
+ * CLI 版本号（来自 package.json 单一事实源）。
+ */
+export declare const CLI_VERSION: string;
+export declare function createCliProgram(context?: CliContext): Command;
+export { registerActionCommands, registerAddCommand, registerBuildCommand, registerConfigCommands, registerDescribeCommand, registerDoctorCommand, registerExportCommand, registerGenerateCommands, registerInfoCommand, registerInitCommand, registerLinkCommands, registerListCommand, registerMcpCommands, registerNewCommands, registerPackCommand, registerPlaybookCommands, registerProfileCommands, registerRemoveCommand, registerRunCommand, registerRunsCommands, registerServeCommand, registerStateCommands, registerTestCommand, registerValidateCommand, };