@ohos-cpf/3rdloop 0.0.1

package/vendor/Server/CLI/opencode.js

@@ -0,0 +1,5 @@
+/**
+ * OpenCodeCLI 快捷导出
+ * 方便通过 import OpenCodeCLI from './cli/opencode.js' 引用
+ */
+export { default } from './opencode/index.js';

package/vendor/Server/DbUse/MessageArchive.js

@@ -0,0 +1,61 @@
+import StorageManager from './StorageManager.js';
+import SessionStore from './stores/SessionStore.js';
+
+/**
+ * MessageArchive —— Session 对话消息存档服务（兼容门面）
+ *
+ * ⚠️ 本类现为 SessionStore 的薄代理，保留原构造签名与方法，使现有 CLI 适配器
+ *    （OpenCodeCLI）的 `new MessageArchive()` 与 `this.archive.*`
+ *    调用无需任何改动即可工作。
+ *
+ * 实际逻辑已迁入 stores/SessionStore.js，存储细节下沉到 adapters/ 层。
+ * 新代码请直接使用 StorageManager + SessionStore（见 index.js 导出）。
+ *
+ * 原有存储布局保持不变：
+ *   db/Session/
+ *     ├── <sessionId>.jsonl        # 消息流（append-only）
+ *     └── <sessionId>.meta.json    # 元信息
+ */
+class MessageArchive {
+    /**
+     * @param {object} [options]
+     * @param {string} [options.baseDir] - 存档根目录（绝对路径）。默认相对本项目推导。
+     * @param {number} [options.stallThresholdMs] - 判定"卡死/停滞"的阈值，默认 5 分钟
+     * @param {StorageManager} [options.manager] - 已有的 StorageManager（复用根目录与实例缓存）
+     */
+    constructor(options = {}) {
+        const stallThresholdMs = options.stallThresholdMs ?? 5 * 60 * 1000;
+
+        // 复用传入的 manager，或自建一个（rootDir 兼容旧的 baseDir 指向 db/Session 的情形）
+        let manager = options.manager;
+        if (!manager) {
+            manager = new StorageManager(
+                options.baseDir
+                    ? { rootDir: options.baseDir }
+                    : {}
+            );
+        }
+
+        // 通过 manager 获取 Session 子域的 jsonl / json 适配器
+        this._store = new SessionStore({
+            jsonl: manager.jsonl('Session'),
+            json: manager.json('Session'),
+            stallThresholdMs
+        });
+    }
+
+    // ─── 代理到 SessionStore，保持原方法签名 ──────────────────────────────────
+
+    async readMeta(sessionId) { return this._store.readMeta(sessionId); }
+    async writeMeta(sessionId, meta) { return this._store.writeMeta(sessionId, meta); }
+    async patchMeta(sessionId, patch) { return this._store.patchMeta(sessionId, patch); }
+    async appendMessage(sessionId, message, opts) { return this._store.appendMessage(sessionId, message, opts); }
+    async appendMessages(sessionId, messages) { return this._store.appendMessages(sessionId, messages); }
+    async readMessages(sessionId) { return this._store.readMessages(sessionId); }
+    async readLastMessage(sessionId) { return this._store.readLastMessage(sessionId); }
+    async listSessions() { return this._store.listSessions(); }
+    async recordCheck(sessionId, current) { return this._store.recordCheck(sessionId, current); }
+    async deleteSession(sessionId) { return this._store.deleteSession(sessionId); }
+}
+
+export default MessageArchive;

package/vendor/Server/DbUse/StorageManager.js

