@actiondock/core 2.5.1 → 2.6.0

package/dist/profile/client-actions.js

@@ -0,0 +1,215 @@
+import { randomUUID } from "node:crypto";
+import { ACTION_CANCELLED, ACTION_TIMEOUT, NETWORK_ERROR } from "../errors.js";
+import { getInsecureDispatcher } from "../server/dispatcher.js";
+import { normalizeServerUrl } from "./manager.js";
+import { assertSecureTransport, buildHeaders, fetchWithProtocolFallback, } from "./client-transport.js";
+import { buildQueryString, fetchRemoteJson } from "./client-query.js";
+/**
+ * 执行远端 Action：支持幂等标识、异步触发、外部取消信号与本地超时守卫组合。
+ */
+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 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 fetchWithProtocolFallback(normalizeServerUrl(serverUrl), `/api/v2/actions/${encodeURIComponent(actionId)}/run`, fetchInit);
+        }
+        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}`,
+            },
+        };
+    }
+}
+/**
+ * 拉取远端 Action 列表（可按意图过滤）。
+ */
+export async function fetchRemoteActions(serverUrl, token, intent, options) {
+    return fetchRemoteJson(serverUrl, `/api/v2/actions${buildQueryString({ intent })}`, token, {
+        errorPrefix: "Failed to fetch remote actions",
+        allowInsecureHttp: options?.allowInsecureHttp,
+        insecure: options?.insecure,
+        dispatcher: options?.dispatcher,
+    });
+}
+/**
+ * 拉取单个远端 Action 的详细契约描述。
+ */
+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) {
+    return fetchRemoteJson(serverUrl, `/api/v2/info${buildQueryString({
+        intent: options?.intent,
+        package: options?.package,
+        tree: options?.tree ? "true" : undefined,
+    })}`, token, {
+        errorPrefix: "Failed to fetch remote info",
+        allowInsecureHttp: options?.allowInsecureHttp,
+        insecure: options?.insecure,
+        dispatcher: options?.dispatcher,
+    });
+}
+/**
+ * 拉取远端环境体检报告（可定向指定包）。
+ */
+export async function fetchRemoteDoctor(serverUrl, token, targetPackage, options) {
+    return fetchRemoteJson(serverUrl, `/api/v2/doctor${buildQueryString({ package: targetPackage })}`, token, {
+        errorPrefix: "Failed to fetch remote doctor report",
+        allowInsecureHttp: options?.allowInsecureHttp,
+        insecure: options?.insecure,
+        dispatcher: options?.dispatcher,
+    });
+}

package/dist/profile/client-config.d.ts

@@ -0,0 +1,20 @@
+import type { RemoteClientRequestOptions } from "./client-transport.js";
+/**
+ * 远端配置域端点。
+ */
+/**
+ * 拉取远端配置视图（可定向指定包）。
+ */
+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-config.js

@@ -0,0 +1,51 @@
+import { buildQueryString, fetchRemoteJson } from "./client-query.js";
+/**
+ * 远端配置域端点。
+ */
+/**
+ * 拉取远端配置视图（可定向指定包）。
+ */
+export async function fetchRemoteConfig(serverUrl, token, packageId, options) {
+    return fetchRemoteJson(serverUrl, `/api/v2/config${buildQueryString({ package: packageId })}`, 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) {
+    return fetchRemoteJson(serverUrl, `/api/v2/config/${encodeURIComponent(key)}${buildQueryString({ package: packageId })}`, 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) {
+    return fetchRemoteJson(serverUrl, `/api/v2/config/env${buildQueryString({ package: packageId })}`, token, {
+        errorPrefix: "Failed to fetch remote config env checks",
+        allowInsecureHttp: options?.allowInsecureHttp,
+        insecure: options?.insecure,
+        dispatcher: options?.dispatcher,
+    });
+}

package/dist/profile/client-health.d.ts

@@ -0,0 +1,14 @@
+import type { RemoteHealthResult } from "./types.js";
+import { type RemoteClientRequestOptions } from "./client-transport.js";
+/**
+ * 远端健康检查域端点。
+ */
+/**
+ * 探测指定远端 ActionDock 服务的健康状态与网络延迟。
+ *
+ * @param serverUrl 目标服务端地址
+ * @param token 鉴权 Token（可选）
+ * @param timeoutMs 探测超时时间（默认 5000ms）
+ * @param options 传输与安全控制选项
+ */
+export declare function checkRemoteHealth(serverUrl: string, token?: string, timeoutMs?: number, options?: RemoteClientRequestOptions): Promise<RemoteHealthResult>;

package/dist/profile/client-health.js

@@ -0,0 +1,68 @@
+import { normalizeServerUrl } from "./manager.js";
+import { assertSecureTransport, buildHeaders, fetchWithProtocolFallback, } from "./client-transport.js";
+import { getInsecureDispatcher } from "../server/dispatcher.js";
+/**
+ * 远端健康检查域端点。
+ */
+/**
+ * 探测指定远端 ActionDock 服务的健康状态与网络延迟。
+ *
+ * @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, {
+            allowInsecureHttp: options?.allowInsecureHttp,
+            insecure: options?.insecure,
+        });
+        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();
+        }
+        const res = await fetchWithProtocolFallback(normalizeServerUrl(serverUrl), "/api/v2/health", fetchInit);
+        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);
+        }
+    }
+}

package/dist/profile/client-playbooks.d.ts

@@ -0,0 +1,19 @@
+import type { RemoteClientRequestOptions } from "./client-transport.js";
+/**
+ * 远端 Playbook 规程域端点。
+ */
+/**
+ * 拉取远端 Playbook 列表（可按意图与包名过滤）。
+ */
+export declare function fetchRemotePlaybooks(serverUrl: string, token?: string, options?: {
+    intent?: string;
+    package?: string;
+} & RemoteClientRequestOptions): Promise<Array<{
+    id: string;
+    description: string;
+    actions: string[];
+    packageId: string;
+    filePath: string;
+}>>;
+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>;

package/dist/profile/client-playbooks.js

@@ -0,0 +1,36 @@
+import { buildQueryString, fetchRemoteJson } from "./client-query.js";
+/**
+ * 远端 Playbook 规程域端点。
+ */
+/**
+ * 拉取远端 Playbook 列表（可按意图与包名过滤）。
+ */
+export async function fetchRemotePlaybooks(serverUrl, token, options) {
+    return fetchRemoteJson(serverUrl, `/api/v2/playbooks${buildQueryString({
+        intent: options?.intent,
+        package: options?.package,
+    })}`, 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,
+    });
+}

package/dist/profile/client-query.d.ts

@@ -0,0 +1,30 @@
+import { type RemoteClientRequestOptions } from "./client-transport.js";
+/**
+ * 远端端点函数共享的请求与查询构造层。
+ *
+ * 职责单一聚焦：JSON 响应解析与错误信封透传、查询参数序列化，
+ * 供各按域端点模块复用，杜绝端点函数内手工拼 query 样板。
+ */
+/**
+ * 执行远端请求并将响应解析为 JSON，统一处理错误信封透传。
+ * 非 2xx 响应或显式 ok=false 信封抛出携带 code/status/details 的 Error。
+ */
+export declare function fetchRemoteJson<T = any>(serverUrl: string, path: string, token?: string, options?: {
+    method?: string;
+    body?: unknown;
+    errorPrefix?: string;
+} & RemoteClientRequestOptions): Promise<T>;
+/**
+ * 由可选参数字典构造查询串（无参数时返回空串）。
+ *
+ * 序列化规则与既有端点行为严格一致：
+ * - undefined 与空串一律跳过（对应原有 if (options?.xxx) 真值守卫）；
+ * - 需保留「存在但为空」语义的参数（如 namespace，服务端区分空串与未传递）
+ *   由调用方显式处理，不经由此助手序列化空串。
+ */
+export declare function buildQueryString(params: Record<string, string | number | boolean | undefined>): string;
+/**
+ * 构造保留「存在但为空」语义的查询串：仅跳过 undefined，空串照常序列化。
+ * 适用 namespace 类参数：服务端以参数是否存在区分空命名空间与默认命名空间。
+ */
+export declare function buildQueryStringPreservingEmpty(params: Record<string, string | number | boolean | undefined>): string;

package/dist/profile/client-query.js

@@ -0,0 +1,70 @@
+import { createRemoteFetch } from "./client-transport.js";
+/**
+ * 远端端点函数共享的请求与查询构造层。
+ *
+ * 职责单一聚焦：JSON 响应解析与错误信封透传、查询参数序列化，
+ * 供各按域端点模块复用，杜绝端点函数内手工拼 query 样板。
+ */
+/**
+ * 执行远端请求并将响应解析为 JSON，统一处理错误信封透传。
+ * 非 2xx 响应或显式 ok=false 信封抛出携带 code/status/details 的 Error。
+ */
+export async function fetchRemoteJson(serverUrl, path, token, options = {}) {
+    const remoteFetch = createRemoteFetch(serverUrl, token, {
+        allowInsecureHttp: options.allowInsecureHttp,
+        insecure: options.insecure,
+        dispatcher: options.dispatcher,
+    });
+    const res = await remoteFetch(path, {
+        method: options.method,
+        body: options.body,
+    });
+    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;
+}
+/**
+ * 由可选参数字典构造查询串（无参数时返回空串）。
+ *
+ * 序列化规则与既有端点行为严格一致：
+ * - undefined 与空串一律跳过（对应原有 if (options?.xxx) 真值守卫）；
+ * - 需保留「存在但为空」语义的参数（如 namespace，服务端区分空串与未传递）
+ *   由调用方显式处理，不经由此助手序列化空串。
+ */
+export function buildQueryString(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === "") {
+            continue;
+        }
+        search.set(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : "";
+}
+/**
+ * 构造保留「存在但为空」语义的查询串：仅跳过 undefined，空串照常序列化。
+ * 适用 namespace 类参数：服务端以参数是否存在区分空命名空间与默认命名空间。
+ */
+export function buildQueryStringPreservingEmpty(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined) {
+            continue;
+        }
+        search.set(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : "";
+}

package/dist/profile/client-runs.d.ts

@@ -0,0 +1,42 @@
+import type { RunRecord } from "@actiondock/sdk";
+import type { RemoteClientRequestOptions } from "./client-transport.js";
+/**
+ * 远端运行记录域端点。
+ */
+/**
+ * 拉取单条远端运行记录。
+ */
+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 fetchRemoteRuns(serverUrl: string, token?: string, options?: {
+    status?: string;
+    actionId?: string;
+    packageId?: string;
+    intent?: string;
+    limit?: number;
+} & RemoteClientRequestOptions): Promise<{
+    ok: boolean;
+    total: number;
+    items: RunRecord[];
+}>;
+/**
+ * 清空远端运行记录（可按包、Action、状态过滤清除范围）。
+ */
+export declare function clearRemoteRuns(serverUrl: string, token?: string, options?: {
+    packageId?: string;
+    actionId?: string;
+    status?: string;
+} & RemoteClientRequestOptions): Promise<{
+    ok: boolean;
+    clearedCount: number;
+}>;

package/dist/profile/client-runs.js

@@ -0,0 +1,58 @@
+import { buildQueryString, fetchRemoteJson } from "./client-query.js";
+/**
+ * 远端运行记录域端点。
+ */
+/**
+ * 拉取单条远端运行记录。
+ */
+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 fetchRemoteRuns(serverUrl, token, options) {
+    return fetchRemoteJson(serverUrl, `/api/v2/runs${buildQueryString({
+        status: options?.status,
+        actionId: options?.actionId,
+        packageId: options?.packageId,
+        intent: options?.intent,
+        limit: options?.limit,
+    })}`, token, {
+        errorPrefix: "Failed to fetch remote runs",
+        allowInsecureHttp: options?.allowInsecureHttp,
+        insecure: options?.insecure,
+        dispatcher: options?.dispatcher,
+    });
+}
+/**
+ * 清空远端运行记录（可按包、Action、状态过滤清除范围）。
+ */
+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,
+    });
+}