@actiondock/core 2.4.1 → 2.5.1

package/dist/app/app.js

@@ -207,6 +207,13 @@ export class DefaultActionDockApp {
         }
         // 3. 读取内存显式注入的 Action 定义
         for (const [id, act] of this.actionsMap) {
+            // 若为当前包完全限定名别名（例如 "pkgId/actionId"），跳过以防与短名 action 重复
+            if (id.startsWith(`${this.packageId}/`)) {
+                const shortId = id.slice(this.packageId.length + 1);
+                if (this.actionsMap.has(shortId) || map.has(shortId)) {
+                    continue;
+                }
+            }
             const existing = map.get(id);
             const actObj = act;
             map.set(id, {

package/dist/profile/client.d.ts

@@ -3,13 +3,27 @@ import type { RemoteHealthResult } from "./types.js";
 /**
  * 校验在携带认证 Token 时传输层协议是否安全。
  * 若请求携带认证 Token 且目标为非本地回环的明文 http://，默认报错拒绝。
- * 可通过 allowInsecureHttp 选项、ACTIONDOCK_ALLOW_INSECURE_HTTP 环境变量或 --allow-insecure-http 命令行参数豁免。
+ * 可通过 allowInsecureHttp 选项、insecure 选项、环境变量或命令行参数豁免。
  */
-export declare function assertSecureTransport(serverUrl: string, token?: string, allowInsecureHttp?: boolean): void;
+export declare function assertSecureTransport(serverUrl: string, token?: string, allowInsecureHttpOrOptions?: boolean | {
+    allowInsecureHttp?: boolean;
+    insecure?: boolean;
+}, insecureArg?: boolean): void;
+/**
+ * 远端请求通用控制选项。
+ */
+export interface RemoteClientRequestOptions {
+    /** 是否允许通过非回环明文 HTTP 发送认证 Token */
+    allowInsecureHttp?: boolean;
+    /** 是否跳过服务端 TLS 证书合法性校验 */
+    insecure?: boolean;
+    /** 自定义底层 HTTP 调度器（平台中立） */
+    dispatcher?: unknown;
+}
 /**
  * 调用远端 ActionDock 服务端执行 Action 时的选项参数。
  */
-export interface RemoteExecuteOptions {
+export interface RemoteExecuteOptions extends RemoteClientRequestOptions {
     /** 动态配置覆盖 */
     configOverrides?: Record<string, unknown>;
     /** 鉴权 Bearer Token */
@@ -22,8 +36,6 @@ export interface RemoteExecuteOptions {
     requestId?: string;
     /** 是否异步触发（202 Accepted 立即返回 runId） */
     async?: boolean;
-    /** 是否允许通过非回环明文 HTTP 发送认证 Token */
-    allowInsecureHttp?: boolean;
 }
 /**
  * 远端 Action 执行结果信封对象。
@@ -37,62 +49,47 @@ export type RemoteExecutionResult<T = unknown> = ExecutionResult<T> & {
  * @param serverUrl 目标服务端地址
  * @param token 鉴权 Token（可选）
  * @param timeoutMs 探测超时时间（默认 5000ms）
+ * @param options 传输与安全控制选项
  */
-export declare function checkRemoteHealth(serverUrl: string, token?: string, timeoutMs?: number, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<RemoteHealthResult>;
+export declare function checkRemoteHealth(serverUrl: string, token?: string, timeoutMs?: number, options?: RemoteClientRequestOptions): Promise<RemoteHealthResult>;
 export declare function executeRemoteAction<T = unknown>(serverUrl: string, actionId: string, input?: unknown, configOverridesOrOptions?: Record<string, unknown> | RemoteExecuteOptions, tokenArg?: string): Promise<RemoteExecutionResult<T>>;
-export declare function fetchRemoteRun(serverUrl: string, runId: string, token?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<RunRecord>;
-export declare function cancelRemoteRun(serverUrl: string, runId: string, token?: string, reason?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<{
+export declare function fetchRemoteRun(serverUrl: string, runId: string, token?: string, options?: RemoteClientRequestOptions): Promise<RunRecord>;
+export declare function cancelRemoteRun(serverUrl: string, runId: string, token?: string, reason?: string, options?: RemoteClientRequestOptions): Promise<{
     ok: boolean;
     runId: string;
     status: string;
 }>;
-export declare function fetchRemoteActions(serverUrl: string, token?: string, intent?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<Array<{
+export declare function fetchRemoteActions(serverUrl: string, token?: string, intent?: string, options?: RemoteClientRequestOptions): Promise<Array<{
     id: string;
     description: string;
     packageId?: string;
 }>>;
-export declare function fetchRemoteActionShow(serverUrl: string, actionId: string, token?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
+export declare function fetchRemoteActionShow(serverUrl: string, actionId: string, token?: string, options?: RemoteClientRequestOptions): Promise<any>;
 export declare function fetchRemoteInfo(serverUrl: string, token?: string, options?: {
     intent?: string;
     package?: string;
     tree?: boolean;
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
-export declare function fetchRemoteDoctor(serverUrl: string, token?: string, targetPackage?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
+} & RemoteClientRequestOptions): Promise<any>;
+export declare function fetchRemoteDoctor(serverUrl: string, token?: string, targetPackage?: string, options?: RemoteClientRequestOptions): Promise<any>;
 export declare function fetchRemotePlaybooks(serverUrl: string, token?: string, options?: {
     intent?: string;
     package?: string;
-    allowInsecureHttp?: boolean;
-}): Promise<Array<{
+} & RemoteClientRequestOptions): Promise<Array<{
     id: string;
     description: string;
     actions: string[];
     packageId: string;
     filePath: string;
 }>>;
-export declare function fetchRemotePlaybookShow(serverUrl: string, playbookId: string, token?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
+export declare function fetchRemotePlaybookShow(playbookId: string, token?: string, options?: RemoteClientRequestOptions): Promise<any>;
+export declare function fetchRemotePlaybookShow(serverUrl: string, playbookId: string, token?: string, options?: RemoteClientRequestOptions): Promise<any>;
 export declare function fetchRemoteRuns(serverUrl: string, token?: string, options?: {
     status?: string;
     actionId?: string;
     packageId?: string;
     intent?: string;
     limit?: number;
-    allowInsecureHttp?: boolean;
-}): Promise<{
+} & RemoteClientRequestOptions): Promise<{
     ok: boolean;
     total: number;
     items: RunRecord[];
@@ -101,8 +98,7 @@ export declare function clearRemoteRuns(serverUrl: string, token?: string, optio
     packageId?: string;
     actionId?: string;
     status?: string;
-    allowInsecureHttp?: boolean;
-}): Promise<{
+} & RemoteClientRequestOptions): Promise<{
     ok: boolean;
     clearedCount: number;
 }>;
@@ -111,8 +107,7 @@ export declare function fetchRemoteStateList(serverUrl: string, token?: string,
     action?: string;
     namespace?: string;
     prefix?: string;
-    allowInsecureHttp?: boolean;
-}): Promise<{
+} & RemoteClientRequestOptions): Promise<{
     ok: boolean;
     packageId: string;
     keys: string[];
@@ -121,42 +116,30 @@ export declare function getRemoteStateKey(serverUrl: string, key: string, token?
     package?: string;
     action?: string;
     namespace?: string;
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
+} & RemoteClientRequestOptions): Promise<any>;
 export declare function setRemoteStateKey(serverUrl: string, key: string, value: unknown, token?: string, options?: {
     package?: string;
     action?: string;
     namespace?: string;
     ttl?: number;
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
+} & RemoteClientRequestOptions): Promise<any>;
 export declare function deleteRemoteStateKey(serverUrl: string, key: string, token?: string, options?: {
     package?: string;
     action?: string;
     namespace?: string;
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
+} & RemoteClientRequestOptions): Promise<any>;
 export declare function clearRemoteState(serverUrl: string, token?: string, options?: {
     package?: string;
     action?: string;
     namespace?: string;
     prefix?: string;
     all?: boolean;
-    allowInsecureHttp?: boolean;
-}): Promise<{
+} & RemoteClientRequestOptions): Promise<{
     ok: boolean;
     packageId: string;
     clearedCount: number;
 }>;
-export declare function fetchRemoteConfig(serverUrl: string, token?: string, packageId?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
-export declare function setRemoteConfig(serverUrl: string, key: string, value: unknown, token?: string, packageId?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
-export declare function deleteRemoteConfig(serverUrl: string, key: string, token?: string, packageId?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
-export declare function fetchRemoteConfigEnv(serverUrl: string, token?: string, packageId?: string, options?: {
-    allowInsecureHttp?: boolean;
-}): Promise<any>;
+export declare function fetchRemoteConfig(serverUrl: string, token?: string, packageId?: string, options?: RemoteClientRequestOptions): Promise<any>;
+export declare function setRemoteConfig(serverUrl: string, key: string, value: unknown, token?: string, packageId?: string, options?: RemoteClientRequestOptions): Promise<any>;
+export declare function deleteRemoteConfig(serverUrl: string, key: string, token?: string, packageId?: string, options?: RemoteClientRequestOptions): Promise<any>;
+export declare function fetchRemoteConfigEnv(serverUrl: string, token?: string, packageId?: string, options?: RemoteClientRequestOptions): Promise<any>;

package/dist/profile/client.js

@@ -2,20 +2,33 @@ 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 选项、ACTIONDOCK_ALLOW_INSECURE_HTTP 环境变量或 --allow-insecure-http 命令行参数豁免。
+ * 可通过 allowInsecureHttp 选项、insecure 选项、环境变量或命令行参数豁免。
  */
-export function assertSecureTransport(serverUrl, token, allowInsecureHttp) {
+export function assertSecureTransport(serverUrl, token, allowInsecureHttpOrOptions, insecureArg) {
     if (!token || !token.trim()) {
         return;
     }
-    const allow = allowInsecureHttp === true ||
+    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.argv?.includes("--allow-insecure-http")));
+                process.env?.ACTIONDOCK_INSECURE === "true" ||
+                process.env?.ACTIONDOCK_INSECURE === "1"));
     if (allow) {
         return;
     }
@@ -51,28 +64,35 @@ function buildHeaders(token) {
  * @param serverUrl 目标服务端地址
  * @param token 鉴权 Token（可选）
  * @param timeoutMs 探测超时时间（默认 5000ms）
+ * @param options 传输与安全控制选项
  */
 export async function checkRemoteHealth(serverUrl, token, timeoutMs = 5000, options) {
     const startTime = Date.now();
     let timer;
     try {
-        assertSecureTransport(serverUrl, token, options?.allowInsecureHttp);
+        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);
-        let res = await fetch(v2Url, {
+        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`, {
-                    method: "GET",
-                    headers: buildHeaders(token),
-                    signal: controller.signal,
-                });
+                const v1Res = await fetch(`${base}/api/v1/health`, fetchInit);
                 if (v1Res.ok || v1Res.status !== 404) {
                     res = v1Res;
                 }
@@ -120,6 +140,8 @@ export async function executeRemoteAction(serverUrl, actionId, input = {}, confi
     let isAsync = false;
     let requestId;
     let allowInsecureHttp;
+    let insecure;
+    let dispatcher;
     if (configOverridesOrOptions && typeof configOverridesOrOptions === "object") {
         if ("token" in configOverridesOrOptions ||
             "timeoutMs" in configOverridesOrOptions ||
@@ -127,7 +149,9 @@ export async function executeRemoteAction(serverUrl, actionId, input = {}, confi
             "async" in configOverridesOrOptions ||
             "requestId" in configOverridesOrOptions ||
             "configOverrides" in configOverridesOrOptions ||
-            "allowInsecureHttp" in configOverridesOrOptions) {
+            "allowInsecureHttp" in configOverridesOrOptions ||
+            "insecure" in configOverridesOrOptions ||
+            "dispatcher" in configOverridesOrOptions) {
             const opts = configOverridesOrOptions;
             configOverrides = opts.configOverrides;
             token = opts.token ?? tokenArg;
@@ -136,12 +160,14 @@ export async function executeRemoteAction(serverUrl, actionId, input = {}, confi
             isAsync = Boolean(opts.async);
             requestId = opts.requestId;
             allowInsecureHttp = opts.allowInsecureHttp;
+            insecure = opts.insecure;
+            dispatcher = opts.dispatcher;
         }
         else {
             configOverrides = configOverridesOrOptions;
         }
     }
-    assertSecureTransport(serverUrl, token, allowInsecureHttp);
+    assertSecureTransport(serverUrl, token, { allowInsecureHttp, insecure });
     const base = normalizeServerUrl(serverUrl);
     const v2Url = `${base}/api/v2/actions/${encodeURIComponent(actionId)}/run`;
     const executionPayload = {};
@@ -187,22 +213,24 @@ export async function executeRemoteAction(serverUrl, actionId, input = {}, confi
                 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, {
-                method: "POST",
-                headers,
-                body: reqBody,
-                signal: controller.signal,
-            });
+            res = await fetch(v2Url, fetchInit);
             if (res.status === 404) {
                 try {
-                    const v1Res = await fetch(`${base}/api/v1/actions/${encodeURIComponent(actionId)}/run`, {
-                        method: "POST",
-                        headers,
-                        body: reqBody,
-                        signal: controller.signal,
-                    });
+                    const v1Res = await fetch(`${base}/api/v1/actions/${encodeURIComponent(actionId)}/run`, fetchInit);
                     if (v1Res.ok || v1Res.status !== 404) {
                         res = v1Res;
                     }
@@ -273,7 +301,10 @@ export async function executeRemoteAction(serverUrl, actionId, input = {}, confi
     }
 }
 async function fetchRemoteJson(serverUrl, path, token, options = {}) {
-    assertSecureTransport(serverUrl, token, options.allowInsecureHttp);
+    assertSecureTransport(serverUrl, token, {
+        allowInsecureHttp: options.allowInsecureHttp,
+        insecure: options.insecure,
+    });
     const base = normalizeServerUrl(serverUrl);
     const normalizedPath = path.startsWith("/") ? path : `/${path}`;
     const url = `${base}${normalizedPath}`;
@@ -284,19 +315,22 @@ async function fetchRemoteJson(serverUrl, path, token, options = {}) {
     if (options.body !== undefined) {
         headers["Content-Type"] = "application/json";
     }
-    let res = await fetch(url, {
+    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}`, {
-                method,
-                headers,
-                body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
-            });
+            const v1Res = await fetch(`${base}${v1Path}`, fetchInit);
             if (v1Res.ok || v1Res.status !== 404) {
                 res = v1Res;
             }
@@ -322,6 +356,8 @@ 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) {
@@ -330,6 +366,8 @@ export async function cancelRemoteRun(serverUrl, runId, token, reason, options)
         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) {
@@ -337,12 +375,16 @@ export async function fetchRemoteActions(serverUrl, token, intent, options) {
     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) {
@@ -357,6 +399,8 @@ export async function fetchRemoteInfo(serverUrl, token, options) {
     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) {
@@ -364,6 +408,8 @@ export async function fetchRemoteDoctor(serverUrl, token, targetPackage, options
     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) {
@@ -376,12 +422,26 @@ export async function fetchRemotePlaybooks(serverUrl, token, options) {
     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(serverUrl, playbookId, token, options) {
+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) {
@@ -400,6 +460,8 @@ export async function fetchRemoteRuns(serverUrl, token, options) {
     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) {
@@ -408,6 +470,8 @@ export async function clearRemoteRuns(serverUrl, token, options) {
         body: options || {},
         errorPrefix: "Failed to clear remote runs",
         allowInsecureHttp: options?.allowInsecureHttp,
+        insecure: options?.insecure,
+        dispatcher: options?.dispatcher,
     });
 }
 export async function fetchRemoteStateList(serverUrl, token, options) {
@@ -424,6 +488,8 @@ export async function fetchRemoteStateList(serverUrl, token, options) {
     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) {
@@ -438,6 +504,8 @@ export async function getRemoteStateKey(serverUrl, key, token, options) {
     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) {
@@ -452,6 +520,8 @@ export async function setRemoteStateKey(serverUrl, key, value, token, options) {
         },
         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) {
@@ -467,6 +537,8 @@ export async function deleteRemoteStateKey(serverUrl, key, token, options) {
         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) {
@@ -475,6 +547,8 @@ export async function clearRemoteState(serverUrl, token, options) {
         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) {
@@ -482,6 +556,8 @@ export async function fetchRemoteConfig(serverUrl, token, packageId, options) {
     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) {
@@ -490,6 +566,8 @@ export async function setRemoteConfig(serverUrl, key, value, token, packageId, o
         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) {
@@ -498,6 +576,8 @@ export async function deleteRemoteConfig(serverUrl, key, token, packageId, optio
         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) {
@@ -505,5 +585,7 @@ export async function fetchRemoteConfigEnv(serverUrl, token, packageId, options)
     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,
     });
 }

package/dist/profile/manager.d.ts

@@ -20,6 +20,7 @@ export declare function loadProfiles(customHome?: string): ProfilesConfig;
  */
 export declare function saveProfiles(data: ProfilesConfig, customHome?: string): void;
 export declare function addProfile(name: string, entry: ProfileEntry, customHome?: string): void;
+export declare function updateProfile(name: string, entry: Partial<ProfileEntry>, customHome?: string): void;
 export declare function removeProfile(name: string, customHome?: string): boolean;
 export declare function useProfile(name: string, customHome?: string): void;
 export declare function getProfile(name: string, customHome?: string): ProfileEntry | undefined;
@@ -44,4 +45,6 @@ export declare function resolveTarget(options?: {
     profile?: string;
     server?: string;
     token?: string;
+    insecure?: boolean;
+    allowInsecureHttp?: boolean;
 }, customHome?: string): ResolvedTarget;