Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

7.2 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { closeSync, existsSync, mkdtempSync, openSync, readFileSync, rmSync, statSync, writeFileSync, writeSync } from 'fs'
import { tmpdir } from 'os'
import { join } from 'path'
import {
  ts, sid, preview, installTimestampedConsole, logFrame,
  adoptLegacyLog, prepareLogFile, trimLogFile, LOG_MAX_BYTES,
} from './log.js'

describe('log helpers', () => {
  afterEach(() => vi.restoreAllMocks())

  it('formats ts() as YYYY-MM-DD HH:MM:SS.mmm', () => {
    expect(ts(new Date(2026, 6, 24, 9, 5, 3, 7))).toBe('2026-07-24 09:05:03.007')
    expect(ts()).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}$/)
  })

  it('shortens session ids', () => {
    expect(sid('69aaaa14-89e9-7e21-871a-ee6ea943fc95')).toBe('69aaaa14')
  })

  describe('logFrame', () => {
    const lastLine = (spy: ReturnType<typeof vi.spyOn>) => String(spy.mock.calls.at(-1)?.[0] ?? '')

    it('prints direction, audience, type and the opaque ids that make a frame identifiable', () => {
      const spy = vi.spyOn(console, 'log').mockImplementation(() => {})
      logFrame('→', 'web', {
        type: 'agent_synced',
        payload: {
          agentId: '26f49435-71e8-4461-ac59-65c0e854b374',
          agent: { engine: 'claude', selectedModel: 'runtime-v1:x:claude:anthropic%2Fclaude-sonnet-5@xhigh' },
        },
      })
      const line = lastLine(spy)
      expect(line).toContain('[frame] → web agent_synced')
      expect(line).toContain('agentId=26f49435')
      expect(line).toContain('engine=claude')
      expect(line).toContain('agent.selectedModel=runtime-v1:x:claude:anthropic%2Fclaude-sonnet-5@xhigh')
    })

    it('never prints a payload body — this log is the one place frames are in the clear', () => {
      const spy = vi.spyOn(console, 'log').mockImplementation(() => {})
      logFrame('←', 'conn:74dab280', {
        type: 'message',
        payload: {
          sessionId: '9e9f7954-1111-2222-3333-444455556666',
          text: 'my private prompt about the acquisition',
          token: 'sk-or-v1-secret',
          images: ['data:image/png;base64,AAAA'],
        },
      })
      const line = lastLine(spy)
      expect(line).toContain('sessionId=9e9f7954')
      expect(line).not.toContain('private prompt')
      expect(line).not.toContain('sk-or-v1-secret')
      expect(line).not.toContain('base64')
    })

    it('summarizes a catalog by size, not by contents', () => {
      const spy = vi.spyOn(console, 'log').mockImplementation(() => {})
      logFrame('→', 'conn:1', { type: 'models_list_result', payload: { models: [{ id: 'a' }, { id: 'b' }] } })
      expect(lastLine(spy)).toContain('models=2')
      logFrame('→', 'conn:1', { type: 'models_list_result', payload: { models: [] } })
      expect(lastLine(spy)).toContain('models=0')
    })
  })

  it('flattens whitespace and caps preview with an ellipsis', () => {
    expect(preview('  hello\n\n  world  ')).toBe('hello world')
    expect(preview('abcdef', 3)).toBe('abc…')
    expect(preview('')).toBe('')
  })

  it('prepends a timestamp yet preserves the original args (waitForReady marker intact)', () => {
    const spy = vi.spyOn(console, 'log').mockImplementation(() => {})
    // Capture the wrapper by re-reading console.log AFTER install.
    installTimestampedConsole()
    console.log('[backend] connected → wss://x')
    const line = spy.mock.calls.at(-1)!.join(' ')
    expect(line).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} \[backend\] connected/)
    expect(line).toContain('[backend] connected') // substring the self-update readiness check scans
  })
})

