@actiondock/core 2.7.0 → 2.8.0

package/dist/service/local.js

@@ -0,0 +1,138 @@
+import { parseActionRef } from "../catalog/resolve-action.js";
+import { CloseTimeoutError, } from "./types.js";
+/**
+ * 本地 ActionDockService 实现。
+ * 遵循标准 Service Ports 体系，面向 ActionDockHost 协调中枢提供结构化服务端口，
+ * 严禁暴露 unwrap 穿透到内部领域对象。
+ */
+export class LocalActionDockService {
+    host;
+    discovery;
+    execution;
+    runs;
+    events;
+    management;
+    constructor(host, options) {
+        this.host = host;
+        const self = this;
+        this.discovery = {
+            async listPackages() {
+                return self.host.info();
+            },
+            async listActions(opts) {
+                return self.host.listActions(opts);
+            },
+            async describeAction(ref) {
+                return self.host.describeAction(ref);
+            },
+            async listPlaybooks(opts) {
+                return self.host.listPlaybooks(opts);
+            },
+            async describePlaybook(id) {
+                return self.host.describePlaybook(id);
+            },
+        };
+        this.execution = {
+            async run(ref, input, opts) {
+                const actionRef = typeof ref === "string" ? parseActionRef(ref) : ref;
+                const cleanOpts = {
+                    signal: opts?.signal,
+                    timeoutMs: opts?.timeoutMs,
+                    config: opts?.config,
+                    requestId: opts?.requestId,
+                };
+                return self.host.runAction(actionRef, (input ?? {}), cleanOpts);
+            },
+            async start(ref, input, opts) {
+                const actionRef = typeof ref === "string" ? parseActionRef(ref) : ref;
+                const cleanOpts = {
+                    signal: opts?.signal,
+                    timeoutMs: opts?.timeoutMs,
+                    config: opts?.config,
+                    requestId: opts?.requestId,
+                };
+                return self.host.startAction(actionRef, (input ?? {}), cleanOpts);
+            },
+        };
+        this.runs = {
+            async list(query) {
+                return self.host.listRuns(query);
+            },
+            async get(runId) {
+                return self.host.getRun(runId);
+            },
+            async cancel(runId, reason) {
+                return self.host.cancelRun(runId, reason);
+            },
+            async clear(opts) {
+                return self.host.clearRuns(opts);
+            },
+        };
+        this.events = {
+            events(runId, opts) {
+                return self.host.events(runId, opts);
+            },
+        };
+        if (options?.enableManagement !== false) {
+            this.management = {
+                config: {
+                    async get(packageId, key) {
+                        return self.host.getConfig(packageId, key);
+                    },
+                    async set(packageId, key, value) {
+                        return self.host.setConfig(packageId, key, value);
+                    },
+                    async delete(packageId, key) {
+                        return self.host.deleteConfig(packageId, key);
+                    },
+                    async list(packageId) {
+                        return self.host.listConfig(packageId);
+                    },
+                },
+                state: {
+                    async get(packageId, actionId, key, opts) {
+                        return self.host.getState(packageId, actionId, key, opts);
+                    },
+                    async set(packageId, actionId, key, value, opts) {
+                        return self.host.setState(packageId, actionId, key, value, opts);
+                    },
+                    async delete(packageId, actionId, key, opts) {
+                        return self.host.deleteState(packageId, actionId, key, opts);
+                    },
+                    async list(packageId, actionId, opts) {
+                        return self.host.listStateKeys(packageId, actionId, opts);
+                    },
+                    async clear(packageId, actionId, opts) {
+                        return self.host.clearState(packageId, actionId, opts);
+                    },
+                    async listEntries(packageId, opts) {
+                        return self.host.listStateEntries(packageId, opts);
+                    },
+                },
+            };
+        }
+    }
+    async info() {
+        return this.discovery.listPackages();
+    }
+    async close(options) {
+        const timeout = options?.timeoutMs ?? options?.graceMs;
+        if (timeout && timeout > 0) {
+            let timer;
+            const timeoutPromise = new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    reject(new CloseTimeoutError(`Service close operation timed out after ${timeout}ms`));
+                }, timeout);
+            });
+            try {
+                await Promise.race([this.host.close(options), timeoutPromise]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+            return;
+        }
+        return this.host.close(options);
+    }
+}

