@actiondock/core 2.6.0 → 2.8.0

package/dist/target/local.js

@@ -1,349 +0,0 @@
-import { createGlobalStorage, isSecretConfigKey } from "../storage/index.js";
-import { ACTIONDOCK_PROTOCOL_VERSION, TargetError, CloseTimeoutError, TARGET_CAPABILITY_UNAVAILABLE, } from "./types.js";
-/**
- * 本地 ActionDockTarget 门面实现。
- * 内部包装 ActionDockHost 或 ActionDockApp，将统一调用直接转交给 Host 或 App。
- */
-export class LocalActionDockTarget {
-    target;
-    constructor(target) {
-        this.target = target;
-    }
-    unwrap() {
-        return this.target;
-    }
-    async info() {
-        const packages = await this.listPackages();
-        let id = "local-host";
-        let name = "Local Host";
-        if ("listApps" in this.target) {
-            id = this.target.id || "local-host";
-            name = this.target.name || "Local Host";
-        }
-        else {
-            id = this.target.packageId;
-            name = packages[0]?.name || this.target.packageId;
-        }
-        return {
-            id,
-            name,
-            protocolVersion: ACTIONDOCK_PROTOCOL_VERSION,
-            packages,
-            capabilities: [
-                "actions",
-                "playbooks",
-                "runs",
-                "events",
-                "management.config",
-                "management.state",
-            ],
-            idempotencyPolicy: {
-                retentionMs: 86400000,
-                header: "x-request-id",
-            },
-        };
-    }
-    async listPackages() {
-        if ("listApps" in this.target) {
-            const apps = this.target.listApps();
-            return Promise.all(apps.map((app) => app.info()));
-        }
-        else {
-            return [await this.target.info()];
-        }
-    }
-    async listActions(options) {
-        return this.target.listActions(options);
-    }
-    async describeAction(ref) {
-        if ("getApp" in this.target) {
-            return this.target.describeAction(ref);
-        }
-        else {
-            const actionId = typeof ref === "string" ? ref : ref.actionId;
-            return this.target.describeAction(actionId);
-        }
-    }
-    async listPlaybooks() {
-        return this.target.listPlaybooks();
-    }
-    async describePlaybook(id) {
-        return this.target.describePlaybook(id);
-    }
-    async runAction(ref, input, options) {
-        if ("listApps" in this.target) {
-            return this.target.runAction(ref, input, options);
-        }
-        const actionId = typeof ref === "string" ? (ref.includes(":") ? ref.split(":").pop() : ref) : ref.actionId;
-        return this.target.runAction(actionId, input, options);
-    }
-    async startAction(ref, input, options) {
-        if ("listApps" in this.target) {
-            return this.target.startAction(ref, input, options);
-        }
-        const actionId = typeof ref === "string" ? (ref.includes(":") ? ref.split(":").pop() : ref) : ref.actionId;
-        return this.target.startAction(actionId, input, options);
-    }
-    async listRuns(options) {
-        if ("listApps" in this.target) {
-            const apps = options?.packageId
-                ? [this.target.getApp(options.packageId)].filter(Boolean)
-                : this.target.listApps();
-            const records = [];
-            for (const app of apps) {
-                // 状态过滤下推到存储层 SQL，避免先分页后过滤导致某包前 N 条非目标状态时贡献 0 条
-                const recs = app.storage.listRuns({
-                    actionId: options?.actionId,
-                    status: options?.status,
-                    limit: options?.limit,
-                });
-                for (const r of recs) {
-                    records.push({
-                        ...r,
-                        packageId: r.packageId || app.packageId,
-                    });
-                }
-            }
-            records.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
-            // 全局 limit 语义：合并后总条数不超过 limit，单处截断
-            if (options?.limit && records.length > options.limit) {
-                records.length = options.limit;
-            }
-            return records;
-        }
-        else {
-            if (options?.packageId && options.packageId !== this.target.packageId) {
-                return [];
-            }
-            // 状态过滤下推到存储层 SQL，单包场景由数据库直接返回目标状态记录
-            return this.target.storage.listRuns({
-                actionId: options?.actionId,
-                status: options?.status,
-                limit: options?.limit,
-            });
-        }
-    }
-    async clearRuns(options) {
-        if ("listApps" in this.target) {
-            const apps = options?.packageId
-                ? [this.target.getApp(options.packageId)].filter(Boolean)
-                : this.target.listApps();
-            let total = 0;
-            for (const app of apps) {
-                total += app.storage.clearRuns({
-                    actionId: options?.actionId,
-                    status: options?.status,
-                });
-            }
-            return total;
-        }
-        else {
-            if (options?.packageId && options.packageId !== this.target.packageId) {
-                return 0;
-            }
-            return this.target.storage.clearRuns({
-                actionId: options?.actionId,
-                status: options?.status,
-            });
-        }
-    }
-    async getRun(runId) {
-        return this.target.getRun(runId);
-    }
-    async cancelRun(runId, reason) {
-        return this.target.cancelRun(runId, reason);
-    }
-    events(runId, options) {
-        return this.target.events(runId, options);
-    }
-    resolveApp(packageId) {
-        if ("listApps" in this.target) {
-            if (packageId) {
-                return this.target.getApp(packageId);
-            }
-            const apps = this.target.listApps();
-            return apps.length === 1 ? apps[0] : undefined;
-        }
-        else {
-            if (!packageId || packageId === this.target.packageId) {
-                return this.target;
-            }
-            return undefined;
-        }
-    }
-    fallbackGlobalStorage;
-    getGlobalStorage() {
-        if ("globalStorage" in this.target && this.target.globalStorage) {
-            return this.target.globalStorage;
-        }
-        const apps = "listApps" in this.target ? this.target.listApps() : [];
-        for (const app of apps) {
-            if (app.globalStorage)
-                return app.globalStorage;
-        }
-        if (!this.fallbackGlobalStorage) {
-            this.fallbackGlobalStorage = createGlobalStorage({
-                dataDir: this.target.options?.dataDir,
-                customHome: this.target.options?.customHome,
-            });
-        }
-        return this.fallbackGlobalStorage;
-    }
-    findDeclaredConfigItem(key) {
-        if ("listApps" in this.target) {
-            let foundItem;
-            for (const app of this.target.listApps()) {
-                const item = app.projectConfig?.config?.[key];
-                if (item) {
-                    if (item.secret)
-                        return item;
-                    foundItem = item;
-                }
-            }
-            return foundItem;
-        }
-        else if ("projectConfig" in this.target) {
-            return this.target.projectConfig?.config?.[key];
-        }
-        return undefined;
-    }
-    async getConfig(packageId, key) {
-        if (packageId === "global") {
-            const globalStorage = this.getGlobalStorage();
-            const val = globalStorage.getConfig(key);
-            const configured = val !== undefined;
-            const declaredItem = this.findDeclaredConfigItem(key);
-            const isSecret = isSecretConfigKey(key, declaredItem);
-            return {
-                key,
-                configured,
-                secret: isSecret,
-                source: configured ? "global" : "default",
-                value: !isSecret && configured ? val : undefined,
-            };
-        }
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new Error(`Package '${packageId}' not found in target`);
-        }
-        return app.getConfig(key);
-    }
-    async setConfig(packageId, key, value) {
-        if (packageId === "global") {
-            await this.getGlobalStorage().setConfig(key, value);
-            return;
-        }
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new Error(`Package '${packageId}' not found in target`);
-        }
-        await app.setConfig(key, value);
-    }
-    async deleteConfig(packageId, key) {
-        if (packageId === "global") {
-            return await this.getGlobalStorage().deleteConfig(key);
-        }
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new Error(`Package '${packageId}' not found in target`);
-        }
-        return await app.deleteConfig(key);
-    }
-    async listConfig(packageId) {
-        if (packageId === "global") {
-            const globalStorage = this.getGlobalStorage();
-            const all = globalStorage.listConfig();
-            return Object.entries(all).map(([key, val]) => {
-                const declaredItem = this.findDeclaredConfigItem(key);
-                const isSecret = isSecretConfigKey(key, declaredItem);
-                return {
-                    key,
-                    configured: true,
-                    secret: isSecret,
-                    source: "global",
-                    value: isSecret ? undefined : val,
-                };
-            });
-        }
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new Error(`Package '${packageId}' not found in target`);
-        }
-        return app.listConfig();
-    }
-    async getState(packageId, actionId, key, options) {
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new Error(`Package '${packageId}' not found in target`);
-        }
-        return app.getState(actionId, key, options);
-    }
-    async setState(packageId, actionId, key, value, options) {
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new Error(`Package '${packageId}' not found in target`);
-        }
-        if (actionId) {
-            await app.setActionState(actionId, key, value, options);
-        }
-        else {
-            await app.setState(key, value, options);
-        }
-    }
-    async deleteState(packageId, actionId, key, options) {
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new Error(`Package '${packageId}' not found in target`);
-        }
-        return app.deleteState(actionId, key, options);
-    }
-    async listStateKeys(packageId, actionId, options) {
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new Error(`Package '${packageId}' not found in target`);
-        }
-        return app.listStateKeys(actionId, options);
-    }
-    async clearState(packageId, actionId, options) {
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new Error(`Package '${packageId}' not found in target`);
-        }
-        return app.clearState(actionId, options);
-    }
-    async listStateEntries(packageId, options) {
-        const app = this.resolveApp(packageId);
-        if (!app) {
-            throw new TargetError(TARGET_CAPABILITY_UNAVAILABLE, `TARGET_CAPABILITY_UNAVAILABLE: Package '${packageId}' not found in target`);
-        }
-        if (!app.storage || typeof app.storage.listStateEntries !== "function") {
-            throw new TargetError(TARGET_CAPABILITY_UNAVAILABLE, `TARGET_CAPABILITY_UNAVAILABLE: listStateEntries is not supported by package '${packageId}' storage`);
-        }
-        return app.storage.listStateEntries(options);
-    }
-    async close(options) {
-        try {
-            this.fallbackGlobalStorage?.close();
-        }
-        catch {
-            // 忽略兜底全局存储关闭异常
-        }
-        this.fallbackGlobalStorage = undefined;
-        if (options?.timeoutMs && options.timeoutMs > 0) {
-            let timer;
-            const timeoutPromise = new Promise((_, reject) => {
-                timer = setTimeout(() => {
-                    reject(new CloseTimeoutError(`Target close operation timed out after ${options.timeoutMs}ms`));
-                }, options.timeoutMs);
-            });
-            try {
-                await Promise.race([this.target.close(), timeoutPromise]);
-            }
-            finally {
-                clearTimeout(timer);
-            }
-            return;
-        }
-        return this.target.close();
-    }
-}

