@actiondock/core 2.6.0 → 2.8.0

package/dist/runtime/index.js

@@ -1,10 +1,9 @@
+export * from "./identity.js";
 export * from "./context.js";
 export * from "./action-collection.js";
 export * from "./action-registry.js";
 export * from "./run-persistence.js";
-export * from "./package-runner-factory.js";
 export * from "./runner.js";
-export * from "./execution-manager.js";
 export * from "./standalone.js";
 export * from "./env.js";
 export * from "./clock.js";

package/dist/runtime/module-loader.d.ts

@@ -1,34 +1,2 @@
-/**
- * 统一源码模块加载器接口。
- * 解耦 Action 与各类扩展模块的具体加载机制（如 ECMAScript 原生 import、tsx 动态转译加载等）。
- */
-export interface ModuleLoader {
-    /**
-     * 解析模块标识符为绝对路径或完整 URL。
-     *
-     * @param specifier 模块规范说明符或物理路径
-     * @param parentPath 发起解析的父级文件或目录路径
-     */
-    resolve?(specifier: string, parentPath?: string): string;
-    /**
-     * 动态加载模块并返回命名空间全量导出对象。
-     *
-     * @param specifier 模块规范说明符或物理路径
-     * @param parentPath 发起加载的父级文件或目录路径
-     */
-    load<T = any>(specifier: string, parentPath?: string): Promise<T>;
-    /**
-     * 加载模块并解包其默认导出（default 或 action 属性）。
-     *
-     * @param specifier 模块规范说明符或物理路径
-     * @param parentPath 发起加载的父级文件或目录路径
-     */
-    loadDefault?<T = any>(specifier: string, parentPath?: string): Promise<T>;
-}
-/**
- * 基于标准 ECMAScript 动态 import 的默认模块加载器。
- */
-export declare class DefaultModuleLoader implements ModuleLoader {
-    load<T = any>(specifier: string, _parentPath?: string): Promise<T>;
-    loadDefault<T = any>(specifier: string, parentPath?: string): Promise<T>;
-}
+export type { ModuleLoader } from "../node/module-loader.js";
+export { NodeModuleLoader, unwrapDefaultExport, } from "../node/module-loader.js";

package/dist/runtime/module-loader.js

@@ -1,16 +1 @@
-import { pathToFileURL } from "node:url";
-/**
- * 基于标准 ECMAScript 动态 import 的默认模块加载器。
- */
-export class DefaultModuleLoader {
-    async load(specifier, _parentPath) {
-        const importSpecifier = specifier.startsWith("file://")
-            ? specifier
-            : pathToFileURL(specifier).href;
-        return (await import(importSpecifier));
-    }
-    async loadDefault(specifier, parentPath) {
-        const mod = await this.load(specifier, parentPath);
-        return (mod?.default !== undefined ? mod.default : mod?.action !== undefined ? mod.action : mod);
-    }
-}
+export { NodeModuleLoader, unwrapDefaultExport, } from "../node/module-loader.js";

package/dist/runtime/process.d.ts

@@ -1,26 +1,8 @@
-import { type CallOptions, type ControlGrant, type OperationReceipt, type ProcessAcquireInput, type ProcessAPI, type ProcessControlInput, type ProcessExecOptions, type ProcessInfo, type ProcessListInput, type ProcessListResult, type ProcessReadInput, type ProcessResult, type ProcessRunInput, type ProcessRunResult, type ProcessStartInput, type ProcessStartResult, type ProcessStopInput, type ProcessWriteInput, type ReadResult } from "@actiondock/sdk";
-import { ProcessManager, type ProcessOwner } from "../process/index.js";
-export type ProcessExecutor = ProcessAPI;
+import type { ProcessAPI } from "@actiondock/sdk";
 /**
- * 基于受管进程驱动的默认基础执行器实现。
- * 保持内核彻底解耦与平台无关，不依赖操作系统原生进程句柄与 Node 模块。
+ * 进程执行器统一契约别名。
+ *
+ * 面向宿主与上层服务的进程能力均以 ProcessAPI 接口为准，
+ * 具体实现由各平台适配层（如 NodeProcessExecutor）提供。
  */
