@actiondock/core 2.12.0 → 2.14.0

package/dist/project/skill-dir.d.ts

@@ -0,0 +1,56 @@
+import type { ProjectConfig } from "./types.js";
+/**
+ * 本地封闭包条目。
+ */
+export interface LocalPackageEntry {
+    packageId: string;
+    packageRoot: string;
+    projectConfig: ProjectConfig;
+}
+/**
+ * 本地技能 / 包目录发现视图。
+ */
+export interface LocalSkillDirectory {
+    type: "single" | "composite";
+    root: string;
+    packages: LocalPackageEntry[];
+}
+/**
+ * 判定路径字符串是否为显式文件/目录路径形态（而非包标识符）。
+ *
+ * 规则：
+ * - 以 .、/、~ 开头；
+ * - 包含 / 或 \\，且不是 scoped 包（@scope/name 仅含一个 /）；
+ * - scoped 包若包含反斜杠或多于一个 /，亦视作路径。
+ */
+export declare function isExplicitPath(p: string): boolean;
+/**
+ * 对明确的本地封闭包集合实施一致性校验。
+ *
+ * 校验规则：
+ * - 重复包标识防护：集合内不得存在相同 packageId；
+ * - 依赖存在性与版本兼容性：声明的直接依赖必须在集合内存在且满足语义版本约束（复用 PackageGraphBuilder）；
+ * - 跨包 uses 目标完整性：uses 声明引用的目标包与目标 Action 必须在集合内存在。
+ *
+ * @param packages 封闭包条目集合
+ */
+export declare function validateLocalSkillPackages(packages: Array<{
+    packageId: string;
+    packageRoot: string;
+    projectConfig: ProjectConfig;
+}>): void;
+/**
+ * 探测指定路径是否为本地 Skill / 包目录（支持单包根目录与 packages/* 复合套件布局）。
+ *
+ * 封闭包装配与校验规则：
+ * - 边界安全防护：packages 目录、各子包目录与 actiondock.json 清单真实路径必须在 Skill 根边界内，禁止越界符号链接；
+ * - 单包布局：目录根部存在 actiondock.json，解析为包含单一包的 LocalSkillDirectory；
+ * - 复合布局：目录根部存在 packages/ 目录，遍历其直接子目录，收集包含 actiondock.json 的子包；
+ * - 集合一致性校验：通过 validateLocalSkillPackages 严格核查依赖闭包、版本兼容与 uses 目标；
+ * - 异常透传：坏清单或权限异常原样抛出，严禁静默回退 Registry；
+ * - 若非候选技能目录，返回 null。
+ *
+ * @param directoryPath 待检查的目录路径（相对路径将基于 cwd 解析）
+ * @param cwd 解析基准工作目录（默认为 process.cwd()）
+ */
+export declare function inspectLocalPackageDirectory(directoryPath: string, cwd?: string): LocalSkillDirectory | null;

package/dist/project/skill-dir.js

