@actiondock/core 2.5.0 → 2.6.0

package/dist/profile/client.js

@@ -1,591 +1,31 @@
-import { randomUUID } from "node:crypto";
-import { normalizeServerUrl } from "./manager.js";
-import { ACTION_CANCELLED, ACTION_TIMEOUT, NETWORK_ERROR } from "../errors.js";
-import { isLoopbackHost } from "../server/security.js";
-import { getInsecureDispatcher } from "../server/dispatcher.js";
 /**
- * 校验在携带认证 Token 时传输层协议是否安全。
- * 若请求携带认证 Token 且目标为非本地回环的明文 http://，默认报错拒绝。
- * 可通过 allowInsecureHttp 选项、insecure 选项、环境变量或命令行参数豁免。
- */
-export function assertSecureTransport(serverUrl, token, allowInsecureHttpOrOptions, insecureArg) {
-    if (!token || !token.trim()) {
-        return;
-    }
-    let allowInsecureHttp = false;
-    let insecure = false;
-    if (typeof allowInsecureHttpOrOptions === "object" && allowInsecureHttpOrOptions !== null) {
-        allowInsecureHttp = Boolean(allowInsecureHttpOrOptions.allowInsecureHttp);
-        insecure = Boolean(allowInsecureHttpOrOptions.insecure);
-    }
-    else {
-        allowInsecureHttp = Boolean(allowInsecureHttpOrOptions);
-        insecure = Boolean(insecureArg);
-    }
-    const allow = allowInsecureHttp ||
-        insecure ||
-        (typeof process !== "undefined" &&
-            (process.env?.ACTIONDOCK_ALLOW_INSECURE_HTTP === "true" ||
-                process.env?.ACTIONDOCK_ALLOW_INSECURE_HTTP === "1" ||
-                process.env?.ACTIONDOCK_INSECURE === "true" ||
-                process.env?.ACTIONDOCK_INSECURE === "1"));
-    if (allow) {
-        return;
-    }
-    const base = normalizeServerUrl(serverUrl);
-    if (base.startsWith("http://")) {
-        try {
-            const parsed = new URL(base);
-            if (!isLoopbackHost(parsed.hostname)) {
-                const err = new Error(`Insecure HTTP connection with authentication token to non-loopback host '${parsed.hostname}' is prohibited. Use HTTPS or pass --allow-insecure-http to override.`);
-                err.code = "INSECURE_TRANSPORT";
-                throw err;
-            }
-        }
-        catch (e) {
-            if (e.code === "INSECURE_TRANSPORT") {
-                throw e;
-            }
-        }
-    }
-}
-function buildHeaders(token) {
-    const headers = {
-        Accept: "application/json",
-    };
-    if (token && token.trim()) {
-        headers.Authorization = `Bearer ${token.trim()}`;
-    }
-    return headers;
-}
-/**
- * 探测指定远端 ActionDock 服务的健康状态与网络延迟。
+ * 远端 Profile 客户端聚合入口。
+ *
+ * 历史上全部端点函数集中于单一 client.ts（约 950 行），现按域拆分为
+ * 单一职责模块，此处仅保留聚合 re-export，导入路径 ./client 与
+ * @actiondock/core 的公共导出面保持完全兼容。
  *
- * @param serverUrl 目标服务端地址
- * @param token 鉴权 Token（可选）
- * @param timeoutMs 探测超时时间（默认 5000ms）
- * @param options 传输与安全控制选项
+ * 模块划分：
+ * - client-transport：传输层（鉴权头、明文校验、协议回退）
+ * - client-query：共享请求与查询构造层
+ * - client-health：健康检查
+ * - client-actions：执行与 Action 查询
+ * - client-playbooks：Playbook 规程查询
+ * - client-runs：运行记录管理
+ * - client-state：状态存储管理
+ * - client-config：配置管理
  */
