@actiondock/core 2.0.12 → 2.2.0

package/dist/app/index.js

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

package/dist/app/types.d.ts

@@ -0,0 +1,283 @@
+import type { ActionDefinition, ActionRef, ExecutionEvent, ExecutionResult, JsonValue, Logger, ProcessAPI, RunRecord } from "@actiondock/sdk";
+import type { CancelResult, ExecuteOptions, ExecutionService, ExecutionTicket } from "../execution/types.js";
+import type { ConfigItemDefinition, ProjectConfig } from "../project/types.js";
+import type { Clock } from "../runtime/clock.js";
+import type { EventSink } from "../runtime/events.js";
+import type { RuntimePlatform, StorageFactory, StorageFactoryOptions } from "../platform/types.js";
+import type { RuntimeStorage } from "../storage/types.js";
+import type { ConfigValueView, StateScopeOptions } from "../target/types.js";
+export type { ConfigValueView, RuntimePlatform, StateScopeOptions, StorageFactory, StorageFactoryOptions };
+/**
+ * 宏包信息契约。
+ */
+export interface PackageInfo {
+    /** 包唯一标识 */
+    id: string;
+    /** 包名称 */
+    name: string;
+    /** 包语义化版本号 */
+    version: string;
+    /** 包描述信息 */
+    description?: string;
+    /** 包根目录绝对物理路径 */
+    packageRoot?: string;
+    /** Action 脚本文件目录 */
+    actionsDir?: string;
+    /** Playbook SOP 文档目录 */
+    playbooksDir?: string;
+    /** 声明的项目依赖配置项清单 */
+    config?: Record<string, ConfigItemDefinition>;
+    /** 动作总数统计 */
+    actionsCount?: number;
+    /** 规程总数统计 */
+    playbooksCount?: number;
+    /** 动作标识符列表 */
+    actions?: string[];
+    /** 规程标识符列表 */
+    playbooks?: string[];
+}
+/**
+ * Action 简要摘要条目。
+ */
+export interface ActionSummary {
+    /** Action 唯一标识 */
+    id: string;
+    /** 所属包唯一标识 */
+    packageId?: string;
+    /** Action 描述信息 */
+    description?: string;
+    /** 标签列表 */
+    tags?: string[];
+    /** 入口文件相对路径 */
+    entry?: string;
+    /** 协议注解元数据 */
+    annotations?: Record<string, unknown>;
+    /** 静态依赖的 Action 列表 */
+    uses?: string[];
+    /** 输入模式规范 */
+    inputSchema?: Record<string, unknown> | boolean;
+    /** 输出模式规范 */
+    outputSchema?: Record<string, unknown> | boolean;
+}
+/**
+ * Action 完整规范说明契约。
+ */
+export interface ActionSpec {
+    /** Action 唯一标识 */
+    id: string;
+    /** 所属包唯一标识 */
+    packageId?: string;
+    /** Action 描述信息 */
+    description?: string;
+    /** 输入模式规范 */
+    inputSchema?: Record<string, unknown> | boolean;
+    /** 输出模式规范 */
+    outputSchema?: Record<string, unknown> | boolean;
+    /** 标签列表 */
+    tags?: string[];
+    /** 协议注解元数据 */
+    annotations?: Record<string, unknown>;
+    /** 静态依赖的 Action 列表 */
+    uses?: string[];
+    /** 入口文件相对路径 */
+    entry?: string;
+    /** 入口文件物理绝对路径 */
+    filePath?: string;
+}
+/**
+ * Action 列表检索查询选项。
+ */
+export interface ListActionsOptions {
+    /** 标签筛选过滤列表 */
+    tags?: string[];
+    /** 模糊检索关键词（匹配标识或描述） */
+    query?: string;
+    /** 标识前缀过滤 */
+    prefix?: string;
+}
+/**
+ * Playbook 规程简要摘要条目。
+ */
+export interface PlaybookSummary {
+    /** Playbook 唯一标识 */
+    id: string;
+    /** 所属包唯一标识 */
+    packageId?: string;
+    /** Playbook 描述信息 */
+    description?: string;
+    /** 规程所依赖或调用的 Action 列表 */
+    actions?: string[];
+    /** 物理源文件路径 */
+    filePath?: string;
+}
+/**
+ * Playbook 规程完整规范说明契约。
+ */
+export interface PlaybookSpec {
+    /** Playbook 唯一标识 */
+    id: string;
+    /** 所属包唯一标识 */
+    packageId?: string;
+    /** Playbook 描述信息 */
+    description?: string;
+    /** 规程所依赖或调用的 Action 列表 */
+    actions?: string[];
+    /** Markdown 正文规程操作指南内容 */
+    content: string;
+    /** 物理源文件路径 */
+    filePath?: string;
+}
+/**
+ * 持久化状态读写操作选项。
+ */
+export interface StateOptions {
+    /** 状态隔离命名空间 */
+    namespace?: string;
+    /** 存活有效期（秒），仅在设置状态时生效 */
+    ttl?: number;
+}
+/**
+ * ActionDockApp 初始化配置选项。
+ */
+export interface ActionDockAppOptions {
+    /** 项目根目录绝对物理路径 */
+    packageRoot?: string;
+    /** 项目配置文件 (actiondock.json) 对象 */
+    projectConfig?: ProjectConfig;
+    /** 显式注入的运行时平台适配 */
+    platform?: RuntimePlatform;
+    /** 显式注入的项目级运行时存储实例 */
+    storage?: RuntimeStorage;
+    /** 显式注入的全局运行时存储实例 */
+    globalStorage?: RuntimeStorage;
+    /** 显式注入的事件接收器 */
+    eventSink?: EventSink;
+    /** 数据持久化存储目录 */
+    dataDir?: string;
+    /** 自定义家目录绝对路径 */
+    customHome?: string;
+    /** 是否采用纯内存运行模式 */
+    inMemory?: boolean;
+    /** 显式注入或预注册的 Action 集合 */
+    actions?: Map<string, ActionDefinition> | Array<{
+        id: string;
+        action: ActionDefinition;
+    } | (ActionDefinition & {
+        id: string;
+    })> | Record<string, ActionDefinition>;
+    /** 跨包或动态 Action 解析器 */
+    actionResolver?: (ref: ActionRef | string) => ActionDefinition | undefined | Promise<ActionDefinition | undefined>;
+    /** 跨包运行上下文解析委托函数 */
+    packageContextResolver?: (packageId: string) => Promise<{
+        projectRoot?: string;
+        projectConfig?: ProjectConfig;
+        storage: RuntimeStorage;
+        actions?: Map<string, ActionDefinition>;
+    } | undefined> | {
+        projectRoot?: string;
+        projectConfig?: ProjectConfig;
+        storage: RuntimeStorage;
+        actions?: Map<string, ActionDefinition>;
+    } | undefined;
+    /** 临时配置覆写字典 */
+    configOverrides?: Record<string, unknown>;
+    /** 宿主所有者标识 */
+    ownerId?: string;
+    /** 最大并发活跃运行数 */
+    maxActiveRuns?: number;
+    /** 最大调用嵌套深度 */
+    maxCallDepth?: number;
+    /** 最大子任务数限制 */
+    maxSubRuns?: number;
+    /** 执行宿主会话标识 */
+    hostSessionId?: string;
+    /** 日志记录器 */
+    logger?: Logger;
+    /** 时钟源 */
+    clock?: Clock;
+    /** 进程执行器 */
+    process?: ProcessAPI;
+    /** 是否暴露调试与物理路径信息 */
+    exposeDebugInfo?: boolean;
+}
+/**
+ * ActionDock 统一应用领域契约。
+ * 作为单个 Action Package 的唯一运行单元与对外门面。
+ */
+export interface ActionDockApp {
+    /** 包唯一标识 */
+    readonly packageId: string;
+    /** 包根目录绝对物理路径 */
+    readonly packageRoot?: string;
+    /** 项目配置对象（actiondock.json 解析结果） */
+    readonly projectConfig: ProjectConfig;
+    /** 底层运行平台驱动适配契约 */
+    readonly platform: RuntimePlatform;
+    /** 当前包持久化存储实例 */
+    readonly storage: RuntimeStorage;
+    /** 全局持久化存储实例 */
+    readonly globalStorage?: RuntimeStorage;
+    /** 统一执行协调服务实例 */
+    readonly executionService: ExecutionService;
+    /** 预加载的 Action 定义映射表（短标识至定义） */
+    readonly actionsMap: Map<string, ActionDefinition>;
+    /** 获取当前包元数据信息 */
+    info(options?: {
+        exposeDebugInfo?: boolean;
+    }): Promise<PackageInfo>;
+    /** 静态列出当前包中所有可用的 Action 摘要 */
+    listActions(options?: ListActionsOptions): Promise<ActionSummary[]>;
+    /** 静态查询并返回指定 Action 的规范结构与模式定义 */
+    describeAction(id: string): Promise<ActionSpec>;
+    /** 静态列出当前包中所有可用的 Playbook 摘要 */
+    listPlaybooks(): Promise<PlaybookSummary[]>;
+    /** 静态查询并返回指定 Playbook 的规范内容与操作指南 */
+    describePlaybook(id: string): Promise<PlaybookSpec>;
+    /** 同步执行指定 Action 并等待终态结果（仅接受本包短标识） */
+    runAction(id: string, input: JsonValue, options?: ExecuteOptions): Promise<ExecutionResult>;
+    /** 异步启动指定 Action 并立即返回任务执行票据（仅接受本包短标识） */
+    startAction(id: string, input: JsonValue, options?: ExecuteOptions): Promise<ExecutionTicket>;
+    /** 查询指定运行标识的记录详情 */
+    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>;
+    /** 列出当前包的所有配置安全视图 */
+    listConfig(): Promise<ConfigValueView[]>;
+    /** 获取指定配置项的安全视图（按五层优先级链解析） */
+    getConfig(key: string): Promise<ConfigValueView>;
+    /** 写入持久化配置项 */
+    setConfig(key: string, value: JsonValue): Promise<void>;
+    /** 删除持久化配置项 */
+    deleteConfig(key: string): Promise<boolean>;
+    /** 获取指定持久化状态值 */
+    getState<T extends JsonValue = JsonValue>(key: string, options?: StateScopeOptions): Promise<T | undefined>;
+    getState<T extends JsonValue = JsonValue>(actionId: string, key: string, options?: StateScopeOptions): Promise<T | undefined>;
+    /** 写入指定持久化状态值 */
+    setState<T extends JsonValue = JsonValue>(key: string, value: T, options?: StateScopeOptions): Promise<void>;
+    setState<T extends JsonValue = JsonValue>(actionId: string, key: string, value: T, options: StateScopeOptions): Promise<void>;
+    /** 删除指定持久化状态项 */
+    deleteState(key: string, options?: StateScopeOptions): Promise<boolean>;
+    deleteState(actionId: string, key: string, options?: StateScopeOptions): Promise<boolean>;
+    /** 显式获取指定 Action 命名空间的状态值 */
+    getActionState<T extends JsonValue = JsonValue>(actionId: string, key: string, options?: StateScopeOptions): Promise<T | undefined>;
+    /** 显式写入指定 Action 命名空间的状态值 */
+    setActionState<T extends JsonValue = JsonValue>(actionId: string, key: string, value: T, options?: StateScopeOptions): Promise<void>;
+    /** 显式删除指定 Action 命名空间的状态项 */
+    deleteActionState(actionId: string, key: string, options?: StateScopeOptions): Promise<boolean>;
+    /** 列出所有状态键 */
+    listStateKeys(options?: StateScopeOptions): Promise<string[]>;
+    listStateKeys(actionId: string, options?: StateScopeOptions): Promise<string[]>;
+    /** 清空指定持久化状态项 */
+    clearState(options?: StateScopeOptions): Promise<number>;
+    clearState(actionId: string, options?: StateScopeOptions): Promise<number>;
+    /** 优雅关闭应用并收尾清理所有底层资源 */
+    close(options?: {
+        graceMs?: number;
+    }): Promise<void>;
+}

