codexuse-cli 3.9.9 → 4.0.0

package/dist/index.js

@@ -2216,6 +2216,17 @@ var SQLITE_BUSY_MAX_ATTEMPTS = 3;
 var SQLITE_BUSY_RETRY_DELAY_MS = 100;
 var writeQueueByDbPath = /* @__PURE__ */ new Map();
 var initializedDbPaths = /* @__PURE__ */ new Set();
+var AppStorageCorruptionError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "AppStorageCorruptionError";
+    this.dbPath = options.dbPath;
+    this.namespace = options.namespace ?? null;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -2232,6 +2243,23 @@ function safeParseJson(raw) {
     return null;
   }
 }
+function parseJsonStrict(raw, options) {
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new AppStorageCorruptionError(
+      `App storage document ${options.namespace} contains invalid JSON.`,
+      {
+        dbPath: options.dbPath,
+        namespace: options.namespace,
+        cause: error
+      }
+    );
+  }
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -2240,9 +2268,32 @@ function isSqliteBusyError(error) {
     return false;
   }
   const sqliteError = error;
-  const message = typeof sqliteError.message === "string" ? sqliteError.message.toLowerCase() : "";
+  if (sqliteError.cause && sqliteError.cause !== error && isSqliteBusyError(sqliteError.cause)) {
+    return true;
+  }
+  if (sqliteError.error && sqliteError.error !== error && isSqliteBusyError(sqliteError.error)) {
+    return true;
+  }
+  const message = typeof sqliteError.message === "string" ? sqliteError.message.toLowerCase() : String(error).toLowerCase();
   return sqliteError.code === "SQLITE_BUSY" || sqliteError.errno === 5 || message.includes("sqlite_busy") || message.includes("database is locked");
 }
+function isSqliteCorruptionError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const sqliteError = error;
+  if (sqliteError.cause && sqliteError.cause !== error && isSqliteCorruptionError(sqliteError.cause)) {
+    return true;
+  }
+  if (sqliteError.error && sqliteError.error !== error && isSqliteCorruptionError(sqliteError.error)) {
+    return true;
+  }
+  const message = typeof sqliteError.message === "string" ? sqliteError.message.toLowerCase() : "";
+  return sqliteError.code === "SQLITE_CORRUPT" || sqliteError.code === "SQLITE_NOTADB" || sqliteError.errno === 11 || sqliteError.errno === 26 || message.includes("database disk image is malformed") || message.includes("file is not a database") || message.includes("database corruption") || message.includes("sqlite_corrupt") || message.includes("sqlite_notadb");
+}
+function isAppStorageCorruptionError(error) {
+  return error instanceof AppStorageCorruptionError || isSqliteCorruptionError(error);
+}
 function beginImmediate(db) {
   db.exec("BEGIN IMMEDIATE");
 }
@@ -2317,19 +2368,55 @@ async function openDatabase(dbPath) {
     close: database.close.bind(database)
   };
 }
