@askexenow/exe-os 0.9.144 → 0.9.145

package/dist/chunk-3H4VU65X.js

@@ -0,0 +1,209 @@
+// src/lib/daemon-restart-orchestrator.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  mkdirSync,
+  openSync,
+  closeSync,
+  unlinkSync,
+  statSync,
+  renameSync,
+  readdirSync
+} from "fs";
+import { execSync } from "child_process";
+import path from "path";
+import os from "os";
+var EXE_DIR = path.join(os.homedir(), ".exe-os");
+var LOG_DIR = path.join(EXE_DIR, "logs");
+var RESTART_LOG = path.join(LOG_DIR, "daemon-restarts.log");
+var RESTART_MARKER = path.join(EXE_DIR, "last-daemon-restart");
+var SPAWN_LOCK_PATH = path.join(EXE_DIR, "exed-spawn.lock");
+var PID_PATH = process.env.EXE_DAEMON_PID ?? path.join(EXE_DIR, "exed.pid");
+var SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? path.join(EXE_DIR, "exed.sock");
+var OOM_MARKER_PATH = path.join(EXE_DIR, "embedding-oom-marker");
+var WORKER_PIDS_DIR = path.join(EXE_DIR, "worker-pids");
+var MCP_VERSION_PATH = path.join(EXE_DIR, "mcp-version");
+var COOLDOWN_MS = 6e4;
+var MIN_DAEMON_AGE_MS = 3e4;
+var SPAWN_LOCK_STALE_MS = 3e4;
+var SIGTERM_GRACE_MS = 5e3;
+var MAX_LOG_SIZE = 2 * 1024 * 1024;
+var _logDirChecked = false;
+function ensureLogDir() {
+  if (_logDirChecked) return;
+  if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true });
+  _logDirChecked = true;
+}
+function maybeRotateLog() {
+  try {
+    if (!existsSync(RESTART_LOG)) return;
+    const s = statSync(RESTART_LOG);
+    if (s.size > MAX_LOG_SIZE) {
+      try {
+        renameSync(RESTART_LOG, `${RESTART_LOG}.1`);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function logRestart(entry) {
+  try {
+    ensureLogDir();
+    maybeRotateLog();
+    appendFileSync(RESTART_LOG, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), pid: process.pid, ...entry }) + "\n");
+  } catch {
+  }
+}
+function logRestartEvent(event, data) {
+  logRestart({ event, ...data });
+}
+function isCooldownActive() {
+  try {
+    if (!existsSync(RESTART_MARKER)) return { active: false, remainingMs: 0 };
+    const last = parseInt(readFileSync(RESTART_MARKER, "utf8").trim(), 10);
+    if (isNaN(last)) return { active: false, remainingMs: 0 };
+    const elapsed = Date.now() - last;
+    if (elapsed < COOLDOWN_MS) return { active: true, remainingMs: COOLDOWN_MS - elapsed };
+  } catch {
+  }
+  return { active: false, remainingMs: 0 };
+}
+function isDaemonTooYoung() {
+  try {
+    return Date.now() - statSync(PID_PATH).mtimeMs < MIN_DAEMON_AGE_MS;
+  } catch {
+    return false;
+  }
+}
+function isOomMarkerSet() {
+  return existsSync(OOM_MARKER_PATH);
+}
+function acquireLock() {
+  try {
+    const fd = openSync(SPAWN_LOCK_PATH, "wx");
+    closeSync(fd);
+    return true;
+  } catch {
+    try {
+      if (Date.now() - statSync(SPAWN_LOCK_PATH).mtimeMs > SPAWN_LOCK_STALE_MS) {
+        try {
+          unlinkSync(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseLock() {
+  try {
+    unlinkSync(SPAWN_LOCK_PATH);
+  } catch {
+  }
+}
+function readDaemonPid() {
+  try {
+    if (!existsSync(PID_PATH)) return null;
+    const pid = parseInt(readFileSync(PID_PATH, "utf8").trim(), 10);
+    return pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killDaemonGracefully(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  const deadline = Date.now() + SIGTERM_GRACE_MS;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) return;
+    const waitEnd = Date.now() + 200;
+    while (Date.now() < waitEnd) {
+    }
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+    logRestart({ event: "sigkill_escalation", target_pid: pid, message: "SIGTERM grace expired, sent SIGKILL" });
+  } catch {
+  }
+}
+function requestRestart(reason, opts) {
+  const isEmbedRelated = opts?.isEmbedRelated ?? false;
+  const cooldown = isCooldownActive();
+  if (cooldown.active) {
+    const msg = `Restart cooldown active (${Math.round(cooldown.remainingMs / 1e3)}s left)`;
+    process.stderr.write(`[restart-orchestrator] ${msg} \u2014 skipping
+`);
+    logRestart({ event: "skipped", reason, skip_reason: "cooldown" });
+    return { ok: false, skipped: msg };
+  }
+  if (isDaemonTooYoung()) {
+    const msg = `Daemon too young (< ${MIN_DAEMON_AGE_MS / 1e3}s)`;
+    process.stderr.write(`[restart-orchestrator] ${msg} \u2014 skipping
+`);
+    logRestart({ event: "skipped", reason, skip_reason: "too_young" });
+    return { ok: false, skipped: msg };
+  }
+  if (isEmbedRelated && isOomMarkerSet()) {
+    const msg = "Embeddings disabled (OOM marker)";
+    process.stderr.write(`[restart-orchestrator] ${msg} \u2014 skipping
+`);
+    logRestart({ event: "skipped", reason, skip_reason: "oom_marker" });
+    return { ok: false, skipped: msg };
+  }
+  if (!acquireLock()) {
+    const msg = "Another process is already restarting daemon";
+    process.stderr.write(`[restart-orchestrator] ${msg} \u2014 skipping
+`);
+    logRestart({ event: "skipped", reason, skip_reason: "lock_held" });
+    return { ok: false, skipped: msg };
+  }
+  try {
+    try {
+      writeFileSync(RESTART_MARKER, String(Date.now()));
+    } catch {
+    }
+    const pid = readDaemonPid();
+    logRestart({ event: "restart_initiated", reason, target_pid: pid, is_embed_related: isEmbedRelated });
+    process.stderr.write(`[restart-orchestrator] Killing daemon (PID ${pid ?? "unknown"}) \u2014 reason: ${reason}
+`);
+    if (pid !== null && isProcessAlive(pid)) killDaemonGracefully(pid);
+    try {
+      unlinkSync(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync(SOCKET_PATH);
+    } catch {
+    }
+    logRestart({ event: "restart_complete", reason, killed_pid: pid });
+    return { ok: true, pid, reason };
+  } finally {
+    releaseLock();
+  }
+}
+
+export {
+  logRestartEvent,
+  requestRestart
+};

package/dist/chunk-3TXOH3SJ.js

@@ -0,0 +1,20 @@
+import {
+  TmuxTransport
+} from "./chunk-RLCZBSUB.js";
+
+// src/lib/transport.ts
+var _transport = null;
+function getTransport() {
+  if (!_transport) {
+    _transport = new TmuxTransport();
+  }
+  return _transport;
+}
+function setTransport(t) {
+  _transport = t;
+}
+
+export {
+  getTransport,
+  setTransport
+};

package/dist/{chunk-GPCQRSAR.js → chunk-4F56OUR7.js}

@@ -1,21 +1,15 @@
 import {
   employeeSessionName,
-  init_task_scope,
-  init_tmux_routing,
   isEmployeeAlive,
   resolveExeSession,
   sendIntercom,
   strictSessionScopeFilter
-} from "./chunk-V3YNF3JK.js";
+} from "./chunk-H4YONWQX.js";
 import {
-  getClient,
-  init_database
-} from "./chunk-WLW7QV2C.js";
+  getClient
+} from "./chunk-NA3MXUU6.js";
 
 // src/lib/messaging.ts
-init_database();
-init_tmux_routing();
-init_task_scope();
 import crypto from "crypto";
 function generateUlid() {
   const timestamp = Date.now().toString(36).padStart(10, "0");

package/dist/{chunk-ZCYQZQTA.js → chunk-53VUIKOE.js}

@@ -1,6 +1,6 @@
 import {
   getGlobalProceduresBlock
-} from "./chunk-52LCN4JK.js";
+} from "./chunk-ER3UJ2VL.js";
 
 // src/lib/employee-templates.ts
 var BASE_OPERATING_PROCEDURES = `

package/dist/{chunk-7YZJUTQ4.js → chunk-56T5TMNK.js}

@@ -1,9 +1,9 @@
 import {
   sendMessage
-} from "./chunk-GPCQRSAR.js";
+} from "./chunk-4F56OUR7.js";
 import {
   getActiveAgent
-} from "./chunk-HLYXFVVT.js";
+} from "./chunk-BXCJOACQ.js";
 
 // src/mcp/tools/send-message.ts
 import { z } from "zod";

package/dist/{chunk-TBO4RYRU.js → chunk-5F3EXHT7.js}

@@ -1,7 +1,7 @@
 import {
   MODELS_DIR,
   init_config
-} from "./chunk-QASVYG2B.js";
+} from "./chunk-KHV55ME4.js";
 
 // src/lib/reranker.ts
 init_config();

package/dist/{chunk-KKYDUT2Z.js → chunk-5WTYETQO.js}

@@ -1,20 +1,20 @@
 import {
   EXE_AI_DIR,
   init_config
-} from "./chunk-QASVYG2B.js";
+} from "./chunk-KHV55ME4.js";
 import {
   enforcePrivateFileSync,
   ensurePrivateDirSync,
   init_secure_files
-} from "./chunk-VAOAI6DS.js";
-import {
-  __esm
-} from "./chunk-KFQGP6VL.js";
+} from "./chunk-GCMT6RWI.js";
 
 // src/lib/daemon-auth.ts
+init_config();
+init_secure_files();
 import crypto from "crypto";
 import path from "path";
 import { existsSync, readFileSync, writeFileSync } from "fs";
+var DAEMON_TOKEN_PATH = path.join(EXE_AI_DIR, "exed.token");
 function normalizeToken(token) {
   if (!token) return null;
   const trimmed = token.trim();
@@ -38,18 +38,9 @@ function ensureDaemonToken(seed) {
   enforcePrivateFileSync(DAEMON_TOKEN_PATH);
   return token;
 }
-var DAEMON_TOKEN_PATH;
-var init_daemon_auth = __esm({
-  "src/lib/daemon-auth.ts"() {
-    init_config();
-    init_secure_files();
-    DAEMON_TOKEN_PATH = path.join(EXE_AI_DIR, "exed.token");
-  }
-});
 
 export {
   DAEMON_TOKEN_PATH,
   readDaemonToken,
-  ensureDaemonToken,
-  init_daemon_auth
+  ensureDaemonToken
 };

package/dist/{chunk-YSRJHKHL.js → chunk-63UVIM7S.js}

@@ -1,17 +1,12 @@
 import {
-  init_behaviors,
   listBehaviors
-} from "./chunk-BNH4LWKE.js";
+} from "./chunk-RWJY7KMP.js";
 import {
-  config_exports,
-  init_config
-} from "./chunk-QASVYG2B.js";
-import {
-  __toCommonJS
-} from "./chunk-KFQGP6VL.js";
+  init_config,
+  loadConfigSync
+} from "./chunk-KHV55ME4.js";
 
 // src/lib/behaviors-export.ts
-init_behaviors();
 import os from "os";
 import path from "path";
 import {
@@ -22,6 +17,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "fs";
+init_config();
 var BEHAVIORS_EXPORT_DIR = path.join(
   os.homedir(),
   ".exe-os",
@@ -31,7 +27,6 @@ var STALE_EXPORT_AGE_MS = 60 * 60 * 1e3;
 var DEFAULT_BEHAVIOR_LIMIT = 30;
 function getBehaviorLimit() {
   try {
-    const { loadConfigSync } = (init_config(), __toCommonJS(config_exports));
     const cfg = loadConfigSync();
     return cfg.behaviorExportLimit ?? DEFAULT_BEHAVIOR_LIMIT;
   } catch {

package/dist/{chunk-KRLOFIPI.js → chunk-64WZEXXA.js}

@@ -1,20 +1,9 @@
-import {
-  __esm,
-  __export
-} from "./chunk-KFQGP6VL.js";
-
 // src/lib/session-registry.ts
-var session_registry_exports = {};
-__export(session_registry_exports, {
-  listSessions: () => listSessions,
-  pruneStaleSessions: () => pruneStaleSessions,
-  refreshSessionProject: () => refreshSessionProject,
-  registerSession: () => registerSession
-});
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { execSync } from "child_process";
 import path from "path";
 import os from "os";
+var REGISTRY_PATH = path.join(os.homedir(), ".exe-os", "session-registry.json");
 function registerSession(entry) {
   const dir = path.dirname(REGISTRY_PATH);
   if (!existsSync(dir)) {
@@ -66,18 +55,10 @@ function pruneStaleSessions() {
   }
   return pruned;
 }
-var REGISTRY_PATH;
-var init_session_registry = __esm({
-  "src/lib/session-registry.ts"() {
-    REGISTRY_PATH = path.join(os.homedir(), ".exe-os", "session-registry.json");
-  }
-});
 
 export {
   registerSession,
   refreshSessionProject,
   listSessions,
-  pruneStaleSessions,
-  session_registry_exports,
-  init_session_registry
+  pruneStaleSessions
 };

package/dist/{chunk-DUXNECD3.js → chunk-65UQ7H5U.js}

@@ -1,23 +1,19 @@
 import {
   PLATFORM_PROCEDURE_TITLES
-} from "./chunk-WZDI6UJ6.js";
+} from "./chunk-MPXPPKJ4.js";
 import {
   getClient,
   getIdentity,
-  init_database,
-  init_identity,
   listIdentities,
   updateIdentity
-} from "./chunk-WLW7QV2C.js";
+} from "./chunk-NA3MXUU6.js";
 import {
   atomicWriteJsonSync,
   init_secure_files
-} from "./chunk-VAOAI6DS.js";
+} from "./chunk-GCMT6RWI.js";
 
 // src/lib/orchestration-package.ts
 init_secure_files();
-init_database();
-init_identity();
 import { randomUUID } from "crypto";
 import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
 import os from "os";

package/dist/{chunk-53JBNNU3.js → chunk-6BUUY7FG.js}

@@ -1,27 +1,16 @@
 import {
   EXE_AI_DIR,
   init_config
-} from "./chunk-QASVYG2B.js";
-import {
-  __esm,
-  __export
-} from "./chunk-KFQGP6VL.js";
+} from "./chunk-KHV55ME4.js";
 
 // src/lib/db-backup.ts
-var db_backup_exports = {};
-__export(db_backup_exports, {
-  createBackup: () => createBackup,
-  findActiveDb: () => findActiveDb,
-  getBackupDir: () => getBackupDir,
-  getLatestBackup: () => getLatestBackup,
-  hasBackupToday: () => hasBackupToday,
-  listBackups: () => listBackups,
-  restoreBackup: () => restoreBackup,
-  rotateBackups: () => rotateBackups
-});
+init_config();
 import { copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, statSync } from "fs";
 import { execFileSync } from "child_process";
 import path from "path";
+var BACKUP_DIR = path.join(EXE_AI_DIR, "backups");
+var DEFAULT_KEEP_DAYS = 3;
+var DB_NAMES = ["memories.db", "exe-mem.db", "exe-os.db", "exe.db"];
 function findActiveDb() {
   for (const name of DB_NAMES) {
     const p = path.join(EXE_AI_DIR, name);
@@ -162,15 +151,6 @@ function restoreBackup(backupPath) {
 function getBackupDir() {
   return BACKUP_DIR;
 }
-var BACKUP_DIR, DEFAULT_KEEP_DAYS, DB_NAMES;
-var init_db_backup = __esm({
-  "src/lib/db-backup.ts"() {
-    init_config();
-    BACKUP_DIR = path.join(EXE_AI_DIR, "backups");
-    DEFAULT_KEEP_DAYS = 3;
-    DB_NAMES = ["memories.db", "exe-mem.db", "exe-os.db", "exe.db"];
-  }
-});
 
 export {
   findActiveDb,
@@ -180,7 +160,5 @@ export {
   hasBackupToday,
   getLatestBackup,
   restoreBackup,
-  getBackupDir,
-  db_backup_exports,
-  init_db_backup
+  getBackupDir
 };

package/dist/{chunk-YGHMRSH5.js → chunk-6D23UNXU.js}

@@ -1,10 +1,6 @@
-import {
-  __require
-} from "./chunk-KFQGP6VL.js";
-
 // src/lib/keychain.ts
 import { readFile, writeFile, unlink, mkdir, chmod, rename, copyFile } from "fs/promises";
-import { existsSync, statSync, writeFileSync } from "fs";
+import { existsSync, statSync, writeFileSync, readFileSync } from "fs";
 import { execSync } from "child_process";
 import crypto from "crypto";
 import path from "path";
@@ -195,16 +191,14 @@ function deriveMachineKey() {
 }
 function readMachineId() {
   try {
-    const { readFileSync } = __require("fs");
     return readFileSync("/etc/machine-id", "utf-8").trim();
   } catch {
     return "";
   }
 }
 function encryptWithMachineKey(plaintext, machineKey) {
-  const crypto2 = __require("crypto");
-  const iv = crypto2.randomBytes(12);
-  const cipher = crypto2.createCipheriv("aes-256-gcm", machineKey, iv);
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", machineKey, iv);
   let encrypted = cipher.update(plaintext, "utf-8", "base64");
   encrypted += cipher.final("base64");
   const authTag = cipher.getAuthTag().toString("base64");

package/dist/{chunk-MI4RRRX5.js → chunk-7APRWURX.js}

@@ -2,35 +2,29 @@ import {
   findScopedDuplicate,
   governMemoryRecord,
   schedulePostWriteMemoryHygiene
-} from "./chunk-E3ZIGQH4.js";
+} from "./chunk-D5MPHVWH.js";
 import {
-  init_state_bus,
   orgBus
-} from "./chunk-WZQ4CPRG.js";
+} from "./chunk-MP2AFCGL.js";
 import {
   disposeTurso,
   ensureSchema,
   getClient,
-  initTurso,
-  init_database
-} from "./chunk-WLW7QV2C.js";
+  initTurso
+} from "./chunk-NA3MXUU6.js";
 import {
-  EMBEDDING_DIM,
-  init_memory
-} from "./chunk-4NYQAS33.js";
+  EMBEDDING_DIM
+} from "./chunk-FXU7JOXK.js";
 import {
   getMasterKey
-} from "./chunk-YGHMRSH5.js";
+} from "./chunk-6D23UNXU.js";
 import {
   init_config,
   loadConfig
-} from "./chunk-QASVYG2B.js";
+} from "./chunk-KHV55ME4.js";
 
 // src/lib/store.ts
-init_memory();
-init_database();
 init_config();
-init_state_bus();
 var _debugStore = process.env.EXE_DEBUG === "1";
 function logStoreDebug(context, err) {
   if (_debugStore) {
@@ -114,7 +108,7 @@ async function initStore(options) {
   if (!options?.lightweight) {
     try {
       if (process.env.EXE_DISABLE_SHARDING !== "1") {
-        const { initShardManager } = await import("./shard-manager-IIII7AAS.js");
+        const { initShardManager } = await import("./shard-manager-VYMJM7NR.js");
         initShardManager(hexKey);
       }
     } catch (e) {
@@ -127,7 +121,7 @@ async function initStore(options) {
     );
     _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
     try {
-      const { loadGlobalProcedures } = await import("./global-procedures-4BN6BD4N.js");
+      const { loadGlobalProcedures } = await import("./global-procedures-IEIJBCAH.js");
       await loadGlobalProcedures();
     } catch (e) {
       logStoreWarn("catch", e);
@@ -244,7 +238,7 @@ async function writeMemory(record) {
     procedure_for: record.procedure_for ?? null
   };
   try {
-    const { checkMemoryPoisoning } = await import("./memory-poisoning-defense-JY4NU3AY.js");
+    const { checkMemoryPoisoning } = await import("./memory-poisoning-defense-OOHJIXIX.js");
     const poisonResult = await checkMemoryPoisoning({
       memoryId: dbRow.id,
       vector: Array.isArray(dbRow.vector) ? dbRow.vector : void 0,
@@ -418,13 +412,13 @@ async function flushBatch() {
     }
     _nextVersion = baseVersion;
     try {
-      const { insertMemoryCardsForBatch } = await import("./memory-cards-PCZ2KWMN.js");
+      const { insertMemoryCardsForBatch } = await import("./memory-cards-OLE6MGO7.js");
       await insertMemoryCardsForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
     }
     try {
-      const { insertOntologyForBatch } = await import("./agentic-ontology-Q3OVWKAK.js");
+      const { insertOntologyForBatch } = await import("./agentic-ontology-5PGUVMDP.js");
       await insertOntologyForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
@@ -432,7 +426,7 @@ async function flushBatch() {
     schedulePostWriteMemoryHygiene(batch.map((row) => row.id));
     _pendingRecords.splice(0, batch.length);
     try {
-      const { isShardingEnabled, getReadyShardClient } = await import("./shard-manager-IIII7AAS.js");
+      const { isShardingEnabled, getReadyShardClient } = await import("./shard-manager-VYMJM7NR.js");
       if (process.env.EXE_DISABLE_SHARDING !== "1" && isShardingEnabled()) {
         const byProject = /* @__PURE__ */ new Map();
         let skippedUnknown = 0;
@@ -503,7 +497,7 @@ function buildRawVisibilityFilter(options, columnPrefix) {
 async function searchMemories(queryVector, agentId, options) {
   let client;
   try {
-    const { isShardingEnabled, shardExists, getReadyShardClient } = await import("./shard-manager-IIII7AAS.js");
+    const { isShardingEnabled, shardExists, getReadyShardClient } = await import("./shard-manager-VYMJM7NR.js");
     if (isShardingEnabled() && options?.projectName && shardExists(options.projectName)) {
       client = await getReadyShardClient(options.projectName);
     } else {
@@ -674,12 +668,29 @@ async function updateMemoryStatus(id, status) {
     args: [status, id]
   });
 }
-function reserveVersions(count) {
-  const reserved = [];
-  for (let i = 0; i < count; i++) {
-    reserved.push(_nextVersion++);
+async function reserveVersions(count) {
+  const client = getClient();
+  await client.execute("BEGIN IMMEDIATE");
+  try {
+    const vResult = await client.execute("SELECT COALESCE(MAX(version), 0) as max_v FROM memories");
+    let baseVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+    if (_nextVersion > baseVersion) {
+      baseVersion = _nextVersion;
+    }
+    const reserved = [];
+    for (let i = 0; i < count; i++) {
+      reserved.push(baseVersion + i);
+    }
+    _nextVersion = baseVersion + count;
+    await client.execute("COMMIT");
+    return reserved;
+  } catch (err) {
+    try {
+      await client.execute("ROLLBACK");
+    } catch {
+    }
+    throw err;
   }
-  return reserved;
 }
 async function getMemoryCardinality(agentId) {
   try {

package/dist/{chunk-3RT5V3M4.js → chunk-7KR5PV4P.js}

@@ -1,10 +1,8 @@
 import {
-  getClient,
-  init_database
-} from "./chunk-WLW7QV2C.js";
+  getClient
+} from "./chunk-NA3MXUU6.js";
 
 // src/lib/token-spend.ts
-init_database();
 import { readdir } from "fs/promises";
 import { createReadStream } from "fs";
 import { createInterface } from "readline";