@vibelet/cli 0.1.35 → 0.1.36

package/src/session-title.test.ts

@@ -0,0 +1,286 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  sanitizeSessionTitle,
+  isIdLikeSessionTitle,
+  isFallbackSessionTitle,
+  titleFromFirstSentence,
+  preferSessionTitle,
+} from './session-title.js';
+
+describe('sanitizeSessionTitle', () => {
+  it('returns undefined for null', () => {
+    assert.equal(sanitizeSessionTitle(null), undefined);
+  });
+
+  it('returns undefined for undefined', () => {
+    assert.equal(sanitizeSessionTitle(undefined), undefined);
+  });
+
+  it('returns undefined for non-string values', () => {
+    assert.equal(sanitizeSessionTitle(42 as any), undefined);
+    assert.equal(sanitizeSessionTitle(true as any), undefined);
+    assert.equal(sanitizeSessionTitle({} as any), undefined);
+  });
+
+  it('returns undefined for empty string', () => {
+    assert.equal(sanitizeSessionTitle(''), undefined);
+  });
+
+  it('returns undefined for whitespace-only string', () => {
+    assert.equal(sanitizeSessionTitle('   '), undefined);
+    assert.equal(sanitizeSessionTitle('\t\n'), undefined);
+  });
+
+  it('collapses internal whitespace', () => {
+    assert.equal(sanitizeSessionTitle('hello   world'), 'hello world');
+    assert.equal(sanitizeSessionTitle('a\n\nb\tc'), 'a b c');
+  });
+
+  it('trims leading and trailing whitespace', () => {
+    assert.equal(sanitizeSessionTitle('  hello  '), 'hello');
+  });
+
+  it('returns normalized string for valid input', () => {
+    assert.equal(sanitizeSessionTitle('Fix the bug'), 'Fix the bug');
+  });
+});
+
+describe('isIdLikeSessionTitle', () => {
+  it('returns false for null/undefined', () => {
+    assert.equal(isIdLikeSessionTitle(null), false);
+    assert.equal(isIdLikeSessionTitle(undefined), false);
+  });
+
+  it('returns false for empty string', () => {
+    assert.equal(isIdLikeSessionTitle(''), false);
+  });
+
+  it('detects long hex strings (8+ chars)', () => {
+    assert.equal(isIdLikeSessionTitle('abcdef01'), true);
+    assert.equal(isIdLikeSessionTitle('0123456789abcdef'), true);
+    assert.equal(isIdLikeSessionTitle('ABCDEF01'), true);
+  });
+
+  it('does not match short hex strings (<8 chars)', () => {
+    assert.equal(isIdLikeSessionTitle('abcdef0'), false);
+  });
+
+  it('detects UUID format', () => {
+    assert.equal(isIdLikeSessionTitle('550e8400-e29b-41d4-a716-446655440000'), true);
+    assert.equal(isIdLikeSessionTitle('ABCDEF00-1234-5678-9ABC-DEF012345678'), true);
+  });
+
+  it('detects agent-prefixed IDs', () => {
+    assert.equal(isIdLikeSessionTitle('agent-abc123'), true);
+    assert.equal(isIdLikeSessionTitle('agent-some_long-id'), true);
+  });
+
+  it('rejects agent prefix with short suffix', () => {
+    assert.equal(isIdLikeSessionTitle('agent-abc'), false);
+  });
+
+  it('returns false for normal titles', () => {
+    assert.equal(isIdLikeSessionTitle('Fix the login bug'), false);
+    assert.equal(isIdLikeSessionTitle('Refactor utils'), false);
+  });
+});
+
+describe('isFallbackSessionTitle', () => {
+  it('returns true for null/undefined/empty', () => {
+    assert.equal(isFallbackSessionTitle(null), true);
+    assert.equal(isFallbackSessionTitle(undefined), true);
+    assert.equal(isFallbackSessionTitle(''), true);
+    assert.equal(isFallbackSessionTitle('   '), true);
+  });
+
+  it('returns true for generic titles', () => {
+    assert.equal(isFallbackSessionTitle('New session'), true);
+    assert.equal(isFallbackSessionTitle('Resumed session'), true);
+    assert.equal(isFallbackSessionTitle('Untitled session'), true);
+  });
+
+  it('returns true for UUID-like titles', () => {
+    assert.equal(isFallbackSessionTitle('550e8400-e29b-41d4-a716-446655440000'), true);
+    assert.equal(isFallbackSessionTitle('abcdef0123456789'), true);
+    assert.equal(isFallbackSessionTitle('agent-abc123def'), true);
+  });
+
+  it('returns false for real titles', () => {
+    assert.equal(isFallbackSessionTitle('Fix the login bug'), false);
+    assert.equal(isFallbackSessionTitle('Add dark mode support'), false);
+  });
+});
+
+describe('titleFromFirstSentence', () => {
+  it('returns undefined for null/undefined', () => {
+    assert.equal(titleFromFirstSentence(null), undefined);
+    assert.equal(titleFromFirstSentence(undefined), undefined);
+  });
+
+  it('returns undefined for empty/whitespace string', () => {
+    assert.equal(titleFromFirstSentence(''), undefined);
+    assert.equal(titleFromFirstSentence('   '), undefined);
+  });
+
+  it('extracts first sentence ending with period', () => {
+    assert.equal(titleFromFirstSentence('Fix the bug. Then deploy.'), 'Fix the bug');
+  });
+
+  it('extracts first sentence ending with exclamation mark', () => {
+    assert.equal(titleFromFirstSentence('Great feature! It works.'), 'Great feature');
+  });
+
+  it('extracts first sentence ending with question mark', () => {
+    assert.equal(titleFromFirstSentence('Does this work? I think so.'), 'Does this work');
+  });
+
+  it('extracts first sentence ending with semicolon', () => {
+    assert.equal(titleFromFirstSentence('First part; second part'), 'First part');
+  });
+
+  it('handles Chinese sentence markers', () => {
+    assert.equal(titleFromFirstSentence('修复了登录问题。然后部署。'), '修复了登录问题');
+    assert.equal(titleFromFirstSentence('这是什么？我不知道。'), '这是什么');
+    assert.equal(titleFromFirstSentence('太好了！继续。'), '太好了');
+    assert.equal(titleFromFirstSentence('第一部分；第二部分'), '第一部分');
+  });
+
+  it('does not split on period without trailing space (e.g. file.ts)', () => {
+    assert.equal(titleFromFirstSentence('Update file.ts for production'), 'Update file.ts for production');
+  });
+
+  it('does split on period at end of string', () => {
+    assert.equal(titleFromFirstSentence('Fix the bug.'), 'Fix the bug');
+  });
+
+  it('returns the whole line if no sentence boundary found', () => {
+    assert.equal(titleFromFirstSentence('Fix the bug'), 'Fix the bug');
+  });
+
+  it('skips meta noise lines', () => {
+    assert.equal(
+      titleFromFirstSentence('<environment_context>some context\nActual title here'),
+      'Actual title here',
+    );
+    assert.equal(
+      titleFromFirstSentence('<command-name>run\nReal title'),
+      'Real title',
+    );
+    assert.equal(
+      titleFromFirstSentence('<command-message>msg\nReal title'),
+      'Real title',
+    );
+    assert.equal(
+      titleFromFirstSentence('<command-args>args\nReal title'),
+      'Real title',
+    );
+    assert.equal(
+      titleFromFirstSentence('<local-command-caveat>caveat\nReal title'),
+      'Real title',
+    );
+    assert.equal(
+      titleFromFirstSentence('<local-command-stdout>out\nReal title'),
+      'Real title',
+    );
+    assert.equal(
+      titleFromFirstSentence('<local-command-stderr>err\nReal title'),
+      'Real title',
+    );
+    assert.equal(
+      titleFromFirstSentence('# AGENTS.md instructions for something\nReal title'),
+      'Real title',
+    );
+  });
+
+  it('skips path-like lines', () => {
+    assert.equal(titleFromFirstSentence('/usr/bin/node\nActual title'), 'Actual title');
+    assert.equal(titleFromFirstSentence('~/projects/foo\nActual title'), 'Actual title');
+    assert.equal(titleFromFirstSentence('./src/index.ts\nActual title'), 'Actual title');
+    assert.equal(titleFromFirstSentence('../parent/file\nActual title'), 'Actual title');
+  });
+
+  it('skips Windows path-like lines', () => {
+    assert.equal(titleFromFirstSentence('C:\\Users\\foo\nActual title'), 'Actual title');
+  });
+
+  it('skips quoted path-like lines', () => {
+    assert.equal(titleFromFirstSentence('"/usr/bin/node"\nActual title'), 'Actual title');
+    assert.equal(titleFromFirstSentence("'~/foo'\nActual title"), 'Actual title');
+  });
+
+  it('truncates long titles with ellipsis', () => {
+    const longText = 'This is a very long title that keeps going and going and should be truncated at some reasonable length by the function';
+    const result = titleFromFirstSentence(longText);
+    assert.ok(result!.length <= 80);
+    assert.ok(result!.endsWith('...'));
+  });
+
+  it('respects custom maxLength', () => {
+    const result = titleFromFirstSentence('This is a somewhat long title for testing', 20);
+    assert.ok(result!.length <= 20);
+    assert.ok(result!.endsWith('...'));
+  });
+
+  it('does not truncate titles within maxLength', () => {
+    assert.equal(titleFromFirstSentence('Short title', 80), 'Short title');
+  });
+
+  it('returns undefined if extracted title is ID-like', () => {
+    assert.equal(titleFromFirstSentence('550e8400-e29b-41d4-a716-446655440000'), undefined);
+    assert.equal(titleFromFirstSentence('abcdef0123456789'), undefined);
+  });
+
+  it('skips empty lines to find the first meaningful line', () => {
+    assert.equal(titleFromFirstSentence('\n\n\nActual title'), 'Actual title');
+  });
+
+  it('handles \\r\\n line endings', () => {
+    assert.equal(titleFromFirstSentence('\r\n\r\nActual title'), 'Actual title');
+  });
+});
+
+describe('preferSessionTitle', () => {
+  it('returns first non-fallback candidate', () => {
+    assert.equal(preferSessionTitle(['Fix the bug', 'Other title']), 'Fix the bug');
+  });
+
+  it('skips null and undefined candidates', () => {
+    assert.equal(preferSessionTitle([null, undefined, 'Fix the bug']), 'Fix the bug');
+  });
+
+  it('skips generic fallback titles', () => {
+    assert.equal(
+      preferSessionTitle(['New session', 'Resumed session', 'Real title']),
+      'Real title',
+    );
+  });
+
+  it('skips ID-like candidates', () => {
+    assert.equal(
+      preferSessionTitle(['550e8400-e29b-41d4-a716-446655440000', 'Real title']),
+      'Real title',
+    );
+  });
+
+  it('falls back to titleFromFirstSentence when all candidates are fallback', () => {
+    assert.equal(
+      preferSessionTitle(['New session', null], 'Extract this title from text'),
+      'Extract this title from text',
+    );
+  });
+
+  it('returns undefined when no candidates and no fallback', () => {
+    assert.equal(preferSessionTitle([null, undefined]), undefined);
+  });
+
+  it('returns undefined when all candidates are fallback and fallback text is empty', () => {
+    assert.equal(preferSessionTitle(['New session'], ''), undefined);
+    assert.equal(preferSessionTitle(['New session'], null), undefined);
+  });
+
+  it('returns undefined for empty candidates array with no fallback', () => {
+    assert.equal(preferSessionTitle([]), undefined);
+  });
+});