package/dist/{target → service}/remote-errors.d.ts

@@ -2,20 +2,17 @@
  * 远端通信错误翻译层。
  *
  * 职责单一：将 profile/client 传输层抛出的底层异常翻译为统一的
- * TargetError 结构化异常，供 RemoteActionDockTarget 各操作边界复用；
+ * 结构化异常，供 RemoteActionDockService 各操作边界复用；
  * 优先读取传输层透传的结构化错误码，无法识别时原样透传。
  */
 /**
- * 将远端通信异常包装翻译为统一的 TargetError。
+ * 将远端通信异常包装翻译为统一的异常。
  *
  * 无法识别的异常按防御与透明原则原样抛出，严禁静默吞没。
  */
 export declare function wrapRemoteError(err: any): never;
 /**
  * 判定远端状态键访问异常是否为键不存在。
- *
- * 优先读取传输层透传的结构化错误码（fetchRemoteJson 会将响应体 error.code
- * 附加到抛出异常的 code 字段），仅当旧版服务器未透传 code 时回退到
- * HTTP 状态与消息文本兼容嗅探。
+ * 读取结构化错误码与 HTTP 状态码。
  */
 export declare function isRemoteStateKeyNotFound(err: any): boolean;

package/dist/service/remote-errors.js

@@ -0,0 +1,38 @@
+/**
+ * 远端通信错误翻译层。
+ *
+ * 职责单一：将 profile/client 传输层抛出的底层异常翻译为统一的
+ * 结构化异常，供 RemoteActionDockService 各操作边界复用；
+ * 优先读取传输层透传的结构化错误码，无法识别时原样透传。
+ */
+import { CAPABILITY_UNAVAILABLE, STATE_KEY_NOT_FOUND } from "../errors.js";
+import { PROTOCOL_UNSUPPORTED, SERVICE_RESULT_UNKNOWN, ServiceError, } from "./types.js";
+/**
+ * 将远端通信异常包装翻译为统一的异常。
+ *
+ * 无法识别的异常按防御与透明原则原样抛出，严禁静默吞没。
+ */
+export function wrapRemoteError(err) {
+    const code = err?.code || "";
+    if (code === "CAPABILITY_UNAVAILABLE" ||
+        code === "TARGET_CAPABILITY_UNAVAILABLE") {
+        throw new ServiceError(CAPABILITY_UNAVAILABLE, `CAPABILITY_UNAVAILABLE: Management APIs are not enabled on remote service`, { originalMessage: err?.message });
+    }
+    if (code === "PROTOCOL_UNSUPPORTED" ||
+        code === "TARGET_PROTOCOL_UNSUPPORTED") {
+        throw new ServiceError(PROTOCOL_UNSUPPORTED, `PROTOCOL_UNSUPPORTED: ${err?.message || ""}`, { originalMessage: err?.message });
+    }
+    if (code === "SERVICE_RESULT_UNKNOWN" ||
+        code === "TARGET_RESULT_UNKNOWN" ||
+        code === "RESULT_UNKNOWN") {
+        throw new ServiceError(SERVICE_RESULT_UNKNOWN, `SERVICE_RESULT_UNKNOWN: ${err?.message || ""}`, { originalMessage: err?.message });
+    }
+    throw err;
+}
+/**
+ * 判定远端状态键访问异常是否为键不存在。
+ * 读取结构化错误码与 HTTP 状态码。
+ */
+export function isRemoteStateKeyNotFound(err) {
+    return err?.code === STATE_KEY_NOT_FOUND || err?.code === "NOT_FOUND" || err?.status === 404;
+}

package/dist/{target → service}/remote-polling.d.ts

