@actiondock/cli 2.0.12 → 2.2.1

package/README.md

@@ -2,7 +2,7 @@
 
 ActionDock 2.0 官方命令行门面工具链。
 
-[![Node.js](https://img.shields.io/badge/Node.js-%3E%3D22.13.0-green?logo=node.js)](https://nodejs.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-%3E%3D24.12.0-green?logo=node.js)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue?logo=typescript)](https://www.typescriptlang.org/)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
@@ -12,10 +12,10 @@ ActionDock 2.0 官方命令行门面工具链。
 
 ## 运行环境
 
-- 原生基于 Node.js 22.13.0 或更高版本运行。
-- 支持 npm、pnpm 与 yarn 进行全局安装或项目级管理。
-- 日常开发、调试、测试、MCP 服务启动与 HTTP 部署完全基于 Node.js，无需安装 Bun。
-- 仅在使用 `ad build` 编译单文件独立二进制产物时，需要系统安装外部 Bun 编译器。
+- 原生基于 Node.js >=24.12.0 运行，充分依托原生类型擦除、内置 SQLite 与原生 HTTP 特性。
+- 支持 npm、pnpm 与 yarn 标准包管理器进行全局安装与项目级管理。
+- 日常开发、调试、测试、构建、打包、MCP 服务启动与 HTTP 部署完全基于 Node.js 与 npm 标准工作流，无需安装外部编译器。
+- 单文件独立二进制构建（`--target`、`--bytecode`、`--standalone`）与 `actiondock.manifest.json` 已在 2.0 中彻底移除，由标准的 Node.js 目录交付产物与 npm 打包取代。
 
 ---
 
@@ -33,19 +33,6 @@ npm install -g @actiondock/cli
 npx ad --help
 ```
 
-### 从源码安装本地开发版
-
-若需从仓库源码调试最新开发版本：
-
-```bash
-git clone https://github.com/team4u/actiondock.git
-cd actiondock
-bun install
-bun run build
-cd packages/cli
-npm link
-```
-
 ---
 
 ## 快速上手流程
@@ -57,6 +44,11 @@ cd my-tools
 npm install
 ```
 
+- 安装并锁定依赖（基于 actiondock.lock.json 与原子事务）：
+```bash
+ad add @actiondock/example-tools
+```
+
 - 本地执行 Action：
 ```bash
 ad run sample.greet --input '{"name": "Alice"}'
@@ -74,30 +66,39 @@ ad mcp
 
 - 导出为便携式 Agent Skill 技能包：
 ```bash
+# 导出源码模式技能
 ad export skill
+
+# 导出自包含 Node.js 目录模式技能
+ad export skill --mode node
 ```
 
-- 编译为零依赖单文件独立二进制产物（需外部安装 Bun）：
+- 构建 Node.js 目录交付产物：
 ```bash
 ad build
 ```
 
+- 打包为标准 npm tarball：
+```bash
+ad pack
+```
+
 ---
 
-## 通用选项与机器调用契约
+## 通用选项与调用契约
 
-所有 CLI 子命令均支持前置或后置传入通用控制选项：
+所有 CLI 子命令均支持传入通用控制选项：
 
-- `-v, -V, --version`：打印版本号并以状态码 0 退出。
+- `-v, -V, --version`：打印版本号并退出。
 - `-h, --help`：打印命令帮助并退出。
 - `--json`：以标准 JSON 格式输出结果。
 - `--envelope`：将输出包装为标准信封结构对象（包含 `ok: true, data: T` 或 `ok: false, error: { code, message, details }`）。
 - `--data-dir <path>`：指定自定义数据存储目录，实现多测试或多任务数据隔离。
 
-### 精确目标解析机制
+### 严格目标解析机制
 
-- **严格目标定位**：通过 `-P, --package <id|path>` 指定目标包。系统严格区分物理路径与注册表包标识符，若目标不存在则坚决不向当前目录或父级目录隐式回退，直接以参数校验错误退出（状态码 2）。
-- **多目标检索契约**：在执行多目标检索（如 `ad info [keywords]` 或 `ad action list [keywords]`）时，若无任何匹配项，在机器模式下始终返回确定性空数组结构并以状态码 0 退出，绝不因空搜索产生异常中断。
+- 严格目标定位：通过 `-P, --package <id|path>` 指定目标包。系统严格区分物理路径与注册表包标识符，若目标不存在则不向当前目录或父级目录隐式回退，直接以参数校验错误退出。
+- 多目标检索契约：在执行多目标检索（如 `ad info` 或 `ad list`）时，若无任何匹配项，在机器模式下始终返回确定性空数组结构并以状态码 0 退出，不因空搜索产生异常中断。
 
 ---
 
@@ -106,17 +107,23 @@ ad build
 | 命令 | 说明 |
 |---|---|
 | `ad init [dir]` | 初始化 Action Package 项目脚手架 |
+| `ad add <package>` | 安装并锁定 Action 依赖，更新 actiondock.lock.json 并提供原子回滚保护 |
+| `ad remove <package>` | 卸载并更新锁定依赖，提供原子回滚保护 |
 | `ad info [patterns...]` | 检索包元数据与能力清单，支持模式匹配与树形展示 |
+| `ad list [patterns...]` | 列出包内所有已注册的 Action |
+| `ad describe <id>` | 查看 Action 的详情、参数与模式规范（别名 `ad show`） |
+| `ad run <id>` | 本地或远程执行指定 Action 并输出标准信封结果 |
+| `ad validate [id]` | 校验 Action 规范与模式规范 |
 | `ad doctor` | 执行运行环境与项目结构健康诊断 |
-| `ad run <id>` | 本地执行指定 Action 并输出标准信封结果 |
-| `ad action list` | 列出包内所有已注册的 Action |
+| `ad action create <id>` | 创建新 Action 源码（别名 `ad action new`） |
 | `ad playbook list` / `show` | 查看智能体操作规程 Playbook |
 | `ad config list` / `get` / `set` | 管理包运行时配置与环境变量绑定 |
 | `ad state list` / `get` / `set` / `delete` / `clear` | 查看与维护 SQLite 持久化状态 |
 | `ad runs list` / `show` | 查询任务执行历史与追踪记录 |
 | `ad test` | 执行快速单元测试 |
-| `ad build` | 调度外部 Bun 编译器打包单文件独立二进制产物 |
-| `ad export skill` | 导出包含操作规程的 Agent Skill 技能包 |
+| `ad build` | 构建 Node.js 目录交付产物（支持 `--vendor-deps` 与 `--archive`） |
+| `ad pack` | 打包为标准 npm tarball（`.tgz`），支持 `--dry-run` |
+| `ad export skill` | 导出 Agent Skill 技能包（支持 `--mode source` 与 `--mode node`） |
 | `ad link` / `unlink` | 注册或注销工作区全局路由与符号链接 |
 | `ad profile` | 管理远程执行节点凭证与环境配置 |
 | `ad serve` | 启动远程 HTTP 执行调度微服务 |
@@ -126,12 +133,12 @@ ad build
 
 ## 架构集成
 
-作为顶层门面，`@actiondock/cli` 串联以下子包：
+作为顶层门面与独立运行分发器，`@actiondock/cli` 串联以下子包：
 
-- 运行时适配：依赖 `@actiondock/runtime-node`，在启动时自动注入基于 Node.js 原生能力的驱动实现。
-- 共享命令集：复用 `@actiondock/runtime-cli` 的命令处理器与标准信封输出渲染器。
-- 构建与打包：调用 `@actiondock/builder` 完成依赖闭包分析与产物装配。
-- 协议服务：通过 `@actiondock/mcp` 与 `@actiondock/core` 启动协议监听。
+- 运行时适配：依赖 [@actiondock/runtime-node](../runtime-node/README.md)，在启动时自动注入基于 Node.js 原生能力的驱动实现。
+- 领域内核：依赖 [@actiondock/core](../core/README.md)，调度统一调用门面 ActionDockTarget、数据目录锁 DataDirLock 与依赖事务管理器。
+- 构建与打包：依赖 [@actiondock/builder](../builder/README.md)，完成目录交付构建、npm 打包与技能导出。
+- 协议服务：通过 [@actiondock/mcp](../mcp/README.md) 启动协议监听。
 
 ---
 

package/bin/ad.js

@@ -1,55 +1,42 @@
 #!/usr/bin/env node
 import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
+import { resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-const isBun = typeof process.versions.bun !== "undefined";
+const distEntry = resolve(import.meta.dirname, "../dist/index.js");
 
-// 本进程是否已挂载 tsx 引导器。execArgv 不会被子进程继承，必须逐进程检测；
-// 严禁改用环境变量判断：Action 内嵌套调度的 ad 子进程会继承父进程环境变量，
-// 却不继承 --import，误判为已引导后会直接 import node_modules 下的 TS 源码，
-// 触发 ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING。
-// 注意也不能依赖 Node 原生类型剥离：它拒绝 node_modules 下的文件，且不支持源码中的目录导入。
-const hasTsx =
-  process.execArgv.some((arg, i) => arg === "--import" && process.execArgv[i + 1]?.includes("tsx")) ||
-  process.execArgv.some((arg) => arg.includes("tsx"));
+if (existsSync(distEntry)) {
+  const { main } = await import(pathToFileURL(distEntry).href);
+  await main(process.argv);
+} else {
+  const isBun = typeof process.versions.bun !== "undefined";
+  const hasTsx =
+    process.execArgv.some((arg, i) => arg === "--import" && process.execArgv[i + 1]?.includes("tsx")) ||
+    process.execArgv.some((arg) => arg.includes("tsx"));
 
-if (!isBun && !hasTsx) {
-  const require = createRequire(import.meta.url);
-  let tsxSpecifier = "tsx";
-  try {
-    tsxSpecifier = pathToFileURL(require.resolve("tsx")).href;
-  } catch {
+  if (!isBun && !hasTsx) {
+    const require = createRequire(import.meta.url);
+    let tsxSpecifier = null;
     try {
-      const runtimeNodePkg = require.resolve("@actiondock/runtime-node/package.json");
-      const runtimeReq = createRequire(runtimeNodePkg);
-      tsxSpecifier = pathToFileURL(runtimeReq.resolve("tsx")).href;
+      tsxSpecifier = pathToFileURL(require.resolve("tsx")).href;
     } catch {
-      // 回退为裸模块名
+      // 未检测到 tsx 模块
     }
-  }
-
-  const extraArgs = [];
-  const [major, minor] = (process.versions.node || "").split(".").map(Number);
-  if (major === 22 && minor < 13) {
-    extraArgs.push("--experimental-sqlite");
-  }
 
-  const res = spawnSync(
-    process.execPath,
-    ["--import", tsxSpecifier, ...extraArgs, fileURLToPath(import.meta.url), ...process.argv.slice(2)],
-    {
-      stdio: "inherit",
+    if (tsxSpecifier) {
+      const res = spawnSync(
+        process.execPath,
+        ["--import", tsxSpecifier, fileURLToPath(import.meta.url), ...process.argv.slice(2)],
+        {
+          stdio: "inherit",
+        }
+      );
+      process.exit(res.status ?? (res.signal ? 1 : 0));
     }
-  );
-  process.exit(res.status ?? (res.signal ? 1 : 0));
-}
+  }
 
-let main;
-try {
-  ({ main } = await import("../dist/index.js"));
-} catch {
-  ({ main } = await import("../src/index.ts"));
+  const { main } = await import("../src/index.ts");
+  await main(process.argv);
 }
-await main(process.argv);
-

package/dist/commands/action/create.d.ts

@@ -1,2 +1,10 @@
 import type { Command } from "commander";
-export declare function registerActionCreateCommand(actionCmd: Command): void;
+import type { CliContext } from "../../types.js";
+/**
+ * 注册 action 命令组（action create, action new）。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export declare function registerActionCommands(program: Command, context?: CliContext): void;
+export declare function handleActionCreate(id: string, options: any, context?: CliContext): Promise<void>;

package/dist/commands/action/create.js

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { assertPathWithinRoot, checkGeneratedTypes, findProjectRoot, getPackageSlug, loadManifest, loadProjectConfig, saveManifest, writeActionTypes, } from "@actiondock/core";
+import { ExecutionError } from "../../errors.js";
+import { writeStdout } from "../../renderer.js";
+/**
+ * 注册 action 命令组（action create, action new）。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export function registerActionCommands(program, context) {
+    const actionCmd = program
+        .command("action")
+        .description("Manage Action definitions (create, scaffold)");
+    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) => {
+        await handleActionCreate(id, options, context);
+    });
+}
+export async function handleActionCreate(id, options, context) {
+    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 });
+        }
+        if (options.file && isAbsolute(options.file)) {
+            throw new ExecutionError(`--file option must be a relative path, received: ${options.file}`);
+        }
+        const cleanName = getPackageSlug(id);
+        const targetRelFile = options.file || `${cleanName}.ts`;
+        const targetFullFile = resolve(actionsDir, targetRelFile);
+        assertPathWithinRoot(actionsDir, targetFullFile, "action file");
+        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>(async (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) || {
+            $schema: "https://actiondock.dev/schema/v2/actiondock.json",
+            id: config.id,
+            name: config.name,
+            version: config.version,
+            actions: {},
+        };
+        manifest.actions = manifest.actions || {};
+        manifest.actions[id] = {
+            entry: join(config.actionsDir || "actions", targetRelFile).replace(/\\/g, "/"),
+            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);
+        // 若当前项目已存在类型生成文件，则同步自动刷新类型声明
+        const typeCheck = checkGeneratedTypes(root, manifest);
+        if (typeCheck.exists) {
+            writeActionTypes(root, manifest);
+        }
+        writeStdout(`[OK] Created Action '${id}' at ${targetFullFile}`, context);
+        writeStdout(`\nTo run this action:`, context);
+        writeStdout(`  ad run ${id} --input '{"exampleParam": "hello"}'`, context);
+    }
+    catch (err) {
+        if (err instanceof ExecutionError)
+            throw err;
+        throw new ExecutionError(err.message);
+    }
+}

package/dist/commands/add.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册 ad add 依赖安装命令。
+ * 遵循规范：安装并锁定依赖，更新 package.json、actiondock.json 与 actiondock.lock.json，执行原子事务快照保护。
+ */
+export declare function registerAddCommand(program: Command, context?: CliContext): void;

package/dist/commands/add.js

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { ActionPackageResolver, beginTransaction, computeManifestDigest, findProjectRoot, getInstallCommand, loadLockfile, loadManifest, MANIFEST_FILE_NAME, parseJsonWithoutDuplicates, saveLockfile, saveManifest, } from "@actiondock/core";
+import { ArgumentError, ExecutionError } from "../errors.js";
+import { renderResult } from "../renderer.js";
+import { getEffectiveOptions, spawnAsync } from "../utils/index.js";
+/**
+ * 从安装说明符中提取基础 npm 包名（去除版本号及前缀范围）。
+ */
+function extractNpmPackageName(spec) {
+    const clean = spec.trim();
+    if (clean.startsWith("@")) {
+        const slashIdx = clean.indexOf("/");
+        if (slashIdx !== -1) {
+            const atIdx = clean.indexOf("@", slashIdx + 1);
+            return atIdx !== -1 ? clean.slice(0, atIdx) : clean;
+        }
+    }
+    else {
+        const atIdx = clean.indexOf("@");
+        return atIdx !== -1 ? clean.slice(0, atIdx) : clean;
+    }
+    return clean;
+}
+/**
+ * 注册 ad add 依赖安装命令。
+ * 遵循规范：安装并锁定依赖，更新 package.json、actiondock.json 与 actiondock.lock.json，执行原子事务快照保护。
+ */
+export function registerAddCommand(program, context) {
+    program
+        .command("add <package>")
+        .description("Install and lock an Action package dependency into current project")
+        .option("--allow-install-scripts", "Explicitly allow lifecycle install scripts from third-party packages")
+        .option("-D, --dev", "Install package as development dependency")
+        .option("-P, --package <path>", "Target project directory path")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action(async (packageSpec, rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const root = options.package ? resolve(options.package) : findProjectRoot();
+        if (!root) {
+            throw new ArgumentError("Not in an ActionDock project (actiondock.json not found).\nPlease specify -P, --package <path> or cd into a project directory.");
+        }
+        const manifest = loadManifest(root);
+        if (!manifest) {
+            throw new ArgumentError(`actiondock.json not found in ${root}`);
+        }
+        const npmPackageName = extractNpmPackageName(packageSpec);
+        // 获取排他修改锁并创建事务快照
+        const tx = await beginTransaction(root, `ad add ${packageSpec}`);
+        try {
+            // 调用包管理器执行安装（默认禁用生命周期安装脚本）
+            const installCmd = getInstallCommand(root);
+            const pm = installCmd[0];
+            const args = [];
+            if (pm === "bun") {
+                args.push("add", packageSpec);
+                if (options.dev) {
+                    args.push("--dev");
+                }
+                if (!options.allowInstallScripts) {
+                    args.push("--ignore-scripts");
+                }
+            }
+            else {
+                args.push("install", packageSpec);
+                if (options.dev) {
+                    args.push("--save-dev");
+                }
+                if (!options.allowInstallScripts) {
+                    args.push("--ignore-scripts");
+                }
+            }
+            const installProc = await spawnAsync(pm, args, {
+                cwd: root,
+                stdio: "pipe",
+            });
+            if (installProc.status !== 0) {
+                const errMsg = installProc.stderr?.toString() || installProc.stdout?.toString() || "Unknown error";
+                throw new Error(`Failed to install '${packageSpec}' using ${pm}: ${errMsg}`);
+            }
+            // 寻址已安装包的 actiondock.json 清单
+            let targetManifestPath = join(root, "node_modules", npmPackageName, MANIFEST_FILE_NAME);
+            if (!existsSync(targetManifestPath)) {
+                targetManifestPath = join(root, "node_modules", packageSpec, MANIFEST_FILE_NAME);
+            }
+            if (!existsSync(targetManifestPath)) {
+                throw new Error(`Target package '${npmPackageName}' does not contain '${MANIFEST_FILE_NAME}'. It is not a valid ActionDock package.`);
+            }
+            const targetRaw = readFileSync(targetManifestPath, "utf-8");
+            const targetManifest = parseJsonWithoutDuplicates(targetRaw);
+            const targetDigest = computeManifestDigest(targetManifest);
+            const targetPackageId = targetManifest.id;
+            const targetVersion = targetManifest.version || "0.1.0";
+            // 更新 actiondock.json.dependencies 映射
+            manifest.dependencies = manifest.dependencies || {};
+            manifest.dependencies[targetPackageId] =
+                targetPackageId === npmPackageName ? `^${targetVersion}` : npmPackageName;
+            // 触发依赖图解析及版本冲突检测
+            const resolver = new ActionPackageResolver({ projectRoot: root, manifest });
+            const graph = resolver.resolveSync();
+            // 更新 actiondock.lock.json
+            const lockfile = loadLockfile(root) || {
+                lockfileVersion: 1,
+                packages: {},
+            };
+            for (const pkg of graph.packages.values()) {
+                if (!pkg.isRoot) {
+                    lockfile.packages[pkg.packageId] = {
+                        package: pkg.npmPackage,
+                        resolved: pkg.version,
+                        source: "npm",
+                        packageId: pkg.packageId,
+                        npmPackage: pkg.npmPackage,
+                        version: pkg.version,
+                        manifestDigest: pkg.manifestDigest,
+                        dependencies: pkg.manifest.dependencies || {},
+                    };
+                }
+            }
+            // 写入清单与锁文件
+            saveManifest(root, manifest);
+            saveLockfile(root, lockfile);
+            // 提交事务
+            await tx.commit();
+            const resultPayload = {
+                packageId: targetPackageId,
+                npmPackage: npmPackageName,
+                version: targetVersion,
+                manifestDigest: targetDigest,
+            };
+            renderResult(resultPayload, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => `Successfully added and locked '${resultPayload.packageId}' (v${resultPayload.version}) from ${resultPayload.npmPackage}.`,
+                context,
+            });
+        }
+        catch (err) {
+            await tx.rollback({ frozenInstall: false });
+            throw new ExecutionError(err.message, err, err.code || "ADD_DEPENDENCY_FAILED");
+        }
+    });
+}

package/dist/commands/build.d.ts

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

package/dist/commands/build.js

@@ -0,0 +1,83 @@
+import { findProjectRoot, resolvePackageRoot } from "@actiondock/core";
+import { ExecutionError } from "../errors.js";
+import { renderResult, writeStdout } from "../renderer.js";
+import { getEffectiveOptions, parseListOption } from "../utils/index.js";
+export function registerBuildCommand(program, context) {
+    program
+        .command("build")
+        .description("Build project actions into a runnable Node.js delivery directory")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("-o, --out <path>", "Output directory (or archive path)")
+        .option("-a, --actions <actions...>", "Only build specific action(s)", parseListOption)
+        .option("-p, --playbooks <playbooks...>", "Only build specific playbook(s)", parseListOption)
+        .option("-z, --archive", "Create a standard zip archive of the build directory")
+        .option("--vendor-deps", "Materialize locked production dependencies into the output")
+        .option("--allow-install-scripts", "Allow lifecycle install scripts to run during vendor-deps")
+        .option("--require-reproducible", "Require reproducible build and fail if install scripts must run")
+        .option("-t, --target <target>", "Target compilation platform (removed)")
+        .option("--bytecode", "Bytecode compilation (removed)")
+        .action(async (rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        // 彻底删除原有单文件二进制输出语义
+        if (options.target !== undefined || options.bytecode !== undefined) {
+            throw new ExecutionError("Unsupported build mode: '--target' and '--bytecode' standalone single-file binary compilation have been removed in ActionDock 2.0. Directory-based Node.js builds are now the standard distribution format.", undefined, "UNSUPPORTED_BUILD_MODE");
+        }
+        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.");
+        }
+        const isMachine = Boolean(options.json || options.envelope);
+        if (!isMachine) {
+            writeStdout("Building Node.js delivery artifact...");
+        }
+        let result;
+        try {
+            const { buildProject } = await import("@actiondock/builder");
+            result = await buildProject({
+                projectRoot: root,
+                outDir: options.out,
+                actions: options.actions,
+                playbooks: options.playbooks,
+                archive: options.archive,
+                vendorDeps: options.vendorDeps,
+                allowInstallScripts: options.allowInstallScripts,
+                requireReproducible: options.requireReproducible,
+            });
+        }
+        catch (err) {
+            if (err?.code === "UNSUPPORTED_BUILD_MODE") {
+                throw new ExecutionError(err.message, undefined, "UNSUPPORTED_BUILD_MODE");
+            }
+            throw new ExecutionError(`Build failed: ${err.message}`);
+        }
+        renderResult(result, {
+            json: isMachine,
+            envelope: options.envelope,
+            humanFormatter: () => {
+                const lines = [];
+                lines.push(`[OK] Successfully built ${result.packageId} (v${result.version})`);
+                lines.push(`  Output:       ${result.outputDir}`);
+                lines.push(`  Entrypoint:   ${result.entrypointPath}`);
+                lines.push(`  Actions:      ${result.actions.join(", ")}`);
+                if (result.playbooks.length > 0) {
+                    lines.push(`  Playbooks:    ${result.playbooks.join(", ")}`);
+                }
+                lines.push(`  Vendor Deps:  ${result.vendorDeps}`);
+                lines.push(`  Reproducible: ${result.reproducible}`);
+                if (result.archivePath) {
+                    lines.push(`  Archive:      ${result.archivePath}`);
+                }
+                if (result.metadataPath) {
+                    lines.push(`  Metadata:     ${result.metadataPath}`);
+                }
+                return lines.join("\n");
+            },
+            context,
+        });
+    });
+}

package/dist/commands/config/delete.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "commander";
+import type { CliContext } from "../../types.js";
+/**
+ * 注册 config delete 子命令：删除配置项。
+ *
+ * @param configCmd config 命令实例
+ * @param context 命令行上下文
+ */
+export declare function registerConfigDeleteCommand(configCmd: Command, context?: CliContext): void;