package/src/session-title.ts

@@ -0,0 +1,108 @@
+const GENERIC_SESSION_TITLES = new Set([
+  'New session',
+  'Resumed session',
+  'Untitled session',
+]);
+
+const KNOWN_META_PREFIXES = [
+  '<environment_context>',
+  '<local-command-caveat>',
+  '<local-command-stdout>',
+  '<local-command-stderr>',
+  '<command-name>',
+  '<command-message>',
+  '<command-args>',
+  '# AGENTS.md instructions for ',
+];
+
+function collapseWhitespace(text: string): string {
+  return text.replace(/\s+/g, ' ').trim();
+}
+
+export function sanitizeSessionTitle(title?: string | null): string | undefined {
+  if (typeof title !== 'string') return undefined;
+  const normalized = collapseWhitespace(title);
+  return normalized || undefined;
+}
+
+export function isIdLikeSessionTitle(title?: string | null): boolean {
+  const normalized = sanitizeSessionTitle(title);
+  if (!normalized) return false;
+  return (
+    /^[0-9a-f]{8,}$/i.test(normalized) ||
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(normalized) ||
+    /^agent-[a-z0-9_-]{6,}$/i.test(normalized)
+  );
+}
+
+export function isFallbackSessionTitle(title?: string | null): boolean {
+  const normalized = sanitizeSessionTitle(title);
+  return !normalized || GENERIC_SESSION_TITLES.has(normalized) || isIdLikeSessionTitle(normalized);
+}
+
+function firstNonEmptyLine(text: string): string | undefined {
+  for (const line of text.replace(/\r/g, '').split('\n')) {
+    const normalized = sanitizeSessionTitle(line);
+    if (!normalized) continue;
+    if (isMetaTitleNoise(normalized)) continue;
+    if (isPathLikeTitleLine(normalized)) continue;
+    return normalized;
+  }
+  return undefined;
+}
+
+function isMetaTitleNoise(text: string): boolean {
+  return KNOWN_META_PREFIXES.some(prefix => text.startsWith(prefix));
+}
+
+function isPathLikeTitleLine(text: string): boolean {
+  const stripped = text
+    .replace(/^['"`]+/, '')
+    .replace(/['"`\\]+$/, '')
+    .trim();
+  if (!stripped) return true;
+  if (/^(\/|~\/|\.\/|\.\.\/)/.test(stripped)) return true;
+  if (/^[A-Za-z]:\\/.test(stripped)) return true;
+  return false;
+}
+
+function findSentenceBoundary(text: string): number {
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '。' || char === '！' || char === '？' || char === '；') {
+      return index + 1;
+    }
+    if (char === '.' || char === '!' || char === '?' || char === ';') {
+      const next = text[index + 1];
+      if (!next || /\s/.test(next)) {
+        return index + 1;
+      }
+    }
+  }
+  return -1;
+}
+
+export function titleFromFirstSentence(text?: string | null, maxLength = 80): string | undefined {
+  if (typeof text !== 'string') return undefined;
+  const line = firstNonEmptyLine(text);
+  if (!line) return undefined;
+
+  const boundary = findSentenceBoundary(line);
+  const sentence = boundary > 0 ? line.slice(0, boundary) : line;
+  const stripped = sentence.replace(/[。！？；.!?;]+$/gu, '').trim();
+  if (!stripped || isIdLikeSessionTitle(stripped)) return undefined;
+  if (stripped.length <= maxLength) return stripped;
+  return `${stripped.slice(0, Math.max(1, maxLength - 3)).trimEnd()}...`;
+}
+
+export function preferSessionTitle(
+  candidates: Array<string | null | undefined>,
+  fallbackText?: string | null,
+): string | undefined {
+  for (const candidate of candidates) {
+    const normalized = sanitizeSessionTitle(candidate);
+    if (!normalized || isFallbackSessionTitle(normalized)) continue;
+    return normalized;
+  }
+  return titleFromFirstSentence(fallbackText);
+}

package/src/shutdown-endpoint.test.ts

@@ -0,0 +1,95 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+// The bundled daemon entry is at the project root's dist/index.cjs
+const daemonEntry = resolve(import.meta.dirname, '..', '..', '..', 'dist', 'index.cjs');
+
+function waitForHealth(port: number, timeoutMs = 10000): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve) => {
+    const poll = async () => {
+      if (Date.now() > deadline) { resolve(false); return; }
+      try {
+        const res = await fetch(`http://127.0.0.1:${port}/health`);
+        if (res.ok) { resolve(true); return; }
+      } catch { /* retry */ }
+      setTimeout(poll, 200);
+    };
+    poll();
+  });
+}
+
+function waitForExit(child: ReturnType<typeof spawn>, timeoutMs = 5000): Promise<number | null> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      resolve(null);
+    }, timeoutMs);
+    child.on('exit', (code) => {
+      clearTimeout(timer);
+      resolve(code);
+    });
+  });
+}
+
+function spawnDaemon(port: number): { child: ReturnType<typeof spawn>; homeDir: string } {
+  const homeDir = mkdtempSync(join(tmpdir(), 'vibelet-shutdown-test-'));
+  const child = spawn(process.execPath, [daemonEntry], {
+    env: {
+      ...process.env,
+      HOME: homeDir,
+      VIBE_PORT: String(port),
+      VIBE_TOKEN: 'test-token',
+      CLAUDE_PATH: process.execPath,
+      CODEX_PATH: process.execPath,
+    },
+    stdio: ['ignore', 'ignore', 'ignore'],
+  });
+  return { child, homeDir };
+}
+
+test('POST /shutdown returns stopping and daemon exits', async () => {
+  const testPort = 29000 + Math.floor(Math.random() * 1000);
+  const { child, homeDir } = spawnDaemon(testPort);
+
+  try {
+    const healthy = await waitForHealth(testPort);
+    assert.ok(healthy, 'Daemon should become healthy');
+
+    const res = await fetch(`http://127.0.0.1:${testPort}/shutdown`, { method: 'POST' });
+    assert.equal(res.status, 200);
+    const body = await res.json() as { status: string };
+    assert.equal(body.status, 'stopping');
+
+    const exitCode = await waitForExit(child);
+    assert.notEqual(exitCode, null, 'Daemon should exit within timeout');
+  } finally {
+    child.kill('SIGKILL');
+    rmSync(homeDir, { recursive: true, force: true });
+  }
+});
+
+test('GET /shutdown does not trigger shutdown', async () => {
+  const testPort = 29000 + Math.floor(Math.random() * 1000);
+  const { child, homeDir } = spawnDaemon(testPort);
+
+  try {
+    const healthy = await waitForHealth(testPort);
+    assert.ok(healthy, 'Daemon should become healthy');
+
+    // GET /shutdown should not match the POST-only route
+    const res = await fetch(`http://127.0.0.1:${testPort}/shutdown`);
+    assert.notEqual(res.status, 200, 'GET /shutdown should not return 200');
+
+    // Daemon should still be alive
+    const stillHealthy = await waitForHealth(testPort, 1500);
+    assert.ok(stillHealthy, 'Daemon should still be running');
+  } finally {
+    child.kill('SIGKILL');
+    rmSync(homeDir, { recursive: true, force: true });
+  }
+});

