@sanqianx/project-knowledge 4.7.0 → 4.8.0

package/_site/_test/logging-api-test.js

@@ -1,89 +1,89 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { StorageLayout } = require('../lib/storage-layout');
-const { Logger, LogRepository, localDay, normalizeRecord } = require('../lib/structured-logger');
-
-function line(entry) {
-  return `${JSON.stringify(normalizeRecord(entry))}\r\n`;
-}
-
-(async () => {
-  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-log-repository-'));
-  const layout = new StorageLayout({ dataDir });
-  const settings = { levels: ['trace', 'debug', 'info', 'warn', 'error', 'fatal'] };
-  const logger = new Logger({ layout, settingsProvider: () => settings });
-  await logger.info('app.started', 'Started', { component: 'server', operationId: 'op-a' });
-  await logger.info('app.completed', 'Completed', { component: 'server', operationId: 'op-a', durationMs: 12 });
-  await logger.warn('project.deleted', 'Deleted project snapshot', { component: 'lifecycle', projectId: 'project-a', projectDisplayName: 'A', projectDeleted: true });
-  await logger.error('commit.analysis.failed', 'Failed', { component: 'commit-reconciler', projectId: 'project-a', operationId: 'op-b', commitSha: 'deadbeef', error: Object.assign(new Error('failure'), { code: 'ETEST' }) });
-  await logger.close();
-
-  const repository = new LogRepository({ layout });
-  const result = repository.query({ levels: ['error'], projectId: 'project-a', component: 'commit-reconciler', commitSha: 'deadbeef' });
-  assert.strictEqual(result.entries.length, 1);
-  assert.strictEqual(result.entries[0].operationId, 'op-b');
-  assert.strictEqual(result.entries[0].error.code, 'ETEST');
-  assert.strictEqual(result.pageSize, 500, 'today query must default to 500 records');
-  assert.strictEqual(repository.query({ pageSize: 999999 }).pageSize, 5000, 'display limit must be capped at 5000');
-  assert.strictEqual(repository.findOrphanedOperations().length, 0);
-
-  await logger.info('migration.started', 'Migration started', { component: 'migration', operationId: 'op-orphan' });
-  await logger.close();
-  assert.strictEqual(repository.findOrphanedOperations().length, 1);
-
-  const legacyRoot = layout.getLogPath('app');
-  fs.mkdirSync(legacyRoot, { recursive: true });
-  fs.writeFileSync(path.join(legacyRoot, '2020-01-01.log'), `${JSON.stringify({ ts: '2020-01-01T00:00:00.000Z', level: 'info', source: 'legacy', event: 'legacy.event', message: 'old' })}\n`);
-  assert.strictEqual(repository.query({ from: '2019-01-01', to: '2021-01-01', event: 'legacy.event' }).entries.length, 1, 'legacy app/hooks logs remain read-only query sources');
-
-  const date = localDay();
-  const mergeA = path.join(layout.getLogPath('project', 'merge-a'), `${date}.jsonl`);
-  const mergeB = path.join(layout.getLogPath('project', 'merge-b'), `${date}.jsonl`);
-  fs.mkdirSync(path.dirname(mergeA), { recursive: true });
-  fs.mkdirSync(path.dirname(mergeB), { recursive: true });
-  const longMessage = `long-${'界'.repeat(70000)}`;
-  const longRecord = { ...normalizeRecord({ id: 'a-1', ts: `${date}T01:00:00.000Z`, level: 'info', event: 'merge.a1', message: 'placeholder', projectId: 'merge-a' }), message: longMessage };
-  fs.writeFileSync(mergeA,
-    `${JSON.stringify(longRecord)}\r\n`
-    + line({ id: 'a-2', ts: `${date}T03:00:00.000Z`, level: 'warn', event: 'merge.a2', message: 'newer a', projectId: 'merge-a' })
-    + '{bad-tail',
-    'utf8');
-  fs.writeFileSync(mergeB,
-    line({ id: 'b-1', ts: `${date}T02:00:00.000Z`, level: 'error', event: 'merge.b1', message: 'middle b', projectId: 'merge-b' }),
-    'utf8');
-
-  const originalReadFileSync = fs.readFileSync;
-  fs.readFileSync = function guardedRead(filePath, ...args) {
-    if (typeof filePath === 'string' && filePath.startsWith(path.join(dataDir, 'logs')) && /\.(?:jsonl|log)$/.test(filePath)) {
-      throw new Error('LogRepository must not read an entire log file');
-    }
-    return originalReadFileSync.call(this, filePath, ...args);
-  };
-  let merged;
-  try {
-    merged = repository.query({ event: '', q: 'merge.', pageSize: 3 });
-  } finally {
-    fs.readFileSync = originalReadFileSync;
-  }
-  assert.deepStrictEqual(merged.entries.map(entry => entry.id), ['a-2', 'b-1', 'a-1'], 'all-project query must k-way merge by timestamp and skip malformed tail data');
-  const long = repository.query({ projectId: 'merge-a', event: 'merge.a1' });
-  assert.strictEqual(long.entries.length, 1);
-  assert(long.entries[0].message.startsWith(`long-${'界'.repeat(100)}`), 'reverse chunk reader must parse lines larger than one chunk');
-  assert(long.entries[0].message.includes('[truncated:'), 'public query must still apply field size bounds');
-
-  const cursorPage = repository.query({ q: 'merge.', pageSize: 1 });
-  assert(cursorPage.nextCursor);
-  fs.unlinkSync(mergeB);
-  assert.throws(
-    () => repository.query({ q: 'merge.', pageSize: 1, cursor: cursorPage.nextCursor }),
-    error => error.code === 'LOG_CURSOR_EXPIRED' && error.retryable === true,
-    'manually deleted cursor source must return a typed restart error',
-  );
-
-  console.log('logging-api-test PASS');
-})().catch(error => {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-});
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const { Logger, LogRepository, localDay, normalizeRecord } = require('../lib/structured-logger');
+
+function line(entry) {
+  return `${JSON.stringify(normalizeRecord(entry))}\r\n`;
+}
+
+(async () => {
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-log-repository-'));
+  const layout = new StorageLayout({ dataDir });
+  const settings = { levels: ['trace', 'debug', 'info', 'warn', 'error', 'fatal'] };
+  const logger = new Logger({ layout, settingsProvider: () => settings });
+  await logger.info('app.started', 'Started', { component: 'server', operationId: 'op-a' });
+  await logger.info('app.completed', 'Completed', { component: 'server', operationId: 'op-a', durationMs: 12 });
+  await logger.warn('project.deleted', 'Deleted project snapshot', { component: 'lifecycle', projectId: 'project-a', projectDisplayName: 'A', projectDeleted: true });
+  await logger.error('commit.analysis.failed', 'Failed', { component: 'commit-reconciler', projectId: 'project-a', operationId: 'op-b', commitSha: 'deadbeef', error: Object.assign(new Error('failure'), { code: 'ETEST' }) });
+  await logger.close();
+
+  const repository = new LogRepository({ layout });
+  const result = repository.query({ levels: ['error'], projectId: 'project-a', component: 'commit-reconciler', commitSha: 'deadbeef' });
+  assert.strictEqual(result.entries.length, 1);
+  assert.strictEqual(result.entries[0].operationId, 'op-b');
+  assert.strictEqual(result.entries[0].error.code, 'ETEST');
+  assert.strictEqual(result.pageSize, 500, 'today query must default to 500 records');
+  assert.strictEqual(repository.query({ pageSize: 999999 }).pageSize, 5000, 'display limit must be capped at 5000');
+  assert.strictEqual(repository.findOrphanedOperations().length, 0);
+
+  await logger.info('migration.started', 'Migration started', { component: 'migration', operationId: 'op-orphan' });
+  await logger.close();
+  assert.strictEqual(repository.findOrphanedOperations().length, 1);
+
+  const legacyRoot = layout.getLogPath('app');
+  fs.mkdirSync(legacyRoot, { recursive: true });
+  fs.writeFileSync(path.join(legacyRoot, '2020-01-01.log'), `${JSON.stringify({ ts: '2020-01-01T00:00:00.000Z', level: 'info', source: 'legacy', event: 'legacy.event', message: 'old' })}\n`);
+  assert.strictEqual(repository.query({ from: '2019-01-01', to: '2021-01-01', event: 'legacy.event' }).entries.length, 1, 'legacy app/hooks logs remain read-only query sources');
+
+  const date = localDay();
+  const mergeA = path.join(layout.getLogPath('project', 'merge-a'), `${date}.jsonl`);
+  const mergeB = path.join(layout.getLogPath('project', 'merge-b'), `${date}.jsonl`);
+  fs.mkdirSync(path.dirname(mergeA), { recursive: true });
+  fs.mkdirSync(path.dirname(mergeB), { recursive: true });
+  const longMessage = `long-${'界'.repeat(70000)}`;
+  const longRecord = { ...normalizeRecord({ id: 'a-1', ts: `${date}T01:00:00.000Z`, level: 'info', event: 'merge.a1', message: 'placeholder', projectId: 'merge-a' }), message: longMessage };
+  fs.writeFileSync(mergeA,
+    `${JSON.stringify(longRecord)}\r\n`
+    + line({ id: 'a-2', ts: `${date}T03:00:00.000Z`, level: 'warn', event: 'merge.a2', message: 'newer a', projectId: 'merge-a' })
+    + '{bad-tail',
+    'utf8');
+  fs.writeFileSync(mergeB,
+    line({ id: 'b-1', ts: `${date}T02:00:00.000Z`, level: 'error', event: 'merge.b1', message: 'middle b', projectId: 'merge-b' }),
+    'utf8');
+
+  const originalReadFileSync = fs.readFileSync;
+  fs.readFileSync = function guardedRead(filePath, ...args) {
+    if (typeof filePath === 'string' && filePath.startsWith(path.join(dataDir, 'logs')) && /\.(?:jsonl|log)$/.test(filePath)) {
+      throw new Error('LogRepository must not read an entire log file');
+    }
+    return originalReadFileSync.call(this, filePath, ...args);
+  };
+  let merged;
+  try {
+    merged = repository.query({ event: '', q: 'merge.', pageSize: 3 });
+  } finally {
+    fs.readFileSync = originalReadFileSync;
+  }
+  assert.deepStrictEqual(merged.entries.map(entry => entry.id), ['a-2', 'b-1', 'a-1'], 'all-project query must k-way merge by timestamp and skip malformed tail data');
+  const long = repository.query({ projectId: 'merge-a', event: 'merge.a1' });
+  assert.strictEqual(long.entries.length, 1);
+  assert(long.entries[0].message.startsWith(`long-${'界'.repeat(100)}`), 'reverse chunk reader must parse lines larger than one chunk');
+  assert(long.entries[0].message.includes('[truncated:'), 'public query must still apply field size bounds');
+
+  const cursorPage = repository.query({ q: 'merge.', pageSize: 1 });
+  assert(cursorPage.nextCursor);
+  fs.unlinkSync(mergeB);
+  assert.throws(
+    () => repository.query({ q: 'merge.', pageSize: 1, cursor: cursorPage.nextCursor }),
+    error => error.code === 'LOG_CURSOR_EXPIRED' && error.retryable === true,
+    'manually deleted cursor source must return a typed restart error',
+  );
+
+  console.log('logging-api-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/logging-sse-no-gap-test.js

@@ -1,88 +1,88 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnServer } = require('./helpers/spawn-server');
-const { StorageLayout } = require('../lib/storage-layout');
-const { LogRepository } = require('../lib/structured-logger');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const PORT = 7950 + (process.pid % 300);
-const BASE = `http://127.0.0.1:${PORT}`;
-
-async function waitForServer() {
-  for (let attempt = 0; attempt < 100; attempt += 1) {
-    try { if ((await fetch(`${BASE}/api/health`)).ok) return; } catch {}
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-  throw new Error('server did not start');
-}
-
-(async () => {
-  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-log-sse-'));
-  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'log-sse', extraEnv: { KB_SKIP_MIGRATION: '1' } });
-  try {
-    await waitForServer();
-    let response = await fetch(`${BASE}/api/logs?q=http.request_`);
-    let snapshot = await response.json();
-    assert.strictEqual(snapshot.pageSize, 500, 'HTTP logs API must preserve the 500-row default');
-    assert(snapshot.streamCursor);
-    response = await fetch(`${BASE}/api/logs?pageSize=999999`);
-    assert.strictEqual((await response.json()).pageSize, 5000, 'HTTP logs API must cap the display page at 5000');
-
-    await fetch(`${BASE}/api/state`);
-    await fetch(`${BASE}/api/projects/not-valid%2Fid`);
-    await new Promise(resolve => setTimeout(resolve, 100));
-    const watermark = JSON.parse(Buffer.from(snapshot.streamCursor, 'base64url').toString('utf8'));
-    const repository = new LogRepository({ layout: new StorageLayout({ dataDir }) });
-    const page = repository.query({ q: 'http.request_', pageSize: 5000 });
-    const expectedGapIds = [];
-    for (const entry of page.entries) {
-      if (entry.id === watermark.afterId) break;
-      expectedGapIds.push(entry.id);
-    }
-    assert(expectedGapIds.length >= 3, 'fixture must create completed and failed requests between GET and SSE');
-
-    const controller = new AbortController();
-    response = await fetch(`${BASE}/api/logs/stream?q=http.request_&streamCursor=${encodeURIComponent(snapshot.streamCursor)}`, { signal: controller.signal });
-    assert.strictEqual(response.status, 200);
-    assert.match(response.headers.get('content-type'), /text\/event-stream/);
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let pending = '';
-    const streamedIds = new Set();
-    let ready = false;
-    const deadline = Date.now() + 5000;
-    while (Date.now() < deadline && (!ready || expectedGapIds.some(id => !streamedIds.has(id)))) {
-      const read = await Promise.race([
-        reader.read(),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('SSE read timeout')), 1000)),
-      ]);
-      if (read.done) break;
-      pending += decoder.decode(read.value, { stream: true });
-      const frames = pending.split('\n\n');
-      pending = frames.pop() || '';
-      for (const frame of frames) {
-        const dataLine = frame.split('\n').find(line => line.startsWith('data: '));
-        if (!dataLine) continue;
-        const event = JSON.parse(dataLine.slice(6));
-        if (event.type === 'logs/ready') ready = true;
-        if (event.type === 'logs/appended' && event.record) streamedIds.add(event.record.id);
-      }
-    }
-    controller.abort();
-    assert(ready, 'SSE must mark the replay/live handoff');
-    assert(expectedGapIds.every(id => streamedIds.has(id)), 'GET-to-SSE handoff must replay every durable gap record exactly by id');
-
-    const requestLogs = repository.query({ q: 'http.request_', pageSize: 5000 }).entries;
-    assert(requestLogs.some(entry => entry.event === 'http.request_started'));
-    assert(requestLogs.some(entry => entry.event === 'http.request_completed' && entry.durationMs >= 0));
-    assert(requestLogs.some(entry => entry.event === 'http.request_failed' && entry.operationId));
-    console.log('logging-sse-no-gap-test PASS');
-  } finally {
-    await spawned.cleanup();
-  }
-})().catch(error => {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-});
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnServer } = require('./helpers/spawn-server');
+const { StorageLayout } = require('../lib/storage-layout');
+const { LogRepository } = require('../lib/structured-logger');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const PORT = 7950 + (process.pid % 300);
+const BASE = `http://127.0.0.1:${PORT}`;
+
+async function waitForServer() {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    try { if ((await fetch(`${BASE}/api/health`)).ok) return; } catch {}
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('server did not start');
+}
+
+(async () => {
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-log-sse-'));
+  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'log-sse', extraEnv: { KB_SKIP_MIGRATION: '1' } });
+  try {
+    await waitForServer();
+    let response = await fetch(`${BASE}/api/logs?q=http.request_`);
+    let snapshot = await response.json();
+    assert.strictEqual(snapshot.pageSize, 500, 'HTTP logs API must preserve the 500-row default');
+    assert(snapshot.streamCursor);
+    response = await fetch(`${BASE}/api/logs?pageSize=999999`);
+    assert.strictEqual((await response.json()).pageSize, 5000, 'HTTP logs API must cap the display page at 5000');
+
+    await fetch(`${BASE}/api/state`);
+    await fetch(`${BASE}/api/projects/not-valid%2Fid`);
+    await new Promise(resolve => setTimeout(resolve, 100));
+    const watermark = JSON.parse(Buffer.from(snapshot.streamCursor, 'base64url').toString('utf8'));
+    const repository = new LogRepository({ layout: new StorageLayout({ dataDir }) });
+    const page = repository.query({ q: 'http.request_', pageSize: 5000 });
+    const expectedGapIds = [];
+    for (const entry of page.entries) {
+      if (entry.id === watermark.afterId) break;
+      expectedGapIds.push(entry.id);
+    }
+    assert(expectedGapIds.length >= 3, 'fixture must create completed and failed requests between GET and SSE');
+
+    const controller = new AbortController();
+    response = await fetch(`${BASE}/api/logs/stream?q=http.request_&streamCursor=${encodeURIComponent(snapshot.streamCursor)}`, { signal: controller.signal });
+    assert.strictEqual(response.status, 200);
+    assert.match(response.headers.get('content-type'), /text\/event-stream/);
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let pending = '';
+    const streamedIds = new Set();
+    let ready = false;
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline && (!ready || expectedGapIds.some(id => !streamedIds.has(id)))) {
+      const read = await Promise.race([
+        reader.read(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('SSE read timeout')), 1000)),
+      ]);
+      if (read.done) break;
+      pending += decoder.decode(read.value, { stream: true });
+      const frames = pending.split('\n\n');
+      pending = frames.pop() || '';
+      for (const frame of frames) {
+        const dataLine = frame.split('\n').find(line => line.startsWith('data: '));
+        if (!dataLine) continue;
+        const event = JSON.parse(dataLine.slice(6));
+        if (event.type === 'logs/ready') ready = true;
+        if (event.type === 'logs/appended' && event.record) streamedIds.add(event.record.id);
+      }
+    }
+    controller.abort();
+    assert(ready, 'SSE must mark the replay/live handoff');
+    assert(expectedGapIds.every(id => streamedIds.has(id)), 'GET-to-SSE handoff must replay every durable gap record exactly by id');
+
+    const requestLogs = repository.query({ q: 'http.request_', pageSize: 5000 }).entries;
+    assert(requestLogs.some(entry => entry.event === 'http.request_started'));
+    assert(requestLogs.some(entry => entry.event === 'http.request_completed' && entry.durationMs >= 0));
+    assert(requestLogs.some(entry => entry.event === 'http.request_failed' && entry.operationId));
+    console.log('logging-sse-no-gap-test PASS');
+  } finally {
+    await spawned.cleanup();
+  }
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/logging-ui-test.js

