@actiondock/core 2.0.2 → 2.0.4

package/src/runtime/process.ts

@@ -0,0 +1,244 @@
+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 checkRes = await this.exec(options.command, ["--version"], {
+            timeoutMs: 1000,
+          });
+          const isReady = await options.probe(checkRes);
+          if (isReady) {
+            return {
+              ok: true,
+              pid: child.pid,
+              ready: true,
+              durationMs: Date.now() - startTime,
+            };
+          }
+        } catch {
+          // 探测失败继续轮询
+        }
+
+        await new Promise((r) => setTimeout(r, probeInterval));
+      }
+
+      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,
+        },
+      };
+    }
+  }
+}

package/src/runtime/runner.ts

@@ -3,6 +3,9 @@ import type {
   ActionContext,
   ActionDefinition,
   ExecutionResult,
+  JsonValue,
+  ProcessAPI,
+  ProgressReporter,
   RuntimeError,
   RunRecord,
 } from "@actiondock/sdk";
@@ -10,6 +13,7 @@ import type { ProjectConfig } from "../project/types";
 import { validateSchema } from "../schema/validator";
 import type { RuntimeStorage, TerminalRunStatus } from "../storage/types";
 import { RuntimeConfig, RuntimeStateStore, StderrLogger } from "./context";
+import { getProcessExecutor } from "./process";
 
 /**
  * ActionRunner 初始化配置选项。
@@ -25,20 +29,34 @@ export interface RunnerOptions {
   configOverrides?: Record<string, unknown>;
   /** 预加载的 Action 映射表 */
   actions?: Map<string, ActionDefinition>;