package/dist/app/types.js

@@ -0,0 +1 @@
+export {};

package/dist/catalog/action-index.d.ts

@@ -1,4 +1,4 @@
-import type { CatalogSnapshot, IndexedAction } from "./types";
+import type { CatalogSnapshot, IndexedAction } from "./types.js";
 export declare class ActionIndex {
     private actions;
     constructor(snapshot: CatalogSnapshot);

package/dist/catalog/action-index.js

@@ -0,0 +1,93 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { loadManifest } from "../project/manifest.js";
+export class ActionIndex {
+    actions = new Map(); // actionId -> IndexedAction[]
+    constructor(snapshot) {
+        this.indexSnapshot(snapshot);
+    }
+    indexSnapshot(snapshot) {
+        for (const [packageId, pkg] of snapshot.packages) {
+            let manifest = null;
+            try {
+                manifest = loadManifest(pkg.projectRoot);
+            }
+            catch {
+                // Skip invalid manifest during catalog indexing
+            }
+            if (manifest && manifest.actions) {
+                for (const [actionId, item] of Object.entries(manifest.actions)) {
+                    const indexed = {
+                        packageId,
+                        actionId,
+                        contract: {
+                            id: actionId,
+                            description: item.description,
+                            inputSchema: item.inputSchema,
+                            outputSchema: item.outputSchema,
+                            uses: item.uses,
+                            tags: item.tags,
+                            annotations: item.annotations,
+                        },
+                        entry: item.entry,
+                        projectRoot: pkg.projectRoot,
+                    };
+                    this.add(indexed);
+                }
+            }
+            else {
+                // 向后兼容回退：若未提供清单，扫描 actions 目录生成基础索引
+                const actionsDir = join(pkg.projectRoot, pkg.config.actionsDir || "actions");
+                if (existsSync(actionsDir)) {
+                    try {
+                        const files = readdirSync(actionsDir);
+                        for (const file of files) {
+                            if (file.endsWith(".ts") || file.endsWith(".js")) {
+                                const actionId = file.replace(/\.(ts|js)$/, "");
+                                const indexed = {
+                                    packageId,
+                                    actionId,
+                                    contract: {
+                                        id: actionId,
+                                    },
+                                    entry: join(pkg.config.actionsDir || "actions", file),
+                                    projectRoot: pkg.projectRoot,
+                                };
+                                this.add(indexed);
+                            }
+                        }
+                    }
+                    catch {
+                        // 忽略读取目录异常
+                    }
+                }
+            }
+        }
+    }
+    add(action) {
+        let list = this.actions.get(action.actionId);
+        if (!list) {
+            list = [];
+            this.actions.set(action.actionId, list);
+        }
+        list.push(action);
+    }
+    list(packageId) {
+        const all = [];
+        for (const [_, list] of this.actions) {
+            for (const action of list) {
+                if (!packageId || action.packageId === packageId) {
+                    all.push(action);
+                }
+            }
+        }
+        return all;
+    }
+    find(actionId, packageId) {
+        const matches = this.actions.get(actionId) || [];
+        if (packageId) {
+            return matches.filter((a) => a.packageId === packageId);
+        }
+        return matches;
+    }
+}

package/dist/catalog/action-resolver.d.ts

@@ -1,6 +1,6 @@
 import type { ActionRef, ResolvedActionRef } from "@actiondock/sdk";
-import { ActionIndex } from "./action-index";
-import type { CatalogSnapshot, IndexedAction } from "./types";
+import { ActionIndex } from "./action-index.js";
+import type { CatalogSnapshot, IndexedAction } from "./types.js";
 export interface ResolveOptions {
     currentPackageId?: string;
 }

package/dist/catalog/action-resolver.js

@@ -0,0 +1,95 @@
+import { ActionIndex } from "./action-index.js";
+export class ActionResolver {
+    snapshot;
+    index;
+    constructor(snapshot, index) {
+        this.snapshot = snapshot;
+        this.index = index || new ActionIndex(snapshot);
+    }
+    /**
+     * 解析字符串或 ActionRef 为规范化的 ActionRef。
+     * 支持 greet、my-tools/greet、@team/github/issues.list。
+     */
+    static parseRef(refStringOrObj) {
+        if (typeof refStringOrObj === "object") {
+            return refStringOrObj;
+        }
+        const str = refStringOrObj.trim();
+        if (str.includes("/")) {
+            const lastSlashIndex = str.lastIndexOf("/");
+            const packageId = str.slice(0, lastSlashIndex);
+            const actionId = str.slice(lastSlashIndex + 1);
+            if (actionId.includes(":") || actionId.includes("/") || actionId.includes("..")) {
+                throw new Error(`Invalid action identifier: '${actionId}'`);
+            }
+            return { packageId, actionId };
+        }
+        // 处理旧语法 package:action 的兼容提醒
+        if (str.includes(":")) {
+            const parts = str.split(":");
+            throw new Error(`Legacy syntax '${str}' is deprecated. Please use '${parts.join("/")}' instead.`);
+        }
+        return { actionId: str };
+    }
+    resolve(refStringOrObj, options = {}) {
+        const ref = ActionResolver.parseRef(refStringOrObj);
+        // 1. 若指定了 packageId，直接精确匹配
+        if (ref.packageId) {
+            const matches = this.index.find(ref.actionId, ref.packageId);
+            if (matches.length === 0) {
+                throw new Error(`ACTION_NOT_FOUND: Action '${ref.actionId}' not found in package '${ref.packageId}'`);
+            }
+            const matched = matches[0];
+            const pkg = this.snapshot.packages.get(matched.packageId);
+            return {
+                resolved: {
+                    packageId: matched.packageId,
+                    packageInstanceId: pkg?.packageInstanceId || matched.packageId,
+                    actionId: matched.actionId,
+                    generationId: this.snapshot.generationId,
+                },
+                action: matched,
+            };
+        }
+        // 2. 未指定 packageId：优先查找当前调用者包
+        if (options.currentPackageId) {
+            const inCurrent = this.index.find(ref.actionId, options.currentPackageId);
+            if (inCurrent.length > 0) {
+                const matched = inCurrent[0];
+                const pkg = this.snapshot.packages.get(matched.packageId);
+                return {
+                    resolved: {
+                        packageId: matched.packageId,
+                        packageInstanceId: pkg?.packageInstanceId || matched.packageId,
+                        actionId: matched.actionId,
+                        generationId: this.snapshot.generationId,
+                    },
+                    action: matched,
+                };
+            }
+        }
+        // 3. 全局唯一匹配检查
+        const allMatches = this.index.find(ref.actionId);
+        if (allMatches.length === 0) {
+            throw new Error(`ACTION_NOT_FOUND: Action '${ref.actionId}' not found in any linked package`);
+        }
+        if (allMatches.length > 1) {
+            const candidates = allMatches.map((m) => `${m.packageId}/${m.actionId}`).join(", ");
+            const err = new Error(`INVALID_ACTION_REF: Action '${ref.actionId}' is ambiguous and provided by multiple packages: ${candidates}. Please specify the package name. (AMBIGUOUS_ACTION_REF)`);
+            err.code = "INVALID_ACTION_REF";
+            err.details = { alias: "AMBIGUOUS_ACTION_REF" };
+            throw err;
+        }
+        const matched = allMatches[0];
+        const pkg = this.snapshot.packages.get(matched.packageId);
+        return {
+            resolved: {
+                packageId: matched.packageId,
+                packageInstanceId: pkg?.packageInstanceId || matched.packageId,
+                actionId: matched.actionId,
+                generationId: this.snapshot.generationId,
+            },
+            action: matched,
+        };
+    }
+}

package/dist/catalog/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./action-index";
-export * from "./action-resolver";
-export * from "./location-registry";
-export * from "./package-catalog";
-export * from "./types";
+export * from "./action-index.js";
+export * from "./action-resolver.js";
+export * from "./location-registry.js";
+export * from "./package-catalog.js";
+export * from "./types.js";

package/dist/catalog/index.js

@@ -0,0 +1,5 @@
+export * from "./action-index.js";
+export * from "./action-resolver.js";
+export * from "./location-registry.js";
+export * from "./package-catalog.js";
+export * from "./types.js";

package/dist/catalog/location-registry.d.ts

@@ -1,15 +1,15 @@
-import type { LocationLink, LocationRegistryData } from "./types";
+import type { LocationLink, LocationRegistryData } from "./types.js";
 export declare class LocationRegistry {
     private customHome?;
     private filePath;
     constructor(customHome?: string);
     getFilePath(): string;
     load(): LocationRegistryData;
-    save(data: LocationRegistryData): void;
+    save(data: LocationRegistryData): Promise<void>;
     addLink(path: string, options?: {
         type?: "package" | "workspace";
         depth?: number;
-    }): LocationLink;
-    removeLink(targetPathOrId: string): LocationLink | null;
-    prune(): LocationLink[];
+    }): Promise<LocationLink>;
+    removeLink(targetPathOrId: string): Promise<LocationLink | null>;
+    prune(): Promise<LocationLink[]>;
 }