+function resetAppStorageInitialization(dbPath) {
+  initializedDbPaths.delete(dbPath);
+}
+async function backupCorruptAppStorageDb(dbPath) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${dbPath}.corrupt-${stamp}`;
+  let moved = false;
+  for (const suffix of ["", "-wal", "-shm"]) {
+    const source = `${dbPath}${suffix}`;
+    const destination = `${backupPath}${suffix}`;
+    try {
+      const stats = await import_node_fs.promises.stat(source);
+      if (!stats.isFile()) {
+        continue;
+      }
+      await import_node_fs.promises.rename(source, destination);
+      moved = true;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  resetAppStorageInitialization(dbPath);
+  return moved ? backupPath : null;
+}
 async function withDatabase(dbPath, task) {
   for (let attempt = 1; attempt <= SQLITE_BUSY_MAX_ATTEMPTS; attempt += 1) {
-    const db = await openDatabase(dbPath);
+    let db = null;
     try {
+      db = await openDatabase(dbPath);
       applyConnectionPragmas(db);
       ensureSchema(db, dbPath);
       return task(db);
     } catch (error) {
+      if (error instanceof AppStorageCorruptionError) {
+        throw error;
+      }
+      if (isSqliteCorruptionError(error)) {
+        throw new AppStorageCorruptionError(
+          "App storage database is corrupt.",
+          { dbPath, cause: error }
+        );
+      }
       if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_MAX_ATTEMPTS) {
         throw error;
       }
     } finally {
-      db.close();
+      db?.close();
     }
     await sleep(SQLITE_BUSY_RETRY_DELAY_MS * attempt);
   }
@@ -2352,6 +2439,40 @@ async function readDocument(dbPath, namespace, normalize) {
     return normalize(parsed);
   });
 }
+async function readDocumentStrict(dbPath, namespace, normalize) {
+  return withDatabase(dbPath, (db) => {
+    const row = useStatement(
+      db,
+      `SELECT value_json AS valueJson FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`,
+      (statement) => statement.get(namespace)
+    );
+    if (!isRecord(row)) {
+      return null;
+    }
+    const parsed = parseJsonStrict(row.valueJson, {
+      dbPath,
+      namespace
+    });
+    if (parsed === null) {
+      throw new AppStorageCorruptionError(
+        `App storage document ${namespace} is empty.`,
+        { dbPath, namespace }
+      );
+    }
+    try {
+      return normalize(parsed);
+    } catch (error) {
+      throw new AppStorageCorruptionError(
+        `App storage document ${namespace} failed normalization.`,
+        {
+          dbPath,
+          namespace,
+          cause: error
+        }
+      );
+    }
+  });
+}
 async function writeDocument(dbPath, namespace, value) {
   return withWriteQueue(
     dbPath,
@@ -3031,7 +3152,7 @@ async function readLegacyAppStateFromDisk() {
   }
 }
 async function readAppStateFromStorage() {
-  return readDocument(
+  return readDocumentStrict(
     resolveStorageDbPath(),
     APP_STATE_DOCUMENT,
     normalizeAppState
@@ -3044,11 +3165,42 @@ async function writeAppStateToStorage(state) {
     normalizeAppState(state)
   );
 }
+function compactRecoveryMessage(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : String(error);
+  return message.replace(/\s+/g, " ").trim().slice(0, 240) || "unknown corruption";
+}
+async function recoverCorruptAppStateStorage(error) {
+  const dbPath = resolveStorageDbPath();
+  if (error instanceof AppStorageCorruptionError && error.namespace === APP_STATE_DOCUMENT) {
+    appStateCache = null;
+    resetAppStorageInitialization(dbPath);
+    const legacyState2 = await readLegacyAppStateFromDisk().catch(() => null);
+    const recovered2 = normalizeAppState(legacyState2 ?? null);
+    recovered2.migration.lastError = `Recovered app-state document after corruption (${compactRecoveryMessage(error)}). Shared storage database preserved.`;
+    return writeAppStateToStorage(recovered2);
+  }
+  const backupPath = await backupCorruptAppStorageDb(dbPath);
+  appStateCache = null;
+  resetAppStorageInitialization(dbPath);
+  const legacyState = await readLegacyAppStateFromDisk().catch(() => null);
+  const recovered = normalizeAppState(legacyState ?? null);
+  recovered.migration.lastError = backupPath ? `Recovered app-state storage after corruption (${compactRecoveryMessage(error)}). Backup: ${import_node_path2.default.basename(backupPath)}` : `Recovered app-state storage after corruption (${compactRecoveryMessage(error)}). No existing DB file was present.`;
+  return writeAppStateToStorage(recovered);
+}
 async function ensureInitialized() {
   if (appStateCache) {
     return appStateCache;
   }
-  const loaded = await readAppStateFromStorage() ?? await readLegacyAppStateFromDisk();
+  let loaded = null;
+  try {
+    loaded = await readAppStateFromStorage() ?? await readLegacyAppStateFromDisk();
+  } catch (error) {
+    if (!isAppStorageCorruptionError(error)) {
+      throw error;
+    }
+    appStateCache = await recoverCorruptAppStateStorage(error);
+    return clone2(appStateCache);
+  }
   const normalized = loaded ?? normalizeAppState(null);
   appStateCache = await writeAppStateToStorage(normalized);
   return clone2(appStateCache);
@@ -3072,7 +3224,11 @@ async function withWriteLock(task) {
   }
 }
 async function initializeAppState(userDataDir) {
-  configuredUserDataDir = userDataDir;
+  if (configuredUserDataDir !== userDataDir) {
+    configuredUserDataDir = userDataDir;
+    appStateCache = null;
+    resetAppStorageInitialization(resolveStorageDbPath());
+  }
   const state = await ensureInitialized();
   return clone2(state);
 }
@@ -12549,7 +12705,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "3.9.9" : "0.0.0";
+var VERSION = true ? "4.0.0" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {