@actiondock/core 2.15.0 → 2.17.0

package/dist/catalog/discovery.d.ts

@@ -1,4 +1,4 @@
-import type { ActionDockManifest, PlaybookSourceManifest } from "../project/types.js";
+import type { ActionDockManifest } from "../project/types.js";
 import type { PackageIdentity } from "../runtime/identity.js";
 /**
  * 发现的包基本信息规范。
@@ -8,8 +8,8 @@ export interface DiscoveredPackage {
     readonly id: string;
     /** 包物理根目录绝对路径 */
     readonly root: string;
-    /** 包清单定义（支持磁盘声明式清单与运行时规程来源清单） */
-    readonly manifest: ActionDockManifest | PlaybookSourceManifest;
+    /** 包清单定义 */
+    readonly manifest: ActionDockManifest;
     /** 包物理与快照身份凭证（可选，由已有运行时传入） */
     readonly identity?: PackageIdentity;
     /** 是否来自工作区目录扫描发现 */

package/dist/catalog/graph.d.ts

@@ -1,11 +1,15 @@
 import { ActionDockError } from "../errors.js";
 import { type ActionDockLockfile } from "../project/lockfile.js";
-import type { ActionDockManifest, PlaybookDefinition, PlaybookSourceManifest } from "../project/types.js";
+import type { ActionDockManifest, PlaybookDefinition } from "../project/types.js";
 import { type PackageIdentity } from "../runtime/identity.js";
 import { parseSemVer, type SemVer } from "../utils/index.js";
 import { type DiscoveredPackage, type PackageDiscoveryOptions } from "./discovery.js";
 export type { SemVer };
 export { parseSemVer };
+/**
+ * 校验两个语义化版本范围是否兼容并能收敛为单一解析版本。
+ * 遵循设计规范：直接或传递版本范围无法收敛时拒绝并抛出 ACTION_PACKAGE_VERSION_CONFLICT。
+ */
 export declare function areVersionsCompatible(v1: string, v2: string): boolean;
 /**
  * 版本冲突错误。
@@ -51,8 +55,8 @@ export interface PackageNode {
     readonly packageId: string;
     /** 包根目录绝对物理路径 */
     readonly root: string;
-    /** 包清单规范（支持磁盘声明式清单与运行时规程来源清单） */
-    readonly manifest: ActionDockManifest | PlaybookSourceManifest;
+    /** 包清单规范 */
+    readonly manifest: ActionDockManifest;
     /** 包清单摘要哈希 */
     readonly manifestDigest: string;
     /** 包版本号 */
