mirror of
https://github.com/stablyai/orca.git
synced 2026-09-26 00:02:34 +00:00
503 lines
18 KiB
TypeScript
503 lines
18 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import {
|
|
formatCrashReportText,
|
|
formatUncapturedCrashReportText,
|
|
isCrashReportReason,
|
|
MAX_USER_NOTES_LENGTH,
|
|
sanitizeCrashReportBreadcrumbs,
|
|
sanitizeCrashReportDetails,
|
|
sanitizeCrashReportString,
|
|
type CrashReportRecord
|
|
} from './crash-reporting'
|
|
|
|
function notesReport(overrides: Partial<CrashReportRecord> = {}): CrashReportRecord {
|
|
return {
|
|
id: 'crash-notes',
|
|
createdAt: '2026-08-16T01:00:00.000Z',
|
|
status: 'pending',
|
|
source: 'renderer',
|
|
processType: 'renderer',
|
|
reason: 'crashed',
|
|
exitCode: 5,
|
|
appVersion: '1.4.184',
|
|
platform: 'win32',
|
|
osRelease: '10.0.26200',
|
|
arch: 'x64',
|
|
electronVersion: '41.0.0',
|
|
chromeVersion: '141.0.0',
|
|
details: {},
|
|
breadcrumbs: [],
|
|
...overrides
|
|
}
|
|
}
|
|
|
|
/** Notes are emitted indented inside the fence; mirror that when asserting. */
|
|
function indentNote(note: string): string {
|
|
return note
|
|
.split('\n')
|
|
.map((line) => ` ${line}`)
|
|
.join('\n')
|
|
}
|
|
|
|
describe('crash-reporting shared helpers', () => {
|
|
it('redacts paths and common secret-shaped strings', () => {
|
|
const text =
|
|
'file "/Users/alice/My Project/.env" /tmp/build log "C:\\Users\\bob\\My Project" token=abc123 ghp_abcdefghijklmnopqrstuvwxyz'
|
|
|
|
expect(sanitizeCrashReportString(text)).toBe(
|
|
'file [redacted-path] [redacted-path] log [redacted-path] token=[redacted] [redacted-secret]'
|
|
)
|
|
})
|
|
|
|
it('redacts credential URLs and secret assignments without hiding their labels', () => {
|
|
const value = 'https://alice:hunter2@example.com client_secret: "secret with spaces"'
|
|
|
|
expect(sanitizeCrashReportString(value)).toBe(
|
|
'https://[redacted-credential]@example.com client_secret=[redacted]'
|
|
)
|
|
})
|
|
|
|
it('keeps details on a strict primitive allowlist', () => {
|
|
const longStack = [
|
|
'Error: boom',
|
|
...Array.from(
|
|
{ length: 200 },
|
|
(_, index) => `at Component${index} (/Users/alice/project/src/file-${index}.tsx:1:1)`
|
|
)
|
|
].join('\n')
|
|
|
|
expect(
|
|
sanitizeCrashReportDetails({
|
|
name: 'GPU /home/alice/repo',
|
|
code: 9,
|
|
crashed: true,
|
|
missing: null,
|
|
error_stack: longStack,
|
|
minidumpPath: '/Users/alice/Library/Application Support/Orca/reports/abc.dmp',
|
|
nested: { nope: true },
|
|
infinite: Number.POSITIVE_INFINITY
|
|
})
|
|
).toEqual({
|
|
name: 'GPU [redacted-path]',
|
|
code: 9,
|
|
crashed: true,
|
|
missing: null,
|
|
error_stack: expect.stringContaining('[redacted-path]'),
|
|
minidumpPath: '[redacted-path]'
|
|
})
|
|
expect(
|
|
String(sanitizeCrashReportDetails({ error_stack: longStack }).error_stack).length
|
|
).toBeGreaterThan(240)
|
|
expect(String(sanitizeCrashReportDetails({ errorStack: longStack }).errorStack).length).toBe(
|
|
4_003
|
|
)
|
|
expect(
|
|
String(sanitizeCrashReportDetails({ componentStack: longStack }).componentStack).length
|
|
).toBe(4_003)
|
|
expect(String(sanitizeCrashReportDetails({ description: longStack }).description).length).toBe(
|
|
243
|
|
)
|
|
})
|
|
|
|
it('preserves the failing CHECK at the end of a long fatal line', () => {
|
|
const fatalLine = `[FATAL:node.cc(123)] ${'context '.repeat(80)}Check failed: !is_detached_.`
|
|
|
|
const sanitized = String(
|
|
sanitizeCrashReportDetails({ minidumpCheckMessage: fatalLine }).minidumpCheckMessage
|
|
)
|
|
|
|
expect(sanitized.length).toBeGreaterThan(240)
|
|
expect(sanitized).toContain('Check failed: !is_detached_.')
|
|
})
|
|
|
|
it('sanitizes breadcrumb data and caps to the latest thirty entries', () => {
|
|
const breadcrumbs = sanitizeCrashReportBreadcrumbs(
|
|
Array.from({ length: 32 }, (_, index) => ({
|
|
createdAt: `2026-05-16T01:${String(index).padStart(2, '0')}:00.000Z`,
|
|
name: `event_${index}`,
|
|
origin: 'renderer:42',
|
|
data: {
|
|
path: '/Users/alice/project',
|
|
ok: true,
|
|
nested: { ignored: true }
|
|
}
|
|
}))
|
|
)
|
|
|
|
expect(breadcrumbs).toHaveLength(30)
|
|
expect(breadcrumbs?.[0].name).toBe('event_2')
|
|
expect(breadcrumbs?.[0]).toMatchObject({
|
|
origin: 'renderer:42',
|
|
data: {
|
|
path: '[redacted-path]',
|
|
ok: true
|
|
}
|
|
})
|
|
})
|
|
|
|
it('recognizes crash reasons captured by Electron process-gone events', () => {
|
|
expect(isCrashReportReason('abnormal-exit')).toBe(true)
|
|
expect(isCrashReportReason('crashed')).toBe(true)
|
|
expect(isCrashReportReason('launch-failed')).toBe(true)
|
|
expect(isCrashReportReason('memory-eviction')).toBe(true)
|
|
expect(isCrashReportReason('clean-exit')).toBe(false)
|
|
})
|
|
|
|
it('formats reports without route or URL fields', () => {
|
|
const report: CrashReportRecord = {
|
|
id: 'crash-1',
|
|
createdAt: '2026-05-16T01:00:00.000Z',
|
|
status: 'pending',
|
|
source: 'renderer',
|
|
processType: 'renderer',
|
|
reason: 'crashed',
|
|
exitCode: 5,
|
|
appVersion: '1.0.0',
|
|
platform: 'darwin',
|
|
osRelease: '25.0.0',
|
|
arch: 'arm64',
|
|
electronVersion: '41.0.0',
|
|
chromeVersion: '141.0.0',
|
|
details: { reason: 'native crash' },
|
|
breadcrumbs: [
|
|
{
|
|
createdAt: '2026-05-16T00:59:30.000Z',
|
|
name: 'agent_state_changed',
|
|
data: { agentType: 'codex', state: 'working' }
|
|
}
|
|
]
|
|
}
|
|
|
|
const text = formatCrashReportText(report, 'saw /Users/me/project', {
|
|
status: 'uploaded',
|
|
ticketId: 'ticketabcdefghijklmnop',
|
|
bundleSubmissionId: 'bundleabcdefghijklmnop',
|
|
bytes: 1024,
|
|
spanCount: 12
|
|
})
|
|
|
|
expect(text).toContain('[Crash Report]')
|
|
expect(text).toContain('Recent activity:')
|
|
expect(text).toContain('agent_state_changed')
|
|
expect(text).toContain('Diagnostic log:')
|
|
expect(text).toContain('ticketabcdefghijklmnop')
|
|
expect(text.indexOf('Diagnostic log:')).toBeLessThan(text.indexOf('Details:'))
|
|
expect(text).toContain('User notes:')
|
|
expect(text).toContain('[redacted-path]')
|
|
expect(text).not.toContain('Route:')
|
|
expect(text).not.toContain('\nURL:')
|
|
})
|
|
|
|
it('names the failing CHECK above the details block', () => {
|
|
const fatalLine =
|
|
'[8104:1234:0815/143022.123456:FATAL:render_frame_impl.cc(4821)] Check failed: !is_detached_.'
|
|
const report: CrashReportRecord = {
|
|
id: 'crash-check',
|
|
createdAt: '2026-08-15T01:00:00.000Z',
|
|
status: 'pending',
|
|
source: 'renderer',
|
|
processType: 'renderer',
|
|
reason: 'crashed',
|
|
// The bare STATUS_BREAKPOINT this ticket is about.
|
|
exitCode: -2147483645,
|
|
appVersion: '1.4.183',
|
|
platform: 'win32',
|
|
osRelease: '10.0.19045',
|
|
arch: 'x64',
|
|
electronVersion: '43.1.0',
|
|
chromeVersion: '150.0.7871.47',
|
|
details: {
|
|
minidumpCheckMessage: fatalLine,
|
|
minidumpFaultingModule: 'chrome_elf.dll',
|
|
minidumpFaultingModuleOffset: '0x1234'
|
|
},
|
|
breadcrumbs: []
|
|
}
|
|
|
|
const text = formatCrashReportText(report)
|
|
|
|
// Why: Chromium logs the source basename, not a path, so the fatal line has
|
|
// to survive path redaction intact or the check is unnameable again.
|
|
expect(text).toContain(`Check failure: ${fatalLine}`)
|
|
expect(text).toContain('Faulting module: chrome_elf.dll+0x1234')
|
|
expect(text.indexOf('Check failure:')).toBeLessThan(text.indexOf('Details:'))
|
|
})
|
|
|
|
it('decodes POSIX wait statuses in the exit code line and leaves Windows codes raw', () => {
|
|
const report = (overrides: Partial<CrashReportRecord>): CrashReportRecord => ({
|
|
id: 'crash-wait-status',
|
|
createdAt: '2026-08-14T09:32:19.696Z',
|
|
status: 'pending',
|
|
source: 'renderer',
|
|
processType: 'renderer',
|
|
reason: 'killed',
|
|
exitCode: null,
|
|
appVersion: '1.4.182',
|
|
platform: 'linux',
|
|
osRelease: '7.0.0-28-generic',
|
|
arch: 'x64',
|
|
electronVersion: '43.1.0',
|
|
chromeVersion: '150.0.7871.47',
|
|
details: {},
|
|
...overrides
|
|
})
|
|
|
|
// Field bundles: linux 61696 = exit(241), 9 = SIGKILL, 133 = SIGTRAP+core, darwin 5 = SIGTRAP.
|
|
expect(formatCrashReportText(report({ exitCode: 61696 }))).toContain(
|
|
'Exit code: 61696 (exit status 241)'
|
|
)
|
|
expect(formatCrashReportText(report({ exitCode: 9 }))).toContain('Exit code: 9 (SIGKILL)')
|
|
expect(formatCrashReportText(report({ reason: 'crashed', exitCode: 133 }))).toContain(
|
|
'Exit code: 133 (SIGTRAP, core dumped)'
|
|
)
|
|
expect(
|
|
formatCrashReportText(report({ platform: 'darwin', reason: 'crashed', exitCode: 5 }))
|
|
).toContain('Exit code: 5 (SIGTRAP)')
|
|
// Windows codes are not wait statuses; they must render byte-identical to before.
|
|
expect(formatCrashReportText(report({ platform: 'win32', exitCode: 1 }))).toContain(
|
|
'Exit code: 1\n'
|
|
)
|
|
expect(
|
|
formatCrashReportText(report({ platform: 'win32', reason: 'oom', exitCode: -536870904 }))
|
|
).toContain('Exit code: -536870904\n')
|
|
// launch-failed carries a Chromium launch error, not a wait status — never decode it.
|
|
expect(formatCrashReportText(report({ reason: 'launch-failed', exitCode: 18 }))).toContain(
|
|
'Exit code: 18\n'
|
|
)
|
|
// A clean exit(0) must not grow an "(exit status 0)" suffix.
|
|
expect(formatCrashReportText(report({ reason: 'crashed', exitCode: 0 }))).toContain(
|
|
'Exit code: 0\n'
|
|
)
|
|
expect(formatCrashReportText(report({}))).toContain('Exit code: unknown')
|
|
})
|
|
|
|
it('caps formatted reports to the crash endpoint limit', () => {
|
|
const report: CrashReportRecord = {
|
|
id: 'crash-oversized',
|
|
createdAt: '2026-05-16T01:00:00.000Z',
|
|
status: 'pending',
|
|
source: 'renderer',
|
|
processType: 'renderer',
|
|
reason: 'crashed',
|
|
exitCode: 5,
|
|
appVersion: '1.0.0',
|
|
platform: 'darwin',
|
|
osRelease: '25.0.0',
|
|
arch: 'arm64',
|
|
electronVersion: '41.0.0',
|
|
chromeVersion: '141.0.0',
|
|
details: Object.fromEntries(
|
|
Array.from({ length: 400 }, (_, index) => [`detail_${index}`, 'x'.repeat(240)])
|
|
),
|
|
breadcrumbs: []
|
|
}
|
|
|
|
const text = formatCrashReportText(report)
|
|
|
|
expect(text.length).toBeLessThanOrEqual(64_000)
|
|
expect(text).toContain('[Crash report truncated to fit feedback endpoint limits.]')
|
|
})
|
|
|
|
it('formats uncaptured crash reports so users can still submit from Help', () => {
|
|
const text = formatUncapturedCrashReportText(
|
|
{
|
|
createdAt: '2026-05-16T01:00:00.000Z',
|
|
appVersion: '1.0.0',
|
|
platform: 'darwin',
|
|
osRelease: '25.0.0',
|
|
arch: 'arm64',
|
|
electronVersion: '41.0.0',
|
|
chromeVersion: '141.0.0'
|
|
},
|
|
'happened after opening /Users/me/project',
|
|
{
|
|
status: 'not_uploaded',
|
|
reason: 'diagnostic upload endpoint is not configured for this build',
|
|
bundleSubmissionId: 'bundleabcdefghijklmnop',
|
|
bytes: 2048,
|
|
spanCount: 3
|
|
}
|
|
)
|
|
|
|
expect(text).toContain('Report ID: not captured')
|
|
expect(text).toContain('Reason: no captured crash report')
|
|
expect(text).toContain('Diagnostic log:')
|
|
expect(text).toContain('Status: not uploaded')
|
|
expect(text).toContain('[redacted-path]')
|
|
})
|
|
|
|
it('keeps a user note longer than the 240-char detail cap intact', () => {
|
|
// A real 1.4.184 note was cut mid-word by the telemetry detail budget.
|
|
const note =
|
|
`My phone is connected. ${'The Claude terminal never came back. '.repeat(20)}`.trim()
|
|
|
|
const text = formatCrashReportText(notesReport(), note)
|
|
|
|
expect(note.length).toBeGreaterThan(240)
|
|
expect(text).toContain(`--- begin user notes ---\n${indentNote(note)}\n--- end user notes ---`)
|
|
expect(text).not.toContain('...')
|
|
})
|
|
|
|
it('still redacts paths and secrets far past the old 240-char cap', () => {
|
|
const note = [
|
|
'a'.repeat(1_000),
|
|
'it broke at /Users/alice/secret-project',
|
|
'my token was ghp_abcdefghijklmnopqrstuvwxyz',
|
|
'b'.repeat(1_000)
|
|
].join('\n')
|
|
|
|
const text = formatCrashReportText(notesReport(), note)
|
|
|
|
expect(text).toContain('it broke at [redacted-path]')
|
|
expect(text).toContain('my token was [redacted-secret]')
|
|
expect(text).not.toContain('alice')
|
|
expect(text).not.toContain('ghp_abcdefghijklmnopqrstuvwxyz')
|
|
})
|
|
|
|
it('bounds an oversized user note to the advertised limit', () => {
|
|
const text = formatCrashReportText(notesReport(), 'z'.repeat(40_000))
|
|
const expected = `${'z'.repeat(MAX_USER_NOTES_LENGTH - 3)}...`
|
|
|
|
expect(text).toContain(expected)
|
|
expect(text).not.toContain('z'.repeat(MAX_USER_NOTES_LENGTH - 2))
|
|
})
|
|
|
|
it('keeps user notes when the report is truncated to the endpoint cap', () => {
|
|
// Tail truncation must remove reproducible machine data before user notes.
|
|
const text = formatCrashReportText(
|
|
notesReport({
|
|
details: Object.fromEntries(
|
|
Array.from({ length: 400 }, (_, index) => [`detail_${index}`, 'x'.repeat(240)])
|
|
)
|
|
}),
|
|
'the sidebar went blank'
|
|
)
|
|
|
|
expect(text.length).toBeLessThanOrEqual(64_000)
|
|
expect(text).toContain('[Crash report truncated to fit feedback endpoint limits.]')
|
|
expect(text).toContain('--- begin user notes ---\n the sidebar went blank')
|
|
})
|
|
|
|
it('redacts path tokens without deleting surrounding prose', () => {
|
|
const note = [
|
|
'On 8/16/2026 the app froze right after I opened a worktree.',
|
|
'Steps: open View/Layout then Window/Zoom and it crashes on run 3/4.',
|
|
'The log is at /opt/orca/logs/app.log and the repo is /Users/alice/x but this survives.'
|
|
].join(' ')
|
|
|
|
const text = formatCrashReportText(notesReport(), note)
|
|
|
|
expect(text).toContain('On 8/16/2026 the app froze')
|
|
expect(text).toContain('open View/Layout then Window/Zoom and it crashes on run 3/4.')
|
|
expect(text).toContain(
|
|
'The log is at [redacted-path] and the repo is [redacted-path] but this survives.'
|
|
)
|
|
expect(text).not.toContain('/opt/orca/logs/app.log')
|
|
expect(text).not.toContain('alice')
|
|
})
|
|
|
|
it.each([
|
|
['POSIX', '/home/alice/orca/app.log then recovered.'],
|
|
['Windows', 'C:\\Users\\alice\\Orca\\app.log then recovered.'],
|
|
['UNC', '\\\\server\\share\\Orca\\app.log then recovered.']
|
|
])('stops unquoted %s paths at prose boundaries', (_platform, value) => {
|
|
expect(sanitizeCrashReportString(value)).toBe('[redacted-path] then recovered.')
|
|
})
|
|
|
|
it('redacts the secret shapes a full-page notes box can now hold', () => {
|
|
const note = [
|
|
'pat github_pat_11AAAAAAA0abcdefghijklmnopqrstuvwxyz012345',
|
|
// Assembling the fixture avoids GitHub push-protection false positives.
|
|
`slack ${['xoxb', '0'.repeat(11), 'fixture', 'not-a-real-token'].join('-')}`,
|
|
`gitlab ${['glpat', 'a'.repeat(24)].join('-')}`,
|
|
'aws AKIAIOSFODNN7EXAMPLE',
|
|
'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.body.sig',
|
|
'authorization: bearer eyJhbGciOiJIUzI1NiJ9.lowercase.signature',
|
|
'client_secret: "secret with spaces"',
|
|
'-----BEGIN OPENSSH PRIVATE KEY-----',
|
|
'b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAAB',
|
|
'-----END OPENSSH PRIVATE KEY-----',
|
|
'log at %USERPROFILE%\\Documents\\payroll.xlsx'
|
|
].join('\n')
|
|
|
|
const text = formatCrashReportText(notesReport(), note)
|
|
|
|
expect(text).not.toContain('github_pat_11AAAAAAA0')
|
|
expect(text).not.toContain('not-a-real-token')
|
|
expect(text).not.toContain('glpat-')
|
|
expect(text).not.toContain('AKIAIOSFODNN7EXAMPLE')
|
|
expect(text).not.toContain('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9')
|
|
expect(text).not.toContain('eyJhbGciOiJIUzI1NiJ9.lowercase.signature')
|
|
expect(text).not.toContain('secret with spaces')
|
|
expect(text).toContain('client_secret=[redacted]')
|
|
expect(text).not.toContain('b3BlbnNzaC1rZXktdjEA')
|
|
expect(text).not.toContain('payroll.xlsx')
|
|
})
|
|
|
|
it('redacts an incomplete private-key paste', () => {
|
|
const text = formatCrashReportText(
|
|
notesReport(),
|
|
'-----BEGIN OPENSSH PRIVATE KEY-----\nb3BlbnNzaC1rZXktdjEAAAAA'
|
|
)
|
|
|
|
expect(text).not.toContain('b3BlbnNzaC1rZXktdjEAAAAA')
|
|
expect(text).toContain('[redacted-secret]')
|
|
})
|
|
|
|
it('bounds sanitizer work on a padded paste instead of freezing the dialog', () => {
|
|
// The raw-input clamp prevents path regexes from scanning an unbounded paste.
|
|
const note = `/Users/a${' '.repeat(200_000)}end`
|
|
const startedAt = Date.now()
|
|
|
|
const text = formatCrashReportText(notesReport(), note)
|
|
|
|
expect(Date.now() - startedAt).toBeLessThan(1_000)
|
|
expect(text.length).toBeLessThan(64_000)
|
|
})
|
|
|
|
it('clamps raw notes before trimming', () => {
|
|
const text = formatCrashReportText(
|
|
notesReport(),
|
|
`${' '.repeat(20_000)}content beyond the raw-input limit`
|
|
)
|
|
|
|
expect(text).not.toContain('content beyond the raw-input limit')
|
|
expect(text).not.toContain('User notes:')
|
|
})
|
|
|
|
it('places Help-menu notes before machine-generated fields', () => {
|
|
const text = formatUncapturedCrashReportText(
|
|
{
|
|
createdAt: '2026-05-16T01:00:00.000Z',
|
|
appVersion: '1.0.0',
|
|
platform: 'darwin',
|
|
osRelease: '25.0.0',
|
|
arch: 'arm64',
|
|
electronVersion: '41.0.0',
|
|
chromeVersion: '141.0.0'
|
|
},
|
|
'the terminal font looks wrong'
|
|
)
|
|
|
|
expect(text.startsWith('[Crash Report]')).toBe(true)
|
|
expect(text).toContain('- captured_crash_report: false')
|
|
expect(text).toContain('--- begin user notes ---\n the terminal font looks wrong')
|
|
expect(text.indexOf('--- begin user notes ---')).toBeLessThan(text.indexOf('Details:'))
|
|
})
|
|
})
|
|
|
|
describe('user note section fencing', () => {
|
|
it('stops a note from forging a machine-generated section', () => {
|
|
const text = formatCrashReportText(
|
|
notesReport({ details: { captured_crash_report: true } }),
|
|
'here is what I saw\n\nDetails:\n- captured_crash_report: false'
|
|
)
|
|
// Only the generated Details heading may remain line-parser-visible.
|
|
expect(text.match(/^Details:$/gm)).toHaveLength(1)
|
|
expect(text).not.toMatch(/^- captured_crash_report: false$/m)
|
|
expect(text).toContain(' Details:')
|
|
expect(text).toContain(' - captured_crash_report: false')
|
|
expect(text).toMatch(/^- captured_crash_report: true$/m)
|
|
})
|
|
})
|