@actiondock/core 2.0.9 → 2.0.11-beta.0

package/src/runtime/index.ts

@@ -6,4 +6,5 @@ export * from "./env";
 export * from "./clock";
 export * from "./process";
 export * from "./events";
+export * from "./module-loader";
 

package/src/runtime/module-loader.ts

@@ -0,0 +1,67 @@
+import { pathToFileURL } from "node:url";
+
+/**
+ * 统一源码模块加载器接口。
+ * 解耦 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 class DefaultModuleLoader implements ModuleLoader {
+  async load<T = any>(specifier: string, _parentPath?: string): Promise<T> {
+    const importSpecifier = specifier.startsWith("file://")
+      ? specifier
+      : pathToFileURL(specifier).href;
+    return (await import(importSpecifier)) as T;
+  }
+
+  async loadDefault<T = any>(specifier: string, parentPath?: string): Promise<T> {
+    const mod = await this.load<any>(specifier, parentPath);
+    return (mod?.default !== undefined ? mod.default : mod?.action !== undefined ? mod.action : mod) as T;
+  }
+}
+
+let globalModuleLoader: ModuleLoader | undefined;
+
+/**
+ * 注册全局模块加载器实现。
+ */
+export function setModuleLoader(loader: ModuleLoader): void {
+  globalModuleLoader = loader;
+}
+
+/**
+ * 获取当前全局模块加载器，若未显式注册则回退使用 DefaultModuleLoader。
+ */
+export function getModuleLoader(): ModuleLoader {
+  if (!globalModuleLoader) {
+    globalModuleLoader = new DefaultModuleLoader();
+  }
+  return globalModuleLoader;
+}

package/src/runtime/process.ts

@@ -200,23 +200,24 @@ export class DefaultProcessExecutor implements ProcessExecutor {
         }
 
         try {
-          const checkRes = await this.exec(options.command, ["--version"], {
-            timeoutMs: 1000,
-          });
-          const isReady = await options.probe(checkRes);
+          const res: DetachedProcessResult = {
+            ok: true,
+            pid: child.pid,
+            ready: true,
+            durationMs: Date.now() - startTime,
+          };
+          const isReady = await options.probe(res as any);
           if (isReady) {
-            return {
-              ok: true,
-              pid: child.pid,
-              ready: true,
-              durationMs: Date.now() - startTime,
-            };
+            return res;
           }
         } catch {
           // 探测失败继续轮询
         }
 
