@actiondock/core 2.0.11 → 2.2.0

package/dist/execution/service.js

@@ -0,0 +1,633 @@
+import { randomUUID } from "node:crypto";
+import { ActionResolver } from "../catalog/action-resolver.js";
+import { computeDigest } from "../project/digest.js";
+import { InMemoryEventSink } from "../runtime/events.js";
+import { ActionRunner } from "../runtime/runner.js";
+import { ACTION_CANCELLED, ACTION_NOT_FOUND, ACTION_TIMEOUT, EXECUTION_FAILED, IDEMPOTENCY_CONFLICT, RUN_REPOSITORY_UNAVAILABLE, UNHANDLED_EXECUTION_ERROR, describeActionLoadFailure, } from "../errors.js";
+/**
+ * 统一执行协调服务实现。
+ */
+export class DefaultExecutionService {
+    packageId;
+    storage;
+    projectConfig;
+    eventSink;
+    maxActiveRuns;
+    ownerId;
+    hostSessionId;
+    _runner;
+    logger;
+    clock;
+    process;
+    platform;
+    actionResolver;
+    activeRuns = new Map();
+    reservedSlots = 0;
+    isClosing = false;
+    ownsStorage;
+    ownsGlobalStorage;
+    globalStorage;
+    constructor(options) {
+        this.platform = options.platform;
+        this.packageId = options.packageId;
+        this.hostSessionId = options.hostSessionId;
+        this.projectConfig = options.projectConfig;
+        this.eventSink = options.eventSink || options.platform?.eventSink || new InMemoryEventSink();
+        this.maxActiveRuns = options.maxActiveRuns || 32;
+        this.ownerId = options.ownerId || `host-${randomUUID().slice(0, 8)}`;
+        this.actionResolver = options.actionResolver;
+        this.logger = options.logger;
+        if (options.platform) {
+            this.clock = options.platform.clock;
+            this.process = options.platform.process;
+            this.storage =
+                options.storage ??
+                    options.platform.storage.createStorage(this.packageId, {
+                        projectRoot: options.projectRoot,
+                        customHome: options.customHome,
+                    });
+        }
+        else {
+            this.clock = options.clock;
+            this.process = options.process;
+            if (!options.storage) {
+                throw new Error("ExecutionService requires either 'storage' or 'platform' option");
+            }
+            this.storage = options.storage;
+        }
+        const globalStorage = options.platform
+            ? (options.globalStorage ?? options.platform.storage.createGlobalStorage({ customHome: options.customHome }))
+            : options.globalStorage;
+        this.ownsStorage = !options.storage;
+        this.ownsGlobalStorage = !options.globalStorage && !!options.platform;
+        this.globalStorage = globalStorage;
+        this._runner = new ActionRunner({
+            packageId: this.packageId,
+            hostSessionId: this.hostSessionId,
+            storage: this.storage,
+            globalStorage,
+            projectRoot: options.projectRoot,
+            projectConfig: this.projectConfig,
+            configOverrides: options.configOverrides,
+            actions: options.actions,
+            process: this.process,
+            clock: this.clock,
+            platform: options.platform,
+            maxCallDepth: options.maxCallDepth,
+            maxSubRuns: options.maxSubRuns,
+            actionResolver: (ref, currentPkgId) => {
+                const parsed = typeof ref === "string" ? ActionResolver.parseRef(ref) : ref;
+                if (parsed.packageId && parsed.packageId !== this.packageId) {
+                    return undefined;
+                }
+                if (currentPkgId && currentPkgId !== this.packageId) {
+                    return undefined;
+                }
+                return this.actionResolver ? this.actionResolver(parsed) : undefined;
+            },
+            getStorageForPackage: options.getStorageForPackage,
+            packageContextResolver: options.packageContextResolver,
+            customHome: options.customHome,
+        });
+    }
+    get runner() {
+        return this._runner;
+    }
+    registerAction(idOrAction, actionDef) {
+        if (typeof idOrAction === "string") {
+            this._runner.registerAction(idOrAction, actionDef);
+        }
+        else {
+            this._runner.registerAction(idOrAction);
+        }
+    }
+    getAction(id) {
+        return this._runner.getAction(id);
+    }
+    listActions() {
+        return this._runner.listActions();
+    }
+    getActiveHandle(runId) {
+        return this.activeRuns.get(runId)?.handle;
+    }
+    setPackageContextResolver(resolver) {
+        this._runner.setPackageContextResolver(resolver);
+    }
+    async resolveTargetAction(ref) {
+        const parsed = typeof ref === "string" ? ActionResolver.parseRef(ref) : ref;
+        const actionId = parsed.actionId;
+        const targetPackageId = parsed.packageId || this.packageId;
+        let runner = this._runner;
+        if (targetPackageId !== this.packageId) {
+            const targetRunner = await this._runner.resolveTargetPackageRunner(targetPackageId);
+            if (!targetRunner)
+                return undefined;
+            runner = targetRunner;
+        }
+        const fromRunner = runner.getAction(actionId);
+        if (fromRunner)
+            return fromRunner;
+        if (this.actionResolver && targetPackageId === this.packageId) {
+            return this.actionResolver(parsed);
+        }
+        return undefined;
+    }
+    async execute(ref, input, options = {}) {
+        const ticket = await this.start(ref, input, options);
+        if (!ticket.result) {
+            throw new Error(`Execution ticket for run '${ticket.runId}' has no result Promise`);
+        }
+        return ticket.result;
+    }
+    get activeRunsCount() {
+        return this.activeRuns.size + this.reservedSlots;
+    }
+    async start(ref, input, options = {}) {
+        if (this.isClosing) {
+            throw new Error("ExecutionService is closing: new tasks rejected");
+        }
+        const currentTotal = this.activeRuns.size + this.reservedSlots;
+        if (currentTotal >= this.maxActiveRuns) {
+            throw new Error(`Concurrency limit reached: ${currentTotal}/${this.maxActiveRuns} active runs`);
+        }
+        this.reservedSlots++;
+        let hasReservedSlot = true;
+        const releaseSlot = () => {
+            if (hasReservedSlot) {
+                this.reservedSlots--;
+                hasReservedSlot = false;
+            }
+        };
+        try {
+            let parsedRef;
+            try {
+                parsedRef = ActionResolver.parseRef(ref);
+            }
+            catch {
+                parsedRef = typeof ref === "object" ? ref : { actionId: ref };
+            }
+            const targetActionId = parsedRef.actionId;
+            const targetPackageId = parsedRef.packageId || this.packageId;
+            const actionRef = `${targetPackageId}/${targetActionId}`;
+            const effectiveClock = options.platform?.clock ?? this.clock;
+            // requestId 幂等检查与去重处理
+            const gateResult = await this.checkIdempotencyGate(input, options, actionRef, effectiveClock);
+            if (gateResult.ticket) {
+                releaseSlot();
+                return gateResult.ticket;
+            }
+            const designatedRunId = gateResult.designatedRunId;
+            const target = await this.resolveExecutionTarget(parsedRef, targetPackageId, targetActionId);
+            if (!target.action) {
+                releaseSlot();
+                return this.failTicketForMissingAction({
+                    target,
+                    input,
+                    options,
+                    targetPackageId,
+                    targetActionId,
+                    designatedRunId,
+                    effectiveClock,
+                });
+            }
+            if (this.isClosing) {
+                throw new Error("ExecutionService is closing: new tasks rejected");
+            }
+            const controller = new AbortController();
+            let onAbort;
+            if (options.signal && typeof options.signal.addEventListener === "function") {
+                if (options.signal.aborted) {
+                    controller.abort(options.signal.reason);
+                }
+                else {
+                    onAbort = () => controller.abort(options.signal?.reason);
+                    options.signal.addEventListener("abort", onAbort, { once: true });
+                }
+            }
+            const runId = designatedRunId || randomUUID();
+            const bridge = this.createEventBridge({ runId, options, effectiveClock });
+            this.registerResolvedAction(target.runner, targetPackageId, targetActionId, target.action);
+            const handle = target.runner.start(targetActionId, input, {
+                runId,
+                rootRunId: options.rootRunId,
+                parentRunId: options.parentRunId,
+                hostSessionId: options.hostSessionId || this.hostSessionId,
+                maxCallDepth: options.maxCallDepth,
+                configOverrides: options.config,
+                signal: controller.signal,
+                timeoutMs: options.timeoutMs,
+                progress: bridge.progressReporter,
+                logger: bridge.executionLogger,
+                process: options.process || options.platform?.process || this.process,
+                platform: options.platform || this.platform,
+            });
+            const activeItem = {
+                runId: handle.runId,
+                handle,
+                controller,
+                status: "running",
+                startedAt: (effectiveClock?.now() ?? new Date()).toISOString(),
+                signal: options.signal,
+                onAbort,
+            };
+            this.activeRuns.set(handle.runId, activeItem);
+            releaseSlot();
+            bridge.emitEvent({ type: "status", status: "running" });
+            this.watchHandleCompletion(handle, activeItem, bridge);
+            return {
+                runId: handle.runId,
+                status: "running",
+                result: handle.result,
+            };
+        }
+        catch (err) {
+            releaseSlot();
+            throw err;
+        }
+    }
+    /**
+     * 幂等门检查：digest 计算与冲突/重复分流（重复命中时直接返回已有票据）。
+     */
+    async checkIdempotencyGate(input, options, actionRef, effectiveClock) {
+        if (!options.requestId) {
+            return {};
+        }
+        const digestPayload = {
+            input,
+            config: options.config,
+            timeoutMs: options.timeoutMs,
+        };
+        const inputDigest = computeDigest(digestPayload);
+        const provisionalRunId = randomUUID();
+        if (!this.storage.checkAndRecordIdempotency) {
+            return {};
+        }
+        const idemp = this.storage.checkAndRecordIdempotency({
+            ownerId: this.ownerId,
+            actionRef,
+            requestId: options.requestId,
+            inputDigest,
+            runId: provisionalRunId,
+            createdAt: (effectiveClock?.now() ?? new Date()).toISOString(),
+        });
+        if (idemp.outcome === "conflict") {
+            const conflictError = {
+                code: IDEMPOTENCY_CONFLICT,
+                message: `Idempotency conflict for requestId '${options.requestId}': input parameters digest mismatch`,
+                details: {
+                    requestId: options.requestId,
+                    actionRef,
+                    expectedDigest: idemp.existingDigest,
+                    actualDigest: inputDigest,
+                },
+            };
+            const err = new Error(conflictError.message);
+            err.code = conflictError.code;
+            err.details = conflictError.details;
+            throw err;
+        }
+        if (idemp.outcome === "duplicate") {
+            const existingRunId = idemp.runId;
+            const active = this.activeRuns.get(existingRunId);
+            if (active) {
+                return {
+                    ticket: {
+                        runId: existingRunId,
+                        status: active.status,
+                        result: active.handle.result,
+                    },
+                };
+            }
+            const record = await this.get(existingRunId);
+            if (record) {
+                const execRes = record.status === "success"
+                    ? { ok: true, runId: existingRunId, data: record.output ?? null }
+                    : {
+                        ok: false,
+                        runId: existingRunId,
+                        error: record.error || {
+                            code: EXECUTION_FAILED,
+                            message: `Run terminated with status '${record.status}'`,
+                        },
+                    };
+                return {
+                    ticket: {
+                        runId: existingRunId,
+                        status: record.status,
+                        result: Promise.resolve(execRes),
+                    },
+                };
+            }
+        }
+        return { designatedRunId: provisionalRunId };
+    }
+    /**
+     * 解析执行目标：确定目标 Runner 并解析目标 Action 定义。
+     */
+    async resolveExecutionTarget(parsedRef, targetPackageId, targetActionId) {
+        let runnerToUse = this._runner;
+        let resolveError;
+        if (targetPackageId && targetPackageId !== this.packageId) {
+            const targetRunner = await this._runner.resolveTargetPackageRunner(targetPackageId);
+            if (targetRunner) {
+                runnerToUse = targetRunner;
+            }
+            else {
+                resolveError = {
+                    code: ACTION_NOT_FOUND,
+                    message: `Target package '${targetPackageId}' not found or unresolvable`,
+                };
+            }
+        }
+        let action;
+        if (!resolveError) {
+            action = runnerToUse.getAction(targetActionId) || runnerToUse.getAction(`${targetPackageId}/${targetActionId}`);
+            if (!action) {
+                const resolution = await runnerToUse.resolveAction(parsedRef);
+                if (resolution.status === "found") {
+                    action = resolution.action;
+                }
+                else if (resolution.status === "load_failed") {
+                    resolveError = describeActionLoadFailure(resolution.error, {
+                        actionId: targetActionId,
+                        packageId: resolution.packageId,
+                        projectRoot: resolution.projectRoot,
+                    });
+                }
+                else {
+                    const targetAction = await this.resolveTargetAction(parsedRef);
+                    if (targetAction) {
+                        action = targetAction;
+                    }
+                    else {
+                        resolveError = {
+                            code: ACTION_NOT_FOUND,
+                            message: `Action '${targetActionId}' not found in package '${targetPackageId}'`,
+                            details: resolution.reason ? { reason: resolution.reason } : undefined,
+                        };
+                    }
+                }
+            }
+        }
+        return { runner: runnerToUse, action, resolveError };
+    }
+    /**
+     * 注册解析成功的目标 Action 至目标 Runner（收敛为单一注册入口）。
+     */
+    registerResolvedAction(runner, targetPackageId, targetActionId, action) {
+        runner.registerAction(targetActionId, action);
+    }
+    /**
+     * 目标 Action 缺失时的失败票据：落库 failed 记录并补发 status 与 finish 事件。
+     */
+    failTicketForMissingAction(args) {
+        const { target, input, options, targetPackageId, targetActionId, designatedRunId, effectiveClock } = args;
+        const runId = designatedRunId || randomUUID();
+        const now = (effectiveClock?.now() ?? new Date()).toISOString();
+        const error = target.resolveError || {
+            code: ACTION_NOT_FOUND,
+            message: `Action '${targetActionId}' not found in package '${targetPackageId}'`,
+        };
+        const rootRunId = options.rootRunId || options.parentRunId || runId;
+        const initialRun = {
+            id: runId,
+            rootRunId,
+            parentRunId: options.parentRunId,
+            packageId: targetPackageId,
+            packageInstanceId: targetPackageId,
+            actionId: targetActionId,
+            generationId: "1",
+            ownerId: this.ownerId,
+            hostSessionId: options.hostSessionId || this.hostSessionId,
+            status: "failed",
+            input,
+            error,
+            startedAt: now,
+            finishedAt: now,
+        };
+        try {
+            target.runner.getStorage().createRun(initialRun);
+        }
+        catch (err) {
+            const repErr = new Error(`RUN_REPOSITORY_UNAVAILABLE: Failed to initialize run record in repository: ${err?.message || String(err)}`);
+            repErr.code = RUN_REPOSITORY_UNAVAILABLE;
+            repErr.details = { originalError: err?.message };
+            throw repErr;
+        }
+        this.eventSink.emit({
+            runId,
+            rootRunId,
+            sequence: 0,
+            timestamp: now,
+            type: "status",
+            status: "failed",
+        });
+        const errEvt = {
+            runId,
+            rootRunId,
+            sequence: 1,
+            timestamp: now,
+            type: "finish",
+            result: {
+                ok: false,
+                runId,
+                error,
+            },
+        };
+        this.eventSink.emit(errEvt);
+        return {
+            runId,
+            status: "failed",
+            result: Promise.resolve({
+                ok: false,
+                runId,
+                error,
+            }),
+        };
+    }
+    /**
+     * 创建执行事件桥：事件序列号分配、进度报告器与双写日志适配器。
+     */
+    createEventBridge(args) {
+        const { runId, options, effectiveClock } = args;
+        let sequence = 0;
+        const emitEvent = (payload) => {
+            const evt = {
+                ...payload,
+                runId,
+                rootRunId: options.rootRunId || options.parentRunId || runId,
+                sequence: sequence++,
+                timestamp: (effectiveClock?.now() ?? new Date()).toISOString(),
+            };
+            this.eventSink.emit(evt);
+        };
+        const progressReporter = {
+            report(current, total, message) {
+                options.progress?.report(current, total, message);
+                emitEvent({
+                    type: "progress",
+                    current,
+                    total,
+                    message,
+                });
+            },
+        };
+        const executionLogger = {
+            debug: (message, data) => {
+                this.logger?.debug(message, data);
+                options.logger?.debug(message, data);
+                emitEvent({
+                    type: "log",
+                    level: "debug",
+                    message,
+                    data: data,
+                });
+            },
+            info: (message, data) => {
+                this.logger?.info(message, data);
+                options.logger?.info(message, data);
+                emitEvent({
+                    type: "log",
+                    level: "info",
+                    message,
+                    data: data,
+                });
+            },
+            warn: (message, data) => {
+                this.logger?.warn(message, data);
+                options.logger?.warn(message, data);
+                emitEvent({
+                    type: "log",
+                    level: "warn",
+                    message,
+                    data: data,
+                });
+            },
+            error: (message, data) => {
+                this.logger?.error(message, data);
+                options.logger?.error(message, data);
+                emitEvent({
+                    type: "log",
+                    level: "error",
+                    message,
+                    data: data,
+                });
+            },
+        };
+        return { emitEvent, progressReporter, executionLogger };
+    }
+    /**
+     * 监听执行句柄终态：映射终态状态、补发 status 与 finish 事件并注销活跃运行。
+     */
+    watchHandleCompletion(handle, activeItem, bridge) {
+        handle.result
+            .then((result) => {
+            const finalStatus = result.ok
+                ? "success"
+                : result.error?.code === ACTION_TIMEOUT
+                    ? "timed_out"
+                    : result.error?.code === ACTION_CANCELLED
+                        ? "cancelled"
+                        : "failed";
+            activeItem.status = finalStatus;
+            bridge.emitEvent({ type: "status", status: finalStatus });
+            bridge.emitEvent({ type: "finish", result });
+        })
+            .catch((err) => {
+            activeItem.status = "failed";
+            bridge.emitEvent({ type: "status", status: "failed" });
+            bridge.emitEvent({
+                type: "finish",
+                result: {
+                    ok: false,
+                    runId: handle.runId,
+                    error: {
+                        code: UNHANDLED_EXECUTION_ERROR,
+                        message: err?.message || String(err),
+                    },
+                },
+            });
+        })
+            .finally(() => {
+            if (activeItem.signal && activeItem.onAbort) {
+                activeItem.signal.removeEventListener("abort", activeItem.onAbort);
+                activeItem.onAbort = undefined;
+            }
+            this.activeRuns.delete(handle.runId);
+        });
+    }
+    async get(runId) {
+        const record = this.storage.getRun(runId);
+        if (record)
+            return record;
+        // 检查所有已解析的目标包 Runner 存储
+        const visited = new Set([this._runner]);
+        const queue = [this._runner];
+        while (queue.length > 0) {
+            const runner = queue.shift();
+            for (const [_, childRunner] of runner.getPackageRunners()) {
+                if (!visited.has(childRunner)) {
+                    visited.add(childRunner);
+                    queue.push(childRunner);
+                    const childRecord = childRunner.getStorage().getRun(runId);
+                    if (childRecord) {
+                        return childRecord;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    async cancel(runId, reason) {
+        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 };
+        }
+        if (active.signal && active.onAbort) {
+            active.signal.removeEventListener("abort", active.onAbort);
+            active.onAbort = undefined;
+        }
+        active.controller.abort(new Error(reason || "Execution cancelled"));
+        active.handle.cancel(reason);
+        return { outcome: "requested", runId };
+    }
+    events(runId, options = {}) {
+        return this.eventSink.subscribe(runId, options);
+    }
+    async close(options = {}) {
+        this.isClosing = true;
+        this.reservedSlots = 0;
+        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(() => { })));
+            let timeoutTimer;
+            const timeoutPromise = new Promise((resolve) => {
+                timeoutTimer = setTimeout(resolve, graceMs);
+            });
+            try {
+                await Promise.race([waitPromise, timeoutPromise]);
+            }
+            finally {
+                if (timeoutTimer !== undefined) {
+                    clearTimeout(timeoutTimer);
+                }
+            }
+        }
+        this.activeRuns.clear();
+        if (this.ownsStorage && this.storage && typeof this.storage.close === "function") {
+            await this.storage.close();
+        }
+        if (this.ownsGlobalStorage && this.globalStorage && typeof this.globalStorage.close === "function") {
+            await this.globalStorage.close();
+        }
+    }
+}
+export { DefaultExecutionService as ExecutionService };