@@ -0,0 +1,107 @@
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import JsonAdapter from './adapters/JsonAdapter.js';
+import JsonlAdapter from './adapters/JsonlAdapter.js';
+import SqliteAdapter from './adapters/SqliteAdapter.js';
+import FileAdapter from './adapters/FileAdapter.js';
+
+/**
+ * StorageManager —— 统一存储管理器
+ *
+ * 职责：
+ *   1. 集中解析存储根目录（db/），所有适配器共享同一根，避免路径散落。
+ *   2. 按子域（subDir）创建并缓存适配器实例，同一子域复用同一实例。
+ *   3. 提供工厂方法 get(type, subDir)，对上层 Store 屏蔽适配器构造细节。
+ *   4. 统一生命周期管理（closeAll）。
+ *
+ * 分层关系：
+ *   ┌─────────────────────────────────────────────┐
+ *   │  Store 层 (SessionStore / TaskStepStore)    │  业务语义
+ *   ├─────────────────────────────────────────────┤
+ *   │  StorageManager                             │  工厂/注册表/根目录
+ *   ├─────────────────────────────────────────────┤
+ *   │  Adapter 层 (Json/Jsonl/Sqlite/File)        │  存储格式实现
+ *   └─────────────────────────────────────────────┘
+ *
+ * 扩展方式：
+ *   - 新增存储格式：实现 BaseAdapter 子类 → 注册到 _ADAPTERS → Manager 自动可用
+ *   - 新增业务存储：实现 Store，依赖 Manager.get() 获取适配器，不感知格式
+ */
+class StorageManager {
+    /**
+     * @param {object} [options]
+     * @param {string} [options.rootDir] - 存储根目录绝对路径。默认 workspace 根下 db/
+     */
+    constructor(options = {}) {
+        if (options.rootDir) {
+            this.rootDir = options.rootDir;
+        } else {
+            // 本文件 (Server/DbUse/) 上溯 3 层到 workspace 根 → db/
+            const here = dirname(fileURLToPath(import.meta.url));
+            this.rootDir = join(here, '..', '..', '..', 'db');
+        }
+        /** @type {Map<string, import('./adapters/BaseAdapter.js').default>} */
+        this._instances = new Map();
+    }
+
+    static get _ADAPTERS() {
+        return {
+            json: JsonAdapter,
+            jsonl: JsonlAdapter,
+            sqlite: SqliteAdapter,
+            file: FileAdapter
+        };
+    }
+
+    /**
+     * 获取（或创建）指定类型与子域的适配器实例。
+     * 同一 (type, subDir) 复用同一实例。
+     *
+     * @param {'json'|'jsonl'|'sqlite'|'file'} type - 适配器类型
+     * @param {string} subDir - 根目录下的子域（如 'Session'、'TaskStep'、'Artifacts'）
+     * @param {object} [adapterOpts] - 传递给适配器的额外选项
+     * @returns {import('./adapters/BaseAdapter.js').default}
+     */
+    get(type, subDir, adapterOpts = {}) {
+        const AdapterClass = StorageManager._ADAPTERS[type];
+        if (!AdapterClass) {
+            throw new Error(
+                `未知的存储类型: "${type}"，可选: ${Object.keys(StorageManager._ADAPTERS).join(', ')}`
+            );
+        }
+        const cacheKey = `${type}:${subDir}`;
+        let instance = this._instances.get(cacheKey);
+        if (!instance) {
+            instance = new AdapterClass({
+                baseDir: this.rootDir,
+                subDir,
+                ...adapterOpts
+            });
+            this._instances.set(cacheKey, instance);
+        }
+        return instance;
+    }
+
+    /** 便捷方法 */
+    json(subDir, opts) { return this.get('json', subDir, opts); }
+    jsonl(subDir, opts) { return this.get('jsonl', subDir, opts); }
+    sqlite(subDir, opts) { return this.get('sqlite', subDir, opts); }
+    file(subDir, opts) { return this.get('file', subDir, opts); }
+
+    /**
+     * 关闭所有适配器（释放数据库连接等）。
+     */
+    async closeAll() {
+        const tasks = [];
+        for (const instance of this._instances.values()) {
+            if (typeof instance.close === 'function') {
+                tasks.push(Promise.resolve(instance.close()).catch(() => {}));
+            }
+        }
+        await Promise.all(tasks);
+        this._instances.clear();
+    }
+}
+
+export default StorageManager;