package/dist/catalog/location-registry.js

@@ -0,0 +1,138 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { getRegistryFilePath, linkPackage, loadRegistry, loadRegistryAsync, pruneRegistry, unlinkPackage, } from "../registry/registry.js";
+import { withRegistryLock } from "../registry/lock.js";
+import { writeRegistryLocked } from "../registry/registry.js";
+import { loadProjectConfig } from "../project/loader.js";
+import { ACTIONDOCK_VERSION } from "../version.js";
+export class LocationRegistry {
+    customHome;
+    filePath;
+    constructor(customHome) {
+        this.customHome = customHome;
+        this.filePath = getRegistryFilePath(customHome);
+    }
+    getFilePath() {
+        return this.filePath;
+    }
+    load() {
+        const reg = loadRegistry(this.customHome);
+        const links = [];
+        if (reg.workspaces) {
+            for (const [wsPath, ws] of Object.entries(reg.workspaces)) {
+                links.push({
+                    type: "workspace",
+                    path: resolve(ws.path || wsPath),
+                    linkedAt: ws.linkedAt || new Date().toISOString(),
+                    depth: 3,
+                });
+            }
+        }
+        if (reg.packages) {
+            for (const pkg of Object.values(reg.packages)) {
+                if (!pkg.workspaceRoot && pkg.path) {
+                    links.push({
+                        type: "package",
+                        path: resolve(pkg.path),
+                        linkedAt: pkg.linkedAt || new Date().toISOString(),
+                    });
+                }
+            }
+        }
+        return { schemaVersion: 1, links };
+    }
+    async save(data) {
+        // 读改写整体收敛在注册表锁内完成，写入直接走锁内原子落盘，
+        // 避免嵌套调用 saveRegistry 造成的同路径锁重入死等
+        await withRegistryLock(this.filePath, async () => {
+            const current = await loadRegistryAsync(this.customHome);
+            const newPackages = {};
+            const newWorkspaces = {};
+            for (const link of data.links) {
+                const absPath = resolve(link.path);
+                if (link.type === "workspace") {
+                    newWorkspaces[absPath] = {
+                        path: absPath,
+                        linkedAt: link.linkedAt || new Date().toISOString(),
+                    };
+                }
+                else {
+                    const existing = Object.values(current.packages || {}).find((p) => resolve(p.path) === absPath);
+                    if (existing) {
+                        newPackages[existing.id] = existing;
+                    }
+                    else if (existsSync(absPath)) {
+                        try {
+                            const config = loadProjectConfig(absPath);
+                            newPackages[config.id] = {
+                                id: config.id,
+                                name: config.name || config.id,
+                                version: config.version || "0.0.0",
+                                path: absPath,
+                                linkedAt: link.linkedAt || new Date().toISOString(),
+                            };
+                        }
+                        catch {
+                            // 项目损坏或配置非法：跳过该链接条目，避免保存整体失败
+                        }
+                    }
+                }
+            }
+            await writeRegistryLocked({
+                version: ACTIONDOCK_VERSION,
+                packages: newPackages,
+                workspaces: newWorkspaces,
+            }, this.customHome);
+        });
+    }
+    async addLink(path, options = {}) {
+        const type = options.type || "package";
+        if (type === "workspace") {
+            const res = await linkPackage(path, this.customHome, { recursive: true });
+            return {
+                type: "workspace",
+                path: resolve(path),
+                linkedAt: res.linkedAt,
+                depth: options.depth ?? 3,
+            };
+        }
+        else {
+            const res = await linkPackage(path, this.customHome, { recursive: false });
+            return {
+                type: "package",
+                path: resolve(path),
+                linkedAt: res.linkedAt,
+            };
+        }
+    }
+    async removeLink(targetPathOrId) {
+        const unres = await unlinkPackage(targetPathOrId, this.customHome);
+        if (!unres || (!unres.removedPackage && !unres.packagesCount)) {
+            return null;
+        }
+        return {
+            type: unres.type,
+            path: unres.path,
+            linkedAt: new Date().toISOString(),
+        };
+    }
+    async prune() {
+        const pruneRes = await pruneRegistry(this.customHome);
+        const removed = [];
+        for (const pkg of pruneRes.prunedPackages) {
+            removed.push({
+                type: "package",
+                path: pkg.path,
+                linkedAt: pkg.linkedAt,
+            });
+        }
+        for (const ws of pruneRes.prunedWorkspaces) {
+            removed.push({
+                type: "workspace",
+                path: ws.path,
+                linkedAt: ws.linkedAt,
+            });
+        }
+        return removed;
+    }
+}

package/dist/catalog/package-catalog.d.ts

@@ -1,5 +1,5 @@
-import { LocationRegistry } from "./location-registry";
-import type { CatalogSnapshot } from "./types";
+import { LocationRegistry } from "./location-registry.js";
+import type { CatalogSnapshot } from "./types.js";
 export declare class PackageCatalog {
     private registry;
     constructor(registry?: LocationRegistry);