@actiondock/core 2.10.0 → 2.12.0

package/dist/runtime/runner.js

@@ -1,609 +0,0 @@
-import { parseActionRef } from "../catalog/resolve-action.js";
-import { ACTION_FAILED, ACTION_NOT_FOUND, ACTION_TIMEOUT, INPUT_NOT_JSON, OUTPUT_NOT_JSON, ACTION_CANCELLED, INPUT_VALIDATION_FAILED, OUTPUT_VALIDATION_FAILED, INVOCATION_UNSUPPORTED, ActionDockError, } from "../errors.js";
-import { validateSchemaOnly } from "../schema/validator.js";
-import { validateActionInputValue } from "../json/value-validator.js";
-import { createActionContext, StderrLogger } from "./context.js";
-import { createDefaultProcessOwner } from "../invocation/types.js";
-import { ActionRegistry, findLocalAction, isActionDefinitionObject, resolveAnonymousActionId, } from "./action-registry.js";
-import { buildInitialRunRecord, createRunFinalizer, createRunOrThrow, tryCreateRun, } from "./run-persistence.js";
-import { validateJsonValue } from "../json/value-validator.js";
-/**
- * 将输入值校验结果映射为标准运行时错误（单一事实源）。
- *
- * json-value 分支映射 INPUT_NOT_JSON（非 JSON 类型值），input-policy 分支映射
- * INPUT_VALIDATION_FAILED（策略违规）并携带 details 数组；start 同步路径与
- * raceExecutionAndAbort 延迟解析路径共用，确保错误码与 details 结构一致。
- */
-function buildInputValidationError(targetActionId, check) {
-    if (check.kind === "json-value") {
-        return {
-            code: INPUT_NOT_JSON,
-            message: `Input validation failed for action '${targetActionId}': ${check.reason}`,
-        };
-    }
-    return {
-        code: INPUT_VALIDATION_FAILED,
-        message: `Input validation failed for action '${targetActionId}': ${check.reason}`,
-        details: [check.reason],
-    };
-}
-/**
- * ActionDock 核心执行引擎（ActionRunner）。
- *
- * 本类为执行编排壳：负责 Action 执行的全生命周期编排（校验、深度与环路检测、
- * 超时与取消竞态、子调用 uses 授权与错误分类），并将单一职责域委托至独立模块：
- * - Action 注册与检索委托 ActionRegistry（action-registry.ts）
- * - RunRecord 构造与落库委托 run-persistence.ts
- * - 跨包动作调用委托注入的 ActionInvoker 并重返目标包执行服务
- *
- * 入参 (inputSchema) 与出参 (outputSchema) 的 JSON Schema 严格校验、嵌套 Action
- * 相互调用的环路检测（Cycle Detection）、超时 (Timeout) 与中断信号 (AbortSignal)
- * 竞态控制与运行记录持久化编排仍由本类承担。
- */
-export class ActionRunner {
-    identity;
-    packageId;
-    packageInstanceId;
-    generationId;
-    storage;
-    globalStorage;
-    projectRoot;
-    projectConfig;
-    configOverrides;
-    registry;
-    clock;
-    process;
-    customHome;
-    actionResolver;
-    hostSessionId;
-    actionInvoker;
-    constructor(options) {
-        if (!options.identity) {
-            throw new Error("ActionRunner requires 'identity' PackageIdentity option");
-        }
-        this.identity = options.identity;
-        this.packageId = this.identity.id;
-        this.packageInstanceId = this.identity.instanceId;
-        this.generationId = this.identity.generation;
-        this.hostSessionId = options.hostSessionId;
-        this.projectRoot = options.projectRoot;
-        this.projectConfig = options.projectConfig;
-        this.configOverrides = options.configOverrides || {};
-        this.registry = new ActionRegistry(options.actions);
-        this.customHome = options.customHome;
-        this.actionInvoker = options.actionInvoker;
-        this.actionResolver = options.actionResolver;
-        if (!options.storage) {
-            throw new Error("ActionRunner requires 'storage' option");
-        }
-        this.storage = options.storage;
-        this.globalStorage = options.globalStorage;
-        this.clock = options.clock;
-        this.process = options.process;
-    }
-    /** 本地 Action 注册表底层映射 */
-    get actions() {
-        return this.registry.map;
-    }
-    getStorage() {
-        return this.storage;
-    }
-    registerAction(idOrAction, actionDef) {
-        this.registry.registerAction(idOrAction, actionDef);
-    }
-    /**
-     * 根据 ID 检索注册的 Action。
-     */
-    getAction(id) {
-        return this.registry.getAction(id);
-    }
-    /**
-     * 设置子任务动作调用委托器。
-     */
-    setActionInvoker(invoker) {
-        this.actionInvoker = invoker;
-    }
-    /**
-     * 动态解析 Action（支持本地注册表、自定义解析器委托与已链接包目录索引检索）。
-     *
-     * @param actionOrRef Action 定义对象、引用或标识符
-     * @returns 解析判别联合结果（found | not_found）
-     */
-    async resolveAction(actionOrRef) {
-        if (isActionDefinitionObject(actionOrRef)) {
-            return { status: "found", action: actionOrRef };
-        }
-        const ref = actionOrRef;
-        let parsed;
-        try {
-            parsed = parseActionRef(ref);
-        }
-        catch (err) {
-            return { status: "not_found", reason: err.message };
-        }
-        const targetActionId = parsed.actionId;
-        const targetPackageId = parsed.packageId;
-        // 铁律：ActionRunner 仅限执行当前包局部 Action，任何跨包请求直接拒绝，禁止跨包解析和执行
-        if (targetPackageId && targetPackageId !== this.packageId) {
-            return {
-                status: "not_found",
-                reason: `Cross-package action '${targetPackageId}/${targetActionId}' cannot be resolved by ActionRunner of package '${this.packageId}'`,
-            };
-        }
-        // 本地 actions 映射表优先检索
-        const localMatched = findLocalAction(this.actions, parsed, this.packageId);
-        if (localMatched) {
-            return { status: "found", action: localMatched };
-        }
-        // 外部注入的局部 actionResolver 调度
-        if (this.actionResolver) {
-            try {
-                const customResolved = await this.actionResolver(targetActionId);
-                if (customResolved) {
-                    this.actions.set(targetActionId, customResolved);
-                    if (this.packageId) {
-                        this.actions.set(`${this.packageId}/${targetActionId}`, customResolved);
-                    }
-                    return { status: "found", action: customResolved };
-                }
-            }
-            catch (err) {
-                return { status: "not_found", reason: err.message };
-            }
-        }
-        // 铁律 4：Runner 不找 Package：只能执行自己所属 Package 的 Action
-        return {
-            status: "not_found",
-            reason: `Action '${targetActionId}' not found in package '${this.packageId}'`,
-        };
-    }
-    /**
-     * 获取当前 Runner 已注册的所有 Action 列表。
-     */
-    listActions() {
-        return this.registry.listActions();
-    }
-    /**
-     * 异步启动 Action 的执行并立即返回 ExecutionHandle 句柄。
-     *
-     * @param actionOrId Action 定义对象、引用或标识符
-     * @param input 传递给 Action 的输入数据
-     * @param options 执行控制选项（超时、取消信号、父运行 ID 等）
-     * @returns 包含 runId、result Promise 和 cancel 方法的执行句柄
-     */
-    start(actionOrId, input = {}, options = {}) {
-        const runCtx = this.prepareRunContext(actionOrId, input, options);
-        const { runId, targetActionId, targetPackageId } = runCtx;
-        // 输入参数 JSON 格式与合法性防御校验（拦截 NaN/Infinity/循环引用等非 JSON 类型及非法原型键策略违规）
-        const inputCheck = validateActionInputValue(input);
-        if (!inputCheck.valid) {
-            const error = buildInputValidationError(targetActionId, inputCheck);
-            // 安全记录 failed 状态（不可序列化或策略违规的非法 input 严禁直接写入持久化存储）
-            tryCreateRun(this.storage, buildInitialRunRecord(this.buildRunPersistenceInput(runCtx), "failed", error));
-            return {
-                runId,
-                result: Promise.resolve({ ok: false, runId, error }),
-                cancel: () => false,
-            };
-        }
-        // 始终优先将执行尝试持久化到存储中（确保任意异常与终态都可追溯）
-        createRunOrThrow(this.storage, buildInitialRunRecord(this.buildRunPersistenceInput(runCtx), "running"));
-        const finalizer = createRunFinalizer(this.storage, runCtx.runId);
-        // 记录调用栈快照（供子任务追溯，若已处于调用栈顶则不重复追加）
-        const callKey = targetPackageId ? `${targetPackageId}/${targetActionId}` : targetActionId;
-        const lastStackItem = runCtx.callStack[runCtx.callStack.length - 1];
-        const isAlreadyAtTop = lastStackItem === callKey ||
-            (targetActionId && lastStackItem === targetActionId) ||
-            (targetPackageId && lastStackItem === `${targetPackageId}/${targetActionId}`);
-        if (!isAlreadyAtTop) {
-            runCtx.callStack.push(callKey);
-        }
-        // 输入参数 JSON Schema 校验（若 action 已就绪）
-        const schemaError = this.checkActionInputSchema(runCtx.action, targetActionId, input);
-        if (schemaError) {
-            finalizer.finalize("failed", undefined, schemaError);
-            return {
-                runId,
-                result: Promise.resolve({ ok: false, runId, error: schemaError }),
-                cancel: () => false,
-            };
-        }
-        // 初始化 AbortController 与超时定时器
-        const controller = new AbortController();
-        let onAbort;
-        if (options.signal) {
-            if (options.signal.aborted) {
-                controller.abort(options.signal.reason);
-            }
-            else {
-                onAbort = () => controller.abort(options.signal?.reason);
-                options.signal.addEventListener("abort", onAbort, { once: true });
-                finalizer.signal = options.signal;
-                finalizer.onAbort = onAbort;
-            }
-        }
-        if (typeof options.timeoutMs === "number" && options.timeoutMs > 0) {
-            finalizer.startTimeout(controller, options.timeoutMs);
-        }
-        // 构建 ActionContext 运行时上下文
-        const ctx = this.buildActionContext({
-            runCtx,
-            controller,
-            rootRunId: this.computeRootRunId(runCtx),
-        });
-        // 执行 Action 业务逻辑并与取消/超时信号进行竞态
-        const executionPromise = this.raceExecutionAndAbort({
-            runCtx,
-            actionOrId,
-            input,
-            options,
-            controller,
-            finalizer,
-            ctx,
-        });
-        return {
-            runId,
-            result: executionPromise,
-            cancel: (reason) => {
-                if (finalizer.finalized || controller.signal.aborted) {
-                    return false;
-                }
-                if (options.signal && onAbort) {
-                    options.signal.removeEventListener("abort", onAbort);
-                    finalizer.onAbort = undefined;
-                }
-                controller.abort(new Error(reason || "Action execution was cancelled"));
-                return true;
-            },
-        };
-    }
-    /**
-     * 计算根运行标识（优先显式 rootRunId，其次 parentRunId，最后自身 runId）。
-     */
-    computeRootRunId(runCtx) {
-        return runCtx.options.rootRunId || runCtx.options.parentRunId || runCtx.runId;
-    }
-    /**
-     * 预解析执行目标并装配运行期共享上下文对象（runId、目标标识、时钟源与调用栈快照）。
-     */
-    prepareRunContext(actionOrId, input, options) {
-        const runId = options.runId || crypto.randomUUID();
-        const effectiveClock = options.clock ?? this.clock;
-        const effectiveProcess = options.process || this.process;
-        const startedAt = effectiveClock?.now().toISOString() ||
-            (typeof this.storage.clock?.now === "function"
-                ? this.storage.clock.now().toISOString()
-                : new Date().toISOString());
-        const callStack = [...(options.callStack || [])];
-        let action;
-        let targetActionId;
-        let targetPackageId = this.packageId;
-        if (isActionDefinitionObject(actionOrId)) {
-            action = actionOrId;
-            const actObj = action;
-            if (actObj.id) {
-                targetActionId = actObj.id;
-            }
-            else {
-                targetActionId = resolveAnonymousActionId(this.actions, action);
-            }
-            this.actions.set(targetActionId, action);
-        }
-        else {
-            const parsed = parseActionRef(actionOrId);
-            targetActionId = parsed.actionId;
-            if (parsed.packageId) {
-                targetPackageId = parsed.packageId;
-            }
-            action = findLocalAction(this.actions, parsed, this.packageId);
-        }
-        return {
-            runId,
-            options,
-            input,
-            action,
-            actionOrId,
-            targetActionId,
-            targetPackageId,
-            effectiveProcess,
-            startedAt,
-            callStack,
-        };
-    }
-    /**
-     * 依据运行期上下文装配落库模块入参（RunRecord 构造领域契约）。
-     */
-    buildRunPersistenceInput(runCtx) {
-        const { options, targetPackageId, targetActionId, startedAt, input } = runCtx;
-        return {
-            runId: runCtx.runId,
-            rootRunId: this.computeRootRunId(runCtx),
-            parentRunId: options.parentRunId,
-            ownerId: options.ownerId,
-            hostSessionId: options.hostSessionId,
-            packageInstanceId: options.packageInstanceId,
-            generationId: options.generationId,
-            targetPackageId,
-            targetActionId,
-            startedAt,
-            input,
-            runnerPackageId: this.packageId,
-            runnerPackageInstanceId: this.packageInstanceId,
-            runnerGenerationId: this.generationId,
-            runnerHostSessionId: this.hostSessionId,
-        };
-    }
-    /**
-     * 输入参数 JSON Schema 校验（若 action 已就绪，返回校验错误或 undefined）。
-     */
-    checkActionInputSchema(action, targetActionId, input) {
-        const targetInputSchema = action?.inputSchema !== undefined
-            ? action.inputSchema
-            : this.projectConfig?.actions?.[targetActionId]?.inputSchema;
-        if (targetInputSchema !== undefined) {
-            const val = validateSchemaOnly(targetInputSchema, input);
-            if (!val.valid) {
-                return {
-                    code: INPUT_VALIDATION_FAILED,
-                    message: `Input schema validation failed for action '${targetActionId}'`,
-                    details: val.errors,
-                };
-            }
-        }
-        return undefined;
-    }
-    /**
-     * 构建 ActionContext 运行时上下文（内嵌子 Action 调用委托提为私有方法）。
-     */
-    buildActionContext(args) {
-        const { runCtx, controller, rootRunId } = args;
-        const { options, targetPackageId, targetActionId, effectiveProcess } = runCtx;
-        const effectiveOwner = options.owner ||
-            createDefaultProcessOwner({
-                tenantId: options.tenantId,
-                principalId: options.principalId || options.ownerId,
-                packageInstanceId: options.packageInstanceId || this.packageInstanceId,
-                generationId: options.generationId || this.generationId,
-            });
-        return createActionContext({
-            actionId: targetActionId,
-            storage: this.storage,
-            globalStorage: this.globalStorage,
-            overrides: { ...this.configOverrides, ...(options.configOverrides || {}) },
-            projectConfig: this.projectConfig,
-            runId: runCtx.runId,
-            rootRunId,
-            parentRunId: options.parentRunId,
-            signal: controller.signal,
-            process: effectiveProcess,
-            owner: effectiveOwner,
-            progress: options.progress,
-            logger: options.logger || new StderrLogger(targetActionId),
-            onActionInvoke: (childAction, childInput, parentRunId) => this.invokeChildAction({
-                runCtx,
-                controller,
-                rootRunId,
-                childAction,
-                childInput,
-                parentRunId,
-            }),
-        });
-    }
-    /**
-     * 子 Action 调用委托：
-     * 必须委托 Host 动作调用器（走 Host 执行主链与 InvocationPolicy 鉴权）；
-     * 缺少 actionInvoker 时直接抛出 INVOCATION_UNSUPPORTED，严禁跨包或同包无约束执行逃逸。
-     */
-    async invokeChildAction(args) {
-        const { runCtx, controller, rootRunId, childAction, childInput, parentRunId } = args;
-        const { options, effectiveProcess, callStack } = runCtx;
-        const invoker = options.actionInvoker || this.actionInvoker;
-        if (!invoker) {
-            throw new ActionDockError(INVOCATION_UNSUPPORTED, "Nested action invocation requires a Host ActionInvoker");
-        }
-        const effectiveParentOwner = options.owner ||
-            createDefaultProcessOwner({
-                tenantId: options.tenantId,
-                principalId: options.principalId || options.ownerId,
-                packageInstanceId: this.packageInstanceId,
-                generationId: this.generationId,
-            });
-        const childRunId = crypto.randomUUID();
-        const invocationContext = {
-            runId: childRunId,
-            rootRunId,
-            parentRunId: parentRunId || runCtx.runId,
-            caller: {
-                packageId: this.packageId,
-                actionId: runCtx.targetActionId,
-                runId: runCtx.runId,
-                declaredUses: runCtx.action?.uses ||
-                    this.projectConfig?.actions?.[runCtx.targetActionId]?.uses,
-            },
-            callStack: [...callStack],
-            package: this.identity,
-            signal: controller.signal,
-            timeoutMs: options.timeoutMs,
-            maxCallDepth: options.maxCallDepth,
-            config: options.configOverrides,
-            tenantId: effectiveParentOwner.tenantId,
-            principalId: effectiveParentOwner.principalId,
-            hostSessionId: options.hostSessionId || this.hostSessionId,
-            logger: options.logger,
-            progress: options.progress,
-            process: effectiveProcess,
-            owner: effectiveParentOwner,
-        };
-        return await invoker(childAction, childInput, invocationContext);
-    }
-    /**
-     * 执行 Action 业务逻辑并与取消/超时信号进行竞态，返回执行结果信封 Promise。
-     */
-    raceExecutionAndAbort(args) {
-        const { runCtx, actionOrId, input, options, controller, finalizer, ctx } = args;
-        const { runId, targetActionId } = runCtx;
-        const abortPromise = new Promise((_, reject) => {
-            const rejectWithReason = () => reject(controller.signal.reason || new Error("Action execution was cancelled"));
-            if (controller.signal.aborted) {
-                rejectWithReason();
-            }
-            else {
-                controller.signal.addEventListener("abort", rejectWithReason, { once: true });
-                // 成功与失败路径统一注销：finalize 时回收监听句柄，避免信号对象残留引用
-                finalizer.raceListenerRemovers.push(() => {
-                    controller.signal.removeEventListener("abort", rejectWithReason);
-                });
-            }
-        });
-        return (async () => {
-            try {
-                let currentAction = runCtx.action;
-                if (!currentAction) {
-                    const resolution = await this.resolveAction(actionOrId);
-                    if (resolution.status === "found") {
-                        currentAction = resolution.action;
-                        runCtx.action = currentAction;
-                    }
-                    else {
-                        const error = {
-                            code: ACTION_NOT_FOUND,
-                            message: `Action '${targetActionId}' not found in registry or linked packages`,
-                            details: resolution.reason ? { reason: resolution.reason } : undefined,
-                        };
-                        finalizer.finalize("failed", undefined, error);
-                        return { ok: false, runId, error };
-                    }
-                    const inputCheck = validateActionInputValue(input);
-                    if (!inputCheck.valid) {
-                        const error = buildInputValidationError(targetActionId, inputCheck);
-                        finalizer.finalize("failed", undefined, error);
-                        return { ok: false, runId, error };
-                    }
-                    // 复用统一校验入口：优先 action 声明 schema，缺失时回退 projectConfig 清单声明
-                    const schemaError = this.checkActionInputSchema(currentAction, targetActionId, input);
-                    if (schemaError) {
-                        finalizer.finalize("failed", undefined, schemaError);
-                        return { ok: false, runId, error: schemaError };
-                    }
-                }
-                const rawOutput = await Promise.race([
-                    Promise.resolve().then(() => currentAction.run(input, ctx)),
-                    abortPromise,
-                ]);
-                // 输出结果非 JSON 格式与合法性校验（拦截 NaN/Infinity/循环引用等）
-                const outputCheck = validateJsonValue(rawOutput);
-                if (!outputCheck.valid) {
-                    const error = {
-                        code: OUTPUT_NOT_JSON,
-                        message: `Output validation failed for action '${targetActionId}': ${outputCheck.reason}`,
-                    };
-                    finalizer.finalize("failed", undefined, error);
-                    return { ok: false, runId, error };
-                }
-                // 输出结果 Schema 校验
-                const outputSchemaError = this.checkActionOutputSchema(currentAction, targetActionId, rawOutput);
-                if (outputSchemaError) {
-                    finalizer.finalize("failed", undefined, outputSchemaError);
-                    return { ok: false, runId, error: outputSchemaError };
-                }
-                finalizer.finalize("success", rawOutput);
-                if (finalizer.persistError) {
-                    return { ok: false, runId, error: finalizer.persistError };
-                }
-                return {
-                    ok: true,
-                    runId,
-                    data: rawOutput,
-                };
-            }
-            catch (err) {
-                return this.classifyExecutionError(err, runCtx, controller, finalizer);
-            }
-            finally {
-                // 仅释放 run 级隔离实例；平台级共享 ContextProcessAPI 生命周期归平台所有，严禁在此误 dispose
-                if (ctx &&
-                    ctx.process?.runScoped === true &&
-                    typeof ctx.process.dispose === "function") {
-                    try {
-                        await ctx.process.dispose();
-                    }
-                    catch { }
-                }
-            }
-        })();
-    }
-    /**
-     * 输出结果 Schema 校验（返回校验错误或 undefined）。
-     */
-    checkActionOutputSchema(action, targetActionId, rawOutput) {
-        const targetOutputSchema = action?.outputSchema !== undefined
-            ? action.outputSchema
-            : this.projectConfig?.actions?.[targetActionId]?.outputSchema;
-        if (targetOutputSchema !== undefined) {
-            const outVal = validateSchemaOnly(targetOutputSchema, rawOutput);
-            if (!outVal.valid) {
-                return {
-                    code: OUTPUT_VALIDATION_FAILED,
-                    message: `Output schema validation failed for action '${targetActionId}'`,
-                    details: outVal.errors,
-                };
-            }
-        }
-        return undefined;
-    }
-    /**
-     * 异常分类收敛：超时、取消与业务失败分别映射为对应终态与错误码。
-     */
-    classifyExecutionError(err, runCtx, controller, finalizer) {
-        const { runId, options } = runCtx;
-        if (finalizer.isTimeout) {
-            const error = {
-                code: ACTION_TIMEOUT,
-                message: `Action exceeded timeout of ${options.timeoutMs}ms`,
-            };
-            finalizer.finalize("timed_out", undefined, error);
-            return { ok: false, runId, error: finalizer.persistError || error };
-        }
-        if (controller.signal.aborted) {
-            const reason = controller.signal.reason;
-            const reasonMsg = reason instanceof Error
-                ? reason.message
-                : typeof reason === "string"
-                    ? reason
-                    : undefined;
-            const error = {
-                code: ACTION_CANCELLED,
-                message: "Action execution was cancelled",
-                details: reasonMsg ? { reason: reasonMsg } : undefined,
-            };
-            finalizer.finalize("cancelled", undefined, error);
-            return { ok: false, runId, error: finalizer.persistError || error };
-        }
-        const error = {
-            code: err?.code || ACTION_FAILED,
-            message: err?.message || String(err),
-            details: err?.details,
-        };
-        finalizer.finalize("failed", undefined, error);
-        return {
-            ok: false,
-            runId,
-            error: finalizer.persistError || error,
-        };
-    }
-    /**
-     * 释放 Runner 持有的资源。
-     * 铁律 4：Runner 仅执行自己所属 Package 的 Action，不管理外部包生命周期。
-     */
-    async dispose() { }
-    /**
-     * 同步等待方式执行指定 Action，直接返回 ExecutionResult 信封结果。
-     *
-     * @param actionOrId Action 定义对象、引用或标识符
-     * @param input 输入参数
-     * @param options 执行控制选项
-     */
-    async execute(actionOrId, input = {}, options = {}) {
-        return this.start(actionOrId, input, options).result;
-    }
-}