+  /** 外部注入的进程执行器 */
+  process?: ProcessAPI;
 }
 
 /**
  * 启动 Action 执行时的可选控制参数。
  */
 export interface ExecutionStartOptions {
+  /** 根运行 ID */
+  rootRunId?: string;
   /** 父级运行 ID（嵌套调用场景下建立调用链树） */
   parentRunId?: string;
+  /** 包物理实例标识 */
+  packageInstanceId?: string;
+  /** 快照代次标识 */
+  generationId?: string;
+  /** 执行所有者标识 */
+  ownerId?: string;
   /** 调用栈数组（用于检测 A -> B -> A 环路死锁） */
   callStack?: string[];
   /** 外部传入的 AbortSignal 取消信号 */
   signal?: AbortSignal;
   /** 最大超时时间（毫秒），超时将自动中止执行并标记为 ACTION_TIMEOUT */
   timeoutMs?: number;
+  /** 外部注入的进程执行器 */
+  process?: ProcessAPI;
+  /** 外部注入的进度报告器 */
+  progress?: ProgressReporter;
 }
 
 /**
@@ -173,11 +191,15 @@ export class ActionRunner {
     // 3. 插入初始运行记录 (状态: running)
     const initialRun: RunRecord = {
       id: runId,
+      rootRunId: options.rootRunId || options.parentRunId || runId,
+      parentRunId: options.parentRunId,
       packageId: this.packageId,
+      packageInstanceId: options.packageInstanceId || this.packageId,
       actionId: action.id,
-      parentRunId: options.parentRunId,
+      generationId: options.generationId || "1",
+      ownerId: options.ownerId || "local",
       status: "running",
-      input,
+      input: input as JsonValue | undefined,
       startedAt,
     };
     this.storage.createRun(initialRun);
@@ -235,9 +257,12 @@ export class ActionRunner {
         childInput: I
       ): Promise<O> => {
         const childResult = await this.execute(childAction, childInput, {
+          rootRunId: initialRun.rootRunId,
           parentRunId: runId,
           callStack,
           signal: controller.signal,
+          process: options.process,
+          progress: options.progress,
         });
         if (!childResult.ok) {
           const err = new Error(childResult.error.message);
@@ -253,8 +278,17 @@ export class ActionRunner {
       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 业务逻辑并与取消/超时信号进行竞态
@@ -295,7 +329,7 @@ export class ActionRunner {
         return {
           ok: true,
           runId,
-          data: rawOutput,
+          data: rawOutput as JsonValue,
         };
       } catch (err: any) {
         if (isTimeout) {

package/src/server/server.ts

@@ -18,10 +18,107 @@ import {
 } from "../registry/registry";
 import { ActionRunner } from "../runtime/runner";
 import type { RuntimeStorage } from "../storage/types";
+import { createServer as createNodeHttpServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import { InvalidJsonError, readJsonBody, RequestTooLargeError } from "./body";
 import { ServerRuntimeRegistry } from "./runtime-registry";
 import { isLoopbackHost, resolveCorsHeaders, verifyBearerToken } from "./security";
-import type { ActionDockServerInstance, ServerOptions } from "./types";
+import type { ActionDockServerInstance, CoreHttpServerFactory, CoreHttpServerInstance, ServerOptions } from "./types";
+
+let customHttpServerFactory: CoreHttpServerFactory | undefined;
+
+/**
+ * 注册自定义 HTTP 服务端工厂（用于 Node.js / Bun 运行时环境适配）。
+ */
+export function setHttpServerFactory(factory: CoreHttpServerFactory): void {
+  customHttpServerFactory = factory;
+}
+
+/**
+ * 根据当前运行时环境启动标准 Web Request/Response 兼容的 HTTP 服务。
+ */
+export function launchHttpServer(
+  port: number,
+  host: string,
+  fetchHandler: (req: Request) => Promise<Response>
+): CoreHttpServerInstance {
+  if (customHttpServerFactory) {
+    return customHttpServerFactory({ port, host, fetch: fetchHandler }) as CoreHttpServerInstance;
+  }
+
+  // 若处于原生 Bun 运行时
+  if (typeof (globalThis as any).Bun !== "undefined" && typeof (globalThis as any).Bun.serve === "function") {
+    const bunServer = (globalThis as any).Bun.serve({
+      port,
+      hostname: host,
+      fetch: fetchHandler,
+    });
+    return {
+      port: bunServer.port,
+      stop: (closeActive?: boolean) => bunServer.stop(closeActive),
+    };
+  }
+
+  // Node.js 原生 node:http 兜底实现
+  const srv = createNodeHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    try {
+      const protocol = (req.socket as any)?.encrypted ? "https" : "http";
+      const hostHeader = req.headers.host || "127.0.0.1";
+      const url = new URL(req.url || "/", `${protocol}://${hostHeader}`).href;
+
+      const headers = new Headers();
+      for (const [k, v] of Object.entries(req.headers)) {
+        if (v === undefined) continue;
+        if (Array.isArray(v)) {
+          for (const item of v) headers.append(k, item);
+        } else {
+          headers.set(k, v);
+        }
+      }
+
+      const method = (req.method || "GET").toUpperCase();
+      const hasBody = method !== "GET" && method !== "HEAD";
+      const init: RequestInit = { method, headers };
+      if (hasBody) {
+        (init as any).body = Readable.toWeb(req);
+        (init as any).duplex = "half";
+      }
+
+      const webReq = new Request(url, init);
+      const webRes = await fetchHandler(webReq);
+
+      res.statusCode = webRes.status;
+      if (webRes.statusText) res.statusMessage = webRes.statusText;
+      webRes.headers.forEach((v, k) => res.setHeader(k, v));
+
+      if (!webRes.body) {
+        res.end();
+        return;
+      }
+      await pipeline(Readable.fromWeb(webRes.body as any), res);
+    } catch (err: any) {
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: err?.message || String(err) }));
+      } else {
+        res.destroy(err);
+      }
+    }
+  });
+
+  srv.listen(port, host);
+  const addr = srv.address();
+  const actualPort = typeof addr === "object" && addr ? addr.port : port;
+
+  return {
+    port: actualPort,
+    stop: () => {
+      srv.close();
+      (srv as any).closeAllConnections?.();
+    },
+  };
+}
 
 /**
  * 辅助函数：快速构造带 CORS 头的 JSON HTTP 响应。
@@ -176,11 +273,8 @@ export function startActionDockServer(
 
   const runtimeRegistry = new ServerRuntimeRegistry();
 
-  const server = Bun.serve({
-    port,
-    hostname: host,
-    async fetch(req) {
-      const origin = req.headers.get("origin");
+  const server = launchHttpServer(port, host, async (req) => {
+    const origin = req.headers.get("origin");
       const corsHeaders = resolveCorsHeaders(origin, options.corsOrigins);
 
       if (req.method === "OPTIONS") {
@@ -1379,8 +1473,8 @@ export function startActionDockServer(
         404,
         corsHeaders
       );
-    },
-  });
+    }
+  );
 
   const actualHost = host === "0.0.0.0" ? "127.0.0.1" : host;
   const url = `http://${actualHost}:${server.port}`;

package/src/server/types.ts

@@ -1,5 +1,16 @@
 import type { ServerRuntimeRegistry } from "./runtime-registry";
 
+export interface CoreHttpServerInstance {
+  port: number;
+  stop: (closeActiveConnections?: boolean) => void | Promise<void>;
+}
+
+export type CoreHttpServerFactory = (options: {
+  port: number;
+  host: string;
+  fetch: (req: Request) => Promise<Response>;
+}) => CoreHttpServerInstance | Promise<CoreHttpServerInstance>;
+
 /**
  * 启动 ActionDock HTTP Runner 服务端的配置选项。
  */

package/src/storage/driver.ts

