@actiondock/core 2.0.11 → 2.2.0

package/dist/app/app.js

@@ -0,0 +1,700 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { DefaultExecutionService } from "../execution/service.js";
+import { createDefaultPlatform } from "../platform/index.js";
+import { findProjectRoot, loadPlaybooks, loadProjectConfig } from "../project/loader.js";
+import { loadManifest } from "../project/manifest.js";
+import { RuntimeConfig } from "../runtime/context.js";
+import { normalizeActionCollection } from "../runtime/action-collection.js";
+import { createGlobalStorage, createLazyStorage, createStorage } from "../storage/index.js";
+import { isSecretConfigKey, sanitizeConfigDefinitions } from "../storage/mask.js";
+import { decodeStateKey, SqliteRuntimeStorage } from "../storage/sqlite.js";
+/**
+ * ActionDock 统一应用默认实现。
+ * 封装并管理单个 Action Package 的执行引擎、静态元数据索引、配置与状态存储生命周期。
+ */
+export class DefaultActionDockApp {
+    packageId;
+    packageRoot;
+    projectConfig;
+    platform;
+    storage;
+    globalStorage;
+    executionService;
+    actionsMap;
+    options;
+    runtimeConfig;
+    isClosed = false;
+    constructor(options = {}) {
+        this.options = options;
+        // 1. 确定项目根路径与配置对象
+        let packageRoot = options.packageRoot;
+        let projectConfig = options.projectConfig;
+        if (!packageRoot && !projectConfig) {
+            const detected = findProjectRoot();
+            if (detected) {
+                packageRoot = detected;
+            }
+        }
+        if (!projectConfig && packageRoot) {
+            const configPath = join(packageRoot, "actiondock.json");
+            if (existsSync(configPath)) {
+                try {
+                    projectConfig = loadProjectConfig(packageRoot);
+                }
+                catch {
+                    // 忽略解析失败，使用回退配置
+                }
+            }
+        }
+        if (!projectConfig) {
+            projectConfig = {
+                id: "default",
+                name: "default",
+                version: "0.1.0",
+            };
+        }
+        this.packageRoot = packageRoot;
+        this.projectConfig = projectConfig;
+        this.packageId = projectConfig.id;
+        // 2. 转换 Action 集合：委托归一化单一入口
+        this.actionsMap = normalizeActionCollection(options.actions).actionsMap;
+        // 3. 确定平台适配层
+        this.platform = options.platform ?? createDefaultPlatform();
+        // 4. 确定并初始化存储实例
+        if (options.storage) {
+            this.storage = options.storage;
+        }
+        else {
+            const storageOpts = {
+                projectRoot: this.packageRoot,
+                dataDir: options.dataDir,
+                customHome: options.customHome,
+                inMemory: options.inMemory,
+            };
+            const storageFactory = this.platform.storage;
+            const initStorage = () => {
+                if (typeof storageFactory === "function") {
+                    return storageFactory(this.packageId, storageOpts);
+                }
+                else if (storageFactory && typeof storageFactory.createStorage === "function") {
+                    return storageFactory.createStorage(this.packageId, storageOpts);
+                }
+                else if (storageFactory && typeof storageFactory.create === "function") {
+                    return storageFactory.create(this.packageId, storageOpts);
+                }
+                else {
+                    return createStorage(this.packageId, storageOpts);
+                }
+            };
+            if (options.inMemory) {
+                this.storage = initStorage();
+            }
+            else {
+                this.storage = createLazyStorage(initStorage);
+            }
+        }
+        // 5. 确定全局存储实例
+        if (options.globalStorage) {
+            this.globalStorage = options.globalStorage;
+        }
+        else if (options.inMemory) {
+            this.globalStorage = new SqliteRuntimeStorage({
+                dbPath: ":memory:",
+                packageId: "__global__",
+            });
+        }
+        else {
+            const globalOpts = {
+                customHome: options.customHome,
+                dataDir: options.dataDir,
+                inMemory: options.inMemory,
+            };
+            const storageFactory = this.platform.storage;
+            const initGlobalStorage = () => {
+                if (storageFactory && typeof storageFactory.createGlobalStorage === "function") {
+                    return storageFactory.createGlobalStorage(globalOpts);
+                }
+                return createGlobalStorage(globalOpts);
+            };
+            this.globalStorage = createLazyStorage(initGlobalStorage);
+        }
+        // 6. 初始化唯一执行协调服务
+        this.executionService = new DefaultExecutionService({
+            packageId: this.packageId,
+            hostSessionId: options.hostSessionId,
+            storage: this.storage,
+            globalStorage: this.globalStorage,
+            projectRoot: this.packageRoot,
+            projectConfig: this.projectConfig,
+            configOverrides: options.configOverrides,
+            actions: this.actionsMap,
+            process: options.process ?? this.platform.process,
+            clock: options.clock ?? this.platform.clock,
+            logger: options.logger,
+            eventSink: options.eventSink ?? this.platform?.eventSink,
+            maxActiveRuns: options.maxActiveRuns,
+            maxCallDepth: options.maxCallDepth,
+            maxSubRuns: options.maxSubRuns,
+            ownerId: options.ownerId,
+            actionResolver: options.actionResolver,
+            packageContextResolver: options.packageContextResolver,
+            customHome: options.customHome,
+            platform: this.platform,
+        });
+        // 7. 初始化配置解析器
+        this.runtimeConfig = new RuntimeConfig(this.storage, options.configOverrides, this.projectConfig, this.globalStorage);
+    }
+    /**
+     * 静态读取并聚合当前包的 Action 规范索引。
+     * 不产生全量模块导入与执行副作用。
+     */
+    getStaticActionMap() {
+        const map = new Map();
+        // 1. 读取声明式清单文件 (actiondock.json)
+        if (this.packageRoot) {
+            try {
+                const manifest = loadManifest(this.packageRoot);
+                if (manifest?.actions) {
+                    for (const [id, item] of Object.entries(manifest.actions)) {
+                        map.set(id, {
+                            id,
+                            packageId: this.packageId,
+                            description: item.description,
+                            inputSchema: item.inputSchema,
+                            outputSchema: item.outputSchema,
+                            tags: item.tags ? [...item.tags] : [],
+                            annotations: item.annotations,
+                            uses: item.uses ? [...item.uses] : [],
+                            entry: item.entry,
+                            filePath: item.entry ? resolve(this.packageRoot, item.entry) : undefined,
+                        });
+                    }
+                }
+            }
+            catch {
+                // 忽略清单缺失或解析异常
+            }
+        }
+        // 2. 读取项目配置文件中声明的 actions (Manifest v2 格式)
+        if (this.projectConfig && this.projectConfig.actions) {
+            const rawActions = this.projectConfig.actions;
+            if (typeof rawActions === "object" && rawActions !== null) {
+                for (const [id, item] of Object.entries(rawActions)) {
+                    const existing = map.get(id);
+                    map.set(id, {
+                        id,
+                        packageId: this.packageId,
+                        description: item.description ?? existing?.description,
+                        inputSchema: item.inputSchema ?? existing?.inputSchema,
+                        outputSchema: item.outputSchema ?? existing?.outputSchema,
+                        tags: item.tags ?? existing?.tags,
+                        annotations: item.annotations ?? existing?.annotations,
+                        uses: item.uses ?? existing?.uses,
+                        entry: item.entry ?? existing?.entry,
+                        filePath: item.entry && this.packageRoot
+                            ? resolve(this.packageRoot, item.entry)
+                            : existing?.filePath,
+                    });
+                }
+            }
+        }
+        // 3. 读取内存显式注入的 Action 定义
+        for (const [id, act] of this.actionsMap) {
+            const existing = map.get(id);
+            const actObj = act;
+            map.set(id, {
+                id,
+                packageId: this.packageId,
+                description: actObj.description ?? existing?.description,
+                inputSchema: actObj.inputSchema ?? existing?.inputSchema,
+                outputSchema: actObj.outputSchema ?? existing?.outputSchema,
+                tags: actObj.tags ? [...actObj.tags] : existing?.tags,
+                annotations: actObj.annotations ?? existing?.annotations,
+                uses: actObj.uses ? [...actObj.uses] : existing?.uses,
+                entry: existing?.entry,
+                filePath: existing?.filePath,
+            });
+        }
+        return map;
+    }
+    /**
+     * 静态读取并聚合当前包的 Playbook 规范索引。
+     */
+    getStaticPlaybookMap() {
+        const map = new Map();
+        // 1. 扫描磁盘规程文件
+        if (this.packageRoot) {
+            const playbooksDir = this.projectConfig?.playbooksDir || "playbooks";
+            const dirPath = join(this.packageRoot, playbooksDir);
+            if (existsSync(dirPath)) {
+                try {
+                    const loaded = loadPlaybooks(this.packageRoot, playbooksDir);
+                    for (const [id, def] of loaded) {
+                        map.set(id, {
+                            id: def.id,
+                            packageId: this.packageId,
+                            description: def.description,
+                            actions: def.actions,
+                            content: def.content,
+                            filePath: def.filePath,
+                        });
+                    }
+                }
+                catch {
+                    // 忽略规程加载异常
+                }
+            }
+        }
+        // 2. 读取项目配置文件中的 playbooks
+        if (this.projectConfig && this.projectConfig.playbooks) {
+            const rawPlaybooks = this.projectConfig.playbooks;
+            if (typeof rawPlaybooks === "object" && rawPlaybooks !== null) {
+                for (const [id, item] of Object.entries(rawPlaybooks)) {
+                    const existing = map.get(id);
+                    let content = item.content ?? existing?.content ?? "";
+                    let filePath = item.entry && this.packageRoot
+                        ? resolve(this.packageRoot, item.entry)
+                        : existing?.filePath;
+                    if (!content && filePath && existsSync(filePath)) {
+                        try {
+                            content = readFileSync(filePath, "utf-8");
+                        }
+                        catch {
+                            // 忽略读取异常
+                        }
+                    }
+                    map.set(id, {
+                        id,
+                        packageId: this.packageId,
+                        description: item.description ?? existing?.description,
+                        actions: item.actions ?? existing?.actions,
+                        content,
+                        filePath,
+                    });
+                }
+            }
+        }
+        return map;
+    }
+    async info(options) {
+        const actionsMap = this.getStaticActionMap();
+        const playbooksMap = this.getStaticPlaybookMap();
+        const actions = Array.from(actionsMap.keys());
+        const playbooks = Array.from(playbooksMap.keys());
+        const showPackageRoot = (options?.exposeDebugInfo ?? this.options.exposeDebugInfo) !== false;
+        return {
+            id: this.packageId,
+            name: this.projectConfig.name || this.packageId,
+            version: this.projectConfig.version || "0.1.0",
+            description: this.projectConfig.description,
+            ...(showPackageRoot ? { packageRoot: this.packageRoot } : {}),
+            actionsDir: this.projectConfig.actionsDir,
+            playbooksDir: this.projectConfig.playbooksDir,
+            config: sanitizeConfigDefinitions(this.projectConfig.config),
+            actions,
+            actionsCount: actions.length,
+            playbooks,
+            playbooksCount: playbooks.length,
+        };
+    }
+    async listActions(options) {
+        const map = this.getStaticActionMap();
+        let summaries = Array.from(map.values()).map((spec) => ({
+            id: spec.id,
+            packageId: this.packageId,
+            description: spec.description,
+            tags: spec.tags,
+            entry: spec.entry,
+            annotations: spec.annotations,
+            uses: spec.uses,
+            inputSchema: spec.inputSchema,
+            outputSchema: spec.outputSchema,
+        }));
+        if (options?.tags && options.tags.length > 0) {
+            summaries = summaries.filter((s) => options.tags.every((t) => s.tags?.includes(t)));
+        }
+        if (options?.query) {
+            const q = options.query.toLowerCase();
+            summaries = summaries.filter((s) => s.id.toLowerCase().includes(q) ||
+                (s.description && s.description.toLowerCase().includes(q)));
+        }
+        if (options?.prefix) {
+            summaries = summaries.filter((s) => s.id.startsWith(options.prefix));
+        }
+        return summaries;
+    }
+    async describeAction(id) {
+        const map = this.getStaticActionMap();
+        let spec = map.get(id);
+        if (!spec && id.startsWith(`${this.packageId}/`)) {
+            spec = map.get(id.slice(this.packageId.length + 1));
+        }
+        if (!spec) {
+            for (const [key, value] of map) {
+                if (key === id || `${this.packageId}/${key}` === id) {
+                    spec = value;
+                    break;
+                }
+            }
+        }
+        let liveAction = this.actionsMap.get(id) || (spec ? this.actionsMap.get(spec.id) : undefined);
+        if (!liveAction && this.executionService.getAction) {
+            liveAction =
+                this.executionService.getAction(id) ||
+                    (spec ? this.executionService.getAction(spec.id) : undefined);
+        }
+        if (!liveAction && this.executionService.runner?.resolveAction) {
+            try {
+                // 仅在本包范围内解析动态动作：限定 packageId 前缀，避免全局兜底搜索把
+                // 其他包的动作误计为本包提供者（host 层据此统计候选导致 AMBIGUOUS_ACTION_REF 误报）。
+                const qualifiedId = id.includes("/") ? id : `${this.packageId}/${id}`;
+                const resolution = await this.executionService.runner.resolveAction(qualifiedId);
+                if (resolution.status === "found") {
+                    liveAction = resolution.action;
+                }
+            }
+            catch {
+                // 忽略动态解析异常
+            }
+        }
+        if (liveAction) {
+            const actObj = liveAction;
+            return {
+                id: actObj.id || id,
+                packageId: this.packageId,
+                description: actObj.description ?? spec?.description,
+                inputSchema: actObj.inputSchema ?? spec?.inputSchema,
+                outputSchema: actObj.outputSchema ?? spec?.outputSchema,
+                tags: actObj.tags ? [...actObj.tags] : spec?.tags,
+                annotations: actObj.annotations ?? spec?.annotations,
+                uses: actObj.uses ? [...actObj.uses] : spec?.uses,
+                entry: spec?.entry,
+                filePath: spec?.filePath,
+            };
+        }
+        if (!spec) {
+            throw new Error(`Action '${id}' not found in package '${this.packageId}'`);
+        }
+        return {
+            ...spec,
+            packageId: this.packageId,
+        };
+    }
+    async listPlaybooks() {
+        const map = this.getStaticPlaybookMap();
+        return Array.from(map.values()).map((spec) => ({
+            id: spec.id,
+            packageId: this.packageId,
+            description: spec.description,
+            actions: spec.actions,
+            filePath: spec.filePath,
+        }));
+    }
+    async describePlaybook(id) {
+        const map = this.getStaticPlaybookMap();
+        const cleanId = id.replace(/\.md$/, "");
+        const spec = map.get(cleanId) || map.get(id);
+        if (!spec) {
+            throw new Error(`Playbook '${id}' not found in package '${this.packageId}'`);
+        }
+        return {
+            ...spec,
+            packageId: this.packageId,
+        };
+    }
+    async runAction(id, input, options) {
+        let actionId = id;
+        if (actionId.includes("/")) {
+            if (actionId.startsWith(`${this.packageId}/`)) {
+                actionId = actionId.slice(this.packageId.length + 1);
+            }
+            else {
+                throw new Error(`ActionDockApp only accepts local action short ID '${id}'. Cross-package invocations must be dispatched via Host invoker.`);
+            }
+        }
+        return this.executionService.execute(actionId, input, options);
+    }
+    async startAction(id, input, options) {
+        let actionId = id;
+        if (actionId.includes("/")) {
+            if (actionId.startsWith(`${this.packageId}/`)) {
+                actionId = actionId.slice(this.packageId.length + 1);
+            }
+            else {
+                throw new Error(`ActionDockApp only accepts local action short ID '${id}'. Cross-package invocations must be dispatched via Host invoker.`);
+            }
+        }
+        return this.executionService.start(actionId, input, options);
+    }
+    async getRun(runId) {
+        return this.executionService.get(runId);
+    }
+    async cancelRun(runId, reason) {
+        return this.executionService.cancel(runId, reason);
+    }
+    events(runId, options) {
+        return this.executionService.events(runId, options);
+    }
+    async listConfig() {
+        const declared = this.projectConfig.config || {};
+        const stored = this.storage.listConfig();
+        const allKeys = Array.from(new Set([...Object.keys(declared), ...Object.keys(stored)]));
+        const views = [];
+        for (const key of allKeys) {
+            const item = await this.getConfig(key);
+            if (item) {
+                views.push(item);
+            }
+        }
+        return views;
+    }
+    async getConfig(key) {
+        const itemDef = this.projectConfig.config?.[key];
+        const isSecret = isSecretConfigKey(key, itemDef);
+        // 委托 RuntimeConfig 五层优先级链单一事实源，避免重复实现解析链
+        const resolved = this.runtimeConfig.describe(key);
+        // overrides 来源对外统一星现为包级覆盖视角
+        const source = resolved.source === "overrides" ? "package" : resolved.source;
+        const configured = resolved.source !== "default";
+        return {
+            key,
+            configured,
+            secret: isSecret,
+            source,
+            value: isSecret ? undefined : resolved.value,
+        };
+    }
+    async setConfig(key, value) {
+        await this.storage.setConfig(key, value);
+    }
+    async deleteConfig(key) {
+        return await this.storage.deleteConfig(key);
+    }
+    async getState(actionIdOrKey, keyOrOptions, options) {
+        let actionId;
+        let key;
+        let opts;
+        if (typeof keyOrOptions === "string") {
+            actionId = actionIdOrKey;
+            key = keyOrOptions;
+            opts = options;
+            if (opts?.actionId && opts.actionId !== actionId) {
+                throw new Error(`Conflicting actionId specified: positional '${actionId}' vs options.actionId '${opts.actionId}'`);
+            }
+        }
+        else {
+            actionId = "";
+            key = actionIdOrKey;
+            opts = keyOrOptions;
+        }
+        if (!actionId && opts?.actionId) {
+            actionId = opts.actionId;
+        }
+        const ns = actionId
+            ? (opts?.namespace ? `${actionId}:${opts.namespace}` : actionId)
+            : (opts?.namespace ?? "");
+        if (opts?.detail) {
+            const entry = await this.storage.findState(key, ns || undefined);
+            return entry;
+        }
+        if (actionId) {
+            return await this.storage.getState(ns, key);
+        }
+        if (ns) {
+            return await this.storage.getState(ns, key);
+        }
+        const entry = await this.storage.findState(key);
+        return entry?.value;
+    }
+    async setState(actionIdOrKey, keyOrValue, valueOrOptions, options) {
+        let actionId;
+        let key;
+        let value;
+        let opts;
+        if (arguments.length >= 4) {
+            if (options?.actionId && options.actionId !== actionIdOrKey) {
+                throw new Error(`Conflicting actionId specified: positional '${actionIdOrKey}' vs options.actionId '${options.actionId}'`);
+            }
+            actionId = actionIdOrKey;
+            key = keyOrValue;
+            value = valueOrOptions;
+            opts = options;
+        }
+        else if (arguments.length === 2) {
+            actionId = "";
+            key = actionIdOrKey;
+            value = keyOrValue;
+            opts = undefined;
+        }
+        else {
+            if (valueOrOptions !== undefined &&
+                (typeof valueOrOptions !== "object" || valueOrOptions === null || Array.isArray(valueOrOptions))) {
+                throw new Error("Invalid options provided to setState. Use setActionState(actionId, key, value, options) or 4-argument setState for action state.");
+            }
+            key = actionIdOrKey;
+            value = keyOrValue;
+            opts = valueOrOptions;
+            actionId = opts?.actionId ?? "";
+        }
+        const ns = actionId
+            ? (opts?.namespace ? `${actionId}:${opts.namespace}` : actionId)
+            : (opts?.namespace ?? "");
+        if (ns) {
+            await this.storage.setState(ns, key, value, opts?.ttl);
+            return;
+        }
+        let targetKey = key;
+        let targetNs = "";
+        try {
+            const decoded = decodeStateKey(key);
+            targetNs = decoded.namespace;
+            targetKey = decoded.key;
+        }
+        catch {
+            targetNs = "";
+        }
+        await this.storage.setState(targetNs, targetKey, value, opts?.ttl);
+    }
+    async deleteState(actionIdOrKey, keyOrOptions, options) {
+        let actionId;
+        let key;
+        let opts;
+        if (typeof keyOrOptions === "string") {
+            actionId = actionIdOrKey;
+            key = keyOrOptions;
+            opts = options;
+            if (opts?.actionId && opts.actionId !== actionId) {
+                throw new Error(`Conflicting actionId specified: positional '${actionId}' vs options.actionId '${opts.actionId}'`);
+            }
+        }
+        else {
+            actionId = "";
+            key = actionIdOrKey;
+            opts = keyOrOptions;
+        }
+        if (!actionId && opts?.actionId) {
+            actionId = opts.actionId;
+        }
+        const ns = actionId
+            ? (opts?.namespace ? `${actionId}:${opts.namespace}` : actionId)
+            : (opts?.namespace ?? "");
+        if (ns) {
+            return await this.storage.deleteState(ns, key);
+        }
+        let targetKey = key;
+        let targetNs = "";
+        try {
+            const decoded = decodeStateKey(key);
+            targetNs = decoded.namespace;
+            targetKey = decoded.key;
+        }
+        catch {
+            targetNs = "";
+        }
+        return await this.storage.deleteState(targetNs, targetKey);
+    }
+    async getActionState(actionId, key, options) {
+        if (options?.actionId && options.actionId !== actionId) {
+            throw new Error(`Conflicting actionId specified: positional '${actionId}' vs options.actionId '${options.actionId}'`);
+        }
+        const ns = options?.namespace ? `${actionId}:${options.namespace}` : actionId;
+        if (options?.detail) {
+            const entry = await this.storage.findState(key, ns || undefined);
+            return entry;
+        }
+        return await this.storage.getState(ns, key);
+    }
+    async setActionState(actionId, key, value, options) {
+        if (options?.actionId && options.actionId !== actionId) {
+            throw new Error(`Conflicting actionId specified: positional '${actionId}' vs options.actionId '${options.actionId}'`);
+        }
+        const ns = options?.namespace ? `${actionId}:${options.namespace}` : actionId;
+        await this.storage.setState(ns, key, value, options?.ttl);
+    }
+    async deleteActionState(actionId, key, options) {
+        if (options?.actionId && options.actionId !== actionId) {
+            throw new Error(`Conflicting actionId specified: positional '${actionId}' vs options.actionId '${options.actionId}'`);
+        }
+        const ns = options?.namespace ? `${actionId}:${options.namespace}` : actionId;
+        return await this.storage.deleteState(ns, key);
+    }
+    async listStateKeys(actionIdOrOptions, options) {
+        let actionId;
+        let opts;
+        if (typeof actionIdOrOptions === "string") {
+            actionId = actionIdOrOptions;
+            opts = options;
+            if (opts?.actionId && opts.actionId !== actionId) {
+                throw new Error(`Conflicting actionId specified: positional '${actionId}' vs options.actionId '${opts.actionId}'`);
+            }
+        }
+        else {
+            actionId = "";
+            opts = actionIdOrOptions;
+        }
+        if (!actionId && opts?.actionId) {
+            actionId = opts.actionId;
+        }
+        const ns = actionId
+            ? (opts?.namespace ? `${actionId}:${opts.namespace}` : actionId)
+            : (opts?.namespace ?? null);
+        return this.storage.listStateKeys(ns, opts?.prefix);
+    }
+    async clearState(actionIdOrOptions, options) {
+        let actionId;
+        let opts;
+        if (typeof actionIdOrOptions === "string") {
+            actionId = actionIdOrOptions;
+            opts = options;
+            if (opts?.actionId && opts.actionId !== actionId) {
+                throw new Error(`Conflicting actionId specified: positional '${actionId}' vs options.actionId '${opts.actionId}'`);
+            }
+        }
+        else {
+            actionId = "";
+            opts = actionIdOrOptions;
+        }
+        if (!actionId && opts?.actionId) {
+            actionId = opts.actionId;
+        }
+        const ns = actionId
+            ? (opts?.namespace ? `${actionId}:${opts.namespace}` : actionId)
+            : (opts?.namespace ?? undefined);
+        return this.storage.clearState({
+            namespace: ns,
+            prefix: opts?.prefix,
+            all: opts?.all,
+        });
+    }
+    async close(options) {
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        try {
+            await this.executionService.close(options);
+        }
+        finally {
+            try {
+                this.storage.close();
+            }
+            catch {
+                // 忽略存储重复关闭异常
+            }
+            finally {
+                try {
+                    this.globalStorage?.close();
+                }
+                catch {
+                    // 忽略全局存储关闭异常
+                }
+            }
+        }
+    }
+}
+/**
+ * 工厂函数：创建并初始化 ActionDockApp 实例。
+ */
+export async function createActionDockApp(options = {}) {
+    return new DefaultActionDockApp(options);
+}

package/dist/app/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./app.js";