@actiondock/core 2.2.2 → 2.3.0

package/dist/runtime/runner.d.ts

@@ -3,22 +3,45 @@ 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";
 /**
  * 校验值是否为合法的 JSON 兼容结构，严禁 NaN、Infinity、循环引用及不可序列化类型。
+ *
+ * 环路检测采用「当前递归路径栈」语义：对象仅在自身子树遍历期间保持标记，
+ * 子树遍历完成后立即移除，从而正确放行共享子对象的有向无环结构（如 {a: shared, b: shared}）。
  */
-export declare function validateJsonValue(val: unknown, seen?: WeakSet<object>): {
+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;
 /**
  * ActionRunner 初始化配置选项。
  */
 export interface RunnerOptions {
     /** 运行所属的 Package ID */
     packageId: string;
+    /** 包物理实例标识 */
+    packageInstanceId?: string;
+    /** 快照代次标识 */
+    generationId?: string;
     /** 持久化运行时存储实例（SQLite） */
     storage?: RuntimeStorage;
     /** 全局共享持久化存储实例（SQLite，用于单例池化避免泄漏） */
@@ -46,17 +69,7 @@ export interface RunnerOptions {
     /** 跨包存储工厂 */
     getStorageForPackage?: (packageId: string, projectRoot?: string) => RuntimeStorage;
     /** 跨包运行上下文解析委托函数 */
-    packageContextResolver?: (packageId: string) => Promise<{
-        projectRoot?: string;
-        projectConfig?: ProjectConfig;
-        storage: RuntimeStorage;
-        actions?: Map<string, ActionDefinition>;
-    } | undefined> | {
-        projectRoot?: string;
-        projectConfig?: ProjectConfig;
-        storage: RuntimeStorage;
-        actions?: Map<string, ActionDefinition>;
-    } | undefined;
+    packageContextResolver?: PackageContextResolver;
     /** 自定义 ActionDock 用户家目录（用于测试隔离与多租户环境） */
     customHome?: string;
     /** 执行宿主会话标识 */
@@ -80,6 +93,12 @@ export interface ExecutionStartOptions {
     generationId?: string;
     /** 执行所有者标识 */
     ownerId?: string;
+    /** 租户标识 */
+    tenantId?: string;
+    /** 主体标识 */
+    principalId?: string;
+    /** 显式执行归属所有者契约 */
+    owner?: ProcessOwner;
     /** 执行宿主会话标识 */
     hostSessionId?: string;
     /** 调用栈数组（用于检测 A -> B -> A 环路死锁） */
@@ -142,7 +161,9 @@ export type ActionResolution = {
  * - 自动记录并持久化 RunRecord 运行记录至 SQLite 存储。
  */
 export declare class ActionRunner {
-    private packageId;
+    readonly packageId: string;
+    readonly packageInstanceId: string;
+    readonly generationId: string;
     private storage;
     private globalStorage?;
     private projectRoot?;
@@ -156,6 +177,8 @@ export declare class ActionRunner {
     private maxSubRuns;
     private activeSubRuns;
     private packageRunners;
+    /** 跨包 Runner 构建中的 in-flight Promise：并发调用 await 同一构建任务，消除 check-then-act 竞态 */
+    private pendingPackageRunners;
     private actionResolver?;
     private getStorageForPackage?;
     private packageContextResolver?;
@@ -190,21 +213,19 @@ export declare class ActionRunner {
     /**
      * 注入或更新跨包运行上下文解析委托。
      */
-    setPackageContextResolver(resolver: (packageId: string) => Promise<{
-        projectRoot?: string;
-        projectConfig?: ProjectConfig;
-        storage: RuntimeStorage;
-        actions?: Map<string, ActionDefinition>;
-    } | undefined> | {
-        projectRoot?: string;
-        projectConfig?: ProjectConfig;
-        storage: RuntimeStorage;
-        actions?: Map<string, ActionDefinition>;
-    } | undefined): void;
+    setPackageContextResolver(resolver: PackageContextResolver): void;
     /**
      * 跨包运行时解析与获取（确保跨包执行具备独立的配置、存储、状态与 Action 注册表）。
+     *
+     * 缓存 miss 后存在长异步窗口（加载配置、扫描 Action、打开存储），并发调用会重复构建
+     * Runner、重复打开 SQLite 连接且子任务限流计数分裂；故以 in-flight Promise 去重，
+     * 并发方 await 同一构建任务，构建失败时移除该 Promise 以便后续重试。
      */
     resolveTargetPackageRunner(targetPackageId: string): Promise<ActionRunner | undefined>;
+    /**
+     * 实际构建跨包 Runner（仅由 resolveTargetPackageRunner 串行调度）。
+     */
+    private buildTargetPackageRunner;
     /**
      * 异步启动 Action 的执行并立即返回 ExecutionHandle 句柄。
      *

package/dist/runtime/runner.js

@@ -1,5 +1,4 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { ActionResolver } from "../catalog/action-resolver.js";
 import { loadActions, loadProjectConfig } from "../project/loader.js";
@@ -11,8 +10,11 @@ import { createActionContext, StderrLogger } from "./context.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";
 /**
  * 校验值是否为合法的 JSON 兼容结构，严禁 NaN、Infinity、循环引用及不可序列化类型。
+ *
+ * 环路检测采用「当前递归路径栈」语义：对象仅在自身子树遍历期间保持标记，
+ * 子树遍历完成后立即移除，从而正确放行共享子对象的有向无环结构（如 {a: shared, b: shared}）。
  */
-export function validateJsonValue(val, seen = new WeakSet()) {
+export function validateJsonValue(val, stack = new WeakSet()) {
     if (val === null || typeof val === "boolean" || typeof val === "string") {
         return { valid: true };
     }
@@ -26,26 +28,32 @@ export function validateJsonValue(val, seen = new WeakSet()) {
         return { valid: false, reason: `Unsupported JSON type '${typeof val}'` };
     }
     if (typeof val === "object") {
-        if (seen.has(val)) {
+        if (stack.has(val)) {
             return { valid: false, reason: "Circular reference detected in object structure" };
         }
-        seen.add(val);
-        if (Array.isArray(val)) {
-            for (const item of val) {
-                const res = validateJsonValue(item, seen);
-                if (!res.valid)
-                    return res;
+        stack.add(val);
+        try {
+            if (Array.isArray(val)) {
+                for (const item of val) {
+                    const res = validateJsonValue(item, stack);
+                    if (!res.valid)
+                        return res;
+                }
+                return { valid: true };
+            }
+            for (const v of Object.values(val)) {
+                if (v !== undefined) {
+                    const res = validateJsonValue(v, stack);
+                    if (!res.valid)
+                        return res;
+                }
             }
             return { valid: true };
         }
-        for (const v of Object.values(val)) {
-            if (v !== undefined) {
-                const res = validateJsonValue(v, seen);
-                if (!res.valid)
-                    return res;
-            }
+        finally {
+            // 无论正常返回还是提前返回，均须将当前对象移出路径栈，避免祖先对象被误判为环路
+            stack.delete(val);
         }
-        return { valid: true };
     }
     return { valid: true };
 }
@@ -63,6 +71,8 @@ let anonymousRunnerActionCounter = 0;
  */
 export class ActionRunner {
     packageId;
+    packageInstanceId;
+    generationId;
     storage;
     globalStorage;
     projectRoot;
@@ -76,6 +86,8 @@ export class ActionRunner {
     maxSubRuns;
     activeSubRuns = 0;
     packageRunners = new Map();
+    /** 跨包 Runner 构建中的 in-flight Promise：并发调用 await 同一构建任务，消除 check-then-act 竞态 */
+    pendingPackageRunners = new Map();
     actionResolver;
     getStorageForPackage;
     packageContextResolver;
@@ -83,6 +95,8 @@ export class ActionRunner {
     hostSessionId;
     constructor(options) {
         this.packageId = options.packageId;
+        this.packageInstanceId = options.packageInstanceId || options.packageId;
+        this.generationId = options.generationId || "1";
         this.hostSessionId = options.hostSessionId;
         this.projectRoot = options.projectRoot;
         this.projectConfig = options.projectConfig;
@@ -272,16 +286,38 @@ export class ActionRunner {
     }
     /**
      * 跨包运行时解析与获取（确保跨包执行具备独立的配置、存储、状态与 Action 注册表）。
+     *
+     * 缓存 miss 后存在长异步窗口（加载配置、扫描 Action、打开存储），并发调用会重复构建
+     * Runner、重复打开 SQLite 连接且子任务限流计数分裂；故以 in-flight Promise 去重，
+     * 并发方 await 同一构建任务，构建失败时移除该 Promise 以便后续重试。
      */
     async resolveTargetPackageRunner(targetPackageId) {
-        if (this.packageRunners.has(targetPackageId)) {
-            return this.packageRunners.get(targetPackageId);
+        const cached = this.packageRunners.get(targetPackageId);
+        if (cached) {
+            return cached;
+        }
+        const inFlight = this.pendingPackageRunners.get(targetPackageId);
+        if (inFlight) {
+            return inFlight;
         }
+        const building = this.buildTargetPackageRunner(targetPackageId).finally(() => {
+            // 无论成败均移除 in-flight 记录：成功者已写入正式缓存，失败者允许重试
+            this.pendingPackageRunners.delete(targetPackageId);
+        });
+        this.pendingPackageRunners.set(targetPackageId, building);
+        return building;
+    }
+    /**
+     * 实际构建跨包 Runner（仅由 resolveTargetPackageRunner 串行调度）。
+     */
+    async buildTargetPackageRunner(targetPackageId) {
         if (this.packageContextResolver) {
             const resolved = await this.packageContextResolver(targetPackageId);
             if (resolved) {
                 const runner = new ActionRunner({
                     packageId: targetPackageId,
+                    packageInstanceId: resolved.packageInstanceId || resolved.projectConfig?.packageInstanceId || targetPackageId,
+                    generationId: resolved.generationId || resolved.projectConfig?.generationId || "1",
                     storage: resolved.storage,
                     globalStorage: this.globalStorage,
                     projectRoot: resolved.projectRoot,
@@ -314,10 +350,9 @@ export class ActionRunner {
                 });
             }
             else {
-                const sqlitePath = config.storage?.sqlitePath || ".actiondock/storage.db";
-                const dbPath = join(root, sqlitePath);
-                const { SqliteRuntimeStorage } = await import("../storage/sqlite.js");
-                storage = new SqliteRuntimeStorage({ dbPath, packageId: targetPackageId, clock: this.clock });
+                // 回退分支与主路径共用 createStorage 单一事实源，确保 run 记录落在统一解析的库文件
+                const { createStorage } = await import("../storage/index.js");
+                storage = createStorage(targetPackageId, { projectRoot: root, customHome: this.customHome });
             }
             const actionsMap = await loadActions(root, config.actionsDir, {
                 autoInstall: false,
@@ -325,6 +360,8 @@ export class ActionRunner {
             });
             const runner = new ActionRunner({
                 packageId: targetPackageId,
+                packageInstanceId: config.packageInstanceId || targetPackageId,
+                generationId: config.generationId || "1",
                 storage,
                 globalStorage: this.globalStorage,
                 projectRoot: root,
@@ -578,9 +615,9 @@ export class ActionRunner {
             rootRunId: this.computeRootRunId(runCtx),
             parentRunId: options.parentRunId,
             packageId: targetPackageId,
-            packageInstanceId: options.packageInstanceId || targetPackageId,
+            packageInstanceId: options.packageInstanceId || (this.packageId === targetPackageId ? this.packageInstanceId : targetPackageId),
             actionId: targetActionId,
-            generationId: options.generationId || "1",
+            generationId: options.generationId || (this.packageId === targetPackageId ? this.generationId : "1"),
             ownerId: options.ownerId || "local",
             hostSessionId: options.hostSessionId || this.hostSessionId,
             status,
@@ -700,7 +737,13 @@ export class ActionRunner {
      */
     buildActionContext(args) {
         const { runCtx, controller, rootRunId } = args;
-        const { options, targetActionId, effectiveProcess } = runCtx;
+        const { options, targetPackageId, targetActionId, effectiveProcess } = runCtx;
+        const effectiveOwner = options.owner || {
+            tenantId: options.tenantId || "default",
+            principalId: options.principalId || options.ownerId || "default",
+            packageInstanceId: options.packageInstanceId || (this.packageId === targetPackageId ? this.packageInstanceId : targetPackageId),
+            generationId: options.generationId || (this.packageId === targetPackageId ? this.generationId : "1"),
+        };
         return createActionContext({
             actionId: targetActionId,
             storage: this.storage,
@@ -712,6 +755,7 @@ export class ActionRunner {
             parentRunId: options.parentRunId,
             signal: controller.signal,
             process: effectiveProcess,
+            owner: effectiveOwner,
             progress: options.progress,
             logger: options.logger || new StderrLogger(targetActionId),
             onActionInvoke: (childAction, childInput, parentRunId) => this.invokeChildAction({
@@ -742,12 +786,31 @@ export class ActionRunner {
             childPackageId = parsed.packageId;
         }
         const childActionId = parsed.actionId;
+        const effectiveParentOwner = options.owner || {
+            tenantId: options.tenantId || "default",
+            principalId: options.principalId || options.ownerId || "default",
+            packageInstanceId: options.packageInstanceId || this.packageInstanceId || this.packageId,
+            generationId: options.generationId || this.generationId || "1",
+        };
+        const isSamePackage = !childPackageId || childPackageId === this.packageId;
         this.activeSubRuns++;
         try {
             const runnerToUse = await this.resolveChildRunner(childPackageId, childActionId);
             if (runnerToUse !== this) {
                 this.assertDeclaredUses(runCtx.action, targetActionId, childPackageId, childActionId);
             }
+            const childPackageInstanceId = isSamePackage
+                ? effectiveParentOwner.packageInstanceId
+                : (runnerToUse !== this ? runnerToUse.packageInstanceId : childPackageId);
+            const childGenerationId = isSamePackage
+                ? effectiveParentOwner.generationId
+                : (runnerToUse !== this ? runnerToUse.generationId : "1");
+            const childOwner = {
+                tenantId: effectiveParentOwner.tenantId,
+                principalId: effectiveParentOwner.principalId,
+                packageInstanceId: childPackageInstanceId,
+                generationId: childGenerationId,
+            };
             const childResult = await runnerToUse.execute(childAction, childInput, {
                 rootRunId,
                 parentRunId,
@@ -759,6 +822,13 @@ export class ActionRunner {
                 logger: options.logger,
                 configOverrides: options.configOverrides,
                 maxCallDepth: options.maxCallDepth ?? this.maxCallDepth,
+                tenantId: childOwner.tenantId,
+                principalId: childOwner.principalId,
+                ownerId: childOwner.principalId,
+                packageInstanceId: childOwner.packageInstanceId,
+                generationId: childOwner.generationId,
+                owner: childOwner,
+                hostSessionId: options.hostSessionId ?? this.hostSessionId,
             });
             if (!childResult.ok) {
                 const err = new Error(childResult.error.message);
@@ -912,6 +982,17 @@ export class ActionRunner {
             catch (err) {
                 return this.classifyExecutionError(err, runCtx, controller, finalizer);
             }
+            finally {
+                // 仅释放 run 级隔离实例；平台级共享 ContextProcessAPI 生命周期归平台所有，严禁在此误 dispose
+                if (ctx &&
+                    ctx.process?.runScoped === true &&
+                    typeof ctx.process.dispose === "function") {
+                    try {
+                        await ctx.process.dispose();
+                    }
+                    catch { }
+                }
+            }
         })();
     }
     /**

package/dist/target/remote.js

@@ -215,6 +215,13 @@ export async function* streamRemoteEvents(serverUrl, runId, token, options) {
         throw err;
     }
     finally {
+        // 防御性取消底层流：仅 releaseLock 会让连接保持挂起，造成连接泄漏
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // 流已自然结束或已被取消时忽略次级异常
+        }
         try {
             reader.releaseLock();
         }

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/core",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "ActionDock Core Engine - Project loader, runtime execution, SQLite storage, standalone builder, and skill exporter",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,7 +29,7 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/sdk": "^2.2.2",
+    "@actiondock/sdk": "^2.3.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1"
   },