package/dist/schema/index.d.ts

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

package/dist/schema/index.js

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

package/dist/server/dispatcher.d.ts

@@ -1,25 +0,0 @@
-/**
- * 获取底层 HTTP 调度器（如 Undici Agent 或自定义 Dispatcher）的提供者函数契约。
- */
-export type FetchDispatcherProvider = () => unknown;
-/**
- * 注册全局用于忽略服务端证书校验的调度器提供者。
- */
-export declare function setInsecureDispatcherProvider(provider?: FetchDispatcherProvider): void;
-/**
- * 获取当前已注册的调度器提供者函数。
- */
-export declare function getInsecureDispatcherProvider(): FetchDispatcherProvider | undefined;
-/**
- * 获取用于忽略服务端证书校验的全局单例 Undici Agent 调度器。
- * 显式配置 bodyTimeout: 0 以防止 SSE 长连接与流式事件读取出现 UND_ERR_BODY_TIMEOUT 空闲超时断流。
- */
-export declare function getInsecureDispatcher(): unknown;
-/**
- * 显式安装平台调度器：向 core 注册本模块的提供者函数。
- */
-export declare function installInsecureDispatcher(): void;
-/**
- * 显式强制重置并销毁调度器连接池（仅用于单元测试重置或进程退出）。
- */
-export declare function closeInsecureDispatcher(): Promise<void>;