package/dist/target/remote-errors.js

@@ -1,51 +0,0 @@
-/**
- * 远端通信错误翻译层。
- *
- * 职责单一：将 profile/client 传输层抛出的底层异常翻译为统一的
- * TargetError 结构化异常，供 RemoteActionDockTarget 各操作边界复用；
- * 优先读取传输层透传的结构化错误码，无法识别时原样透传。
- */
-import { STATE_KEY_NOT_FOUND } from "../errors.js";
-import { TARGET_CAPABILITY_UNAVAILABLE, TARGET_PROTOCOL_UNSUPPORTED, TARGET_RESULT_UNKNOWN, TargetError, } from "./types.js";
-/**
- * 将远端通信异常包装翻译为统一的 TargetError。
- *
- * 无法识别的异常按防御与透明原则原样抛出，严禁静默吞没。
- */
-export function wrapRemoteError(err) {
-    const msg = String(err?.message || "");
-    const code = err?.code || "";
-    if (code === "CAPABILITY_UNAVAILABLE" ||
-        code === "TARGET_CAPABILITY_UNAVAILABLE" ||
-        msg.includes("CAPABILITY_UNAVAILABLE") ||
-        msg.includes("TARGET_CAPABILITY_UNAVAILABLE") ||
-        msg.includes("Management APIs are not enabled")) {
-        throw new TargetError(TARGET_CAPABILITY_UNAVAILABLE, `TARGET_CAPABILITY_UNAVAILABLE: Management APIs are not enabled on remote target`, { originalMessage: msg });
-    }
-    if (code === "PROTOCOL_UNSUPPORTED" ||
-        code === "TARGET_PROTOCOL_UNSUPPORTED" ||
-        msg.includes("PROTOCOL_UNSUPPORTED") ||
-        msg.includes("TARGET_PROTOCOL_UNSUPPORTED")) {
-        throw new TargetError(TARGET_PROTOCOL_UNSUPPORTED, `TARGET_PROTOCOL_UNSUPPORTED: ${msg}`, { originalMessage: msg });
-    }
-    if (code === "TARGET_RESULT_UNKNOWN" ||
-        code === "RESULT_UNKNOWN" ||
-        msg.includes("TARGET_RESULT_UNKNOWN")) {
-        throw new TargetError(TARGET_RESULT_UNKNOWN, `TARGET_RESULT_UNKNOWN: ${msg}`, { originalMessage: msg });
-    }
-    throw err;
-}
-/**
- * 判定远端状态键访问异常是否为键不存在。
- *
- * 优先读取传输层透传的结构化错误码（fetchRemoteJson 会将响应体 error.code
- * 附加到抛出异常的 code 字段），仅当旧版服务器未透传 code 时回退到
- * HTTP 状态与消息文本兼容嗅探。
- */
-export function isRemoteStateKeyNotFound(err) {
-    if (err?.code === STATE_KEY_NOT_FOUND) {
-        return true;
-    }
-    const msg = String(err?.message || "");
-    return err?.status === 404 || msg.includes("404") || msg.includes("not found");
-}

