@actiondock/core 2.0.11 → 2.2.0

package/src/execution/service.ts

@@ -1,322 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type {
-  ActionDefinition,
-  ActionRef,
-  ExecutionEvent,
-  ExecutionResult,
-  JsonValue,
-  Logger,
-  ProgressReporter,
-  RunRecord,
-  RunStatus,
-} from "@actiondock/sdk";
-import type { ProjectConfig } from "../project/types";
-import { type EventSink, getDefaultEventSink } from "../runtime/events";
-import { ActionRunner, type ExecutionHandle } from "../runtime/runner";
-import type { RuntimeStorage } from "../storage/types";
-import type {
-  CancelResult,
-  ExecuteOptions,
-  ExecutionService,
-  ExecutionTicket,
-} from "./types";
-
-export interface ExecutionServiceOptions {
-  packageId: string;
-  storage: RuntimeStorage;
-  projectConfig?: ProjectConfig;
-  eventSink?: EventSink;
-  maxActiveRuns?: number;
-  ownerId?: string;
-  actionResolver?: (ref: ActionRef) => ActionDefinition | undefined | Promise<ActionDefinition | undefined>;
-}
-
-interface ActiveRun {
-  runId: string;
-  handle: ExecutionHandle;
-  controller: AbortController;
-  status: RunStatus;
-  startedAt: string;
-}
-
-/**
- * 统一执行协调服务实现。
- */
-export class DefaultExecutionService implements ExecutionService {
-  private packageId: string;
-  private storage: RuntimeStorage;
-  private projectConfig?: ProjectConfig;
-  private eventSink: EventSink;
-  private maxActiveRuns: number;
-  private ownerId: string;
-  private runner: ActionRunner;
-  private actionResolver?: (ref: ActionRef) => ActionDefinition | undefined | Promise<ActionDefinition | undefined>;
-  private activeRuns = new Map<string, ActiveRun>();
-  private isClosing = false;
-
-  constructor(options: ExecutionServiceOptions) {
-    this.packageId = options.packageId;
-    this.storage = options.storage;
-    this.projectConfig = options.projectConfig;
-    this.eventSink = options.eventSink || getDefaultEventSink();
-    this.maxActiveRuns = options.maxActiveRuns || 32;
-    this.ownerId = options.ownerId || `host-${randomUUID().slice(0, 8)}`;
-    this.actionResolver = options.actionResolver;
-
-    this.runner = new ActionRunner({
-      packageId: this.packageId,
-      storage: this.storage,
-      projectConfig: this.projectConfig,
-    });
-  }
-
-  public registerAction(action: ActionDefinition): void {
-    this.runner.registerAction(action);
-  }
-
-  private async resolveTargetAction(ref: ActionRef): Promise<ActionDefinition | undefined> {
-    const fromRunner = this.runner.getAction(ref.actionId);
-    if (fromRunner) return fromRunner;
-    if (this.actionResolver) {
-      return this.actionResolver(ref);
-    }
-    return undefined;
-  }
-
-  async execute(
-    ref: ActionRef,
-    input: JsonValue,
-    options: ExecuteOptions = {}
-  ): Promise<ExecutionResult> {
-    const ticket = await this.start(ref, input, options);
-    const active = this.activeRuns.get(ticket.runId);
-    if (!active) {
-      const record = await this.get(ticket.runId);
-      if (record && record.status === "success") {
-        return { ok: true, runId: ticket.runId, data: record.output ?? null };
-      }
-      return {
-        ok: false,
-        runId: ticket.runId,
-        error: record?.error || {
-          code: "RUN_TERMINATED_EARLY",
-          message: `Run ${ticket.runId} terminated without result`,
-        },
-      };
-    }
-    return active.handle.result;
-  }
-
-  async start(
-    ref: ActionRef,
-    input: JsonValue,
-    options: ExecuteOptions = {}
-  ): Promise<ExecutionTicket> {
-    if (this.isClosing) {
-      throw new Error("ExecutionService is closing: new tasks rejected");
-    }
-
-    if (this.activeRuns.size >= this.maxActiveRuns) {
-      throw new Error(
-        `Concurrency limit reached: ${this.activeRuns.size}/${this.maxActiveRuns} active runs`
-      );
-    }
-
-    const action = await this.resolveTargetAction(ref);
-    if (!action) {
-      const runId = randomUUID();
-      const errEvt: ExecutionEvent = {
-        runId,
-        rootRunId: runId,
-        sequence: 0,
-        timestamp: new Date().toISOString(),
-        type: "finish",
-        result: {
-          ok: false,
-          runId,
-          error: {
-            code: "ACTION_NOT_FOUND",
-            message: `Action '${ref.actionId}' not found in package '${ref.packageId || this.packageId}'`,
-          },
-        },
-      };
-      this.eventSink.emit(errEvt);
-      return {
-        runId,
-        status: "failed",
-      };
-    }
-
-    const controller = new AbortController();
-    if (options.signal) {
-      if (options.signal.aborted) {
-        controller.abort(options.signal.reason);
-      } else {
-        options.signal.addEventListener(
-          "abort",
-          () => controller.abort(options.signal?.reason),
-          { once: true }
-        );
-      }
-    }
-
-    const runId = randomUUID();
-    let sequence = 0;
-    type EventPayload =
-      | { type: "log"; level: "debug" | "info" | "warn" | "error"; message: string; data?: JsonValue }
-      | { type: "progress"; current?: number; total?: number; message?: string }
-      | { type: "status"; status: RunStatus }
-      | { type: "finish"; result: ExecutionResult };
-
-    const emitEvent = (payload: EventPayload) => {
-      const evt: ExecutionEvent = {
-        ...payload,
-        runId,
-        rootRunId: runId,
-        sequence: sequence++,
-        timestamp: new Date().toISOString(),
-      };
-      this.eventSink.emit(evt);
-    };
-
-    const progressReporter: ProgressReporter = {
-      report(current: number, total?: number, message?: string) {
-        emitEvent({
-          type: "progress",
-          current,
-          total,
-          message,
-        });
-      },
-    };
-
-    const executionLogger: Logger = {
-      debug(message: string, data?: unknown) {
-        emitEvent({
-          type: "log",
-          level: "debug",
-          message,
-          data: data as JsonValue | undefined,
-        });
-      },
-      info(message: string, data?: unknown) {
-        emitEvent({
-          type: "log",
-          level: "info",
-          message,
-          data: data as JsonValue | undefined,
-        });
-      },
-      warn(message: string, data?: unknown) {
-        emitEvent({
-          type: "log",
-          level: "warn",
-          message,
-          data: data as JsonValue | undefined,
-        });
-      },
-      error(message: string, data?: unknown) {
-        emitEvent({
-          type: "log",
-          level: "error",
-          message,
-          data: data as JsonValue | undefined,
-        });
-      },
-    };
-
-    const handle = this.runner.start(action, input, {
-      runId,
-      signal: controller.signal,
-      timeoutMs: options.timeoutMs,
-      progress: progressReporter,
-      logger: executionLogger,
-    });
-
-    const activeItem: ActiveRun = {
-      runId: handle.runId,
-      handle,
-      controller,
-      status: "running",
-      startedAt: new Date().toISOString(),
-    };
-
-    this.activeRuns.set(handle.runId, activeItem);
-    emitEvent({ type: "status", status: "running" });
-
-    handle.result
-      .then((result: ExecutionResult) => {
-        activeItem.status = result.ok ? "success" : "failed";
-        emitEvent({ type: "finish", result });
-      })
-      .catch((err: any) => {
-        activeItem.status = "failed";
-        emitEvent({
-          type: "finish",
-          result: {
-            ok: false,
-            runId: handle.runId,
-            error: {
-              code: "UNHANDLED_EXECUTION_ERROR",
-              message: err?.message || String(err),
-            },
-          },
-        });
-      })
-      .finally(() => {
-        this.activeRuns.delete(handle.runId);
-      });
-
-    return {
-      runId: handle.runId,
-      status: "running",
-    };
-  }
-
-  async get(runId: string): Promise<RunRecord | undefined> {
-    const record = this.storage.getRun(runId);
-    return record || undefined;
-  }
-
-  async cancel(runId: string, reason?: string): Promise<CancelResult> {
-    const active = this.activeRuns.get(runId);
-    if (!active) {
-      const record = await this.get(runId);
-      if (record) {
-        return { outcome: "already_terminal", runId, status: record.status };
-      }
-      return { outcome: "not_found", runId };
-    }
-
-    active.controller.abort(new Error(reason || "Execution cancelled"));
-    active.handle.cancel(reason);
-    return { outcome: "requested", runId };
-  }
-
-  events(
-    runId: string,
-    options: { after?: number; signal?: AbortSignal } = {}
-  ): AsyncIterable<ExecutionEvent> {
-    return this.eventSink.subscribe(runId, options);
-  }
-
-  async close(options: { graceMs?: number } = {}): Promise<void> {
-    this.isClosing = true;
-    const graceMs = options.graceMs ?? 5000;
-
-    for (const [_, active] of this.activeRuns) {
-      active.controller.abort(new Error("Service shutting down"));
-      active.handle.cancel("Service shutting down");
-    }
-
-    if (this.activeRuns.size > 0) {
-      const waitPromise = Promise.all(
-        Array.from(this.activeRuns.values()).map((a) => a.handle.result.catch(() => {}))
-      );
-      const timeoutPromise = new Promise((resolve) => setTimeout(resolve, graceMs));
-      await Promise.race([waitPromise, timeoutPromise]);
-    }
-
-    this.activeRuns.clear();
-  }
-}

