@actiondock/core 2.7.0 → 2.9.0

package/dist/server/types.d.ts

@@ -1,5 +1,4 @@
-import type { ActionDockHost } from "../host/types.js";
-import type { ActionDockTarget } from "../target/types.js";
+import type { ActionDockService } from "../service/types.js";
 export interface CoreHttpServerInstance {
     port: number;
     stop: (closeActiveConnections?: boolean) => void | Promise<void>;
@@ -19,26 +18,52 @@ export interface ServerTlsOptions {
     /** 私钥密码口令（若私钥被密码加密） */
     passphrase?: string;
 }
-export type CoreHttpServerFactory = (options: {
-    port: number;
-    host: string;
-    fetch: (req: Request) => Promise<Response>;
-    tls?: ServerTlsOptions;
-}) => CoreHttpServerInstance | Promise<CoreHttpServerInstance>;
+/**
+ * 单个虚拟投影视图（Virtual View）的配置选项。
+ */
+export interface ServerViewOptions {
+    /** 视图唯一标识名称（若在 views 对象中配置则键名作为默认名称） */
+    name?: string;
+    /** 该视图独立的 Bearer Token 鉴权令牌 */
+    token?: string;
+    /** 该视图允许访问执行的 Package ID 白名单列表（为空允许全部） */
+    packageAllowlist?: string[];
+    /** 该视图允许访问执行的 Action 标识白名单列表（为空允许全部，支持短名或 packageId/actionId） */
+    actionAllowlist?: string[];
+    /** 该视图是否开启配置与状态管理路由能力（默认关闭） */
+    enableManagement?: boolean;
+    /** 该视图是否启用一体化 MCP 协议支持（默认开启） */
+    enableMcp?: boolean;
+    /** 该视图自定义的 MCP 请求处理器钩子（可选，支持请求处理函数或接收视图策略的工厂函数） */
+    mcpHandler?: ((req: Request, view?: EffectiveServerPolicy) => Promise<Response | null | undefined> | Response | null | undefined) | ((view: EffectiveServerPolicy) => ((req: Request) => Promise<Response | null | undefined> | Response | null | undefined));
+}
+/**
+ * 当前请求上下文生效的统一服务端安全策略。
+ */
+export interface EffectiveServerPolicy {
+    /** 当前生效的视图名称（默认视图为 "default"） */
+    viewName?: string;
+    /** 当前生效的 Bearer Token 鉴权令牌 */
+    token?: string;
+    /** 当前生效的 Package ID 白名单列表 */
+    packageAllowlist?: string[];
+    /** 当前生效的 Action 标识白名单列表 */
+    actionAllowlist?: string[];
+    /** 当前生效的管理能力开关 */
+    enableManagement?: boolean;
+}
 /**
  * 启动 ActionDock HTTP Runner 服务端的配置选项。
  */
 export interface ServerOptions {
     /** 监听端口号（默认 5177） */
     port?: number;
-    /** 绑定监听的主机地址（默认 "127.0.0.1"），或关联的 ActionDockHost 宿主实例 */
-    host?: string | ActionDockHost;
-    /** 显式绑定的 ActionDockHost 宿主实例（向前兼容别名） */
-    hostInstance?: ActionDockHost;
-    /** 关联的目标 ActionDockTarget 门面实例 */
-    target?: ActionDockTarget;
-    /** 显式绑定的主机地址（当 host 传入 ActionDockHost 时的可选覆盖项） */
+    /** 绑定监听的主机地址（默认 "127.0.0.1"） */
     hostname?: string;
+    /** 绑定监听的主机地址（hostname 的字符串别名） */
+    host?: string;
+    /** 关联的标准 ActionDockService 服务端口实例 */
+    service?: ActionDockService;
     /** 用于 HTTP Bearer Token 鉴权的密钥令牌 */
     token?: string;
     /** 是否允许通过 URL 查询参数携带 Token 进行鉴权（默认 false，关闭以防泄露） */
@@ -57,14 +82,18 @@ export interface ServerOptions {
     corsOrigins?: string[];
     /** 允许访问执行的 Package ID 白名单列表（为空允许全部） */
     packageAllowlist?: string[];
+    /** 允许访问执行的 Action 标识白名单列表（为空允许全部，支持短名或 packageId/actionId） */
+    actionAllowlist?: string[];
     /** 最大允许的请求体字节限制（默认 1MB，防 DoS） */
     maxBodyBytes?: number;
     /** 是否在 health 和 info 接口中透传本地 projectRoot 等调试路径 */
     exposeDebugInfo?: boolean;
     /** 是否启用一体化 MCP 协议支持（默认开启） */
     enableMcp?: boolean;
-    /** 自定义 MCP 请求处理器钩子（若挂载则 /mcp 路由交由其处理） */
-    mcpHandler?: (req: Request) => Promise<Response | null | undefined> | Response | null | undefined;
+    /** 自定义 MCP 请求处理器钩子（若挂载则 /mcp 路由交由其处理，支持处理函数或接收视图策略的工厂函数） */
+    mcpHandler?: ((req: Request, view?: EffectiveServerPolicy) => Promise<Response | null | undefined> | Response | null | undefined) | ((view: EffectiveServerPolicy) => ((req: Request) => Promise<Response | null | undefined> | Response | null | undefined));
+    /** 自定义 MCP 处理器工厂函数（可选，为每个视图创建独立处理器） */
+    mcpHandlerFactory?: (view: EffectiveServerPolicy) => ((req: Request) => Promise<Response | null | undefined> | Response | null | undefined);
     /** 可选注入的统一运行时底层平台 */
     platform?: import("../platform/types.js").RuntimePlatform;
     /** 是否显式开启配置与状态管理路由能力（默认关闭，关闭时返回 403） */
@@ -73,6 +102,26 @@ export interface ServerOptions {
     scanLinkedPackages?: boolean;
     /** 服务端 TLS/HTTPS 安全传输选项 */
     tls?: ServerTlsOptions;
+    /**
+     * 虚拟投影视图配置。
+     * 支持对象字典形式 Record<string, ServerViewOptions> 或数组形式 ServerViewOptions[]。
+     * 单端口上支持多视图独立隔离 Token、白名单与管理权限。
+     */
+    views?: Record<string, ServerViewOptions> | ServerViewOptions[];
+}
+/**
+ * 路由处理统一上下文对象。
+ */
+export interface RouteContext {
+    req: Request;
+    url: URL;
+    pathname: string;
+    corsHeaders: Record<string, string>;
+    projectRoot: string | null;
+    customHome?: string;
+    service: ActionDockService;
+    options: ServerOptions;
+    activePolicy: EffectiveServerPolicy;
 }
 /**
  * 已启动的 ActionDock HTTP Runner 实例句柄。
@@ -80,10 +129,8 @@ export interface ServerOptions {
 export interface ActionDockServerInstance {
     /** 实际监听的端口号 */
     port: number;
-    /** 关联的 ActionDockHost 宿主实例（若启动时传入或创建） */
-    host?: ActionDockHost;
-    /** 关联的 ActionDockTarget 目标门面实例 */
-    target?: ActionDockTarget;
+    /** 关联的 ActionDockService 服务端口实例 */
+    service: ActionDockService;
     /** 服务端可访问的基础 URL（如 "http://127.0.0.1:5177"） */
     url: string;
     /** 服务就绪 Promise（可等待端口解析与监听建立） */

package/dist/service/factory.d.ts

@@ -0,0 +1,12 @@
+import { RemoteActionDockService } from "./remote.js";
+import type { ActionDockService, ConnectActionDockOptions, CreateActionDockOptions, RemoteServiceOptions } from "./types.js";
+/**
+ * 工厂函数：创建本地 ActionDock 服务实例。
+ * 遵循标准 Service Ports 体系，屏蔽底层多包协调或单包存储细节。
+ */
+export declare function createActionDock(options?: CreateActionDockOptions): Promise<ActionDockService>;
+/**
+ * 工厂函数：连接远端 ActionDock 服务实例。
+ * 支持传入目标 HTTP 根地址、Profile 别名或完整连接配置选项。
+ */
+export declare function connectActionDock(urlOrProfile: string | RemoteServiceOptions, options?: ConnectActionDockOptions): Promise<RemoteActionDockService>;

package/dist/service/factory.js

@@ -0,0 +1,85 @@
+import { createActionDockHost } from "../host/host.js";
+import { LocalActionDockService } from "./local.js";
+import { RemoteActionDockService } from "./remote.js";
+import { ActionDockError, INVALID_ARGUMENT, NOT_FOUND } from "../errors.js";
+/**
+ * 工厂函数：创建本地 ActionDock 服务实例。
+ * 遵循标准 Service Ports 体系，屏蔽底层多包协调或单包存储细节。
+ */
+export async function createActionDock(options = {}) {
+    if (options.runtimeOptions) {
+        const inMemory = options.inMemory ?? options.runtimeOptions.inMemory;
+        const host = await createActionDockHost({
+            packages: [options.runtimeOptions],
+            autoLoadCurrentProject: false,
+            scanLinkedPackages: false,
+            inMemory,
+            dataDir: options.dataDir ?? options.runtimeOptions.dataDir,
+            customHome: options.customHome ?? options.runtimeOptions.customHome,
+            platform: options.platform ?? options.runtimeOptions.platform,
+            clock: options.runtimeOptions.clock,
+            process: options.runtimeOptions.process,
+            logger: options.runtimeOptions.logger,
+            recoverOrphans: options.recoverOrphans,
+        });
+        return new LocalActionDockService(host, { enableManagement: options.enableManagement });
+    }
+    const host = await createActionDockHost({
+        scanLinkedPackages: options.scanLinkedPackages ?? true,
+        ...options,
+        recoverOrphans: options.recoverOrphans ?? true,
+        ...(options.hostOptions || {}),
+    });
+    return new LocalActionDockService(host, { enableManagement: options.enableManagement });
+}
+/**
+ * 工厂函数：连接远端 ActionDock 服务实例。
+ * 支持传入目标 HTTP 根地址、Profile 别名或完整连接配置选项。
+ */
+export async function connectActionDock(urlOrProfile, options) {
+    let targetUrl;
+    let token = options?.token;
+    let insecure = options?.insecure;
+    let allowInsecureHttp = options?.allowInsecureHttp;
+    let dispatcher = options?.dispatcher;
+    let timeoutMs = options?.timeoutMs;
+    let baseTimeoutMs = options?.baseTimeoutMs;
+    if (typeof urlOrProfile === "object" && urlOrProfile !== null) {
+        targetUrl = urlOrProfile.serverUrl;
+        token = urlOrProfile.token ?? token;
+        insecure = urlOrProfile.insecure ?? insecure;
+        allowInsecureHttp = urlOrProfile.allowInsecureHttp ?? allowInsecureHttp;
+        dispatcher = urlOrProfile.dispatcher ?? dispatcher;
+        timeoutMs = urlOrProfile.timeoutMs ?? timeoutMs;
+        baseTimeoutMs = urlOrProfile.baseTimeoutMs ?? baseTimeoutMs;
+    }
+    else if (typeof urlOrProfile === "string") {
+        if (urlOrProfile.startsWith("http://") || urlOrProfile.startsWith("https://")) {
+            targetUrl = urlOrProfile;
+        }
+        else {
+            const { resolveTarget } = await import("../profile/manager.js");
+            const resolved = resolveTarget({ profile: urlOrProfile }, options?.customHome);
+            if (resolved.type !== "remote" || !resolved.serverUrl) {
+                throw new ActionDockError(NOT_FOUND, `Profile '${urlOrProfile}' not found or is not a remote profile`);
+            }
+            targetUrl = resolved.serverUrl;
+            token = resolved.token ?? token;
+            insecure = resolved.insecure ?? insecure;
+            allowInsecureHttp = resolved.allowInsecureHttp ?? allowInsecureHttp;
+        }
+    }
+    else {
+        throw new ActionDockError(INVALID_ARGUMENT, "Invalid urlOrProfile argument for connectActionDock");
+    }
+    return new RemoteActionDockService({
+        serverUrl: targetUrl,
+        token,
+        insecure,
+        allowInsecureHttp,
+        dispatcher,
+        timeoutMs,
+        baseTimeoutMs,
+        enableManagement: options?.enableManagement,
+    });
+}

package/dist/{target → service}/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./types.js";
 export * from "./local.js";
 export * from "./remote.js";
-export * from "./target.js";
+export * from "./factory.js";

package/dist/{target → service}/index.js

@@ -1,4 +1,4 @@
 export * from "./types.js";
 export * from "./local.js";
 export * from "./remote.js";
-export * from "./target.js";
+export * from "./factory.js";

package/dist/service/local.d.ts

@@ -0,0 +1,27 @@
+import type { PackageInfo } from "../package/types.js";
+import type { ActionDockHost } from "../host/types.js";
+import type { ActionDockService, ConfigPort, DiscoveryPort, EventsPort, ExecutionPort, RunsPort, StatePort } from "./types.js";
+/**
+ * 本地 ActionDockService 实现。
+ * 遵循标准 Service Ports 体系，面向 ActionDockHost 协调中枢提供结构化服务端口，
+ * 严禁暴露 unwrap 穿透到内部领域对象。
+ */
+export declare class LocalActionDockService implements ActionDockService {
+    protected readonly host: ActionDockHost;
+    readonly discovery: DiscoveryPort;
+    readonly execution: ExecutionPort;
+    readonly runs: RunsPort;
+    readonly events: EventsPort;
+    readonly management?: {
+        config: ConfigPort;
+        state: StatePort;
+    };
+    constructor(host: ActionDockHost, options?: {
+        enableManagement?: boolean;
+    });
+    info(): Promise<PackageInfo[]>;
+    close(options?: {
+        timeoutMs?: number;
+        graceMs?: number;
+    }): Promise<void>;
+}

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>;
+}