agent-yes 1.53.1 → 1.54.0

package/dist/{SUPPORTED_CLIS-I-XMBksk.js → SUPPORTED_CLIS-Db5tikbx.js}

@@ -1,7 +1,7 @@
 import { a as __esmMin, c as __toESM, i as __commonJSMin, n as require_winston, o as __exportAll, s as __require, t as logger } from "./logger-DH1Rx9HI.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
-import { existsSync, mkdirSync } from "fs";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync } from "fs";
 import path, { dirname, join } from "path";
 import { constants } from "node:os";
 import path$1 from "node:path";
@@ -21,7 +21,8 @@ import { finished } from "node:stream/promises";
 import { Duplex, PassThrough, Readable, Transform, Writable, getDefaultHighWaterMark } from "node:stream";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { fromWritable } from "from-node-stream";
-import { mkdir, readFile, readdir, rename, writeFile as writeFile$1 } from "fs/promises";
+import { appendFile, mkdir, readFile, readdir, rename, writeFile as writeFile$1 } from "fs/promises";
+import { lock } from "proper-lockfile";
 
 //#region node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
@@ -9315,180 +9316,220 @@ function shouldUseLock(_cwd) {
 }
 
 //#endregion
-//#region ts/SqliteAdapter.ts
-var SqliteAdapter = class {
-	db;
-	isInitialized = false;
-	async init(dbPath) {
+//#region ts/JsonlStore.ts
+/**
+* A lightweight NeDB-style JSONL persistence layer.
+*
+* - Append-only writes (one JSON object per line)
+* - Same `_id` → last line wins (fields merged)
+* - `$$deleted` lines act as tombstones
+* - Crash recovery: skip partial last line, recover from temp file
+* - Multi-process safe via proper-lockfile (reads don't need lock)
+* - Compact on close: deduplicates into clean file via atomic rename
+*/
+var JsonlStore = class {
+	filePath;
+	tempPath;
+	lockPath;
+	docs = /* @__PURE__ */ new Map();
+	constructor(filePath) {
+		this.filePath = filePath;
+		this.tempPath = filePath + "~";
+		this.lockPath = path.dirname(filePath);
+	}
+	/**
+	* Load all records from the JSONL file. No lock needed.
+	* Handles crash recovery: partial last line skipped, temp file recovery.
+	*/
+	async load() {
+		await mkdir(path.dirname(this.filePath), { recursive: true });
+		if (!existsSync(this.filePath) && existsSync(this.tempPath)) {
+			logger.debug("[JsonlStore] Recovering from temp file");
+			await rename(this.tempPath, this.filePath);
+		}
+		this.docs = /* @__PURE__ */ new Map();
+		let raw = "";
 		try {
-			await mkdir(path.dirname(dbPath), { recursive: true });
-			if (typeof globalThis.Bun !== "undefined") {
-				const { Database } = await import("bun:sqlite");
-				this.db = new Database(dbPath);
-			} else {
-				const { DatabaseSync } = await import("node:sqlite");
-				this.db = new DatabaseSync(dbPath);
-			}
-			this.isInitialized = true;
-			logger.debug(`[SqliteAdapter] Initialized database at ${dbPath}`);
-		} catch (error) {
-			logger.warn(`[SqliteAdapter] Failed to initialize database at ${dbPath}:`, error);
-			this.db = this.createFallbackDb();
-			this.isInitialized = false;
+			raw = await readFile(this.filePath, "utf-8");
+		} catch (err) {
+			if (err.code === "ENOENT") return this.docs;
+			throw err;
 		}
-	}
-	createFallbackDb() {
-		const storage = /* @__PURE__ */ new Map();
-		return {
-			prepare: (sql) => ({
-				all: (...params) => {
-					logger.debug("[SqliteAdapter] Using fallback mode (query):", sql);
-					return storage.get(sql) || [];
-				},
-				run: (...params) => {
-					logger.debug("[SqliteAdapter] Using fallback mode (run):", sql);
-					return {
-						lastInsertRowid: 0,
-						changes: 0
-					};
+		const lines = raw.split("\n");
+		let corruptCount = 0;
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			try {
+				const doc = JSON.parse(trimmed);
+				if (!doc._id) continue;
+				if (doc.$$deleted) this.docs.delete(doc._id);
+				else {
+					const existing = this.docs.get(doc._id);
+					if (existing) this.docs.set(doc._id, {
+						...existing,
+						...doc
+					});
+					else this.docs.set(doc._id, doc);
 				}
-			}),
-			query: (sql) => ({ all: (params) => {
-				logger.debug("[SqliteAdapter] Using fallback mode (query):", sql);
-				return storage.get(sql) || [];
-			} }),
-			run: (sql, params) => {
-				logger.debug("[SqliteAdapter] Using fallback mode (run):", sql);
-			},
-			close: () => {
-				logger.debug("[SqliteAdapter] Closing fallback db");
+			} catch {
+				corruptCount++;
 			}
+		}
+		if (corruptCount > 0) logger.debug(`[JsonlStore] Skipped ${corruptCount} corrupt line(s) in ${this.filePath}`);
+		return this.docs;
+	}
+	/** Get all live documents. */
+	getAll() {
+		return Array.from(this.docs.values());
+	}
+	/** Find a document by _id. */
+	getById(id) {
+		return this.docs.get(id);
+	}
+	/** Find documents matching a predicate. */
+	find(predicate) {
+		return this.getAll().filter(predicate);
+	}
+	/** Find first document matching a predicate. */
+	findOne(predicate) {
+		for (const doc of this.docs.values()) if (predicate(doc)) return doc;
+	}
+	/**
+	* Append a new document. Acquires lock.
+	* If no _id is provided, one is generated.
+	*/
+	async append(doc) {
+		const id = doc._id || generateId();
+		const { _id: _, ...rest } = doc;
+		const fullDoc = {
+			_id: id,
+			...rest
 		};
+		return await this.withLock(async () => {
+			await appendFile(this.filePath, JSON.stringify(fullDoc) + "\n");
+			const existing = this.docs.get(fullDoc._id);
+			if (existing) this.docs.set(fullDoc._id, {
+				...existing,
+				...fullDoc
+			});
+			else this.docs.set(fullDoc._id, fullDoc);
+			return fullDoc;
+		});
 	}
-	query(sql, params = []) {
-		try {
-			if (typeof this.db.query === "function") return this.db.query(sql).all(params);
-			else return this.db.prepare(sql).all(...params);
-		} catch (error) {
-			logger.debug("[SqliteAdapter] Query failed:", error);
-			return [];
-		}
+	/**
+	* Update a document by _id. Appends a merge line. Acquires lock.
+	*/
+	async updateById(id, patch) {
+		await this.withLock(async () => {
+			const line = {
+				_id: id,
+				...patch
+			};
+			await appendFile(this.filePath, JSON.stringify(line) + "\n");
+			const existing = this.docs.get(id);
+			if (existing) this.docs.set(id, {
+				...existing,
+				...patch
+			});
+		});
 	}
-	run(sql, params = []) {
-		try {
-			if (typeof this.db.query === "function") {
-				this.db.run(sql, params);
-				return {};
-			} else return this.db.prepare(sql).run(...params);
-		} catch (error) {
-			logger.debug("[SqliteAdapter] Run failed:", error);
-			return {};
-		}
+	/**
+	* Delete a document by _id. Appends a tombstone. Acquires lock.
+	*/
+	async deleteById(id) {
+		await this.withLock(async () => {
+			const tombstone = {
+				_id: id,
+				$$deleted: true
+			};
+			await appendFile(this.filePath, JSON.stringify(tombstone) + "\n");
+			this.docs.delete(id);
+		});
+	}
+	/**
+	* Compact the file: deduplicate entries, remove tombstones.
+	* Writes to temp file, fsyncs, then atomic renames.
+	* Acquires lock.
+	*/
+	async compact() {
+		await this.withLock(async () => {
+			const lines = Array.from(this.docs.values()).map((doc) => {
+				const { _id, $$deleted, ...rest } = doc;
+				return JSON.stringify({
+					_id,
+					...rest
+				});
+			}).join("\n");
+			const content = lines ? lines + "\n" : "";
+			await writeFile$1(this.tempPath, content);
+			const fd = openSync(this.tempPath, "r");
+			fsyncSync(fd);
+			closeSync(fd);
+			await rename(this.tempPath, this.filePath);
+		});
 	}
-	close() {
+	async withLock(fn) {
+		const dir = path.dirname(this.filePath);
+		let release;
 		try {
-			if (this.db?.close) this.db.close();
-		} catch (error) {
-			logger.debug("[SqliteAdapter] Close failed:", error);
+			release = await lock(dir, {
+				lockfilePath: this.filePath + ".lock",
+				retries: {
+					retries: 5,
+					minTimeout: 50,
+					maxTimeout: 500
+				}
+			});
+			return await fn();
+		} finally {
+			if (release) await release();
 		}
 	}
-	isReady() {
-		return this.isInitialized;
-	}
 };
+let idCounter = 0;
+function generateId() {
+	return Date.now().toString(36) + (idCounter++).toString(36) + Math.random().toString(36).slice(2, 6);
+}
 
 //#endregion
 //#region ts/pidStore.ts
 var PidStore = class PidStore {
-	db;
 	storeDir;
-	dbPath;
+	store;
 	constructor(workingDir) {
 		this.storeDir = path.resolve(workingDir, ".agent-yes");
-		this.dbPath = path.join(this.storeDir, "pid.sqlite");
+		this.store = new JsonlStore(path.join(this.storeDir, "pid-records.jsonl"));
 	}
 	async init() {
 		try {
 			await this.ensureGitignore();
-			this.db = new SqliteAdapter();
-			await this.db.init(this.dbPath);
-			if (this.db.isReady()) {
-				this.db.run("PRAGMA journal_mode=WAL");
-				this.db.run("PRAGMA synchronous=NORMAL");
-				this.db.run("PRAGMA cache_size=1000");
-				this.db.run("PRAGMA temp_store=memory");
-				this.db.run(`
-          CREATE TABLE IF NOT EXISTS pid_records (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            pid INTEGER NOT NULL UNIQUE,
-            cli TEXT NOT NULL,
-            args TEXT NOT NULL,
-            prompt TEXT,
-            cwd TEXT NOT NULL,
-            logFile TEXT NOT NULL,
-            fifoFile TEXT NOT NULL,
-            status TEXT NOT NULL DEFAULT 'active',
-            exitReason TEXT NOT NULL DEFAULT '',
-            exitCode INTEGER,
-            startedAt INTEGER NOT NULL,
-            updatedAt INTEGER NOT NULL
-          )
-        `);
-				try {
-					if (!this.db.query("PRAGMA table_info(pid_records)").some((col) => col.name === "cwd")) {
-						logger.info("[pidStore] Migrating database: adding cwd column");
-						this.db.run("ALTER TABLE pid_records ADD COLUMN cwd TEXT NOT NULL DEFAULT ''");
-					}
-				} catch (error) {
-					logger.warn("[pidStore] Migration check failed:", error);
-				}
-				await this.cleanStaleRecords();
-			} else logger.warn("[pidStore] Database not ready, running in fallback mode");
+			await this.store.load();
+			await this.cleanStaleRecords();
 		} catch (error) {
 			logger.warn("[pidStore] Failed to initialize:", error);
 		}
 	}
 	async registerProcess({ pid, cli, args, prompt, cwd }) {
 		const now = Date.now();
-		const argsJson = JSON.stringify(args);
-		const logFile = path.resolve(this.getLogDir(), `${pid}.log`);
-		const fifoFile = this.getFifoPath(pid);
-		try {
-			this.db.run(`
-        INSERT INTO pid_records (pid, cli, args, prompt, cwd, logFile, fifoFile, status, exitReason, startedAt, updatedAt)
-        VALUES (?, ?, ?, ?, ?, ?, ?, 'active', '', ?, ?)
-      `, [
-				pid,
-				cli,
-				argsJson,
-				prompt,
-				cwd,
-				logFile,
-				fifoFile,
-				now,
-				now
-			]);
-		} catch (error) {
-			if (error.code === "SQLITE_CONSTRAINT_UNIQUE") this.db.run(`
-          UPDATE pid_records
-          SET cli = ?, args = ?, prompt = ?, cwd = ?, logFile = ?, fifoFile = ?, status = 'active', exitReason = '', startedAt = ?, updatedAt = ?
-          WHERE pid = ?
-        `, [
-				cli,
-				argsJson,
-				prompt,
-				cwd,
-				logFile,
-				fifoFile,
-				now,
-				now,
-				pid
-			]);
-			else throw error;
-		}
-		const result = this.db.query("SELECT * FROM pid_records WHERE pid = ?", [pid])[0];
+		const record = {
+			pid,
+			cli,
+			args: JSON.stringify(args),
+			prompt,
+			cwd,
+			logFile: path.resolve(this.getLogDir(), `${pid}.log`),
+			fifoFile: this.getFifoPath(pid),
+			status: "active",
+			exitReason: "",
+			startedAt: now
+		};
+		const existing = this.store.findOne((doc) => doc.pid === pid);
+		if (existing) await this.store.updateById(existing._id, record);
+		else await this.store.append(record);
+		const result = this.store.findOne((doc) => doc.pid === pid);
 		if (!result) {
-			const allRecords = this.db.query("SELECT * FROM pid_records");
+			const allRecords = this.store.getAll();
 			logger.error(`[pidStore] Failed to find record for PID ${pid}. All records:`, allRecords);
 			throw new Error(`Failed to register process ${pid}`);
 		}
@@ -9496,26 +9537,16 @@ var PidStore = class PidStore {
 		return result;
 	}
 	async updateStatus(pid, status, extra) {
-		const updatedAt = Date.now();
-		const exitReason = extra?.exitReason || "";
-		const exitCode = extra?.exitCode;
-		if (exitCode !== void 0) this.db.run("UPDATE pid_records SET status = ?, exitReason = ?, exitCode = ?, updatedAt = ? WHERE pid = ?", [
-			status,
-			exitReason,
-			exitCode,
-			updatedAt,
-			pid
-		]);
-		else this.db.run("UPDATE pid_records SET status = ?, exitReason = ?, updatedAt = ? WHERE pid = ?", [
-			status,
-			exitReason,
-			updatedAt,
-			pid
-		]);
+		const existing = this.store.findOne((doc) => doc.pid === pid);
+		if (!existing) return;
+		const patch = { status };
+		if (extra?.exitReason !== void 0) patch.exitReason = extra.exitReason;
+		if (extra?.exitCode !== void 0) patch.exitCode = extra.exitCode;
+		await this.store.updateById(existing._id, patch);
 		logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
 	}
 	getAllRecords() {
-		return this.db.query("SELECT * FROM pid_records");
+		return this.store.getAll();
 	}
 	getLogDir() {
 		return path.resolve(this.storeDir, "logs");
@@ -9525,21 +9556,22 @@ var PidStore = class PidStore {
 		else return path.resolve(this.storeDir, "fifo", `${pid}.stdin`);
 	}
 	async cleanStaleRecords() {
-		const activeRecords = this.db.query("SELECT * FROM pid_records WHERE status != 'exited'");
+		const activeRecords = this.store.find((r) => r.status !== "exited");
 		for (const record of activeRecords) if (!this.isProcessAlive(record.pid)) {
-			this.db.run("UPDATE pid_records SET status = 'exited', exitReason = 'stale-cleanup', updatedAt = ? WHERE pid = ?", [Date.now(), record.pid]);
+			await this.store.updateById(record._id, {
+				status: "exited",
+				exitReason: "stale-cleanup"
+			});
 			logger.debug(`[pidStore] Cleaned stale record for PID ${record.pid}`);
 		}
 	}
 	async close() {
 		try {
-			this.db.run("PRAGMA optimize");
-			this.db.run("VACUUM");
+			await this.store.compact();
 		} catch (error) {
-			logger.warn("[pidStore] Failed to optimize database:", error);
+			logger.debug("[pidStore] Compact on close failed:", error);
 		}
-		this.db.close();
-		logger.debug("[pidStore] Database optimized and closed");
+		logger.debug("[pidStore] Database compacted and closed");
 	}
 	isProcessAlive(pid) {
 		try {
@@ -9555,6 +9587,10 @@ var PidStore = class PidStore {
 # Ignore all log files and runtime data
 logs/
 fifo/
+pid-db/
+*.jsonl
+*.jsonl~
+*.jsonl.lock
 *.sqlite
 *.sqlite-*
 *.log
@@ -9578,7 +9614,7 @@ fifo/
 		try {
 			const store = new PidStore(workingDir);
 			await store.init();
-			const records = store.db.query("SELECT * FROM pid_records WHERE status != 'exited' ORDER BY startedAt DESC LIMIT 1");
+			const records = store.store.find((r) => r.status !== "exited").sort((a, b) => b.startedAt - a.startedAt);
 			await store.close();
 			return records[0]?.fifoFile ?? null;
 		} catch (error) {
@@ -10734,4 +10770,4 @@ const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { AgentContext as a, config as i, CLIS_CONFIG as n, PidStore as o, agentYes as r, removeControlCharacters as s, SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-I-XMBksk.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-Db5tikbx.js.map

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { c as __toESM, i as __commonJSMin, r as require_ms, t as logger } from "./logger-DH1Rx9HI.js";
 import "./agent-yes.config-Dr2p5kBW.js";
-import { o as PidStore, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-I-XMBksk.js";
+import { o as PidStore, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Db5tikbx.js";
 import { createRequire } from "node:module";
 import { argv } from "process";
 import { spawn } from "child_process";
@@ -4505,7 +4505,7 @@ const Yargs = YargsFactory(esm_default);
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.53.1";
+var version = "1.54.0";
 
 //#endregion
 //#region ts/parseCliArgs.ts

package/dist/index.js

@@ -1,4 +1,4 @@
 import "./logger-DH1Rx9HI.js";
-import { a as AgentContext, i as config, n as CLIS_CONFIG, r as agentYes, s as removeControlCharacters } from "./SUPPORTED_CLIS-I-XMBksk.js";
+import { a as AgentContext, i as config, n as CLIS_CONFIG, r as agentYes, s as removeControlCharacters } from "./SUPPORTED_CLIS-Db5tikbx.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.53.1",
+  "version": "1.54.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -83,9 +83,9 @@
   },
   "dependencies": {
     "@snomiao/bun-pty": "^0.3.4",
-    "@snomiao/keyv-sqlite": "^5.0.4",
     "bun-pty": "^0.4.8",
     "from-node-stream": "^0.1.2",
+    "proper-lockfile": "^4.1.2",
     "yaml": "^2.8.2"
   },
   "devDependencies": {
@@ -95,6 +95,7 @@
     "@types/jest": "^30.0.0",
     "@types/ms": "^2.1.0",
     "@types/node": "^25.0.10",
+    "@types/proper-lockfile": "^4.1.4",
     "@types/yargs": "^17.0.35",
     "@typescript/native-preview": "^7.0.0-dev.20260124.1",
     "execa": "^9.6.1",