@vibelet/cli 0.1.37 → 1.0.0

package/src/session-title.test.ts

@@ -1,286 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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),
-  };
-}