asaihost-nodejs 0.0.1

package/dist/chunk-LOMSUPPU.es.js

@@ -0,0 +1,1202 @@
+import {
+  getNowTime
+} from "./chunk-UTKVJE7N.es.js";
+import {
+  asRows,
+  getDataServer,
+  normalizeStoreOpt,
+  qNum,
+  qStr,
+  resolveStoreConfig
+} from "./chunk-KUZQ36IJ.es.js";
+import {
+  __export,
+  __name
+} from "./chunk-6U2I5EON.es.js";
+
+// src/sysserver/lib/common/LogStore.ts
+var LogStore_exports = {};
+__export(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
+import fs from "fs/promises";
+import path from "path";
+function storeBaseAbs($asai) {
+  const resolved = resolveStoreConfig($asai, "log");
+  const opt = normalizeStoreOpt("log", resolved.type, resolved.opt);
+  const dir = String(opt.dir || "webdata/webdb/log/store/");
+  return path.resolve(process.cwd(), dir);
+}
+__name(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 path.join(storeBaseAbs($asai), INDEX_ROOT);
+}
+__name(indexRootAbs, "indexRootAbs");
+function safeSeg(v) {
+  return (v || "_").replace(/[\\/:*?"<>|]/g, "_").slice(0, 64) || "_";
+}
+__name(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(row.id ?? "0");
+  return path.join(INDEX_ROOT, kind, ns, source, logDate, `${id}.json`);
+}
+__name(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;
+}
+__name(rowToRecord, "rowToRecord");
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+__name(ensureDir, "ensureDir");
+async function readCounter($asai) {
+  const file = path.join(storeBaseAbs($asai), META_ROOT, ID_COUNTER);
+  try {
+    const raw = await fs.readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    return Math.max(0, Number(parsed.next || parsed.last || 0));
+  } catch {
+    return 0;
+  }
+}
+__name(readCounter, "readCounter");
+async function writeCounter($asai, next) {
+  const dir = path.join(storeBaseAbs($asai), META_ROOT);
+  await ensureDir(dir);
+  await fs.writeFile(path.join(dir, ID_COUNTER), JSON.stringify({ next, updatedAt: Date.now() }, null, 2), "utf8");
+}
+__name(writeCounter, "writeCounter");
+async function nextId($asai) {
+  const cur = await readCounter($asai);
+  const id = cur + 1;
+  await writeCounter($asai, id);
+  return id;
+}
+__name(nextId, "nextId");
+async function migrateLegacyBlobIfNeeded($asai) {
+  const base = storeBaseAbs($asai);
+  const legacyPath = path.join(base, LEGACY_BLOB);
+  let legacy = [];
+  try {
+    const raw = await fs.readFile(legacyPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed) && parsed.length) legacy = parsed;
+  } catch {
+    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 = path.join(base, entryRelPath(record));
+    await ensureDir(path.dirname(abs));
+    await fs.writeFile(abs, JSON.stringify(record, null, 2), "utf8");
+  }
+  await writeCounter($asai, maxId);
+  await fs.rename(legacyPath, `${legacyPath}.migrated.${Date.now()}`).catch(() => void 0);
+  return legacy.length;
+}
+__name(migrateLegacyBlobIfNeeded, "migrateLegacyBlobIfNeeded");
+async function walkIndexFiles($asai) {
+  const root = indexRootAbs($asai);
+  const rows = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        await walk(full);
+      } else if (ent.isFile() && ent.name.endsWith(".json")) {
+        try {
+          const raw = await fs.readFile(full, "utf8");
+          const parsed = JSON.parse(raw);
+          if (parsed && typeof parsed === "object") rows.push(rowToRecord(parsed));
+        } catch {
+        }
+      }
+    }
+  }
+  __name(walk, "walk");
+  await walk(root);
+  return rows;
+}
+__name(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;
+}
+__name(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;
+}
+__name(applySearchFilters, "applySearchFilters");
+var migrateOnce = null;
+async function ensureMigrated($asai) {
+  if (!migrateOnce) {
+    migrateOnce = migrateLegacyBlobIfNeeded($asai).then(() => void 0);
+  }
+  await migrateOnce;
+}
+__name(ensureMigrated, "ensureMigrated");
+async function fileStoreInsert($asai, row) {
+  await ensureMigrated($asai);
+  const id = await nextId($asai);
+  const record = rowToRecord({ id, ...row });
+  const abs = path.join(storeBaseAbs($asai), entryRelPath(record));
+  await ensureDir(path.dirname(abs));
+  await fs.writeFile(abs, JSON.stringify(record, null, 2), "utf8");
+}
+__name(fileStoreInsert, "fileStoreInsert");
+async function fileStoreQuery($asai, filter = {}) {
+  await ensureMigrated($asai);
+  const rows = await walkIndexFiles($asai);
+  return applyQueryFilter(rows, { ...filter, limit: filter.limit ?? 500 });
+}
+__name(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;
+}
+__name(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
+  };
+}
+__name(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;
+}
+__name(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 fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        await walk(full);
+      } else if (ent.isFile() && ent.name.endsWith(".json")) {
+        try {
+          const raw = await fs.readFile(full, "utf8");
+          const parsed = JSON.parse(raw);
+          if (String(parsed.file_name) !== fileName) continue;
+          if (ns && String(parsed.ns) !== ns) continue;
+          await fs.unlink(full);
+          removed += 1;
+        } catch {
+        }
+      }
+    }
+  }
+  __name(walk, "walk");
+  await walk(root);
+  return removed;
+}
+__name(fileStoreDeleteByFile, "fileStoreDeleteByFile");
+async function fileStoreDiskStats($asai) {
+  const logger = $asai?.hostconfig?.logger || {};
+  const scanDirs = [
+    { kind: "web", dir: logger.path?.server },
+    { kind: "web", dir: logger.path?.client },
+    { kind: "access", dir: logger.path?.access },
+    { kind: "intervention", dir: logger.intervention?.path, ns: "prod" },
+    { kind: "intervention", dir: logger.intervention?.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 fs.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 {
+      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;
+}
+__name(fileStoreDiskStats, "fileStoreDiskStats");
+function getFileStorePaths($asai) {
+  const base = storeBaseAbs($asai);
+  return { base, index: path.join(base, INDEX_ROOT) };
+}
+__name(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 = resolveStoreConfig($asai, "log");
+  return {
+    type: resolved.type,
+    opt: normalizeStoreOpt("log", resolved.type, resolved.opt)
+  };
+}
+__name(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 = $asai?.hostconfig?.logger || {};
+  const fallback = $asai?.[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: opt.create ?? 1,
+    fallbackFrom: fallback ? configuredType : void 0,
+    fallbackReason: fallback?.reason,
+    compliancePaths: {
+      server: logger.path?.server,
+      client: logger.path?.client,
+      access: logger.path?.access,
+      intervention: logger.intervention?.path,
+      interventionTest: logger.intervention?.testPath,
+      interventionArchive: logger.intervention?.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;
+}
+__name(getLogStoreMeta, "getLogStoreMeta");
+function isLogStoreEnabled($asai) {
+  return getEffectiveStoreType($asai) !== "none";
+}
+__name(isLogStoreEnabled, "isLogStoreEnabled");
+function isLogStoreFileBackend($asai) {
+  return getEffectiveStoreType($asai) === "file";
+}
+__name(isLogStoreFileBackend, "isLogStoreFileBackend");
+function prefersDiskLogAccess($asai) {
+  return isLogStoreFileBackend($asai);
+}
+__name(prefersDiskLogAccess, "prefersDiskLogAccess");
+function markSqliteFallback($asai, reason) {
+  if (!$asai[SQLITE_FALLBACK_KEY]) {
+    $asai[SQLITE_FALLBACK_KEY] = { at: Date.now(), reason: String(reason?.message || reason || "sqlite unavailable") };
+    try {
+      ($asai?.$log || console.warn)("LOG", "[store] SQLite unavailable, fallback to file folder storage:", $asai[SQLITE_FALLBACK_KEY].reason);
+    } catch {
+    }
+  }
+}
+__name(markSqliteFallback, "markSqliteFallback");
+function getEffectiveStoreType($asai) {
+  const cfg = getLogStoreConfig($asai).type;
+  if ($asai?.[SQLITE_FALLBACK_KEY] && (cfg === "sqlite" || cfg === "mysql")) return "file";
+  if (cfg === "file" || cfg === "sqlite" || cfg === "mysql") return cfg;
+  return "none";
+}
+__name(getEffectiveStoreType, "getEffectiveStoreType");
+function dbType($asai) {
+  return getEffectiveStoreType($asai);
+}
+__name(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;
+}
+__name(rowToRecord2, "rowToRecord");
+function isTableMissing(err) {
+  const msg = String(err?.message || err || "");
+  return msg.includes("no such table") || msg.includes("doesn't exist");
+}
+__name(isTableMissing, "isTableMissing");
+function isSqliteUnavailable(err) {
+  const msg = String(err?.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");
+}
+__name(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 qNum(0);
+              return qStr("", "sqlite");
+            })
+          ]
+        });
+      }
+      $asai[LOG_TABLE_ENSURED] = true;
+    })();
+  }
+  try {
+    await ensureLogTablePromise;
+  } catch (err) {
+    ensureLogTablePromise = null;
+    throw err;
+  }
+}
+__name(ensureLogTable, "ensureLogTable");
+async function beforeSqliteLogOp($asai) {
+  if (getLogStoreConfig($asai).type === "sqlite" && !$asai[SQLITE_FALLBACK_KEY]) {
+    await ensureLogTable($asai);
+  }
+}
+__name(beforeSqliteLogOp, "beforeSqliteLogOp");
+function isLogStoreSqlite($asai) {
+  return getEffectiveStoreType($asai) === "sqlite" || getEffectiveStoreType($asai) === "mysql";
+}
+__name(isLogStoreSqlite, "isLogStoreSqlite");
+function getDb($asai) {
+  return getDataServer($asai, "log");
+}
+__name(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 qNum(v);
+          return qStr(v == null ? "" : String(v), type);
+        })
+      ]
+    });
+  } catch (err) {
+    if (getLogStoreConfig($asai).type === "sqlite" && isSqliteUnavailable(err)) {
+      markSqliteFallback($asai, err);
+      await fileStoreInsert($asai, row);
+      return;
+    }
+    throw err;
+  }
+}
+__name(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", "=", qStr(filter.kind, type)]);
+  if (filter.ns) where.push(["ns", "=", qStr(filter.ns, type)]);
+  if (filter.source) where.push(["source", "=", qStr(filter.source, type)]);
+  if (filter.log_date) where.push(["log_date", "=", qStr(filter.log_date, type)]);
+  if (filter.file_name) where.push(["file_name", "=", qStr(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: filter.limit ?? 500
+    });
+    return asRows(res).map(rowToRecord2);
+  } catch (err) {
+    if (isTableMissing(err) || isSqliteUnavailable(err)) {
+      if (getLogStoreConfig($asai).type === "sqlite") markSqliteFallback($asai, err);
+      return fileStoreQuery($asai, filter);
+    }
+    throw err;
+  }
+}
+__name(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", "=", qNum(Number(id))]],
+      limit: 1
+    });
+    const rows = asRows(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;
+  }
+}
+__name(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);
+}
+__name(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;
+}
+__name(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;
+}
+__name(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
+  };
+}
+__name(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(asRows(res));
+  } catch (err) {
+    if (isTableMissing(err) || isSqliteUnavailable(err)) {
+      if (getLogStoreConfig($asai).type === "sqlite") markSqliteFallback($asai, err);
+      return fileStoreDiskStats($asai);
+    }
+    throw err;
+  }
+}
+__name(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", "=", qStr(fileName, type)]];
+  if (ns) where.push(["ns", "=", qStr(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;
+  }
+}
+__name(dbDeleteLogEntriesByFile, "dbDeleteLogEntriesByFile");
+
+// src/sysserver/lib/common/LogStore.ts
+async function mirrorWebLog($asai, opts) {
+  if (!isLogStoreEnabled($asai)) return;
+  const now = /* @__PURE__ */ new Date();
+  const logDate = getNowTime(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()
+  });
+}
+__name(mirrorWebLog, "mirrorWebLog");
+async function mirrorInterventionLog($asai, opts) {
+  if (!isLogStoreEnabled($asai)) return;
+  const logDate = getNowTime(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()
+  });
+}
+__name(mirrorInterventionLog, "mirrorInterventionLog");
+async function mirrorAccessLog($asai, opts) {
+  if (!isLogStoreEnabled($asai)) return;
+  const now = /* @__PURE__ */ new Date();
+  const logDate = getNowTime(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 || "-"} ${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()
+  });
+}
+__name(mirrorAccessLog, "mirrorAccessLog");
+async function queryUnifiedLogs($asai, filter) {
+  return dbQueryLogEntries($asai, filter);
+}
+__name(queryUnifiedLogs, "queryUnifiedLogs");
+async function searchUnifiedLogs($asai, filter) {
+  return dbSearchLogEntries($asai, filter);
+}
+__name(searchUnifiedLogs, "searchUnifiedLogs");
+async function exportLogContent($asai, opts) {
+  const format = opts.format || "raw";
+  const { readInterventionFile } = await import("./InterventionLog-R6CCPU2B.es.js");
+  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
+  };
+}
+__name(exportLogContent, "exportLogContent");
+async function getComplianceReport($asai, ns = "prod") {
+  const { listInterventionFiles, readInterventionFile } = await import("./InterventionLog-R6CCPU2B.es.js");
+  const retentionYears = $asai?.hostconfig?.logger?.intervention?.retentionYears ?? 5;
+  const stats = await dbLogStats($asai);
+  const storeMeta = getLogStoreMeta($asai);
+  const effectiveType = getEffectiveStoreType($asai);
+  let files = [];
+  try {
+    files = await listInterventionFiles($asai, ns);
+  } catch {
+    files = [];
+  }
+  const chainChecks = [];
+  for (const f of files.slice(0, 30)) {
+    if (!f.name?.includes(".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 {
+      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($asai?.hostconfig?.logger?.diskAlertMb || 512) * 1048576;
+  if (disk.totalBytes >= diskThreshold) {
+    const { alertDiskUsage } = await import("./log-alert-GLCULMQP.es.js");
+    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"]
+  };
+}
+__name(getComplianceReport, "getComplianceReport");
+async function measureLogDiskUsage($asai) {
+  const fsp = await import("fs/promises");
+  const pathMod = await import("path");
+  const storeMeta = getLogStoreMeta($asai);
+  const dirs = {};
+  const paths = [
+    $asai?.hostconfig?.logger?.path?.access,
+    $asai?.hostconfig?.logger?.path?.server,
+    $asai?.hostconfig?.logger?.path?.client,
+    $asai?.hostconfig?.logger?.intervention?.path,
+    $asai?.hostconfig?.logger?.intervention?.testPath,
+    $asai?.hostconfig?.logger?.intervention?.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 {
+    }
+    return total;
+  }
+  __name(dirSize, "dirSize");
+  async function fileSize(filePath) {
+    try {
+      const st = await fsp.stat(filePath);
+      return st.isFile() ? st.size : 0;
+    } catch {
+      return 0;
+    }
+  }
+  __name(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 };
+}
+__name(measureLogDiskUsage, "measureLogDiskUsage");
+async function archiveInterventionYear($asai, opts) {
+  const fsp = await import("fs/promises");
+  const path2 = await import("path");
+  const zlib = await import("zlib");
+  const { pipeline } = await import("stream/promises");
+  const { createReadStream, createWriteStream } = await import("fs");
+  const ns = opts.ns || "prod";
+  const { listInterventionFiles, readInterventionFile } = await import("./InterventionLog-R6CCPU2B.es.js");
+  const yearStr = String(opts.year);
+  const archiveBase = $asai?.hostconfig?.logger?.intervention?.archivePath || path2.join($asai?.hostconfig?.logger?.intervention?.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" ? $asai?.hostconfig?.logger?.intervention?.testPath || "./webdata/webdb/log/intervention-test/" : $asai?.hostconfig?.logger?.intervention?.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 import("./intervention-hooks-FI4EHOL5.es.js");
+      await logProcessGuardEvent($asai, {
+        action: "archive_intervention",
+        detail: `${f.name} -> ${gzPath}`,
+        outcome: "Success",
+        severity: 6
+      });
+      archived.push(f.name);
+    } catch (err) {
+      errors.push(`${f.name}: ${err?.message || err}`);
+    }
+  }
+  return { archived, skipped, errors };
+}
+__name(archiveInterventionYear, "archiveInterventionYear");
+async function listUnifiedGroups($asai, filter = {}) {
+  return dbListLogGroups($asai, filter);
+}
+__name(listUnifiedGroups, "listUnifiedGroups");
+async function getUnifiedStats($asai) {
+  return dbLogStats($asai);
+}
+__name(getUnifiedStats, "getUnifiedStats");
+async function getUnifiedEntry($asai, id) {
+  return dbGetLogEntry($asai, id);
+}
+__name(getUnifiedEntry, "getUnifiedEntry");
+async function purgeStoreEntriesForFile($asai, fileName, ns = "") {
+  return dbDeleteLogEntriesByFile($asai, fileName, ns);
+}
+__name(purgeStoreEntriesForFile, "purgeStoreEntriesForFile");
+async function purgeSqliteEntriesForFile($asai, fileName, ns = "") {
+  return purgeStoreEntriesForFile($asai, fileName, ns);
+}
+__name(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
+  }));
+}
+__name(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
+  }));
+}
+__name(groupsToInterventionFiles, "groupsToInterventionFiles");
+async function readWebLogFromStore($asai, source, fileName) {
+  const m = fileName.match(/log-(\d{4}-\d{2}-\d{2})/);
+  const logDate = m?.[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("");
+}
+__name(readWebLogFromStore, "readWebLogFromStore");
+
+export {
+  getLogStoreConfig,
+  getLogStoreMeta,
+  isLogStoreEnabled,
+  isLogStoreFileBackend,
+  prefersDiskLogAccess,
+  getEffectiveStoreType,
+  isLogStoreSqlite,
+  mirrorWebLog,
+  mirrorInterventionLog,
+  mirrorAccessLog,
+  queryUnifiedLogs,
+  searchUnifiedLogs,
+  exportLogContent,
+  getComplianceReport,
+  archiveInterventionYear,
+  listUnifiedGroups,
+  getUnifiedStats,
+  getUnifiedEntry,
+  purgeStoreEntriesForFile,
+  purgeSqliteEntriesForFile,
+  groupsToManageChildren,
+  groupsToInterventionFiles,
+  readWebLogFromStore,
+  LogStore_exports
+};
+//# sourceMappingURL=chunk-LOMSUPPU.es.js.map