describe('log file cap', () => {
  let dir: string
  let file: string
  let legacy: string
  const line = (i: number): string => `line-${String(i).padStart(6, '0')} ${'x'.repeat(80)}\n`

  beforeEach(() => {
    dir = mkdtempSync(join(tmpdir(), 'adapter-log-'))
    file = join(dir, 'harness.log')
    legacy = join(dir, 'machine.log')
  })
  afterEach(() => rmSync(dir, { recursive: true, force: true }))

  const fill = (bytes: number): number => {
    let out = ''
    let i = 0
    while (out.length < bytes) out += line(i++)
    writeFileSync(file, out)
    return i
  }

  it('leaves a file under the cap alone', () => {
    fill(2_000)
    const before = readFileSync(file, 'utf-8')
    expect(trimLogFile(file, 10_000)).toBe(false)
    expect(readFileSync(file, 'utf-8')).toBe(before)
  })

  it('is a no-op when there is no log yet', () => {
    expect(trimLogFile(join(dir, 'nope.log'))).toBe(false)
  })

  it('drops the OLDEST half and keeps the newest lines, at a line boundary', () => {
    const cap = 40_000
    const written = fill(cap * 2)
    expect(trimLogFile(file, cap)).toBe(true)

    const after = readFileSync(file, 'utf-8')
    expect(statSync(file).size).toBeLessThanOrEqual(cap)
    // Newest line survived, oldest is gone.
    expect(after).toContain(`line-${String(written - 1).padStart(6, '0')}`)
    expect(after).not.toContain('line-000000')
    // First line is the trim marker; the second is a WHOLE line, not a fragment.
    const lines = after.split('\n')
    expect(lines[0]).toMatch(/\[log\] trimmed — dropped the oldest \d+ MB \(cap 0 MB\)$/)
    expect(lines[1]).toMatch(/^line-\d{6} x+$/)
  })

  it('keeps an O_APPEND writer landing at the end — no sparse hole', () => {
    // The daemon holds the log as its stdout fd across a trim; this is the property that makes an
    // in-place rewrite safe (a non-append fd would resume at its old offset and leave NUL bytes).
    const cap = 40_000
    fill(cap * 2)
    const fd = openSync(file, 'a')
    try {
      expect(trimLogFile(file, cap)).toBe(true)
      writeSync(fd, 'after-the-trim\n')
    } finally {
      closeSync(fd)
    }
    const after = readFileSync(file)
    expect(after.toString('utf-8').trimEnd().endsWith('after-the-trim')).toBe(true)
    expect(after.includes(0)).toBe(false)
    expect(after.length).toBeLessThanOrEqual(cap)
  })

  it('caps at 10 MB by default', () => {
    expect(LOG_MAX_BYTES).toBe(10 * 1024 * 1024)
  })

  it('adopts a legacy log by RENAME, so an open fd keeps writing to the same file', () => {
    writeFileSync(legacy, 'old-history\n')
    const inode = statSync(legacy).ino
    const fd = openSync(legacy, 'a')   // stands in for a daemon started before the rename
    try {
      adoptLegacyLog(file, legacy)
      writeSync(fd, 'written-after-rename\n')
    } finally {
      closeSync(fd)
    }
    expect(existsSync(legacy)).toBe(false)
    expect(statSync(file).ino).toBe(inode)
    expect(readFileSync(file, 'utf-8')).toBe('old-history\nwritten-after-rename\n')
  })

  it('never clobbers an existing log, and shrugs off a missing legacy one', () => {
    writeFileSync(file, 'current\n')
    writeFileSync(legacy, 'stale\n')
    adoptLegacyLog(file, legacy)
    expect(readFileSync(file, 'utf-8')).toBe('current\n')
    expect(readFileSync(legacy, 'utf-8')).toBe('stale\n')   // left for the user to delete

    rmSync(legacy)
    expect(() => adoptLegacyLog(file, legacy)).not.toThrow()
  })

  it('prepareLogFile adopts then trims in one pass', () => {
    let out = ''
    while (out.length < 30_000) out += line(out.length)
    writeFileSync(legacy, out)
    prepareLogFile(file, legacy, 10_000)
    expect(existsSync(legacy)).toBe(false)
    expect(statSync(file).size).toBeLessThanOrEqual(10_000)
  })
})