c0de-agent 0.0.0 → 1.1.0

package/dist/server/server.js

@@ -0,0 +1,269 @@
+// src/server/server.ts
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { connect as tcpConnect } from 'node:net';
+import { join } from 'node:path';
+import { serve } from '@hono/node-server';
+import { WebSocketServer } from 'ws';
+import { BUILTIN_AGENTS, createAgentRegistry } from '../core/agents/index.js';
+import { loadConfig } from '../core/config.js';
+import { decryptSecret } from '../core/secret.js';
+import { createDB, migrateDB } from '../db/index.js';
+import { createRegistry, registerProvider } from '../llm/registry.js';
+import { initPlugins } from '../plugins/index.js';
+import { createDefaultRegistry, createDefaultURLRegistry } from '../tools/index.js';
+import { checkForUpdate, createHandoffServer, createUpdateScheduler, requestHandoff, restoreSessions, } from '../update/index.js';
+import { createAgentManager } from './agent-manager.js';
+import { PTYManager } from './terminal/pty-manager.js';
+import { createApp } from './app.js';
+import { createPermissionStore } from './permission/store.js';
+/** 把 config.providers 注册到新建的 LLM registry（修复此前空 registry 的遗漏）。 */
+function buildRegistryFromConfig(config) {
+    const registry = createRegistry();
+    for (const p of config.providers) {
+        registerProviderFromConfig(registry, p);
+    }
+    return registry;
+}
+function registerProviderFromConfig(registry, p) {
+    // 兼容 config.json 中以 _tag 标识 provider 的格式（name 缺失时回退到 _tag）
+    const name = p.name || p._tag;
+    if (!name || !p.baseURL)
+        return;
+    // baseURL 已含 /v1 时用 /chat/completions，避免 /v1/v1 双重前缀
+    const path = p.baseURL.replace(/\/+$/, '').endsWith('/v1') ? '/chat/completions' : undefined;
+    registerProvider(registry, {
+        name,
+        baseURL: p.baseURL,
+        apiKey: p.apiKey ? decryptSecret(p.apiKey) : p.apiKey,
+        ...(path ? { path } : {}),
+    });
+}
+/**
+ * config 变更后原地同步 registry（清空旧路由 + 重新注册），
+ * 使运行中的 ServerContext 立即生效，无需重启。
+ */
+function syncRegistryFromConfig(registry, config) {
+    registry.routes.clear();
+    registry.roles.clear();
+    for (const p of config.providers) {
+        registerProviderFromConfig(registry, p);
+    }
+}
+/** 解析 PGLite 持久化数据目录：优先 C0DE_DB_DIR，否则 <cwd>/.c0de/pglite。 */
+function resolveDbDir(cwd) {
+    const envDir = process.env.C0DE_DB_DIR;
+    if (envDir && envDir.trim() !== '')
+        return envDir;
+    return join(cwd, '.c0de', 'pglite');
+}
+/**
+ * 围绕已有 DB handle 组装 ServerContext（不建/不关闭 DB）。
+ *
+ * dev 热重载重建复用此函数：PGLite 单写者约束下 DB handle 必须跨重载存活，
+ * 但 ctx 其余资源（agentManager/permissionStore/registries/plugins）全部重建为新实例。
+ * 返回的 dispose 清理 ctx 资源但**不 close db**——db 由调用方持有。
+ */
+async function buildServerContext(db, opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    if (opts.restoreFrom) {
+        const snapshot = JSON.parse(readFileSync(opts.restoreFrom, 'utf8'));
+        await restoreSessions(db, snapshot);
+    }
+    const config = await loadConfig(cwd);
+    const toolRegistry = createDefaultRegistry(config);
+    const llmRegistry = buildRegistryFromConfig(config);
+    const urlRegistry = createDefaultURLRegistry();
+    const { pluginRegistry, hookRunner } = await initPlugins({
+        cwd,
+        config,
+        toolRegistry,
+        llmRegistry,
+    });
+    const ctx = {
+        db,
+        config,
+        toolRegistry,
+        llmRegistry,
+        urlRegistry,
+        hookRunner,
+        pluginRegistry,
+        agentManager: createAgentManager(),
+        permissionStore: createPermissionStore(),
+        permissionMode: config.permission.defaultMode,
+        // Agent 注册表：内置 4 个默认 agent；项目/用户自定义 agent 可在启动后补充加载。
+        agentRegistry: (() => {
+            const reg = createAgentRegistry();
+            for (const def of BUILTIN_AGENTS)
+                reg.register(def);
+            return reg;
+        })(),
+        // spec §18.1 后台版本检查调度器；config.update.enabled 控制是否启动。
+        updateScheduler: createUpdateScheduler({
+            checkFn: opts.checkForUpdateFn ?? checkForUpdate,
+            intervalMs: config.update.intervalMs,
+            initialDelayMs: config.update.initialDelayMs,
+        }),
+        cwd,
+        ptyManager: new PTYManager(),
+    };
+    // spec §18.3 handoff server：旧实例监听随机端口，收到 POST /handoff 时
+    // 序列化当前会话状态 + 优雅关闭，让新实例接管。config.update.enabled=false
+    // 或测试 skipHandoff 时跳过（减少后台资源占用）。
+    let handoffServer;
+    if (config.update.enabled && !opts.skipHandoff) {
+        const createHandoff = opts.createHandoffFn ?? createHandoffServer;
+        handoffServer = await createHandoff(async () => {
+            // 序列化在热更新主链路（performHotUpdate）已完成；handoff 回调只需释放资源。
+            // 这里提前停 scheduler 以避免 close 期间还在跑检查。
+            ctx.updateScheduler.stop();
+        });
+        ctx.handoff = { port: handoffServer.port, server: handoffServer };
+    }
+    return {
+        ctx,
+        dispose: async () => {
+            // dev 重建前调用：中止活跃 run + settle pending permission +
+            // 停 scheduler + 关 handoff。**不 close db**（调用方持有）。
+            ctx.agentManager.dispose();
+            ctx.permissionStore.dispose();
+            ctx.updateScheduler.stop();
+            ctx.ptyManager.dispose();
+            if (handoffServer)
+                await handoffServer.close();
+        },
+    };
+}
+/** dev 专用：创建 + migrate PGLite，跨热重载复用（单写者，只建一次）。 */
+async function createDevDb(cwd) {
+    const dataDir = resolveDbDir(cwd);
+    if (!existsSync(dataDir))
+        mkdirSync(dataDir, { recursive: true });
+    const db = await createDB({ driver: 'pglite', dataDir });
+    // migrateDB 失败必须 close，否则 WASM 实例泄漏锁住 dataDir。
+    try {
+        await migrateDB(db);
+    }
+    catch (err) {
+        await db.close().catch(() => { });
+        throw err;
+    }
+    return db;
+}
+/** 初始化 DB + 配置 + 注册表，返回 ServerContext + 清理函数（dev 与独立后端共用）。 */
+async function bootstrapServerContext(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const ownsDb = !opts.db;
+    // 持久化 PGLite 数据：默认 <cwd>/.c0de/pglite（与 .c0de/cache、.c0de/config.json 同约定），
+    // 可用 C0DE_DB_DIR 覆盖。此前默认 in-memory，进程重启即丢全部会话/消息/调用详情。
+    // 测试注入 opts.db 时跳过（保持 in-memory 隔离）。
+    let db;
+    if (opts.db) {
+        db = opts.db;
+        // 注入 db 仍需 migrate（测试可能注入全新 in-memory db）。
+        // migrateDB 失败时若 ownsDb 才 close（注入的由调用方管）。
+        try {
+            await migrateDB(db);
+        }
+        catch (err) {
+            if (ownsDb)
+                await db.close().catch(() => { });
+            throw err;
+        }
+    }
+    else {
+        db = await createDevDb(cwd);
+    }
+    const { ctx, dispose } = await buildServerContext(db, opts);
+    return {
+        ctx,
+        close: async () => {
+            await dispose();
+            if (ownsDb)
+                await db.close();
+        },
+    };
+}
+/**
+ * 请求旧实例 handoff 后轮询端口释放（spec §18.3）。旧实例收到 /handoff 后
+ * 优雅退出释放端口；新实例轮询 TCP 连接直到被拒（端口已释放）或超时报错。
+ */
+async function requestHandoffWithRetry(port, maxAttempts = 30, delayMs = 100) {
+    try {
+        await requestHandoff(port);
+    }
+    catch {
+        // 旧实例未启 handoff 端点（update 未启用）；直接尝试绑端口。
+        return;
+    }
+    for (let i = 0; i < maxAttempts; i++) {
+        const released = await new Promise((resolve) => {
+            const sock = tcpConnect({ host: '127.0.0.1', port });
+            sock.once('connect', () => {
+                sock.destroy();
+                resolve(false); // 连上 → 旧实例还在
+            });
+            sock.once('error', () => resolve(true)); // 连接拒绝 → 端口已释放
+        });
+        if (released)
+            return;
+        await new Promise((r) => setTimeout(r, delayMs));
+    }
+    throw new Error(`handoff: old instance on port ${port} did not release after ${maxAttempts} attempts`);
+}
+async function startServer(opts = {}) {
+    const port = opts.port ?? 3000;
+    // spec §18.3：新实例从 --handoff-port 拿到旧实例端口，请求优雅退出后绑端口。
+    if (opts.handoffPort && !opts.skipHandoff) {
+        await requestHandoffWithRetry(opts.handoffPort);
+    }
+    const { ctx, close: closeCtx } = await bootstrapServerContext(opts);
+    const app = createApp(ctx);
+    // config.update.enabled 时启动后台调度器。
+    if (ctx.config.update.enabled)
+        ctx.updateScheduler.start();
+    const server = serve({ fetch: app.fetch, port });
+    // WebSocket：终端双向流。Hono v2 无原生 WS，用 ws 包直接挂载到 HTTP server。
+    // 匹配 /api/terminal/:id/ws → ptyManager.attachWebSocket
+    const wss = new WebSocketServer({ noServer: true });
+    const expectedToken = ctx.config.security.authEnabled ? ctx.config.security.token : undefined;
+    server.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url ?? '', `http://${req.headers.host ?? 'localhost'}`);
+        const match = url.pathname.match(/^\/api\/terminal\/([^/]+)\/ws$/);
+        if (!match) {
+            socket.destroy();
+            return;
+        }
+        // 认证：token 通过 query 参数传递（浏览器 WS 无法设置 Authorization header）
+        if (expectedToken) {
+            const token = url.searchParams.get('token');
+            if (token !== expectedToken) {
+                socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+        }
+        const ptyId = match[1];
+        if (!ptyId) {
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            const attached = ctx.ptyManager.attachWebSocket(ptyId, ws);
+            if (!attached) {
+                ws.send(JSON.stringify({ type: 'error', message: 'Terminal not found' }));
+                ws.close(1008, 'Terminal not found');
+            }
+        });
+    });
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        wss.close();
+        server.close();
+        await closeCtx();
+    };
+    return { app, port, close };
+}
+export { bootstrapServerContext, buildRegistryFromConfig, buildServerContext, createDevDb, startServer, syncRegistryFromConfig, };