@@ -141,14 +145,12 @@ export declare class DefaultPackageGraph implements PackageGraph {
 export interface PackageGraphBuilderOptions {
     /** 预先发现的包集合，若未提供则通过 PackageDiscovery 自动发现 */
     packages?: DiscoveredPackage[];
-    /** 完整显式集合的依赖存在性与选定版本校验（Host 增量注册时不启用）。 */
-    validateDependencies?: boolean;
     /** 根工程根目录或根包标识（与 projectRoot 互为别名） */
     root?: string;
     /** 当前工程根目录绝对或相对物理路径 */
     projectRoot?: string;
     /** 显式根清单 */
-    manifest?: ActionDockManifest | PlaybookSourceManifest;
+    manifest?: ActionDockManifest;
     /** 锁文件规范对象（若未显式提供且 projectRoot 存在，则尝试自动读取 actiondock.lock.json） */
     lockfile?: ActionDockLockfile;
     /** 是否允许扫描与链接开发软链接包（默认根据 discoveryOptions 判定） */

package/dist/catalog/graph.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { ActionDockError, ACTION_PACKAGE_VERSION_CONFLICT, MANIFEST_DIGEST_MISMATCH, MANIFEST_NOT_FOUND, MANIFEST_READ_FAILED, PACKAGE_NOT_FOUND, PACKAGE_ID_CONFLICT, INVALID_ARGUMENT, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
+import { ActionDockError, ACTION_PACKAGE_VERSION_CONFLICT, MANIFEST_DIGEST_MISMATCH, MANIFEST_NOT_FOUND, MANIFEST_READ_FAILED, PACKAGE_NOT_FOUND, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
 import { computeManifestDigest, parseJsonWithoutDuplicates } from "../project/digest.js";
 import { loadLockfile } from "../project/lockfile.js";
 import { loadPlaybooks, loadProjectConfig } from "../project/loader.js";
@@ -10,124 +10,30 @@ import { createPackageIdentity } from "../runtime/identity.js";
 import { parseSemVer } from "../utils/index.js";
 import { PackageDiscovery } from "./discovery.js";
 export { parseSemVer };
-/** 有限版本契约：严格三段版本（允许 v/= 前缀）、^、~、*；不猜测其他范围。 */
-function parseVersionRange(value) {
-    const text = value.trim();
-    if (!text || text === "*")
-        return {};
-    const prefix = text[0];
-    const minimum = parseSemVer(prefix === "^" || prefix === "~" ? text.slice(1) : text);
-    if (!minimum)
-        return undefined;
-    if (prefix !== "^" && prefix !== "~")
-        return { minimum, exact: true };
-    const maximum = prefix === "~"
-        ? { major: minimum.major, minor: minimum.minor + 1, patch: 0 }
-        : minimum.major > 0 ? { major: minimum.major + 1, minor: 0, patch: 0 }
-            : minimum.minor > 0 ? { major: 0, minor: minimum.minor + 1, patch: 0 }
-                : { major: 0, minor: 0, patch: minimum.patch + 1 };
-    return { minimum, maximum };
-}
-function compareVersions(a, b) {
-    const core = a.major - b.major || a.minor - b.minor || a.patch - b.patch;
-    if (core)
-        return core;
-    if (a.prerelease === b.prerelease)
-        return 0;
-    if (a.prerelease === undefined)
-        return 1;
-    if (b.prerelease === undefined)
-        return -1;
-    const left = a.prerelease.split(".");
-    const right = b.prerelease.split(".");
-    for (let i = 0; i < Math.max(left.length, right.length); i++) {
-        if (left[i] === undefined)
-            return -1;
-        if (right[i] === undefined)
-            return 1;
-        if (left[i] === right[i])
-            continue;
-        const numericLeft = /^\d+$/.test(left[i]);
-        const numericRight = /^\d+$/.test(right[i]);
-        if (numericLeft && numericRight)
-            return BigInt(left[i]) < BigInt(right[i]) ? -1 : 1;
-        if (numericLeft !== numericRight)
-            return numericLeft ? -1 : 1;
-        return left[i] < right[i] ? -1 : 1;
-    }
-    return 0;
-}
-function satisfiesRange(version, range) {
-    if (range.exact)
-        return compareVersions(version, range.minimum) === 0;
-    if (range.minimum && compareVersions(version, range.minimum) < 0)
-        return false;
-    if (range.maximum && compareVersions(version, range.maximum) >= 0)
-        return false;
-    // 预发布版本仅在范围下界显式点名同一核心版本的预发布时纳入。
-    if (version.prerelease !== undefined) {
-        const min = range.minimum;
-        return Boolean(min?.prerelease && version.major === min.major && version.minor === min.minor && version.patch === min.patch);
-    }
-    return true;
-}
-export function areVersionsCompatible(v1, v2) {
-    const left = parseVersionRange(v1);
-    const right = parseVersionRange(v2);
-    if (!left || !right)
-        return false;
-    const candidate = !left.minimum ? right.minimum : !right.minimum ? left.minimum
-        : compareVersions(left.minimum, right.minimum) >= 0 ? left.minimum : right.minimum;
-    if (!candidate)
-        return true;
-    if (satisfiesRange(candidate, left) && satisfiesRange(candidate, right))
-        return true;
-    // 两个范围可以在预发布下界之后的稳定版本交汇，但不能改变精确版本。
-    const stable = { major: candidate.major, minor: candidate.minor, patch: candidate.patch };
-    return satisfiesRange(stable, left) && satisfiesRange(stable, right);
-}
 /**
- * 判定给定的依赖规格是否为不支持的语义化版本范围形态（而非获取描述）。
- *
- * 规则：
- * - 范围操作符开头：^, ~, <, >, =, *；
- * - 复合范围操作符：|| 或 - 范围；
- * - X 范围与通配：如 1.x, 1.2.x, 1.*, 1.2.*, v1.x 等；
- * - 不完整两段或一段版本：如 1, 1.2, v1, v1.2 等；
- * - 版本三段式开头但未被严格解析器支持的非法形态。
+ * 校验两个语义化版本范围是否兼容并能收敛为单一解析版本。
+ * 遵循设计规范：直接或传递版本范围无法收敛时拒绝并抛出 ACTION_PACKAGE_VERSION_CONFLICT。
  */
-function isUnsupportedVersionRange(spec) {
-    const text = spec.trim();
-    if (!text)
-        return false;
-    if (/^[~^<>=*]/.test(text))
-        return true;
-    if (/\|\||\s+-\s+/.test(text))
-        return true;
-    if (/^v?\d+\.(?:[xX*]|\d+\.[xX*])(?:$|[-+])/.test(text))
-        return true;
-    if (/^v?\d+(?:\.\d+)?$/.test(text))
-        return true;
-    if (/^v?\d+\.\d+\.\d+/.test(text))
+export function areVersionsCompatible(v1, v2) {
+    if (v1 === v2 || v1 === "*" || v2 === "*" || !v1 || !v2) {
         return true;
-    return false;
-}
-/** 获取描述不是版本约束；仅真实范围及锁定版本参与版本兼容校验。 */
-function dependencyVersionRequirements(spec, locked) {
-    const requirements = [];
-    const range = spec === undefined ? undefined : parseVersionRange(spec);
-    if (spec !== undefined && range)
-        requirements.push(spec);
-    else if (spec !== undefined && isUnsupportedVersionRange(spec)) {
-        throw new ActionDockError(INVALID_ARGUMENT, `Unsupported Action package version range '${spec}'; supported forms are exact versions, ^, ~ and *`);
     }
-    const lockedVersion = locked?.resolved || locked?.version;
-    if (lockedVersion && parseSemVer(lockedVersion))
-        requirements.push(lockedVersion);
-    else if (lockedVersion) {
-        throw new ActionDockError(INVALID_ARGUMENT, `Invalid locked Action package version '${lockedVersion}'`);
+    const clean1 = v1.trim().replace(/^[\^~=]/, "");
+    const clean2 = v2.trim().replace(/^[\^~=]/, "");
+    const sem1 = parseSemVer(clean1);
+    const sem2 = parseSemVer(clean2);
+    if (!sem1 || !sem2) {
+        return v1 === v2;
+    }
+    if (sem1.major !== sem2.major) {
+        return false;
+    }
+    if (v1.startsWith("~") || v2.startsWith("~")) {
+        if (sem1.minor !== sem2.minor) {
+            return false;
+        }
     }
-    return requirements;
+    return true;
 }
 /**
  * 版本冲突错误。
@@ -321,20 +227,30 @@ function computeTransitiveDependencies(nodes) {
 function collectVisiblePlaybooks(rootNode, nodes) {
     const visiblePlaybooks = new Map();
     const delegatedActions = new Set();
-    if (rootNode) {
-        const rootPbs = loadPlaybooks(rootNode.root || "", undefined, rootNode.manifest);
-        for (const [id, pb] of rootPbs.entries()) {
-            visiblePlaybooks.set(id, pb);
-            visiblePlaybooks.set(`${rootNode.packageId}/${id}`, pb);
+    if (rootNode && rootNode.root && existsSync(rootNode.root)) {
+        try {
+            const rootPbs = loadPlaybooks(rootNode.root, undefined, rootNode.manifest);
+            for (const [id, pb] of rootPbs.entries()) {
+                visiblePlaybooks.set(id, pb);
+                visiblePlaybooks.set(`${rootNode.packageId}/${id}`, pb);
+            }
+        }
+        catch {
+            // 忽略根包 Playbook 加载异常
         }
         for (const depId of rootNode.directDependencies) {
             if (depId === rootNode.packageId)
                 continue;
             const depNode = nodes.get(depId);
-            if (depNode) {
-                const depPbs = loadPlaybooks(depNode.root || "", undefined, depNode.manifest);
-                for (const [id, pb] of depPbs.entries()) {
-                    visiblePlaybooks.set(`${depId}/${id}`, pb);
+            if (depNode && depNode.root && existsSync(depNode.root)) {
+                try {
+                    const depPbs = loadPlaybooks(depNode.root, undefined, depNode.manifest);
+                    for (const [id, pb] of depPbs.entries()) {
+                        visiblePlaybooks.set(`${depId}/${id}`, pb);
+                    }
+                }
+                catch {
+                    // 忽略依赖包 Playbook 加载异常
                 }
             }
         }
@@ -364,16 +280,13 @@ export class PackageGraphBuilder {
      */
     buildFromPackages(nodes, generation) {
         for (const pkg of this.options.packages) {
-            if (nodes.has(pkg.id)) {
-                throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID '${pkg.id}' occurs more than once in explicit package graph`);
-            }
             const fields = createPackageNodeFields({
                 id: pkg.id,
                 root: pkg.root,
                 manifest: pkg.manifest,
                 npmPackage: pkg.id,
                 isDirect: Boolean(pkg.isCurrentProject),
-                isRoot: false,
+                isRoot: Boolean(pkg.isCurrentProject),
                 identity: pkg.identity,
                 generation,
             });
@@ -395,48 +308,20 @@ export class PackageGraphBuilder {
             }
         }
         if (!rootIdentity) {
-            const currentProjectNodes = Array.from(nodes.values()).filter((n) => n.isDirect);
-            if (currentProjectNodes.length === 1) {
-                rootIdentity = currentProjectNodes[0].identity;
-            }
-        }
-        for (const [id, node] of nodes) {
-            const isTheRoot = Boolean(rootIdentity && node.identity.id === rootIdentity.id);
-            nodes.set(id, { ...node, isRoot: isTheRoot, isDirect: isTheRoot || Boolean(node.isDirect) });
-        }
-        if (this.options.validateDependencies) {
             for (const node of nodes.values()) {
-                const lockfile = node.root ? loadLockfile(node.root) : null;
-                for (const [depId, spec] of Object.entries(node.manifest.dependencies || {})) {
-                    const dep = nodes.get(depId);
-                    if (!dep) {
-                        throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${depId}' required by '${node.packageId}' is missing from explicit graph`);
-                    }
-                    for (const requirement of dependencyVersionRequirements(spec)) {
-                        if (!areVersionsCompatible(requirement, dep.version)) {
-                            throw new ActionPackageVersionConflictError(depId, [
-                                { requester: node.packageId, rangeOrVersion: requirement },
-                                { requester: depId, rangeOrVersion: dep.version },
-                            ]);
-                        }
-                    }
-                }
-                // 根锁文件也可能锁定传递依赖，不能只检查直接 dependencies。
-                for (const [depId, locked] of Object.entries(lockfile?.packages || {})) {
-                    const dep = nodes.get(depId);
-                    if (!dep)
-                        continue;
-                    for (const requirement of dependencyVersionRequirements(undefined, locked)) {
-                        if (!areVersionsCompatible(requirement, dep.version)) {
-                            throw new ActionPackageVersionConflictError(depId, [
-                                { requester: node.packageId, rangeOrVersion: requirement },
-                                { requester: depId, rangeOrVersion: dep.version },
-                            ]);
-                        }
-                    }
+                if (node.isRoot) {
+                    rootIdentity = node.identity;
+                    break;
                 }
             }
         }
+        if (rootIdentity) {
+            const rootNode = nodes.get(rootIdentity.id);
+            if (rootNode) {
+                rootNode.isRoot = true;
+                rootNode.isDirect = true;
+            }
+        }
         linkDirectDependencies(nodes);
         computeTransitiveDependencies(nodes);
         const effectiveRootNode = rootIdentity ? nodes.get(rootIdentity.id) : undefined;
@@ -530,13 +415,6 @@ export class PackageGraphBuilder {
                     // 忽略扫描外部链接包异常
                 }
             }
-            const requesterLocks = new Map([[rootPackageId, lockfile]]);
-            const getRequesterLock = (requester) => {
-                if (!requesterLocks.has(requester)) {
-                    requesterLocks.set(requester, loadLockfile(nodes.get(requester).root));
-                }
-                return requesterLocks.get(requester);
-            };
             const versionRequirements = new Map();
             function recordRequirement(pkgId, requester, rangeOrVersion) {
                 const existing = versionRequirements.get(pkgId) || [];
@@ -551,22 +429,10 @@ export class PackageGraphBuilder {
                 existing.push({ requester, rangeOrVersion });
                 versionRequirements.set(pkgId, existing);
             }
-            const recordDependency = (pkgId, requester, spec) => {
-                const requesterLocked = getRequesterLock(requester)?.packages[pkgId];
-                for (const requirement of dependencyVersionRequirements(spec, requesterLocked)) {
-                    recordRequirement(pkgId, requester, requirement);
-                }
-                const rootLocked = lockfile?.packages[pkgId];
-                if (rootLocked && rootLocked !== requesterLocked) {
-                    for (const requirement of dependencyVersionRequirements(undefined, rootLocked)) {
-                        recordRequirement(pkgId, rootPackageId, requirement);
-                    }
-                }
-            };
             const queue = [];
             for (const [depId, spec] of Object.entries(rootManifest.dependencies || {})) {
                 rootNode.directDependencies.add(depId);
-                recordDependency(depId, rootPackageId, spec);
+                recordRequirement(depId, rootPackageId, spec);
                 queue.push({
                     pkgId: depId,
                     requester: rootPackageId,
@@ -594,7 +460,7 @@ export class PackageGraphBuilder {
                     continue;
                 }
                 let pkgDir = null;
-                const locked = getRequesterLock(item.requester)?.packages[item.pkgId] || lockfile?.packages[item.pkgId];
+                const locked = lockfile?.packages?.[item.pkgId];
                 if (packageRootsRecord?.[item.pkgId]) {
                     pkgDir = packageRootsRecord[item.pkgId];
                 }
@@ -608,7 +474,7 @@ export class PackageGraphBuilder {
                     }
                     candidateNames.push(item.rangeOrSpec);
                     candidateNames.push(item.pkgId);
-                    let cur = nodes.get(item.requester)?.root || absProjectRoot;
+                    let cur = absProjectRoot;
                     while (true) {
                         for (const candName of candidateNames) {
                             const candPath = join(cur, "node_modules", candName);
@@ -640,9 +506,6 @@ export class PackageGraphBuilder {
                     throw new ActionDockError(MANIFEST_READ_FAILED, `Failed to read manifest for '${item.pkgId}': ${err.message}`);
                 }
                 const depManifest = parseJsonWithoutDuplicates(manifestRaw);
-                if (depManifest.id !== item.pkgId) {
-                    throw new ActionDockError(PACKAGE_ID_CONFLICT, `Expected package '${item.pkgId}' at '${pkgDir}', found '${depManifest.id}'`);
-                }
                 const actualDigest = computeManifestDigest(depManifest);
                 if (locked?.manifestDigest && locked.manifestDigest !== actualDigest) {
                     throw new ActionDockError(MANIFEST_DIGEST_MISMATCH, `Manifest digest mismatch for package '${item.pkgId}': expected '${locked.manifestDigest}', got '${actualDigest}'. Re-resolution required.`);
@@ -675,13 +538,15 @@ export class PackageGraphBuilder {
                 };
                 nodes.set(item.pkgId, newNode);
                 for (const [subDepId, subSpec] of Object.entries(depManifest.dependencies || {})) {
-                    recordDependency(subDepId, item.pkgId, subSpec);
-                    queue.push({
-                        pkgId: subDepId,
-                        requester: item.pkgId,
-                        rangeOrSpec: subSpec,
-                        isDirect: false,
-                    });
+                    recordRequirement(subDepId, item.pkgId, subSpec);
+                    if (!nodes.has(subDepId)) {
+                        queue.push({
+                            pkgId: subDepId,
+                            requester: item.pkgId,
+                            rangeOrSpec: subSpec,
+                            isDirect: false,
+                        });
+                    }
                 }
             }
             if (scanLinked) {

package/dist/catalog/resolve-playbook.d.ts

@@ -20,7 +20,7 @@ export interface ResolvePlaybookContext {
     readonly caller?: string;
 }
 /**
- * 基于 PackageGraph 的规程寻址函数，正文统一由规程加载层提供。
- * 替代原 registry 内部的 resolvePlaybookProject 启发式搜索。
+ * 纯领域规程解析函数 resolvePlaybook。
+ * 基于 PackageGraph 替代原 registry 内部的 resolvePlaybookProject 启发式搜索。
  */
 export declare function resolvePlaybook(identifier: string, context: ResolvePlaybookContext): ResolvedPlaybook;

package/dist/catalog/resolve-playbook.js

@@ -1,12 +1,48 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { loadPlaybooks } from "../project/loader.js";
 import { getPackageSlug } from "../utils/index.js";
 import { ActionDockError, INVALID_ACTION_REF, NOT_FOUND, PACKAGE_NOT_FOUND } from "../errors.js";
 function getNodePlaybooks(node) {
-    return loadPlaybooks(node.root, node.manifest.playbooksDir, node.manifest);
+    const map = new Map();
+    if (node.root && existsSync(node.root)) {
+        try {
+            const diskPlaybooks = loadPlaybooks(node.root, node.manifest?.playbooksDir);
+            for (const [k, v] of diskPlaybooks) {
+                map.set(k, v);
+            }
+        }
+        catch {
+            // 忽略磁盘规程目录扫描异常
+        }
+    }
+    if (node.manifest?.playbooks && typeof node.manifest.playbooks === "object") {
+        for (const [id, item] of Object.entries(node.manifest.playbooks)) {
+            const existing = map.get(id);
+            let content = item.content ?? existing?.content ?? "";
+            let filePath = item.entry && node.root
+                ? resolve(node.root, item.entry)
+                : existing?.filePath;
+            if (!content && filePath && existsSync(filePath)) {
+                try {
+                    content = readFileSync(filePath, "utf-8");
+                }
+                catch { }
+            }
+            map.set(id, {
+                id,
+                description: item.description ?? existing?.description,
+                actions: item.actions ?? existing?.actions ?? [],
+                content,
+                filePath: filePath || "",
+            });
+        }
+    }
+    return map;
 }
 /**
- * 基于 PackageGraph 的规程寻址函数，正文统一由规程加载层提供。
- * 替代原 registry 内部的 resolvePlaybookProject 启发式搜索。
+ * 纯领域规程解析函数 resolvePlaybook。
+ * 基于 PackageGraph 替代原 registry 内部的 resolvePlaybookProject 启发式搜索。
  */
 export function resolvePlaybook(identifier, context) {
     const str = identifier.trim();
@@ -51,15 +87,20 @@ export function resolvePlaybook(identifier, context) {
     // 3. 全局搜索
     const matches = [];
     for (const node of context.graph.packages.values()) {
-        const playbooks = getNodePlaybooks(node);
-        const pb = playbooks.get(str);
-        if (pb) {
-            matches.push({
-                packageId: node.identity.id,
-                projectRoot: node.root,
-                playbookId: str,
-                playbook: pb,
-            });
+        try {
+            const playbooks = getNodePlaybooks(node);
+            const pb = playbooks.get(str);
+            if (pb) {
+                matches.push({
+                    packageId: node.identity.id,
+                    projectRoot: node.root,
+                    playbookId: str,
+                    playbook: pb,
+                });
+            }
+        }
+        catch {
+            // 忽略单个包加载异常
         }
     }
     if (matches.length === 1) {

package/dist/execution/service.js

@@ -7,6 +7,7 @@ import { InMemoryEventSink } from "../runtime/events.js";
 import { ActionDockError, ACTION_CANCELLED, ACTION_FAILED, ACTION_NOT_FOUND, ACTION_TIMEOUT, EXECUTION_CONCURRENCY_LIMIT, EXECUTION_FAILED, IDEMPOTENCY_CONFLICT, INPUT_NOT_JSON, INPUT_VALIDATION_FAILED, INVALID_ARGUMENT, INVOCATION_UNSUPPORTED, OUTPUT_NOT_JSON, OUTPUT_VALIDATION_FAILED, RUN_REPOSITORY_UNAVAILABLE, SERVICE_CLOSED, UNHANDLED_EXECUTION_ERROR, describeActionLoadFailure, } from "../errors.js";
 import { resultStatusToRunStatus } from "../storage/types.js";
 import { createDefaultProcessOwner, } from "../invocation/types.js";
+import { snapshotRunOrigin } from "../runtime/run-origin.js";
 import { ActionRegistry, isActionDefinitionObject, resolveAnonymousActionId, } from "../runtime/action-registry.js";
 import { buildInitialRunRecord, createRunFinalizer, createRunOrThrow, tryCreateRun, } from "../runtime/run-persistence.js";
 import { createActionContext } from "../runtime/context.js";
@@ -432,6 +433,7 @@ export class DefaultExecutionService {
             process: opts.process || this.process,
             owner: opts.owner,
             requestId: opts.requestId,
+            origin: snapshotRunOrigin(opts.origin),
         };
     }
     async raceExecution(args) {
@@ -548,6 +550,7 @@ export class DefaultExecutionService {
             progress: context.progress,
             process: effectiveProcess,
             owner: effectiveOwner,
+            origin: context.origin,
         };
         return await invoker(childAction, childInput, invocationContext);
     }
@@ -712,8 +715,10 @@ export class DefaultExecutionService {
             message: `Action '${targetActionId}' not found in package '${targetPackageId}'`,
         };
         const rootRunId = context.rootRunId || context.parentRunId || runId;
+        const origin = snapshotRunOrigin(context.origin);
         const initialRun = {
             id: runId,
+            ...(origin !== undefined ? { origin } : {}),
             rootRunId,
             parentRunId: context.parentRunId,
             packageId: targetPackageId,
@@ -777,6 +782,7 @@ export class DefaultExecutionService {
             runId,
             rootRunId,
             parentRunId: context.parentRunId,
+            origin: context.origin,
             ownerId: context.principalId || context.tenantId || this.ownerId,
             hostSessionId: context.hostSessionId || this.hostSessionId,
             hostPid: this.hostPid,

package/dist/execution/types.d.ts

@@ -1,5 +1,5 @@
 import type { ActionDefinition, ActionRef, ExecutionEvent, ExecutionResult, JsonValue, Logger, ProcessAPI, RunRecord, RunStatus } from "@actiondock/sdk";
-import type { ProjectConfig, RuntimeProjectConfig } from "../project/types.js";
+import type { ProjectConfig } from "../project/types.js";
 import type { Clock } from "../storage/clock.js";
 import type { EventSink } from "../runtime/events.js";
 import type { RuntimeStorage } from "../storage/types.js";
@@ -40,7 +40,7 @@ export interface ExecutionServiceOptions {
     storage: RuntimeStorage;
     globalStorage?: RuntimeStorage;
     projectRoot?: string;
-    projectConfig?: ProjectConfig | RuntimeProjectConfig;
+    projectConfig?: ProjectConfig;
     configOverrides?: Record<string, unknown>;
     actions?: Map<string, ActionDefinition>;
     process?: ProcessAPI;

package/dist/host/host.js

@@ -7,6 +7,7 @@ import { findProjectRoot, loadProjectConfig } from "../project/loader.js";
 import { hasPendingTransactions, isProjectLockHeld, recoverPendingTransactions } from "../project/transactions.js";
 import { listLinkedPackages } from "../registry/registry.js";
 import { InMemoryEventSink } from "../runtime/events.js";
+import { snapshotRunOrigin } from "../runtime/run-origin.js";
 import { ActionDockError, ACTION_NOT_FOUND, ACTION_PACKAGE_VERSION_CONFLICT, ACTION_SUBRUN_LIMIT, EXECUTION_FAILED, INVALID_ACTION_REF, PACKAGE_ID_CONFLICT, PACKAGE_NOT_FOUND, PROJECT_BUSY, PROJECT_RECOVERY_REQUIRED, SERVICE_CLOSED, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
 import { InvocationPolicy } from "../invocation/policy.js";
 import { createAbortError } from "../ipc/service.js";
@@ -135,6 +136,7 @@ export class DefaultActionDockHost {
         };
         this.execution = {
             async run(ref, input, opts) {
+                const origin = snapshotRunOrigin(opts?.origin);
                 await self.ensureInitialized();
                 const actionRef = typeof ref === "string" ? parseActionRef(ref) : ref;
                 const cleanOpts = {
@@ -142,10 +144,12 @@ export class DefaultActionDockHost {
                     timeoutMs: opts?.timeoutMs,
                     config: opts?.config,
                     requestId: opts?.requestId,
+                    origin,
                 };
                 return self.runAction(actionRef, (input ?? {}), cleanOpts);
             },
             async start(ref, input, opts) {
+                const origin = snapshotRunOrigin(opts?.origin);
                 await self.ensureInitialized();
                 const actionRef = typeof ref === "string" ? parseActionRef(ref) : ref;
                 const cleanOpts = {
@@ -153,6 +157,7 @@ export class DefaultActionDockHost {
                     timeoutMs: opts?.timeoutMs,
                     config: opts?.config,
                     requestId: opts?.requestId,
+                    origin,
                 };
                 return self.startAction(actionRef, (input ?? {}), cleanOpts);
             },
@@ -634,6 +639,7 @@ export class DefaultActionDockHost {
                     progress: context.progress,
                     process: context.process,
                     owner: targetOwner,
+                    origin: context.origin,
                 };
                 const ticket = await targetRuntime.startInvocation(targetActionId, childInput, subInvocationContext);
                 if (!ticket.result) {
@@ -752,14 +758,18 @@ export class DefaultActionDockHost {
         return describeVisiblePlaybook(this.listRuntimes(), id, this.visibility());
     }
     async runAction(ref, input, options = {}) {
+        const origin = snapshotRunOrigin(options.origin);
+        const effectiveOptions = { ...options, origin };
         await this.ensureInitialized();
-        const ticket = await this.startAction(ref, input, options);
+        const ticket = await this.startAction(ref, input, effectiveOptions);
         if (!ticket.result) {
             throw new ActionDockError(EXECUTION_FAILED, `Execution ticket for run '${ticket.runId}' has no result Promise`);
         }
         return ticket.result;
     }
     async startAction(ref, input, options = {}) {
+        const origin = snapshotRunOrigin(options.origin);
+        const effectiveOptions = { ...options, origin };
         await this.ensureInitialized();
         if (this.isClosed) {
             throw new ActionDockError(SERVICE_CLOSED, "ActionDockHost is closed: new tasks rejected");
@@ -837,13 +847,14 @@ export class DefaultActionDockHost {
         const rootContext = createRootInvocationContext({
             targetPackage: targetRuntime.identity,
             callStack: [rootKey],
-            signal: options.signal,
-            timeoutMs: options.timeoutMs,
-            config: options.config,
-            requestId: options.requestId,
+            signal: effectiveOptions.signal,
+            timeoutMs: effectiveOptions.timeoutMs,
+            config: effectiveOptions.config,
+            requestId: effectiveOptions.requestId,
             hostSessionId: this.hostSessionId,
             maxCallDepth: this.maxCallDepth,
             process: this.options.process,
+            origin: effectiveOptions.origin,
         });
         // 调度目标包执行服务
         return targetRuntime.startInvocation(targetActionId, input, rootContext);

package/dist/host/routing.d.ts

@@ -25,7 +25,7 @@ export declare function listVisiblePlaybooks(runtimes: readonly PackageRuntime[]
     graph?: PackageGraph;
 }): Promise<PlaybookSummary[]>;
 /**
- * 静态查询指定 Playbook 规范：委托 resolvePlaybook 统一寻址与来源加载。
+ * 静态查询指定 Playbook 规范：基于 resolvePlaybook 统一纯领域解析。
  */
 export declare function describeVisiblePlaybook(runtimes: readonly PackageRuntime[], id: string, visibility: {
     hostPublicPackageIds: ReadonlySet<string>;