@actiondock/core 2.6.0 → 2.8.0

package/dist/target/remote.js

@@ -1,818 +0,0 @@
-import { ActionResolver } from "../catalog/action-resolver.js";
-import { cancelRemoteRun, clearRemoteRuns, clearRemoteState, deleteRemoteConfig, deleteRemoteStateKey, executeRemoteAction, fetchRemoteActionShow, fetchRemoteActions, fetchRemoteConfig, fetchRemoteInfo, fetchRemotePlaybookShow, fetchRemotePlaybooks, fetchRemoteRun, fetchRemoteRuns, fetchRemoteStateList, getRemoteStateKey, setRemoteConfig, setRemoteStateKey, assertSecureTransport, } from "../profile/client.js";
-import { normalizeServerUrl } from "../profile/manager.js";
-import { isTerminalRunStatus } from "../storage/types.js";
-import { ACTIONDOCK_PROTOCOL_VERSION, TargetError, TARGET_PROTOCOL_UNSUPPORTED, TARGET_CAPABILITY_UNAVAILABLE, TARGET_CLOSED, } from "./types.js";
-import { ACTION_CANCELLED, REMOTE_STREAM_UNAVAILABLE, TIMEOUT } from "../errors.js";
-import { getInsecureDispatcher } from "../server/dispatcher.js";
-import { listProtocolRouteCandidates } from "../profile/client.js";
-import { isRemoteStateKeyNotFound, wrapRemoteError } from "./remote-errors.js";
-import { formatTerminalRunResult, pollRunCompletion } from "./remote-polling.js";
-import { parseSseMessages } from "./sse-parser.js";
-/**
- * 读取并解析远端 SSE 事件流。
- *
- * 候选路由依次尝试：v2 /events -> v2 /stream -> v1 /stream；
- * 全部候选均不可用（网络异常或非流式响应）时抛出携带各候选 URL 与
- * 失败原因的 REMOTE_STREAM_UNAVAILABLE 聚合错误，严禁以空流伪装正常。
- */
-export async function* streamRemoteEvents(serverUrl, runId, token, options) {
-    assertSecureTransport(serverUrl, token, {
-        allowInsecureHttp: options?.allowInsecureHttp,
-        insecure: options?.insecure,
-    });
-    const base = normalizeServerUrl(serverUrl);
-    const runRoute = `runs/${encodeURIComponent(runId)}`;
-    // 候选优先级：v2 /events -> v2 /stream -> v1 /stream（后两者经共享协议候选工具展开）
-    const candidateUrls = [
-        `${base}/api/v2/${runRoute}/events`,
-        ...listProtocolRouteCandidates(base, `/api/v2/${runRoute}/stream`),
-    ];
-    const headers = {
-        Accept: "text/event-stream",
-    };
-    if (token && token.trim()) {
-        headers.Authorization = `Bearer ${token.trim()}`;
-    }
-    if (options?.after !== undefined) {
-        headers["Last-Event-ID"] = String(options.after);
-    }
-    /**
-     * 依次尝试全部候选路由，返回首个可用响应。
-     *
-     * 单个候选失败（网络异常或非流式响应）时记录原因继续尝试后续候选；
-     * 所有候选均失败时返回汇总后的失败原因列表供上层抛出聚合错误。
-     */
-    async function resolveStreamCandidate() {
-        const candidateFailures = [];
-        for (const url of candidateUrls) {
-            const fetchInit = {
-                headers,
-                signal: options?.signal,
-            };
-            if (options?.dispatcher) {
-                fetchInit.dispatcher = options.dispatcher;
-            }
-            else if (options?.insecure) {
-                fetchInit.dispatcher = getInsecureDispatcher();
-            }
-            try {
-                const resp = await fetch(url, fetchInit);
-                if (resp.status === 410) {
-                    let errJson;
-                    try {
-                        errJson = await resp.json();
-                    }
-                    catch { }
-                    const err = new Error(errJson?.error?.message || "Event cursor has expired");
-                    err.code = errJson?.error?.code || "EVENT_CURSOR_EXPIRED";
-                    err.details = errJson?.error?.details;
-                    throw err;
-                }
-                if (resp.ok && resp.body) {
-                    return { ok: true, body: resp.body };
-                }
-                candidateFailures.push({
-                    url,
-                    reason: `HTTP ${resp.status} ${resp.statusText || ""}`.trim(),
-                });
-            }
-            catch (err) {
-                if (err?.code === "EVENT_CURSOR_EXPIRED") {
-                    throw err;
-                }
-                candidateFailures.push({
-                    url,
-                    reason: err?.message ? `${err.name || "Error"}: ${err.message}` : String(err),
-                });
-            }
-        }
-        return { ok: false, candidateFailures };
-    }
-    /**
-     * 构造全部候选路由均不可用时的聚合错误。
-     */
-    function buildStreamUnavailableError(candidateFailures) {
-        const summary = candidateFailures
-            .map((f) => `${f.url} (${f.reason})`)
-            .join(", ");
-        const err = new Error(`REMOTE_STREAM_UNAVAILABLE: All event stream candidates failed for run '${runId}': ${summary}`);
-        err.code = REMOTE_STREAM_UNAVAILABLE;
-        err.details = {
-            runId,
-            candidates: candidateFailures.map((f) => ({ url: f.url, reason: f.reason })),
-        };
-        return err;
-    }
-    const res = await resolveStreamCandidate();
-    if (!res.ok) {
-        throw buildStreamUnavailableError(res.candidateFailures);
-    }
-    try {
-        for await (const msg of parseSseMessages(res.body, { signal: options?.signal })) {
-            const evt = decodeExecutionEvent(msg, runId);
-            if (evt)
-                yield evt;
-        }
-    }
-    catch (err) {
-        if (err.name === "AbortError" || options?.signal?.aborted) {
-            return;
-        }
-        throw err;
-    }
-}
-/**
- * 将 SSE 消息载荷解码为统一执行事件。
- *
- * 非 JSON 数据行直接忽略；finish 事件取 data.result 字段，其余事件字段展开合并。
- */
-function decodeExecutionEvent(msg, runId) {
-    try {
-        const data = JSON.parse(msg.data);
-        if (msg.event === "finish") {
-            return {
-                eventId: msg.id ?? data.eventId,
-                type: "finish",
-                runId,
-                timestamp: new Date().toISOString(),
-                result: data.result || data,
-            };
-        }
-        else {
-            return {
-                eventId: msg.id ?? data.eventId,
-                type: (msg.event || "message"),
-                runId,
-                timestamp: new Date().toISOString(),
-                ...data,
-            };
-        }
-    }
-    catch {
-        // 忽略非 JSON 数据行
-        return undefined;
-    }
-}
-/**
- * 远程 ActionDockTarget 门面实现。
- * 内部封装基于 HTTP/SSE 协议与远端 ActionDock 服务端的通信管道。
- */
-export class RemoteActionDockTarget {
-    serverUrl;
-    token;
-    timeoutMs;
-    baseTimeoutMs;
-    allowInsecureHttp;
-    insecure;
-    dispatcher;
-    isClosed = false;
-    constructor(options) {
-        this.serverUrl = options.serverUrl;
-        this.token = options.token;
-        this.timeoutMs = options.timeoutMs;
-        this.baseTimeoutMs = options.baseTimeoutMs ?? 60000;
-        this.allowInsecureHttp = options.allowInsecureHttp;
-        this.insecure = options.insecure;
-        this.dispatcher = options.dispatcher;
-    }
-    assertNotClosed() {
-        if (this.isClosed) {
-            throw new TargetError(TARGET_CLOSED, "RemoteActionDockTarget is closed");
-        }
-    }
-    async info() {
-        this.assertNotClosed();
-        let raw;
-        try {
-            raw = await fetchRemoteInfo(this.serverUrl, this.token, {
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-        const protocolVersion = (raw && typeof raw === "object" && raw.protocolVersion) || ACTIONDOCK_PROTOCOL_VERSION;
-        if (protocolVersion && typeof protocolVersion === "string") {
-            const [remoteMajor] = protocolVersion.split(".");
-            const [currentMajor] = ACTIONDOCK_PROTOCOL_VERSION.split(".");
-            if (remoteMajor !== currentMajor) {
-                throw new TargetError(TARGET_PROTOCOL_UNSUPPORTED, `TARGET_PROTOCOL_UNSUPPORTED: Remote server protocol version '${protocolVersion}' is incompatible with expected '${ACTIONDOCK_PROTOCOL_VERSION}'`);
-            }
-        }
-        let packages = [];
-        if (Array.isArray(raw)) {
-            packages = raw;
-        }
-        else if (raw && typeof raw === "object") {
-            if (Array.isArray(raw.packages)) {
-                packages = raw.packages;
-            }
-            else if (raw.packages && typeof raw.packages === "object") {
-                packages = Object.values(raw.packages);
-            }
-        }
-        return {
-            id: (raw && typeof raw === "object" && raw.id) || "remote-target",
-            name: (raw && typeof raw === "object" && raw.name) || "Remote ActionDock Server",
-            protocolVersion,
-            packages,
-            capabilities: (raw && typeof raw === "object" && Array.isArray(raw.capabilities))
-                ? raw.capabilities
-                : ["actions", "playbooks", "runs", "events", "management.config", "management.state"],
-            idempotencyPolicy: raw && typeof raw === "object" ? raw.idempotencyPolicy : undefined,
-        };
-    }
-    async listPackages() {
-        this.assertNotClosed();
-        const info = await this.info();
-        return info.packages;
-    }
-    async listActions(options) {
-        this.assertNotClosed();
-        const rawList = await fetchRemoteActions(this.serverUrl, this.token, options?.query, {
-            allowInsecureHttp: this.allowInsecureHttp,
-            insecure: this.insecure,
-            dispatcher: this.dispatcher,
-        });
-        let summaries = rawList.map((item) => ({
-            id: item.id,
-            description: item.description,
-            tags: item.tags,
-            inputSchema: item.inputSchema,
-            outputSchema: item.outputSchema,
-            packageId: item.packageId,
-        }));
-        if (options?.prefix) {
-            summaries = summaries.filter((s) => s.id.startsWith(options.prefix));
-        }
-        if (options?.tags && options.tags.length > 0) {
-            summaries = summaries.filter((s) => options.tags.every((t) => s.tags?.includes(t)));
-        }
-        return summaries;
-    }
-    async describeAction(ref) {
-        this.assertNotClosed();
-        let parsed;
-        try {
-            parsed = ActionResolver.parseRef(ref);
-        }
-        catch {
-            parsed = typeof ref === "object" ? ref : { actionId: ref };
-        }
-        const actionId = parsed.packageId
-            ? `${parsed.packageId}/${parsed.actionId}`
-            : parsed.actionId;
-        const raw = await fetchRemoteActionShow(this.serverUrl, actionId, this.token, {
-            allowInsecureHttp: this.allowInsecureHttp,
-            insecure: this.insecure,
-            dispatcher: this.dispatcher,
-        });
-        return {
-            id: raw.id,
-            description: raw.description,
-            inputSchema: raw.inputSchema,
-            outputSchema: raw.outputSchema,
-            tags: raw.tags,
-            annotations: raw.annotations,
-            uses: raw.uses,
-            entry: raw.entry,
-            filePath: raw.filePath,
-            packageId: raw.packageId ?? parsed.packageId,
-        };
-    }
-    async listPlaybooks(options) {
-        this.assertNotClosed();
-        const rawList = await fetchRemotePlaybooks(this.serverUrl, this.token, {
-            ...options,
-            allowInsecureHttp: this.allowInsecureHttp,
-            insecure: this.insecure,
-            dispatcher: this.dispatcher,
-        });
-        return rawList.map((item) => ({
-            id: item.id,
-            description: item.description,
-            actions: item.actions,
-            packageId: item.packageId,
-            filePath: item.filePath,
-        }));
-    }
-    async describePlaybook(id) {
-        this.assertNotClosed();
-        const raw = await fetchRemotePlaybookShow(this.serverUrl, id, this.token, {
-            allowInsecureHttp: this.allowInsecureHttp,
-            insecure: this.insecure,
-            dispatcher: this.dispatcher,
-        });
-        const parsedPkgId = id.includes("/") ? id.slice(0, id.lastIndexOf("/")) : undefined;
-        return {
-            id: raw.id,
-            description: raw.description,
-            actions: raw.actions,
-            filePath: raw.filePath,
-            content: raw.content,
-            packageId: raw.packageId ?? parsedPkgId,
-        };
-    }
-    async runAction(ref, input, options) {
-        this.assertNotClosed();
-        let parsed;
-        try {
-            parsed = ActionResolver.parseRef(ref);
-        }
-        catch {
-            parsed = typeof ref === "object" ? ref : { actionId: ref };
-        }
-        const actionId = parsed.packageId
-            ? `${parsed.packageId}/${parsed.actionId}`
-            : parsed.actionId;
-        return executeRemoteAction(this.serverUrl, actionId, input, {
-            configOverrides: options?.config,
-            token: this.token,
-            timeoutMs: options?.timeoutMs ?? this.timeoutMs,
-            signal: options?.signal,
-            requestId: options?.requestId,
-            async: false,
-            allowInsecureHttp: this.allowInsecureHttp,
-            insecure: this.insecure,
-            dispatcher: this.dispatcher,
-        });
-    }
-    async startAction(ref, input, options) {
-        this.assertNotClosed();
-        let parsed;
-        try {
-            parsed = ActionResolver.parseRef(ref);
-        }
-        catch {
-            parsed = typeof ref === "object" ? ref : { actionId: ref };
-        }
-        const actionId = parsed.packageId
-            ? `${parsed.packageId}/${parsed.actionId}`
-            : parsed.actionId;
-        const res = await executeRemoteAction(this.serverUrl, actionId, input, {
-            configOverrides: options?.config,
-            token: this.token,
-            timeoutMs: options?.timeoutMs ?? this.timeoutMs,
-            signal: options?.signal,
-            requestId: options?.requestId,
-            async: true,
-            allowInsecureHttp: this.allowInsecureHttp,
-            insecure: this.insecure,
-            dispatcher: this.dispatcher,
-        });
-        if (!res.ok) {
-            return {
-                runId: res.runId,
-                status: "failed",
-                result: Promise.resolve(res),
-            };
-        }
-        const runId = res.runId || res.data?.runId;
-        const status = res.status || res.data?.status || "running";
-        return {
-            runId,
-            status,
-            result: this.waitForRunCompletion(runId, options?.signal, options?.timeoutMs),
-        };
-    }
-    /**
-     * 等待远端运行抵达终态：优先监听 SSE 事件流，失败后按指数退避轮询运行详情。
-     *
-     * @param runId 运行标识
-     * @param signal 外部取消信号
-     * @param timeoutMs 运行自身声明的超时（等待上限取该值与默认上限中的较大者）
-     */
-    async waitForRunCompletion(runId, signal, timeoutMs) {
-        const startTime = Date.now();
-        const maxWaitMs = Math.max(this.baseTimeoutMs, timeoutMs ?? 0);
-        if (signal?.aborted) {
-            return {
-                ok: false,
-                runId,
-                error: {
-                    code: ACTION_CANCELLED,
-                    message: "Action execution was cancelled",
-                },
-            };
-        }
-        if (this.isClosed) {
-            return {
-                ok: false,
-                runId,
-                error: {
-                    code: TARGET_CLOSED,
-                    message: "RemoteActionDockTarget is closed",
-                },
-            };
-        }
-        const internalController = new AbortController();
-        let sseTimedOut = false;
-        let timer;
-        if (maxWaitMs > 0 && maxWaitMs !== Infinity) {
-            timer = setTimeout(() => {
-                sseTimedOut = true;
-                internalController.abort();
-            }, maxWaitMs);
-        }
-        const onAbort = () => {
-            internalController.abort();
-        };
-        if (signal) {
-            signal.addEventListener("abort", onAbort, { once: true });
-        }
-        // 优先尝试监听 SSE 事件流终态事件
-        try {
-            for await (const evt of this.events(runId, { signal: internalController.signal })) {
-                if (evt.type === "finish") {
-                    const res = evt.result || evt.data || evt;
-                    if (typeof res?.ok === "boolean") {
-                        return res;
-                    }
-                }
-            }
-        }
-        catch (err) {
-            if (err?.code === TARGET_CLOSED || this.isClosed) {
-                return {
-                    ok: false,
-                    runId,
-                    error: {
-                        code: TARGET_CLOSED,
-                        message: "RemoteActionDockTarget is closed",
-                    },
-                };
-            }
-            if (!signal?.aborted && !sseTimedOut) {
-                // SSE 通道异常视为不可用：记录后按指数退避进入轮询兜底
-                console.warn(`[ActionDock] SSE event stream unavailable for run '${runId}', falling back to polling: ${err?.message || String(err)}`);
-            }
-        }
-        finally {
-            if (timer) {
-                clearTimeout(timer);
-            }
-            if (signal) {
-                signal.removeEventListener("abort", onAbort);
-            }
-        }
-        if (signal?.aborted) {
-            return {
-                ok: false,
-                runId,
-                error: {
-                    code: ACTION_CANCELLED,
-                    message: "Action execution was cancelled",
-                },
-            };
-        }
-        const remainingWaitMs = Math.max(0, maxWaitMs - (Date.now() - startTime));
-        if (remainingWaitMs <= 0) {
-            if (this.isClosed) {
-                return {
-                    ok: false,
-                    runId,
-                    error: {
-                        code: TARGET_CLOSED,
-                        message: "RemoteActionDockTarget is closed",
-                    },
-                };
-            }
-            try {
-                const run = await this.getRun(runId);
-                if (run && isTerminalRunStatus(run.status)) {
-                    return this.formatTerminalRunResult(run, runId);
-                }
-            }
-            catch (err) {
-                if (err?.code === TARGET_CLOSED || this.isClosed) {
-                    return {
-                        ok: false,
-                        runId,
-                        error: {
-                            code: TARGET_CLOSED,
-                            message: "RemoteActionDockTarget is closed",
-                        },
-                    };
-                }
-                throw err;
-            }
-            const waitedMs = Date.now() - startTime;
-            return {
-                ok: false,
-                runId,
-                error: {
-                    code: TIMEOUT,
-                    message: `Timed out waiting for run '${runId}' completion after ${waitedMs}ms`,
-                },
-            };
-        }
-        // 剩余时间继续通过 pollRunCompletion 进行轮询兜底
-        return this.pollRunCompletion(runId, signal, remainingWaitMs, startTime, maxWaitMs);
-    }
-    /**
-     * 指数退避轮询远端运行详情直至终态、取消或超时上限。
-     */
-    async pollRunCompletion(runId, signal, timeoutMs, startTime = Date.now(), totalMaxWaitMs) {
-        return pollRunCompletion({
-            baseTimeoutMs: this.baseTimeoutMs,
-            isClosed: () => this.isClosed,
-            getRun: (id) => this.getRun(id),
-        }, runId, signal, timeoutMs, startTime, totalMaxWaitMs);
-    }
-    formatTerminalRunResult(run, runId) {
-        return formatTerminalRunResult(run, runId);
-    }
-    async listRuns(options) {
-        this.assertNotClosed();
-        try {
-            const res = await fetchRemoteRuns(this.serverUrl, this.token, {
-                packageId: options?.packageId,
-                actionId: options?.actionId,
-                status: options?.status,
-                intent: options?.intent,
-                limit: options?.limit,
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-            return res.items || [];
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-    }
-    async clearRuns(options) {
-        this.assertNotClosed();
-        try {
-            const res = await clearRemoteRuns(this.serverUrl, this.token, {
-                ...options,
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-            return res.clearedCount ?? 0;
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-    }
-    async getRun(runId) {
-        this.assertNotClosed();
-        try {
-            return await fetchRemoteRun(this.serverUrl, runId, this.token, {
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-        }
-        catch (err) {
-            const msg = String(err?.message || "");
-            if (msg.includes("404") || msg.includes("not found") || msg.includes("RUN_NOT_FOUND")) {
-                return undefined;
-            }
-            throw err;
-        }
-    }
-    async cancelRun(runId, reason) {
-        this.assertNotClosed();
-        try {
-            const res = await cancelRemoteRun(this.serverUrl, runId, this.token, reason, {
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-            return { outcome: "requested", runId: res.runId };
-        }
-        catch (err) {
-            const msg = String(err?.message || "");
-            const code = String(err?.code || "");
-            if (code === "RUN_ALREADY_FINISHED" ||
-                msg.includes("already finished") ||
-                msg.includes("RUN_ALREADY_FINISHED")) {
-                let status = err?.errorData?.status || err?.details?.status;
-                if (!status) {
-                    try {
-                        const run = await this.getRun(runId);
-                        if (run?.status) {
-                            status = run.status;
-                        }
-                    }
-                    catch { }
-                }
-                return { outcome: "already_terminal", runId, status: status || "failed" };
-            }
-            if (code === "RUN_NOT_FOUND" ||
-                msg.includes("not found") ||
-                msg.includes("RUN_NOT_FOUND") ||
-                msg.includes("404")) {
-                return { outcome: "not_found", runId };
-            }
-            throw err;
-        }
-    }
-    events(runId, options) {
-        this.assertNotClosed();
-        const self = this;
-        async function* stream() {
-            self.assertNotClosed();
-            for await (const event of streamRemoteEvents(self.serverUrl, runId, self.token, {
-                ...options,
-                allowInsecureHttp: self.allowInsecureHttp,
-                insecure: self.insecure,
-                dispatcher: self.dispatcher,
-            })) {
-                self.assertNotClosed();
-                yield event;
-            }
-        }
-        return stream();
-    }
-    async getConfig(packageId, key) {
-        this.assertNotClosed();
-        try {
-            const list = await this.listConfig(packageId);
-            const found = list.find((c) => c.key === key);
-            if (found) {
-                return found;
-            }
-            return {
-                key,
-                configured: false,
-                secret: false,
-                source: "default",
-                value: undefined,
-            };
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-    }
-    async setConfig(packageId, key, value) {
-        this.assertNotClosed();
-        try {
-            await setRemoteConfig(this.serverUrl, key, value, this.token, packageId || undefined, {
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-    }
-    async deleteConfig(packageId, key) {
-        this.assertNotClosed();
-        try {
-            const res = await deleteRemoteConfig(this.serverUrl, key, this.token, packageId || undefined, {
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-            return Boolean(res?.deleted ?? true);
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-    }
-    async listConfig(packageId) {
-        this.assertNotClosed();
-        try {
-            const res = await fetchRemoteConfig(this.serverUrl, this.token, packageId || undefined, {
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-            if (Array.isArray(res))
-                return res;
-            if (Array.isArray(res?.items))
-                return res.items;
-            if (Array.isArray(res?.config))
-                return res.config;
-            const values = res?.values || {};
-            const declared = res?.declared || {};
-            const defaultSource = packageId === "global" ? "global" : "package";
-            return Object.entries(values).map(([k, v]) => ({
-                key: k,
-                configured: v !== undefined,
-                secret: Boolean(declared[k]?.secret),
-                source: defaultSource,
-                value: v,
-            }));
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-    }
-    async getState(packageId, actionId, key, options) {
-        this.assertNotClosed();
-        try {
-            const res = await getRemoteStateKey(this.serverUrl, key, this.token, {
-                package: packageId || undefined,
-                action: actionId || undefined,
-                namespace: options?.namespace,
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-            if (res === undefined)
-                return undefined;
-            if (options?.detail) {
-                return res;
-            }
-            return (res?.value !== undefined ? res.value : res);
-        }
-        catch (err) {
-            if (isRemoteStateKeyNotFound(err)) {
-                return undefined;
-            }
-            wrapRemoteError(err);
-        }
-    }
-    async setState(packageId, actionId, key, value, options) {
-        this.assertNotClosed();
-        try {
-            await setRemoteStateKey(this.serverUrl, key, value, this.token, {
-                package: packageId || undefined,
-                action: actionId || undefined,
-                namespace: options?.namespace,
-                ttl: options?.ttl,
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-    }
-    async deleteState(packageId, actionId, key, options) {
-        this.assertNotClosed();
-        try {
-            const res = await deleteRemoteStateKey(this.serverUrl, key, this.token, {
-                package: packageId || undefined,
-                action: actionId || undefined,
-                namespace: options?.namespace,
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-            return Boolean(res?.deleted ?? true);
-        }
-        catch (err) {
-            if (isRemoteStateKeyNotFound(err)) {
-                return false;
-            }
-            wrapRemoteError(err);
-        }
-    }
-    async listStateKeys(packageId, actionId, options) {
-        this.assertNotClosed();
-        try {
-            const res = await fetchRemoteStateList(this.serverUrl, this.token, {
-                package: packageId || undefined,
-                action: actionId || undefined,
-                namespace: options?.namespace,
-                prefix: options?.prefix,
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-            return res.keys || [];
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-    }
-    async clearState(packageId, actionId, options) {
-        this.assertNotClosed();
-        try {
-            const res = await clearRemoteState(this.serverUrl, this.token, {
-                package: packageId || undefined,
-                action: actionId || undefined,
-                namespace: options?.namespace,
-                prefix: options?.prefix,
-                all: options?.all,
-                allowInsecureHttp: this.allowInsecureHttp,
-                insecure: this.insecure,
-                dispatcher: this.dispatcher,
-            });
-            return res.clearedCount ?? 0;
-        }
-        catch (err) {
-            wrapRemoteError(err);
-        }
-    }
-    async listStateEntries(packageId, options) {
-        this.assertNotClosed();
-        throw new TargetError(TARGET_CAPABILITY_UNAVAILABLE, "TARGET_CAPABILITY_UNAVAILABLE: listStateEntries is not supported on remote target");
-    }
-    async close(_options) {
-        if (this.isClosed) {
-            return;
-        }
-        this.isClosed = true;
-    }
-}