-        await new Promise((r) => setTimeout(r, probeInterval));
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) break;
+        const sleepTime = Math.min(probeInterval, remaining);
+        await new Promise((r) => setTimeout(r, sleepTime));
       }
 
       return {

package/src/runtime/runner.ts

@@ -1,19 +1,24 @@
+import { existsSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import type {
   ActionContext,
   ActionDefinition,
+  ActionRef,
   ExecutionResult,
   JsonValue,
+  Logger,
   ProcessAPI,
   ProgressReporter,
   RuntimeError,
   RunRecord,
 } from "@actiondock/sdk";
+import { ActionResolver } from "../catalog/action-resolver";
+import { loadActions, loadProjectConfig } from "../project/loader";
 import type { ProjectConfig } from "../project/types";
+import { resolveActionProject } from "../registry/registry";
 import { validateSchema } from "../schema/validator";
 import type { RuntimeStorage, TerminalRunStatus } from "../storage/types";
-import { RuntimeConfig, RuntimeStateStore, StderrLogger } from "./context";
-import { getProcessExecutor } from "./process";
+import { createActionContext, StderrLogger } from "./context";
 
 /**
  * ActionRunner 初始化配置选项。
@@ -31,12 +36,19 @@ export interface RunnerOptions {
   actions?: Map<string, ActionDefinition>;
   /** 外部注入的进程执行器 */
   process?: ProcessAPI;
+  /** 动态解析跨包或未注册 Action 的委托函数 */
+  actionResolver?: (
+    ref: ActionRef | string,
+    currentPackageId?: string
+  ) => ActionDefinition | undefined | Promise<ActionDefinition | undefined>;
 }
 
 /**
  * 启动 Action 执行时的可选控制参数。
  */
 export interface ExecutionStartOptions {
+  /** 显式指定的运行 ID */
+  runId?: string;
   /** 根运行 ID */
   rootRunId?: string;
   /** 父级运行 ID（嵌套调用场景下建立调用链树） */
@@ -57,6 +69,8 @@ export interface ExecutionStartOptions {
   process?: ProcessAPI;
   /** 外部注入的进度报告器 */
   progress?: ProgressReporter;
+  /** 外部注入的日志记录器 */
+  logger?: Logger;
 }
 
 /**
@@ -91,6 +105,10 @@ export class ActionRunner {
   private projectConfig?: ProjectConfig;
   private configOverrides: Record<string, unknown>;
   private actions: Map<string, ActionDefinition>;
+  private actionResolver?: (
+    ref: ActionRef | string,
+    currentPackageId?: string
+  ) => ActionDefinition | undefined | Promise<ActionDefinition | undefined>;
 
   constructor(options: RunnerOptions) {
     this.packageId = options.packageId;
@@ -98,6 +116,7 @@ export class ActionRunner {
     this.projectConfig = options.projectConfig;
     this.configOverrides = options.configOverrides || {};
     this.actions = options.actions || new Map();
+    this.actionResolver = options.actionResolver;
   }
 
   /**
@@ -114,6 +133,86 @@ export class ActionRunner {
     return this.actions.get(id);
   }
 
+  /**
+   * 动态解析 Action（支持本地注册表、自定义解析器委托与已链接包目录索引检索）。
+   * 
+   * @param actionOrRef Action 定义对象、引用或标识符
+   * @returns 解析出的 ActionDefinition，若未找到则返回 undefined
+   */
+  public async resolveAction(
+    actionOrRef: ActionDefinition | ActionRef | string
+  ): Promise<ActionDefinition | undefined> {
+    if (
+      typeof actionOrRef === "object" &&
+      "run" in actionOrRef &&
+      typeof (actionOrRef as any).run === "function"
+    ) {
+      return actionOrRef as ActionDefinition;
+    }
+
+    const ref = actionOrRef as ActionRef | string;
+    const parsed = ActionResolver.parseRef(ref);
+    const targetActionId = parsed.actionId;
+    const targetPackageId = parsed.packageId;
+
+    // 1. 本地 actions 映射表优先检索
+    if (targetPackageId && targetPackageId !== this.packageId) {
+      if (this.actions.has(`${targetPackageId}/${targetActionId}`)) {
+        return this.actions.get(`${targetPackageId}/${targetActionId}`);
+      }
+    } else {
+      if (this.actions.has(targetActionId)) {
+        return this.actions.get(targetActionId);
+      }
+      if (this.packageId && this.actions.has(`${this.packageId}/${targetActionId}`)) {
+        return this.actions.get(`${this.packageId}/${targetActionId}`);
+      }
+    }
+
+    // 2. 外部注入的自定义 actionResolver 调度
+    if (this.actionResolver) {
+      const customResolved = await this.actionResolver(ref, this.packageId);
+      if (customResolved) {
+        if (targetPackageId && targetPackageId !== this.packageId) {
+          this.actions.set(`${targetPackageId}/${targetActionId}`, customResolved);
+        } else {
+          this.actions.set(targetActionId, customResolved);
+          if (this.packageId) {
+            this.actions.set(`${this.packageId}/${targetActionId}`, customResolved);
+          }
+        }
+        return customResolved;
+      }
+    }
+
+    // 3. 基于全局链接注册表与目录索引的动态寻址与按需加载
+    try {
+      const identifier = targetPackageId
+        ? `${targetPackageId}/${targetActionId}`
+        : targetActionId;
+      const resolved = await resolveActionProject(identifier);
+      if (resolved && existsSync(resolved.projectRoot)) {
+        const config = loadProjectConfig(resolved.projectRoot);
+        const actionsMap = await loadActions(resolved.projectRoot, config.actionsDir, {
+          autoInstall: false,
+        });
+        const matched = actionsMap.get(resolved.actionId);
+        if (matched) {
+          this.actions.set(`${resolved.packageId}/${resolved.actionId}`, matched);
+          // 仅当目标包就是当前项目时才注册短标识符，避免跨包动态载入污染全局短标识符
+          if (!targetPackageId || resolved.packageId === this.packageId) {
+            this.actions.set(resolved.actionId, matched);
+          }
+          return matched;
+        }
+      }
+    } catch {
+      // 忽略寻址异常并返回 undefined
+    }
+
+    return undefined;
+  }
+
   /**
    * 获取当前 Runner 已注册的所有 Action 列表。
    */
@@ -124,44 +223,61 @@ export class ActionRunner {
   /**
    * 异步启动 Action 的执行并立即返回 ExecutionHandle 句柄。
    * 
-   * @param actionOrId Action 定义对象或已注册的 Action ID
+   * @param actionOrId Action 定义对象、引用或标识符
    * @param input 传递给 Action 的输入数据
    * @param options 执行控制选项（超时、取消信号、父运行 ID 等）
    * @returns 包含 runId、result Promise 和 cancel 方法的执行句柄
    */
   start(
-    actionOrId: ActionDefinition | string,
+    actionOrId: ActionDefinition | ActionRef | string,
     input: unknown = {},
     options: ExecutionStartOptions = {}
   ): ExecutionHandle {
-    const runId = randomUUID();
+    const runId = options.runId || randomUUID();
     const startedAt = new Date().toISOString();
     const callStack = [...(options.callStack || [])];
 
-    let action: ActionDefinition;
-    if (typeof actionOrId === "string") {
-      const found = this.actions.get(actionOrId);
-      if (!found) {
-        const error: RuntimeError = {
-          code: "ACTION_NOT_FOUND",
-          message: `Action '${actionOrId}' not found in registry`,
-        };
-        return {
-          runId,
-          result: Promise.resolve({ ok: false, runId, error }),
-          cancel: () => false,
-        };
-      }
-      action = found;
+    let action: ActionDefinition | undefined;
+    let targetActionId: string;
+    let targetPackageId: string = this.packageId;
+
+    if (
+      typeof actionOrId === "object" &&
+      "run" in actionOrId &&
+      typeof (actionOrId as any).run === "function"
+    ) {
+      action = actionOrId as ActionDefinition;
+      targetActionId = action.id;
     } else {
-      action = actionOrId;
+      const parsed = ActionResolver.parseRef(actionOrId as ActionRef | string);
+      targetActionId = parsed.actionId;
+      if (parsed.packageId) {
+        targetPackageId = parsed.packageId;
+      }
+
+      if (parsed.packageId && parsed.packageId !== this.packageId) {
+        action = this.actions.get(`${parsed.packageId}/${targetActionId}`);
+      } else {
+        action =
+          this.actions.get(targetActionId) ||
+          (this.packageId ? this.actions.get(`${this.packageId}/${targetActionId}`) : undefined);
+      }
     }
 
     // 1. 环路死锁检测 (Cycle Detection)
-    if (callStack.includes(action.id)) {
+    const isExternal = Boolean(targetPackageId && targetPackageId !== this.packageId);
+    const callKey = isExternal
+      ? `${targetPackageId}/${targetActionId}`
+      : targetActionId;
+
+    const hasCycle = isExternal
+      ? callStack.includes(callKey)
+      : (callStack.includes(callKey) || (this.packageId ? callStack.includes(`${this.packageId}/${targetActionId}`) : false));
+
+    if (hasCycle) {
       const error: RuntimeError = {
         code: "ACTION_CYCLE_DETECTED",
-        message: `Cycle detected in action invocation: ${callStack.join(" -> ")} -> ${action.id}`,
+        message: `Cycle detected in action invocation: ${callStack.join(" -> ")} -> ${callKey}`,
       };
       return {
         runId,
@@ -169,10 +285,10 @@ export class ActionRunner {
         cancel: () => false,
       };
     }
-    callStack.push(action.id);
+    callStack.push(callKey);
 
-    // 2. 输入参数 JSON Schema 校验
-    if (action.inputSchema) {
+    // 2. 输入参数 JSON Schema 校验（若 action 已就绪）
+    if (action?.inputSchema) {
       const val = validateSchema(action.inputSchema, input);
       if (!val.valid) {
         const error: RuntimeError = {
@@ -193,9 +309,9 @@ export class ActionRunner {
       id: runId,
       rootRunId: options.rootRunId || options.parentRunId || runId,
       parentRunId: options.parentRunId,
-      packageId: this.packageId,
-      packageInstanceId: options.packageInstanceId || this.packageId,
-      actionId: action.id,
+      packageId: targetPackageId,
+      packageInstanceId: options.packageInstanceId || targetPackageId,
+      actionId: targetActionId,
       generationId: options.generationId || "1",
       ownerId: options.ownerId || "local",
       status: "running",
@@ -243,26 +359,26 @@ export class ActionRunner {
     };
 
     // 5. 构建 ActionContext 运行时上下文
-    const config = new RuntimeConfig(
-      this.storage,
-      this.configOverrides,
-      this.projectConfig
-    );
-    const state = new RuntimeStateStore(this.storage);
-    const log = new StderrLogger(action.id);
-
-    const invoker = {
-      invoke: async <I, O>(
-        childAction: ActionDefinition<I, O>,
-        childInput: I
-      ): Promise<O> => {
+    const ctx = createActionContext({
+      storage: this.storage,
+      overrides: this.configOverrides,
+      projectConfig: this.projectConfig,
+      runId,
+      rootRunId: initialRun.rootRunId,
+      parentRunId: options.parentRunId,
+      signal: controller.signal,
+      process: options.process,
+      progress: options.progress,
+      logger: options.logger || new StderrLogger(action?.id || targetActionId),
+      onActionInvoke: async (childAction, childInput, parentRunId) => {
         const childResult = await this.execute(childAction, childInput, {
           rootRunId: initialRun.rootRunId,
-          parentRunId: runId,
+          parentRunId,
           callStack,
           signal: controller.signal,
           process: options.process,
           progress: options.progress,
+          logger: options.logger,
         });
         if (!childResult.ok) {
           const err = new Error(childResult.error.message);
@@ -270,26 +386,9 @@ export class ActionRunner {
           (err as any).details = childResult.error.details;
           throw err;
         }
-        return childResult.data as O;
+        return childResult.data;
       },
-    };
-
-    const ctx: ActionContext = {
-      config,
-      state,
-      actions: invoker,
-      process: options.process || getProcessExecutor(),
-      log,
-      progress: options.progress || {
-        report() {},
-      },
-      signal: controller.signal,
-      run: {
-        id: runId,
-        rootId: initialRun.rootRunId,
-        parentId: options.parentRunId,
-      },
-    };
+    });
 
     // 6. 执行 Action 业务逻辑并与取消/超时信号进行竞态
     const abortPromise = new Promise<never>((_, reject) => {
@@ -306,18 +405,44 @@ export class ActionRunner {
 
     const executionPromise = (async (): Promise<ExecutionResult> => {
       try {
+        let currentAction = action;
+        if (!currentAction) {
+          currentAction = await this.resolveAction(actionOrId);
+          if (!currentAction) {
+            const error: RuntimeError = {
+              code: "ACTION_NOT_FOUND",
+              message: `Action '${targetActionId}' not found in registry or linked packages`,
+            };
+            finalizeRun("failed", undefined, error);
+            return { ok: false, runId, error };
+          }
+
+          if (currentAction.inputSchema) {
+            const val = validateSchema(currentAction.inputSchema, input);
+            if (!val.valid) {
+              const error: RuntimeError = {
+                code: "INPUT_VALIDATION_FAILED",
+                message: `Input schema validation failed for action '${currentAction.id}'`,
+                details: val.errors,
+              };
+              finalizeRun("failed", undefined, error);
+              return { ok: false, runId, error };
+            }
+          }
+        }
+
         const rawOutput = await Promise.race([
-          Promise.resolve().then(() => action.run(input, ctx)),
+          Promise.resolve().then(() => currentAction!.run(input, ctx)),
           abortPromise,
         ]);
 
         // 输出结果 Schema 校验
-        if (action.outputSchema) {
-          const outVal = validateSchema(action.outputSchema, rawOutput);
+        if (currentAction.outputSchema) {
+          const outVal = validateSchema(currentAction.outputSchema, rawOutput);
           if (!outVal.valid) {
             const error: RuntimeError = {
               code: "OUTPUT_VALIDATION_FAILED",
-              message: `Output schema validation failed for action '${action.id}'`,
+              message: `Output schema validation failed for action '${currentAction.id}'`,
               details: outVal.errors,
             };
             finalizeRun("failed", undefined, error);
@@ -388,12 +513,12 @@ export class ActionRunner {
   /**
    * 同步等待方式执行指定 Action，直接返回 ExecutionResult 信封结果。
    * 
-   * @param actionOrId Action 定义对象或 ID
+   * @param actionOrId Action 定义对象、引用或标识符
    * @param input 输入参数
    * @param options 执行控制选项
    */
   async execute(
-    actionOrId: ActionDefinition | string,
+    actionOrId: ActionDefinition | ActionRef | string,
     input: unknown = {},
     options: ExecutionStartOptions = {}
   ): Promise<ExecutionResult> {

package/src/server/index.ts

@@ -2,5 +2,6 @@ export * from "./types";
 export * from "./security";
 export * from "./body";
 export * from "./runtime-registry";
+export * from "./routes";
 export * from "./server";