package/dist/server/terminal/pty-manager.d.ts

@@ -0,0 +1,53 @@
+import type { WebSocket } from 'ws';
+/** PTY 会话信息（返回给前端）。 */
+export interface PTYInfo {
+    id: string;
+    pid: number;
+    title: string;
+    cols: number;
+    rows: number;
+    cwd: string;
+    /** shell 程序路径。 */
+    shell: string;
+}
+export interface CreatePTYOptions {
+    cwd: string;
+    cols?: number;
+    rows?: number;
+    title?: string;
+    /** 覆盖默认 shell；不传则自动检测。 */
+    shell?: string;
+}
+/**
+ * PTY 生命周期管理器。
+ *
+ * 负责 spawn / write / resize / kill 伪终端进程，并将 PTY 输出
+ * 通过 WebSocket 推送到前端。一个 PTY 可同时挂多个 WebSocket
+ * （多标签共享同一终端），任一 WS 断开不影响进程。
+ */
+export declare class PTYManager {
+    private entries;
+    /** 创建新 PTY 会话。 */
+    create(opts: CreatePTYOptions): PTYInfo;
+    /** 向 PTY stdin 写入数据。 */
+    write(id: string, data: string): void;
+    /** 调整 PTY 尺寸。 */
+    resize(id: string, cols: number, rows: number): void;
+    /** 更新 PTY 标题。 */
+    setTitle(id: string, title: string): void;
+    /** 终止 PTY 进程。 */
+    kill(id: string): void;
+    /** 获取 PTY 信息。 */
+    get(id: string): PTYInfo | undefined;
+    /** 列出所有活跃 PTY。 */
+    list(): PTYInfo[];
+    /**
+     * 将 WebSocket 挂载到 PTY，建立双向数据流：
+     * - PTY onData → WS send（终端输出）
+     * - WS onMessage → PTY write（用户输入）
+     * - WS onClose → 摘除连接（PTY 保持存活）
+     */
+    attachWebSocket(id: string, ws: WebSocket): boolean;
+    /** 终止所有 PTY 进程（服务器关闭时调用）。 */
+    dispose(): void;
+}