-export async function checkRemoteHealth(serverUrl, token, timeoutMs = 5000, options) {
-    const startTime = Date.now();
-    let timer;
-    try {
-        assertSecureTransport(serverUrl, token, {
-            allowInsecureHttp: options?.allowInsecureHttp,
-            insecure: options?.insecure,
-        });
-        const base = normalizeServerUrl(serverUrl);
-        const v2Url = `${base}/api/v2/health`;
-        const controller = new AbortController();
-        timer = setTimeout(() => controller.abort(), timeoutMs);
-        const fetchInit = {
-            method: "GET",
-            headers: buildHeaders(token),
-            signal: controller.signal,
-        };
-        if (options?.dispatcher) {
-            fetchInit.dispatcher = options.dispatcher;
-        }
-        else if (options?.insecure) {
-            fetchInit.dispatcher = getInsecureDispatcher();
-        }
-        let res = await fetch(v2Url, fetchInit);
-        if (res.status === 404) {
-            try {
-                const v1Res = await fetch(`${base}/api/v1/health`, fetchInit);
-                if (v1Res.ok || v1Res.status !== 404) {
-                    res = v1Res;
-                }
-            }
-            catch { }
-        }
-        const latencyMs = Date.now() - startTime;
-        if (!res.ok) {
-            const text = await res.text().catch(() => "");
-            return {
-                ok: false,
-                latencyMs,
-                error: `Server responded with status ${res.status}: ${text || res.statusText}`,
-            };
-        }
-        const data = (await res.json().catch(() => ({})));
-        return {
-            ok: true,
-            status: data.status || "healthy",
-            version: data.version,
-            uptime: data.uptime,
-            latencyMs,
-        };
-    }
-    catch (err) {
-        const latencyMs = Date.now() - startTime;
-        return {
-            ok: false,
-            latencyMs,
-            error: err.name === "AbortError" ? "Connection timed out" : err.message,
-        };
-    }
-    finally {
-        if (timer !== undefined) {
-            clearTimeout(timer);
-        }
-    }
-}
-export async function executeRemoteAction(serverUrl, actionId, input = {}, configOverridesOrOptions, tokenArg) {
-    // Parse options / backwards compatibility
-    let configOverrides;
-    let token = tokenArg;
-    let timeoutMs;
-    let signal;
-    let isAsync = false;
-    let requestId;
-    let allowInsecureHttp;
-    let insecure;
-    let dispatcher;
-    if (configOverridesOrOptions && typeof configOverridesOrOptions === "object") {
-        if ("token" in configOverridesOrOptions ||
-            "timeoutMs" in configOverridesOrOptions ||
-            "signal" in configOverridesOrOptions ||
-            "async" in configOverridesOrOptions ||
-            "requestId" in configOverridesOrOptions ||
-            "configOverrides" in configOverridesOrOptions ||
-            "allowInsecureHttp" in configOverridesOrOptions ||
-            "insecure" in configOverridesOrOptions ||
-            "dispatcher" in configOverridesOrOptions) {
-            const opts = configOverridesOrOptions;
-            configOverrides = opts.configOverrides;
-            token = opts.token ?? tokenArg;
-            timeoutMs = opts.timeoutMs;
-            signal = opts.signal;
-            isAsync = Boolean(opts.async);
-            requestId = opts.requestId;
-            allowInsecureHttp = opts.allowInsecureHttp;
-            insecure = opts.insecure;
-            dispatcher = opts.dispatcher;
-        }
-        else {
-            configOverrides = configOverridesOrOptions;
-        }
-    }
-    assertSecureTransport(serverUrl, token, { allowInsecureHttp, insecure });
-    const base = normalizeServerUrl(serverUrl);
-    const v2Url = `${base}/api/v2/actions/${encodeURIComponent(actionId)}/run`;
-    const executionPayload = {};
-    if (isAsync) {
-        executionPayload.mode = "async";
-    }
-    if (typeof timeoutMs === "number" && timeoutMs > 0) {
-        executionPayload.timeoutMs = timeoutMs;
-    }
-    if (requestId) {
-        executionPayload.requestId = requestId;
-    }
-    // 组合外部取消信号与本地超时守卫：服务端僵死时仍能在 timeoutMs 内本地中断，避免永久挂起
-    let timeoutTimer;
-    let localTimedOut = false;
-    try {
-        const headers = {
-            ...buildHeaders(token),
-            "Content-Type": "application/json",
-        };
-        if (requestId) {
-            headers["Idempotency-Key"] = requestId;
-            headers["x-request-id"] = requestId;
-        }
-        const reqBody = JSON.stringify({
-            input,
-            config: configOverrides,
-            execution: Object.keys(executionPayload).length > 0 ? executionPayload : undefined,
-        });
-        const controller = new AbortController();
-        const onExternalAbort = () => controller.abort(signal?.reason);
-        if (signal) {
-            if (signal.aborted) {
-                controller.abort(signal.reason);
-            }
-            else {
-                signal.addEventListener("abort", onExternalAbort, { once: true });
-            }
-        }
-        if (typeof timeoutMs === "number" && timeoutMs > 0) {
-            timeoutTimer = setTimeout(() => {
-                localTimedOut = true;
-                controller.abort();
-            }, timeoutMs);
-        }
-        const fetchInit = {
-            method: "POST",
-            headers,
-            body: reqBody,
-            signal: controller.signal,
-        };
-        if (dispatcher) {
-            fetchInit.dispatcher = dispatcher;
-        }
-        else if (insecure) {
-            fetchInit.dispatcher = getInsecureDispatcher();
-        }
-        let res;
-        try {
-            res = await fetch(v2Url, fetchInit);
-            if (res.status === 404) {
-                try {
-                    const v1Res = await fetch(`${base}/api/v1/actions/${encodeURIComponent(actionId)}/run`, fetchInit);
-                    if (v1Res.ok || v1Res.status !== 404) {
-                        res = v1Res;
-                    }
-                }
-                catch { }
-            }
-        }
-        finally {
-            if (timeoutTimer !== undefined) {
-                clearTimeout(timeoutTimer);
-            }
-            if (signal) {
-                signal.removeEventListener("abort", onExternalAbort);
-            }
-        }
-        const data = (await res.json().catch(() => null));
-        if (data && typeof data === "object" && typeof data.ok === "boolean") {
-            return data;
-        }
-        if (!res.ok) {
-            // 错误信封严禁伪造 runId：与任何真实运行无关的标识会让调用方查询永远 not_found
-            return {
-                ok: false,
-                runId: "",
-                error: {
-                    code: res.status === 401 ? "UNAUTHORIZED" : "REMOTE_EXECUTION_FAILED",
-                    message: `Remote server HTTP ${res.status}: ${res.statusText}`,
-                    details: data,
-                },
-            };
-        }
-        return {
-            ok: true,
-            runId: randomUUID(),
-            data,
-        };
-    }
-    catch (err) {
-        // 本地超时守卫触发时归类为超时；外部信号中止时归类为取消
-        if (localTimedOut) {
-            return {
-                ok: false,
-                runId: "",
-                error: {
-                    code: ACTION_TIMEOUT,
-                    message: `Remote execution exceeded local timeout of ${timeoutMs}ms`,
-                },
-            };
-        }
-        if (err.name === "AbortError" || signal?.aborted) {
-            return {
-                ok: false,
-                runId: "",
-                error: {
-                    code: ACTION_CANCELLED,
-                    message: "Action execution was cancelled",
-                },
-            };
-        }
-        return {
-            ok: false,
-            runId: "",
-            error: {
-                code: NETWORK_ERROR,
-                message: `Failed to connect to remote ActionDock server at ${serverUrl}: ${err.message}`,
-            },
-        };
-    }
-}
-async function fetchRemoteJson(serverUrl, path, token, options = {}) {
-    assertSecureTransport(serverUrl, token, {
-        allowInsecureHttp: options.allowInsecureHttp,
-        insecure: options.insecure,
-    });
-    const base = normalizeServerUrl(serverUrl);
-    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-    const url = `${base}${normalizedPath}`;
-    const method = options.method || "GET";
-    const headers = {
-        ...buildHeaders(token),
-    };
-    if (options.body !== undefined) {
-        headers["Content-Type"] = "application/json";
-    }
-    const fetchInit = {
-        method,
-        headers,
-        body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
-    };
-    if (options.dispatcher) {
-        fetchInit.dispatcher = options.dispatcher;
-    }
-    else if (options.insecure) {
-        fetchInit.dispatcher = getInsecureDispatcher();
-    }
-    let res = await fetch(url, fetchInit);
-    if (res.status === 404 && normalizedPath.startsWith("/api/v2/")) {
-        const v1Path = normalizedPath.replace("/api/v2/", "/api/v1/");
-        try {
-            const v1Res = await fetch(`${base}${v1Path}`, fetchInit);
-            if (v1Res.ok || v1Res.status !== 404) {
-                res = v1Res;
-            }
-        }
-        catch { }
-    }
-    const data = (await res.json().catch(() => ({})));
-    if (!res.ok || (options.method === "POST" && data && data.ok === false)) {
-        const errorPrefix = options.errorPrefix || "Remote request failed";
-        const msg = data?.error?.message || `${errorPrefix} (${res.status}): ${res.statusText}`;
-        const err = new Error(msg);
-        if (data?.error?.code) {
-            err.code = data.error.code;
-        }
-        err.status = res.status;
-        err.errorData = data?.error;
-        err.details = data?.error?.details ?? data?.error;
-        throw err;
-    }
-    return data;
-}
-export async function fetchRemoteRun(serverUrl, runId, token, options) {
-    return fetchRemoteJson(serverUrl, `/api/v2/runs/${encodeURIComponent(runId)}`, token, {
-        errorPrefix: `Failed to fetch remote run '${runId}'`,
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function cancelRemoteRun(serverUrl, runId, token, reason, options) {
-    return fetchRemoteJson(serverUrl, `/api/v2/runs/${encodeURIComponent(runId)}/cancel`, token, {
-        method: "POST",
-        body: { reason },
-        errorPrefix: `Failed to cancel remote run '${runId}'`,
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemoteActions(serverUrl, token, intent, options) {
-    const query = intent ? `?intent=${encodeURIComponent(intent)}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/actions${query}`, token, {
-        errorPrefix: "Failed to fetch remote actions",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemoteActionShow(serverUrl, actionId, token, options) {
-    return fetchRemoteJson(serverUrl, `/api/v2/actions/${encodeURIComponent(actionId)}`, token, {
-        errorPrefix: `Failed to fetch remote action '${actionId}'`,
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemoteInfo(serverUrl, token, options) {
-    const params = new URLSearchParams();
-    if (options?.intent)
-        params.set("intent", options.intent);
-    if (options?.package)
-        params.set("package", options.package);
-    if (options?.tree)
-        params.set("tree", "true");
-    const qs = params.toString() ? `?${params.toString()}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/info${qs}`, token, {
-        errorPrefix: "Failed to fetch remote info",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemoteDoctor(serverUrl, token, targetPackage, options) {
-    const query = targetPackage ? `?package=${encodeURIComponent(targetPackage)}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/doctor${query}`, token, {
-        errorPrefix: "Failed to fetch remote doctor report",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemotePlaybooks(serverUrl, token, options) {
-    const params = new URLSearchParams();
-    if (options?.intent)
-        params.set("intent", options.intent);
-    if (options?.package)
-        params.set("package", options.package);
-    const qs = params.toString() ? `?${params.toString()}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/playbooks${qs}`, token, {
-        errorPrefix: "Failed to fetch remote playbooks",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemotePlaybookShow(serverUrlOrPlaybookId, playbookIdOrToken, tokenOrOptions, optionsArg) {
-    let serverUrl = serverUrlOrPlaybookId;
-    let playbookId = playbookIdOrToken || "";
-    let token;
-    let options = optionsArg;
-    if (typeof tokenOrOptions === "object") {
-        options = tokenOrOptions;
-    }
-    else if (typeof tokenOrOptions === "string") {
-        token = tokenOrOptions;
-    }
-    return fetchRemoteJson(serverUrl, `/api/v2/playbooks/${encodeURIComponent(playbookId)}`, token, {
-        errorPrefix: `Failed to fetch remote playbook '${playbookId}'`,
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemoteRuns(serverUrl, token, options) {
-    const params = new URLSearchParams();
-    if (options?.status)
-        params.set("status", options.status);
-    if (options?.actionId)
-        params.set("actionId", options.actionId);
-    if (options?.packageId)
-        params.set("packageId", options.packageId);
-    if (options?.intent)
-        params.set("intent", options.intent);
-    if (options?.limit)
-        params.set("limit", String(options.limit));
-    const qs = params.toString() ? `?${params.toString()}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/runs${qs}`, token, {
-        errorPrefix: "Failed to fetch remote runs",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function clearRemoteRuns(serverUrl, token, options) {
-    return fetchRemoteJson(serverUrl, "/api/v2/runs/clear", token, {
-        method: "POST",
-        body: options || {},
-        errorPrefix: "Failed to clear remote runs",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemoteStateList(serverUrl, token, options) {
-    const params = new URLSearchParams();
-    if (options?.package)
-        params.set("package", options.package);
-    if (options?.action)
-        params.set("action", options.action);
-    if (options?.namespace !== undefined)
-        params.set("namespace", options.namespace);
-    if (options?.prefix)
-        params.set("prefix", options.prefix);
-    const qs = params.toString() ? `?${params.toString()}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/state${qs}`, token, {
-        errorPrefix: "Failed to list remote state keys",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function getRemoteStateKey(serverUrl, key, token, options) {
-    const params = new URLSearchParams();
-    if (options?.package)
-        params.set("package", options.package);
-    if (options?.action)
-        params.set("action", options.action);
-    if (options?.namespace !== undefined)
-        params.set("namespace", options.namespace);
-    const qs = params.toString() ? `?${params.toString()}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/state/${encodeURIComponent(key)}${qs}`, token, {
-        errorPrefix: `Failed to fetch remote state key '${key}'`,
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function setRemoteStateKey(serverUrl, key, value, token, options) {
-    return fetchRemoteJson(serverUrl, `/api/v2/state/${encodeURIComponent(key)}`, token, {
-        method: "PUT",
-        body: {
-            value,
-            package: options?.package,
-            action: options?.action,
-            namespace: options?.namespace,
-            ttl: options?.ttl,
-        },
-        errorPrefix: `Failed to set remote state key '${key}'`,
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function deleteRemoteStateKey(serverUrl, key, token, options) {
-    const params = new URLSearchParams();
-    if (options?.package)
-        params.set("package", options.package);
-    if (options?.action)
-        params.set("action", options.action);
-    if (options?.namespace !== undefined)
-        params.set("namespace", options.namespace);
-    const qs = params.toString() ? `?${params.toString()}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/state/${encodeURIComponent(key)}${qs}`, token, {
-        method: "DELETE",
-        errorPrefix: `Failed to delete remote state key '${key}'`,
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function clearRemoteState(serverUrl, token, options) {
-    return fetchRemoteJson(serverUrl, "/api/v2/state/clear", token, {
-        method: "POST",
-        body: options || {},
-        errorPrefix: "Failed to clear remote state",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemoteConfig(serverUrl, token, packageId, options) {
-    const query = packageId ? `?package=${encodeURIComponent(packageId)}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/config${query}`, token, {
-        errorPrefix: "Failed to fetch remote config",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function setRemoteConfig(serverUrl, key, value, token, packageId, options) {
-    return fetchRemoteJson(serverUrl, "/api/v2/config", token, {
-        method: "PUT",
-        body: { key, value, package: packageId },
-        errorPrefix: `Failed to set remote config '${key}'`,
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function deleteRemoteConfig(serverUrl, key, token, packageId, options) {
-    const query = packageId ? `?package=${encodeURIComponent(packageId)}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/config/${encodeURIComponent(key)}${query}`, token, {
-        method: "DELETE",
-        errorPrefix: `Failed to delete remote config '${key}'`,
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
-export async function fetchRemoteConfigEnv(serverUrl, token, packageId, options) {
-    const query = packageId ? `?package=${encodeURIComponent(packageId)}` : "";
-    return fetchRemoteJson(serverUrl, `/api/v2/config/env${query}`, token, {
-        errorPrefix: "Failed to fetch remote config env checks",
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-        dispatcher: options?.dispatcher,
-    });
-}
+// 传输层与通用类型
+export { assertSecureTransport, createRemoteFetch, fetchWithProtocolFallback, listProtocolRouteCandidates, } from "./client-transport.js";
+// 健康检查
+export { checkRemoteHealth } from "./client-health.js";
+// 执行与 Action 查询
+export { executeRemoteAction, fetchRemoteActionShow, fetchRemoteActions, fetchRemoteDoctor, fetchRemoteInfo, } from "./client-actions.js";
+// Playbook 规程查询
+export { fetchRemotePlaybookShow, fetchRemotePlaybooks } from "./client-playbooks.js";
+// 运行记录管理
+export { cancelRemoteRun, clearRemoteRuns, fetchRemoteRun, fetchRemoteRuns, } from "./client-runs.js";
+// 状态存储管理
+export { clearRemoteState, deleteRemoteStateKey, fetchRemoteStateList, getRemoteStateKey, setRemoteStateKey, } from "./client-state.js";
+// 配置管理
+export { deleteRemoteConfig, fetchRemoteConfig, fetchRemoteConfigEnv, setRemoteConfig, } from "./client-config.js";

package/dist/profile/manager.js

@@ -1,7 +1,7 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { toSnakeUpperCase } from "../runtime/env.js";
-import { isLoopbackHost } from "../server/security.js";
+import { isLoopbackHost } from "../utils/net.js";
 import { getActionDockHome } from "../utils/index.js";
 const PROFILE_NAME_REGEX = /^[a-zA-Z0-9_\-\.]+$/;
 /**

package/dist/project/closure.d.ts

@@ -9,17 +9,17 @@ export interface EnsureDependencyClosureOptions {
     customHome?: string;
 }
 export interface DependencyClosureResult {
-    /** 成功执行依赖安装或更新的项目根路径列表 */
+    /** 成功执行依赖预装的项目根路径列表（默认实现下永远为空） */
     installed: string[];
     /** 无法在注册表中解析包引用的警告列表 */
     warnings: string[];
 }
 /**
- * 广度优先遍历 (BFS) uses 声明的跨包依赖闭包，对涉及的每个项目包逐一执行依赖预装（ensureProjectDependencies）。
- * 内部已尊重 ACTIONDOCK_AUTO_INSTALL=false 环境变量。
+ * 广度优先遍历 (BFS) uses 声明的跨包依赖闭包，对涉及的每个项目包逐一调用依赖预装回调。
+ * 默认预装回调为明确的不操作（ActionDock 2.0 不做运行时安装）；可通过 opts.ensure 注入自定义实现。
  *
  * @param roots 根项目目录列表
  * @param opts 选项参数
- * @returns 安装成功的路径列表及警告信息
+ * @returns 预装成功的路径列表及警告信息
  */
 export declare function ensureDependencyClosure(roots: string[], opts?: EnsureDependencyClosureOptions): Promise<DependencyClosureResult>;

package/dist/project/closure.js

@@ -1,15 +1,21 @@
 import { resolve } from "node:path";
 import { ActionResolver } from "../catalog/action-resolver.js";
 import { resolvePackageRoot } from "../registry/registry.js";
-import { ensureProjectDependencies } from "./loader.js";
 import { loadManifest } from "./manifest.js";
 /**
- * 广度优先遍历 (BFS) uses 声明的跨包依赖闭包，对涉及的每个项目包逐一执行依赖预装（ensureProjectDependencies）。
- * 内部已尊重 ACTIONDOCK_AUTO_INSTALL=false 环境变量。
+ * 依赖预装的默认实现：明确的不操作。
+ * ActionDock 2.0 移除了运行时静默在线安装，保留该签名仅为闭包遍历提供注入点（便于单测 Mock 与自定义扩展）。
+ */
+function noopEnsure() {
+    return false;
+}
+/**
+ * 广度优先遍历 (BFS) uses 声明的跨包依赖闭包，对涉及的每个项目包逐一调用依赖预装回调。
+ * 默认预装回调为明确的不操作（ActionDock 2.0 不做运行时安装）；可通过 opts.ensure 注入自定义实现。
  *
  * @param roots 根项目目录列表
  * @param opts 选项参数
- * @returns 安装成功的路径列表及警告信息
+ * @returns 预装成功的路径列表及警告信息
  */
 export async function ensureDependencyClosure(roots, opts = {}) {
     const seen = new Set();
@@ -24,7 +30,7 @@ export async function ensureDependencyClosure(roots, opts = {}) {
         if (seen.has(root))
             continue;
         seen.add(root);
-        const ensureFn = opts.ensure ?? ensureProjectDependencies;
+        const ensureFn = opts.ensure ?? noopEnsure;
         const wasInstalled = await ensureFn(root);
         if (wasInstalled) {
             installed.push(root);