aws-runtime-bridge 1.0.3 → 1.1.0

package/dist/services/memory-service.js

@@ -1,650 +0,0 @@
-/**
- * 记忆服务
- *
- * 支持三文件存储结构：
- * - todo-memory.json: task_list 类型记忆
- * - hot-memory.json: recently_memory 类型记忆
- * - cold-memory.json: memory 类型记忆（长期记忆）
- *
- * 文件存储在项目根目录下的 vibe-coding/memory/ 目录
- *
- * 权限控制：
- * - 私有记忆（isPublic=false）：仅创建者可读写
- * - 公开记忆（isPublic=true）：小组内所有成员可读取，仅创建者可编辑删除
- */
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { createLogger } from "../utils/logger.js";
-const log = createLogger("memory-service");
-const MEMORY_TYPE_TO_FILE = {
-    task_list: "todo-memory.json",
-    recently_memory: "hot-memory.json",
-    memory: "cold-memory.json",
-};
-const ALL_MEMORY_TYPES = [
-    "task_list",
-    "recently_memory",
-    "memory",
-];
-const LISTABLE_MEMORY_TYPES = ["task_list", "recently_memory"];
-const URI_PATTERN = /^([a-zA-Z_][a-zA-Z0-9_]*):\/\/(.*)$/;
-/**
- * 获取记忆文件路径（异步版本）
- *
- * 记忆文件存储在 vibe-coding/memory/ 目录下（与 my.yml 同级）
- */
-export async function getMemoryFilePath(workspacePath, memoryType) {
-    const vibeCodingDir = await findVibeCodingDir(workspacePath);
-    const memoryDir = path.join(vibeCodingDir, "memory");
-    const fileName = MEMORY_TYPE_TO_FILE[memoryType];
-    return path.join(memoryDir, fileName);
-}
-/**
- * 获取记忆目录路径（异步版本）
- */
-export async function getMemoryDirPath(workspacePath) {
-    const vibeCodingDir = await findVibeCodingDir(workspacePath);
-    return path.join(vibeCodingDir, "memory");
-}
-/**
- * 向上查找 vibe-coding 目录（异步版本）
- */
-async function findVibeCodingDir(startPath) {
-    let currentPath = path.resolve(startPath);
-    // 向上查找，最多查找 10 层
-    for (let i = 0; i < 10; i++) {
-        const vibeCodingPath = path.join(currentPath, "vibe-coding");
-        // 检查是否存在 vibe-coding 目录或 my.yml 文件
-        const myYmlPath = path.join(vibeCodingPath, "my.yml");
-        try {
-            // 如果存在 my.yml，则返回 vibe-coding 目录
-            const stat = await fs.stat(myYmlPath);
-            if (stat.isFile()) {
-                return vibeCodingPath;
-            }
-        }
-        catch {
-            // 文件不存在，继续向上查找
-        }
-        // 检查 vibe-coding 目录是否存在
-        try {
-            const stat = await fs.stat(vibeCodingPath);
-            if (stat.isDirectory()) {
-                return vibeCodingPath;
-            }
-        }
-        catch {
-            // 目录不存在，继续向上查找
-        }
-        // 向上一级
-        const parentPath = path.dirname(currentPath);
-        if (parentPath === currentPath) {
-            // 已经到达根目录，停止查找
-            break;
-        }
-        currentPath = parentPath;
-    }
-    // 未找到 vibe-coding 目录，在 workspacePath 同级创建
-    log.warn(`[MemoryService] 未找到 vibe-coding 目录，将在 ${startPath} 同级创建`);
-    return path.join(path.dirname(startPath), "vibe-coding");
-}
-/**
- * 检查记忆访问权限
- *
- * @param record 记忆记录
- * @param requestorId 请求者 Agent ID
- * @returns 是否有权限访问
- */
-function canAccess(record, requestorId) {
-    // 创建者始终可以访问自己的记忆
-    if (record.creatorId === requestorId) {
-        return true;
-    }
-    // 公开记忆可以被小组内其他成员访问
-    if (record.isPublic) {
-        return true;
-    }
-    // 私有记忆，非创建者无法访问
-    return false;
-}
-/**
- * 检查记忆编辑/删除权限
- *
- * @param record 记忆记录
- * @param requestorId 请求者 Agent ID
- * @returns 是否有权限编辑/删除
- */
-function canModify(record, requestorId) {
-    // 只有创建者可以编辑/删除自己的记忆
-    return record.creatorId === requestorId;
-}
-/**
- * 为公开记忆添加来源信息标注
- *
- * 当读取他人公开记忆时，添加来源信息以便识别
- */
-function annotatePublicMemory(record, requestorId) {
-    const isOwn = record.creatorId === requestorId;
-    if (isOwn) {
-        return { ...record, isOwn: true };
-    }
-    // 格式化时间为更易读的格式（YYYY-MM-DD HH:mm）
-    const createdDate = new Date(record.createdAt);
-    const formattedTime = createdDate.toLocaleString("zh-CN", {
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-        hour: "2-digit",
-        minute: "2-digit",
-    });
-    return {
-        ...record,
-        isOwn: false,
-        source: `由 ${record.creatorName} 创建于 ${formattedTime}`,
-    };
-}
-export class MemoryService {
-    /**
-     * 确保记忆目录存在（已使用异步 API）
-     */
-    async ensureMemoryDir(workspacePath) {
-        const memoryDir = await getMemoryDirPath(workspacePath);
-        await fs.mkdir(memoryDir, { recursive: true });
-        return memoryDir;
-    }
-    /**
-     * 生成当前时间的 ISO 字符串
-     */
-    nowIso() {
-        return new Date().toISOString();
-    }
-    /**
-     * 规范化 URI
-     */
-    normalizeUri(input) {
-        const value = String(input || "").trim();
-        const matched = URI_PATTERN.exec(value);
-        if (!matched) {
-            throw new Error(`Invalid memory uri: ${input}`);
-        }
-        const domainPart = matched[1];
-        const pathPart = matched[2];
-        if (!domainPart || !pathPart) {
-            throw new Error(`Invalid memory uri: ${input}`);
-        }
-        const domain = domainPart.toLowerCase();
-        const normalizedPath = pathPart.replace(/^\/+|\/+$/g, "");
-        if (!normalizedPath) {
-            throw new Error(`Invalid memory uri path: ${input}`);
-        }
-        return {
-            uri: `${domain}://${normalizedPath}`,
-            domain,
-            path: normalizedPath,
-        };
-    }
-    /**
-     * 规范化记忆类型
-     */
-    normalizeMemoryType(input, allowedTypes = ALL_MEMORY_TYPES) {
-        const value = String(input || "").trim();
-        if (!allowedTypes.includes(value)) {
-            throw new Error(`Invalid memory_type: ${input}`);
-        }
-        return value;
-    }
-    /**
-     * 确保类型匹配
-     */
-    ensureTypeMatch(record, expectedType) {
-        if (expectedType && record.memory_type !== expectedType) {
-            throw new Error(`Memory type mismatch: expected ${expectedType}, actual ${record.memory_type}`);
-        }
-    }
-    /**
-     * 生成记忆 ID
-     */
-    generateId(uri) {
-        const cleaned = uri.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-        return `${cleaned}_${Date.now().toString(36)}`;
-    }
-    /**
-     * 加载指定类型的记忆文件（已使用异步 API）
-     */
-    async loadMemoryFile(workspacePath, memoryType) {
-        const filePath = await getMemoryFilePath(workspacePath, memoryType);
-        try {
-            const raw = await fs.readFile(filePath, "utf-8");
-            const parsed = JSON.parse(raw);
-            // 确保 records 数组存在
-            if (!parsed.records || !Array.isArray(parsed.records)) {
-                parsed.records = [];
-            }
-            // 规范化每条记录，补充缺失的创建者信息（兼容旧数据）
-            for (const record of parsed.records) {
-                record.memory_type = this.normalizeMemoryType(record.memory_type || memoryType);
-                // 兼容旧数据：如果没有创建者信息，使用默认值
-                if (!record.creatorId) {
-                    record.creatorId = "unknown";
-                    record.creatorName = "未知创建者";
-                }
-                if (record.isPublic === undefined) {
-                    record.isPublic = false;
-                }
-            }
-            return parsed;
-        }
-        catch (err) {
-            const error = err;
-            if (error?.code === "ENOENT") {
-                // 文件不存在，返回空数据
-                return {
-                    records: [],
-                    updatedAt: this.nowIso(),
-                };
-            }
-            throw err;
-        }
-    }
-    /**
-     * 保存记忆文件（已使用异步 API）
-     */
-    async saveMemoryFile(workspacePath, memoryType, data) {
-        await this.ensureMemoryDir(workspacePath);
-        const filePath = await getMemoryFilePath(workspacePath, memoryType);
-        data.updatedAt = this.nowIso();
-        await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
-        log.info(`[MemoryService] 保存记忆文件: ${filePath}, 记录数: ${data.records.length}`);
-    }
-    /**
-     * 创建记忆
-     */
-    async createMemory(workspacePath, input) {
-        const normalizedType = this.normalizeMemoryType(input.memory_type);
-        const normalized = this.normalizeUri(input.uri);
-        const data = await this.loadMemoryFile(workspacePath, normalizedType);
-        // 检查是否已存在
-        const existing = data.records.find((r) => r.uri === normalized.uri);
-        if (existing) {
-            throw new Error(`Memory already exists: ${normalized.uri}`);
-        }
-        // 验证创建者信息
-        if (!input.creatorId) {
-            throw new Error("creatorId is required");
-        }
-        if (!input.creatorName) {
-            throw new Error("creatorName is required");
-        }
-        const now = this.nowIso();
-        const record = {
-            id: this.generateId(normalized.uri),
-            uri: normalized.uri,
-            domain: normalized.domain,
-            path: normalized.path,
-            content: String(input.content || ""),
-            memory_type: normalizedType,
-            createdAt: now,
-            updatedAt: now,
-            version: 1,
-            creatorId: input.creatorId,
-            creatorName: input.creatorName,
-            isPublic: input.isPublic ?? false, // 默认私有
-        };
-        data.records.push(record);
-        await this.saveMemoryFile(workspacePath, normalizedType, data);
-        const visibility = record.isPublic ? "公开" : "私有";
-        log.info(`[MemoryService] 创建记忆: ${normalized.uri}, 类型: ${normalizedType}, 创建者: ${input.creatorName}, 可见性: ${visibility}`);
-        return record;
-    }
-    /**
-     * 读取记忆（带权限检查）
-     *
-     * 权限规则：
-     * - 自己的记忆：可读取
-     * - 公开的记忆：可读取，但会标注来源信息
-     * - 他人私有记忆：无法读取
-     */
-    async readMemory(workspacePath, input) {
-        const normalized = this.normalizeUri(input.uri);
-        const expectedType = typeof input.memory_type === "string"
-            ? this.normalizeMemoryType(input.memory_type)
-            : undefined;
-        // 如果指定了类型，只从对应文件读取
-        if (expectedType) {
-            const data = await this.loadMemoryFile(workspacePath, expectedType);
-            const record = data.records.find((r) => r.uri === normalized.uri) ?? null;
-            if (record) {
-                this.ensureTypeMatch(record, expectedType);
-                // 权限检查
-                if (!canAccess(record, input.requestorId)) {
-                    log.warn(`[MemoryService] 无权限读取记忆: ${normalized.uri}, 请求者: ${input.requestorId}, 创建者: ${record.creatorId}`);
-                    return null;
-                }
-                return annotatePublicMemory(record, input.requestorId);
-            }
-            return null;
-        }
-        // 未指定类型，依次从三个文件查找
-        for (const memoryType of ALL_MEMORY_TYPES) {
-            const data = await this.loadMemoryFile(workspacePath, memoryType);
-            const record = data.records.find((r) => r.uri === normalized.uri);
-            if (record) {
-                // 权限检查
-                if (!canAccess(record, input.requestorId)) {
-                    log.warn(`[MemoryService] 无权限读取记忆: ${normalized.uri}, 请求者: ${input.requestorId}, 创建者: ${record.creatorId}`);
-                    return null;
-                }
-                return annotatePublicMemory(record, input.requestorId);
-            }
-        }
-        return null;
-    }
-    /**
-     * 更新记忆（带权限检查）
-     *
-     * 权限规则：只有创建者可以更新自己的记忆
-     * 更新时会记录最后编辑者信息
-     */
-    async updateMemory(workspacePath, input) {
-        const normalized = this.normalizeUri(input.uri);
-        // 先找到记忆所在的文件
-        let existingRecord = null;
-        let existingType = null;
-        for (const memoryType of ALL_MEMORY_TYPES) {
-            const data = await this.loadMemoryFile(workspacePath, memoryType);
-            const record = data.records.find((r) => r.uri === normalized.uri);
-            if (record) {
-                existingRecord = record;
-                existingType = memoryType;
-                break;
-            }
-        }
-        if (!existingRecord || !existingType) {
-            throw new Error(`Memory not found: ${normalized.uri}`);
-        }
-        // 权限检查：只有创建者可以编辑
-        if (!canModify(existingRecord, input.editorId)) {
-            throw new Error(`无权限编辑此记忆: 只有创建者 ${existingRecord.creatorName} 可以编辑`);
-        }
-        // 校验类型
-        const expectedType = typeof input.memory_type === "string"
-            ? this.normalizeMemoryType(input.memory_type)
-            : undefined;
-        this.ensureTypeMatch(existingRecord, expectedType);
-        // 更新内容
-        let nextContent = existingRecord.content;
-        if (typeof input.old_string === "string" &&
-            typeof input.new_string === "string") {
-            const oldString = input.old_string;
-            if (!oldString) {
-                throw new Error("old_string cannot be empty when replacing");
-            }
-            const occurrenceCount = nextContent.split(oldString).length - 1;
-            if (occurrenceCount === 0) {
-                throw new Error("old_string not found in memory content");
-            }
-            if (occurrenceCount > 1) {
-                throw new Error("old_string appears multiple times; replace is ambiguous");
-            }
-            nextContent = nextContent.replace(oldString, input.new_string);
-        }
-        if (typeof input.append === "string" && input.append.length > 0) {
-            nextContent = `${nextContent}${input.append}`;
-        }
-        // 加载文件并更新
-        const data = await this.loadMemoryFile(workspacePath, existingType);
-        const existing = data.records.find((r) => r.uri === normalized.uri);
-        if (!existing) {
-            throw new Error(`Memory not found: ${normalized.uri}`);
-        }
-        const updated = {
-            ...existing,
-            content: nextContent,
-            updatedAt: this.nowIso(),
-            version: existing.version + 1,
-            // 记录最后编辑者（如果编辑者不是创建者）
-            lastEditorId: input.editorId,
-            lastEditorName: input.editorName,
-        };
-        // 替换数组中的记录
-        const index = data.records.findIndex((r) => r.uri === normalized.uri);
-        data.records[index] = updated;
-        await this.saveMemoryFile(workspacePath, existingType, data);
-        log.info(`[MemoryService] 更新记忆: ${normalized.uri}, 版本: ${updated.version}, 编辑者: ${input.editorName}`);
-        return updated;
-    }
-    /**
-     * 删除记忆（带权限检查）
-     *
-     * 权限规则：只有创建者可以删除自己的记忆
-     */
-    async deleteMemory(workspacePath, input) {
-        const normalized = this.normalizeUri(input.uri);
-        const expectedType = typeof input.memory_type === "string"
-            ? this.normalizeMemoryType(input.memory_type)
-            : undefined;
-        // 找到记忆
-        for (const memoryType of ALL_MEMORY_TYPES) {
-            if (expectedType && memoryType !== expectedType) {
-                continue;
-            }
-            const data = await this.loadMemoryFile(workspacePath, memoryType);
-            const index = data.records.findIndex((r) => r.uri === normalized.uri);
-            if (index !== -1) {
-                const existing = data.records[index];
-                this.ensureTypeMatch(existing, expectedType);
-                // 权限检查：只有创建者可以删除
-                if (!canModify(existing, input.requestorId)) {
-                    log.warn(`[MemoryService] 无权限删除记忆: ${normalized.uri}, 请求者: ${input.requestorId}, 创建者: ${existing.creatorId}`);
-                    return {
-                        deleted: false,
-                        reason: `无权限删除此记忆: 只有创建者 ${existing.creatorName} 可以删除`,
-                    };
-                }
-                data.records.splice(index, 1);
-                await this.saveMemoryFile(workspacePath, memoryType, data);
-                log.info(`[MemoryService] 删除记忆: ${normalized.uri}, 类型: ${memoryType}`);
-                return { deleted: true };
-            }
-        }
-        return { deleted: false, reason: "Memory not found" };
-    }
-    /**
-     * 搜索记忆（带权限过滤）
-     *
-     * 权限规则：只返回自己的记忆 + 公开的记忆
-     * 公开的记忆会标注来源信息
-     */
-    async searchMemory(workspacePath, input) {
-        const query = String(input.query || "")
-            .trim()
-            .toLowerCase();
-        const memoryTypeFilter = input.memory_type
-            ? this.normalizeMemoryType(input.memory_type)
-            : undefined;
-        const limit = typeof input.limit === "number" && input.limit > 0 ? input.limit : 10;
-        if (!query) {
-            return { query, results: [], totalFound: 0 };
-        }
-        const seenById = new Set();
-        const ranked = [];
-        // 从所有文件（或指定类型文件）搜索
-        const typesToSearch = memoryTypeFilter
-            ? [memoryTypeFilter]
-            : ALL_MEMORY_TYPES;
-        for (const memoryType of typesToSearch) {
-            const data = await this.loadMemoryFile(workspacePath, memoryType);
-            for (const record of data.records) {
-                if (seenById.has(record.id)) {
-                    continue;
-                }
-                // 权限过滤：只搜索自己可访问的记忆
-                if (!canAccess(record, input.requestorId)) {
-                    continue;
-                }
-                const haystack = `${record.uri}\n${record.content}`.toLowerCase();
-                if (!haystack.includes(query)) {
-                    continue;
-                }
-                // 计算得分：URI 匹配权重更高
-                const inUri = record.uri.toLowerCase().includes(query) ? 2 : 0;
-                const inContent = record.content.toLowerCase().includes(query) ? 1 : 0;
-                const score = inUri + inContent;
-                const isOwn = record.creatorId === input.requestorId;
-                seenById.add(record.id);
-                ranked.push({ score, record, isOwn });
-            }
-        }
-        // 按得分和更新时间排序，自己的记忆优先
-        ranked.sort((a, b) => {
-            // 自己的记忆优先显示
-            if (a.isOwn !== b.isOwn) {
-                return a.isOwn ? -1 : 1;
-            }
-            // 然后按得分排序
-            if (b.score !== a.score) {
-                return b.score - a.score;
-            }
-            // 最后按更新时间排序
-            return b.record.updatedAt.localeCompare(a.record.updatedAt);
-        });
-        const results = ranked
-            .slice(0, limit)
-            .map((item) => annotatePublicMemory(item.record, input.requestorId));
-        log.info(`[MemoryService] 搜索记忆: query="${query}", 找到 ${ranked.length} 条, 返回 ${results.length} 条`);
-        return {
-            query,
-            results,
-            totalFound: ranked.length,
-        };
-    }
-    /**
-     * 按类型列出记忆（带权限过滤）
-     *
-     * 权限规则：只列出自己的记忆 + 公开的记忆
-     */
-    async listByType(workspacePath, input) {
-        const listType = this.normalizeMemoryType(input.memory_type, LISTABLE_MEMORY_TYPES);
-        const data = await this.loadMemoryFile(workspacePath, listType);
-        // 权限过滤
-        const filteredRecords = data.records.filter((record) => canAccess(record, input.requestorId));
-        // 按更新时间排序，自己的记忆优先
-        const records = [...filteredRecords];
-        records.sort((a, b) => {
-            // 自己的记忆优先显示
-            const aIsOwn = a.creatorId === input.requestorId;
-            const bIsOwn = b.creatorId === input.requestorId;
-            if (aIsOwn !== bIsOwn) {
-                return aIsOwn ? -1 : 1;
-            }
-            // 然后按更新时间排序
-            return b.updatedAt.localeCompare(a.updatedAt);
-        });
-        // 标注来源信息
-        const annotatedRecords = records.map((record) => annotatePublicMemory(record, input.requestorId));
-        log.info(`[MemoryService] 列出记忆: 类型=${listType}, 总数=${data.records.length}, 可访问=${annotatedRecords.length}`);
-        return annotatedRecords;
-    }
-    /**
-     * 删除任务列表记忆（仅限 task_list 类型，带权限检查）
-     */
-    async removeTaskListMemory(workspacePath, uri, requestorId) {
-        const record = await this.readMemory(workspacePath, {
-            uri,
-            requestorId,
-        });
-        if (!record) {
-            return { deleted: false, reason: "Memory not found or no access" };
-        }
-        if (record.memory_type !== "task_list") {
-            throw new Error("task_list_remove only supports task_list type");
-        }
-        return this.deleteMemory(workspacePath, {
-            uri: record.uri,
-            memory_type: "task_list",
-            requestorId,
-        });
-    }
-    /**
-     * 归档短期记忆（将 recently_memory 转为 memory，带权限检查）
-     *
-     * 权限规则：只有创建者可以归档自己的记忆
-     */
-    async archiveRecentlyMemory(workspacePath, uri, requestorId) {
-        const recordResult = await this.readMemory(workspacePath, {
-            uri,
-            requestorId,
-        });
-        if (!recordResult) {
-            throw new Error(`Memory not found or no access: ${uri}`);
-        }
-        const record = recordResult;
-        if (record.memory_type !== "recently_memory") {
-            throw new Error("archive only supports recently_memory type");
-        }
-        // 权限检查：只有创建者可以归档
-        if (!canModify(record, requestorId)) {
-            throw new Error(`无权限归档此记忆: 只有创建者 ${record.creatorName} 可以归档`);
-        }
-        // 从 hot-memory.json 中删除
-        const hotData = await this.loadMemoryFile(workspacePath, "recently_memory");
-        const hotIndex = hotData.records.findIndex((r) => r.uri === uri);
-        if (hotIndex === -1) {
-            throw new Error(`Memory not found in hot-memory.json: ${uri}`);
-        }
-        hotData.records.splice(hotIndex, 1);
-        await this.saveMemoryFile(workspacePath, "recently_memory", hotData);
-        // 添加到 cold-memory.json
-        const coldData = await this.loadMemoryFile(workspacePath, "memory");
-        const archived = {
-            ...record,
-            memory_type: "memory",
-            updatedAt: this.nowIso(),
-            version: record.version + 1,
-        };
-        coldData.records.push(archived);
-        await this.saveMemoryFile(workspacePath, "memory", coldData);
-        log.info(`[MemoryService] 归档记忆: ${uri}, 从 recently_memory 到 memory`);
-        return archived;
-    }
-    /**
-     * 获取所有记忆统计信息（已使用异步 API）
-     */
-    async getStats(workspacePath, requestorId) {
-        const memoryDir = await getMemoryDirPath(workspacePath);
-        const stats = {
-            task_list: 0,
-            recently_memory: 0,
-            memory: 0,
-            total: 0,
-            accessible: 0,
-            own: 0,
-            public: 0,
-            memoryDir,
-        };
-        for (const memoryType of ALL_MEMORY_TYPES) {
-            const data = await this.loadMemoryFile(workspacePath, memoryType);
-            stats[memoryType] = data.records.length;
-            stats.total += data.records.length;
-            for (const record of data.records) {
-                if (record.isPublic) {
-                    stats.public++;
-                }
-                if (requestorId && record.creatorId === requestorId) {
-                    stats.own++;
-                }
-                if (requestorId && canAccess(record, requestorId)) {
-                    stats.accessible++;
-                }
-            }
-        }
-        // 如果没有提供 requestorId，accessible 等于 total
-        if (!requestorId) {
-            stats.accessible = stats.total;
-            stats.own = 0;
-        }
-        return stats;
-    }
-}
-// 导出单例
-export const memoryService = new MemoryService();