-export declare class DefaultProcessExecutor implements ProcessExecutor {
-    private readonly manager;
-    private readonly owner;
-    constructor(manager?: ProcessManager, owner?: ProcessOwner);
-    exec(command: string, args?: string[], options?: ProcessExecOptions): Promise<ProcessResult>;
-    spawn(command: string, args?: string[], options?: ProcessExecOptions): Promise<ProcessResult>;
-    run(input: ProcessRunInput, call?: CallOptions): Promise<ProcessRunResult>;
-    start(input: ProcessStartInput, call?: CallOptions): Promise<ProcessStartResult>;
-    inspect(id: string, call?: CallOptions): Promise<ProcessInfo>;
-    list(input: ProcessListInput, call?: CallOptions): Promise<ProcessListResult>;
-    acquire(id: string, input: ProcessAcquireInput, call?: CallOptions): Promise<ControlGrant>;
-    renew(id: string, token: string, ttlMs: number, call?: CallOptions): Promise<ControlGrant>;
-    release(id: string, token: string, call?: CallOptions): Promise<void>;
-    write(id: string, input: ProcessWriteInput, call?: CallOptions): Promise<OperationReceipt>;
-    operation(id: string, requestId: string, call?: CallOptions): Promise<OperationReceipt>;
-    read(id: string, input: ProcessReadInput, call?: CallOptions): Promise<ReadResult>;
-    control(id: string, input: ProcessControlInput, call?: CallOptions): Promise<OperationReceipt>;
-    stop(id: string, input: ProcessStopInput, call?: CallOptions): Promise<ProcessInfo>;
-}
+export type ProcessExecutor = ProcessAPI;

package/dist/runtime/process.js

@@ -1,118 +1 @@
-import { MemoryProcessDriver, ProcessManager } from "../process/index.js";
-/**
- * 基于受管进程驱动的默认基础执行器实现。
- * 保持内核彻底解耦与平台无关，不依赖操作系统原生进程句柄与 Node 模块。
- */
-export class DefaultProcessExecutor {
-    manager;
-    owner;
-    constructor(manager, owner) {
-        this.manager = manager ?? new ProcessManager({ driver: new MemoryProcessDriver() });
-        this.owner = owner ?? {
-            tenantId: "default",
-            principalId: "default",
-            packageInstanceId: "default",
-            generationId: "default",
-        };
-    }
-    async exec(command, args = [], options = {}) {
-        const startTime = Date.now();
-        try {
-            const runResult = await this.manager.run(this.owner, {
-                spec: {
-                    executable: command,
-                    args,
-                    cwd: options.cwd,
-                    env: options.env ? { inherit: "none", set: options.env } : undefined,
-                    io: { mode: "pipe" },
-                },
-                timeoutMs: options.timeoutMs ?? 0,
-                maxOutputBytes: options.maxOutputBytes ?? 10 * 1024 * 1024,
-            }, options.signal ? { signal: options.signal } : undefined);
-            let stdout = "";
-            let stderr = "";
-            for (const chunk of runResult.chunks) {
-                if (chunk.stream === "stdout") {
-                    stdout += chunk.data.data;
-                }
-                else if (chunk.stream === "stderr") {
-                    stderr += chunk.data.data;
-                }
-            }
-            const durationMs = Date.now() - startTime;
-            const ok = runResult.exit.code === 0;
-            if (!ok && options.throwOnError) {
-                throw new Error(stderr || `Process exited with code ${runResult.exit.code}`);
-            }
-            return {
-                ok,
-                exitCode: runResult.exit.code,
-                signal: runResult.exit.signal ?? undefined,
-                stdout,
-                stderr,
-                raw: new Uint8Array(),
-                timedOut: false,
-                cancelled: false,
-                durationMs,
-            };
-        }
-        catch (err) {
-            if (options.throwOnError) {
-                throw err;
-            }
-            return {
-                ok: false,
-                exitCode: -1,
-                stdout: "",
-                stderr: err?.message || String(err),
-                raw: new Uint8Array(),
-                timedOut: false,
-                cancelled: false,
-                durationMs: Date.now() - startTime,
-                error: {
-                    code: err?.code || "PROCESS_FAILED",
-                    message: err?.message || String(err),
-                },
-            };
-        }
-    }
-    async spawn(command, args = [], options = {}) {
-        return this.exec(command, args, options);
-    }
-    async run(input, call) {
-        return this.manager.run(this.owner, input, call);
-    }
-    async start(input, call) {
-        return this.manager.start(this.owner, input, call);
-    }
-    async inspect(id, call) {
-        return this.manager.inspect(this.owner, id, call);
-    }
-    async list(input, call) {
-        return this.manager.list(this.owner, input, call);
-    }
-    async acquire(id, input, call) {
-        return this.manager.acquire(this.owner, id, input, call);
-    }
-    async renew(id, token, ttlMs, call) {
-        return this.manager.renew(this.owner, id, token, ttlMs, call);
-    }
-    async release(id, token, call) {
-        return this.manager.release(this.owner, id, token, call);
-    }
-    async write(id, input, call) {
-        return this.manager.write(this.owner, id, input, call);
-    }
-    async operation(id, requestId, call) {
-        return this.manager.operation(this.owner, id, requestId, call);
-    }
-    async read(id, input, call) {
-        return this.manager.read(this.owner, id, input, call);
-    }
-    async control(id, input, call) {
-        return this.manager.control(this.owner, id, input, call);
-    }
-    async stop(id, input, call) {
-        return this.manager.stop(this.owner, id, input, call);
-    }
-}
+export {};