package/dist/server/terminal/pty-manager.js

@@ -0,0 +1,160 @@
+// src/server/terminal/pty-manager.ts
+import { spawn } from 'node-pty';
+import { randomUUID } from 'node:crypto';
+/** 检测当前平台默认 shell。 */
+function detectShell() {
+    if (process.platform === 'win32') {
+        return process.env.COMSPEC ?? 'cmd.exe';
+    }
+    return process.env.SHELL ?? '/bin/bash';
+}
+const DEFAULT_COLS = 80;
+const DEFAULT_ROWS = 24;
+const MAX_TITLE_LEN = 100;
+function truncateTitle(title) {
+    const clean = title.replace(/[\r\n]/g, ' ').trim();
+    return clean.length > MAX_TITLE_LEN ? `${clean.slice(0, MAX_TITLE_LEN)}…` : clean;
+}
+/**
+ * PTY 生命周期管理器。
+ *
+ * 负责 spawn / write / resize / kill 伪终端进程，并将 PTY 输出
+ * 通过 WebSocket 推送到前端。一个 PTY 可同时挂多个 WebSocket
+ * （多标签共享同一终端），任一 WS 断开不影响进程。
+ */
+export class PTYManager {
+    entries = new Map();
+    /** 创建新 PTY 会话。 */
+    create(opts) {
+        const id = `pty_${randomUUID()}`;
+        const cols = opts.cols ?? DEFAULT_COLS;
+        const rows = opts.rows ?? DEFAULT_ROWS;
+        const shell = opts.shell ?? detectShell();
+        const pty = spawn(shell, [], {
+            name: 'xterm-256color',
+            cols,
+            rows,
+            cwd: opts.cwd,
+            env: {
+                ...process.env,
+                TERM: 'xterm-256color',
+                COLORTERM: 'truecolor',
+            },
+        });
+        const info = {
+            id,
+            pid: pty.pid,
+            title: truncateTitle(opts.title ?? shell),
+            cols,
+            rows,
+            cwd: opts.cwd,
+            shell,
+        };
+        const entry = { pty, info, sockets: new Set() };
+        // PTY 输出 → 广播到所有挂载的 WebSocket
+        pty.onData((data) => {
+            for (const ws of entry.sockets) {
+                if (ws.readyState === ws.OPEN) {
+                    ws.send(data);
+                }
+            }
+        });
+        // PTY 退出 → 通知所有 WS 并清理
+        pty.onExit(({ exitCode }) => {
+            for (const ws of entry.sockets) {
+                if (ws.readyState === ws.OPEN) {
+                    ws.send(JSON.stringify({ type: 'exit', exitCode }));
+                    ws.close(1000, 'pty exited');
+                }
+            }
+            this.entries.delete(id);
+        });
+        this.entries.set(id, entry);
+        return info;
+    }
+    /** 向 PTY stdin 写入数据。 */
+    write(id, data) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            throw new Error(`PTY not found: ${id}`);
+        entry.pty.write(data);
+    }
+    /** 调整 PTY 尺寸。 */
+    resize(id, cols, rows) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            throw new Error(`PTY not found: ${id}`);
+        entry.pty.resize(Math.max(1, cols), Math.max(1, rows));
+        entry.info.cols = cols;
+        entry.info.rows = rows;
+    }
+    /** 更新 PTY 标题。 */
+    setTitle(id, title) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            throw new Error(`PTY not found: ${id}`);
+        entry.info.title = truncateTitle(title);
+    }
+    /** 终止 PTY 进程。 */
+    kill(id) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            return;
+        // 通知所有 WS
+        for (const ws of entry.sockets) {
+            if (ws.readyState === ws.OPEN) {
+                ws.send(JSON.stringify({ type: 'exit', exitCode: 0 }));
+                ws.close(1000, 'pty killed');
+            }
+        }
+        try {
+            entry.pty.kill();
+        }
+        catch {
+            // 进程可能已退出
+        }
+        this.entries.delete(id);
+    }
+    /** 获取 PTY 信息。 */
+    get(id) {
+        return this.entries.get(id)?.info;
+    }
+    /** 列出所有活跃 PTY。 */
+    list() {
+        return [...this.entries.values()].map((e) => ({ ...e.info }));
+    }
+    /**
+     * 将 WebSocket 挂载到 PTY，建立双向数据流：
+     * - PTY onData → WS send（终端输出）
+     * - WS onMessage → PTY write（用户输入）
+     * - WS onClose → 摘除连接（PTY 保持存活）
+     */
+    attachWebSocket(id, ws) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            return false;
+        entry.sockets.add(ws);
+        ws.on('message', (data) => {
+            const text = typeof data === 'string' ? data : data.toString('utf8');
+            try {
+                entry.pty.write(text);
+            }
+            catch {
+                // PTY 可能已退出
+            }
+        });
+        ws.on('close', () => {
+            entry.sockets.delete(ws);
+        });
+        ws.on('error', () => {
+            entry.sockets.delete(ws);
+        });
+        return true;
+    }
+    /** 终止所有 PTY 进程（服务器关闭时调用）。 */
+    dispose() {
+        for (const id of this.entries.keys()) {
+            this.kill(id);
+        }
+    }
+}