package/dist/services/session-lookup.d.ts

@@ -1,20 +0,0 @@
-import type { PersistedSession } from '../types.js';
-type ActiveSessionSnapshot = {
-    sessionId: string;
-    workspacePath: string;
-    mode: 'pty' | 'sdk';
-};
-type PersistedSessionSnapshot = Pick<PersistedSession, 'sessionId' | 'workspacePath' | 'command' | 'status' | 'startedAt'> & {
-    mode?: 'pty';
-};
-/**
- * 构建按 Agent 查询会话状态的统一响应。
- *
- * 主流程：
- * 1. 活跃会话返回 hasActiveSession=true 且 isActive=true
- * 2. 持久化可恢复会话返回 hasActiveSession=true 且 isActive=false
- * 3. 无会话返回 false/false
- */
-export declare function buildSessionLookupResponse(agentId: string, activeSession?: ActiveSessionSnapshot | null, persistedSession?: PersistedSessionSnapshot | null): Record<string, unknown>;
-export {};
-//# sourceMappingURL=session-lookup.d.ts.map

package/dist/services/session-lookup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-lookup.d.ts","sourceRoot":"","sources":["../../src/services/session-lookup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,KAAK,qBAAqB,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;CACrB,CAAC;AAEF,KAAK,wBAAwB,GAAG,IAAI,CAAC,gBAAgB,EAAE,WAAW,GAAG,eAAe,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,CAAC,GAAG;IAC3H,IAAI,CAAC,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,qBAAqB,GAAG,IAAI,EAC5C,gBAAgB,CAAC,EAAE,wBAAwB,GAAG,IAAI,GACjD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoCzB"}