package/dist/runtime/run-persistence.js

@@ -1,4 +1,4 @@
-import { RUN_PERSISTENCE_FAILED, RUN_REPOSITORY_UNAVAILABLE } from "../errors.js";
+import { ActionDockError, RUN_PERSISTENCE_FAILED, RUN_REPOSITORY_UNAVAILABLE } from "../errors.js";
 /**
  * 构建运行初始记录（RunRecord 组装单一事实源）。
  */
@@ -43,10 +43,7 @@ export function createRunOrThrow(storage, record) {
         storage.createRun(record);
     }
     catch (err) {
-        const error = new Error(`RUN_REPOSITORY_UNAVAILABLE: Failed to initialize run record in repository: ${err?.message || String(err)}`);
-        error.code = RUN_REPOSITORY_UNAVAILABLE;
-        error.details = { originalError: err?.message };
-        throw error;
+        throw new ActionDockError(RUN_REPOSITORY_UNAVAILABLE, `RUN_REPOSITORY_UNAVAILABLE: Failed to initialize run record in repository: ${err?.message || String(err)}`, { originalError: err?.message });
     }
 }
 /**

package/dist/runtime/runner.d.ts

@@ -2,48 +2,21 @@ import type { ActionDefinition, ActionRef, ExecutionResult, Logger, ProcessAPI,
 import type { ProjectConfig } from "../project/types.js";
 import type { RuntimeStorage } from "../storage/types.js";
 import type { Clock } from "./clock.js";
-import type { RuntimePlatform } from "../platform/types.js";
 import type { ProcessOwner } from "../process/index.js";
-export { RUN_REPOSITORY_UNAVAILABLE, RUN_PERSISTENCE_FAILED, INPUT_NOT_JSON, OUTPUT_NOT_JSON, ACTION_SUBRUN_LIMIT, MAX_SUBRUNS_REACHED, ACTION_CALL_CYCLE, ACTION_CYCLE_DETECTED, ACTION_MAX_DEPTH_EXCEEDED, } from "../errors.js";
+import type { PackageIdentity } from "./identity.js";
+import type { ActionInvoker } from "../execution/types.js";
 /**
- * 校验值是否为合法的 JSON 兼容结构，严禁 NaN、Infinity、循环引用及不可序列化类型。
- *
- * 环路检测采用「当前递归路径栈」语义：对象仅在自身子树遍历期间保持标记，
- * 子树遍历完成后立即移除，从而正确放行共享子对象的有向无环结构（如 {a: shared, b: shared}）。
- */
-export declare function validateJsonValue(val: unknown, stack?: WeakSet<object>): {
-    valid: true;
-} | {
-    valid: false;
-    reason: string;
-};
-/**
- * 跨包运行上下文解析结果契约。
- */
-export interface PackageContextResolution {
-    projectRoot?: string;
-    projectConfig?: ProjectConfig;
-    storage: RuntimeStorage;
-    actions?: Map<string, ActionDefinition>;
-    packageInstanceId?: string;
-    generationId?: string;
-}
-/**
- * 跨包运行上下文解析委托函数契约。
+ * 局部动作解析器委托函数契约（仅限当前包内部动作）。
  */
-export type PackageContextResolver = (packageId: string) => Promise<PackageContextResolution | undefined> | PackageContextResolution | undefined;
+export type LocalActionResolver = (actionId: string) => ActionDefinition | undefined | Promise<ActionDefinition | undefined>;
 /**
  * ActionRunner 初始化配置选项。
  */
