@actiondock/core 2.0.11 → 2.0.12

package/src/runtime/events.ts

@@ -1,142 +0,0 @@
-import type { ExecutionEvent } from "@actiondock/sdk";
-
-export interface EventSink {
-  emit(event: ExecutionEvent): void;
-  subscribe(
-    runId: string,
-    options?: { after?: number; signal?: AbortSignal }
-  ): AsyncIterable<ExecutionEvent>;
-  clear(runId: string): void;
-}
-
-/**
- * 进程内有界事件缓冲区实现。
- * 遵循设计文档：每个运行最多保留 1024 条或 1MB 事件，支持单调序号。
- */
-export class InMemoryEventSink implements EventSink {
-  private eventsByRun = new Map<string, ExecutionEvent[]>();
-  private listeners = new Map<string, Set<(event: ExecutionEvent) => void>>();
-  private maxEventsPerRun = 1024;
-
-  emit(event: ExecutionEvent): void {
-    let list = this.eventsByRun.get(event.runId);
-    if (!list) {
-      list = [];
-      this.eventsByRun.set(event.runId, list);
-    }
-
-    if (list.length >= this.maxEventsPerRun) {
-      // 淘汰旧日志和进度事件，保留状态和结果
-      const nonEssentialIndex = list.findIndex((e) => e.type === "log" || e.type === "progress");
-      if (nonEssentialIndex >= 0) {
-        list.splice(nonEssentialIndex, 1);
-      } else {
-        list.shift();
-      }
-    }
-    list.push(event);
-
-    const subs = this.listeners.get(event.runId);
-    if (subs) {
-      for (const listener of subs) {
-        try {
-          listener(event);
-        } catch {
-          // 忽略单个监听器内部异常
-        }
-      }
-    }
-  }
-
-  async *subscribe(
-    runId: string,
-    options: { after?: number; signal?: AbortSignal } = {}
-  ): AsyncIterable<ExecutionEvent> {
-    const after = options.after ?? -1;
-    const history = this.eventsByRun.get(runId) || [];
-
-    for (const evt of history) {
-      if (evt.sequence > after) {
-        yield evt;
-      }
-    }
-
-    const lastEvt = history[history.length - 1];
-    if (lastEvt && (lastEvt.type === "finish" || lastEvt.type === "status" && lastEvt.status !== "running")) {
-      return;
-    }
-
-    const queue: ExecutionEvent[] = [];
-    let notify: (() => void) | null = null;
-    let done = false;
-
-    const listener = (evt: ExecutionEvent) => {
-      if (evt.sequence > after) {
-        queue.push(evt);
-        if (notify) {
-          notify();
-          notify = null;
-        }
-        if (evt.type === "finish") {
-          done = true;
-        }
-      }
-    };
-
-    let subs = this.listeners.get(runId);
-    if (!subs) {
-      subs = new Set();
-      this.listeners.set(runId, subs);
-    }
-    subs.add(listener);
-
-    const cleanup = () => {
-      subs?.delete(listener);
-      if (subs && subs.size === 0) {
-        this.listeners.delete(runId);
-      }
-    };
-
-    if (options.signal) {
-      options.signal.addEventListener("abort", () => {
-        done = true;
-        if (notify) {
-          notify();
-          notify = null;
-        }
-      }, { once: true });
-    }
-
-    try {
-      while (!done && !options.signal?.aborted) {
-        if (queue.length > 0) {
-          yield queue.shift()!;
-        } else {
-          await new Promise<void>((resolve) => {
-            notify = resolve;
-          });
-        }
-      }
-      while (queue.length > 0) {
-        yield queue.shift()!;
-      }
-    } finally {
-      cleanup();
-    }
-  }
-
-  clear(runId: string): void {
-    this.eventsByRun.delete(runId);
-    this.listeners.delete(runId);
-  }
-}
-
-let defaultEventSink: EventSink = new InMemoryEventSink();
-
-export function getDefaultEventSink(): EventSink {
-  return defaultEventSink;
-}
-
-export function setDefaultEventSink(sink: EventSink): void {
-  defaultEventSink = sink;
-}

package/src/runtime/execution-manager.ts

