asaihost-nodejs 0.0.1

package/dist/chunk-VLMM735Q.cjs

@@ -0,0 +1,1202 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkO6LVLSNBcjs = require('./chunk-O6LVLSNB.cjs');
+
+
+
+
+
+
+
+var _chunkHHPGUJ75cjs = require('./chunk-HHPGUJ75.cjs');
+
+
+
+var _chunkSMVZ3ZDJcjs = require('./chunk-SMVZ3ZDJ.cjs');
+
+// src/sysserver/lib/common/LogStore.ts
+var LogStore_exports = {};
+_chunkSMVZ3ZDJcjs.__export.call(void 0, LogStore_exports, {
+  archiveInterventionYear: () => archiveInterventionYear,
+  exportLogContent: () => exportLogContent,
+  getComplianceReport: () => getComplianceReport,
+  getEffectiveStoreType: () => getEffectiveStoreType,
+  getLogStoreConfig: () => getLogStoreConfig,
+  getLogStoreMeta: () => getLogStoreMeta,
+  getUnifiedEntry: () => getUnifiedEntry,
+  getUnifiedStats: () => getUnifiedStats,
+  groupsToInterventionFiles: () => groupsToInterventionFiles,
+  groupsToManageChildren: () => groupsToManageChildren,
+  isLogStoreEnabled: () => isLogStoreEnabled,
+  isLogStoreFileBackend: () => isLogStoreFileBackend,
+  isLogStoreSqlite: () => isLogStoreSqlite,
+  listUnifiedGroups: () => listUnifiedGroups,
+  mirrorAccessLog: () => mirrorAccessLog,
+  mirrorInterventionLog: () => mirrorInterventionLog,
+  mirrorWebLog: () => mirrorWebLog,
+  prefersDiskLogAccess: () => prefersDiskLogAccess,
+  purgeSqliteEntriesForFile: () => purgeSqliteEntriesForFile,
+  purgeStoreEntriesForFile: () => purgeStoreEntriesForFile,
+  queryUnifiedLogs: () => queryUnifiedLogs,
+  readWebLogFromStore: () => readWebLogFromStore,
+  searchUnifiedLogs: () => searchUnifiedLogs
+});
+
+// src/sysserver/lib/common/log-file-store.ts
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function storeBaseAbs($asai) {
+  const resolved = _chunkHHPGUJ75cjs.resolveStoreConfig.call(void 0, $asai, "log");
+  const opt = _chunkHHPGUJ75cjs.normalizeStoreOpt.call(void 0, "log", resolved.type, resolved.opt);
+  const dir = String(opt.dir || "webdata/webdb/log/store/");
+  return _path2.default.resolve(process.cwd(), dir);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, storeBaseAbs, "storeBaseAbs");
+var INDEX_ROOT = "index";
+var META_ROOT = "_meta";
+var ID_COUNTER = "id-counter.json";
+var LEGACY_BLOB = "log_entries.json";
+function indexRootAbs($asai) {
+  return _path2.default.join(storeBaseAbs($asai), INDEX_ROOT);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, indexRootAbs, "indexRootAbs");
+function safeSeg(v) {
+  return (v || "_").replace(/[\\/:*?"<>|]/g, "_").slice(0, 64) || "_";
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, safeSeg, "safeSeg");
+function entryRelPath(row) {
+  const kind = safeSeg(String(row.kind || "web"));
+  const ns = safeSeg(String(row.ns || "_"));
+  const source = safeSeg(String(row.source || "_"));
+  const logDate = safeSeg(String(row.log_date || "unknown"));
+  const id = String(_nullishCoalesce(row.id, () => ( "0")));
+  return _path2.default.join(INDEX_ROOT, kind, ns, source, logDate, `${id}.json`);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, entryRelPath, "entryRelPath");
+function rowToRecord(row) {
+  const out = { ...row };
+  for (const k of ["severity", "retention_protected", "created_at", "id"]) {
+    if (out[k] != null && out[k] !== "") out[k] = Number(out[k]);
+  }
+  return out;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, rowToRecord, "rowToRecord");
+async function ensureDir(dir) {
+  await _promises2.default.mkdir(dir, { recursive: true });
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, ensureDir, "ensureDir");
+async function readCounter($asai) {
+  const file = _path2.default.join(storeBaseAbs($asai), META_ROOT, ID_COUNTER);
+  try {
+    const raw = await _promises2.default.readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    return Math.max(0, Number(parsed.next || parsed.last || 0));
+  } catch (e2) {
+    return 0;
+  }
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, readCounter, "readCounter");
+async function writeCounter($asai, next) {
+  const dir = _path2.default.join(storeBaseAbs($asai), META_ROOT);
+  await ensureDir(dir);
+  await _promises2.default.writeFile(_path2.default.join(dir, ID_COUNTER), JSON.stringify({ next, updatedAt: Date.now() }, null, 2), "utf8");
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, writeCounter, "writeCounter");
+async function nextId($asai) {
+  const cur = await readCounter($asai);
+  const id = cur + 1;
+  await writeCounter($asai, id);
+  return id;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, nextId, "nextId");
+async function migrateLegacyBlobIfNeeded($asai) {
+  const base = storeBaseAbs($asai);
+  const legacyPath = _path2.default.join(base, LEGACY_BLOB);
+  let legacy = [];
+  try {
+    const raw = await _promises2.default.readFile(legacyPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed) && parsed.length) legacy = parsed;
+  } catch (e3) {
+    return 0;
+  }
+  let maxId = await readCounter($asai);
+  for (const row of legacy) {
+    const id = Number(row.id || ++maxId);
+    if (id > maxId) maxId = id;
+    const record = rowToRecord({ ...row, id });
+    const abs = _path2.default.join(base, entryRelPath(record));
+    await ensureDir(_path2.default.dirname(abs));
+    await _promises2.default.writeFile(abs, JSON.stringify(record, null, 2), "utf8");
+  }
+  await writeCounter($asai, maxId);
+  await _promises2.default.rename(legacyPath, `${legacyPath}.migrated.${Date.now()}`).catch(() => void 0);
+  return legacy.length;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, migrateLegacyBlobIfNeeded, "migrateLegacyBlobIfNeeded");
+async function walkIndexFiles($asai) {
+  const root = indexRootAbs($asai);
+  const rows = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await _promises2.default.readdir(dir, { withFileTypes: true });
+    } catch (e4) {
+      return;
+    }
+    for (const ent of entries) {
+      const full = _path2.default.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        await walk(full);
+      } else if (ent.isFile() && ent.name.endsWith(".json")) {
+        try {
+          const raw = await _promises2.default.readFile(full, "utf8");
+          const parsed = JSON.parse(raw);
+          if (parsed && typeof parsed === "object") rows.push(rowToRecord(parsed));
+        } catch (e5) {
+        }
+      }
+    }
+  }
+  _chunkSMVZ3ZDJcjs.__name.call(void 0, walk, "walk");
+  await walk(root);
+  return rows;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, walkIndexFiles, "walkIndexFiles");
+function applyQueryFilter(rows, filter) {
+  let out = rows;
+  if (filter.kind) out = out.filter((r) => r.kind === filter.kind);
+  if (filter.ns) out = out.filter((r) => r.ns === filter.ns);
+  if (filter.source) out = out.filter((r) => r.source === filter.source);
+  if (filter.log_date) out = out.filter((r) => r.log_date === filter.log_date);
+  if (filter.file_name) out = out.filter((r) => r.file_name === filter.file_name);
+  out.sort((a, b) => Number(b.created_at || 0) - Number(a.created_at || 0));
+  if (filter.limit != null) out = out.slice(0, filter.limit);
+  return out;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, applyQueryFilter, "applyQueryFilter");
+function applySearchFilters(rows, filter) {
+  let out = rows;
+  if (filter.keyword) {
+    const kw = filter.keyword.toLowerCase();
+    out = out.filter((r) => {
+      const hay = [r.message, r.raw_line, r.event_type, r.us, r.identification, r.category].map((v) => String(v || "").toLowerCase()).join(" ");
+      return hay.includes(kw);
+    });
+  }
+  if (filter.event_type) {
+    const et = filter.event_type.toUpperCase();
+    out = out.filter((r) => String(r.event_type || "").toUpperCase() === et);
+  }
+  if (filter.severity_min != null && !Number.isNaN(Number(filter.severity_min))) {
+    const min = Number(filter.severity_min);
+    out = out.filter((r) => Number(r.severity || 0) >= min);
+  }
+  if (filter.date_from) out = out.filter((r) => String(r.log_date || "") >= filter.date_from);
+  if (filter.date_to) out = out.filter((r) => String(r.log_date || "") <= filter.date_to);
+  if (filter.outcome) {
+    const oc = filter.outcome.toLowerCase();
+    out = out.filter((r) => String(r.outcome || "").toLowerCase() === oc);
+  }
+  return out;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, applySearchFilters, "applySearchFilters");
+var migrateOnce = null;
+async function ensureMigrated($asai) {
+  if (!migrateOnce) {
+    migrateOnce = migrateLegacyBlobIfNeeded($asai).then(() => void 0);
+  }
+  await migrateOnce;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, ensureMigrated, "ensureMigrated");
+async function fileStoreInsert($asai, row) {
+  await ensureMigrated($asai);
+  const id = await nextId($asai);
+  const record = rowToRecord({ id, ...row });
+  const abs = _path2.default.join(storeBaseAbs($asai), entryRelPath(record));
+  await ensureDir(_path2.default.dirname(abs));
+  await _promises2.default.writeFile(abs, JSON.stringify(record, null, 2), "utf8");
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, fileStoreInsert, "fileStoreInsert");
+async function fileStoreQuery($asai, filter = {}) {
+  await ensureMigrated($asai);
+  const rows = await walkIndexFiles($asai);
+  return applyQueryFilter(rows, { ...filter, limit: _nullishCoalesce(filter.limit, () => ( 500)) });
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, fileStoreQuery, "fileStoreQuery");
+async function fileStoreGet($asai, id) {
+  await ensureMigrated($asai);
+  const rows = await walkIndexFiles($asai);
+  const found = rows.find((r) => String(r.id) === String(id));
+  return found ? rowToRecord(found) : null;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, fileStoreGet, "fileStoreGet");
+async function fileStoreSearch($asai, filter = {}) {
+  await ensureMigrated($asai);
+  const baseLimit = 2e4;
+  const rows = await fileStoreQuery($asai, {
+    kind: filter.kind,
+    ns: filter.ns,
+    source: filter.source,
+    log_date: filter.log_date,
+    file_name: filter.file_name,
+    limit: baseLimit
+  });
+  const filtered = applySearchFilters(rows, filter);
+  const offset = Math.max(0, Number(filter.offset) || 0);
+  const limit = Math.min(2e3, Math.max(1, Number(filter.limit) || 200));
+  return {
+    entries: filtered.slice(offset, offset + limit),
+    total: filtered.length,
+    truncated: rows.length >= baseLimit
+  };
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, fileStoreSearch, "fileStoreSearch");
+async function fileStoreStats($asai) {
+  await ensureMigrated($asai);
+  const rows = await walkIndexFiles($asai);
+  const stats = { total: rows.length, web: 0, intervention: 0, sec: 0, access: 0, prod: 0, test: 0 };
+  for (const r of rows) {
+    const k = String(r.kind || "");
+    if (k === "web") stats.web += 1;
+    else if (k === "intervention") stats.intervention += 1;
+    else if (k === "sec") stats.sec += 1;
+    else if (k === "access") stats.access += 1;
+    const ns = String(r.ns || "");
+    if (ns === "prod") stats.prod += 1;
+    if (ns === "test") stats.test += 1;
+  }
+  return stats;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, fileStoreStats, "fileStoreStats");
+async function fileStoreDeleteByFile($asai, fileName, ns = "") {
+  await ensureMigrated($asai);
+  const base = storeBaseAbs($asai);
+  const root = indexRootAbs($asai);
+  let removed = 0;
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await _promises2.default.readdir(dir, { withFileTypes: true });
+    } catch (e6) {
+      return;
+    }
+    for (const ent of entries) {
+      const full = _path2.default.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        await walk(full);
+      } else if (ent.isFile() && ent.name.endsWith(".json")) {
+        try {
+          const raw = await _promises2.default.readFile(full, "utf8");
+          const parsed = JSON.parse(raw);
+          if (String(parsed.file_name) !== fileName) continue;
+          if (ns && String(parsed.ns) !== ns) continue;
+          await _promises2.default.unlink(full);
+          removed += 1;
+        } catch (e7) {
+        }
+      }
+    }
+  }
+  _chunkSMVZ3ZDJcjs.__name.call(void 0, walk, "walk");
+  await walk(root);
+  return removed;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, fileStoreDeleteByFile, "fileStoreDeleteByFile");
+async function fileStoreDiskStats($asai) {
+  const logger = _optionalChain([$asai, 'optionalAccess', _ => _.hostconfig, 'optionalAccess', _2 => _2.logger]) || {};
+  const scanDirs = [
+    { kind: "web", dir: _optionalChain([logger, 'access', _3 => _3.path, 'optionalAccess', _4 => _4.server]) },
+    { kind: "web", dir: _optionalChain([logger, 'access', _5 => _5.path, 'optionalAccess', _6 => _6.client]) },
+    { kind: "access", dir: _optionalChain([logger, 'access', _7 => _7.path, 'optionalAccess', _8 => _8.access]) },
+    { kind: "intervention", dir: _optionalChain([logger, 'access', _9 => _9.intervention, 'optionalAccess', _10 => _10.path]), ns: "prod" },
+    { kind: "intervention", dir: _optionalChain([logger, 'access', _11 => _11.intervention, 'optionalAccess', _12 => _12.testPath]), ns: "test" }
+  ].filter((d) => d.dir);
+  const stats = { total: 0, web: 0, intervention: 0, sec: 0, access: 0, prod: 0, test: 0 };
+  for (const { kind, dir, ns } of scanDirs) {
+    let count = 0;
+    try {
+      const entries = await _promises2.default.readdir(String(dir), { withFileTypes: true });
+      for (const ent of entries) {
+        if (!ent.isFile()) continue;
+        if (ent.name.endsWith(".delete") || ent.name.startsWith(".")) continue;
+        count += 1;
+      }
+    } catch (e8) {
+      continue;
+    }
+    if (kind === "web") stats.web += count;
+    else if (kind === "intervention") stats.intervention += count;
+    else if (kind === "access") stats.access += count;
+    if (ns === "prod") stats.prod += count;
+    if (ns === "test") stats.test += count;
+    stats.total += count;
+  }
+  const indexStats = await fileStoreStats($asai).catch(() => ({ sec: 0 }));
+  stats.sec = indexStats.sec || 0;
+  return stats;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, fileStoreDiskStats, "fileStoreDiskStats");
+function getFileStorePaths($asai) {
+  const base = storeBaseAbs($asai);
+  return { base, index: _path2.default.join(base, INDEX_ROOT) };
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, getFileStorePaths, "getFileStorePaths");
+
+// src/sysserver/lib/common/log-db.ts
+var LOG_ENTRY_FIELDS = [
+  "kind",
+  "ns",
+  "source",
+  "log_date",
+  "file_name",
+  "event_type",
+  "category",
+  "severity",
+  "us",
+  "message",
+  "raw_line",
+  "chain_hash",
+  "prev_hash",
+  "outcome",
+  "identification",
+  "retention_protected",
+  "created_at"
+];
+var TABLE_LOG_ENTRIES = "asai_log_entries";
+var SQLITE_FALLBACK_KEY = "_logStoreUseFileFallback";
+function getLogStoreConfig($asai) {
+  const resolved = _chunkHHPGUJ75cjs.resolveStoreConfig.call(void 0, $asai, "log");
+  return {
+    type: resolved.type,
+    opt: _chunkHHPGUJ75cjs.normalizeStoreOpt.call(void 0, "log", resolved.type, resolved.opt)
+  };
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, getLogStoreConfig, "getLogStoreConfig");
+var STORE_TYPE_LABELS = {
+  file: "File",
+  sqlite: "SQLite",
+  mysql: "MySQL"
+};
+function getLogStoreMeta($asai) {
+  const cfg = getLogStoreConfig($asai);
+  const effective = getEffectiveStoreType($asai);
+  const { type: configuredType, opt } = cfg;
+  const type = effective === "none" ? configuredType : effective;
+  const enabled = isLogStoreEnabled($asai);
+  const logger = _optionalChain([$asai, 'optionalAccess', _13 => _13.hostconfig, 'optionalAccess', _14 => _14.logger]) || {};
+  const fallback = _optionalChain([$asai, 'optionalAccess', _15 => _15[SQLITE_FALLBACK_KEY]]);
+  const meta = {
+    type,
+    configuredType,
+    enabled,
+    label: STORE_TYPE_LABELS[type] || type,
+    mode: type === "file" ? "file-folder" : type,
+    dualWrite: true,
+    folderManaged: type === "file",
+    create: _nullishCoalesce(opt.create, () => ( 1)),
+    fallbackFrom: fallback ? configuredType : void 0,
+    fallbackReason: _optionalChain([fallback, 'optionalAccess', _16 => _16.reason]),
+    compliancePaths: {
+      server: _optionalChain([logger, 'access', _17 => _17.path, 'optionalAccess', _18 => _18.server]),
+      client: _optionalChain([logger, 'access', _19 => _19.path, 'optionalAccess', _20 => _20.client]),
+      access: _optionalChain([logger, 'access', _21 => _21.path, 'optionalAccess', _22 => _22.access]),
+      intervention: _optionalChain([logger, 'access', _23 => _23.intervention, 'optionalAccess', _24 => _24.path]),
+      interventionTest: _optionalChain([logger, 'access', _25 => _25.intervention, 'optionalAccess', _26 => _26.testPath]),
+      interventionArchive: _optionalChain([logger, 'access', _27 => _27.intervention, 'optionalAccess', _28 => _28.archivePath])
+    }
+  };
+  if (type === "file") {
+    const paths = getFileStorePaths($asai);
+    meta.dir = opt.dir;
+    meta.ext = opt.ext || ".json";
+    meta.indexDir = paths.index;
+    meta.layout = "index/{kind}/{ns}/{source}/{log_date}/{id}.json";
+    meta.location = String(opt.dir || "");
+  } else if (type === "sqlite") {
+    meta.database = opt.database;
+    meta.location = String(opt.database || "");
+  } else if (type === "mysql") {
+    meta.host = opt.host;
+    meta.database = opt.database;
+    meta.location = `${opt.host || "127.0.0.1"}/${opt.database || "asai_logs"}`;
+  }
+  return meta;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, getLogStoreMeta, "getLogStoreMeta");
+function isLogStoreEnabled($asai) {
+  return getEffectiveStoreType($asai) !== "none";
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, isLogStoreEnabled, "isLogStoreEnabled");
+function isLogStoreFileBackend($asai) {
+  return getEffectiveStoreType($asai) === "file";
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, isLogStoreFileBackend, "isLogStoreFileBackend");
+function prefersDiskLogAccess($asai) {
+  return isLogStoreFileBackend($asai);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, prefersDiskLogAccess, "prefersDiskLogAccess");
+function markSqliteFallback($asai, reason) {
+  if (!$asai[SQLITE_FALLBACK_KEY]) {
+    $asai[SQLITE_FALLBACK_KEY] = { at: Date.now(), reason: String(_optionalChain([reason, 'optionalAccess', _29 => _29.message]) || reason || "sqlite unavailable") };
+    try {
+      (_optionalChain([$asai, 'optionalAccess', _30 => _30.$log]) || console.warn)("LOG", "[store] SQLite unavailable, fallback to file folder storage:", $asai[SQLITE_FALLBACK_KEY].reason);
+    } catch (e9) {
+    }
+  }
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, markSqliteFallback, "markSqliteFallback");
+function getEffectiveStoreType($asai) {
+  const cfg = getLogStoreConfig($asai).type;
+  if (_optionalChain([$asai, 'optionalAccess', _31 => _31[SQLITE_FALLBACK_KEY]]) && (cfg === "sqlite" || cfg === "mysql")) return "file";
+  if (cfg === "file" || cfg === "sqlite" || cfg === "mysql") return cfg;
+  return "none";
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, getEffectiveStoreType, "getEffectiveStoreType");
+function dbType($asai) {
+  return getEffectiveStoreType($asai);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, dbType, "dbType");
+function rowToRecord2(row) {
+  const out = { ...row };
+  for (const k of ["severity", "retention_protected", "created_at", "id"]) {
+    if (out[k] != null && out[k] !== "") out[k] = Number(out[k]);
+  }
+  return out;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, rowToRecord2, "rowToRecord");
+function isTableMissing(err) {
+  const msg = String(_optionalChain([err, 'optionalAccess', _32 => _32.message]) || err || "");
+  return msg.includes("no such table") || msg.includes("doesn't exist");
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, isTableMissing, "isTableMissing");
+function isSqliteUnavailable(err) {
+  const msg = String(_optionalChain([err, 'optionalAccess', _33 => _33.message]) || err || "").toLowerCase();
+  return isTableMissing(err) || msg.includes("sqlite") || msg.includes("cannot open") || msg.includes("unable to open") || msg.includes("enoent") || msg.includes("not a directory");
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, isSqliteUnavailable, "isSqliteUnavailable");
+var LOG_TABLE_ENSURED = "_logTableEnsured";
+var ensureLogTablePromise = null;
+async function ensureLogTable($asai) {
+  if ($asai[LOG_TABLE_ENSURED]) return;
+  if (getLogStoreConfig($asai).type !== "sqlite") return;
+  if (!ensureLogTablePromise) {
+    ensureLogTablePromise = (async () => {
+      const db = getDb($asai);
+      try {
+        await db.sqlDb({ type: "select", table: TABLE_LOG_ENTRIES, field: ["id"], limit: 1 });
+      } catch (err) {
+        if (!isTableMissing(err)) throw err;
+        await db.sqlDb({
+          type: "insert",
+          table: TABLE_LOG_ENTRIES,
+          field: [...LOG_ENTRY_FIELDS],
+          value: [
+            LOG_ENTRY_FIELDS.map((f) => {
+              if (f === "severity" || f === "retention_protected" || f === "created_at") return _chunkHHPGUJ75cjs.qNum.call(void 0, 0);
+              return _chunkHHPGUJ75cjs.qStr.call(void 0, "", "sqlite");
+            })
+          ]
+        });
+      }
+      $asai[LOG_TABLE_ENSURED] = true;
+    })();
+  }
+  try {
+    await ensureLogTablePromise;
+  } catch (err) {
+    ensureLogTablePromise = null;
+    throw err;
+  }
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, ensureLogTable, "ensureLogTable");
+async function beforeSqliteLogOp($asai) {
+  if (getLogStoreConfig($asai).type === "sqlite" && !$asai[SQLITE_FALLBACK_KEY]) {
+    await ensureLogTable($asai);
+  }
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, beforeSqliteLogOp, "beforeSqliteLogOp");
+function isLogStoreSqlite($asai) {
+  return getEffectiveStoreType($asai) === "sqlite" || getEffectiveStoreType($asai) === "mysql";
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, isLogStoreSqlite, "isLogStoreSqlite");
+function getDb($asai) {
+  return _chunkHHPGUJ75cjs.getDataServer.call(void 0, $asai, "log");
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, getDb, "getDb");
+async function dbInsertLogEntry($asai, row) {
+  if (!isLogStoreEnabled($asai)) return;
+  const type = dbType($asai);
+  if (type === "file") {
+    await fileStoreInsert($asai, row);
+    return;
+  }
+  const db = getDb($asai);
+  try {
+    await beforeSqliteLogOp($asai);
+    await db.sqlDb({
+      type: "insert",
+      table: TABLE_LOG_ENTRIES,
+      field: [...LOG_ENTRY_FIELDS],
+      value: [
+        LOG_ENTRY_FIELDS.map((f) => {
+          const v = row[f];
+          if (f === "severity" || f === "retention_protected" || f === "created_at") return _chunkHHPGUJ75cjs.qNum.call(void 0, v);
+          return _chunkHHPGUJ75cjs.qStr.call(void 0, v == null ? "" : String(v), type);
+        })
+      ]
+    });
+  } catch (err) {
+    if (getLogStoreConfig($asai).type === "sqlite" && isSqliteUnavailable(err)) {
+      markSqliteFallback($asai, err);
+      await fileStoreInsert($asai, row);
+      return;
+    }
+    throw err;
+  }
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, dbInsertLogEntry, "dbInsertLogEntry");
+async function dbQueryLogEntries($asai, filter = {}) {
+  if (!isLogStoreEnabled($asai)) return [];
+  const type = dbType($asai);
+  if (type === "file") {
+    return fileStoreQuery($asai, filter);
+  }
+  const db = getDb($asai);
+  const where = [];
+  if (filter.kind) where.push(["kind", "=", _chunkHHPGUJ75cjs.qStr.call(void 0, filter.kind, type)]);
+  if (filter.ns) where.push(["ns", "=", _chunkHHPGUJ75cjs.qStr.call(void 0, filter.ns, type)]);
+  if (filter.source) where.push(["source", "=", _chunkHHPGUJ75cjs.qStr.call(void 0, filter.source, type)]);
+  if (filter.log_date) where.push(["log_date", "=", _chunkHHPGUJ75cjs.qStr.call(void 0, filter.log_date, type)]);
+  if (filter.file_name) where.push(["file_name", "=", _chunkHHPGUJ75cjs.qStr.call(void 0, filter.file_name, type)]);
+  try {
+    await beforeSqliteLogOp($asai);
+    const res = await db.sqlDb({
+      type: "select",
+      table: TABLE_LOG_ENTRIES,
+      field: ["id", ...LOG_ENTRY_FIELDS],
+      where: where.length ? where : void 0,
+      order: [["created_at", "desc"], ["id", "desc"]],
+      limit: _nullishCoalesce(filter.limit, () => ( 500))
+    });
+    return _chunkHHPGUJ75cjs.asRows.call(void 0, res).map(rowToRecord2);
+  } catch (err) {
+    if (isTableMissing(err) || isSqliteUnavailable(err)) {
+      if (getLogStoreConfig($asai).type === "sqlite") markSqliteFallback($asai, err);
+      return fileStoreQuery($asai, filter);
+    }
+    throw err;
+  }
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, dbQueryLogEntries, "dbQueryLogEntries");
+async function dbGetLogEntry($asai, id) {
+  if (!isLogStoreEnabled($asai)) return null;
+  const type = dbType($asai);
+  if (type === "file") {
+    return fileStoreGet($asai, id);
+  }
+  const db = getDb($asai);
+  try {
+    await beforeSqliteLogOp($asai);
+    const res = await db.sqlDb({
+      type: "select",
+      table: TABLE_LOG_ENTRIES,
+      field: ["id", ...LOG_ENTRY_FIELDS],
+      where: [["id", "=", _chunkHHPGUJ75cjs.qNum.call(void 0, Number(id))]],
+      limit: 1
+    });
+    const rows = _chunkHHPGUJ75cjs.asRows.call(void 0, res);
+    return rows.length ? rowToRecord2(rows[0]) : null;
+  } catch (err) {
+    if (isTableMissing(err) || isSqliteUnavailable(err)) {
+      if (getLogStoreConfig($asai).type === "sqlite") markSqliteFallback($asai, err);
+      return fileStoreGet($asai, id);
+    }
+    throw err;
+  }
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, dbGetLogEntry, "dbGetLogEntry");
+async function dbListLogGroups($asai, filter = {}) {
+  const entries = await dbQueryLogEntries($asai, {
+    kind: filter.kind,
+    ns: filter.ns,
+    source: filter.source,
+    limit: 5e3
+  });
+  const groups = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const kind = String(e.kind || "");
+    const ns = String(e.ns || "");
+    const source = String(e.source || "");
+    const logDate = String(e.log_date || "");
+    const fileName = String(e.file_name || (kind === "web" ? `log-${logDate}.txt` : ""));
+    const key = `${kind}|${ns}|${source}|${fileName}`;
+    const created = Number(e.created_at || 0);
+    const g = groups.get(key);
+    if (!g) {
+      groups.set(key, { key, kind, ns, source, log_date: logDate, file_name: fileName, entryCount: 1, lastAt: created });
+    } else {
+      g.entryCount += 1;
+      if (created > g.lastAt) g.lastAt = created;
+    }
+  }
+  return [...groups.values()].sort((a, b) => b.lastAt - a.lastAt);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, dbListLogGroups, "dbListLogGroups");
+function countStatsFromRows(rows) {
+  const stats = { total: rows.length, web: 0, intervention: 0, sec: 0, access: 0, prod: 0, test: 0 };
+  for (const r of rows) {
+    const k = String(r.kind || "");
+    if (k === "web") stats.web += 1;
+    else if (k === "intervention") stats.intervention += 1;
+    else if (k === "sec") stats.sec += 1;
+    else if (k === "access") stats.access += 1;
+    const ns = String(r.ns || "");
+    if (ns === "prod") stats.prod += 1;
+    if (ns === "test") stats.test += 1;
+  }
+  return stats;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, countStatsFromRows, "countStatsFromRows");
+function applySearchFilters2(rows, filter) {
+  let out = rows;
+  if (filter.keyword) {
+    const kw = filter.keyword.toLowerCase();
+    out = out.filter((r) => {
+      const hay = [r.message, r.raw_line, r.event_type, r.us, r.identification, r.category].map((v) => String(v || "").toLowerCase()).join(" ");
+      return hay.includes(kw);
+    });
+  }
+  if (filter.event_type) {
+    const et = filter.event_type.toUpperCase();
+    out = out.filter((r) => String(r.event_type || "").toUpperCase() === et);
+  }
+  if (filter.severity_min != null && !Number.isNaN(Number(filter.severity_min))) {
+    const min = Number(filter.severity_min);
+    out = out.filter((r) => Number(r.severity || 0) >= min);
+  }
+  if (filter.date_from) {
+    out = out.filter((r) => String(r.log_date || "") >= filter.date_from);
+  }
+  if (filter.date_to) {
+    out = out.filter((r) => String(r.log_date || "") <= filter.date_to);
+  }
+  if (filter.outcome) {
+    const oc = filter.outcome.toLowerCase();
+    out = out.filter((r) => String(r.outcome || "").toLowerCase() === oc);
+  }
+  return out;
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, applySearchFilters2, "applySearchFilters");
+async function dbSearchLogEntries($asai, filter = {}) {
+  if (!isLogStoreEnabled($asai)) return { entries: [], total: 0, truncated: false };
+  if (dbType($asai) === "file") return fileStoreSearch($asai, filter);
+  const baseLimit = 2e4;
+  const rows = await dbQueryLogEntries($asai, {
+    kind: filter.kind,
+    ns: filter.ns,
+    source: filter.source,
+    log_date: filter.log_date,
+    file_name: filter.file_name,
+    limit: baseLimit
+  });
+  const filtered = applySearchFilters2(rows, filter);
+  const offset = Math.max(0, Number(filter.offset) || 0);
+  const limit = Math.min(2e3, Math.max(1, Number(filter.limit) || 200));
+  const entries = filtered.slice(offset, offset + limit);
+  return {
+    entries,
+    total: filtered.length,
+    truncated: rows.length >= baseLimit
+  };
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, dbSearchLogEntries, "dbSearchLogEntries");
+async function dbLogStats($asai) {
+  if (!isLogStoreEnabled($asai)) {
+    return { total: 0, web: 0, intervention: 0, sec: 0, access: 0, prod: 0, test: 0 };
+  }
+  const type = dbType($asai);
+  if (type === "file") {
+    const disk = await fileStoreDiskStats($asai);
+    const index = await fileStoreStats($asai).catch(() => null);
+    if (index && index.total > 0) {
+      return { ...disk, sec: index.sec, total: Math.max(disk.total, index.total) };
+    }
+    return disk;
+  }
+  const db = getDb($asai);
+  try {
+    await beforeSqliteLogOp($asai);
+    const res = await db.sqlDb({
+      type: "select",
+      table: TABLE_LOG_ENTRIES,
+      field: ["kind", "ns"],
+      limit: 1e5
+    });
+    return countStatsFromRows(_chunkHHPGUJ75cjs.asRows.call(void 0, res));
+  } catch (err) {
+    if (isTableMissing(err) || isSqliteUnavailable(err)) {
+      if (getLogStoreConfig($asai).type === "sqlite") markSqliteFallback($asai, err);
+      return fileStoreDiskStats($asai);
+    }
+    throw err;
+  }
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, dbLogStats, "dbLogStats");
+async function dbDeleteLogEntriesByFile($asai, fileName, ns = "") {
+  if (!isLogStoreEnabled($asai)) return 0;
+  const type = dbType($asai);
+  if (type === "file") {
+    return fileStoreDeleteByFile($asai, fileName, ns);
+  }
+  const db = getDb($asai);
+  const where = [["file_name", "=", _chunkHHPGUJ75cjs.qStr.call(void 0, fileName, type)]];
+  if (ns) where.push(["ns", "=", _chunkHHPGUJ75cjs.qStr.call(void 0, ns, type)]);
+  try {
+    await beforeSqliteLogOp($asai);
+    const res = await db.sqlDb({
+      type: "delete",
+      table: TABLE_LOG_ENTRIES,
+      where
+    });
+    if (res && typeof res === "object" && "changes" in res) return Number(res.changes || 0);
+    return 0;
+  } catch (err) {
+    if (isTableMissing(err) || isSqliteUnavailable(err)) {
+      if (getLogStoreConfig($asai).type === "sqlite") markSqliteFallback($asai, err);
+      return fileStoreDeleteByFile($asai, fileName, ns);
+    }
+    throw err;
+  }
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, dbDeleteLogEntriesByFile, "dbDeleteLogEntriesByFile");
+
+// src/sysserver/lib/common/LogStore.ts
+async function mirrorWebLog($asai, opts) {
+  if (!isLogStoreEnabled($asai)) return;
+  const now = /* @__PURE__ */ new Date();
+  const logDate = _chunkO6LVLSNBcjs.getNowTime.call(void 0, 2, now);
+  const kind = opts.source === "sec" ? "sec" : "web";
+  await dbInsertLogEntry($asai, {
+    kind,
+    ns: "",
+    source: opts.source,
+    log_date: logDate,
+    file_name: `log-${logDate}.txt`,
+    event_type: "",
+    category: kind === "sec" ? "AuditLogEvents" : "",
+    severity: kind === "sec" ? 7 : 2,
+    us: "",
+    message: opts.message || opts.rawLine.slice(0, 2e3),
+    raw_line: opts.rawLine,
+    chain_hash: "",
+    prev_hash: "",
+    outcome: "",
+    identification: "",
+    retention_protected: 0,
+    created_at: now.getTime()
+  });
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, mirrorWebLog, "mirrorWebLog");
+async function mirrorInterventionLog($asai, opts) {
+  if (!isLogStoreEnabled($asai)) return;
+  const logDate = _chunkO6LVLSNBcjs.getNowTime.call(void 0, 2);
+  const isAudit = opts.fileName.includes("deletion-audit");
+  await dbInsertLogEntry($asai, {
+    kind: "intervention",
+    ns: opts.ns,
+    source: "",
+    log_date: logDate,
+    file_name: opts.fileName,
+    event_type: opts.event.type,
+    category: opts.category,
+    severity: opts.severity,
+    us: opts.event.us || "",
+    message: opts.event.detail || opts.event.name,
+    raw_line: opts.rawLine,
+    chain_hash: opts.chainHash,
+    prev_hash: opts.prevHash,
+    outcome: opts.event.outcome || "Success",
+    identification: opts.event.identification || "",
+    retention_protected: isAudit ? 1 : 0,
+    created_at: Date.now()
+  });
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, mirrorInterventionLog, "mirrorInterventionLog");
+async function mirrorAccessLog($asai, opts) {
+  if (!isLogStoreEnabled($asai)) return;
+  const now = /* @__PURE__ */ new Date();
+  const logDate = _chunkO6LVLSNBcjs.getNowTime.call(void 0, 2, now);
+  const fileName = opts.format === "clf" ? `access-clf-${logDate}.log` : `access-w3c-${logDate}.log`;
+  await dbInsertLogEntry($asai, {
+    kind: "access",
+    ns: "",
+    source: opts.format,
+    log_date: logDate,
+    file_name: fileName,
+    event_type: opts.logType || "HTTP",
+    category: "RequestErrors",
+    severity: opts.status && opts.status >= 500 ? 4 : 2,
+    us: "",
+    message: `${opts.method || "-"} ${opts.url || "-"} ${_nullishCoalesce(opts.status, () => ( "-"))}`,
+    raw_line: opts.rawLine.trim(),
+    chain_hash: "",
+    prev_hash: "",
+    outcome: opts.status && opts.status < 400 ? "Success" : "Failure",
+    identification: opts.host || "",
+    retention_protected: 0,
+    created_at: now.getTime()
+  });
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, mirrorAccessLog, "mirrorAccessLog");
+async function queryUnifiedLogs($asai, filter) {
+  return dbQueryLogEntries($asai, filter);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, queryUnifiedLogs, "queryUnifiedLogs");
+async function searchUnifiedLogs($asai, filter) {
+  return dbSearchLogEntries($asai, filter);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, searchUnifiedLogs, "searchUnifiedLogs");
+async function exportLogContent($asai, opts) {
+  const format = opts.format || "raw";
+  const { readInterventionFile } = await Promise.resolve().then(() => _interopRequireWildcard(require("./InterventionLog-25EHE4QR.cjs")));
+  const ns = opts.ns === "test" ? "test" : "prod";
+  if (opts.kind === "intervention" && opts.fileName) {
+    const data = await readInterventionFile($asai, opts.fileName, ns);
+    if (format === "json") {
+      return {
+        fileName: opts.fileName,
+        format,
+        content: JSON.stringify({ fileName: opts.fileName, ns, parsed: data.parsed, chain: data.chain, meta: data.meta }, null, 2),
+        mime: "application/json",
+        lineCount: data.parsed.length
+      };
+    }
+    return {
+      fileName: opts.fileName,
+      format: format === "cef" ? "cef" : "raw",
+      content: data.raw,
+      mime: "text/plain",
+      lineCount: data.parsed.length
+    };
+  }
+  const fileName = opts.fileName || "";
+  const source = opts.source || "server";
+  let content = "";
+  if (fileName.startsWith("log-")) {
+    content = await readWebLogFromStore($asai, source, fileName);
+  } else if (isLogStoreEnabled($asai)) {
+    const rows = await dbQueryLogEntries($asai, {
+      kind: opts.kind === "intervention" ? "intervention" : opts.kind,
+      ns: opts.ns,
+      source,
+      file_name: fileName || void 0,
+      limit: 5e3
+    });
+    content = rows.reverse().map((r) => String(r.raw_line || "")).join("");
+  }
+  if (format === "json") {
+    const rows = await dbQueryLogEntries($asai, {
+      kind: opts.kind === "intervention" ? "intervention" : opts.kind,
+      ns: opts.ns,
+      source,
+      file_name: fileName || void 0,
+      limit: 5e3
+    });
+    return {
+      fileName: fileName || "export.json",
+      format,
+      content: JSON.stringify({ fileName, source, entries: rows }, null, 2),
+      mime: "application/json",
+      lineCount: rows.length
+    };
+  }
+  const lineCount = content ? content.split("\n").filter((l) => l.trim()).length : 0;
+  return {
+    fileName: fileName || "export.log",
+    format: "raw",
+    content,
+    mime: "text/plain",
+    lineCount
+  };
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, exportLogContent, "exportLogContent");
+async function getComplianceReport($asai, ns = "prod") {
+  const { listInterventionFiles, readInterventionFile } = await Promise.resolve().then(() => _interopRequireWildcard(require("./InterventionLog-25EHE4QR.cjs")));
+  const retentionYears = _nullishCoalesce(_optionalChain([$asai, 'optionalAccess', _34 => _34.hostconfig, 'optionalAccess', _35 => _35.logger, 'optionalAccess', _36 => _36.intervention, 'optionalAccess', _37 => _37.retentionYears]), () => ( 5));
+  const stats = await dbLogStats($asai);
+  const storeMeta = getLogStoreMeta($asai);
+  const effectiveType = getEffectiveStoreType($asai);
+  let files = [];
+  try {
+    files = await listInterventionFiles($asai, ns);
+  } catch (e10) {
+    files = [];
+  }
+  const chainChecks = [];
+  for (const f of files.slice(0, 30)) {
+    if (!_optionalChain([f, 'access', _38 => _38.name, 'optionalAccess', _39 => _39.includes, 'call', _40 => _40(".cef.")])) continue;
+    try {
+      const data = await readInterventionFile($asai, f.name, ns);
+      chainChecks.push({
+        fileName: f.name,
+        entryCount: data.parsed.length,
+        chainOk: data.chain.ok,
+        brokenLines: data.chain.results.filter((r) => !r.ok).length,
+        protectedAudit: !!f.protectedAudit,
+        expired: !!f.expired
+      });
+    } catch (e11) {
+      chainChecks.push({
+        fileName: f.name,
+        entryCount: 0,
+        chainOk: false,
+        brokenLines: -1,
+        protectedAudit: !!f.protectedAudit,
+        expired: !!f.expired
+      });
+    }
+  }
+  const allChainsOk = chainChecks.length > 0 && chainChecks.every((c) => c.chainOk);
+  const disk = await measureLogDiskUsage($asai);
+  const diskThreshold = Number(_optionalChain([$asai, 'optionalAccess', _41 => _41.hostconfig, 'optionalAccess', _42 => _42.logger, 'optionalAccess', _43 => _43.diskAlertMb]) || 512) * 1048576;
+  if (disk.totalBytes >= diskThreshold) {
+    const { alertDiskUsage } = await Promise.resolve().then(() => _interopRequireWildcard(require("./log-alert-LAJ6VSAG.cjs")));
+    alertDiskUsage($asai, "log", disk.totalBytes, diskThreshold);
+  }
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ns,
+    retentionYears,
+    store: {
+      enabled: !!storeMeta.enabled,
+      type: effectiveType,
+      label: storeMeta.label,
+      mode: storeMeta.mode,
+      location: storeMeta.location,
+      dir: storeMeta.dir,
+      database: storeMeta.database,
+      indexDir: storeMeta.indexDir,
+      layout: storeMeta.layout,
+      dualWrite: storeMeta.dualWrite,
+      folderManaged: storeMeta.folderManaged,
+      fallbackFrom: storeMeta.fallbackFrom,
+      fallbackReason: storeMeta.fallbackReason
+    },
+    stats,
+    fileCount: files.length,
+    disk,
+    chainSummary: {
+      checked: chainChecks.length,
+      allOk: allChainsOk,
+      brokenFiles: chainChecks.filter((c) => !c.chainOk).map((c) => c.fileName)
+    },
+    chainChecks,
+    formats: ["CLF", "W3C Extended", "CEF"]
+  };
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, getComplianceReport, "getComplianceReport");
+async function measureLogDiskUsage($asai) {
+  const fsp = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+  const pathMod = await Promise.resolve().then(() => _interopRequireWildcard(require("path")));
+  const storeMeta = getLogStoreMeta($asai);
+  const dirs = {};
+  const paths = [
+    _optionalChain([$asai, 'optionalAccess', _44 => _44.hostconfig, 'optionalAccess', _45 => _45.logger, 'optionalAccess', _46 => _46.path, 'optionalAccess', _47 => _47.access]),
+    _optionalChain([$asai, 'optionalAccess', _48 => _48.hostconfig, 'optionalAccess', _49 => _49.logger, 'optionalAccess', _50 => _50.path, 'optionalAccess', _51 => _51.server]),
+    _optionalChain([$asai, 'optionalAccess', _52 => _52.hostconfig, 'optionalAccess', _53 => _53.logger, 'optionalAccess', _54 => _54.path, 'optionalAccess', _55 => _55.client]),
+    _optionalChain([$asai, 'optionalAccess', _56 => _56.hostconfig, 'optionalAccess', _57 => _57.logger, 'optionalAccess', _58 => _58.intervention, 'optionalAccess', _59 => _59.path]),
+    _optionalChain([$asai, 'optionalAccess', _60 => _60.hostconfig, 'optionalAccess', _61 => _61.logger, 'optionalAccess', _62 => _62.intervention, 'optionalAccess', _63 => _63.testPath]),
+    _optionalChain([$asai, 'optionalAccess', _64 => _64.hostconfig, 'optionalAccess', _65 => _65.logger, 'optionalAccess', _66 => _66.intervention, 'optionalAccess', _67 => _67.archivePath])
+  ].filter(Boolean);
+  if (storeMeta.type === "file" && storeMeta.dir) {
+    paths.push(String(storeMeta.dir));
+  }
+  async function dirSize(dir) {
+    let total = 0;
+    try {
+      const entries = await fsp.readdir(dir, { withFileTypes: true });
+      for (const ent of entries) {
+        const full = pathMod.join(dir, ent.name);
+        if (ent.isDirectory()) total += await dirSize(full);
+        else {
+          const st = await fsp.stat(full);
+          total += st.size;
+        }
+      }
+    } catch (e12) {
+    }
+    return total;
+  }
+  _chunkSMVZ3ZDJcjs.__name.call(void 0, dirSize, "dirSize");
+  async function fileSize(filePath) {
+    try {
+      const st = await fsp.stat(filePath);
+      return st.isFile() ? st.size : 0;
+    } catch (e13) {
+      return 0;
+    }
+  }
+  _chunkSMVZ3ZDJcjs.__name.call(void 0, fileSize, "fileSize");
+  let totalBytes = 0;
+  for (const d of paths) {
+    const bytes = await dirSize(d);
+    dirs[d] = bytes;
+    totalBytes += bytes;
+  }
+  if (storeMeta.type === "sqlite" && storeMeta.database) {
+    const dbPath = String(storeMeta.database);
+    const bytes = await fileSize(dbPath);
+    dirs[dbPath] = bytes;
+    totalBytes += bytes;
+  }
+  return { totalBytes, dirs };
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, measureLogDiskUsage, "measureLogDiskUsage");
+async function archiveInterventionYear($asai, opts) {
+  const fsp = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+  const path2 = await Promise.resolve().then(() => _interopRequireWildcard(require("path")));
+  const zlib = await Promise.resolve().then(() => _interopRequireWildcard(require("zlib")));
+  const { pipeline } = await Promise.resolve().then(() => _interopRequireWildcard(require("stream/promises")));
+  const { createReadStream, createWriteStream } = await Promise.resolve().then(() => _interopRequireWildcard(require("fs")));
+  const ns = opts.ns || "prod";
+  const { listInterventionFiles, readInterventionFile } = await Promise.resolve().then(() => _interopRequireWildcard(require("./InterventionLog-25EHE4QR.cjs")));
+  const yearStr = String(opts.year);
+  const archiveBase = _optionalChain([$asai, 'optionalAccess', _68 => _68.hostconfig, 'optionalAccess', _69 => _69.logger, 'optionalAccess', _70 => _70.intervention, 'optionalAccess', _71 => _71.archivePath]) || path2.join(_optionalChain([$asai, 'optionalAccess', _72 => _72.hostconfig, 'optionalAccess', _73 => _73.logger, 'optionalAccess', _74 => _74.intervention, 'optionalAccess', _75 => _75.path]) || "./webdata/webdb/log/intervention/", "archive/");
+  const archiveDir = path2.join(archiveBase, yearStr);
+  const files = await listInterventionFiles($asai, ns);
+  const targets = files.filter((f) => f.name.includes(`intervention-${yearStr}-`) && f.name.endsWith(".cef.log"));
+  const archived = [];
+  const skipped = [];
+  const errors = [];
+  for (const f of targets) {
+    const gzName = `${f.name}.gz`;
+    const gzPath = path2.join(archiveDir, gzName);
+    try {
+      const content = await readInterventionFile($asai, f.name, ns);
+      if (!content.chain.ok) {
+        errors.push(`${f.name}: chain verification failed`);
+        continue;
+      }
+      if (opts.dryRun) {
+        skipped.push(`${f.name} (dry-run)`);
+        continue;
+      }
+      await fsp.mkdir(archiveDir, { recursive: true });
+      if (await fsp.stat(gzPath).then(() => true).catch(() => false)) {
+        skipped.push(`${f.name}: archive exists`);
+        continue;
+      }
+      const srcPath = path2.join(
+        ns === "test" ? _optionalChain([$asai, 'optionalAccess', _76 => _76.hostconfig, 'optionalAccess', _77 => _77.logger, 'optionalAccess', _78 => _78.intervention, 'optionalAccess', _79 => _79.testPath]) || "./webdata/webdb/log/intervention-test/" : _optionalChain([$asai, 'optionalAccess', _80 => _80.hostconfig, 'optionalAccess', _81 => _81.logger, 'optionalAccess', _82 => _82.intervention, 'optionalAccess', _83 => _83.path]) || "./webdata/webdb/log/intervention/",
+        f.name
+      );
+      await pipeline(
+        createReadStream(srcPath),
+        zlib.createGzip(),
+        createWriteStream(gzPath)
+      );
+      await fsp.unlink(srcPath);
+      await purgeStoreEntriesForFile($asai, f.name, ns);
+      const { logProcessGuardEvent } = await Promise.resolve().then(() => _interopRequireWildcard(require("./intervention-hooks-LE6X4C6N.cjs")));
+      await logProcessGuardEvent($asai, {
+        action: "archive_intervention",
+        detail: `${f.name} -> ${gzPath}`,
+        outcome: "Success",
+        severity: 6
+      });
+      archived.push(f.name);
+    } catch (err) {
+      errors.push(`${f.name}: ${_optionalChain([err, 'optionalAccess', _84 => _84.message]) || err}`);
+    }
+  }
+  return { archived, skipped, errors };
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, archiveInterventionYear, "archiveInterventionYear");
+async function listUnifiedGroups($asai, filter = {}) {
+  return dbListLogGroups($asai, filter);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, listUnifiedGroups, "listUnifiedGroups");
+async function getUnifiedStats($asai) {
+  return dbLogStats($asai);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, getUnifiedStats, "getUnifiedStats");
+async function getUnifiedEntry($asai, id) {
+  return dbGetLogEntry($asai, id);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, getUnifiedEntry, "getUnifiedEntry");
+async function purgeStoreEntriesForFile($asai, fileName, ns = "") {
+  return dbDeleteLogEntriesByFile($asai, fileName, ns);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, purgeStoreEntriesForFile, "purgeStoreEntriesForFile");
+async function purgeSqliteEntriesForFile($asai, fileName, ns = "") {
+  return purgeStoreEntriesForFile($asai, fileName, ns);
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, purgeSqliteEntriesForFile, "purgeSqliteEntriesForFile");
+function groupsToManageChildren(groups) {
+  return groups.filter((g) => g.kind === "web" || g.kind === "sec").map((g) => ({
+    name: g.file_name,
+    path: g.file_name,
+    size: g.entryCount,
+    entryCount: g.entryCount,
+    source: g.source,
+    fromStore: true
+  }));
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, groupsToManageChildren, "groupsToManageChildren");
+function groupsToInterventionFiles(groups, ns) {
+  return groups.filter((g) => g.kind === "intervention" && (!ns || g.ns === ns)).map((g) => ({
+    name: g.file_name,
+    ns: g.ns || ns,
+    size: g.entryCount,
+    mtime: new Date(g.lastAt).toISOString(),
+    entryCount: g.entryCount,
+    ageDays: 0,
+    retentionDays: 0,
+    retentionYears: 5,
+    expired: false,
+    protectedAudit: g.file_name.includes("deletion-audit"),
+    fromStore: true
+  }));
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, groupsToInterventionFiles, "groupsToInterventionFiles");
+async function readWebLogFromStore($asai, source, fileName) {
+  const m = fileName.match(/log-(\d{4}-\d{2}-\d{2})/);
+  const logDate = _optionalChain([m, 'optionalAccess', _85 => _85[1]]) || "";
+  const rows = await dbQueryLogEntries($asai, {
+    kind: source === "sec" ? "sec" : "web",
+    source,
+    log_date: logDate,
+    limit: 5e3
+  });
+  return rows.reverse().map((r) => String(r.raw_line || "")).join("");
+}
+_chunkSMVZ3ZDJcjs.__name.call(void 0, readWebLogFromStore, "readWebLogFromStore");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.getLogStoreConfig = getLogStoreConfig; exports.getLogStoreMeta = getLogStoreMeta; exports.isLogStoreEnabled = isLogStoreEnabled; exports.isLogStoreFileBackend = isLogStoreFileBackend; exports.prefersDiskLogAccess = prefersDiskLogAccess; exports.getEffectiveStoreType = getEffectiveStoreType; exports.isLogStoreSqlite = isLogStoreSqlite; exports.mirrorWebLog = mirrorWebLog; exports.mirrorInterventionLog = mirrorInterventionLog; exports.mirrorAccessLog = mirrorAccessLog; exports.queryUnifiedLogs = queryUnifiedLogs; exports.searchUnifiedLogs = searchUnifiedLogs; exports.exportLogContent = exportLogContent; exports.getComplianceReport = getComplianceReport; exports.archiveInterventionYear = archiveInterventionYear; exports.listUnifiedGroups = listUnifiedGroups; exports.getUnifiedStats = getUnifiedStats; exports.getUnifiedEntry = getUnifiedEntry; exports.purgeStoreEntriesForFile = purgeStoreEntriesForFile; exports.purgeSqliteEntriesForFile = purgeSqliteEntriesForFile; exports.groupsToManageChildren = groupsToManageChildren; exports.groupsToInterventionFiles = groupsToInterventionFiles; exports.readWebLogFromStore = readWebLogFromStore; exports.LogStore_exports = LogStore_exports;
+//# sourceMappingURL=chunk-VLMM735Q.cjs.map