@@ -0,0 +1,126 @@
+import { createRequire } from "node:module";
+import type { SqliteDriver } from "./types";
+
+export type SqliteDriverFactory = (dbPath: string) => SqliteDriver;
+
+/** ESM 环境下可用的 CommonJS require，用于动态加载 node:sqlite / bun:sqlite */
+const cjsRequire = createRequire(import.meta.url);
+
+let customDriverFactory: SqliteDriverFactory | undefined;
+
+/**
+ * 注册全局默认 SQLite 驱动工厂。
+ */
+export function setSqliteDriverFactory(factory: SqliteDriverFactory): void {
+  customDriverFactory = factory;
+}
+
+/**
+ * 创建默认 SQLite 驱动实例。
+ * 优先使用外部注册的工厂，其次根据当前运行时环境自动适配。
+ */
+export function createDefaultSqliteDriver(dbPath: string): SqliteDriver {
+  if (customDriverFactory) {
+    return customDriverFactory(dbPath);
+  }
+
+  // 检查是否在 Bun 运行时环境
+  if (typeof (globalThis as any).Bun !== "undefined") {
+    try {
+      const { Database } = (globalThis as any).Bun.sqlite || cjsRequire("bun:sqlite");
+      const db = new Database(dbPath);
+      // bun:sqlite 的 statement 未 finalize 时会一直持有数据库文件句柄，
+      // Windows 下导致 db.close() 后文件仍被锁（EBUSY 无法删除）。
+      // 跟踪全部 prepared statement，close() 时统一 finalize 释放句柄。
+      const openStatements = new Set<any>();
+      return {
+        exec(sql: string) {
+          db.exec(sql);
+        },
+        prepare(sql: string) {
+          const stmt = db.prepare(sql);
+          openStatements.add(stmt);
+          return {
+            run(...args: any[]) {
+              const params = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+              const res = stmt.run(...params);
+              return { changes: res.changes, lastInsertRowid: res.lastInsertRowid };
+            },
+            get<T>(...args: any[]): T | undefined {
+              const params = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+              return stmt.get(...params) as T | undefined;
+            },
+            all<T>(...args: any[]): T[] {
+              const params = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+              return stmt.all(...params) as T[];
+            },
+          };
+        },
+        transaction<T>(fn: () => T extends PromiseLike<unknown> ? never : T): T {
+          return db.transaction(fn)() as T;
+        },
+        close() {
+          for (const stmt of openStatements) {
+            try {
+              stmt.finalize();
+            } catch {
+              // 已 finalize 或重复释放时忽略
+            }
+          }
+          openStatements.clear();
+          db.close();
+        },
+      };
+    } catch {
+      // 若在 Bun 下获取 bun:sqlite 失败，回退到标准 Node 驱动尝试
+    }
+  }
+
+  // 在 Node.js 环境下使用 node:sqlite
+  try {
+    const { DatabaseSync } = cjsRequire("node:sqlite");
+    const db = new DatabaseSync(dbPath);
+    return {
+      exec(sql: string) {
+        db.exec(sql);
+      },
+      prepare(sql: string) {
+        const stmt = db.prepare(sql);
+        return {
+          run(...args: any[]) {
+            const params = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+            const res = stmt.run(...params);
+            return { changes: res.changes, lastInsertRowid: res.lastInsertRowid };
+          },
+          get<T>(...args: any[]): T | undefined {
+            const params = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+            return stmt.get(...params) as T | undefined;
+          },
+          all<T>(...args: any[]): T[] {
+            const params = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+            return stmt.all(...params) as T[];
+          },
+        };
+      },
+      transaction<T>(fn: () => T extends PromiseLike<unknown> ? never : T): T {
+        db.exec("BEGIN");
+        try {
+          const res = fn();
+          if (res && typeof (res as any).then === "function") {
+            throw new Error("Async transactions are not allowed in SQLite");
+          }
+          db.exec("COMMIT");
+          return res;
+        } catch (e) {
+          db.exec("ROLLBACK");
+          throw e;
+        }
+      },
+      close() {
+        db.close();
+      },
+    };
+  } catch (err: any) {
+    throw new Error(`Failed to initialize SQLite driver: ${err?.message || String(err)}`);
+  }
+}

package/src/storage/index.ts

@@ -1,8 +1,9 @@
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { getActionDockHome } from "../utils";
 import { SqliteRuntimeStorage } from "./sqlite";
 import type { RuntimeStorage, StorageOptions } from "./types";
 
+export * from "./driver";
 export * from "./mask";
 export * from "./sqlite";
 export * from "./types";
@@ -33,7 +34,7 @@ export function resolveDatabasePath(
     return join(options.projectRoot, ".actiondock", "runtime.db");
   }
   // 独立执行二进制默认存储路径: ~/.actiondock/data/<package-id>/runtime.db
-  return join(homedir(), ".actiondock", "data", packageId, "runtime.db");
+  return join(getActionDockHome(), ".actiondock", "data", packageId, "runtime.db");
 }
 
 /**
@@ -57,7 +58,7 @@ export function createStorage(
  * @param customHome 自定义家目录路径（可选）
  */
 export function createGlobalStorage(customHome?: string): RuntimeStorage {
-  const baseDir = customHome || process.env.ACTIONDOCK_HOME || homedir();
+  const baseDir = getActionDockHome(customHome);
   const dbPath = join(baseDir, ".actiondock", "global.db");
   return new SqliteRuntimeStorage({ dbPath, packageId: "__global__" });
 }