claude-yes 1.34.0 → 1.35.0

package/dist/cli.js

@@ -20732,24 +20732,81 @@ var init_fifo = __esm(() => {
 });
 
 // ts/pidStore.ts
-import Datastore from "@seald-io/nedb";
 import { mkdir as mkdir3 } from "fs/promises";
 import path9 from "path";
 
+class SqliteAdapter {
+  db;
+  async init(dbPath) {
+    if (typeof globalThis.Bun !== "undefined") {
+      try {
+        const { Database } = await import("bun:sqlite");
+        this.db = new Database(dbPath);
+      } catch (error) {
+        logger.warn("[pidStore] bun:sqlite not available, falling back to better-sqlite3");
+        const Database = (await import("better-sqlite3")).default;
+        this.db = new Database(dbPath);
+      }
+    } else {
+      const Database = (await import("better-sqlite3")).default;
+      this.db = new Database(dbPath);
+    }
+  }
+  query(sql, params = []) {
+    if (typeof this.db.prepare === "function") {
+      return this.db.prepare(sql).all(params);
+    } else {
+      return this.db.query(sql).all(params);
+    }
+  }
+  run(sql, params = []) {
+    if (typeof this.db.prepare === "function") {
+      return this.db.prepare(sql).run(params);
+    } else {
+      this.db.run(sql, params);
+      return {};
+    }
+  }
+  close() {
+    if (this.db.close) {
+      this.db.close();
+    }
+  }
+}
+
 class PidStore {
   db;
   baseDir;
+  dbPath;
   constructor(workingDir) {
     this.baseDir = path9.resolve(workingDir, ".agent-yes");
+    this.dbPath = path9.join(this.baseDir, "pid.sqlite");
   }
   async init() {
     await mkdir3(path9.join(this.baseDir, "logs"), { recursive: true });
     await mkdir3(path9.join(this.baseDir, "fifo"), { recursive: true });
-    this.db = new Datastore({
-      filename: path9.join(this.baseDir, "pid.jsonl"),
-      autoload: true
-    });
-    await this.db.loadDatabaseAsync();
+    this.db = new SqliteAdapter;
+    await this.db.init(this.dbPath);
+    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,
+        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
+      )
+    `);
     await this.cleanStaleRecords();
   }
   async registerProcess({
@@ -20759,29 +20816,43 @@ class PidStore {
     prompt
   }) {
     const now = Date.now();
-    const record = {
-      pid,
-      cli,
-      args,
-      prompt,
-      logFile: this.getLogPath(pid),
-      fifoFile: this.getFifoPath(pid),
-      status: "active",
-      exitReason: "",
-      startedAt: now,
-      updatedAt: now
-    };
-    await this.db.insertAsync(record);
+    const argsJson = JSON.stringify(args);
+    const logFile = this.getLogPath(pid);
+    const fifoFile = this.getFifoPath(pid);
+    try {
+      this.db.run(`
+        INSERT INTO pid_records (pid, cli, args, prompt, logFile, fifoFile, status, exitReason, startedAt, updatedAt)
+        VALUES (?, ?, ?, ?, ?, ?, 'active', '', ?, ?)
+      `, [pid, cli, argsJson, prompt, logFile, fifoFile, now, now]);
+    } catch (error) {
+      if (error.code === "SQLITE_CONSTRAINT_UNIQUE") {
+        this.db.run(`
+          UPDATE pid_records
+          SET cli = ?, args = ?, prompt = ?, logFile = ?, fifoFile = ?, status = 'active', exitReason = '', startedAt = ?, updatedAt = ?
+          WHERE pid = ?
+        `, [cli, argsJson, prompt, logFile, fifoFile, now, now, pid]);
+      } else {
+        throw error;
+      }
+    }
+    const result = this.db.query("SELECT * FROM pid_records WHERE pid = ?", [pid])[0];
+    if (!result) {
+      const allRecords = this.db.query("SELECT * FROM pid_records");
+      logger.error(`[pidStore] Failed to find record for PID ${pid}. All records:`, allRecords);
+      throw new Error(`Failed to register process ${pid}`);
+    }
     logger.debug(`[pidStore] Registered process ${pid}`);
-    return record;
+    return result;
   }
   async updateStatus(pid, status, extra) {
-    const update2 = {
-      status,
-      updatedAt: Date.now(),
-      ...extra
-    };
-    await this.db.updateAsync({ pid }, { $set: update2 }, {});
+    const updatedAt = Date.now();
+    const exitReason = extra?.exitReason || "";
+    const exitCode = extra?.exitCode;
+    if (exitCode !== undefined) {
+      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]);
+    }
     logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
   }
   getLogPath(pid) {
@@ -20791,25 +20862,23 @@ class PidStore {
     return path9.resolve(this.baseDir, "fifo", `${pid}.stdin`);
   }
   async cleanStaleRecords() {
-    const activeRecords = await this.db.findAsync({
-      status: { $ne: "exited" }
-    });
+    const activeRecords = this.db.query("SELECT * FROM pid_records WHERE status != 'exited'");
     for (const record of activeRecords) {
       if (!this.isProcessAlive(record.pid)) {
-        await this.db.updateAsync({ pid: record.pid }, {
-          $set: {
-            status: "exited",
-            exitReason: "stale-cleanup",
-            updatedAt: Date.now()
-          }
-        }, {});
+        this.db.run("UPDATE pid_records SET status = 'exited', exitReason = 'stale-cleanup', updatedAt = ? WHERE pid = ?", [Date.now(), record.pid]);
         logger.debug(`[pidStore] Cleaned stale record for PID ${record.pid}`);
       }
     }
   }
   async close() {
-    await this.db.compactDatafileAsync();
-    logger.debug("[pidStore] Database compacted and closed");
+    try {
+      this.db.run("PRAGMA optimize");
+      this.db.run("VACUUM");
+    } catch (error) {
+      logger.warn("[pidStore] Failed to optimize database:", error);
+    }
+    this.db.close();
+    logger.debug("[pidStore] Database optimized and closed");
   }
   isProcessAlive(pid) {
     try {
@@ -20822,10 +20891,9 @@ class PidStore {
   static async findActiveFifo(workingDir) {
     const store = new PidStore(workingDir);
     await store.init();
-    const records = await store.db.findAsync({ status: { $ne: "exited" } });
+    const records = store.db.query("SELECT * FROM pid_records WHERE status != 'exited' ORDER BY startedAt DESC LIMIT 1");
     await store.close();
-    const sorted = records.sort((a2, b) => b.startedAt - a2.startedAt);
-    return sorted[0]?.fifoFile ?? null;
+    return records[0]?.fifoFile ?? null;
   }
 }
 var init_pidStore = __esm(() => {
@@ -27688,7 +27756,7 @@ var package_default = {
     registry: "https://registry.npmjs.org/"
   },
   scripts: {
-    build: "bun build ./ts/cli.ts ./ts/index.ts --outdir=dist --target=node --sourcemap --external=@seald-io/nedb --external=@snomiao/bun-pty --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
+    build: "bun build ./ts/cli.ts ./ts/index.ts --outdir=dist --target=node --sourcemap --external=better-sqlite3 --external=@snomiao/bun-pty --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
     postbuild: "bun ./ts/postbuild.ts",
     demo: "bun run build && bun link && claude-yes -- demo",
     dev: "bun ts/index.ts",
@@ -27700,9 +27768,9 @@ var package_default = {
     test: "bun test --coverage"
   },
   dependencies: {
-    "@seald-io/nedb": "^4.0.4",
     "@snomiao/bun-pty": "^0.3.4",
     "bun-pty": "^0.4.8",
+    "better-sqlite3": "^12.1.0",
     "from-node-stream": "^0.1.2"
   },
   devDependencies: {
@@ -27714,6 +27782,7 @@ var package_default = {
     "@types/bun": "^1.3.6",
     "@types/jest": "^30.0.0",
     "@types/ms": "^2.1.0",
+    "@types/better-sqlite3": "^7.6.12",
     "@types/node": "^25.0.10",
     "@types/yargs": "^17.0.35",
     "cpu-wait": "^0.0.10",
@@ -27924,24 +27993,81 @@ var logger2 = import_winston3.default.createLogger({
 
 // ts/pidStore.ts
 init_logger();
-import Datastore2 from "@seald-io/nedb";
 import { mkdir as mkdir6 } from "fs/promises";
 import path12 from "path";
 
+class SqliteAdapter2 {
+  db;
+  async init(dbPath) {
+    if (typeof globalThis.Bun !== "undefined") {
+      try {
+        const { Database } = await import("bun:sqlite");
+        this.db = new Database(dbPath);
+      } catch (error) {
+        logger.warn("[pidStore] bun:sqlite not available, falling back to better-sqlite3");
+        const Database = (await import("better-sqlite3")).default;
+        this.db = new Database(dbPath);
+      }
+    } else {
+      const Database = (await import("better-sqlite3")).default;
+      this.db = new Database(dbPath);
+    }
+  }
+  query(sql, params = []) {
+    if (typeof this.db.prepare === "function") {
+      return this.db.prepare(sql).all(params);
+    } else {
+      return this.db.query(sql).all(params);
+    }
+  }
+  run(sql, params = []) {
+    if (typeof this.db.prepare === "function") {
+      return this.db.prepare(sql).run(params);
+    } else {
+      this.db.run(sql, params);
+      return {};
+    }
+  }
+  close() {
+    if (this.db.close) {
+      this.db.close();
+    }
+  }
+}
+
 class PidStore2 {
   db;
   baseDir;
+  dbPath;
   constructor(workingDir) {
     this.baseDir = path12.resolve(workingDir, ".agent-yes");
+    this.dbPath = path12.join(this.baseDir, "pid.sqlite");
   }
   async init() {
     await mkdir6(path12.join(this.baseDir, "logs"), { recursive: true });
     await mkdir6(path12.join(this.baseDir, "fifo"), { recursive: true });
-    this.db = new Datastore2({
-      filename: path12.join(this.baseDir, "pid.jsonl"),
-      autoload: true
-    });
-    await this.db.loadDatabaseAsync();
+    this.db = new SqliteAdapter2;
+    await this.db.init(this.dbPath);
+    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,
+        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
+      )
+    `);
     await this.cleanStaleRecords();
   }
   async registerProcess({
@@ -27951,29 +28077,43 @@ class PidStore2 {
     prompt
   }) {
     const now = Date.now();
-    const record = {
-      pid,
-      cli,
-      args,
-      prompt,
-      logFile: this.getLogPath(pid),
-      fifoFile: this.getFifoPath(pid),
-      status: "active",
-      exitReason: "",
-      startedAt: now,
-      updatedAt: now
-    };
-    await this.db.insertAsync(record);
+    const argsJson = JSON.stringify(args);
+    const logFile = this.getLogPath(pid);
+    const fifoFile = this.getFifoPath(pid);
+    try {
+      this.db.run(`
+        INSERT INTO pid_records (pid, cli, args, prompt, logFile, fifoFile, status, exitReason, startedAt, updatedAt)
+        VALUES (?, ?, ?, ?, ?, ?, 'active', '', ?, ?)
+      `, [pid, cli, argsJson, prompt, logFile, fifoFile, now, now]);
+    } catch (error) {
+      if (error.code === "SQLITE_CONSTRAINT_UNIQUE") {
+        this.db.run(`
+          UPDATE pid_records
+          SET cli = ?, args = ?, prompt = ?, logFile = ?, fifoFile = ?, status = 'active', exitReason = '', startedAt = ?, updatedAt = ?
+          WHERE pid = ?
+        `, [cli, argsJson, prompt, logFile, fifoFile, now, now, pid]);
+      } else {
+        throw error;
+      }
+    }
+    const result = this.db.query("SELECT * FROM pid_records WHERE pid = ?", [pid])[0];
+    if (!result) {
+      const allRecords = this.db.query("SELECT * FROM pid_records");
+      logger.error(`[pidStore] Failed to find record for PID ${pid}. All records:`, allRecords);
+      throw new Error(`Failed to register process ${pid}`);
+    }
     logger.debug(`[pidStore] Registered process ${pid}`);
-    return record;
+    return result;
   }
   async updateStatus(pid, status, extra) {
-    const update2 = {
-      status,
-      updatedAt: Date.now(),
-      ...extra
-    };
-    await this.db.updateAsync({ pid }, { $set: update2 }, {});
+    const updatedAt = Date.now();
+    const exitReason = extra?.exitReason || "";
+    const exitCode = extra?.exitCode;
+    if (exitCode !== undefined) {
+      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]);
+    }
     logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
   }
   getLogPath(pid) {
@@ -27983,25 +28123,23 @@ class PidStore2 {
     return path12.resolve(this.baseDir, "fifo", `${pid}.stdin`);
   }
   async cleanStaleRecords() {
-    const activeRecords = await this.db.findAsync({
-      status: { $ne: "exited" }
-    });
+    const activeRecords = this.db.query("SELECT * FROM pid_records WHERE status != 'exited'");
     for (const record of activeRecords) {
       if (!this.isProcessAlive(record.pid)) {
-        await this.db.updateAsync({ pid: record.pid }, {
-          $set: {
-            status: "exited",
-            exitReason: "stale-cleanup",
-            updatedAt: Date.now()
-          }
-        }, {});
+        this.db.run("UPDATE pid_records SET status = 'exited', exitReason = 'stale-cleanup', updatedAt = ? WHERE pid = ?", [Date.now(), record.pid]);
         logger.debug(`[pidStore] Cleaned stale record for PID ${record.pid}`);
       }
     }
   }
   async close() {
-    await this.db.compactDatafileAsync();
-    logger.debug("[pidStore] Database compacted and closed");
+    try {
+      this.db.run("PRAGMA optimize");
+      this.db.run("VACUUM");
+    } catch (error) {
+      logger.warn("[pidStore] Failed to optimize database:", error);
+    }
+    this.db.close();
+    logger.debug("[pidStore] Database optimized and closed");
   }
   isProcessAlive(pid) {
     try {
@@ -28014,10 +28152,9 @@ class PidStore2 {
   static async findActiveFifo(workingDir) {
     const store = new PidStore2(workingDir);
     await store.init();
-    const records = await store.db.findAsync({ status: { $ne: "exited" } });
+    const records = store.db.query("SELECT * FROM pid_records WHERE status != 'exited' ORDER BY startedAt DESC LIMIT 1");
     await store.close();
-    const sorted = records.sort((a2, b) => b.startedAt - a2.startedAt);
-    return sorted[0]?.fifoFile ?? null;
+    return records[0]?.fifoFile ?? null;
   }
 }
 
@@ -28050,5 +28187,5 @@ var { exitCode } = await cliYes(config3);
 console.log("exiting process");
 process.exit(exitCode ?? 1);
 
-//# debugId=12710EC867DEB2CA64756E2164756E21
+//# debugId=C4007A87ED18C3B264756E2164756E21
 //# sourceMappingURL=cli.js.map

package/dist/index.js

@@ -20730,24 +20730,81 @@ var init_fifo = __esm(() => {
 });
 
 // ts/pidStore.ts
-import Datastore from "@seald-io/nedb";
 import { mkdir as mkdir3 } from "fs/promises";
 import path9 from "path";
 
+class SqliteAdapter {
+  db;
+  async init(dbPath) {
+    if (typeof globalThis.Bun !== "undefined") {
+      try {
+        const { Database } = await import("bun:sqlite");
+        this.db = new Database(dbPath);
+      } catch (error) {
+        logger.warn("[pidStore] bun:sqlite not available, falling back to better-sqlite3");
+        const Database = (await import("better-sqlite3")).default;
+        this.db = new Database(dbPath);
+      }
+    } else {
+      const Database = (await import("better-sqlite3")).default;
+      this.db = new Database(dbPath);
+    }
+  }
+  query(sql, params = []) {
+    if (typeof this.db.prepare === "function") {
+      return this.db.prepare(sql).all(params);
+    } else {
+      return this.db.query(sql).all(params);
+    }
+  }
+  run(sql, params = []) {
+    if (typeof this.db.prepare === "function") {
+      return this.db.prepare(sql).run(params);
+    } else {
+      this.db.run(sql, params);
+      return {};
+    }
+  }
+  close() {
+    if (this.db.close) {
+      this.db.close();
+    }
+  }
+}
+
 class PidStore {
   db;
   baseDir;
+  dbPath;
   constructor(workingDir) {
     this.baseDir = path9.resolve(workingDir, ".agent-yes");
+    this.dbPath = path9.join(this.baseDir, "pid.sqlite");
   }
   async init() {
     await mkdir3(path9.join(this.baseDir, "logs"), { recursive: true });
     await mkdir3(path9.join(this.baseDir, "fifo"), { recursive: true });
-    this.db = new Datastore({
-      filename: path9.join(this.baseDir, "pid.jsonl"),
-      autoload: true
-    });
-    await this.db.loadDatabaseAsync();
+    this.db = new SqliteAdapter;
+    await this.db.init(this.dbPath);
+    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,
+        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
+      )
+    `);
     await this.cleanStaleRecords();
   }
   async registerProcess({
@@ -20757,29 +20814,43 @@ class PidStore {
     prompt
   }) {
     const now = Date.now();
-    const record = {
-      pid,
-      cli,
-      args,
-      prompt,
-      logFile: this.getLogPath(pid),
-      fifoFile: this.getFifoPath(pid),
-      status: "active",
-      exitReason: "",
-      startedAt: now,
-      updatedAt: now
-    };
-    await this.db.insertAsync(record);
+    const argsJson = JSON.stringify(args);
+    const logFile = this.getLogPath(pid);
+    const fifoFile = this.getFifoPath(pid);
+    try {
+      this.db.run(`
+        INSERT INTO pid_records (pid, cli, args, prompt, logFile, fifoFile, status, exitReason, startedAt, updatedAt)
+        VALUES (?, ?, ?, ?, ?, ?, 'active', '', ?, ?)
+      `, [pid, cli, argsJson, prompt, logFile, fifoFile, now, now]);
+    } catch (error) {
+      if (error.code === "SQLITE_CONSTRAINT_UNIQUE") {
+        this.db.run(`
+          UPDATE pid_records
+          SET cli = ?, args = ?, prompt = ?, logFile = ?, fifoFile = ?, status = 'active', exitReason = '', startedAt = ?, updatedAt = ?
+          WHERE pid = ?
+        `, [cli, argsJson, prompt, logFile, fifoFile, now, now, pid]);
+      } else {
+        throw error;
+      }
+    }
+    const result = this.db.query("SELECT * FROM pid_records WHERE pid = ?", [pid])[0];
+    if (!result) {
+      const allRecords = this.db.query("SELECT * FROM pid_records");
+      logger.error(`[pidStore] Failed to find record for PID ${pid}. All records:`, allRecords);
+      throw new Error(`Failed to register process ${pid}`);
+    }
     logger.debug(`[pidStore] Registered process ${pid}`);
-    return record;
+    return result;
   }
   async updateStatus(pid, status, extra) {
-    const update2 = {
-      status,
-      updatedAt: Date.now(),
-      ...extra
-    };
-    await this.db.updateAsync({ pid }, { $set: update2 }, {});
+    const updatedAt = Date.now();
+    const exitReason = extra?.exitReason || "";
+    const exitCode = extra?.exitCode;
+    if (exitCode !== undefined) {
+      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]);
+    }
     logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
   }
   getLogPath(pid) {
@@ -20789,25 +20860,23 @@ class PidStore {
     return path9.resolve(this.baseDir, "fifo", `${pid}.stdin`);
   }
   async cleanStaleRecords() {
-    const activeRecords = await this.db.findAsync({
-      status: { $ne: "exited" }
-    });
+    const activeRecords = this.db.query("SELECT * FROM pid_records WHERE status != 'exited'");
     for (const record of activeRecords) {
       if (!this.isProcessAlive(record.pid)) {
-        await this.db.updateAsync({ pid: record.pid }, {
-          $set: {
-            status: "exited",
-            exitReason: "stale-cleanup",
-            updatedAt: Date.now()
-          }
-        }, {});
+        this.db.run("UPDATE pid_records SET status = 'exited', exitReason = 'stale-cleanup', updatedAt = ? WHERE pid = ?", [Date.now(), record.pid]);
         logger.debug(`[pidStore] Cleaned stale record for PID ${record.pid}`);
       }
     }
   }
   async close() {
-    await this.db.compactDatafileAsync();
-    logger.debug("[pidStore] Database compacted and closed");
+    try {
+      this.db.run("PRAGMA optimize");
+      this.db.run("VACUUM");
+    } catch (error) {
+      logger.warn("[pidStore] Failed to optimize database:", error);
+    }
+    this.db.close();
+    logger.debug("[pidStore] Database optimized and closed");
   }
   isProcessAlive(pid) {
     try {
@@ -20820,10 +20889,9 @@ class PidStore {
   static async findActiveFifo(workingDir) {
     const store = new PidStore(workingDir);
     await store.init();
-    const records = await store.db.findAsync({ status: { $ne: "exited" } });
+    const records = store.db.query("SELECT * FROM pid_records WHERE status != 'exited' ORDER BY startedAt DESC LIMIT 1");
     await store.close();
-    const sorted = records.sort((a2, b) => b.startedAt - a2.startedAt);
-    return sorted[0]?.fifoFile ?? null;
+    return records[0]?.fifoFile ?? null;
   }
 }
 var init_pidStore = __esm(() => {
@@ -21654,5 +21722,5 @@ export {
   CLIS_CONFIG
 };
 
-//# debugId=6BCBE693D722CAEF64756E2164756E21
+//# debugId=9A92FE5B1254037264756E2164756E21
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.34.0",
+  "version": "1.35.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -62,7 +62,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "bun build ./ts/cli.ts ./ts/index.ts --outdir=dist --target=node --sourcemap --external=@seald-io/nedb --external=@snomiao/bun-pty --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
+    "build": "bun build ./ts/cli.ts ./ts/index.ts --outdir=dist --target=node --sourcemap --external=better-sqlite3 --external=@snomiao/bun-pty --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
     "postbuild": "bun ./ts/postbuild.ts",
     "demo": "bun run build && bun link && claude-yes -- demo",
     "dev": "bun ts/index.ts",
@@ -74,8 +74,8 @@
     "test": "bun test --coverage"
   },
   "dependencies": {
-    "@seald-io/nedb": "^4.0.4",
     "@snomiao/bun-pty": "^0.3.4",
+    "better-sqlite3": "^12.1.0",
     "bun-pty": "^0.4.8",
     "from-node-stream": "^0.1.2"
   },
@@ -85,6 +85,7 @@
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/release-notes-generator": "^14.1.0",
+    "@types/better-sqlite3": "^7.6.12",
     "@types/bun": "^1.3.6",
     "@types/jest": "^30.0.0",
     "@types/ms": "^2.1.0",

package/ts/pidStore.ts

@@ -1,12 +1,12 @@
-import Datastore from "@seald-io/nedb";
 import { mkdir } from "fs/promises";
 import path from "path";
 import { logger } from "./logger.ts";
 
 export interface PidRecord {
+  id?: number;
   pid: number;
   cli: string;
-  args: string[];
+  args: string;
   prompt?: string;
   logFile: string;
   fifoFile: string;
@@ -17,23 +17,95 @@ export interface PidRecord {
   updatedAt: number;
 }
 
+// Direct SQLite implementation to avoid Kysely compatibility issues
+class SqliteAdapter {
+  private db: any;
+
+  async init(dbPath: string) {
+    if (typeof globalThis.Bun !== "undefined") {
+      try {
+        const { Database } = await import("bun:sqlite");
+        this.db = new Database(dbPath);
+      } catch (error) {
+        logger.warn("[pidStore] bun:sqlite not available, falling back to better-sqlite3");
+        const Database = (await import("better-sqlite3")).default;
+        this.db = new Database(dbPath);
+      }
+    } else {
+      const Database = (await import("better-sqlite3")).default;
+      this.db = new Database(dbPath);
+    }
+  }
+
+  query(sql: string, params: any[] = []): any[] {
+    if (typeof this.db.prepare === "function") {
+      // better-sqlite3 style
+      return this.db.prepare(sql).all(params);
+    } else {
+      // bun:sqlite style
+      return this.db.query(sql).all(params);
+    }
+  }
+
+  run(sql: string, params: any[] = []): { lastInsertRowid?: number; changes?: number } {
+    if (typeof this.db.prepare === "function") {
+      // better-sqlite3 style
+      return this.db.prepare(sql).run(params);
+    } else {
+      // bun:sqlite style
+      this.db.run(sql, params);
+      return {}; // Bun doesn't return metadata in the same way
+    }
+  }
+
+  close() {
+    if (this.db.close) {
+      this.db.close();
+    }
+  }
+}
+
 export class PidStore {
-  protected db!: Datastore<PidRecord>;
+  protected db!: SqliteAdapter;
   private baseDir: string;
+  private dbPath: string;
 
   constructor(workingDir: string) {
     this.baseDir = path.resolve(workingDir, ".agent-yes");
+    this.dbPath = path.join(this.baseDir, "pid.sqlite");
   }
 
   async init(): Promise<void> {
     await mkdir(path.join(this.baseDir, "logs"), { recursive: true });
     await mkdir(path.join(this.baseDir, "fifo"), { recursive: true });
 
-    this.db = new Datastore<PidRecord>({
-      filename: path.join(this.baseDir, "pid.jsonl"),
-      autoload: true,
-    });
-    await this.db.loadDatabaseAsync();
+    this.db = new SqliteAdapter();
+    await this.db.init(this.dbPath);
+
+    // Enable WAL mode for better concurrency and performance
+    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");
+
+    // Create table if it doesn't exist
+    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,
+        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
+      )
+    `);
+
     await this.cleanStaleRecords();
   }
 
@@ -49,21 +121,40 @@ export class PidStore {
     prompt?: string;
   }): Promise<PidRecord> {
     const now = Date.now();
-    const record: PidRecord = {
-      pid,
-      cli,
-      args,
-      prompt,
-      logFile: this.getLogPath(pid),
-      fifoFile: this.getFifoPath(pid),
-      status: "active",
-      exitReason: "",
-      startedAt: now,
-      updatedAt: now,
-    };
-    await this.db.insertAsync(record);
+    const argsJson = JSON.stringify(args);
+    const logFile = this.getLogPath(pid);
+    const fifoFile = this.getFifoPath(pid);
+
+    try {
+      this.db.run(`
+        INSERT INTO pid_records (pid, cli, args, prompt, logFile, fifoFile, status, exitReason, startedAt, updatedAt)
+        VALUES (?, ?, ?, ?, ?, ?, 'active', '', ?, ?)
+      `, [pid, cli, argsJson, prompt, logFile, fifoFile, now, now]);
+    } catch (error: any) {
+      // Handle unique constraint violation by updating existing record
+      if (error.code === "SQLITE_CONSTRAINT_UNIQUE") {
+        this.db.run(`
+          UPDATE pid_records
+          SET cli = ?, args = ?, prompt = ?, logFile = ?, fifoFile = ?, status = 'active', exitReason = '', startedAt = ?, updatedAt = ?
+          WHERE pid = ?
+        `, [cli, argsJson, prompt, logFile, fifoFile, now, now, pid]);
+      } else {
+        throw error;
+      }
+    }
+
+    // Fetch the record
+    const result = this.db.query("SELECT * FROM pid_records WHERE pid = ?", [pid])[0];
+
+    if (!result) {
+      // Log all records for debugging
+      const allRecords = this.db.query("SELECT * FROM pid_records");
+      logger.error(`[pidStore] Failed to find record for PID ${pid}. All records:`, allRecords);
+      throw new Error(`Failed to register process ${pid}`);
+    }
+
     logger.debug(`[pidStore] Registered process ${pid}`);
-    return record;
+    return result;
   }
 
   async updateStatus(
@@ -71,12 +162,22 @@ export class PidStore {
     status: PidRecord["status"],
     extra?: { exitReason?: string; exitCode?: number },
   ): Promise<void> {
-    const update: Partial<PidRecord> = {
-      status,
-      updatedAt: Date.now(),
-      ...extra,
-    };
-    await this.db.updateAsync({ pid }, { $set: update }, {});
+    const updatedAt = Date.now();
+    const exitReason = extra?.exitReason || "";
+    const exitCode = extra?.exitCode;
+
+    if (exitCode !== undefined) {
+      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]
+      );
+    }
+
     logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
   }
 