package/src/storage-housekeeping.test.ts

@@ -0,0 +1,78 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runStorageHousekeepingSync, trimFileTailSync } from './storage-housekeeping.js';
+
+test('trimFileTailSync leaves files under the cap unchanged', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'vibelet-storage-'));
+  const filePath = join(dir, 'audit.jsonl');
+  writeFileSync(filePath, 'one\ntwo\n', 'utf8');
+
+  const result = trimFileTailSync(filePath, { maxBytes: 64 });
+
+  assert.equal(result.trimmed, false);
+  assert.equal(readFileSync(filePath, 'utf8'), 'one\ntwo\n');
+});
+
+test('trimFileTailSync keeps the newest tail aligned to a newline when trimming', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'vibelet-storage-'));
+  const filePath = join(dir, 'daemon.stdout.log');
+  writeFileSync(filePath, 'alpha\nbravo\ncharlie\ndelta\n', 'utf8');
+
+  const result = trimFileTailSync(filePath, {
+    maxBytes: 20,
+    retainBytes: 20,
+  });
+
+  assert.equal(result.trimmed, true);
+  assert.equal(readFileSync(filePath, 'utf8'), 'charlie\ndelta\n');
+  assert.equal(result.afterBytes, Buffer.byteLength('charlie\ndelta\n'));
+});
+
+test('trimFileTailSync reserves space for an incoming append', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'vibelet-storage-'));
+  const filePath = join(dir, 'audit.jsonl');
+  writeFileSync(filePath, '1111\n2222\n3333\n4444\n', 'utf8');
+
+  const result = trimFileTailSync(filePath, {
+    maxBytes: 18,
+    incomingBytes: 6,
+    retainBytes: 18,
+  });
+
+  assert.equal(result.trimmed, true);
+  assert.equal(readFileSync(filePath, 'utf8'), '3333\n4444\n');
+  assert.ok(result.afterBytes + 6 <= 18);
+});
+
+test('runStorageHousekeepingSync trims only oversized audit and log files', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'vibelet-storage-'));
+  const dataDir = join(dir, 'data');
+  const logDir = join(dir, 'logs');
+  mkdirSync(dataDir, { recursive: true });
+  mkdirSync(logDir, { recursive: true });
+
+  const auditPath = join(dataDir, 'audit.jsonl');
+  const stdoutLogPath = join(logDir, 'daemon.stdout.log');
+  const stderrLogPath = join(logDir, 'daemon.stderr.log');
+
+  writeFileSync(auditPath, 'old-a\nold-b\nkeep-a\nkeep-b\n', 'utf8');
+  writeFileSync(stdoutLogPath, 'stdout-old\nstdout-keep\n', 'utf8');
+  writeFileSync(stderrLogPath, 'stderr-ok\n', 'utf8');
+
+  const result = runStorageHousekeepingSync({
+    auditPath,
+    stdoutLogPath,
+    stderrLogPath,
+    auditMaxBytes: 20,
+    logMaxBytes: 20,
+  });
+
+  assert.equal(result.trimmedFiles, 2);
+  assert.ok(result.reclaimedBytes > 0);
+  assert.equal(readFileSync(auditPath, 'utf8'), 'keep-a\nkeep-b\n');
+  assert.equal(readFileSync(stdoutLogPath, 'utf8'), 'stdout-keep\n');
+  assert.equal(readFileSync(stderrLogPath, 'utf8'), 'stderr-ok\n');
+});