package/dist/server/types.d.ts

@@ -0,0 +1,76 @@
+import type { AgentRegistry } from '../core/agents/types.js';
+import type { Config } from '../core/config.js';
+import type { DB } from '../db/client.js';
+import type { chatStream as chatStreamFn } from '../llm/provider.js';
+import type { Registry } from '../llm/registry.js';
+import type { HookRunner, PluginRegistry } from '../plugins/types.js';
+import type { Config as SharedConfig } from '../shared/types/config.js';
+import type { URLRegistry } from '../shared/types/tool.js';
+import type { ToolRegistry } from '../tools/types.js';
+import type { HandoffServer, UpdateScheduler } from '../update/index.js';
+import type { PTYManager } from './terminal/pty-manager.js';
+import type { AgentManager } from './agent-manager.js';
+import type { PermissionStore } from './permission/store.js';
+/** 持有所有服务依赖的不可变上下文（config 字段可变用于 PATCH 更新）。 */
+type ServerContext = {
+    db: DB;
+    config: Config;
+    toolRegistry: ToolRegistry;
+    llmRegistry: Registry;
+    /** 内置 URL 解析器注册表（file://, skill://）；注入 agent loop 的 ToolContext。 */
+    urlRegistry: URLRegistry;
+    /** 插件 hook runner；接入 agent loop 的 tool/provider/message hook。 */
+    hookRunner: HookRunner;
+    /** 插件注册表（builtin + 已加载外部插件）；供插件管理 API 查询。 */
+    pluginRegistry: PluginRegistry;
+    agentManager: AgentManager;
+    /** 全局权限确认 store（单例），独立于 agent run 生命周期。 */
+    permissionStore: PermissionStore;
+    /** 全局授权模式（运行时可临时切换）：'default' 逐个确认；'auto' 自动放行 ask 工具（YOLO）。启动时取 config.permission.defaultMode，PUT /api/permissions 临时切换不回写 config。 */
+    permissionMode: 'default' | 'auto';
+    /** Agent 类型注册表（spec: multi-agent-design）。注入 agent loop 的 runSubAgent。 */
+    agentRegistry: AgentRegistry;
+    /** 后台版本检查调度器（spec §18.1）；/api/update 读取其缓存结果。 */
+    updateScheduler: UpdateScheduler;
+    /** Handoff HTTP 端点（spec §18.3）；热更新时新实例 POST /handoff 触发优雅退出。 undefined 表示未启用。 */
+    handoff?: {
+        port: number;
+        server: HandoffServer;
+    };
+    cwd: string;
+    /** 终端 PTY 管理器（Web 终端面板用）。 */
+    ptyManager: PTYManager;
+    /** 测试注入：覆盖 LLM chat stream。生产环境为 undefined。 */
+    chatStream?: typeof chatStreamFn;
+};
+/** POST /api/chat 请求体。 */
+type ChatRequest = {
+    sessionId: string;
+    message: string;
+    provider?: string;
+    model?: string;
+    tools?: string[];
+};
+/** Agent 控制请求（abort/pause/resume）。 */
+type ControlRequest = {
+    sessionId: string;
+};
+/** POST /api/chat/steer 请求体。 */
+type SteerRequest = {
+    sessionId: string;
+    message: string;
+};
+/** POST /api/tools/confirm 请求体。 */
+type ConfirmRequest = {
+    toolCallId: string;
+    approved: boolean;
+};
+/** 统一错误响应体。 */
+type APIErrorBody = {
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+};
+export type { APIErrorBody, ChatRequest, Config, ConfirmRequest, ControlRequest, HandoffServer, ServerContext, SharedConfig, SteerRequest, };