@@ -1,104 +1,106 @@
-const assert = require('assert');
-const path = require('path');
-const { spawnServer } = require('./helpers/spawn-server');
-const { requestJson, waitFor } = require('./helpers/cdp-browser');
-const { createLoggingUiFixture } = require('./helpers/logging-ui-fixture');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const port = 8750 + (process.pid % 180);
-
-function baseParams(fixture, pageSize) {
-  const params = new URLSearchParams();
-  params.set('from', '2000-01-01');
-  params.set('to', '2999-12-31');
-  params.set('levels', 'trace,debug,info,warn,error,fatal');
-  params.set('projectId', fixture.projectId);
-  params.set('pageSize', String(pageSize || 10));
-  return params;
-}
-
-async function jsonResponse(url) {
-  const response = await fetch(url, { headers: { Accept: 'application/json' } });
-  const body = await response.json();
-  return { response, body };
-}
-
-(async () => {
-  const fixture = await createLoggingUiFixture({ totalLogs: 64 });
-  const server = spawnServer({ root: ROOT, port, dataDir: fixture.dataDir, tag: 'logging-ui-api', stdio: 'ignore' });
-  try {
-    await waitFor(() => requestJson('http://127.0.0.1:' + port + '/api/health').then(body => body.ok), 'logging API', 20000);
-    const baseUrl = 'http://127.0.0.1:' + port;
-    const firstParams = baseParams(fixture, 10);
-    const first = await jsonResponse(baseUrl + '/api/logs?' + firstParams.toString());
-    assert.strictEqual(first.response.status, 200);
-    assert.strictEqual(first.body.entries.length, 10);
-    assert(first.body.nextCursor, 'first page must return an opaque next cursor');
-    assert.strictEqual(first.body.pageSize, 10);
-    assert(first.body.health && first.body.health.status === 'ok');
-    assert.deepStrictEqual(Object.keys(first.body.counts).sort(), ['debug', 'error', 'fatal', 'info', 'trace', 'warn']);
-
-    const secondParams = baseParams(fixture, 10);
-    secondParams.set('cursor', first.body.nextCursor);
-    const second = await jsonResponse(baseUrl + '/api/logs?' + secondParams.toString());
-    assert.strictEqual(second.response.status, 200);
-    assert.strictEqual(second.body.entries.length, 10);
-    assert(!second.body.entries.some(entry => first.body.entries.some(prior => prior.id === entry.id)), 'cursor pages must not overlap');
-
-    const invalidParams = baseParams(fixture, 10);
-    invalidParams.set('cursor', first.body.nextCursor);
-    invalidParams.set('q', 'changed-fingerprint');
-    const invalid = await jsonResponse(baseUrl + '/api/logs?' + invalidParams.toString());
-    assert.strictEqual(invalid.response.status, 409);
-    assert.strictEqual(invalid.body.error.code, 'LOG_CURSOR_EXPIRED');
-    assert.strictEqual(invalid.body.error.retryable, true);
-    assert(!('stack' in invalid.body.error), 'public cursor error must not leak a stack');
-
-    const filters = [
-      ['component', 'commit-reconciler'],
-      ['event', 'fixture.phase.10'],
-      ['operationId', 'op-flow-visual'],
-      ['commitSha', fixture.repo.headCommit],
-      ['q', '<img src=x onerror=window.__xss=1>'],
-      ['levels', 'fatal'],
-    ];
-    for (const pair of filters) {
-      const params = baseParams(fixture, 100);
-      params.set(pair[0], pair[1]);
-      const result = await jsonResponse(baseUrl + '/api/logs?' + params.toString());
-      assert.strictEqual(result.response.status, 200, 'filter failed: ' + pair[0]);
-      assert(result.body.entries.length > 0, 'filter returned no entries: ' + pair[0]);
-    }
-
-    const exportParams = baseParams(fixture, 100);
-    exportParams.delete('pageSize');
-    exportParams.set('operationId', 'op-flow-visual');
-    exportParams.set('component', 'commit-reconciler');
-    exportParams.set('event', 'fixture.phase.3');
-    exportParams.set('commitSha', fixture.repo.headCommit);
-    const exported = await fetch(baseUrl + '/api/logs/export?' + exportParams.toString(), { headers: { Accept: 'application/x-ndjson' } });
-    assert.strictEqual(exported.status, 200);
-    assert((exported.headers.get('content-type') || '').includes('application/x-ndjson'));
-    assert((exported.headers.get('content-disposition') || '').includes('attachment'));
-    const lines = (await exported.text()).trim().split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line));
-    assert.strictEqual(lines.length, 1);
-    assert(lines.every(entry => entry.operationId === 'op-flow-visual' && entry.component === 'commit-reconciler' && entry.event === 'fixture.phase.3'));
-
-    const rootMutation = await fetch(baseUrl + '/api/settings', {
-      method: 'PATCH',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ logging: { rootPath: path.join(fixture.dataDir, 'elsewhere') } }),
-    });
-    assert.strictEqual(rootMutation.status, 409, 'logging root must not be mutable through the API');
-    const persistedSettings = JSON.parse(require('fs').readFileSync(fixture.layout.getSettingsPath(), 'utf8'));
-    assert(!Object.prototype.hasOwnProperty.call(persistedSettings.logging, 'rootPath'));
-
-    console.log('logging UI test PASS');
-  } finally {
-    await server.cleanup();
-    fixture.cleanup();
-  }
-})().catch(error => {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-});
+const assert = require('assert');
+const path = require('path');
+const { spawnServer } = require('./helpers/spawn-server');
+const { requestJson, waitFor } = require('./helpers/cdp-browser');
+const { createLoggingUiFixture } = require('./helpers/logging-ui-fixture');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const port = 8750 + (process.pid % 180);
+
+function baseParams(fixture, pageSize) {
+  const params = new URLSearchParams();
+  params.set('from', '2000-01-01');
+  params.set('to', '2999-12-31');
+  params.set('levels', 'trace,debug,info,warn,error,fatal');
+  params.set('projectId', fixture.projectId);
+  params.set('pageSize', String(pageSize || 10));
+  return params;
+}
+
+async function jsonResponse(url) {
+  const response = await fetch(url, { headers: { Accept: 'application/json' } });
+  const body = await response.json();
+  return { response, body };
+}
+
+(async () => {
+  const fixture = await createLoggingUiFixture({ totalLogs: 64 });
+  const server = spawnServer({ root: ROOT, port, dataDir: fixture.dataDir, tag: 'logging-ui-api', stdio: 'ignore' });
+  try {
+    await waitFor(() => requestJson('http://127.0.0.1:' + port + '/api/health').then(body => body.ok), 'logging API', 20000);
+    const baseUrl = 'http://127.0.0.1:' + port;
+    const firstParams = baseParams(fixture, 10);
+    const first = await jsonResponse(baseUrl + '/api/logs?' + firstParams.toString());
+    assert.strictEqual(first.response.status, 200);
+    assert.strictEqual(first.body.entries.length, 10);
+    assert(first.body.nextCursor, 'first page must return an opaque next cursor');
+    assert.strictEqual(first.body.pageSize, 10);
+    assert(first.body.health && first.body.health.status === 'ok');
+    assert.deepStrictEqual(Object.keys(first.body.counts).sort(), ['debug', 'error', 'fatal', 'info', 'trace', 'warn']);
+
+    const secondParams = baseParams(fixture, 10);
+    secondParams.set('cursor', first.body.nextCursor);
+    const second = await jsonResponse(baseUrl + '/api/logs?' + secondParams.toString());
+    assert.strictEqual(second.response.status, 200);
+    assert.strictEqual(second.body.entries.length, 10);
+    assert(!second.body.entries.some(entry => first.body.entries.some(prior => prior.id === entry.id)), 'cursor pages must not overlap');
+
+    const invalidParams = baseParams(fixture, 10);
+    invalidParams.set('cursor', first.body.nextCursor);
+    invalidParams.set('q', 'changed-fingerprint');
+    const invalid = await jsonResponse(baseUrl + '/api/logs?' + invalidParams.toString());
+    assert.strictEqual(invalid.response.status, 409);
+    assert.strictEqual(invalid.body.error.code, 'LOG_CURSOR_EXPIRED');
+    assert.strictEqual(invalid.body.error.retryable, true);
+    assert(!('stack' in invalid.body.error), 'public cursor error must not leak a stack');
+
+    const filters = [
+      ['component', 'commit-reconciler'],
+      ['event', 'fixture.phase.10'],
+      ['operationId', 'op-flow-visual'],
+      ['commitSha', fixture.repo.headCommit],
+      ['q', '<img src=x onerror=window.__xss=1>'],
+      ['q', 'VALIDATION_FAILED'],
+      ['q', '模型输出校验失败'],
+      ['levels', 'fatal'],
+    ];
+    for (const pair of filters) {
+      const params = baseParams(fixture, 100);
+      params.set(pair[0], pair[1]);
+      const result = await jsonResponse(baseUrl + '/api/logs?' + params.toString());
+      assert.strictEqual(result.response.status, 200, 'filter failed: ' + pair[0]);
+      assert(result.body.entries.length > 0, 'filter returned no entries: ' + pair[0]);
+    }
+
+    const exportParams = baseParams(fixture, 100);
+    exportParams.delete('pageSize');
+    exportParams.set('operationId', 'op-flow-visual');
+    exportParams.set('component', 'commit-reconciler');
+    exportParams.set('event', 'fixture.phase.3');
+    exportParams.set('commitSha', fixture.repo.headCommit);
+    const exported = await fetch(baseUrl + '/api/logs/export?' + exportParams.toString(), { headers: { Accept: 'application/x-ndjson' } });
+    assert.strictEqual(exported.status, 200);
+    assert((exported.headers.get('content-type') || '').includes('application/x-ndjson'));
+    assert((exported.headers.get('content-disposition') || '').includes('attachment'));
+    const lines = (await exported.text()).trim().split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line));
+    assert.strictEqual(lines.length, 1);
+    assert(lines.every(entry => entry.operationId === 'op-flow-visual' && entry.component === 'commit-reconciler' && entry.event === 'fixture.phase.3'));
+
+    const rootMutation = await fetch(baseUrl + '/api/settings', {
+      method: 'PATCH',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ logging: { rootPath: path.join(fixture.dataDir, 'elsewhere') } }),
+    });
+    assert.strictEqual(rootMutation.status, 409, 'logging root must not be mutable through the API');
+    const persistedSettings = JSON.parse(require('fs').readFileSync(fixture.layout.getSettingsPath(), 'utf8'));
+    assert(!Object.prototype.hasOwnProperty.call(persistedSettings.logging, 'rootPath'));
+
+    console.log('logging UI test PASS');
+  } finally {
+    await server.cleanup();
+    fixture.cleanup();
+  }
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});