@actiondock/core 2.6.0 → 2.8.0

package/dist/server/server.js

@@ -1,17 +1,13 @@
-import { createServer as createNodeHttpServer } from "node:http";
-import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { createActionDockHost } from "../host/host.js";
+import { NodeHttpServer } from "./http-server.js";
+import { createActionDock } from "../service/factory.js";
 import { NOT_FOUND, UNAUTHORIZED } from "../errors.js";
 import { ensureDependencyClosure } from "../project/closure.js";
 import { findProjectRoot } from "../project/loader.js";
 import { listLinkedPackages, resolvePackageRoot } from "../registry/registry.js";
-import { LocalActionDockTarget } from "../target/local.js";
 import { handleActionsRoutes, handleConfigRoutes, handleDoctorRoute, handleHealthRoute, handleInfoRoute, handlePlaybooksRoutes, handleRunsRoutes, handleStateRoutes, jsonResponse, } from "./routes/index.js";
-import { DEFAULT_MAX_BODY_BYTES } from "./body.js";
 import { isLoopbackHost, resolveCorsHeaders, verifyBearerToken } from "./security.js";
+import { createMcpEndpointHandler } from "./mcp-endpoint.js";
 /**
  * 规范化主机地址用于拼接 URL。
  * 若 host 包含冒号 : 且不以 [ 开头，则添加中括号包裹（IPv6 标准格式）。
@@ -23,132 +19,28 @@ export function formatHostForUrl(host) {
  * 根据当前运行时环境启动标准 Web Request/Response 兼容的 HTTP 服务。
  */
 export async function launchHttpServer(port, host, fetchHandler, tls) {
-    const requestListener = async (req, res) => {
-        const ac = new AbortController();
-        const onReqClose = () => {
-            if (!req.complete) {
-                ac.abort(new Error("Request aborted by client"));
-            }
-        };
-        const onResClose = () => {
-            if (!res.writableFinished) {
-                ac.abort(new Error("Request aborted by client"));
-            }
-        };
-        req.on("close", onReqClose);
-        res.on("close", onResClose);
-        try {
-            const protocol = req.socket?.encrypted ? "https" : "http";
-            const hostHeader = req.headers.host || "127.0.0.1";
-            const url = new URL(req.url || "/", `${protocol}://${hostHeader}`).href;
-            const headers = new Headers();
-            for (const [k, v] of Object.entries(req.headers)) {
-                if (v === undefined)
-                    continue;
-                if (Array.isArray(v)) {
-                    for (const item of v)
-                        headers.append(k, item);
-                }
-                else {
-                    headers.set(k, v);
-                }
-            }
-            const method = (req.method || "GET").toUpperCase();
-            const hasBody = method !== "GET" && method !== "HEAD";
-            const init = { method, headers, signal: ac.signal };
-            if (hasBody) {
-                init.body = Readable.toWeb(req);
-                init.duplex = "half";
-            }
-            const webReq = new Request(url, init);
-            const webRes = await fetchHandler(webReq);
-            res.statusCode = webRes.status;
-            if (webRes.statusText)
-                res.statusMessage = webRes.statusText;
-            webRes.headers.forEach((v, k) => res.setHeader(k, v));
-            if (!webRes.body) {
-                res.end();
-                return;
-            }
-            await pipeline(Readable.fromWeb(webRes.body), res);
-        }
-        catch (err) {
-            if (!res.headersSent) {
-                res.statusCode = 500;
-                res.end(JSON.stringify({ error: err?.message || String(err) }));
-            }
-            else {
-                res.destroy(err);
-            }
-        }
-        finally {
-            req.removeListener("close", onReqClose);
-            res.removeListener("close", onResClose);
-        }
-    };
-    let srv;
-    if (tls) {
-        let cert = tls.cert;
-        if (!cert && tls.certPath) {
-            cert = readFileSync(tls.certPath);
-        }
-        let key = tls.key;
-        if (!key && tls.keyPath) {
-            key = readFileSync(tls.keyPath);
-        }
-        const httpsOptions = {
-            cert,
-            key,
-        };
-        if (tls.ca) {
-            httpsOptions.ca = tls.ca;
-        }
-        if (tls.passphrase) {
-            httpsOptions.passphrase = tls.passphrase;
-        }
-        const { createServer: createHttpsServer } = await import("node:https");
-        srv = createHttpsServer(httpsOptions, requestListener);
-    }
-    else {
-        srv = createNodeHttpServer(requestListener);
-    }
-    const instance = {
+    const server = new NodeHttpServer({
         port,
+        host,
+        fetch: fetchHandler,
+        tls,
+    });
+    await server.listen(port, host);
+    const instance = {
+        port: server.port,
         stop: async () => {
-            await new Promise((resolve) => {
-                srv.close(() => resolve());
-                srv.closeAllConnections?.();
-            });
+            await server.close();
         },
+        ready: Promise.resolve(),
     };
-    await new Promise((resolve, reject) => {
-        srv.once("error", (err) => {
-            reject(err);
-        });
-        srv.listen(port, host, () => {
-            const addr = srv.address();
-            if (typeof addr === "object" && addr) {
-                instance.port = addr.port;
-            }
-            resolve();
-        });
-    });
-    instance.ready = Promise.resolve();
     return instance;
 }
 /**
- * 启动 ActionDock 2.0 原生轻量级 HTTP 服务端。
- * 作为 ActionDockHost 与 ActionDockTarget 的薄适配层，负责中间件流转、认证拦截与路由分发。
+ * 启动 ActionDock 原生轻量级 HTTP 服务端。
+ * 面向 ActionDockService 服务端口，负责中间件流转、认证拦截与路由分发。
  */
 export async function startActionDockServer(options = {}) {
-    let hostInstance = options.hostInstance ??
-        (options.host && typeof options.host === "object" && "listActions" in options.host
-            ? options.host
-            : undefined);
-    let targetInstance = options.target;
-    const hostString = typeof options.host === "string"
-        ? options.host
-        : (options.hostname ?? "127.0.0.1");
+    const hostString = options.hostname ?? options.host ?? "127.0.0.1";
     const port = options.port ?? 5177;
     const host = hostString;
     const token = options.token;
@@ -160,27 +52,22 @@ export async function startActionDockServer(options = {}) {
     if (!isLoopbackHost(host) && !token && !options.allowInsecureNoAuth) {
         throw new Error("Authentication token is required when binding to a non-loopback address. Use --allow-insecure-no-auth to override.");
     }
-    // 若调用方未传入 host 或 target，通过 projectRoot、customHome、platform 等直接创建宿主
-    if (!targetInstance && !hostInstance) {
+    let serviceInstance = options.service;
+    // 若未传 service，服务端统一通过 createActionDock() 实例化，不再接受或处理外部传入的 Host 实体
+    if (!serviceInstance) {
         const scanLinkedPackages = options.scanLinkedPackages ?? !projectRoot;
-        hostInstance = await createActionDockHost({
+        serviceInstance = await createActionDock({
             projectRoot: projectRoot || undefined,
             customHome,
             platform: options.platform,
             dataDir: options.dataDir,
             inMemory: options.inMemory,
             scanLinkedPackages,
-            autoLoadCurrentProject: true,
+            enableManagement: options.enableManagement,
         });
     }
-    if (!targetInstance && hostInstance) {
-        targetInstance = new LocalActionDockTarget(hostInstance);
-    }
-    else if (targetInstance && !hostInstance) {
-        const inner = targetInstance?.unwrap?.();
-        if (inner && "listApps" in inner) {
-            hostInstance = inner;
-        }
+    if (!serviceInstance) {
+        throw new Error("Failed to initialize ActionDockService for server");
     }
     const roots = [];
     if (projectRoot) {
@@ -204,6 +91,15 @@ export async function startActionDockServer(options = {}) {
     if (roots.length > 0) {
         await ensureDependencyClosure(roots, { customHome });
     }
+    // MCP 统一网关端点处理器：鉴权、请求体限流与委托序列收敛为共享单一事实源
+    const mcpEndpointHandler = options.mcpHandler
+        ? createMcpEndpointHandler(options.mcpHandler, {
+            token,
+            allowQueryToken: options.allowQueryToken,
+            corsOrigins: options.corsOrigins,
+            maxBodyBytes: options.maxBodyBytes,
+        })
+        : undefined;
     const fetchHandler = async (req) => {
         const origin = req.headers.get("origin");
         const corsHeaders = resolveCorsHeaders(origin, options.corsOrigins);
@@ -222,8 +118,7 @@ export async function startActionDockServer(options = {}) {
             corsHeaders,
             projectRoot,
             customHome,
-            host: hostInstance,
-            target: targetInstance,
+            service: serviceInstance,
             options,
         };
         // 1. 健康检查路由（内部处理独立鉴权逻辑）
@@ -231,82 +126,11 @@ export async function startActionDockServer(options = {}) {
         if (healthResponse) {
             return healthResponse;
         }
-        // 2. MCP 统一网关端点
+        // 2. MCP 统一网关端点（委托共享端点处理器）
         if (options.enableMcp !== false &&
-            options.mcpHandler &&
+            mcpEndpointHandler &&
             (pathname === "/mcp" || pathname.startsWith("/mcp/"))) {
-            if (!verifyBearerToken(req, token, options)) {
-                return jsonResponse({
-                    ok: false,
-                    error: {
-                        code: UNAUTHORIZED,
-                        message: "Invalid or missing Bearer token",
-                    },
-                }, 401, corsHeaders);
-            }
-            // 请求体体积限制保护
-            const maxBytes = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
-            const contentLengthHeader = req.headers.get("content-length");
-            if (contentLengthHeader) {
-                const parsedLength = parseInt(contentLengthHeader, 10);
-                if (!isNaN(parsedLength) && parsedLength > maxBytes) {
-                    return jsonResponse({
-                        ok: false,
-                        error: {
-                            code: "REQUEST_TOO_LARGE",
-                            message: "Request body exceeds maximum allowed size",
-                        },
-                    }, 413, corsHeaders);
-                }
-            }
-            let mcpReq = req;
-            if (req.body && req.method !== "GET" && req.method !== "HEAD") {
-                const reader = req.body.getReader();
-                const chunks = [];
-                let totalBytes = 0;
-                let tooLarge = false;
-                try {
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        if (value) {
-                            totalBytes += value.byteLength;
-                            if (totalBytes > maxBytes) {
-                                tooLarge = true;
-                                await reader.cancel();
-                                break;
-                            }
-                            chunks.push(value);
-                        }
-                    }
-                }
-                finally {
-                    reader.releaseLock();
-                }
-                if (tooLarge) {
-                    return jsonResponse({
-                        ok: false,
-                        error: {
-                            code: "REQUEST_TOO_LARGE",
-                            message: "Request body exceeds maximum allowed size",
-                        },
-                    }, 413, corsHeaders);
-                }
-                const merged = new Uint8Array(totalBytes);
-                let offset = 0;
-                for (const chunk of chunks) {
-                    merged.set(chunk, offset);
-                    offset += chunk.byteLength;
-                }
-                mcpReq = new Request(req.url, {
-                    method: req.method,
-                    headers: req.headers,
-                    body: merged,
-                    signal: req.signal,
-                });
-            }
-            const mcpRes = await options.mcpHandler(mcpReq);
+            const mcpRes = await mcpEndpointHandler(req);
             if (mcpRes)
                 return mcpRes;
         }
@@ -320,7 +144,7 @@ export async function startActionDockServer(options = {}) {
                 },
             }, 401, corsHeaders);
         }
-        // 4. 业务领域路由分发（完全委托 Target / Host）
+        // 4. 业务领域路由分发（完全委托 Service）
         const routeResponse = (await handleInfoRoute(ctx)) ||
             (await handleDoctorRoute(ctx)) ||
             (await handleActionsRoutes(ctx)) ||
@@ -353,28 +177,20 @@ export async function startActionDockServer(options = {}) {
         set port(val) {
             server.port = val;
         },
-        host: hostInstance,
-        target: targetInstance,
+        service: serviceInstance,
         get url() {
             return `${protocol}://${formatHostForUrl(actualHost)}:${this.port}`;
         },
         ready: Promise.resolve(),
         stop: async (stopOptions) => {
             await server.stop(true);
-            if (targetInstance) {
-                try {
-                    await targetInstance.close(stopOptions?.graceMs !== undefined ? { timeoutMs: stopOptions.graceMs } : undefined);
-                }
-                catch {
-                    // 忽略关闭异常
-                }
-            }
-            if (hostInstance && hostInstance !== targetInstance?.unwrap?.()) {
+            if (serviceInstance) {
                 try {
-                    await hostInstance.close(stopOptions);
+                    await serviceInstance.close(stopOptions);
                 }
-                catch {
-                    // 忽略宿主关闭异常
+                catch (err) {
+                    // 服务关闭失败不阻断停机流程，但保留可观测诊断
+                    console.warn(`[ActionDockServer] Service close failed during stop: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
         },

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,18 @@ export interface ServerTlsOptions {
     /** 私钥密码口令（若私钥被密码加密） */
     passphrase?: string;
 }
-export type CoreHttpServerFactory = (options: {
-    port: number;
-    host: string;
-    fetch: (req: Request) => Promise<Response>;
-    tls?: ServerTlsOptions;
-}) => CoreHttpServerInstance | Promise<CoreHttpServerInstance>;
 /**
  * 启动 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，关闭以防泄露） */
@@ -80,10 +71,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>;
+}