package/dist/server/dispatcher.js

@@ -1,54 +0,0 @@
-import { Agent } from "undici";
-let insecureDispatcherProvider;
-let globalInsecureAgent;
-/**
- * 注册全局用于忽略服务端证书校验的调度器提供者。
- */
-export function setInsecureDispatcherProvider(provider) {
-    insecureDispatcherProvider = provider;
-}
-/**
- * 获取当前已注册的调度器提供者函数。
- */
-export function getInsecureDispatcherProvider() {
-    return insecureDispatcherProvider;
-}
-/**
- * 获取用于忽略服务端证书校验的全局单例 Undici Agent 调度器。
- * 显式配置 bodyTimeout: 0 以防止 SSE 长连接与流式事件读取出现 UND_ERR_BODY_TIMEOUT 空闲超时断流。
- */
-export function getInsecureDispatcher() {
-    if (insecureDispatcherProvider) {
-        return insecureDispatcherProvider();
-    }
-    if (!globalInsecureAgent || globalInsecureAgent.closed || globalInsecureAgent.destroyed) {
-        globalInsecureAgent = new Agent({
-            connect: {
-                rejectUnauthorized: false,
-            },
-            bodyTimeout: 0,
-        });
-    }
-    return globalInsecureAgent;
-}
-/**
- * 显式安装平台调度器：向 core 注册本模块的提供者函数。
- */
-export function installInsecureDispatcher() {
-    setInsecureDispatcherProvider(getInsecureDispatcher);
-}
-/**
- * 显式强制重置并销毁调度器连接池（仅用于单元测试重置或进程退出）。
- */
-export async function closeInsecureDispatcher() {
-    if (globalInsecureAgent) {
-        const agent = globalInsecureAgent;
-        globalInsecureAgent = undefined;
-        try {
-            await agent.close();
-        }
-        catch (err) {
-            console.warn("[actiondock] closeInsecureDispatcher failed to close agent:", err);
-        }
-    }
-}