package/dist/server/types.js

@@ -0,0 +1,2 @@
+// src/server/types.ts
+export {};

package/dist/server/util/safe-path.d.ts

@@ -0,0 +1,7 @@
+/**
+ * safeResolve 已下沉到共享层（src/shared/utils/path.ts），供 tools / server 等
+ * 所有层统一引用，避免 tools 层反向依赖 server 层。
+ *
+ * 本文件仅做 re-export，保持 server 层调用方（chat/files 路由）的对外 API 不变。
+ */
+export { safeResolve } from '../../shared/utils/path.js';

package/dist/server/util/safe-path.js

@@ -0,0 +1,7 @@
+/**
+ * safeResolve 已下沉到共享层（src/shared/utils/path.ts），供 tools / server 等
+ * 所有层统一引用，避免 tools 层反向依赖 server 层。
+ *
+ * 本文件仅做 re-export，保持 server 层调用方（chat/files 路由）的对外 API 不变。
+ */
+export { safeResolve } from '../../shared/utils/path.js';

package/dist/session/archive.d.ts

@@ -0,0 +1,15 @@
+import type { DB } from '../db/client.js';
+import type { ArchiveRef, CompactionArchive, SessionEntry } from './types.js';
+/** Archive original entries before compaction/squash. Returns the archive id. */
+declare function archiveOriginalEntries(handle: DB, sessionId: string, entries: SessionEntry[], archiveType: 'compaction' | 'squash' | 'shake', summary: string, compactionId: string): Promise<string>;
+/** Get an archive by id. Returns null for invalid or non-existent ids. */
+declare function getArchive(handle: DB, id: string): Promise<CompactionArchive | null>;
+/** Get the original entries stored in an archive. */
+declare function getArchiveOriginalEntries(handle: DB, archiveId: string): Promise<SessionEntry[]>;
+/** Search archives by keyword (case-insensitive substring on searchable text). */
+declare function searchArchives(handle: DB, sessionId: string, query: string): Promise<CompactionArchive[]>;
+/** Parse a `@[archive:<id>]` or `@[squash:<n>]` reference from text. Returns null if none. */
+declare function parseArchiveReference(text: string): ArchiveRef | null;
+/** Resolve an archive reference to displayable text. */
+declare function resolveArchiveReference(handle: DB, sessionId: string, ref: ArchiveRef): Promise<string | null>;
+export { archiveOriginalEntries, getArchive, getArchiveOriginalEntries, parseArchiveReference, resolveArchiveReference, searchArchives, };