@lakphy/local-router 0.4.2 → 0.5.0

package/dist/cli.js

@@ -9285,13 +9285,13 @@ var require_src = __commonJS((exports) => {
 });
 
 // src/cli.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
 import { setTimeout as sleep2 } from "timers/promises";
 import { parseArgs as parseArgs3 } from "util";
 
 // src/cli/config-command.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname3, join as join11 } from "path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname3, join as join12 } from "path";
 import { createInterface as createInterface4 } from "readline/promises";
 import { parseArgs as parseArgs2 } from "util";
 
@@ -10569,7 +10569,7 @@ function validateConfigOrThrow(config) {
 }
 
 // src/cli/process.ts
-import { closeSync, openSync, readFileSync as readFileSync6, statSync } from "fs";
+import { closeSync as closeSync2, openSync as openSync2, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
 import { setTimeout as sleep } from "timers/promises";
 import { parseArgs } from "util";
 
@@ -51809,10 +51809,23 @@ async function getLogMetrics(options) {
 }
 
 // src/log-query.ts
-import { createReadStream as createReadStream2, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join4, resolve as resolve4 } from "path";
+import { createReadStream as createReadStream3, existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join5, resolve as resolve4 } from "path";
 import { createInterface as createInterface2 } from "readline";
 
+// src/log-index.ts
+import { Database } from "bun:sqlite";
+import {
+  closeSync,
+  createReadStream as createReadStream2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readSync,
+  statSync
+} from "fs";
+import { join as join4 } from "path";
+
 // src/log-session-identity.ts
 var USER_SESSION_DELIMITER = "_account__session_";
 function toRecord(value) {
@@ -51889,6 +51902,824 @@ function resolveLogSessionIdentity(requestBody) {
   };
 }
 
+// src/log-index.ts
+var SCHEMA_VERSION = 1;
+var MAX_INDEX_QUEUE = 20000;
+var INDEX_BATCH_SIZE = 250;
+var INDEX_FLUSH_DELAY_MS = 50;
+var LIKE_SEARCH_THRESHOLD = 2;
+var FTS_TOKEN_PATTERN = /[\p{L}\p{N}_-]+/gu;
+var singleton = null;
+function encodeBase64Url(value) {
+  return Buffer.from(value, "utf-8").toString("base64url");
+}
+function decodeBase64Url(value) {
+  return Buffer.from(value, "base64url").toString("utf-8");
+}
+function encodeOffsetLogEventId(date5, offset) {
+  return encodeBase64Url(JSON.stringify({ v: 2, d: date5, o: offset }));
+}
+function decodeOffsetLogEventId(id) {
+  try {
+    const parsed = JSON.parse(decodeBase64Url(id));
+    if (parsed.v !== 2 || typeof parsed.d !== "string" || !Number.isInteger(parsed.o)) {
+      return null;
+    }
+    const offset = Number(parsed.o);
+    if (offset < 0)
+      return null;
+    return { v: 2, date: parsed.d, offset };
+  } catch {
+    return null;
+  }
+}
+function encodeCursor(data) {
+  return encodeBase64Url(JSON.stringify(data));
+}
+function decodeCursor(raw2) {
+  const parsed = JSON.parse(decodeBase64Url(raw2));
+  if (parsed.v !== 2 || parsed.sort !== "time_desc" && parsed.sort !== "time_asc" || typeof parsed.id !== "string" || typeof parsed.queryHash !== "string" || !Number.isFinite(parsed.tsMs)) {
+    throw new Error("cursor \u975E\u6CD5");
+  }
+  return parsed;
+}
+function toDayStart2(ms) {
+  const date5 = new Date(ms);
+  return Date.UTC(date5.getUTCFullYear(), date5.getUTCMonth(), date5.getUTCDate());
+}
+function listDateStrings2(fromMs, toMs) {
+  const result = [];
+  for (let day = toDayStart2(fromMs);day <= toDayStart2(toMs); day += 24 * 60 * 60 * 1000) {
+    result.push(new Date(day).toISOString().slice(0, 10));
+  }
+  return result;
+}
+function getStatusClass2(event) {
+  if (event.error_type)
+    return "network_error";
+  const status = event.upstream_status ?? 0;
+  if (status >= 200 && status < 300)
+    return "2xx";
+  if (status >= 400 && status < 500)
+    return "4xx";
+  if (status >= 500)
+    return "5xx";
+  return "network_error";
+}
+function isErrorEvent2(event) {
+  if (event.error_type)
+    return true;
+  const status = event.upstream_status ?? 0;
+  return status < 200 || status >= 400;
+}
+function getLevel(event) {
+  return isErrorEvent2(event) ? "error" : "info";
+}
+function buildMessage(event) {
+  if (event.error_message)
+    return event.error_message;
+  if (event.error_type)
+    return event.error_type;
+  const status = event.upstream_status ?? 0;
+  return `${event.method} ${event.path} -> ${status}`;
+}
+function toPercent2(numerator, denominator) {
+  if (denominator <= 0)
+    return 0;
+  return Number((numerator / denominator * 100).toFixed(2));
+}
+function hashQuery(query) {
+  const stable = {
+    fromMs: query.fromMs,
+    toMs: query.toMs,
+    levels: [...query.levels].sort(),
+    providers: [...query.providers].sort(),
+    routeTypes: [...query.routeTypes].sort(),
+    models: [...query.models].sort(),
+    modelIns: [...query.modelIns].sort(),
+    modelOuts: [...query.modelOuts].sort(),
+    users: [...query.users].sort(),
+    sessions: [...query.sessions].sort(),
+    statusClasses: [...query.statusClasses].sort(),
+    hasError: query.hasError,
+    q: query.q
+  };
+  return Bun.hash(JSON.stringify(stable)).toString(36);
+}
+function buildSearchText(event) {
+  const identity = resolveLogSessionIdentity(event.request_body);
+  return [
+    event.request_id,
+    event.path,
+    event.provider,
+    event.model_in,
+    event.model_out,
+    event.route_type,
+    identity.userIdRaw ?? "",
+    identity.userKey ?? "",
+    identity.sessionId ?? "",
+    event.error_type ?? "",
+    event.error_message ?? "",
+    buildMessage(event)
+  ].join(" ").toLowerCase();
+}
+function buildFtsQuery(q) {
+  const tokens = q.match(FTS_TOKEN_PATTERN)?.map((token2) => token2.trim()).filter(Boolean) ?? [];
+  if (tokens.length === 0)
+    return null;
+  return tokens.map((token2) => `"${token2.replaceAll('"', '""')}"`).join(" AND ");
+}
+function shouldUseFts(q) {
+  return q.trim().length >= LIKE_SEARCH_THRESHOLD && buildFtsQuery(q) !== null;
+}
+function escapeLikePattern(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
+function eventToRow(input) {
+  const { event } = input;
+  if (!event.ts_start)
+    return null;
+  const tsMs = Date.parse(event.ts_start);
+  if (!Number.isFinite(tsMs))
+    return null;
+  const identity = resolveLogSessionIdentity(event.request_body);
+  const level = getLevel(event);
+  const statusClass = getStatusClass2(event);
+  const latencyMs = Math.max(0, event.latency_ms ?? 0);
+  const model = event.model_out || event.model_in;
+  return {
+    id: input.id,
+    ts_ms: tsMs,
+    ts_start: event.ts_start,
+    level,
+    provider: event.provider,
+    route_type: event.route_type,
+    model,
+    model_in: event.model_in,
+    model_out: event.model_out,
+    path: event.path,
+    request_id: event.request_id,
+    latency_ms: latencyMs,
+    upstream_status: event.upstream_status ?? 0,
+    status_class: statusClass,
+    has_error: level === "error" ? 1 : 0,
+    message: buildMessage(event),
+    error_type: event.error_type,
+    has_metadata: identity.hasMetadata ? 1 : 0,
+    user_id_raw: identity.userIdRaw,
+    user_key: identity.userKey,
+    session_id: identity.sessionId,
+    source_date: input.date,
+    source_file: input.filePath,
+    line_number: input.lineNumber,
+    byte_offset: input.offset,
+    byte_length: input.byteLength,
+    search_text: buildSearchText(event)
+  };
+}
+function rowToSummary(row) {
+  return {
+    id: row.id,
+    ts: row.ts_start,
+    level: row.level,
+    provider: row.provider,
+    routeType: row.route_type,
+    model: row.model,
+    modelIn: row.model_in,
+    modelOut: row.model_out,
+    path: row.path,
+    requestId: row.request_id,
+    latencyMs: row.latency_ms,
+    upstreamStatus: row.upstream_status,
+    statusClass: row.status_class,
+    hasError: row.has_error === 1,
+    message: row.message,
+    errorType: row.error_type,
+    hasMetadata: row.has_metadata === 1,
+    userIdRaw: row.user_id_raw,
+    userKey: row.user_key,
+    sessionId: row.session_id
+  };
+}
+async function* readJsonlLinesWithOffsets(filePath) {
+  const stream = createReadStream2(filePath);
+  let buffer2 = Buffer.alloc(0);
+  let bufferOffset = 0;
+  let lineNumber = 0;
+  for await (const chunk of stream) {
+    const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    buffer2 = buffer2.length === 0 ? chunkBuffer : Buffer.concat([buffer2, chunkBuffer]);
+    let newlineIndex = buffer2.indexOf(10);
+    while (newlineIndex !== -1) {
+      const lineBuffer = buffer2.subarray(0, newlineIndex);
+      const byteLength = newlineIndex + 1;
+      const lineOffset = bufferOffset;
+      lineNumber += 1;
+      yield {
+        line: lineBuffer.toString("utf-8").replace(/\r$/, ""),
+        offset: lineOffset,
+        lineNumber,
+        byteLength
+      };
+      buffer2 = buffer2.subarray(byteLength);
+      bufferOffset += byteLength;
+      newlineIndex = buffer2.indexOf(10);
+    }
+  }
+  if (buffer2.length > 0) {
+    lineNumber += 1;
+    yield {
+      line: buffer2.toString("utf-8").replace(/\r$/, ""),
+      offset: bufferOffset,
+      lineNumber,
+      byteLength: buffer2.length
+    };
+  }
+}
+function readLineAtOffset(filePath, offset) {
+  const fd = openSync(filePath, "r");
+  try {
+    const chunks = [];
+    const buffer2 = Buffer.allocUnsafe(64 * 1024);
+    let position = offset;
+    while (true) {
+      const bytesRead = readSync(fd, buffer2, 0, buffer2.length, position);
+      if (bytesRead <= 0)
+        break;
+      const readable = buffer2.subarray(0, bytesRead);
+      const newline = readable.indexOf(10);
+      if (newline >= 0 && newline < bytesRead) {
+        chunks.push(Buffer.from(readable.subarray(0, newline)));
+        break;
+      }
+      chunks.push(Buffer.from(readable));
+      position += bytesRead;
+    }
+    if (chunks.length === 0)
+      return null;
+    return Buffer.concat(chunks).toString("utf-8").replace(/\r$/, "");
+  } finally {
+    closeSync(fd);
+  }
+}
+function createEmptyStats() {
+  return {
+    total: 0,
+    errorCount: 0,
+    errorRate: 0,
+    avgLatencyMs: 0,
+    p95LatencyMs: 0
+  };
+}
+function createEmptyQueryResult(query, meta3 = {}) {
+  return {
+    items: [],
+    nextCursor: null,
+    hasMore: false,
+    stats: createEmptyStats(),
+    meta: {
+      scannedFiles: 0,
+      scannedLines: 0,
+      parseErrors: 0,
+      truncated: false,
+      indexUsed: true,
+      indexFresh: true,
+      usesFts: shouldUseFts(query.q),
+      queryMs: 0,
+      rowsReturned: 0,
+      statsMode: "exact",
+      ...meta3
+    }
+  };
+}
+function appendInClause(clauses, params, column2, values) {
+  if (values.length === 0)
+    return;
+  clauses.push(`${column2} IN (${values.map(() => "?").join(", ")})`);
+  params.push(...values);
+}
+function buildWhereClause(query, options = {}) {
+  const clauses = ["e.ts_ms >= ?", "e.ts_ms <= ?"];
+  const params = [query.fromMs, query.toMs];
+  const usesFts = !options.forceLikeSearch && shouldUseFts(query.q);
+  appendInClause(clauses, params, "e.level", query.levels);
+  appendInClause(clauses, params, "e.provider", query.providers);
+  appendInClause(clauses, params, "e.route_type", query.routeTypes);
+  appendInClause(clauses, params, "e.model", query.models);
+  appendInClause(clauses, params, "e.model_in", query.modelIns);
+  appendInClause(clauses, params, "e.model_out", query.modelOuts);
+  appendInClause(clauses, params, "e.status_class", query.statusClasses);
+  if (query.users.length > 0) {
+    clauses.push(`(e.user_id_raw IN (${query.users.map(() => "?").join(", ")}) OR e.user_key IN (${query.users.map(() => "?").join(", ")}))`);
+    params.push(...query.users, ...query.users);
+  }
+  appendInClause(clauses, params, "e.session_id", query.sessions);
+  if (query.hasError !== null) {
+    clauses.push("e.has_error = ?");
+    params.push(query.hasError ? 1 : 0);
+  }
+  if (query.q) {
+    if (usesFts) {
+      const ftsQuery = buildFtsQuery(query.q);
+      clauses.push("e.id IN (SELECT event_id FROM log_events_fts WHERE log_events_fts MATCH ?)");
+      params.push(ftsQuery);
+    } else {
+      clauses.push("e.search_text LIKE ? ESCAPE '\\'");
+      params.push(`%${escapeLikePattern(query.q.toLowerCase())}%`);
+    }
+  }
+  return {
+    whereSql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
+    params,
+    usesFts
+  };
+}
+
+class LogIndex {
+  baseDir;
+  config;
+  db;
+  queue = [];
+  flushTimer = null;
+  disposed = false;
+  rebuildingFiles = new Set;
+  dirtyFiles = new Set;
+  insertEventStmt;
+  insertFtsStmt;
+  deleteFtsStmt;
+  upsertFileStmt;
+  constructor(baseDir, config2) {
+    this.baseDir = baseDir;
+    this.config = config2;
+    mkdirSync2(baseDir, { recursive: true });
+    const dbPath = join4(baseDir, "logs-index.sqlite");
+    this.db = new Database(dbPath, { create: true, strict: true });
+    this.configure();
+    this.migrate();
+    this.insertEventStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO log_events (
+        id, ts_ms, ts_start, level, provider, route_type, model, model_in, model_out,
+        path, request_id, latency_ms, upstream_status, status_class, has_error,
+        message, error_type, has_metadata, user_id_raw, user_key, session_id,
+        source_date, source_file, line_number, byte_offset, byte_length, search_text
+      ) VALUES (
+        $id, $ts_ms, $ts_start, $level, $provider, $route_type, $model, $model_in, $model_out,
+        $path, $request_id, $latency_ms, $upstream_status, $status_class, $has_error,
+        $message, $error_type, $has_metadata, $user_id_raw, $user_key, $session_id,
+        $source_date, $source_file, $line_number, $byte_offset, $byte_length, $search_text
+      )
+    `);
+    this.deleteFtsStmt = this.db.prepare("DELETE FROM log_events_fts WHERE event_id = ?");
+    this.insertFtsStmt = this.db.prepare("INSERT INTO log_events_fts(event_id, search_text) VALUES (?, ?)");
+    this.upsertFileStmt = this.db.prepare(`
+      INSERT INTO log_index_files(file_path, source_date, size_bytes, mtime_ms, indexed_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(file_path) DO UPDATE SET
+        source_date = excluded.source_date,
+        size_bytes = excluded.size_bytes,
+        mtime_ms = excluded.mtime_ms,
+        indexed_at = excluded.indexed_at
+    `);
+  }
+  dispose() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.queue = [];
+    this.disposed = true;
+    this.db.close();
+  }
+  enqueue(item) {
+    if (this.disposed)
+      return;
+    if (this.queue.length >= MAX_INDEX_QUEUE) {
+      const dropped = this.queue.shift();
+      if (dropped) {
+        this.dirtyFiles.add(dropped.filePath);
+      }
+    }
+    this.queue.push(item);
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+        this.flushQueue();
+      }, INDEX_FLUSH_DELAY_MS);
+      this.flushTimer.unref?.();
+    }
+  }
+  async ensureRangeIndexed(fromMs, toMs) {
+    let scannedFiles = 0;
+    let scannedLines = 0;
+    let parseErrors = 0;
+    const eventsDir = join4(this.baseDir, "events");
+    const dates = listDateStrings2(fromMs, toMs);
+    for (const date5 of dates) {
+      const filePath = join4(eventsDir, `${date5}.jsonl`);
+      if (!existsSync3(filePath))
+        continue;
+      const stats = statSync(filePath);
+      const fileRow = this.db.query("SELECT size_bytes, mtime_ms FROM log_index_files WHERE file_path = ?").get(filePath);
+      const sizeBytes = stats.size;
+      const mtimeMs = Math.trunc(stats.mtimeMs);
+      if (!this.dirtyFiles.has(filePath) && fileRow && fileRow.size_bytes === sizeBytes && fileRow.mtime_ms === mtimeMs) {
+        continue;
+      }
+      const result = await this.rebuildFile(filePath, date5, sizeBytes, mtimeMs);
+      scannedFiles += 1;
+      scannedLines += result.scannedLines;
+      parseErrors += result.parseErrors;
+    }
+    return { scannedFiles, scannedLines, parseErrors };
+  }
+  queryEvents(query, options = {}) {
+    const startedAt = performance.now();
+    const queryHash = hashQuery(query);
+    const decodedCursor = query.cursor ? decodeCursor(query.cursor) : null;
+    if (decodedCursor) {
+      if (decodedCursor.sort !== query.sort || decodedCursor.queryHash !== queryHash) {
+        throw new Error("cursor \u4E0E\u5F53\u524D\u67E5\u8BE2\u6761\u4EF6\u4E0D\u5339\u914D");
+      }
+    }
+    const { whereSql, params, usesFts } = buildWhereClause(query, options);
+    const cursorClause = decodedCursor ? query.sort === "time_desc" ? "AND (e.ts_ms < ? OR (e.ts_ms = ? AND e.id < ?))" : "AND (e.ts_ms > ? OR (e.ts_ms = ? AND e.id > ?))" : "";
+    const cursorParams = decodedCursor ? [decodedCursor.tsMs, decodedCursor.tsMs, decodedCursor.id] : [];
+    const orderSql = query.sort === "time_desc" ? "ORDER BY e.ts_ms DESC, e.id DESC" : "ORDER BY e.ts_ms ASC, e.id ASC";
+    const limit = Math.max(1, query.limit);
+    let rows;
+    try {
+      rows = this.db.query(`
+          SELECT
+            e.id, e.ts_start, e.level, e.provider, e.route_type, e.model, e.model_in,
+            e.model_out, e.path, e.request_id, e.latency_ms, e.upstream_status,
+            e.status_class, e.has_error, e.message, e.error_type, e.has_metadata,
+            e.user_id_raw, e.user_key, e.session_id, e.ts_ms
+          FROM log_events e
+          ${whereSql}
+          ${cursorClause}
+          ${orderSql}
+          LIMIT ?
+        `).all(...params, ...cursorParams, limit + 1);
+    } catch (err) {
+      if (!usesFts)
+        throw err;
+      const fallback = this.queryEvents(query, { forceLikeSearch: true });
+      return {
+        ...fallback,
+        meta: {
+          ...fallback.meta,
+          usesFts: false,
+          fallbackReason: `FTS \u67E5\u8BE2\u5931\u8D25\uFF0C\u5DF2\u9000\u56DE\u7D22\u5F15 LIKE/\u5185\u5B58\u8FC7\u6EE4: ${err instanceof Error ? err.message : String(err)}`
+        }
+      };
+    }
+    const pageRows = rows.slice(0, limit);
+    const hasMore = rows.length > limit;
+    const lastRow = pageRows[pageRows.length - 1];
+    const stats = this.queryStats(whereSql, params);
+    return {
+      items: pageRows.map(rowToSummary),
+      nextCursor: hasMore && lastRow ? encodeCursor({
+        v: 2,
+        sort: query.sort,
+        tsMs: lastRow.ts_ms,
+        id: lastRow.id,
+        queryHash
+      }) : null,
+      hasMore,
+      stats,
+      meta: {
+        scannedFiles: 0,
+        scannedLines: 0,
+        parseErrors: 0,
+        truncated: false,
+        indexUsed: true,
+        indexFresh: true,
+        usesFts,
+        queryMs: Math.round((performance.now() - startedAt) * 100) / 100,
+        rowsReturned: pageRows.length,
+        statsMode: "exact"
+      }
+    };
+  }
+  getEventRecordByOffsetId(id) {
+    const parsedId = decodeOffsetLogEventId(id);
+    if (!parsedId)
+      return null;
+    const row = this.db.query("SELECT source_date, source_file, line_number, byte_offset FROM log_events WHERE id = ?").get(id);
+    const filePath = row?.source_file ?? join4(this.baseDir, "events", `${parsedId.date}.jsonl`);
+    if (!existsSync3(filePath))
+      return null;
+    const line2 = readLineAtOffset(filePath, row?.byte_offset ?? parsedId.offset);
+    if (!line2?.trim())
+      return null;
+    const event = JSON.parse(line2);
+    return {
+      event,
+      location: {
+        id,
+        date: row?.source_date ?? parsedId.date,
+        file: filePath,
+        line: row?.line_number ?? null,
+        offset: row?.byte_offset ?? parsedId.offset
+      }
+    };
+  }
+  configure() {
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA temp_store = MEMORY;
+      PRAGMA busy_timeout = 3000;
+      PRAGMA foreign_keys = ON;
+    `);
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS log_index_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS log_index_files (
+        file_path TEXT PRIMARY KEY,
+        source_date TEXT NOT NULL,
+        size_bytes INTEGER NOT NULL,
+        mtime_ms INTEGER NOT NULL,
+        indexed_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS log_events (
+        id TEXT PRIMARY KEY,
+        ts_ms INTEGER NOT NULL,
+        ts_start TEXT NOT NULL,
+        level TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        route_type TEXT NOT NULL,
+        model TEXT NOT NULL,
+        model_in TEXT NOT NULL,
+        model_out TEXT NOT NULL,
+        path TEXT NOT NULL,
+        request_id TEXT NOT NULL,
+        latency_ms INTEGER NOT NULL,
+        upstream_status INTEGER NOT NULL,
+        status_class TEXT NOT NULL,
+        has_error INTEGER NOT NULL,
+        message TEXT NOT NULL,
+        error_type TEXT,
+        has_metadata INTEGER NOT NULL,
+        user_id_raw TEXT,
+        user_key TEXT,
+        session_id TEXT,
+        source_date TEXT NOT NULL,
+        source_file TEXT NOT NULL,
+        line_number INTEGER,
+        byte_offset INTEGER NOT NULL,
+        byte_length INTEGER NOT NULL,
+        search_text TEXT NOT NULL
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS log_events_fts
+      USING fts5(event_id UNINDEXED, search_text);
+
+      CREATE INDEX IF NOT EXISTS idx_log_events_time_desc ON log_events(ts_ms DESC, id DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_time_asc ON log_events(ts_ms ASC, id ASC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_level_time ON log_events(level, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_provider_time ON log_events(provider, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_route_time ON log_events(route_type, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_model_time ON log_events(model, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_status_time ON log_events(status_class, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_error_time ON log_events(has_error, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_user_time ON log_events(user_key, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_session_time ON log_events(session_id, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_file ON log_events(source_file);
+    `);
+    this.db.prepare(`
+        INSERT INTO log_index_meta(key, value)
+        VALUES ('schema_version', ?)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value
+      `).run(String(SCHEMA_VERSION));
+  }
+  flushQueue() {
+    if (this.queue.length === 0 || this.disposed)
+      return;
+    const batch = this.queue.splice(0, INDEX_BATCH_SIZE);
+    const transaction = this.db.transaction((items) => {
+      for (const item of items) {
+        this.insertQueueItem(item);
+      }
+    });
+    try {
+      transaction(batch);
+    } catch (err) {
+      console.error("[log-index] \u589E\u91CF\u7D22\u5F15\u5199\u5165\u5931\u8D25:", err);
+    }
+    if (this.queue.length > 0 && !this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+        this.flushQueue();
+      }, INDEX_FLUSH_DELAY_MS);
+      this.flushTimer.unref?.();
+    }
+  }
+  insertQueueItem(item) {
+    if (this.rebuildingFiles.has(item.filePath))
+      return;
+    const id = encodeOffsetLogEventId(item.date, item.offset);
+    const row = eventToRow({
+      id,
+      date: item.date,
+      filePath: item.filePath,
+      lineNumber: null,
+      offset: item.offset,
+      byteLength: item.byteLength,
+      event: item.event
+    });
+    if (!row)
+      return;
+    this.insertEventStmt.run(row);
+    this.deleteFtsStmt.run(id);
+    this.insertFtsStmt.run(id, row.search_text);
+    if (!this.dirtyFiles.has(item.filePath)) {
+      try {
+        const stats = statSync(item.filePath);
+        const indexedThrough = item.offset + item.byteLength;
+        this.upsertFileStmt.run(item.filePath, item.date, Math.min(indexedThrough, stats.size), Math.trunc(stats.mtimeMs), Date.now());
+      } catch {}
+    }
+  }
+  async rebuildFile(filePath, date5, sizeBytes, mtimeMs) {
+    if (this.rebuildingFiles.has(filePath)) {
+      return { scannedLines: 0, parseErrors: 0 };
+    }
+    this.rebuildingFiles.add(filePath);
+    let scannedLines = 0;
+    let parseErrors = 0;
+    const rows = [];
+    try {
+      for await (const item of readJsonlLinesWithOffsets(filePath)) {
+        scannedLines += 1;
+        if (!item.line.trim())
+          continue;
+        let event;
+        try {
+          event = JSON.parse(item.line);
+        } catch {
+          parseErrors += 1;
+          continue;
+        }
+        const row = eventToRow({
+          id: encodeOffsetLogEventId(date5, item.offset),
+          date: date5,
+          filePath,
+          lineNumber: item.lineNumber,
+          offset: item.offset,
+          byteLength: item.byteLength,
+          event
+        });
+        if (row)
+          rows.push(row);
+      }
+      const transaction = this.db.transaction((eventRows) => {
+        this.db.prepare("DELETE FROM log_events_fts WHERE event_id IN (SELECT id FROM log_events WHERE source_file = ?)").run(filePath);
+        this.db.prepare("DELETE FROM log_events WHERE source_file = ?").run(filePath);
+        for (const row of eventRows) {
+          this.insertEventStmt.run(row);
+          this.insertFtsStmt.run(row.id, row.search_text);
+        }
+        this.upsertFileStmt.run(filePath, date5, sizeBytes, mtimeMs, Date.now());
+      });
+      transaction(rows);
+      this.dirtyFiles.delete(filePath);
+      return { scannedLines, parseErrors };
+    } finally {
+      this.rebuildingFiles.delete(filePath);
+    }
+  }
+  queryStats(whereSql, params) {
+    const aggregate = this.db.query(`
+        SELECT
+          COUNT(*) AS total,
+          COALESCE(SUM(has_error), 0) AS errorCount,
+          COALESCE(AVG(latency_ms), 0) AS avgLatencyMs
+        FROM log_events e
+        ${whereSql}
+      `).get(...params);
+    const total = Number(aggregate.total) || 0;
+    if (total <= 0)
+      return createEmptyStats();
+    const p95Offset = Math.max(0, Math.ceil(total * 0.95) - 1);
+    const p95Row = this.db.query(`
+        SELECT latency_ms
+        FROM log_events e
+        ${whereSql}
+        ORDER BY latency_ms ASC
+        LIMIT 1 OFFSET ?
+      `).get(...params, p95Offset);
+    const errorCount = Number(aggregate.errorCount) || 0;
+    return {
+      total,
+      errorCount,
+      errorRate: toPercent2(errorCount, total),
+      avgLatencyMs: Math.round(Number(aggregate.avgLatencyMs) || 0),
+      p95LatencyMs: Math.round(p95Row?.latency_ms ?? 0)
+    };
+  }
+}
+function initLogIndex(baseDir, config2) {
+  disposeLogIndex();
+  if (config2?.enabled === false)
+    return;
+  try {
+    singleton = new LogIndex(baseDir, config2);
+  } catch (err) {
+    singleton = null;
+    console.error("[log-index] SQLite \u7D22\u5F15\u521D\u59CB\u5316\u5931\u8D25\uFF0C\u5C06\u9000\u56DE JSONL \u626B\u63CF:", err);
+  }
+}
+function disposeLogIndex() {
+  if (!singleton)
+    return;
+  try {
+    singleton.dispose();
+  } catch (err) {
+    console.error("[log-index] SQLite \u7D22\u5F15\u5173\u95ED\u5931\u8D25:", err);
+  } finally {
+    singleton = null;
+  }
+}
+function getLogIndex(baseDir) {
+  if (!singleton)
+    return null;
+  if (baseDir && singleton.baseDir !== baseDir)
+    return null;
+  return singleton;
+}
+function enqueueLogEventForIndex(input) {
+  const index = getLogIndex(input.baseDir);
+  index?.enqueue(input);
+}
+async function queryIndexedLogEvents(logConfig, query) {
+  if (!logConfig || logConfig.enabled === false)
+    return createEmptyQueryResult(query);
+  const baseDir = resolveLogBaseDir(logConfig);
+  const index = getLogIndex(baseDir);
+  if (!index)
+    return null;
+  try {
+    const freshness = await index.ensureRangeIndexed(query.fromMs, query.toMs);
+    const result = index.queryEvents(query);
+    return {
+      ...result,
+      meta: {
+        ...result.meta,
+        scannedFiles: freshness.scannedFiles,
+        scannedLines: freshness.scannedLines,
+        parseErrors: freshness.parseErrors
+      }
+    };
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("cursor")) {
+      throw err;
+    }
+    return {
+      ...createEmptyQueryResult(query, {
+        indexUsed: false,
+        indexFresh: false,
+        fallbackReason: err instanceof Error ? err.message : String(err),
+        statsMode: "none"
+      })
+    };
+  }
+}
+function getIndexedLogEventDetail(logConfig, id) {
+  if (!logConfig || logConfig.enabled === false)
+    return null;
+  const baseDir = resolveLogBaseDir(logConfig);
+  const indexed = getLogIndex(baseDir)?.getEventRecordByOffsetId(id);
+  if (indexed)
+    return indexed;
+  const parsedId = decodeOffsetLogEventId(id);
+  if (!parsedId)
+    return null;
+  const filePath = join4(baseDir, "events", `${parsedId.date}.jsonl`);
+  if (!existsSync3(filePath))
+    return null;
+  const line2 = readLineAtOffset(filePath, parsedId.offset);
+  if (!line2?.trim())
+    return null;
+  return {
+    event: JSON.parse(line2),
+    location: {
+      id,
+      date: parsedId.date,
+      file: filePath,
+      line: null,
+      offset: parsedId.offset
+    }
+  };
+}
+
 // src/log-query.ts
 var WINDOW_MS2 = {
   "1h": 60 * 60 * 1000,
@@ -51900,49 +52731,57 @@ var MAX_QUERY_LIMIT = 200;
 var DEFAULT_QUERY_LIMIT = 50;
 var MAX_EXPORT_ROWS = 5000;
 var MAX_Q_LENGTH = 200;
-function encodeBase64Url(value) {
+function encodeBase64Url2(value) {
   return Buffer.from(value, "utf-8").toString("base64url");
 }
-function decodeBase64Url(value) {
+function decodeBase64Url2(value) {
   return Buffer.from(value, "base64url").toString("utf-8");
 }
-function encodeCursor(data) {
-  return encodeBase64Url(JSON.stringify(data));
+function encodeCursor2(data) {
+  return encodeBase64Url2(JSON.stringify(data));
 }
-function decodeCursor(raw2) {
-  const parsed = JSON.parse(decodeBase64Url(raw2));
+function decodeCursor2(raw2) {
+  const parsed = JSON.parse(decodeBase64Url2(raw2));
   if (!Number.isInteger(parsed.offset) || parsed.offset < 0) {
     throw new Error("cursor \u975E\u6CD5");
   }
   return parsed;
 }
+function isLegacyOffsetCursor(raw2) {
+  try {
+    const parsed = JSON.parse(decodeBase64Url2(raw2));
+    return Number.isInteger(parsed.offset) && Number(parsed.offset) >= 0;
+  } catch {
+    return false;
+  }
+}
 function encodeEventId(date5, line2) {
-  return encodeBase64Url(JSON.stringify({ d: date5, l: line2 }));
+  return encodeBase64Url2(JSON.stringify({ d: date5, l: line2 }));
 }
 function decodeEventId(id) {
-  const parsed = JSON.parse(decodeBase64Url(id));
+  const parsed = JSON.parse(decodeBase64Url2(id));
   if (typeof parsed.d !== "string" || !Number.isInteger(parsed.l) || Number(parsed.l) <= 0) {
     throw new Error("id \u975E\u6CD5");
   }
   return { date: parsed.d, line: Number(parsed.l) };
 }
-function toPercent2(numerator, denominator) {
+function toPercent3(numerator, denominator) {
   if (denominator <= 0)
     return 0;
   return Number((numerator / denominator * 100).toFixed(2));
 }
-function toDayStart2(ms) {
+function toDayStart3(ms) {
   const date5 = new Date(ms);
   return Date.UTC(date5.getUTCFullYear(), date5.getUTCMonth(), date5.getUTCDate());
 }
-function listDateStrings2(fromMs, toMs) {
+function listDateStrings3(fromMs, toMs) {
   const result = [];
-  for (let day = toDayStart2(fromMs);day <= toDayStart2(toMs); day += 24 * 60 * 60 * 1000) {
+  for (let day = toDayStart3(fromMs);day <= toDayStart3(toMs); day += 24 * 60 * 60 * 1000) {
     result.push(new Date(day).toISOString().slice(0, 10));
   }
   return result;
 }
-function getStatusClass2(event) {
+function getStatusClass3(event) {
   if (event.error_type)
     return "network_error";
   const status = event.upstream_status ?? 0;
@@ -51954,16 +52793,16 @@ function getStatusClass2(event) {
     return "5xx";
   return "network_error";
 }
-function isErrorEvent2(event) {
+function isErrorEvent3(event) {
   if (event.error_type)
     return true;
   const status = event.upstream_status ?? 0;
   return status < 200 || status >= 400;
 }
-function getLevel(event) {
-  return isErrorEvent2(event) ? "error" : "info";
+function getLevel2(event) {
+  return isErrorEvent3(event) ? "error" : "info";
 }
-function buildMessage(event) {
+function buildMessage2(event) {
   if (event.error_message)
     return event.error_message;
   if (event.error_type)
@@ -51988,7 +52827,7 @@ function containsKeyword(event, q) {
     identity.sessionId ?? "",
     event.error_type ?? "",
     event.error_message ?? "",
-    buildMessage(event)
+    buildMessage2(event)
   ].join(" ").toLowerCase();
   return haystack.includes(keyword);
 }
@@ -52037,7 +52876,7 @@ function finalizeStats(stats) {
   return {
     total: stats.total,
     errorCount: stats.errorCount,
-    errorRate: toPercent2(stats.errorCount, stats.total),
+    errorRate: toPercent3(stats.errorCount, stats.total),
     avgLatencyMs: Math.round(stats.latencySum / stats.total),
     p95LatencyMs: percentileFromCounts(stats.latencyCounts, stats.total, 0.95)
   };
@@ -52057,17 +52896,17 @@ function insertBoundedEvent(items, item, sort, maxKeep) {
     items.pop();
   }
 }
-function clampLimit(limit) {
+function clampLimit(limit, maxLimit = MAX_QUERY_LIMIT) {
   if (!Number.isFinite(limit))
     return DEFAULT_QUERY_LIMIT;
   const integer2 = Math.floor(limit);
   if (integer2 <= 0)
     return DEFAULT_QUERY_LIMIT;
-  return Math.min(MAX_QUERY_LIMIT, integer2);
+  return Math.min(maxLimit, integer2);
 }
-function normalizeQuery(input) {
+function normalizeQuery(input, maxLimit = MAX_QUERY_LIMIT) {
   const sort = input.sort ?? "time_desc";
-  const limit = clampLimit(input.limit);
+  const limit = clampLimit(input.limit, maxLimit);
   const qRaw = (input.q ?? "").trim();
   const q = qRaw.length > MAX_Q_LENGTH ? qRaw.slice(0, MAX_Q_LENGTH) : qRaw;
   return {
@@ -52107,7 +52946,7 @@ function eventToSummary(item) {
     upstreamStatus: event.upstream_status ?? 0,
     statusClass: item.statusClass,
     hasError: item.level === "error",
-    message: buildMessage(event),
+    message: buildMessage2(event),
     errorType: event.error_type,
     hasMetadata: identity.hasMetadata,
     userIdRaw: identity.userIdRaw,
@@ -52115,6 +52954,57 @@ function eventToSummary(item) {
     sessionId: identity.sessionId
   };
 }
+function createLogEventSummaryFromEvent(event, location) {
+  const ts = Date.parse(event.ts_start);
+  return eventToSummary({
+    id: location.id,
+    date: location.date,
+    line: location.line ?? 0,
+    ts: Number.isFinite(ts) ? ts : 0,
+    level: getLevel2(event),
+    statusClass: getStatusClass3(event),
+    event
+  });
+}
+function logEventMatchesQuery(event, query) {
+  if (!event.ts_start)
+    return false;
+  const ts = Date.parse(event.ts_start);
+  if (!Number.isFinite(ts) || ts < query.fromMs || ts > query.toMs)
+    return false;
+  const level = getLevel2(event);
+  const statusClass = getStatusClass3(event);
+  if (query.levels.length > 0 && !query.levels.includes(level))
+    return false;
+  if (query.providers.length > 0 && !query.providers.includes(event.provider))
+    return false;
+  if (query.routeTypes.length > 0 && !query.routeTypes.includes(event.route_type))
+    return false;
+  const eventModel = event.model_out || event.model_in;
+  if (query.models.length > 0 && !query.models.includes(eventModel))
+    return false;
+  if (query.modelIns.length > 0 && !query.modelIns.includes(event.model_in))
+    return false;
+  if (query.modelOuts.length > 0 && !query.modelOuts.includes(event.model_out))
+    return false;
+  const identity = resolveLogSessionIdentity(event.request_body);
+  if (query.users.length > 0) {
+    const matchedByRaw = identity.userIdRaw ? query.users.includes(identity.userIdRaw) : false;
+    const matchedByUserKey = identity.userKey ? query.users.includes(identity.userKey) : false;
+    if (!matchedByRaw && !matchedByUserKey)
+      return false;
+  }
+  if (query.sessions.length > 0) {
+    if (!identity.sessionId || !query.sessions.includes(identity.sessionId))
+      return false;
+  }
+  if (query.statusClasses.length > 0 && !query.statusClasses.includes(statusClass))
+    return false;
+  const hasError = level === "error";
+  if (query.hasError !== null && query.hasError !== hasError)
+    return false;
+  return containsKeyword(event, query.q);
+}
 function detectBodyPolicy(event) {
   const hasRequestBody = event.request_body !== undefined;
   const hasResponseBody = event.response_body !== undefined;
@@ -52168,14 +53058,14 @@ function readStreamContent(baseDir, streamFile) {
     if (!looksLikeStreamFile) {
       return { content: null, warning: "stream_file \u4E0D\u662F .sse.raw \u6587\u4EF6\uFF0C\u5DF2\u8DF3\u8FC7\u8BFB\u53D6\u3002" };
     }
-    if (existsSync3(resolvedFromFile)) {
+    if (existsSync4(resolvedFromFile)) {
       return { content: readFileSync3(resolvedFromFile, "utf-8"), warning: null };
     }
     const fallbackPath = resolve4(resolvedBase, streamFile);
     if (!fallbackPath.startsWith(`${resolvedBase}/`) && fallbackPath !== resolvedBase) {
       return { content: null, warning: "stream_file \u8DEF\u5F84\u975E\u6CD5\uFF0C\u5DF2\u62D2\u7EDD\u8BFB\u53D6\u3002" };
     }
-    if (!existsSync3(fallbackPath)) {
+    if (!existsSync4(fallbackPath)) {
       return { content: null, warning: "stream_file \u4E0D\u5B58\u5728\uFF0C\u53EF\u80FD\u5DF2\u88AB\u6E05\u7406\u3002" };
     }
     return { content: readFileSync3(fallbackPath, "utf-8"), warning: null };
@@ -52188,8 +53078,8 @@ function readStreamContent(baseDir, streamFile) {
 }
 async function buildLogEventDetail(id, parsed, location, context2) {
   const event = parsed;
-  const level = getLevel(event);
-  const statusClass = getStatusClass2(event);
+  const level = getLevel2(event);
+  const statusClass = getStatusClass3(event);
   const bodyPolicy = detectBodyPolicy(event);
   const requestBodyAvailable = event.request_body !== undefined;
   const responseBodyAvailable = event.response_body !== undefined;
@@ -52261,8 +53151,8 @@ async function buildLogEventDetail(id, parsed, location, context2) {
   };
 }
 async function scanEvents(baseDir, query) {
-  const eventsDir = join4(baseDir, "events");
-  if (!existsSync3(eventsDir)) {
+  const eventsDir = join5(baseDir, "events");
+  if (!existsSync4(eventsDir)) {
     return {
       items: [],
       stats: {
@@ -52280,8 +53170,8 @@ async function scanEvents(baseDir, query) {
       }
     };
   }
-  const dates = listDateStrings2(query.fromMs, query.toMs);
-  const offset = query.cursor ? decodeCursor(query.cursor).offset : 0;
+  const dates = listDateStrings3(query.fromMs, query.toMs);
+  const offset = query.cursor ? decodeCursor2(query.cursor).offset : 0;
   const maxKeep = offset + query.limit;
   const items = [];
   const runningStats = createRunningStats();
@@ -52294,11 +53184,11 @@ async function scanEvents(baseDir, query) {
       truncated = true;
       break;
     }
-    const filePath = join4(eventsDir, `${date5}.jsonl`);
-    if (!existsSync3(filePath))
+    const filePath = join5(eventsDir, `${date5}.jsonl`);
+    if (!existsSync4(filePath))
       continue;
     scannedFiles += 1;
-    const stream = createReadStream2(filePath, { encoding: "utf-8" });
+    const stream = createReadStream3(filePath, { encoding: "utf-8" });
     const rl = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
     let lineNumber = 0;
     for await (const line2 of rl) {
@@ -52324,8 +53214,8 @@ async function scanEvents(baseDir, query) {
       const ts = Date.parse(event.ts_start);
       if (!Number.isFinite(ts) || ts < query.fromMs || ts > query.toMs)
         continue;
-      const level = getLevel(event);
-      const statusClass = getStatusClass2(event);
+      const level = getLevel2(event);
+      const statusClass = getStatusClass3(event);
       if (query.levels.length > 0 && !query.levels.includes(level))
         continue;
       if (query.providers.length > 0 && !query.providers.includes(event.provider))
@@ -52415,6 +53305,9 @@ function validateSort(value) {
   return value === "time_desc" || value === "time_asc";
 }
 async function queryLogEvents(context2, input) {
+  return queryLogEventsInternal(context2, input, MAX_QUERY_LIMIT);
+}
+async function queryLogEventsInternal(context2, input, maxLimit) {
   const logEnabled = !!context2.logConfig && context2.logConfig.enabled !== false;
   if (!logEnabled) {
     return {
@@ -52437,30 +53330,51 @@ async function queryLogEvents(context2, input) {
     };
   }
   const baseDir = resolveLogBaseDir(context2.logConfig);
-  const query = normalizeQuery(input);
-  const offset = query.cursor ? decodeCursor(query.cursor).offset : 0;
+  const query = normalizeQuery(input, maxLimit);
+  const indexed = await queryIndexedLogEvents(context2.logConfig, query);
+  if (indexed?.meta.indexUsed) {
+    return indexed;
+  }
+  if (query.cursor && !isLegacyOffsetCursor(query.cursor)) {
+    throw new Error(`\u7D22\u5F15\u67E5\u8BE2\u5931\u8D25\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7D22\u5F15 cursor \u56DE\u9000\u5230 JSONL\uFF0C\u8BF7\u91CD\u65B0\u67E5\u8BE2\u7B2C\u4E00\u9875${indexed?.meta.fallbackReason ? `: ${indexed.meta.fallbackReason}` : ""}`);
+  }
+  const offset = query.cursor ? decodeCursor2(query.cursor).offset : 0;
   const scanned = await scanEvents(baseDir, query);
   const pageItems = scanned.items.slice(offset, offset + query.limit);
   const hasMore = scanned.stats.total > offset + query.limit;
   const nextOffset = offset + pageItems.length;
   return {
     items: pageItems.map(eventToSummary),
-    nextCursor: hasMore ? encodeCursor({ offset: nextOffset }) : null,
+    nextCursor: hasMore ? encodeCursor2({ offset: nextOffset }) : null,
     hasMore,
     stats: scanned.stats,
-    meta: scanned.meta
+    meta: {
+      ...scanned.meta,
+      indexUsed: false,
+      indexFresh: false,
+      fallbackReason: indexed?.meta.fallbackReason,
+      statsMode: "exact"
+    }
   };
 }
 async function getLogEventDetailById(context2, id) {
   const logEnabled = !!context2.logConfig && context2.logConfig.enabled !== false;
   if (!logEnabled)
     return null;
+  const indexed = getIndexedLogEventDetail(context2.logConfig, id);
+  if (indexed) {
+    return buildLogEventDetail(id, indexed.event, {
+      date: indexed.location.date,
+      line: indexed.location.line ?? 0,
+      file: indexed.location.file
+    }, context2);
+  }
   const { date: date5, line: line2 } = decodeEventId(id);
   const baseDir = resolveLogBaseDir(context2.logConfig);
-  const filePath = join4(baseDir, "events", `${date5}.jsonl`);
-  if (!existsSync3(filePath))
+  const filePath = join5(baseDir, "events", `${date5}.jsonl`);
+  if (!existsSync4(filePath))
     return null;
-  const stream = createReadStream2(filePath, { encoding: "utf-8" });
+  const stream = createReadStream3(filePath, { encoding: "utf-8" });
   const rl = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
   let lineNumber = 0;
   for await (const lineText of rl) {
@@ -52570,11 +53484,11 @@ function createJsonExportStream(data) {
   });
 }
 async function exportLogEvents(context2, input, format) {
-  const data = await queryLogEvents(context2, {
+  const data = await queryLogEventsInternal(context2, {
     ...input,
     cursor: null,
     limit: MAX_EXPORT_ROWS
-  });
+  }, MAX_EXPORT_ROWS);
   const now2 = new Date().toISOString().replace(/[:.]/g, "-");
   if (format === "csv") {
     return {
@@ -52613,18 +53527,18 @@ function parseBooleanFlag(value) {
 }
 
 // src/log-sessions.ts
-import { createReadStream as createReadStream3, existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
+import { createReadStream as createReadStream4, existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
 import { createInterface as createInterface3 } from "readline";
 var MAX_LINES_SCANNED3 = 250000;
 var MAX_Q_LENGTH2 = 200;
-function toDayStart3(ms) {
+function toDayStart4(ms) {
   const date5 = new Date(ms);
   return Date.UTC(date5.getUTCFullYear(), date5.getUTCMonth(), date5.getUTCDate());
 }
-function listDateStrings3(fromMs, toMs) {
+function listDateStrings4(fromMs, toMs) {
   const result = [];
-  for (let day = toDayStart3(fromMs);day <= toDayStart3(toMs); day += 24 * 60 * 60 * 1000) {
+  for (let day = toDayStart4(fromMs);day <= toDayStart4(toMs); day += 24 * 60 * 60 * 1000) {
     result.push(new Date(day).toISOString().slice(0, 10));
   }
   return result;
@@ -52735,8 +53649,8 @@ async function queryLogSessions(context2, input) {
     return createEmptyResult(normalized.fromMs, normalized.toMs);
   }
   const baseDir = resolveLogBaseDir(context2.logConfig);
-  const eventsDir = join5(baseDir, "events");
-  if (!existsSync4(eventsDir)) {
+  const eventsDir = join6(baseDir, "events");
+  if (!existsSync5(eventsDir)) {
     return createEmptyResult(normalized.fromMs, normalized.toMs);
   }
   const usersMap = new Map;
@@ -52748,17 +53662,17 @@ async function queryLogSessions(context2, input) {
   let scannedLines = 0;
   let parseErrors = 0;
   let truncated = false;
-  const dateStrings = listDateStrings3(normalized.fromMs, normalized.toMs);
+  const dateStrings = listDateStrings4(normalized.fromMs, normalized.toMs);
   for (const date5 of dateStrings) {
     if (scannedLines >= MAX_LINES_SCANNED3) {
       truncated = true;
       break;
     }
-    const filePath = join5(eventsDir, `${date5}.jsonl`);
-    if (!existsSync4(filePath))
+    const filePath = join6(eventsDir, `${date5}.jsonl`);
+    if (!existsSync5(filePath))
       continue;
     scannedFiles += 1;
-    const stream = createReadStream3(filePath, { encoding: "utf-8" });
+    const stream = createReadStream4(filePath, { encoding: "utf-8" });
     const rl = createInterface3({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
     for await (const line2 of rl) {
       if (scannedLines >= MAX_LINES_SCANNED3) {
@@ -52863,8 +53777,8 @@ async function queryLogSessions(context2, input) {
 }
 
 // src/log-storage.ts
-import { existsSync as existsSync5, promises as fsPromises } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, promises as fsPromises } from "fs";
+import { join as join7 } from "path";
 var cachedStorage = null;
 var calculationPromise = null;
 var lastCalculationTime = 0;
@@ -52872,7 +53786,7 @@ var CACHE_TTL_MS2 = 60 * 60 * 1000;
 var CALCULATION_INTERVAL_MS = 60 * 60 * 1000;
 var MIN_CALCULATION_INTERVAL_MS = 5 * 60 * 1000;
 async function calculateDirSize(dirPath) {
-  if (!existsSync5(dirPath)) {
+  if (!existsSync6(dirPath)) {
     return { bytes: 0, fileCount: 0 };
   }
   let bytes = 0;
@@ -52881,7 +53795,7 @@ async function calculateDirSize(dirPath) {
     try {
       const entries = await fsPromises.readdir(currentPath, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join6(currentPath, entry.name);
+        const fullPath = join7(currentPath, entry.name);
         if (entry.isDirectory()) {
           await walk(fullPath);
         } else if (entry.isFile()) {
@@ -52904,6 +53818,7 @@ async function doCalculateStorage(logConfig) {
       totalBytes: 0,
       eventsBytes: 0,
       streamsBytes: 0,
+      indexBytes: 0,
       fileCount: 0,
       lastUpdatedAt: new Date().toISOString(),
       isCalculating: false
@@ -52911,18 +53826,40 @@ async function doCalculateStorage(logConfig) {
   }
   const baseDir = resolveLogBaseDir(logConfig);
   const [eventsResult, streamsResult] = await Promise.all([
-    calculateDirSize(join6(baseDir, "events")),
-    calculateDirSize(join6(baseDir, "streams"))
+    calculateDirSize(join7(baseDir, "events")),
+    calculateDirSize(join7(baseDir, "streams"))
   ]);
+  const indexResult = await calculateIndexSize(baseDir);
   return {
-    totalBytes: eventsResult.bytes + streamsResult.bytes,
+    totalBytes: eventsResult.bytes + streamsResult.bytes + indexResult.bytes,
     eventsBytes: eventsResult.bytes,
     streamsBytes: streamsResult.bytes,
-    fileCount: eventsResult.fileCount + streamsResult.fileCount,
+    indexBytes: indexResult.bytes,
+    fileCount: eventsResult.fileCount + streamsResult.fileCount + indexResult.fileCount,
     lastUpdatedAt: new Date().toISOString(),
     isCalculating: false
   };
 }
+async function calculateIndexSize(baseDir) {
+  if (!existsSync6(baseDir)) {
+    return { bytes: 0, fileCount: 0 };
+  }
+  let bytes = 0;
+  let fileCount = 0;
+  try {
+    const entries = await fsPromises.readdir(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.startsWith("logs-index.sqlite"))
+        continue;
+      const stats = await fsPromises.stat(join7(baseDir, entry.name));
+      bytes += stats.size;
+      fileCount += 1;
+    }
+  } catch {
+    return { bytes, fileCount };
+  }
+  return { bytes, fileCount };
+}
 async function getLogStorageInfo(options) {
   const { logConfig, forceRefresh = false, nowMs = Date.now() } = options;
   if (!forceRefresh && cachedStorage && cachedStorage.expiresAt > nowMs) {
@@ -52965,10 +53902,25 @@ function startLogStorageBackgroundTask(logConfig) {
   };
 }
 
-// src/logger.ts
-import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+// src/log-tail.ts
+var subscribers = new Set;
+function publishLogEvent(event) {
+  for (const subscriber of subscribers) {
+    try {
+      subscriber(event);
+    } catch {}
+  }
+}
+function subscribeLogEvents(subscriber) {
+  subscribers.add(subscriber);
+  return () => {
+    subscribers.delete(subscriber);
+  };
+}
 
+// src/logger.ts
+import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8 } from "path";
 class Logger {
   baseDir;
   eventsDir;
@@ -52983,8 +53935,8 @@ class Logger {
     this._bodyPolicy = config2.bodyPolicy ?? "off";
     this._streamsEnabled = config2.streams?.enabled !== false;
     this.maxStreamBytes = config2.streams?.maxBytesPerRequest ?? 10 * 1024 * 1024;
-    this.eventsDir = join7(baseDir, "events");
-    this.streamsDir = join7(baseDir, "streams");
+    this.eventsDir = join8(baseDir, "events");
+    this.streamsDir = join8(baseDir, "streams");
     if (this._enabled)
       this.ensureDirs();
   }
@@ -52996,14 +53948,14 @@ class Logger {
   }
   ensureDirs() {
     for (const dir of [this.baseDir, this.eventsDir, this.streamsDir]) {
-      if (!existsSync6(dir))
-        mkdirSync2(dir, { recursive: true });
+      if (!existsSync7(dir))
+        mkdirSync3(dir, { recursive: true });
     }
   }
   ensureStreamDateDir(dateStr) {
-    const dir = join7(this.streamsDir, dateStr);
-    if (!existsSync6(dir))
-      mkdirSync2(dir, { recursive: true });
+    const dir = join8(this.streamsDir, dateStr);
+    if (!existsSync7(dir))
+      mkdirSync3(dir, { recursive: true });
     return dir;
   }
   writeEvent(event) {
@@ -53012,9 +53964,21 @@ class Logger {
     try {
       this.ensureDirs();
       const dateStr = event.ts_start.slice(0, 10);
-      const filePath = join7(this.eventsDir, `${dateStr}.jsonl`);
-      appendFileSync(filePath, `${JSON.stringify(event)}
-`);
+      const filePath = join8(this.eventsDir, `${dateStr}.jsonl`);
+      const offset = existsSync7(filePath) ? statSync2(filePath).size : 0;
+      const line2 = `${JSON.stringify(event)}
+`;
+      appendFileSync(filePath, line2);
+      const id = encodeOffsetLogEventId(dateStr, offset);
+      enqueueLogEventForIndex({
+        baseDir: this.baseDir,
+        filePath,
+        date: dateStr,
+        offset,
+        byteLength: Buffer.byteLength(line2),
+        event
+      });
+      publishLogEvent({ id, date: dateStr, filePath, offset, event });
     } catch (err) {
       console.error("[logger] \u4E8B\u4EF6\u65E5\u5FD7\u5199\u5165\u5931\u8D25:", err);
     }
@@ -53024,7 +53988,7 @@ class Logger {
       return null;
     try {
       const dir = this.ensureStreamDateDir(dateStr);
-      const filePath = join7(dir, `${requestId}.sse.raw`);
+      const filePath = join8(dir, `${requestId}.sse.raw`);
       const toWrite = content.length > this.maxStreamBytes ? `${content.slice(0, this.maxStreamBytes)}
 [TRUNCATED]` : content;
       writeFileSync3(filePath, toWrite);
@@ -53038,6 +54002,7 @@ class Logger {
 var instance = null;
 function initLogger(baseDir, config2) {
   instance = new Logger(baseDir, config2);
+  initLogIndex(baseDir, config2);
   if (instance.enabled) {
     console.log(`[logger] \u65E5\u5FD7\u7CFB\u7EDF\u5DF2\u521D\u59CB\u5316: ${baseDir}`);
   }
@@ -53047,6 +54012,7 @@ function getLogger() {
 }
 function resetLogger() {
   instance = null;
+  disposeLogIndex();
 }
 function collectHeaders(headers) {
   const result = {};
@@ -54252,7 +55218,7 @@ var openAPISpec = {
 // src/plugin-loader.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join8, resolve as resolve5 } from "path";
+import { join as join9, resolve as resolve5 } from "path";
 function isLocalPath(pkg) {
   return pkg.startsWith("./") || pkg.startsWith("../") || pkg.startsWith("/") || /^[A-Za-z]:[\\/]/.test(pkg);
 }
@@ -54275,7 +55241,7 @@ var remoteTmpDir = null;
 var remoteTmpFiles = [];
 async function ensureRemoteTmpDir() {
   if (!remoteTmpDir) {
-    remoteTmpDir = await mkdtemp(join8(tmpdir(), "local-router-plugins-"));
+    remoteTmpDir = await mkdtemp(join9(tmpdir(), "local-router-plugins-"));
   }
   return remoteTmpDir;
 }
@@ -54288,7 +55254,7 @@ async function fetchRemotePlugin(url2) {
   const ext = inferExtension(url2, response.headers.get("content-type"));
   const dir = await ensureRemoteTmpDir();
   const fileName = `plugin_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
-  const filePath = join8(dir, fileName);
+  const filePath = join9(dir, fileName);
   await writeFile(filePath, content, "utf-8");
   remoteTmpFiles.push(filePath);
   return filePath;
@@ -54427,7 +55393,7 @@ class PluginManager {
 // src/proxy.ts
 import { appendFile, readFile, unlink } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/plugin-engine.ts
 async function executeRequestPlugins(plugins, ctx, url2, headers, body) {
@@ -54619,7 +55585,7 @@ function buildLogEvent(logMeta, targetUrl, proxyUrl, tsEnd, overrides) {
   };
 }
 function createTempStreamCapturePath(requestId) {
-  return join9(tmpdir2(), `local-router-stream-${requestId}-${Date.now()}.sse.raw`);
+  return join10(tmpdir2(), `local-router-stream-${requestId}-${Date.now()}.sse.raw`);
 }
 async function appendTempStreamCapture(filePath, chunk) {
   await appendFile(filePath, chunk);
@@ -55445,7 +56411,6 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
     }
   });
   api2.get("/logs/tail", async (c2) => {
-    const config2 = store.get();
     const target = c2.req.raw;
     const windowRaw = c2.req.query("window") ?? "1h";
     if (!isLogQueryWindow(windowRaw)) {
@@ -55473,11 +56438,15 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
     }
     const encoder = new TextEncoder;
     let closed = false;
-    let lastSeenTs = Date.now() - 60 * 1000;
+    const maxPendingItems = 500;
     let closeStream = null;
     const stream = new ReadableStream({
       start(controller) {
-        let timer = null;
+        let heartbeatTimer = null;
+        let unsubscribe = null;
+        let flushQueued = false;
+        let droppedItems = 0;
+        const pending = [];
         const push2 = (event, payload) => {
           if (closed)
             return;
@@ -55491,60 +56460,106 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
           if (closed)
             return;
           closed = true;
-          if (timer) {
-            clearInterval(timer);
-            timer = null;
+          if (heartbeatTimer) {
+            clearInterval(heartbeatTimer);
+            heartbeatTimer = null;
           }
+          unsubscribe?.();
+          unsubscribe = null;
           target.signal.removeEventListener("abort", close);
           try {
             controller.close();
           } catch {}
         };
         closeStream = close;
-        push2("ready", { ok: true, now: new Date().toISOString() });
-        timer = setInterval(async () => {
+        const buildTailQuery = () => ({
+          ...resolveLogQueryRange({
+            window: windowRaw,
+            from: c2.req.query("from"),
+            to: c2.req.query("to")
+          }),
+          levels,
+          providers: parseCommaSeparated(c2.req.query("provider")),
+          routeTypes: parseCommaSeparated(c2.req.query("routeType")),
+          models: parseCommaSeparated(c2.req.query("model")),
+          modelIns: parseCommaSeparated(c2.req.query("modelIn")),
+          modelOuts: parseCommaSeparated(c2.req.query("modelOut")),
+          users: parseCommaSeparated(c2.req.query("user")),
+          sessions: parseCommaSeparated(c2.req.query("session")),
+          statusClasses,
+          hasError,
+          q: c2.req.query("q") ?? "",
+          sort: sortRaw,
+          limit: 100,
+          cursor: null
+        });
+        const flush = () => {
+          flushQueued = false;
+          if (closed || pending.length === 0)
+            return;
+          const items = pending.splice(0, pending.length);
+          const overflowMessage = droppedItems > 0 ? `\u5B9E\u65F6\u8FFD\u8E2A\u961F\u5217\u5DF2\u4E22\u5F03 ${droppedItems} \u6761\u4E8B\u4EF6\uFF0C\u8BF7\u91CD\u65B0\u67E5\u8BE2\u4EE5\u8865\u9F50\u3002` : undefined;
+          droppedItems = 0;
+          push2("events", {
+            items,
+            nextCursor: null,
+            hasMore: false,
+            stats: {
+              total: 0,
+              errorCount: 0,
+              errorRate: 0,
+              avgLatencyMs: 0,
+              p95LatencyMs: 0
+            },
+            meta: {
+              scannedFiles: 0,
+              scannedLines: 0,
+              parseErrors: 0,
+              truncated: false,
+              indexUsed: true,
+              indexFresh: true,
+              usesFts: false,
+              queryMs: 0,
+              rowsReturned: items.length,
+              fallbackReason: overflowMessage,
+              statsMode: "none"
+            }
+          });
+        };
+        const queueFlush = () => {
+          if (flushQueued)
+            return;
+          flushQueued = true;
+          queueMicrotask(flush);
+        };
+        unsubscribe = subscribeLogEvents((published) => {
           if (closed)
             return;
           try {
-            const toMs = Date.now();
-            const data = await queryLogEvents({ logConfig: config2.log }, {
-              fromMs: Math.max(lastSeenTs, toMs - 60 * 60 * 1000),
-              toMs,
-              levels,
-              providers: parseCommaSeparated(c2.req.query("provider")),
-              routeTypes: parseCommaSeparated(c2.req.query("routeType")),
-              models: parseCommaSeparated(c2.req.query("model")),
-              modelIns: parseCommaSeparated(c2.req.query("modelIn")),
-              modelOuts: parseCommaSeparated(c2.req.query("modelOut")),
-              users: parseCommaSeparated(c2.req.query("user")),
-              sessions: parseCommaSeparated(c2.req.query("session")),
-              statusClasses,
-              hasError,
-              q: c2.req.query("q") ?? "",
-              sort: sortRaw,
-              limit: 100
-            });
-            if (closed)
+            const query = buildTailQuery();
+            if (!logEventMatchesQuery(published.event, query))
               return;
-            if (data.items.length > 0) {
-              const maxTs = Math.max(...data.items.map((item) => Date.parse(item.ts)).filter(Number.isFinite));
-              if (Number.isFinite(maxTs)) {
-                lastSeenTs = Math.max(lastSeenTs, maxTs + 1);
-              }
-              push2("events", {
-                items: data.items,
-                stats: data.stats,
-                meta: data.meta
-              });
-            } else {
-              push2("heartbeat", { ts: new Date().toISOString() });
+            if (pending.length >= maxPendingItems) {
+              pending.shift();
+              droppedItems += 1;
             }
+            pending.push(createLogEventSummaryFromEvent(published.event, {
+              id: published.id,
+              date: published.date,
+              line: null
+            }));
+            queueFlush();
           } catch (err) {
-            if (closed)
-              return;
             push2("error", { error: err instanceof Error ? err.message : String(err) });
           }
-        }, 3000);
+        });
+        push2("ready", { ok: true, now: new Date().toISOString() });
+        heartbeatTimer = setInterval(() => {
+          if (closed)
+            return;
+          push2("heartbeat", { ts: new Date().toISOString() });
+        }, 15000);
+        heartbeatTimer.unref?.();
         target.signal.addEventListener("abort", close);
       },
       cancel() {
@@ -55764,30 +56779,30 @@ async function startServer(options) {
 }
 
 // src/cli/runtime.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join10, resolve as resolve7 } from "path";
+import { join as join11, resolve as resolve7 } from "path";
 function getRuntimeDirs() {
-  const root2 = join10(homedir2(), ".local-router");
+  const root2 = join11(homedir2(), ".local-router");
   return {
     root: root2,
-    run: join10(root2, "run"),
-    logs: join10(root2, "logs")
+    run: join11(root2, "run"),
+    logs: join11(root2, "logs")
   };
 }
 function getRuntimeFiles() {
   const dirs = getRuntimeDirs();
   return {
-    pid: join10(dirs.run, "local-router.pid"),
-    state: join10(dirs.run, "status.json"),
-    daemonLog: join10(dirs.logs, "daemon.log")
+    pid: join11(dirs.run, "local-router.pid"),
+    state: join11(dirs.run, "status.json"),
+    daemonLog: join11(dirs.logs, "daemon.log")
   };
 }
 function ensureRuntimeDirs() {
   const dirs = getRuntimeDirs();
-  mkdirSync3(dirs.root, { recursive: true });
-  mkdirSync3(dirs.run, { recursive: true });
-  mkdirSync3(dirs.logs, { recursive: true });
+  mkdirSync4(dirs.root, { recursive: true });
+  mkdirSync4(dirs.run, { recursive: true });
+  mkdirSync4(dirs.logs, { recursive: true });
 }
 function writeRuntimeState(state) {
   ensureRuntimeDirs();
@@ -55798,7 +56813,7 @@ function writeRuntimeState(state) {
 }
 function readRuntimeState() {
   const files = getRuntimeFiles();
-  if (!existsSync7(files.state)) {
+  if (!existsSync8(files.state)) {
     return null;
   }
   try {
@@ -55953,8 +56968,8 @@ async function startDaemon(flags) {
   }
   ensureRuntimeDirs();
   const files = getRuntimeFiles();
-  const stdoutFd = openSync(files.daemonLog, "a");
-  const stderrFd = openSync(files.daemonLog, "a");
+  const stdoutFd = openSync2(files.daemonLog, "a");
+  const stderrFd = openSync2(files.daemonLog, "a");
   const childArgs = [process.argv[1] ?? "src/cli.ts", "__run-server", "--mode", "daemon"];
   if (flags.config) {
     childArgs.push("--config", resolveConfigArgPath(flags.config));
@@ -55975,8 +56990,8 @@ async function startDaemon(flags) {
     stderr: stderrFd,
     detached: true
   });
-  closeSync(stdoutFd);
-  closeSync(stderrFd);
+  closeSync2(stdoutFd);
+  closeSync2(stderrFd);
   child.unref();
   for (let i = 0;i < 24; i += 1) {
     await sleep(250);
@@ -56024,7 +57039,7 @@ async function stopProcess(graceMs = 8000) {
 }
 function readLogDelta(filePath, offset) {
   try {
-    const stats = statSync(filePath);
+    const stats = statSync3(filePath);
     if (stats.size <= offset) {
       return { content: "", nextOffset: offset };
     }
@@ -56043,9 +57058,9 @@ function readConfig(configArg) {
 }
 function saveConfig(path, config2) {
   validateConfigOrThrow(config2);
-  const backupDir = join11(dirname3(path), ".backups");
-  mkdirSync4(backupDir, { recursive: true });
-  const backupPath = join11(backupDir, `config-${Date.now()}.json5`);
+  const backupDir = join12(dirname3(path), ".backups");
+  mkdirSync5(backupDir, { recursive: true });
+  const backupPath = join12(backupDir, `config-${Date.now()}.json5`);
   writeFileSync5(backupPath, readFileSync7(path, "utf-8"), "utf-8");
   const content = dist_default.stringify(config2, { space: 2, quote: '"' });
   writeFileSync5(path, content, "utf-8");
@@ -56715,7 +57730,7 @@ async function cmdStatus(args) {
   }
 }
 function printLastLines(filePath, lines) {
-  if (!existsSync8(filePath)) {
+  if (!existsSync9(filePath)) {
     console.log(`\u65E5\u5FD7\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`);
     return 0;
   }