package/vendor/Server/DbUse/adapters/BaseAdapter.js

@@ -0,0 +1,94 @@
+import { promises as fs } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * BaseAdapter —— 所有存储适配器的抽象基类
+ *
+ * 职责：
+ *   1. 统一根目录解析（相对路径 → 绝对路径）。
+ *   2. 提供目录确保、路径拼接工具方法。
+ *   3. 声明子类必须实现的接口契约（子类不实现则抛 NotImplemented）。
+ *
+ * 设计原则：
+ *   - 高内聚：每种存储格式（JSON/JSONL/SQLite/File）的读写细节封装在各自适配器。
+ *   - 低耦合：Store 层只依赖适配器接口，不感知具体格式；适配器之间互不依赖。
+ *   - 可扩展：新增存储格式只需新增一个 Adapter 子类，无需改动 Store 与 Manager。
+ */
+class BaseAdapter {
+    /**
+     * @param {object} options
+     * @param {string} [options.baseDir]  - 该适配器的工作根目录（绝对路径）
+     * @param {string} [options.subDir]   - 根目录下的子目录名（如 'Session'、'TaskStep'）
+     */
+    constructor(options = {}) {
+        this.subDir = options.subDir || '';
+        if (options.baseDir) {
+            this.baseDir = options.baseDir;
+        } else {
+            // 默认：本文件 (Server/DbUse/adapters/) 上溯 4 层到 workspace 根 → db/
+            const here = dirname(fileURLToPath(import.meta.url));
+            this.baseDir = join(here, '..', '..', '..', '..', 'db');
+        }
+        this.rootDir = this.subDir ? join(this.baseDir, this.subDir) : this.baseDir;
+        this._ensureDirPromise = null;
+    }
+
+    // ─── 工具方法 ──────────────────────────────────────────────────────────────
+
+    /**
+     * 确保工作目录存在（幂等，并发安全）。
+     * @returns {Promise<string>} 目录绝对路径
+     */
+    async ensureDir() {
+        if (!this._ensureDirPromise) {
+            this._ensureDirPromise = fs.mkdir(this.rootDir, { recursive: true }).then(() => {
+                this._ensureDirPromise = null;
+                return this.rootDir;
+            }).catch(err => {
+                this._ensureDirPromise = null;
+                throw err;
+            });
+        }
+        return this._ensureDirPromise;
+    }
+
+    /** 拼接工作目录下的路径 */
+    path(...segments) {
+        return join(this.rootDir, ...segments);
+    }
+
+    /** 同步版路径拼接（供 SQLite 等 sync 场景使用） */
+    pathSync(...segments) {
+        return join(this.rootDir, ...segments);
+    }
+
+    // ─── 子类必须实现的接口契约 ────────────────────────────────────────────────
+    // 以下方法默认抛出 NotImplementedError，子类按需覆盖。
+
+    async read(/* key */) {
+        throw new Error(`${this.constructor.name}.read() 未实现`);
+    }
+
+    async write(/* key, data */) {
+        throw new Error(`${this.constructor.name}.write() 未实现`);
+    }
+
+    async delete(/* key */) {
+        throw new Error(`${this.constructor.name}.delete() 未实现`);
+    }
+
+    async list() {
+        throw new Error(`${this.constructor.name}.list() 未实现`);
+    }
+
+    /**
+     * 返回适配器类型标识，用于日志与注册表。
+     * @returns {string}
+     */
+    get type() {
+        return 'base';
+    }
+}
+
+export default BaseAdapter;

package/vendor/Server/DbUse/adapters/FileAdapter.js