package/src/storage-housekeeping.ts

@@ -0,0 +1,111 @@
+import { closeSync, existsSync, ftruncateSync, openSync, readSync, statSync, writeSync } from 'fs';
+
+export interface TrimFileOptions {
+  maxBytes: number;
+  incomingBytes?: number;
+  retainBytes?: number;
+}
+
+export interface TrimFileResult {
+  path: string;
+  existed: boolean;
+  trimmed: boolean;
+  beforeBytes: number;
+  afterBytes: number;
+  reclaimedBytes: number;
+}
+
+export interface StorageHousekeepingOptions {
+  auditPath: string;
+  stdoutLogPath: string;
+  stderrLogPath: string;
+  auditMaxBytes: number;
+  logMaxBytes: number;
+}
+
+export interface StorageHousekeepingResult {
+  files: TrimFileResult[];
+  trimmedFiles: number;
+  reclaimedBytes: number;
+}
+
+function clampRetainBytes(beforeBytes: number, maxBytes: number, incomingBytes: number, retainBytes?: number): number {
+  const appendBudget = Math.max(0, maxBytes - incomingBytes);
+  const defaultRetain = Math.floor(maxBytes * 0.75);
+  return Math.max(0, Math.min(beforeBytes, appendBudget, retainBytes ?? defaultRetain));
+}
+
+export function trimFileTailSync(filePath: string, options: TrimFileOptions): TrimFileResult {
+  const existed = existsSync(filePath);
+  if (!existed) {
+    return {
+      path: filePath,
+      existed: false,
+      trimmed: false,
+      beforeBytes: 0,
+      afterBytes: 0,
+      reclaimedBytes: 0,
+    };
+  }
+
+  const beforeBytes = statSync(filePath).size;
+  const incomingBytes = Math.max(0, options.incomingBytes ?? 0);
+  if (options.maxBytes <= 0 || beforeBytes + incomingBytes <= options.maxBytes) {
+    return {
+      path: filePath,
+      existed: true,
+      trimmed: false,
+      beforeBytes,
+      afterBytes: beforeBytes,
+      reclaimedBytes: 0,
+    };
+  }
+
+  const keepBytes = clampRetainBytes(beforeBytes, options.maxBytes, incomingBytes, options.retainBytes);
+  const fd = openSync(filePath, 'r+');
+  try {
+    let tail = Buffer.alloc(0);
+    if (keepBytes > 0) {
+      const buffer = Buffer.alloc(keepBytes);
+      readSync(fd, buffer, 0, keepBytes, beforeBytes - keepBytes);
+      let start = 0;
+      if (beforeBytes > keepBytes) {
+        const newlineIndex = buffer.indexOf(0x0a);
+        if (newlineIndex >= 0 && newlineIndex + 1 < buffer.length) {
+          start = newlineIndex + 1;
+        }
+      }
+      tail = buffer.subarray(start);
+    }
+
+    ftruncateSync(fd, 0);
+    if (tail.length > 0) {
+      writeSync(fd, tail, 0, tail.length, 0);
+    }
+
+    return {
+      path: filePath,
+      existed: true,
+      trimmed: true,
+      beforeBytes,
+      afterBytes: tail.length,
+      reclaimedBytes: beforeBytes - tail.length,
+    };
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export function runStorageHousekeepingSync(options: StorageHousekeepingOptions): StorageHousekeepingResult {
+  const files = [
+    trimFileTailSync(options.auditPath, { maxBytes: options.auditMaxBytes }),
+    trimFileTailSync(options.stdoutLogPath, { maxBytes: options.logMaxBytes }),
+    trimFileTailSync(options.stderrLogPath, { maxBytes: options.logMaxBytes }),
+  ];
+
+  return {
+    files,
+    trimmedFiles: files.filter(file => file.trimmed).length,
+    reclaimedBytes: files.reduce((sum, file) => sum + file.reclaimedBytes, 0),
+  };
+}