@@ -1,74 +0,0 @@
-import type { ExecutionHandle } from "./runner";
-
-/**
- * 内存中活跃执行句柄（In-flight Execution Handles）生命周期管理器。
- * 
- * 职责：
- * 1. 集中追踪正在执行的异步 Action 任务句柄。
- * 2. 任务完成（无论成功或失败）后通过 Promise.finally 自动注销，防止内存泄漏。
- * 3. 支持依据 runId 查询、遍历或主动发送取消信号（cancel）。
- */
-export class ExecutionManager {
-  private active = new Map<string, ExecutionHandle>();
-
-  /**
-   * 注册一个活跃的执行句柄。
-   * 当底层 Promise 完成结算（resolve/reject）时，自动从活跃映射表中移除。
-   * 
-   * @param handle 执行句柄对象
-   */
-  public register(handle: ExecutionHandle): void {
-    this.active.set(handle.runId, handle);
-    handle.result.finally(() => {
-      this.active.delete(handle.runId);
-    });
-  }
-
-  /**
-   * 根据 runId 检索正在执行的任务句柄。
-   * 
-   * @param runId 运行 ID
-   * @returns 匹配的 ExecutionHandle 或 undefined
-   */
-  public get(runId: string): ExecutionHandle | undefined {
-    return this.active.get(runId);
-  }
-
-  /**
-   * 向指定 runId 的在途执行任务发送取消信号。
-   * 
-   * @param runId 目标运行 ID
-   * @param reason 取消原因描述
-   * @returns 若句柄存在且成功触发中断返回 true；若任务不存在或已完成返回 false
-   */
-  public cancel(runId: string, reason?: string): boolean {
-    const handle = this.active.get(runId);
-    if (!handle) {
-      return false;
-    }
-    return handle.cancel(reason);
-  }
-
-  /**
-   * 手动从活跃集合中移除执行句柄。
-   * 
-   * @param runId 运行 ID
-   */
-  public remove(runId: string): void {
-    this.active.delete(runId);
-  }
-
-  /**
-   * 获取当前系统中所有正在执行的活跃句柄列表。
-   */
-  public list(): ExecutionHandle[] {
-    return Array.from(this.active.values());
-  }
-
-  /**
-   * 清空所有活跃执行句柄。
-   */
-  public clear(): void {
-    this.active.clear();
-  }
-}

package/src/runtime/module-loader.ts

@@ -1,67 +0,0 @@
-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