@@ -0,0 +1,138 @@
+import { promises as fs } from 'node:fs';
+import { dirname, join } from 'node:path';
+import BaseAdapter from './BaseAdapter.js';
+
+/**
+ * FileAdapter —— 原始文件读写适配器
+ *
+ * 用途：任务的文件创建/产物落盘、二进制内容、非结构化文本等。
+ * 与 JsonAdapter/JsonlAdapter 的区别：不做 JSON 序列化，原样写入/读取。
+ *
+ * 提供：
+ *   - writeFile(key, content) / readFile(key)     文本或 Buffer
+ *   - createFile(key, content)                    仅在不存在时创建
+ *   - appendFile(key, content)                    追加
+ *   - exists(key) / stat(key)                     元信息
+ *   - list(pattern)                               列举文件
+ */
+class FileAdapter extends BaseAdapter {
+    constructor(options = {}) {
+        super(options);
+        this._defaultExt = options.defaultExt || '';
+    }
+
+    get type() {
+        return 'file';
+    }
+
+    _file(key) {
+        // key 即相对 rootDir 的文件路径（可含子目录与扩展名）
+        return this.path(key);
+    }
+
+    /**
+     * 写入文件（覆盖）。
+     * @param {string} key
+     * @param {string|Buffer} content
+     * @param {object} [opts]
+     * @param {boolean} [opts.binary] - 是否二进制
+     */
+    async write(key, content, opts = {}) {
+        await this.ensureDir();
+        const file = this._file(key);
+        await fs.mkdir(dirname(file), { recursive: true });
+        await fs.writeFile(file, content, opts.binary ? null : 'utf8');
+        return key;
+    }
+
+    /** readFile 别名，对齐接口 */
+    async read(key, opts = {}) {
+        return this.readFile(key, opts);
+    }
+
+    async readFile(key, opts = {}) {
+        try {
+            return await fs.readFile(this._file(key), opts.binary ? null : 'utf8');
+        } catch (err) {
+            if (err.code === 'ENOENT') return null;
+            throw err;
+        }
+    }
+
+    /**
+     * 仅当文件不存在时创建（原子性：O_EXCL）。
+     * @returns {Promise<boolean>} 是否实际创建
+     */
+    async createFile(key, content = '', opts = {}) {
+        await this.ensureDir();
+        const file = this._file(key);
+        await fs.mkdir(dirname(file), { recursive: true });
+        try {
+            // 'wx' 标志：存在则失败
+            const handle = await fs.open(file, 'wx');
+            await handle.writeFile(content, opts.binary ? null : 'utf8');
+            await handle.close();
+            return true;
+        } catch (err) {
+            if (err.code === 'EEXIST') return false;
+            throw err;
+        }
+    }
+
+    async appendFile(key, content, opts = {}) {
+        await this.ensureDir();
+        const file = this._file(key);
+        await fs.mkdir(dirname(file), { recursive: true });
+        await fs.appendFile(file, content, opts.binary ? null : 'utf8');
+        return key;
+    }
+
+    async exists(key) {
+        try {
+            await fs.access(this._file(key));
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async stat(key) {
+        try {
+            return await fs.stat(this._file(key));
+        } catch (err) {
+            if (err.code === 'ENOENT') return null;
+            throw err;
+        }
+    }
+
+    async delete(key) {
+        try {
+            await fs.unlink(this._file(key));
+            return true;
+        } catch (err) {
+            if (err.code === 'ENOENT') return false;
+            throw err;
+        }
+    }
+
+    /**
+     * 列举目录下的文件名（不含目录）。pattern 为简单前缀过滤。
+     * @param {string} [pattern]
+     * @returns {Promise<Array<string>>}
+     */
+    async list(pattern) {
+        await this.ensureDir();
+        try {
+            const entries = await fs.readdir(this.rootDir, { withFileTypes: true });
+            return entries
+                .filter(e => e.isFile())
+                .map(e => e.name)
+                .filter(name => !pattern || name.startsWith(pattern));
+        } catch (err) {
+            if (err.code === 'ENOENT') return [];
+            throw err;
+        }
+    }
+}
+
+export default FileAdapter;

package/vendor/Server/DbUse/adapters/JsonAdapter.js

@@ -0,0 +1,138 @@
+import { promises as fs } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import BaseAdapter from './BaseAdapter.js';
+
+/**
+ * JsonAdapter —— JSON 文件存储适配器
+ *
+ * 用途：存储结构化的小型文档（meta、配置、任务快照），整文件读写。
+ * 一个 key 对应一个 `<key>.json` 文件，内容为 JSON 对象。
+ *
+ * 适用场景：元信息、步骤状态、单文档存档。
+ * 不适用：高频追加的消息流（请用 JsonlAdapter）或大量记录（请用 SqliteAdapter）。
+ */
+class JsonAdapter extends BaseAdapter {
+    constructor(options = {}) {
+        super(options);
+        this._ext = options.ext || '.json';
+    }
+
+    get type() {
+        return 'json';
+    }
+
+    _file(key) {
+        // key 允许含子目录，自动创建
+        return this.path(`${key}${this._ext}`);
+    }
+
+    async read(key) {
+        try {
+            const raw = await fs.readFile(this._file(key), 'utf8');
+            return JSON.parse(raw);
+        } catch (err) {
+            if (err.code === 'ENOENT') return null;
+            throw err;
+        }
+    }
+
+    async write(key, data) {
+        await this.ensureDir();
+        const file = this._file(key);
+        // 确保子目录存在
+        await fs.mkdir(dirname(file), { recursive: true });
+        // 原子写入：先写临时文件，再 rename 覆盖目标文件。
+        // 避免并发 writeFile 直接截断目标文件时，另一路仍在写尾部，
+        // 产生 JSON 尾部拼接垃圾（如 orchestration.json 损坏场景）。
+        // rename 在同一文件系统内是原子的，读端要么看到旧文件要么看到完整新文件。
+        const tmp = `${file}.${randomBytes(6).toString('hex')}.tmp`;
+        try {
+            await fs.writeFile(tmp, JSON.stringify(data, null, 2), 'utf8');
+            await fs.rename(tmp, file);
+        } catch (err) {
+            // 出错时清理临时文件，避免残留
+            await fs.unlink(tmp).catch(() => {});
+            throw err;
+        }
+        return data;
+    }
+
+    async delete(key) {
+        try {
+            await fs.unlink(this._file(key));
+            return true;
+        } catch (err) {
+            if (err.code === 'ENOENT') return false;
+            throw err;
+        }
+    }
+
+    /**
+     * 列举 JSON 文件。
+     *
+     * @param {string} [prefix] - 可选的子目录前缀（如 'task-001/stepid_'），
+     *                           传入时递归列举该前缀下的文件，key 含子目录路径。
+     *                           不传时列举根目录下的文件。
+     * @returns {Promise<Array<{key: string, data: object}>>}
+     */
+    async list(prefix) {
+        await this.ensureDir();
+
+        if (prefix) {
+            // 子目录模式：在 rootDir/prefix 的父目录下递归查找匹配文件
+            const dir = dirname(this.path(prefix));
+            const files = await this._readdirRecursive(dir);
+            const result = [];
+            for (const file of files) {
+                if (!file.endsWith(this._ext)) continue;
+                // 从 rootDir 开始的相对路径（去掉扩展名）作为 key
+                const rel = file.slice(this.rootDir.length + 1, -this._ext.length);
+                if (!rel.startsWith(prefix)) continue;
+                const data = await this.read(rel);
+                if (data != null) result.push({ key: rel, data });
+            }
+            return result;
+        }
+
+        // 根目录模式
+        const entries = await fs.readdir(this.rootDir, { withFileTypes: true });
+        const result = [];
+        for (const e of entries) {
+            if (e.isFile() && e.name.endsWith(this._ext)) {
+                const key = e.name.slice(0, -this._ext.length);
+                const data = await this.read(key);
+                if (data != null) result.push({ key, data });
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 递归读取目录下所有文件路径。
+     * @param {string} dir
+     * @returns {Promise<string[]>}
+     * @private
+     */
+    async _readdirRecursive(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch (err) {
+            if (err.code === 'ENOENT') return [];
+            throw err;
+        }
+        const files = [];
+        for (const e of entries) {
+            const full = join(dir, e.name);
+            if (e.isDirectory()) {
+                files.push(...await this._readdirRecursive(full));
+            } else if (e.isFile()) {
+                files.push(full);
+            }
+        }
+        return files;
+    }
+}
+
+export default JsonAdapter;

package/vendor/Server/DbUse/adapters/JsonlAdapter.js

@@ -0,0 +1,114 @@
+import { promises as fs } from 'node:fs';
+import { dirname } from 'node:path';
+import BaseAdapter from './BaseAdapter.js';
+
+/**
+ * JsonlAdapter —— JSONL 流式追加存储适配器
+ *
+ * 用途：append-only 消息流、事件日志等高频追加场景。
+ * 一个 key 对应一个 `<key>.jsonl` 文件，每行一条 JSON。
+ *
+ * 优势：
+ *   - 追加写入 O(1)，无需读改写整文件
+ *   - 天然增量，便于按行读取/流式处理
+ *   - 单文件损坏只影响该 key
+ */
+class JsonlAdapter extends BaseAdapter {
+    constructor(options = {}) {
+        super(options);
+        this._ext = options.ext || '.jsonl';
+    }
+
+    get type() {
+        return 'jsonl';
+    }
+
+    _file(key) {
+        return this.path(`${key}${this._ext}`);
+    }
+
+    /**
+     * 追加一条记录。
+     * @param {string} key
+     * @param {object} record
+     * @returns {Promise<object>} 实际写入的记录
+     */
+    async append(key, record) {
+        await this.ensureDir();
+        const file = this._file(key);
+        await fs.mkdir(dirname(file), { recursive: true });
+        const line = JSON.stringify(record) + '\n';
+        await fs.appendFile(file, line, 'utf8');
+        return record;
+    }
+
+    /**
+     * 批量追加。
+     * @param {string} key
+     * @param {Array<object>} records
+     * @returns {Promise<number>} 实际写入条数
+     */
+    async appendBatch(key, records) {
+        await this.ensureDir();
+        const file = this._file(key);
+        await fs.mkdir(dirname(file), { recursive: true });
+        const content = records.map(r => JSON.stringify(r)).join('\n') + (records.length ? '\n' : '');
+        if (content) await fs.appendFile(file, content, 'utf8');
+        return records.length;
+    }
+
+    /**
+     * 读取全部记录（按行顺序）。
+     * @param {string} key
+     * @returns {Promise<Array<object>>}
+     */
+    async read(key) {
+        try {
+            const raw = await fs.readFile(this._file(key), 'utf8');
+            const lines = raw.split('\n').filter(Boolean);
+            const out = [];
+            for (const line of lines) {
+                try { out.push(JSON.parse(line)); }
+                catch { /* 跳过损坏行 */ }
+            }
+            return out;
+        } catch (err) {
+            if (err.code === 'ENOENT') return [];
+            throw err;
+        }
+    }
+
+    /**
+     * 读取最后一条记录（高效：从尾部读取）。
+     * @param {string} key
+     * @returns {Promise<object|null>}
+     */
+    async readLast(key) {
+        const records = await this.read(key);
+        return records.length > 0 ? records[records.length - 1] : null;
+    }
+
+    async delete(key) {
+        try {
+            await fs.unlink(this._file(key));
+            return true;
+        } catch (err) {
+            if (err.code === 'ENOENT') return false;
+            throw err;
+        }
+    }
+
+    async list() {
+        await this.ensureDir();
+        const entries = await fs.readdir(this.rootDir, { withFileTypes: true });
+        const result = [];
+        for (const e of entries) {
+            if (e.isFile() && e.name.endsWith(this._ext)) {
+                result.push(e.name.slice(0, -this._ext.length));
+            }
+        }
+        return result;
+    }
+}
+
+export default JsonlAdapter;