@@ -89,30 +190,31 @@ export class PidStore {
   }
 
   async cleanStaleRecords(): Promise<void> {
-    const activeRecords = await this.db.findAsync({
-      status: { $ne: "exited" } as any,
-    });
+    const activeRecords = this.db.query("SELECT * FROM pid_records WHERE status != 'exited'");
+
     for (const record of activeRecords) {
       if (!this.isProcessAlive(record.pid)) {
-        await this.db.updateAsync(
-          { pid: record.pid },
-          {
-            $set: {
-              status: "exited" as const,
-              exitReason: "stale-cleanup",
-              updatedAt: Date.now(),
-            },
-          },
-          {},
+        this.db.run(
+          "UPDATE pid_records SET status = 'exited', exitReason = 'stale-cleanup', updatedAt = ? WHERE pid = ?",
+          [Date.now(), record.pid]
         );
+
         logger.debug(`[pidStore] Cleaned stale record for PID ${record.pid}`);
       }
     }
   }
 
   async close(): Promise<void> {
-    await this.db.compactDatafileAsync();
-    logger.debug("[pidStore] Database compacted and closed");
+    // Optimize the database (equivalent to compacting in nedb)
+    try {
+      this.db.run("PRAGMA optimize");
+      this.db.run("VACUUM");
+    } catch (error) {
+      logger.warn("[pidStore] Failed to optimize database:", error);
+    }
+
+    this.db.close();
+    logger.debug("[pidStore] Database optimized and closed");
   }
 
   private isProcessAlive(pid: number): boolean {
@@ -127,9 +229,12 @@ export class PidStore {
   static async findActiveFifo(workingDir: string): Promise<string | null> {
     const store = new PidStore(workingDir);
     await store.init();
-    const records = await store.db.findAsync({ status: { $ne: "exited" } as any });
+
+    const records = store.db.query(
+      "SELECT * FROM pid_records WHERE status != 'exited' ORDER BY startedAt DESC LIMIT 1"
+    );
+
     await store.close();
-    const sorted = records.sort((a, b) => b.startedAt - a.startedAt);
-    return sorted[0]?.fifoFile ?? null;
+    return records[0]?.fifoFile ?? null;
   }
-}
+}