@@ -1,245 +0,0 @@
-import { spawn } from "node:child_process";
-import type {
-  DetachedProcessOptions,
-  DetachedProcessResult,
-  ProcessAPI,
-  ProcessExecOptions,
-  ProcessResult,
-  RuntimeError,
-} from "@actiondock/sdk";
-
-export type ProcessExecutor = ProcessAPI;
-
-let globalProcessExecutor: ProcessExecutor | undefined;
-
-export function setProcessExecutor(executor: ProcessExecutor): void {
-  globalProcessExecutor = executor;
-}
-
-export function getProcessExecutor(): ProcessExecutor {
-  if (!globalProcessExecutor) {
-    globalProcessExecutor = new DefaultProcessExecutor();
-  }
-  return globalProcessExecutor;
-}
-
-/**
- * 基于 Node.js 标准 child_process 实现的基础进程执行器。
- */
-export class DefaultProcessExecutor implements ProcessExecutor {
-  async exec(
-    command: string,
-    args: string[] = [],
-    options: ProcessExecOptions = {}
-  ): Promise<ProcessResult> {
-    const startTime = Date.now();
-    const maxOutputBytes = options.maxOutputBytes ?? 10 * 1024 * 1024;
-
-    return new Promise<ProcessResult>((resolve, reject) => {
-      let stdoutBuf = "";
-      let stderrBuf = "";
-      let totalBytes = 0;
-      let timedOut = false;
-      let cancelled = false;
-      let error: RuntimeError | undefined;
-
-      const cp = spawn(command, args, {
-        cwd: options.cwd,
-        env: options.env ? { ...process.env, ...options.env } : process.env,
-        stdio: ["pipe", "pipe", "pipe"],
-      });
-
-      if (options.input) {
-        cp.stdin.write(options.input);
-        cp.stdin.end();
-      } else {
-        cp.stdin.end();
-      }
-
-      let timer: ReturnType<typeof setTimeout> | undefined;
-      if (options.timeoutMs && options.timeoutMs > 0) {
-        timer = setTimeout(() => {
-          timedOut = true;
-          cp.kill("SIGTERM");
-          setTimeout(() => {
-            if (!cp.killed) cp.kill("SIGKILL");
-          }, 1000);
-        }, options.timeoutMs);
-      }
-
-      const onAbort = () => {
-        cancelled = true;
-        cp.kill("SIGTERM");
-        setTimeout(() => {
-          if (!cp.killed) cp.kill("SIGKILL");
-        }, 1000);
-      };
-
-      if (options.signal) {
-        if (options.signal.aborted) {
-          onAbort();
-        } else {
-          options.signal.addEventListener("abort", onAbort, { once: true });
-        }
-      }
-
-      cp.stdout?.on("data", (chunk: Buffer) => {
-        totalBytes += chunk.length;
-        if (totalBytes > maxOutputBytes) {
-          error = {
-            code: "PROCESS_OUTPUT_LIMIT",
-            message: `Process output exceeded limit of ${maxOutputBytes} bytes`,
-          };
-          cp.kill("SIGKILL");
-          return;
-        }
-        stdoutBuf += chunk.toString("utf-8");
-      });
-
-      cp.stderr?.on("data", (chunk: Buffer) => {
-        totalBytes += chunk.length;
-        if (totalBytes > maxOutputBytes) {
-          error = {
-            code: "PROCESS_OUTPUT_LIMIT",
-            message: `Process output exceeded limit of ${maxOutputBytes} bytes`,
-          };
-          cp.kill("SIGKILL");
-          return;
-        }
-        stderrBuf += chunk.toString("utf-8");
-      });
-
-      cp.on("error", (err) => {
-        if (timer) clearTimeout(timer);
-        const durationMs = Date.now() - startTime;
-        const res: ProcessResult = {
-          ok: false,
-          exitCode: null,
-          stdout: stdoutBuf.trim(),
-          stderr: stderrBuf.trim() || err.message,
-          raw: new TextEncoder().encode(stdoutBuf),
-          timedOut,
-          cancelled,
-          durationMs,
-          error: error || {
-            code: "PROCESS_SPAWN_ERROR",
-            message: err.message,
-          },
-        };
-        if (options.throwOnError) {
-          reject(new Error(err.message));
-        } else {
-          resolve(res);
-        }
-      });
-
-      cp.on("close", (exitCode, signal) => {
-        if (timer) clearTimeout(timer);
-        const durationMs = Date.now() - startTime;
-        const ok = exitCode === 0 && !timedOut && !cancelled && !error;
-
-        const res: ProcessResult = {
-          ok,
-          exitCode,
-          signal: signal || undefined,
-          stdout: stdoutBuf.trim(),
-          stderr: stderrBuf.trim(),
-          raw: new TextEncoder().encode(stdoutBuf),
-          timedOut,
-          cancelled,
-          durationMs,
-          error,
-        };
-
-        if (!ok && options.throwOnError) {
-          reject(new Error(stderrBuf.trim() || `Process exited with code ${exitCode}`));
-        } else {
-          resolve(res);
-        }
-      });
-    });
-  }
-
-  async spawnDetached(options: DetachedProcessOptions): Promise<DetachedProcessResult> {
-    const startTime = Date.now();
-    try {
-      const child = spawn(options.command, options.args || [], {
-        cwd: options.cwd,
-        env: options.env ? { ...process.env, ...options.env } : process.env,
-        detached: true,
-        stdio: "ignore",
-      });
-
-      child.unref();
-
-      if (!options.probe) {
-        return {
-          ok: true,
-          pid: child.pid,
-          ready: true,
-          durationMs: Date.now() - startTime,
-        };
-      }
-
-      const probeInterval = options.probeIntervalMs ?? 200;
-      const probeTimeout = options.probeTimeoutMs ?? 5000;
-      const deadline = Date.now() + probeTimeout;
-
-      while (Date.now() < deadline) {
-        if (options.signal?.aborted) {
-          return {
-            ok: false,
-            pid: child.pid,
-            ready: false,
-            durationMs: Date.now() - startTime,
-            error: {
-              code: "PROCESS_CANCELLED",
-              message: "Probe was cancelled by AbortSignal",
-            },
-          };
-        }
-
-        try {
-          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 res;
-          }
-        } catch {
-          // 探测失败继续轮询
-        }
-
-        const remaining = deadline - Date.now();
-        if (remaining <= 0) break;
-        const sleepTime = Math.min(probeInterval, remaining);
-        await new Promise((r) => setTimeout(r, sleepTime));
-      }
-
-      return {
-        ok: false,
-        pid: child.pid,
-        ready: false,
-        durationMs: Date.now() - startTime,
-        error: {
-          code: "PROCESS_PROBE_TIMEOUT",
-          message: `Process probe timed out after ${probeTimeout}ms`,
-        },
-      };
-    } catch (err: any) {
-      return {
-        ok: false,
-        ready: false,
-        durationMs: Date.now() - startTime,
-        error: {
-          code: "PROCESS_DETACHED_FAILED",
-          message: err.message,
-        },
-      };
-    }
-  }
-}