package/src/execution/types.ts

@@ -1,73 +0,0 @@
-import type {
-  ActionRef,
-  ExecutionEvent,
-  ExecutionResult,
-  JsonValue,
-  RunRecord,
-  RunStatus,
-} from "@actiondock/sdk";
-
-/**
- * 执行参数选项。
- */
-export interface ExecuteOptions {
-  /** 外部取消信号 */
-  signal?: AbortSignal;
-  /** 超时时间（毫秒） */
-  timeoutMs?: number;
-  /** 配置临时覆盖字典 */
-  config?: Record<string, JsonValue>;
-}
-
-/**
- * 异步任务执行票据。
- */
-export interface ExecutionTicket {
-  /** 运行标识 */
-  runId: string;
-  /** 当前状态 */
-  status: RunStatus;
-}
-
-/**
- * 取消操作结果枚举。
- */
-export type CancelResult =
-  | { outcome: "requested"; runId: string }
-  | { outcome: "already_terminal"; runId: string; status: RunStatus }
-  | { outcome: "not_found"; runId: string }
-  | { outcome: "not_owner"; runId: string };
-
-/**
- * 统一执行协调服务接口。
- */
-export interface ExecutionService {
-  /** 同步执行 Action 并等待终态结果 */
-  execute(
-    ref: ActionRef,
-    input: JsonValue,
-    options?: ExecuteOptions
-  ): Promise<ExecutionResult>;
-
-  /** 异步启动 Action 并立即返回任务票据 */
-  start(
-    ref: ActionRef,
-    input: JsonValue,
-    options?: ExecuteOptions
-  ): Promise<ExecutionTicket>;
-
-  /** 根据 ID 获取运行记录 */
-  get(runId: string): Promise<RunRecord | undefined>;
-
-  /** 取消指定的在运行任务 */
-  cancel(runId: string, reason?: string): Promise<CancelResult>;
-
-  /** 订阅执行事件流 */
-  events(
-    runId: string,
-    options?: { after?: number; signal?: AbortSignal }
-  ): AsyncIterable<ExecutionEvent>;
-
-  /** 优雅关闭服务并等待活跃任务收尾 */
-  close(options?: { graceMs?: number }): Promise<void>;
-}

package/src/export/index.ts

@@ -1 +0,0 @@
-export * from "./templates";