@@ -0,0 +1,214 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { ActionDockError, ACTION_NOT_FOUND, PACKAGE_NOT_FOUND, PACKAGE_ID_CONFLICT, } from "../errors.js";
+import { loadProjectConfig } from "./loader.js";
+import { PackageGraphBuilder } from "../catalog/graph.js";
+import { parseActionRef } from "../catalog/resolve-action.js";
+import { createPackageIdentity } from "../runtime/identity.js";
+/**
+ * 判定路径字符串是否为显式文件/目录路径形态（而非包标识符）。
+ *
+ * 规则：
+ * - 以 .、/、~ 开头；
+ * - 包含 / 或 \\，且不是 scoped 包（@scope/name 仅含一个 /）；
+ * - scoped 包若包含反斜杠或多于一个 /，亦视作路径。
+ */
+export function isExplicitPath(p) {
+    if (!p)
+        return false;
+    if (p.startsWith("@")) {
+        const slashCount = (p.match(/\//g) || []).length;
+        return slashCount > 1 || p.includes("\\");
+    }
+    return (p.startsWith(".") ||
+        p.startsWith("/") ||
+        p.startsWith("~") ||
+        p.includes("/") ||
+        p.includes("\\"));
+}
+/**
+ * 对明确的本地封闭包集合实施一致性校验。
+ *
+ * 校验规则：
+ * - 重复包标识防护：集合内不得存在相同 packageId；
+ * - 依赖存在性与版本兼容性：声明的直接依赖必须在集合内存在且满足语义版本约束（复用 PackageGraphBuilder）；
+ * - 跨包 uses 目标完整性：uses 声明引用的目标包与目标 Action 必须在集合内存在。
+ *
+ * @param packages 封闭包条目集合
+ */
+export function validateLocalSkillPackages(packages) {
+    if (!packages || packages.length === 0)
+        return;
+    // 1. 重复 packageId 校验
+    const seenIds = new Set();
+    for (const pkg of packages) {
+        if (seenIds.has(pkg.packageId)) {
+            throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${pkg.packageId}' is declared more than once in skill packages`);
+        }
+        seenIds.add(pkg.packageId);
+    }
+    // 2. 构造包发现视图并交由 PackageGraphBuilder 校验依赖与版本
+    const discovered = packages.map((pkg) => ({
+        id: pkg.packageId,
+        root: pkg.packageRoot,
+        manifest: pkg.projectConfig,
+        identity: createPackageIdentity({
+            id: pkg.packageId,
+            instanceId: `${pkg.packageId}:${pkg.packageRoot}`,
+            generation: "skill-local",
+        }),
+        isCurrentProject: true,
+    }));
+    const builder = new PackageGraphBuilder({
+        packages: discovered,
+        validateDependencies: true,
+    });
+    builder.buildSync();
+    // 3. uses 声明目标存在性校验
+    const pkgMap = new Map();
+    for (const pkg of packages) {
+        pkgMap.set(pkg.packageId, pkg.projectConfig);
+    }
+    const validateUseRef = (rawRef, caller, currentPkg) => {
+        if (typeof rawRef !== "string" || !rawRef.trim())
+            return;
+        const trimmed = rawRef.trim();
+        // 先按完整包身份识别裸包引用，包括 scoped 包。
+        if (pkgMap.has(trimmed)) {
+            return;
+        }
+        // 裸 scoped 包只有一个斜杠，不能按限定动作拆分。
+        if (trimmed.startsWith("@") && (trimmed.match(/\//g) || []).length === 1) {
+            throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${trimmed}' referenced by uses in '${caller}' was not found in skill directory`);
+        }
+        // 限定动作与包级通配符复用统一引用解析器。
+        if (trimmed.includes("/")) {
+            const ref = parseActionRef(trimmed);
+            const targetPkgId = ref.packageId;
+            const targetActionId = ref.actionId;
+            const targetPkg = pkgMap.get(targetPkgId);
+            if (!targetPkg) {
+                throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${targetPkgId}' referenced by uses in '${caller}' was not found in skill directory`);
+            }
+            if (targetActionId !== "*") {
+                const hasAction = Boolean(targetPkg.actions && targetPkg.actions[targetActionId]);
+                if (!hasAction) {
+                    throw new ActionDockError(ACTION_NOT_FOUND, `Action '${targetActionId}' referenced by uses in '${caller}' was not found in package '${targetPkgId}'`);
+                }
+            }
+            return;
+        }
+        // 本包短动作引用。
+        if (currentPkg.actions && currentPkg.actions[trimmed]) {
+            return;
+        }
+        // 目标不存在。
+        throw new ActionDockError(PACKAGE_NOT_FOUND, `Package or action '${trimmed}' referenced by uses in '${caller}' was not found in skill directory`);
+    };
+    for (const pkg of packages) {
+        const pkgUses = pkg.projectConfig.uses;
+        if (Array.isArray(pkgUses)) {
+            for (const ref of pkgUses) {
+                validateUseRef(ref, `package '${pkg.packageId}'`, pkg.projectConfig);
+            }
+        }
+        if (pkg.projectConfig.actions && typeof pkg.projectConfig.actions === "object") {
+            for (const [actionId, actionEntry] of Object.entries(pkg.projectConfig.actions)) {
+                if (actionEntry && Array.isArray(actionEntry.uses)) {
+                    for (const ref of actionEntry.uses) {
+                        validateUseRef(ref, `action '${pkg.packageId}/${actionId}'`, pkg.projectConfig);
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * 探测指定路径是否为本地 Skill / 包目录（支持单包根目录与 packages/* 复合套件布局）。
+ *
+ * 封闭包装配与校验规则：
+ * - 边界安全防护：packages 目录、各子包目录与 actiondock.json 清单真实路径必须在 Skill 根边界内，禁止越界符号链接；
+ * - 单包布局：目录根部存在 actiondock.json，解析为包含单一包的 LocalSkillDirectory；
+ * - 复合布局：目录根部存在 packages/ 目录，遍历其直接子目录，收集包含 actiondock.json 的子包；
+ * - 集合一致性校验：通过 validateLocalSkillPackages 严格核查依赖闭包、版本兼容与 uses 目标；
+ * - 异常透传：坏清单或权限异常原样抛出，严禁静默回退 Registry；
+ * - 若非候选技能目录，返回 null。
+ *
+ * @param directoryPath 待检查的目录路径（相对路径将基于 cwd 解析）
+ * @param cwd 解析基准工作目录（默认为 process.cwd()）
+ */
+export function inspectLocalPackageDirectory(directoryPath, cwd) {
+    if (!directoryPath || typeof directoryPath !== "string") {
+        return null;
+    }
+    const absDir = resolve(cwd || process.cwd(), directoryPath);
+    if (!existsSync(absDir)) {
+        return null;
+    }
+    try {
+        const stat = statSync(absDir);
+        if (!stat.isDirectory()) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    // 单包布局：根目录包含 actiondock.json
+    const rootManifest = join(absDir, "actiondock.json");
+    if (existsSync(rootManifest)) {
+        const config = loadProjectConfig(absDir);
+        const packages = [
+            {
+                packageId: config.id,
+                packageRoot: absDir,
+                projectConfig: config,
+            },
+        ];
+        validateLocalSkillPackages(packages);
+        return {
+            type: "single",
+            root: absDir,
+            packages,
+        };
+    }
+    // 复合 Skill 布局：存在 packages/ 目录且包含至少一个有效子包
+    const packagesDir = join(absDir, "packages");
+    if (existsSync(packagesDir)) {
+        const pStat = statSync(packagesDir);
+        if (pStat.isDirectory()) {
+            const entries = readdirSync(packagesDir, { withFileTypes: true });
+            const packages = [];
+            const seenIds = new Set();
+            entries.sort((a, b) => a.name.localeCompare(b.name));
+            for (const entry of entries) {
+                const subDir = join(packagesDir, entry.name);
+                const sStat = statSync(subDir);
+                if (sStat.isDirectory()) {
+                    const subManifest = join(subDir, "actiondock.json");
+                    if (existsSync(subManifest)) {
+                        const childConfig = loadProjectConfig(subDir);
+                        if (seenIds.has(childConfig.id)) {
+                            throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${childConfig.id}' is declared more than once in skill directory '${absDir}'`);
+                        }
+                        seenIds.add(childConfig.id);
+                        packages.push({
+                            packageId: childConfig.id,
+                            packageRoot: subDir,
+                            projectConfig: childConfig,
+                        });
+                    }
+                }
+            }
+            if (packages.length > 0) {
+                validateLocalSkillPackages(packages);
+                return {
+                    type: "composite",
+                    root: absDir,
+                    packages,
+                };
+            }
+        }
+    }
+    return null;
+}

package/dist/project/types.d.ts

@@ -75,6 +75,8 @@ export interface ActionDockManifest {
     actions?: Record<string, ActionManifestEntry>;
     /** 声明的 Playbooks 集合（唯一事实源） */
     playbooks?: Record<string, PlaybookManifestEntry>;
+    /** 包级静态依赖引用，与 Action 的 uses 共用引用语义。 */
+    uses?: string[];
     /** 跨包外部依赖映射（逻辑包 ID 到 npm 包名） */
     dependencies?: Record<string, string>;
     /** 框架导出与分发边界文件列表 */

package/dist/registry/registry.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from "node:
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { findProjectRoot, loadProjectConfig } from "../project/loader.js";
+import { inspectLocalPackageDirectory, isExplicitPath } from "../project/skill-dir.js";
 import { getActionDockHome, getPackageSlug } from "../utils/index.js";
 import { ActionDockError, MANIFEST_NOT_FOUND, REGISTRY_CORRUPTED } from "../errors.js";
 import { withRegistryLock } from "./lock.js";
@@ -399,31 +400,42 @@ export function resolvePackageRoot(packageIdOrPath, cwd, customHome) {
     const resolvedPath = resolve(baseDir, packageIdOrPath);
     // 检查 packageIdOrPath 是否为磁盘上现存的目录或文件路径
     if (existsSync(resolvedPath)) {
+        let info;
         try {
-            const info = statSync(resolvedPath);
+            info = statSync(resolvedPath);
+        }
+        catch (err) {
+            if (err?.code !== "ENOENT" && err?.code !== "ENOTDIR") {
+                throw err;
+            }
+        }
+        if (info) {
             const targetDir = info.isDirectory() ? resolvedPath : dirname(resolvedPath);
+            // 普通开发包根目录：直接包含 actiondock.json 清单。
+            // 普通清单根目录定位与封闭 Skill 执行校验分离，不能被当成只含一个包的 Skill 闭包拒绝。
             if (existsSync(join(targetDir, "actiondock.json"))) {
+                loadProjectConfig(targetDir);
                 return targetDir;
             }
-            const parentRoot = findProjectRoot(targetDir);
-            if (parentRoot) {
-                return parentRoot;
+            // 复合技能布局：根目录下存在 packages/ 目录且包含有效子包。
+            const localSkill = inspectLocalPackageDirectory(targetDir);
+            if (localSkill) {
+                return localSkill.root;
+            }
+            // 具体文件查找所属工程根目录：仅当 packageIdOrPath 指向具体文件（非目录）时，
+            // 才尝试向上查找所属工程根目录；目录形态绝不向上回退，防止显式目录越界命中父级工程。
+            if (!info.isDirectory()) {
+                const parentRoot = findProjectRoot(targetDir);
+                if (parentRoot) {
+                    loadProjectConfig(parentRoot);
+                    return parentRoot;
+                }
             }
-        }
-        catch {
-            // stat 失败（如并发删除）：忽略并继续走标识符解析路径
         }
     }
     // 显式路径形态但未解析成功的场景：
     // scoped package 标识符（如 @team/tools）虽含 '/' 但属于包 ID 而非文件路径
-    const isScopedPackage = packageIdOrPath.startsWith("@");
-    const isExplicitPath = !isScopedPackage &&
-        (packageIdOrPath.startsWith(".") ||
-            packageIdOrPath.startsWith("/") ||
-            packageIdOrPath.startsWith("~") ||
-            packageIdOrPath.includes("/") ||
-            packageIdOrPath.includes("\\"));
-    if (isExplicitPath) {
+    if (isExplicitPath(packageIdOrPath)) {
         // 显式路径不存在或不是 ActionDock 项目时必须失败，禁止静默回退
         return null;
     }

package/dist/runtime/action-collection.js

@@ -22,6 +22,7 @@ export function normalizeActionCollection(rawActions) {
                 description: v.description,
                 inputSchema: v.inputSchema,
                 outputSchema: v.outputSchema,
+                annotations: v.annotations,
             };
         }
         return { actionsMap, actionSpecs };
@@ -37,6 +38,7 @@ export function normalizeActionCollection(rawActions) {
                     description: item.description ?? act.description,
                     inputSchema: item.inputSchema ?? act.inputSchema,
                     outputSchema: item.outputSchema ?? act.outputSchema,
+                    annotations: item.annotations ?? act.annotations,
                 };
             }
         }
@@ -50,6 +52,7 @@ export function normalizeActionCollection(rawActions) {
                 description: v.description,
                 inputSchema: v.inputSchema,
                 outputSchema: v.outputSchema,
+                annotations: v.annotations,
             };
         }
     }

package/dist/runtime/standalone-commands.js

@@ -29,7 +29,7 @@ export async function handleList(ctx, subArgs) {
     const effectiveIntent = intent || (positionalPatterns.length > 0 ? positionalPatterns.join("|") : undefined);
     const actions = await ctx.service.discovery.listActions();
     const list = actions.map((a) => ({
-        id: a.id,
+        id: ctx.options.multiPackage && a.packageId && !a.id.includes("/") ? `${a.packageId}/${a.id}` : a.id,
         description: a.description || "",
     }));
     const filterRes = filterWithFallbackInfo(list, effectiveIntent, [(a) => a.id, (a) => a.description], !noFallback);
@@ -66,13 +66,13 @@ export async function handleDescribe(ctx, subArgs) {
         });
     }
     const payload = buildActionDescribePayload(action, {
-        packageId: ctx.options.packageId,
+        packageId: action.packageId || ctx.options.packageId,
     });
     if (isJson) {
         ctx.writeOut(JSON.stringify(payload, null, 2));
     }
     else {
-        ctx.writeOut(formatActionDetail(payload));
+        ctx.writeOut(formatActionDetail(payload, { supportsTextField: false }));
     }
     return ExitCode.SUCCESS;
 }
@@ -84,6 +84,7 @@ export async function handleRun(ctx, subArgs, actionArgs, signal) {
     }
     let inputStr;
     let inputFile;
+    let stdinField;
     let timeoutMs;
     const recognizedFlags = new Set(["--json", "--async"]);
     for (let i = 0; i < subArgs.length; i++) {
@@ -131,6 +132,12 @@ export async function handleRun(ctx, subArgs, actionArgs, signal) {
         else if (arg.startsWith("-f=")) {
             inputFile = arg.slice(3);
         }
+        else if (arg === "--stdin-field" && i + 1 < subArgs.length) {
+            stdinField = subArgs[++i];
+        }
+        else if (arg.startsWith("--stdin-field=")) {
+            stdinField = arg.slice(14);
+        }
         else if (arg.startsWith("-")) {
             const hint = "Hint: Separate action inputs from CLI options using '--', e.g.: ad run <id> [options] -- <param>=<val> or <param>:=<json>.";
             return ctx.emitError(isJson, "INVALID_ARGUMENT", `error: unknown option '${arg}'`, ExitCode.INVALID_ARGUMENT, {
@@ -144,8 +151,10 @@ export async function handleRun(ctx, subArgs, actionArgs, signal) {
         input = await resolveActionInput({
             input: inputStr,
             inputFile,
+            stdinField,
             flatArgs: actionArgs.length > 0 ? actionArgs : undefined,
             stdin: process.stdin,
+            signal,
         });
         const check = validateActionInputValue(input);
         if (!check.valid) {
@@ -265,6 +274,9 @@ function isServiceCapabilityError(err) {
         code === "TARGET_CAPABILITY_UNAVAILABLE");
 }
 export async function handleConfig(ctx, subArgs) {
+    if (ctx.options.multiPackage) {
+        return ctx.emitError(subArgs.includes("--json"), "CAPABILITY_UNAVAILABLE", "Multi-package entries do not support config/state management; configure actions using --config and --data-dir.", ExitCode.INVALID_ARGUMENT);
+    }
     const sub = subArgs[0] || "list";
     if (!ctx.service.management) {
         ctx.writeErr("Error: management port is not enabled on this service");
@@ -341,6 +353,9 @@ function decodeStateKeyArg(key) {
     }
 }
 export async function handleState(ctx, subArgs) {
+    if (ctx.options.multiPackage) {
+        return ctx.emitError(subArgs.includes("--json"), "CAPABILITY_UNAVAILABLE", "Multi-package entries do not support config/state management; configure actions using --config and --data-dir.", ExitCode.INVALID_ARGUMENT);
+    }
     const sub = subArgs[0] || "list";
     let namespace;
     let isAll = false;

package/dist/runtime/standalone-help.js

@@ -42,6 +42,8 @@ export function printHelp(writeOut, options) {
     writeOut("  <cmd> describe <id> [--json]                Show action details and schemas");
     writeOut("  <cmd> run <id> [--input '<json>']           Execute action (raw text output by default)");
     writeOut("  <cmd> run <id> [--json]                     Output standard execution result in JSON format");
+    writeOut("  <cmd> run <id> [--stdin-field <field>] [-- <assignments...>]");
+    writeOut("                                             Bind raw stdin text to an input field");
     writeOut("  <cmd> config list/get/set/delete            Manage package configuration");
     writeOut("  <cmd> state list/get/set/delete             Manage shared state store");
     writeOut("\nGlobal options:");

package/dist/runtime/standalone.d.ts

@@ -24,6 +24,8 @@ export interface InvocationControl {
 export interface StandaloneDispatcherOptions {
     /** 所属 Package ID */
     packageId: string;
+    /** 多包入口使用完全限定发现标识，不以展示名操作配置和状态。 */
+    multiPackage?: boolean;
     /** 版本号 */
     version: string;
     /** 描述信息 */

package/dist/storage/sqlite-driver.d.ts

@@ -1,4 +1,3 @@
-import "../utils/warning.js";
 import type { DatabaseSync } from "node:sqlite";
 import { normalizeSqliteParams } from "./params.js";
 import type { SqliteDriver, SqliteStatement } from "./types.js";

package/dist/storage/sqlite-driver.js

@@ -1,4 +1,3 @@
-import "../utils/warning.js";
 import { normalizeSqliteParams } from "./params.js";
 import { ActionDockError, ASYNC_TRANSACTION_UNSUPPORTED, STORAGE_CLOSED } from "../errors.js";
 // 基于原生 ESM Top-Level Await 在模块评估期动态加载，确保警告静默拦截器优先就绪且保持纯正 ESM 架构

package/dist/utils/index.d.ts

@@ -104,4 +104,3 @@ export declare function assertPathWithinRoot(rootDir: string, targetPath: string
  * Backwards-compatible alias for assertPathWithinRoot targeting project roots.
  */
 export declare function assertWithinProjectRoot(projectRoot: string, subDir: string, fieldName: string): void;
-export { suppressExperimentalWarnings } from "./warning.js";

package/dist/utils/index.js

@@ -281,4 +281,3 @@ export function assertWithinProjectRoot(projectRoot, subDir, fieldName) {
     }
     assertPathWithinRoot(projectRoot, subDir, fieldName);
 }
-export { suppressExperimentalWarnings } from "./warning.js";

package/dist/utils/semver.d.ts

@@ -6,10 +6,11 @@ export interface SemVer {
     minor: number;
     patch: number;
     prerelease?: string;
+    build?: string;
 }
 /**
  * 解析基础 SemVer 版本字符串（单一事实源）。
- * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀；
+ * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀与构建元数据；
  * 其余形态（两段式、非数值等）返回 null，由调用方自行兜底。
  *
  * 本模块不依赖任何 Node 内建与 core 领域模块，可在无 loader 的原生

package/dist/utils/semver.js

@@ -1,19 +1,25 @@
 /**
  * 解析基础 SemVer 版本字符串（单一事实源）。
- * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀；
+ * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀与构建元数据；
  * 其余形态（两段式、非数值等）返回 null，由调用方自行兜底。
  *
  * 本模块不依赖任何 Node 内建与 core 领域模块，可在无 loader 的原生
  * Node 直接以 .ts 形态导入（工程脚本域复用此处单一事实源）。
  */
 export function parseSemVer(v) {
-    const match = v.trim().replace(/^[v=]/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+    const match = v.trim().replace(/^[v=]/, "").match(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/);
     if (!match)
         return null;
+    const [major, minor, patch] = match.slice(1, 4).map(Number);
+    if (![major, minor, patch].every(Number.isSafeInteger))
+        return null;
+    if (match[4]?.split(".").some((id) => /^\d+$/.test(id) && id.length > 1 && id.startsWith("0")))
+        return null;
     return {
-        major: parseInt(match[1], 10),
-        minor: parseInt(match[2], 10),
-        patch: parseInt(match[3], 10),
+        major,
+        minor,
+        patch,
         prerelease: match[4],
+        ...(match[5] === undefined ? {} : { build: match[5] }),
     };
 }

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export declare const ACTIONDOCK_VERSION = "2.12.0";
+export declare const ACTIONDOCK_VERSION = "2.14.0";

package/dist/version.js

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export const ACTIONDOCK_VERSION = "2.12.0";
+export const ACTIONDOCK_VERSION = "2.14.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/core",
-  "version": "2.12.0",
+  "version": "2.14.0",
   "description": "ActionDock Core Engine - Project loader, runtime execution, SQLite storage, standalone builder, and skill exporter",
   "type": "module",
   "main": "./dist/index.js",
@@ -41,11 +41,6 @@
       "types": "./dist/package/index.d.ts",
       "import": "./dist/package/index.js",
       "default": "./dist/package/index.js"
-    },
-    "./warning": {
-      "types": "./dist/utils/warning.d.ts",
-      "import": "./dist/utils/warning.js",
-      "default": "./dist/utils/warning.js"
     }
   },
   "files": [
@@ -64,7 +59,7 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/sdk": "^2.12.0",
+    "@actiondock/sdk": "^2.14.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "undici": "^7.29.1"

package/dist/utils/warning.d.ts

@@ -1 +0,0 @@
-export declare function suppressExperimentalWarnings(): void;

package/dist/utils/warning.js

@@ -1,52 +0,0 @@
-/**
- * 全局禁用 Node.js 所有的 ExperimentalWarning 实验性特性警告。
- * 跨所有 Node.js 运行版本，不区分具体特性（如 SQLite、类型擦除等），
- * 在进程级别统一静默全部实验性警告，同时完整保留废弃警告与运行期异常。
- *
- * 逃生通道：当环境变量 ACTIONDOCK_SILENCE_WARNINGS 显式设置为 "0" 时，放弃静默以供深度调试排查。
- */
-const kExperimentalWarningSuppressed = Symbol.for("actiondock.experimental_warning_suppressed");
-export function suppressExperimentalWarnings() {
-    // 逃生通道：支持开发者显式禁用静默逻辑，确保排障透明度
-    if (process.env.ACTIONDOCK_SILENCE_WARNINGS === "0") {
-        return;
-    }
-    const globalObj = globalThis;
-    if (globalObj[kExperimentalWarningSuppressed]) {
-        return;
-    }
-    globalObj[kExperimentalWarningSuppressed] = true;
-    // 1. 拦截 process.emitWarning 源头
-    const originalEmitWarning = process.emitWarning;
-    if (typeof originalEmitWarning === "function") {
-        process.emitWarning = function (warning, ...args) {
-            if (typeof warning === "string") {
-                const type = typeof args[0] === "string" ? args[0] : args[0]?.type || args[1];
-                if (type === "ExperimentalWarning") {
-                    return;
-                }
-            }
-            else if (warning) {
-                const warnObj = warning;
-                if (warnObj.name === "ExperimentalWarning" || warnObj.type === "ExperimentalWarning") {
-                    return;
-                }
-            }
-            return Reflect.apply(originalEmitWarning, process, [warning, ...args]);
-        };
-    }
-    // 2. 包装进程级 warning 事件分发器，作为双层防护
-    const originalListeners = process.listeners("warning");
-    process.removeAllListeners("warning");
-    process.on("warning", (warning) => {
-        const warnObj = warning;
-        if (warnObj.name === "ExperimentalWarning" || warnObj.type === "ExperimentalWarning") {
-            return;
-        }
-        for (const listener of originalListeners) {
-            listener.call(process, warning);
-        }
-    });
-}
-// 模块被引入时立即自执行
-suppressExperimentalWarnings();