-export interface RunnerOptions {
-    /** 运行所属的 Package ID */
-    packageId: string;
-    /** 包物理实例标识 */
-    packageInstanceId?: string;
-    /** 快照代次标识 */
-    generationId?: string;
+export interface ActionRunnerOptions {
+    /** 显式注入的包物理与快照身份标识值对象（必填单一事实源） */
+    identity: PackageIdentity;
     /** 持久化运行时存储实例（SQLite） */
-    storage?: RuntimeStorage;
+    storage: RuntimeStorage;
     /** 全局共享持久化存储实例（SQLite，用于单例池化避免泄漏） */
     globalStorage?: RuntimeStorage;
     /** 项目根目录绝对路径 */
@@ -58,25 +31,15 @@ export interface RunnerOptions {
     process?: ProcessAPI;
     /** 可选的时间与时钟源（默认使用存储内嵌时钟或系统时间） */
     clock?: Clock;
-    /** 可选的底层运行时平台契约 */
-    platform?: RuntimePlatform;
-    /** 动态解析跨包或未注册 Action 的委托函数 */
-    actionResolver?: (ref: ActionRef | string, currentPackageId?: string) => ActionDefinition | undefined | Promise<ActionDefinition | undefined>;
-    /** 最大调用嵌套深度限制（防死循环/过深调用链，默认 16） */
-    maxCallDepth?: number;
-    /** 最大并发子任务数限制（默认 64） */
-    maxSubRuns?: number;
-    /** 跨包存储工厂 */
-    getStorageForPackage?: (packageId: string, projectRoot?: string) => RuntimeStorage;
-    /** 跨包运行上下文解析委托函数 */
-    packageContextResolver?: PackageContextResolver;
+    /** 仅支持当前包局部 Action 的动态解析委托函数 */
+    actionResolver?: LocalActionResolver;
     /** 自定义 ActionDock 用户家目录（用于测试隔离与多租户环境） */
     customHome?: string;
     /** 执行宿主会话标识 */
     hostSessionId?: string;
+    /** 子任务调用委托函数 */
+    actionInvoker?: ActionInvoker;
 }
-/** ActionRunnerOptions 别名兼容 */
-export type ActionRunnerOptions = RunnerOptions;
 /**
  * 启动 Action 执行时的可选控制参数。
  */
@@ -111,14 +74,16 @@ export interface ExecutionStartOptions {
     maxCallDepth?: number;
     /** 外部注入的进程执行器 */
     process?: ProcessAPI;
-    /** 可选的底层运行时平台契约 */
-    platform?: RuntimePlatform;
+    /** 可选的时间与时钟源 */
+    clock?: Clock;
     /** 外部注入的进度报告器 */
     progress?: ProgressReporter;
     /** 外部注入的日志记录器 */
     logger?: Logger;
     /** 执行级临时配置覆盖项 */
     configOverrides?: Record<string, unknown>;
+    /** 子任务调用委托函数 */
+    actionInvoker?: ActionInvoker;
 }
 /**
  * 异步执行句柄，支持获取执行结果 Promise 与主动取消操作。
@@ -144,26 +109,22 @@ export type ActionResolution = {
 } | {
     status: "not_found";
     reason?: string;
-} | {
-    status: "load_failed";
-    error: Error;
-    packageId: string;
-    projectRoot: string;
 };
 /**
  * ActionDock 核心执行引擎（ActionRunner）。
  *
  * 本类为执行编排壳：负责 Action 执行的全生命周期编排（校验、深度与环路检测、
  * 超时与取消竞态、子调用 uses 授权与错误分类），并将单一职责域委托至独立模块：
- * - Action 注册与检索委托 `ActionRegistry`（action-registry.ts）
+ * - Action 注册与检索委托 ActionRegistry（action-registry.ts）
  * - RunRecord 构造与落库委托 run-persistence.ts
- * - 跨包 Runner 构建与缓存委托 `PackageRunnerFactory`（package-runner-factory.ts）
+ * - 跨包动作调用委托注入的 ActionInvoker 并重返目标包执行服务
  *
  * 入参 (inputSchema) 与出参 (outputSchema) 的 JSON Schema 严格校验、嵌套 Action
  * 相互调用的环路检测（Cycle Detection）、超时 (Timeout) 与中断信号 (AbortSignal)
  * 竞态控制与运行记录持久化编排仍由本类承担。
  */
 export declare class ActionRunner {
+    readonly identity: PackageIdentity;
     readonly packageId: string;
     readonly packageInstanceId: string;
     readonly generationId: string;
@@ -175,20 +136,14 @@ export declare class ActionRunner {
     private registry;
     private clock?;
     private process?;
-    private platform?;
-    private maxCallDepth;
-    private maxSubRuns;
-    private activeSubRuns;
-    private packageFactory;
-    private actionResolver?;
-    private getStorageForPackage?;
     private customHome?;
+    private actionResolver?;
     private hostSessionId?;
-    constructor(options: RunnerOptions);
-    /** 本地 Action 注册表底层映射（仅内部与跨包工厂委托使用） */
+    private actionInvoker?;
+    constructor(options: ActionRunnerOptions);
+    /** 本地 Action 注册表底层映射 */
     private get actions();
     getStorage(): RuntimeStorage;
-    getPackageRunners(): Map<string, ActionRunner>;
     /**
      * 注册单个 Action 到当前 Runner。
      */
@@ -201,29 +156,21 @@ export declare class ActionRunner {
      * 根据 ID 检索注册的 Action。
      */
     getAction(id: string): ActionDefinition | undefined;
+    /**
+     * 设置子任务动作调用委托器。
+     */
+    setActionInvoker(invoker?: ActionInvoker): void;
     /**
      * 动态解析 Action（支持本地注册表、自定义解析器委托与已链接包目录索引检索）。
      *
      * @param actionOrRef Action 定义对象、引用或标识符
-     * @returns 解析判别联合结果（found | not_found | load_failed）
+     * @returns 解析判别联合结果（found | not_found）
      */
     resolveAction(actionOrRef: ActionDefinition | ActionRef | string): Promise<ActionResolution>;
     /**
      * 获取当前 Runner 已注册的所有 Action 列表。
      */
     listActions(): ActionDefinition[];
-    /**
-     * 注入或更新跨包运行上下文解析委托。
-     */
-    setPackageContextResolver(resolver: PackageContextResolver): void;
-    /**
-     * 跨包运行时解析与获取（确保跨包执行具备独立的配置、存储、状态与 Action 注册表）。
-     *
-     * 缓存 miss 后存在长异步窗口（加载配置、扫描 Action、打开存储），并发调用会重复构建
-     * Runner、重复打开 SQLite 连接且子任务限流计数分裂；故以 in-flight Promise 去重，
-     * 并发方 await 同一构建任务，构建失败时移除该 Promise 以便后续重试。
-     */
-    resolveTargetPackageRunner(targetPackageId: string): Promise<ActionRunner | undefined>;
     /**
      * 异步启动 Action 的执行并立即返回 ExecutionHandle 句柄。
      *
@@ -245,14 +192,6 @@ export declare class ActionRunner {
      * 依据运行期上下文装配落库模块入参（RunRecord 构造领域契约）。
      */
     private buildRunPersistenceInput;
-    /**
-     * 调用嵌套深度限制检测（超限时返回 ACTION_CALL_CYCLE 错误）。
-     */
-    private checkCallDepth;
-    /**
-     * 计算调用键并执行环路死锁检测（命中时返回携带错误的调用键结果）。
-     */
-    private computeCallKey;
     /**
      * 输入参数 JSON Schema 校验（若 action 已就绪，返回校验错误或 undefined）。
      */
@@ -262,17 +201,11 @@ export declare class ActionRunner {
      */
     private buildActionContext;
     /**
-     * 子 Action 调用委托：并发上限守卫、uses 跨包声明校验与子执行派发。
+     * 子 Action 调用委托：
+     * 必须委托 Host 动作调用器（走 Host 执行主链与 InvocationPolicy 鉴权）；
+     * 缺少 actionInvoker 时直接抛出 INVOCATION_UNSUPPORTED，严禁跨包或同包无约束执行逃逸。
      */
     private invokeChildAction;
-    /**
-     * 校验跨包子调用是否已在 uses 声明中授权（未声明时抛出 UNDECLARED_ACTION_DEPENDENCY）。
-     */
-    private assertDeclaredUses;
-    /**
-     * 解析子调用应使用的 Runner（本包或已解析的目标包 Runner）。
-     */
-    private resolveChildRunner;
     /**
      * 执行 Action 业务逻辑并与取消/超时信号进行竞态，返回执行结果信封 Promise。
      */
@@ -286,11 +219,8 @@ export declare class ActionRunner {
      */
     private classifyExecutionError;
     /**
-     * 释放 Runner 持有的跨包资源：遍历关闭全部子包 Runner 及其独立创建的存储连接。
-     *
-     * 幂等且并发安全：重复调用直接复用首次 Promise；子包存储异常不阻断其余释放；
-     * 仅关闭由本 Runner 构建子包 Runner 时独立创建的存储，外部注入的存储（如经
-     * packageContextResolver 传入的目标包自身存储）生命周期归所有者管理，不在此误关。
+     * 释放 Runner 持有的资源。
+     * 铁律 4：Runner 仅执行自己所属 Package 的 Action，不管理外部包生命周期。
      */
     dispose(): Promise<void>;
     /**