@dbcube/core 5.1.12 → 5.1.15

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   Binary: () => Binary,
   ComputedFieldProcessor: () => ComputedFieldProcessor,
   Config: () => Config,
+  DaemonClient: () => DaemonClient,
   DbConfig: () => DbConfig,
   Engine: () => Engine,
   FileLogger: () => FileLogger,
@@ -44,7 +45,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/Engine.ts
-var import_path3 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 
 // src/lib/Arquitecture.ts
 var os = __toESM(require("os"));
@@ -734,14 +735,216 @@ var Config = class {
 };
 
 // src/lib/Engine.ts
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 var import_module = require("module");
+
+// src/lib/DaemonClient.ts
+var import_net = __toESM(require("net"));
+var import_fs = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_child_process = require("child_process");
+var DaemonClient = class _DaemonClient {
+  static registry = /* @__PURE__ */ new Map();
+  name;
+  binaryPath;
+  engineArgs;
+  socket = null;
+  buffer = "";
+  pending = [];
+  starting = null;
+  requestTimeout;
+  constructor(name, binaryPath, engineArgs, requestTimeout = 3e4) {
+    this.name = name;
+    this.binaryPath = binaryPath;
+    this.engineArgs = engineArgs;
+    this.requestTimeout = requestTimeout;
+  }
+  static get(name, binaryPath, engineArgs) {
+    let client = this.registry.get(name);
+    if (!client) {
+      client = new _DaemonClient(name, binaryPath, engineArgs);
+      this.registry.set(name, client);
+    }
+    return client;
+  }
+  static isEnabled() {
+    const flag = process.env.DBCUBE_DAEMON;
+    if (flag === "0" || flag === "false") return false;
+    return true;
+  }
+  portfilePath() {
+    return import_path3.default.join(process.cwd(), ".dbcube", "daemon", `${this.name}.json`);
+  }
+  /**
+   * Ensures a usable daemon connection. Returns false when the daemon
+   * can't be used (old binary, startup failure) so callers fall back
+   * to one-shot spawn mode.
+   */
+  async ensure() {
+    if (this.socket && !this.socket.destroyed) return true;
+    if (this.starting) return this.starting;
+    this.starting = this.connectOrStart().catch(() => false);
+    const result = await this.starting;
+    this.starting = null;
+    return result;
+  }
+  async connectOrStart() {
+    const port = this.readPortfile();
+    if (port && await this.tryConnect(port)) return true;
+    try {
+      import_fs.default.unlinkSync(this.portfilePath());
+    } catch {
+    }
+    this.spawnDaemon();
+    const deadline = Date.now() + 1e4;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 150));
+      const newPort = this.readPortfile();
+      if (newPort && await this.tryConnect(newPort)) return true;
+    }
+    return false;
+  }
+  readPortfile() {
+    try {
+      const raw = import_fs.default.readFileSync(this.portfilePath(), "utf8");
+      const info = JSON.parse(raw);
+      return typeof info.port === "number" ? info.port : null;
+    } catch {
+      return null;
+    }
+  }
+  spawnDaemon() {
+    const child = (0, import_child_process.spawn)(this.binaryPath, [...this.engineArgs, "--action", "server", "--tcp-port", "9944"], {
+      detached: true,
+      stdio: "ignore",
+      cwd: process.cwd()
+    });
+    child.unref();
+  }
+  tryConnect(port) {
+    return new Promise((resolve5) => {
+      const socket = import_net.default.createConnection({ host: "127.0.0.1", port }, async () => {
+        socket.setNoDelay(true);
+        this.attach(socket);
+        try {
+          const pong = await this.send({ action: "ping" });
+          resolve5(pong.status === 200);
+        } catch {
+          this.detach();
+          resolve5(false);
+        }
+      });
+      socket.once("error", () => resolve5(false));
+      socket.setTimeout(3e3, () => {
+        socket.destroy();
+        resolve5(false);
+      });
+    });
+  }
+  attach(socket) {
+    this.socket = socket;
+    this.buffer = "";
+    socket.setTimeout(0);
+    socket.on("data", (chunk) => this.onData(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    socket.on("close", () => this.detach());
+    socket.on("error", () => this.detach());
+  }
+  detach() {
+    if (this.socket) {
+      this.socket.removeAllListeners();
+      this.socket.destroy();
+      this.socket = null;
+    }
+    for (const req of this.pending.splice(0)) {
+      clearTimeout(req.timer);
+      req.reject(new Error("Daemon connection lost"));
+    }
+  }
+  onData(chunk) {
+    this.buffer += chunk.toString("utf8");
+    let idx;
+    while ((idx = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, idx).trim();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (!line) continue;
+      const marker = line.indexOf("PROCESS_RESPONSE:");
+      if (marker === -1) continue;
+      const jsonPart = line.slice(marker + "PROCESS_RESPONSE:".length);
+      const req = this.pending.shift();
+      if (!req) continue;
+      clearTimeout(req.timer);
+      try {
+        req.resolve(JSON.parse(jsonPart));
+      } catch (e) {
+        req.reject(new Error(`Invalid daemon response: ${e.message}`));
+      }
+    }
+  }
+  /**
+   * Sends a request to the daemon. Responses arrive in FIFO order on the
+   * single socket, so pending requests resolve in send order.
+   */
+  send(payload) {
+    return new Promise((resolve5, reject) => {
+      if (!this.socket || this.socket.destroyed) {
+        reject(new Error("Daemon not connected"));
+        return;
+      }
+      const timer = setTimeout(() => {
+        const i = this.pending.findIndex((p) => p.timer === timer);
+        if (i !== -1) this.pending.splice(i, 1);
+        reject(new Error("Daemon request timeout"));
+      }, this.requestTimeout);
+      this.pending.push({ resolve: resolve5, reject, timer });
+      this.socket.write(JSON.stringify(payload) + "\n");
+    });
+  }
+  async execute(dml, txId) {
+    const payload = { action: "execute", dml: JSON.stringify(dml) };
+    if (txId) payload.tx_id = txId;
+    return this.send(payload);
+  }
+  async raw(query, params = [], txId) {
+    const payload = { action: "raw", query, params };
+    if (txId) payload.tx_id = txId;
+    return this.send(payload);
+  }
+  async begin() {
+    const res = await this.send({ action: "begin" });
+    if (res.status !== 200 || !res.data?.tx_id) {
+      throw new Error(res.message || "Failed to begin transaction");
+    }
+    return res.data.tx_id;
+  }
+  async commit(txId) {
+    const res = await this.send({ action: "commit", tx_id: txId });
+    if (res.status !== 200) throw new Error(res.message || "Failed to commit transaction");
+  }
+  async rollback(txId) {
+    const res = await this.send({ action: "rollback", tx_id: txId });
+    if (res.status !== 200) throw new Error(res.message || "Failed to rollback transaction");
+  }
+  async shutdown() {
+    try {
+      await this.send({ action: "shutdown" });
+    } catch {
+    }
+    this.detach();
+    try {
+      import_fs.default.unlinkSync(this.portfilePath());
+    } catch {
+    }
+  }
+};
+
+// src/lib/Engine.ts
 var Engine = class {
   name;
   config;
   arguments;
   binary = null;
   timeout;
+  daemonFailed = false;
   constructor(name, timeout = 3e4) {
     this.name = name;
     this.config = this.setConfig(name);
@@ -753,6 +956,77 @@ var Engine = class {
       this.binary = await Binary.get();
     }
   }
+  /**
+   * Returns a connected DaemonClient for this database, or null when
+   * daemon mode is disabled/unavailable (then callers use spawn mode).
+   */
+  async getDaemon() {
+    if (this.daemonFailed || !DaemonClient.isEnabled()) return null;
+    await this.initializeBinary();
+    if (!this.binary) return null;
+    const binaryPath = this.binary["query_engine"];
+    if (!binaryPath) return null;
+    const client = DaemonClient.get(this.name, binaryPath, this.arguments);
+    const ok = await client.ensure();
+    if (!ok) {
+      this.daemonFailed = true;
+      return null;
+    }
+    return client;
+  }
+  /**
+   * Executes a DML plan. Uses the persistent daemon (sub-millisecond
+   * overhead) when available; falls back to one-shot spawn otherwise.
+   */
+  async executeDml(dml, txId) {
+    const daemon = await this.getDaemon();
+    if (daemon) {
+      try {
+        return await daemon.execute(dml, txId);
+      } catch (error) {
+        if (txId) throw error;
+      }
+    }
+    if (txId) {
+      throw new Error("Transactions require daemon mode. Make sure the query-engine binary is up to date (npx dbcube update).");
+    }
+    return this.run("query_engine", ["--action", "execute", "--dml", JSON.stringify(dml)]);
+  }
+  /**
+   * Executes raw SQL (or a MongoDB command document) with bound parameters.
+   */
+  async rawQuery(query, params = [], txId) {
+    const daemon = await this.getDaemon();
+    if (daemon) {
+      try {
+        return await daemon.raw(query, params, txId);
+      } catch (error) {
+        if (txId) throw error;
+      }
+    }
+    if (txId) {
+      throw new Error("Transactions require daemon mode. Make sure the query-engine binary is up to date (npx dbcube update).");
+    }
+    return this.run("query_engine", ["--action", "raw", "--query", query, "--params", JSON.stringify(params)]);
+  }
+  /** Starts a transaction (daemon mode only). Returns the transaction id. */
+  async beginTransaction() {
+    const daemon = await this.getDaemon();
+    if (!daemon) {
+      throw new Error("Transactions require daemon mode. Make sure the query-engine binary is up to date (npx dbcube update).");
+    }
+    return daemon.begin();
+  }
+  async commitTransaction(txId) {
+    const daemon = await this.getDaemon();
+    if (!daemon) throw new Error("Daemon connection lost during transaction");
+    return daemon.commit(txId);
+  }
+  async rollbackTransaction(txId) {
+    const daemon = await this.getDaemon();
+    if (!daemon) throw new Error("Daemon connection lost during transaction");
+    return daemon.rollback(txId);
+  }
   setArguments() {
     let args = [];
     if (this.config.type == "sqlite") {
@@ -791,7 +1065,7 @@ var Engine = class {
   setConfig(name) {
     const configInstance = new Config();
     try {
-      const configFilePath = import_path3.default.resolve(process.cwd(), "dbcube.config.js");
+      const configFilePath = import_path4.default.resolve(process.cwd(), "dbcube.config.js");
       const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
       const require2 = (0, import_module.createRequire)(requireUrl);
       if (require2.cache && require2.resolve) {
@@ -824,7 +1098,7 @@ var Engine = class {
       throw new Error("Binary not initialized");
     }
     return new Promise((resolve5, reject) => {
-      const child = (0, import_child_process.spawn)(this.binary[binary], [...this.arguments, ...args]);
+      const child = (0, import_child_process2.spawn)(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
       let isResolved = false;
@@ -910,10 +1184,10 @@ var Engine = class {
 };
 
 // src/lib/QueryEngine.ts
-var import_path4 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 var import_module2 = require("module");
-var net = __toESM(require("net"));
-var import_child_process2 = require("child_process");
+var net2 = __toESM(require("net"));
+var import_child_process3 = require("child_process");
 var globalTcpServers = /* @__PURE__ */ new Map();
 var globalTcpConnections = /* @__PURE__ */ new Map();
 var connectionQueues = /* @__PURE__ */ new Map();
@@ -950,7 +1224,7 @@ var QueryEngine = class {
   }
   isPortAvailable(port) {
     return new Promise((resolve5) => {
-      const tester = net.createServer();
+      const tester = net2.createServer();
       tester.once("error", () => resolve5(false));
       tester.once("listening", () => {
         tester.close();
@@ -1002,7 +1276,7 @@ var QueryEngine = class {
   setConfig(name) {
     const configInstance = new Config();
     try {
-      const configFilePath = import_path4.default.resolve(process.cwd(), "dbcube.config.js");
+      const configFilePath = import_path5.default.resolve(process.cwd(), "dbcube.config.js");
       const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
       const require2 = (0, import_module2.createRequire)(requireUrl);
       if (require2.cache && require2.resolve) {
@@ -1064,7 +1338,7 @@ var QueryEngine = class {
   }
   async isServerResponding(port) {
     return new Promise((resolve5) => {
-      const client = new net.Socket();
+      const client = new net2.Socket();
       const timeout = setTimeout(() => {
         client.destroy();
         resolve5(false);
@@ -1102,7 +1376,7 @@ var QueryEngine = class {
     this.tcpPort = await this.findAvailablePort(this.tcpPort);
     return new Promise((resolve5, reject) => {
       const serverArgs = [...this.arguments, "--action", "server", "--tcp-port", this.tcpPort.toString()];
-      const serverProcess = (0, import_child_process2.spawn)(this.binary["query_engine"], serverArgs);
+      const serverProcess = (0, import_child_process3.spawn)(this.binary["query_engine"], serverArgs);
       let started = false;
       const timeout = setTimeout(() => {
         if (!started) {
@@ -1185,7 +1459,7 @@ var QueryEngine = class {
   }
   async createNewConnection(port) {
     return new Promise((resolve5, reject) => {
-      const client = new net.Socket();
+      const client = new net2.Socket();
       client.setNoDelay(true);
       client.setKeepAlive(true, 6e4);
       const timeout = setTimeout(() => {
@@ -1262,7 +1536,7 @@ var QueryEngine = class {
       throw new Error("Binary not initialized");
     }
     return new Promise((resolve5, reject) => {
-      const child = (0, import_child_process2.spawn)(this.binary[binary], [...this.arguments, ...args]);
+      const child = (0, import_child_process3.spawn)(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
       let isResolved = false;
@@ -1369,15 +1643,15 @@ var QueryEngine = class {
 };
 
 // src/lib/SqliteExecutor.ts
-var import_child_process3 = require("child_process");
-var path5 = __toESM(require("path"));
-var fs3 = __toESM(require("fs"));
+var import_child_process4 = require("child_process");
+var path6 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
 var import_util = require("util");
 var import_module3 = require("module");
 var import_url3 = require("url");
-var import_path5 = require("path");
+var import_path6 = require("path");
 var import_meta3 = {};
-var execAsync = (0, import_util.promisify)(import_child_process3.exec);
+var execAsync = (0, import_util.promisify)(import_child_process4.exec);
 var SqliteExecutor = class {
   binaryPath;
   dbPath;
@@ -1387,13 +1661,13 @@ var SqliteExecutor = class {
   }
   findVersionedBinary(binDir, platform2) {
     try {
-      const files = fs3.readdirSync(binDir);
+      const files = fs4.readdirSync(binDir);
       const extension = platform2 === "win32" ? ".exe" : "";
       const platformName = platform2 === "win32" ? "windows" : platform2 === "darwin" ? "macos" : "linux";
       const pattern = new RegExp(`^sqlite-engine-v\\d+\\.\\d+\\.\\d+-${platformName}-x64${extension.replace(".", "\\.")}$`);
       const matchingFile = files.find((f) => pattern.test(f));
       if (matchingFile) {
-        return path5.join(binDir, matchingFile);
+        return path6.join(binDir, matchingFile);
       }
     } catch (error) {
     }
@@ -1401,36 +1675,36 @@ var SqliteExecutor = class {
   }
   getBinaryPath() {
     const __filename2 = typeof import_meta3 !== "undefined" && import_meta3.url ? (0, import_url3.fileURLToPath)(import_meta3.url) : "";
-    const __dirname = __filename2 ? (0, import_path5.dirname)(__filename2) : process.cwd();
+    const __dirname = __filename2 ? (0, import_path6.dirname)(__filename2) : process.cwd();
     const possibleDirs = [
-      path5.resolve(process.cwd(), ".dbcube", "bin"),
-      path5.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
-      path5.resolve(__dirname, "..", "bin")
+      path6.resolve(process.cwd(), ".dbcube", "bin"),
+      path6.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
+      path6.resolve(__dirname, "..", "bin")
     ];
     const platform2 = process.platform;
     const extension = platform2 === "win32" ? ".exe" : "";
     const platformName = platform2 === "win32" ? "windows" : platform2 === "darwin" ? "macos" : "linux";
     for (const dir of possibleDirs) {
       const versionedPath = this.findVersionedBinary(dir, platform2);
-      if (versionedPath && fs3.existsSync(versionedPath)) {
+      if (versionedPath && fs4.existsSync(versionedPath)) {
         return versionedPath;
       }
     }
     const binaryName = `sqlite-engine-${platformName}-x64${extension}`;
     for (const dir of possibleDirs) {
-      const fullPath = path5.join(dir, binaryName);
-      if (fs3.existsSync(fullPath)) {
+      const fullPath = path6.join(dir, binaryName);
+      if (fs4.existsSync(fullPath)) {
         return fullPath;
       }
     }
     const fallbackName = `sqlite-engine${extension}`;
     for (const dir of possibleDirs) {
-      const fullPath = path5.join(dir, fallbackName);
-      if (fs3.existsSync(fullPath)) {
+      const fullPath = path6.join(dir, fallbackName);
+      if (fs4.existsSync(fullPath)) {
         return fullPath;
       }
     }
-    return path5.join(possibleDirs[0], binaryName);
+    return path6.join(possibleDirs[0], binaryName);
   }
   async executeBinary(args) {
     const escapedArgs = args.map((arg) => {
@@ -1581,9 +1855,9 @@ var SqliteExecutor = class {
 };
 
 // src/lib/DbConfig.ts
-var path6 = __toESM(require("path"));
-var import_fs = __toESM(require("fs"));
-var rootPath = path6.resolve(process.cwd(), ".dbcube");
+var path7 = __toESM(require("path"));
+var import_fs2 = __toESM(require("fs"));
+var rootPath = path7.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
   executor = null;
   database;
@@ -1593,11 +1867,11 @@ var SQLite = class {
   async ifExist() {
     if (this.database) {
       const dbPath = this.database || ":memory:";
-      const configPath = path6.join(rootPath, dbPath + ".db");
-      if (!import_fs.default.existsSync(rootPath)) {
-        import_fs.default.mkdirSync(rootPath, { recursive: true });
+      const configPath = path7.join(rootPath, dbPath + ".db");
+      if (!import_fs2.default.existsSync(rootPath)) {
+        import_fs2.default.mkdirSync(rootPath, { recursive: true });
       }
-      if (import_fs.default.existsSync(configPath)) {
+      if (import_fs2.default.existsSync(configPath)) {
         return true;
       }
       if (!this.executor) {
@@ -1612,9 +1886,9 @@ var SQLite = class {
       try {
         if (!this.executor) {
           const dbPath = this.database || ":memory:";
-          const configPath = path6.join(rootPath, dbPath + ".db");
-          if (!import_fs.default.existsSync(rootPath)) {
-            import_fs.default.mkdirSync(rootPath, { recursive: true });
+          const configPath = path7.join(rootPath, dbPath + ".db");
+          if (!import_fs2.default.existsSync(rootPath)) {
+            import_fs2.default.mkdirSync(rootPath, { recursive: true });
           }
           this.executor = new SqliteExecutor(configPath);
           const connected = await this.executor.connect();
@@ -1796,8 +2070,8 @@ var DbConfig = new SQLite({ DATABASE: "config" });
 var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
-var fs5 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var import_events = require("events");
 var FileLogger = class _FileLogger extends import_events.EventEmitter {
   static watchers = /* @__PURE__ */ new Map();
@@ -1812,9 +2086,9 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
    */
   static async write(filePath, message, level = "INFO", append = true) {
     try {
-      const dir = path7.dirname(filePath);
-      if (!fs5.existsSync(dir)) {
-        fs5.mkdirSync(dir, { recursive: true });
+      const dir = path8.dirname(filePath);
+      if (!fs6.existsSync(dir)) {
+        fs6.mkdirSync(dir, { recursive: true });
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const formattedMessage = `[${timestamp}] [${level}] ${message}
@@ -1824,9 +2098,9 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
         return true;
       }
       if (append) {
-        await fs5.promises.appendFile(filePath, formattedMessage, "utf8");
+        await fs6.promises.appendFile(filePath, formattedMessage, "utf8");
       } else {
-        await fs5.promises.writeFile(filePath, formattedMessage, "utf8");
+        await fs6.promises.writeFile(filePath, formattedMessage, "utf8");
       }
       return true;
     } catch (error) {
@@ -1851,12 +2125,12 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
     const buffer = _FileLogger.buffers.get(filePath);
     if (buffer && buffer.length > 0) {
       try {
-        const dir = path7.dirname(filePath);
-        if (!fs5.existsSync(dir)) {
-          fs5.mkdirSync(dir, { recursive: true });
+        const dir = path8.dirname(filePath);
+        if (!fs6.existsSync(dir)) {
+          fs6.mkdirSync(dir, { recursive: true });
         }
         const content = buffer.join("");
-        await fs5.promises.appendFile(filePath, content, "utf8");
+        await fs6.promises.appendFile(filePath, content, "utf8");
         _FileLogger.buffers.delete(filePath);
         return true;
       } catch (error) {
@@ -1992,10 +2266,10 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
       // Si debe retornar como array de líneas
     } = options;
     try {
-      if (!fs5.existsSync(filePath)) {
+      if (!fs6.existsSync(filePath)) {
         return asArray ? [] : "";
       }
-      let content = await fs5.promises.readFile(filePath, "utf8");
+      let content = await fs6.promises.readFile(filePath, "utf8");
       if (asArray) {
         let linesArray = content.split("\n").filter((line) => line.trim() !== "");
         if (lines !== null) {
@@ -2038,15 +2312,15 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
     } = options;
     let lastSize = 0;
     let lastPosition = 0;
-    if (fs5.existsSync(filePath)) {
-      const stats = fs5.statSync(filePath);
+    if (fs6.existsSync(filePath)) {
+      const stats = fs6.statSync(filePath);
       lastSize = stats.size;
       lastPosition = fromEnd ? stats.size : 0;
     }
     const listener = async (curr, prev) => {
       try {
         if (curr.size > lastSize) {
-          const stream = fs5.createReadStream(filePath, {
+          const stream = fs6.createReadStream(filePath, {
             start: lastPosition,
             end: curr.size - 1,
             encoding: "utf8"
@@ -2074,7 +2348,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
         console.error("Error en watcher:", error);
       }
     };
-    fs5.watchFile(filePath, { persistent, interval }, listener);
+    fs6.watchFile(filePath, { persistent, interval }, listener);
     const watcherId = `${filePath}_${Date.now()}`;
     _FileLogger.watchers.set(watcherId, listener);
     return {
@@ -2082,7 +2356,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
       stop: () => {
         const storedListener = _FileLogger.watchers.get(watcherId);
         if (storedListener) {
-          fs5.unwatchFile(filePath, storedListener);
+          fs6.unwatchFile(filePath, storedListener);
           _FileLogger.watchers.delete(watcherId);
         }
       },
@@ -2095,7 +2369,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
   static stopAllWatchers() {
     for (const [watcherId] of _FileLogger.watchers) {
       const filePath = watcherId.split("_")[0];
-      fs5.unwatchFile(filePath);
+      fs6.unwatchFile(filePath);
     }
     _FileLogger.watchers.clear();
   }
@@ -2125,7 +2399,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
       if (lines.length > maxLines) {
         const keepLines = lines.slice(-maxLines);
         const content = keepLines.join("\n") + "\n";
-        await fs5.promises.writeFile(filePath, content, "utf8");
+        await fs6.promises.writeFile(filePath, content, "utf8");
         return lines.length - maxLines;
       }
       return 0;
@@ -2140,8 +2414,8 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
    */
   static async deleteLogFile(filePath) {
     try {
-      if (fs5.existsSync(filePath)) {
-        await fs5.promises.unlink(filePath);
+      if (fs6.existsSync(filePath)) {
+        await fs6.promises.unlink(filePath);
         return true;
       }
       return false;
@@ -2572,6 +2846,7 @@ function convertToType(value, type2) {
   Binary,
   ComputedFieldProcessor,
   Config,
+  DaemonClient,
   DbConfig,
   Engine,
   FileLogger,