aws-runtime-bridge 1.9.10 → 1.9.21

package/dist/services/fileSnapshotStore.js

@@ -0,0 +1,500 @@
+/**
+ * 文件快照存储服务
+ *
+ * 借鉴 Claude Code fileHistory 的确定性整文件覆盖方案，替代 git stash 实现稳定快照。
+ * - 快照 = 工作区那一刻所有文件的内容哈希副本 + index.json 映射
+ * - 还原 = "先清后写"整文件覆盖，零冲突，幂等
+ * - 内容哈希去重：相同文件内容跨快照共享一份物理副本
+ */
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+import { createLogger } from "../utils/logger.js";
+const log = createLogger("file-snapshot-store");
+// ── 常量 ──────────────────────────────────────────────────────
+/** 快照根目录，可通过环境变量覆盖 */
+function resolveSnapshotRoot() {
+    const envRoot = String(process.env.AWS_RUNTIME_SNAPSHOT_ROOT || "").trim();
+    if (envRoot)
+        return envRoot;
+    return path.join(homedir(), ".agentswork", "snapshots");
+}
+/** 快照操作超时（毫秒），默认 120s */
+function resolveSnapshotTimeoutMs() {
+    const configured = Number(process.env.AWS_RUNTIME_SNAPSHOT_TIMEOUT_MS);
+    if (Number.isFinite(configured) && configured >= 5_000)
+        return configured;
+    return 120_000;
+}
+/** 快照时排除的目录/文件名（精确匹配首层或任意层级） */
+const EXCLUDED_NAMES = new Set([
+    ".git",
+    "node_modules",
+    ".agentswork-snapshots",
+    "__pycache__",
+    ".cache",
+    ".next",
+    "target",
+    "dist",
+    ".idea",
+    ".vscode",
+]);
+/** 单文件最大备份大小（默认 50MB），超过则跳过 */
+const MAX_FILE_SIZE = Number(process.env.AWS_RUNTIME_SNAPSHOT_MAX_FILE_SIZE || 50 * 1024 * 1024);
+/** 单快照最大文件数（防止超大工作区耗尽磁盘） */
+const MAX_FILE_COUNT = Number(process.env.AWS_RUNTIME_SNAPSHOT_MAX_FILES || 50_000);
+// ── 工具函数 ──────────────────────────────────────────────────
+function sha256Short(data) {
+    return createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+function workspaceHash(workspacePath) {
+    return sha256Short(path.resolve(workspacePath));
+}
+function snapshotDirFor(snapshotRoot, wsHash, snapshotId) {
+    return path.join(snapshotRoot, wsHash, snapshotId);
+}
+/**
+ * 判断路径是否应被排除。
+ * 主流程：遍历路径段，命中 EXCLUDED_NAMES 则排除。
+ */
+function isExcludedPath(relPath) {
+    const parts = relPath.split(path.sep);
+    return parts.some((segment) => EXCLUDED_NAMES.has(segment));
+}
+/**
+ * 递归遍历工作区，收集所有普通文件的相对路径。
+ * 遵守排除规则，不递归排除目录。
+ */
+async function collectWorkspaceFiles(dirPath, basePath, result, fileCountLimit) {
+    let entries;
+    try {
+        entries = await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT" || err.code === "EACCES")
+            return;
+        throw error;
+    }
+    for (const entry of entries) {
+        if (result.length >= fileCountLimit) {
+            log.warn(`[FileSnapshot] 文件数已达上限 ${fileCountLimit}，停止遍历`);
+            return;
+        }
+        if (EXCLUDED_NAMES.has(entry.name))
+            continue;
+        const fullPath = path.join(dirPath, entry.name);
+        const relPath = path.relative(basePath, fullPath);
+        if (entry.isDirectory()) {
+            await collectWorkspaceFiles(fullPath, basePath, result, fileCountLimit);
+        }
+        else if (entry.isFile()) {
+            result.push(relPath);
+        }
+        // 忽略符号链接和其他特殊文件
+    }
+}
+/**
+ * 安全删除文件，忽略 ENOENT
+ */
+async function safeUnlink(filePath) {
+    try {
+        await fs.unlink(filePath);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT")
+            throw error;
+    }
+}
+/**
+ * 递归删除空目录
+ */
+async function removeEmptyDirs(dirPath, basePath) {
+    if (dirPath === basePath)
+        return;
+    try {
+        const entries = await fs.readdir(dirPath);
+        if (entries.length === 0) {
+            await fs.rmdir(dirPath);
+            // 尝试递归清理父目录
+            await removeEmptyDirs(path.dirname(dirPath), basePath);
+        }
+    }
+    catch {
+        // 忽略
+    }
+}
+// ── 核心 API ──────────────────────────────────────────────────
+/**
+ * 创建工作区文件快照。
+ *
+ * 算法（借鉴 Claude Code fileHistoryMakeSnapshot）：
+ * 1. 遍历工作区收集所有文件
+ * 2. 对每个文件计算内容哈希，拷贝到快照目录（去重）
+ * 3. 写入 index.json 和 meta.json
+ */
+export async function createSnapshot(params) {
+    const startTime = Date.now();
+    const snapshotRoot = resolveSnapshotRoot();
+    const normalizedPath = path.resolve(String(params.workspacePath).trim());
+    const wsHash = workspaceHash(normalizedPath);
+    // 验证工作区存在
+    try {
+        const stat = await fs.stat(normalizedPath);
+        if (!stat.isDirectory()) {
+            return { ok: false, snapshotId: "", snapshotKey: "", fileCount: 0, totalBytes: 0, workspaceHash: wsHash, error: "workspace path is not a directory" };
+        }
+    }
+    catch {
+        return { ok: false, snapshotId: "", snapshotKey: "", fileCount: 0, totalBytes: 0, workspaceHash: wsHash, error: "workspace path does not exist" };
+    }
+    const snapshotId = params.snapshotId?.trim() || crypto.randomUUID();
+    const snapshotName = params.snapshotName?.trim() || `snapshot-${new Date().toISOString()}`;
+    const triggerType = params.triggerType?.trim() || "MANUAL";
+    const snapshotKey = `${wsHash}/${snapshotId}`;
+    const snapshotDir = snapshotDirFor(snapshotRoot, wsHash, snapshotId);
+    const filesDir = path.join(snapshotDir, "files");
+    try {
+        // 创建目录
+        await fs.mkdir(filesDir, { recursive: true });
+        // 收集工作区文件
+        const files = [];
+        await collectWorkspaceFiles(normalizedPath, normalizedPath, files, MAX_FILE_COUNT);
+        const index = {};
+        let totalBytes = 0;
+        let fileCount = 0;
+        // 超时保护
+        const timeoutMs = resolveSnapshotTimeoutMs();
+        const deadline = Date.now() + timeoutMs;
+        for (const relPath of files) {
+            if (Date.now() > deadline) {
+                log.warn(`[FileSnapshot] 快照超时 ${timeoutMs}ms，已备份 ${fileCount}/${files.length} 个文件`);
+                break;
+            }
+            const fullPath = path.join(normalizedPath, relPath);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (!stat.isFile())
+                    continue;
+                if (stat.size > MAX_FILE_SIZE) {
+                    log.warn(`[FileSnapshot] 跳过大文件: ${relPath} (${(stat.size / 1024 / 1024).toFixed(1)}MB)`);
+                    continue;
+                }
+                const content = await fs.readFile(fullPath);
+                const contentHash = sha256Short(content);
+                const backupPath = path.join(filesDir, contentHash);
+                // 内容去重：只在物理文件不存在时拷贝
+                try {
+                    await fs.access(backupPath);
+                }
+                catch {
+                    await fs.writeFile(backupPath, content);
+                }
+                index[relPath] = {
+                    backupName: contentHash,
+                    size: stat.size,
+                    mtime: stat.mtimeMs,
+                    mode: stat.mode,
+                };
+                totalBytes += stat.size;
+                fileCount++;
+            }
+            catch (error) {
+                const err = error;
+                if (err.code === "ENOENT" || err.code === "EACCES") {
+                    log.warn(`[FileSnapshot] 跳过不可读文件: ${relPath}`);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        // 写入 index.json
+        await fs.writeFile(path.join(snapshotDir, "index.json"), JSON.stringify(index, null, 2));
+        // 写入 meta.json
+        const meta = {
+            snapshotId,
+            workspacePath: normalizedPath,
+            snapshotName,
+            triggerType,
+            createdAt: new Date().toISOString(),
+            fileCount,
+            totalBytes,
+            workspaceHash: wsHash,
+        };
+        await fs.writeFile(path.join(snapshotDir, "meta.json"), JSON.stringify(meta, null, 2));
+        const elapsed = Date.now() - startTime;
+        log.info(`[FileSnapshot] 创建快照完成: ${snapshotKey}, ${fileCount} files, ${(totalBytes / 1024 / 1024).toFixed(1)}MB, ${elapsed}ms`);
+        return { ok: true, snapshotId, snapshotKey, fileCount, totalBytes, workspaceHash: wsHash };
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[FileSnapshot] 创建快照失败: ${err.message}`);
+        // 清理部分写入的目录
+        try {
+            await fs.rm(snapshotDir, { recursive: true, force: true });
+        }
+        catch {
+            // 忽略清理错误
+        }
+        return { ok: false, snapshotId, snapshotKey, fileCount: 0, totalBytes: 0, workspaceHash: wsHash, error: err.message };
+    }
+}
+/**
+ * 还原工作区到快照状态。
+ *
+ * 算法（借鉴 Claude Code applySnapshot）：
+ * 1. 可选：还原前自动创建安全网快照（preRestoreBackup）
+ * 2. 读取目标快照 index.json
+ * 3. 删除工作区中"快照后新增"的文件
+ * 4. 从备份逐文件覆盖，内容相同则跳过
+ */
+export async function restoreSnapshot(params) {
+    const startTime = Date.now();
+    const snapshotRoot = resolveSnapshotRoot();
+    const normalizedPath = path.resolve(String(params.workspacePath).trim());
+    const preRestoreBackup = params.preRestoreBackup !== false; // 默认 true
+    // 解析 snapshotKey
+    const [wsHash, snapshotId] = params.snapshotKey.split("/");
+    if (!wsHash || !snapshotId) {
+        return { ok: false, filesRestored: 0, filesDeleted: 0, filesSkipped: 0, error: "invalid snapshotKey format" };
+    }
+    const snapshotDir = snapshotDirFor(snapshotRoot, wsHash, snapshotId);
+    const indexPath = path.join(snapshotDir, "index.json");
+    // 验证快照存在
+    try {
+        await fs.access(indexPath);
+    }
+    catch {
+        return { ok: false, filesRestored: 0, filesDeleted: 0, filesSkipped: 0, error: `snapshot not found: ${params.snapshotKey}` };
+    }
+    try {
+        // 安全网：还原前自动快照
+        let preRestoreSnapshotKey;
+        if (preRestoreBackup) {
+            try {
+                const guardResult = await createSnapshot({
+                    workspacePath: normalizedPath,
+                    snapshotName: `pre-restore-guard-${snapshotId}`,
+                    triggerType: "AUTO_RESTORE_GUARD",
+                });
+                if (guardResult.ok) {
+                    preRestoreSnapshotKey = guardResult.snapshotKey;
+                    log.info(`[FileSnapshot] 还原前安全网快照: ${preRestoreSnapshotKey}`);
+                }
+                else {
+                    log.warn(`[FileSnapshot] 还原前安全网快照失败: ${guardResult.error}`);
+                    // 不阻断还原
+                }
+            }
+            catch (error) {
+                log.warn(`[FileSnapshot] 还原前安全网快照异常: ${error.message}`);
+            }
+        }
+        // 读取 index
+        const indexRaw = await fs.readFile(indexPath, "utf-8");
+        const targetIndex = JSON.parse(indexRaw);
+        // 确保工作区目录存在
+        await fs.mkdir(normalizedPath, { recursive: true });
+        // 收集当前工作区文件
+        const currentFiles = [];
+        await collectWorkspaceFiles(normalizedPath, normalizedPath, currentFiles, MAX_FILE_COUNT * 2);
+        const targetRelPaths = new Set(Object.keys(targetIndex));
+        let filesDeleted = 0;
+        let filesRestored = 0;
+        let filesSkipped = 0;
+        // 第一步：删除"快照后新增"的文件（存在于当前但不在快照中）
+        for (const relPath of currentFiles) {
+            if (!targetRelPaths.has(relPath)) {
+                const fullPath = path.join(normalizedPath, relPath);
+                await safeUnlink(fullPath);
+                filesDeleted++;
+                // 尝试清理空目录
+                const parentDir = path.dirname(fullPath);
+                if (parentDir !== normalizedPath) {
+                    await removeEmptyDirs(parentDir, normalizedPath);
+                }
+            }
+        }
+        // 第二步：还原目标文件
+        const timeoutMs = resolveSnapshotTimeoutMs();
+        const deadline = Date.now() + timeoutMs;
+        for (const [relPath, entry] of Object.entries(targetIndex)) {
+            if (Date.now() > deadline) {
+                log.warn(`[FileSnapshot] 还原超时 ${timeoutMs}ms，已还原 ${filesRestored} 个文件`);
+                break;
+            }
+            const fullPath = path.join(normalizedPath, relPath);
+            const backupPath = path.join(snapshotDir, "files", entry.backupName);
+            try {
+                // 检查备份文件存在
+                try {
+                    await fs.access(backupPath);
+                }
+                catch {
+                    log.warn(`[FileSnapshot] 备份文件丢失，跳过: ${relPath}`);
+                    filesSkipped++;
+                    continue;
+                }
+                // 优化：当前文件内容哈希相同则跳过
+                try {
+                    const currentContent = await fs.readFile(fullPath);
+                    const currentHash = sha256Short(currentContent);
+                    if (currentHash === entry.backupName) {
+                        filesSkipped++;
+                        continue;
+                    }
+                }
+                catch {
+                    // 文件不存在或不可读，继续还原
+                }
+                // 确保父目录存在
+                await fs.mkdir(path.dirname(fullPath), { recursive: true });
+                // 拷贝备份到工作区
+                await fs.copyFile(backupPath, fullPath);
+                // 恢复权限（Windows 下 chmod 为 no-op）
+                try {
+                    await fs.chmod(fullPath, entry.mode);
+                }
+                catch {
+                    // Windows 或部分文件系统不支持 chmod，忽略
+                }
+                filesRestored++;
+            }
+            catch (error) {
+                log.warn(`[FileSnapshot] 还原文件失败: ${relPath} - ${error.message}`);
+                filesSkipped++;
+            }
+        }
+        const elapsed = Date.now() - startTime;
+        log.info(`[FileSnapshot] 还原完成: ${params.snapshotKey}, restored=${filesRestored}, deleted=${filesDeleted}, skipped=${filesSkipped}, ${elapsed}ms`);
+        return {
+            ok: true,
+            filesRestored,
+            filesDeleted,
+            filesSkipped,
+            preRestoreSnapshotKey,
+        };
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[FileSnapshot] 还原快照失败: ${err.message}`);
+        return { ok: false, filesRestored: 0, filesDeleted: 0, filesSkipped: 0, error: err.message };
+    }
+}
+/**
+ * 列出指定工作区的所有快照
+ */
+export async function listSnapshots(workspacePath) {
+    const snapshotRoot = resolveSnapshotRoot();
+    const normalizedPath = path.resolve(String(workspacePath).trim());
+    const wsHash = workspaceHash(normalizedPath);
+    const wsDir = path.join(snapshotRoot, wsHash);
+    try {
+        await fs.access(wsDir);
+    }
+    catch {
+        return [];
+    }
+    const entries = await fs.readdir(wsDir, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const metaPath = path.join(wsDir, entry.name, "meta.json");
+        try {
+            const metaRaw = await fs.readFile(metaPath, "utf-8");
+            const meta = JSON.parse(metaRaw);
+            results.push({
+                snapshotId: meta.snapshotId,
+                snapshotKey: `${wsHash}/${meta.snapshotId}`,
+                snapshotName: meta.snapshotName,
+                triggerType: meta.triggerType,
+                createdAt: meta.createdAt,
+                fileCount: meta.fileCount,
+                totalBytes: meta.totalBytes,
+            });
+        }
+        catch {
+            // 跳过损坏的快照
+            log.warn(`[FileSnapshot] 跳过损坏快照: ${entry.name}`);
+        }
+    }
+    // 按创建时间倒序
+    results.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return results;
+}
+/**
+ * 删除指定快照
+ */
+export async function deleteSnapshot(snapshotKey) {
+    const snapshotRoot = resolveSnapshotRoot();
+    const [wsHash, snapshotId] = snapshotKey.split("/");
+    if (!wsHash || !snapshotId) {
+        return { ok: false, error: "invalid snapshotKey format" };
+    }
+    const snapshotDir = snapshotDirFor(snapshotRoot, wsHash, snapshotId);
+    try {
+        await fs.access(snapshotDir);
+    }
+    catch {
+        return { ok: false, error: `snapshot not found: ${snapshotKey}` };
+    }
+    try {
+        // 读取 index 获取备份文件列表（引用计数）
+        const indexRaw = await fs.readFile(path.join(snapshotDir, "index.json"), "utf-8");
+        const index = JSON.parse(indexRaw);
+        const backupNames = new Set(Object.values(index).map((e) => e.backupName));
+        // 删除快照目录
+        await fs.rm(snapshotDir, { recursive: true, force: true });
+        // 引用计数：检查同工作区下其他快照是否还引用同一备份文件
+        const wsDir = path.join(snapshotRoot, wsHash);
+        try {
+            const otherSnapshots = await fs.readdir(wsDir, { withFileTypes: true });
+            const referencedHashes = new Set();
+            for (const other of otherSnapshots) {
+                if (!other.isDirectory())
+                    continue;
+                try {
+                    const otherIndexRaw = await fs.readFile(path.join(wsDir, other.name, "index.json"), "utf-8");
+                    const otherIndex = JSON.parse(otherIndexRaw);
+                    for (const entry of Object.values(otherIndex)) {
+                        referencedHashes.add(entry.backupName);
+                    }
+                }
+                catch {
+                    // 忽略损坏的快照
+                }
+            }
+            // 删除不再被引用的备份文件
+            const filesDir = path.join(wsDir, "files");
+            try {
+                for (const backupName of backupNames) {
+                    if (!referencedHashes.has(backupName)) {
+                        await safeUnlink(path.join(filesDir, backupName));
+                    }
+                }
+            }
+            catch {
+                // 忽略清理错误
+            }
+        }
+        catch {
+            // 工作区目录不存在，无需清理
+        }
+        log.info(`[FileSnapshot] 删除快照: ${snapshotKey}`);
+        return { ok: true };
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[FileSnapshot] 删除快照失败: ${err.message}`);
+        return { ok: false, error: err.message };
+    }
+}
+/**
+ * 获取快照根目录（供诊断/调试使用）
+ */
+export function getSnapshotRootPath() {
+    return resolveSnapshotRoot();
+}

package/dist/services/instance-ai-config-service.d.ts

@@ -0,0 +1,49 @@
+/**
+ * AI 配置服务
+ *
+ * 管理 ACode 实例的 AI provider 配置（model/baseURL/apiKey）。
+ * 支持三层来源（api > env > file）仲裁，deep-merge 后写入
+ * per-instance acode.json 供 ACode runtime 加载。
+ */
+export interface AdapterInstanceAiConfig {
+    model?: string;
+    baseURL?: string;
+    apiKey?: string;
+    effort?: string;
+}
+interface PrepareOptions {
+    /** 来自请求体 instanceAiConfig 的覆盖（api > env > file 中的 "api" 层） */
+    apiOverrides?: AdapterInstanceAiConfig;
+    agentId: string;
+    sessionId?: string;
+    runtimeBridgeBaseUrl?: string;
+}
+interface PrepareResult {
+    instanceConfig: {
+        config: AdapterInstanceAiConfig;
+        source: {
+            model: string;
+            baseURL: string;
+            apiKey: string;
+            effort: string;
+        };
+    };
+    perInstanceConfigPath: string;
+}
+/**
+ * 脱敏日志中的敏感字段（apiKey / secret / token / password）。
+ * 返回新对象，不修改原对象。
+ */
+export declare function redactForLog(obj: Record<string, unknown>): Record<string, unknown>;
+/**
+ * 准备 ACode 实例配置。
+ *
+ * 主流程：
+ * 1. 从 apiOverrides（请求体）、env（环境变量）、file（acode.json）三层收集配置
+ * 2. 按 api > env > file 优先级仲裁每个字段
+ * 3. 将仲裁结果 deep-merge 写入 per-instance acode.json
+ * 4. 返回合并后的 config 和 per-instance 文件路径
+ */
+export declare function prepareAcodeInstanceConfig(options: PrepareOptions): Promise<PrepareResult>;
+export {};
+//# sourceMappingURL=instance-ai-config-service.d.ts.map

package/dist/services/instance-ai-config-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-ai-config-service.d.ts","sourceRoot":"","sources":["../../src/services/instance-ai-config-service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAWH,MAAM,WAAW,uBAAuB;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,cAAc;IACtB,8DAA8D;IAC9D,YAAY,CAAC,EAAE,uBAAuB,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,UAAU,aAAa;IACrB,cAAc,EAAE;QACd,MAAM,EAAE,uBAAuB,CAAC;QAChC,MAAM,EAAE;YACN,KAAK,EAAE,MAAM,CAAC;YACd,OAAO,EAAE,MAAM,CAAC;YAChB,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;KACH,CAAC;IACF,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AASD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAelF;AA+CD;;;;;;;;GAQG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,aAAa,CAAC,CAgGxB"}