@@ -7,8 +7,8 @@
  */
 import type { ExecutionResult, RunRecord } from "@actiondock/sdk";
 /**
- * 轮询依赖上下文：由 RemoteActionDockTarget 门面注入自身能力，
- * 保持本模块与门面实现解耦（子模块不得反向依赖 remote.ts）。
+ * 轮询依赖上下文：由 RemoteActionDockService 门面注入自身能力，
+ * 保持本模块与门面实现解耦。
  */
 export interface RunPollingContext {
     /** 轮询等待基准底线超时时间（毫秒，默认 60000ms） */

package/dist/{target → service}/remote-polling.js

@@ -5,9 +5,9 @@
  * 运行详情直至终态、取消或超时上限；并将终态运行记录翻译为统一
  * ExecutionResult 结构。不感知 SSE 通道与门面生命周期。
  */
-import { ACTION_CANCELLED, EXECUTION_FAILED, TIMEOUT } from "../errors.js";
+import { ACTION_CANCELLED, EXECUTION_FAILED, RUN_INTERRUPTED, TIMEOUT } from "../errors.js";
 import { isTerminalRunStatus } from "../storage/types.js";
-import { TARGET_CLOSED } from "./types.js";
+import { SERVICE_CLOSED } from "./types.js";
 /**
  * 将终态运行记录翻译为统一 ExecutionResult 结构。
  */
@@ -20,7 +20,7 @@ export function formatTerminalRunResult(run, runId) {
             ok: false,
             runId,
             error: run.error || {
-                code: "RUN_INTERRUPTED",
+                code: RUN_INTERRUPTED,
                 message: `Run '${runId}' was interrupted`,
             },
         };
@@ -55,8 +55,8 @@ export async function pollRunCompletion(ctx, runId, signal, timeoutMs, startTime
                 ok: false,
                 runId,
                 error: {
-                    code: TARGET_CLOSED,
-                    message: "RemoteActionDockTarget is closed",
+                    code: SERVICE_CLOSED,
+                    message: "RemoteActionDockService is closed",
                 },
             };
         }
@@ -77,13 +77,13 @@ export async function pollRunCompletion(ctx, runId, signal, timeoutMs, startTime
             }
         }
         catch (err) {
-            if (err?.code === TARGET_CLOSED || ctx.isClosed()) {
+            if (err?.code === SERVICE_CLOSED || ctx.isClosed()) {
                 return {
                     ok: false,
                     runId,
                     error: {
-                        code: TARGET_CLOSED,
-                        message: "RemoteActionDockTarget is closed",
+                        code: SERVICE_CLOSED,
+                        message: "RemoteActionDockService is closed",
                     },
                 };
             }

package/dist/service/remote.d.ts

@@ -0,0 +1,34 @@
+import type { PackageInfo } from "../package/types.js";
+import { type RemoteServiceOptions } from "./types.js";
+import type { ActionDockService, ConfigPort, ConnectActionDockOptions, DiscoveryPort, EventsPort, ExecutionPort, RunsPort, StatePort } from "./types.js";
+/**
+ * 远程 ActionDockService 端口实现。
+ * 封装与远端 ActionDock 服务的 HTTP / SSE 协议交互，
+ * 遵循统一的 Service Ports 契约。
+ */
+export declare class RemoteActionDockService implements ActionDockService {
+    readonly serverUrl: string;
+    readonly token?: string;
+    readonly timeoutMs?: number;
+    readonly baseTimeoutMs: number;
+    readonly allowInsecureHttp?: boolean;
+    readonly insecure?: boolean;
+    readonly dispatcher?: unknown;
+    private isClosed;
+    readonly discovery: DiscoveryPort;
+    readonly execution: ExecutionPort;
+    readonly runs: RunsPort;
+    readonly events: EventsPort;
+    readonly management?: {
+        config: ConfigPort;
+        state: StatePort;
+    };
+    constructor(options: ConnectActionDockOptions | RemoteServiceOptions);
+    private assertNotClosed;
+    info(): Promise<PackageInfo[]>;
+    private waitForRunCompletion;
+    close(_options?: {
+        timeoutMs?: number;
+        graceMs?: number;
+    }): Promise<void>;
+}