package/dist/target/remote.d.ts

@@ -1,86 +0,0 @@
-import type { ActionRef, ExecutionEvent, ExecutionResult, JsonValue, RunRecord } from "@actiondock/sdk";
-import type { ActionSpec, ActionSummary, ListActionsOptions, PackageInfo, PlaybookSpec, PlaybookSummary } from "../app/types.js";
-import type { CancelResult, ExecuteOptions, ExecutionTicket } from "../execution/types.js";
-import { type StateEntry } from "../storage/types.js";
-import { type ActionDockTarget, type ConfigValueView, type ListRunsOptions, type RemoteTargetOptions, type StateScopeOptions, type TargetInfo } from "./types.js";
-/**
- * 读取并解析远端 SSE 事件流。
- *
- * 候选路由依次尝试：v2 /events -> v2 /stream -> v1 /stream；
- * 全部候选均不可用（网络异常或非流式响应）时抛出携带各候选 URL 与
- * 失败原因的 REMOTE_STREAM_UNAVAILABLE 聚合错误，严禁以空流伪装正常。
- */
-export declare function streamRemoteEvents(serverUrl: string, runId: string, token?: string, options?: {
-    after?: number | string;
-    signal?: AbortSignal;
-    maxQueueSize?: number;
-    allowInsecureHttp?: boolean;
-    insecure?: boolean;
-    dispatcher?: unknown;
-}): AsyncIterable<ExecutionEvent>;
-/**
- * 远程 ActionDockTarget 门面实现。
- * 内部封装基于 HTTP/SSE 协议与远端 ActionDock 服务端的通信管道。
- */
-export declare class RemoteActionDockTarget implements ActionDockTarget {
-    readonly serverUrl: string;
-    readonly token?: string;
-    readonly timeoutMs?: number;
-    readonly baseTimeoutMs: number;
-    readonly allowInsecureHttp?: boolean;
-    readonly insecure?: boolean;
-    readonly dispatcher?: unknown;
-    private isClosed;
-    constructor(options: RemoteTargetOptions);
-    private assertNotClosed;
-    info(): Promise<TargetInfo>;
-    listPackages(): Promise<PackageInfo[]>;
-    listActions(options?: ListActionsOptions): Promise<ActionSummary[]>;
-    describeAction(ref: ActionRef | string): Promise<ActionSpec>;
-    listPlaybooks(options?: {
-        intent?: string;
-        package?: string;
-    }): Promise<PlaybookSummary[]>;
-    describePlaybook(id: string): Promise<PlaybookSpec>;
-    runAction(ref: ActionRef | string, input: JsonValue, options?: ExecuteOptions): Promise<ExecutionResult>;
-    startAction(ref: ActionRef | string, input: JsonValue, options?: ExecuteOptions): Promise<ExecutionTicket>;
-    /**
-     * 等待远端运行抵达终态：优先监听 SSE 事件流，失败后按指数退避轮询运行详情。
-     *
-     * @param runId 运行标识
-     * @param signal 外部取消信号
-     * @param timeoutMs 运行自身声明的超时（等待上限取该值与默认上限中的较大者）
-     */
-    private waitForRunCompletion;
-    /**
-     * 指数退避轮询远端运行详情直至终态、取消或超时上限。
-     */
-    private pollRunCompletion;
-    private formatTerminalRunResult;
-    listRuns(options?: ListRunsOptions): Promise<RunRecord[]>;
-    clearRuns(options?: {
-        packageId?: string;
-        actionId?: string;
-        status?: string;
-    }): Promise<number>;
-    getRun(runId: string): Promise<RunRecord | undefined>;
-    cancelRun(runId: string, reason?: string): Promise<CancelResult>;
-    events(runId: string, options?: {
-        after?: number | string;
-        signal?: AbortSignal;
-        maxQueueSize?: number;
-    }): AsyncIterable<ExecutionEvent>;
-    getConfig(packageId: string, key: string): Promise<ConfigValueView>;
-    setConfig(packageId: string, key: string, value: JsonValue): Promise<void>;
-    deleteConfig(packageId: string, key: string): Promise<boolean>;
-    listConfig(packageId: string): Promise<ConfigValueView[]>;
-    getState<T extends JsonValue = JsonValue>(packageId: string, actionId: string, key: string, options?: StateScopeOptions): Promise<T | undefined>;
-    setState<T extends JsonValue = JsonValue>(packageId: string, actionId: string, key: string, value: T, options?: StateScopeOptions): Promise<void>;
-    deleteState(packageId: string, actionId: string, key: string, options?: StateScopeOptions): Promise<boolean>;
-    listStateKeys(packageId: string, actionId: string, options?: StateScopeOptions): Promise<string[]>;
-    clearState(packageId: string, actionId: string, options?: StateScopeOptions): Promise<number>;
-    listStateEntries(packageId: string, options?: any): Promise<StateEntry[]>;
-    close(_options?: {
-        timeoutMs?: number;
-    }): Promise<void>;
-}