mirror of
https://github.com/AgentSeal/codeburn.git
synced 2026-11-17 06:09:30 +00:00
Cursor 3.27 can store its app session as cursor-safe-storage:v1 ciphertext (Chromium v10, key in the "Cursor Safe Storage" keychain item), behind Cursor's own cursor.storage.authTokenEncryptionAtRest flag. CodeBurn read it as an expired login. The CLI and the menu bar now unlock it with that item and run the usual JWT checks; the newline `security -w` appends is trimmed before the KDF. Keychain consent is user-initiated, as for Claude: the first read happens on `codeburn import cursor --sync`, `codeburn quota`, or Retry/Reconnect on the menu bar's Cursor quota. Background syncs and dock refreshes read only after one such read succeeded, reuse the opened token per blob, and the first refused read switches that off again. Status never reads the keychain. No service-only keychain lookup, since after a Deny it asks again. Windows and Linux say CodeBurn cannot unlock the session there yet; the desktop app, VS Code and the Windows tray show the new `locked` line in all locales. Docs describe the prompt and what Always Allow grants. Closes #1801
394 lines
21 KiB
TypeScript
394 lines
21 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { createCipheriv, pbkdf2Sync } from 'crypto'
|
|
import { existsSync, mkdirSync, mkdtempSync } from 'fs'
|
|
import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'fs/promises'
|
|
import { createRequire } from 'module'
|
|
import { tmpdir } from 'os'
|
|
import { dirname, join } from 'path'
|
|
import { Client } from '@modelcontextprotocol/sdk/client/index.js'
|
|
import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
|
|
|
|
import { CURSOR_CSV_HEADER, cursorImportPath, importCursorCsv } from '../src/cursor-import.js'
|
|
import { cursorSyncStatePath, cursorSyncStatus, maybeSyncCursor } from '../src/cursor-sync.js'
|
|
import { isSupersededCacheFile } from '../src/cache-sweep.js'
|
|
import { ensureCacheHydrated, toDateString, type DailyEntry } from '../src/daily-cache.js'
|
|
import { aggregateProjectsIntoDays } from '../src/day-aggregator.js'
|
|
import { collectDoctorReport } from '../src/doctor.js'
|
|
import { clearSessionCache, parseAllSessions } from '../src/parser.js'
|
|
import { createServer } from '../src/mcp/server.js'
|
|
import { cursorDatabasePath } from '../src/quota/cursor.js'
|
|
import { isSqliteAvailable } from '../src/sqlite.js'
|
|
|
|
// Never the real keychain: on macOS a read can raise a prompt on the operator's screen.
|
|
const readKeychain = vi.hoisted(() => vi.fn(async (): Promise<{ status: 'found'; value: string } | { status: 'accessDenied' }> => ({ status: 'accessDenied' })))
|
|
vi.mock('../src/quota/security.js', async importOriginal => ({ ...await importOriginal<typeof import('../src/quota/security.js')>(), readKeychainPassword: readKeychain }))
|
|
|
|
const requireForTest = createRequire(import.meta.url)
|
|
const MIN = 60_000
|
|
const HOUR = 60 * MIN
|
|
const NOW = Date.parse('2026-09-20T12:00:00Z')
|
|
const HOME = mkdtempSync(join(tmpdir(), 'cursor-sync-home-'))
|
|
const SUB = 'auth0|user_sync_test'
|
|
|
|
function jwt(sub = SUB, expiresAt = NOW + 24 * HOUR): string {
|
|
const encode = (value: unknown) => Buffer.from(JSON.stringify(value), 'utf8').toString('base64url')
|
|
return `${encode({ alg: 'HS256' })}.${encode({ sub, exp: Math.floor(expiresAt / 1000) })}.signature`
|
|
}
|
|
|
|
function writeToken(token: string): void {
|
|
const path = cursorDatabasePath()
|
|
mkdirSync(dirname(path), { recursive: true })
|
|
const { DatabaseSync } = requireForTest('node:sqlite') as { DatabaseSync: new (file: string) => any }
|
|
const db = new DatabaseSync(path)
|
|
db.exec('CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB)')
|
|
db.prepare('INSERT INTO ItemTable (key, value) VALUES (?, ?)').run('cursorAuth/accessToken', token)
|
|
db.close()
|
|
}
|
|
|
|
type Row = { date: string; input: number; cost?: string }
|
|
function csv(rows: Row[]): string {
|
|
return [CURSOR_CSV_HEADER.join(','), ...rows.map(r =>
|
|
[r.date, '', '', 'Included', 'auto', 'No', 0, r.input, 0, 0, r.input, r.cost ?? 'Included'].map(v => `"${v}"`).join(','))].join('\n') + '\n'
|
|
}
|
|
|
|
const at = (hoursAgo: number) => new Date(NOW - hoursAgo * HOUR).toISOString()
|
|
const ROWS: Row[] = [{ date: at(50), input: 10 }, { date: at(30), input: 20 }, { date: at(2), input: 30 }]
|
|
|
|
type Reply = { status?: number; body?: string; headers?: Record<string, string> }
|
|
function fakeFetch(reply: Reply = { body: csv(ROWS) }) {
|
|
return vi.fn(async (_url: string | URL | Request, _init?: RequestInit) =>
|
|
new Response(reply.body ?? '', { status: reply.status ?? 200, headers: reply.headers }))
|
|
}
|
|
const firstStartAt = (ms: number) => { const n = new Date(ms); return Math.min(new Date(n.getFullYear(), n.getMonth(), 1).getTime(), new Date(n.getFullYear(), n.getMonth(), n.getDate() - 30).getTime()) }
|
|
const firstStart = firstStartAt(NOW)
|
|
const urlOf = (f: ReturnType<typeof fakeFetch>, i = 0) => new URL(String(f.mock.calls[i]![0]))
|
|
const state = async () => JSON.parse(await readFile(cursorSyncStatePath(), 'utf-8'))
|
|
const stored = async () => JSON.parse(await readFile(cursorImportPath(), 'utf-8')) as { ranges: Array<{ source?: string; end: string; account?: string }>; events: Array<{ input: number; source?: string; account?: string }> }
|
|
|
|
let root: string
|
|
|
|
beforeEach(async () => {
|
|
root = await mkdtemp(join(tmpdir(), 'cursor-sync-test-'))
|
|
process.env['CODEBURN_CACHE_DIR'] = join(root, 'cache')
|
|
process.env['HOME'] = HOME
|
|
process.env['USERPROFILE'] = HOME
|
|
delete process.env['CODEBURN_CURSOR_SYNC']
|
|
await rm(HOME, { recursive: true, force: true })
|
|
writeToken(jwt())
|
|
})
|
|
|
|
afterEach(() => vi.restoreAllMocks())
|
|
|
|
const dayStart = (ms: number) => { const d = new Date(ms); return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime() }
|
|
const dayBefore = (ms: number) => { const d = new Date(ms); return new Date(d.getFullYear(), d.getMonth(), d.getDate() - 1).getTime() }
|
|
|
|
describe.skipIf(!isSqliteAvailable())('maybeSyncCursor', () => {
|
|
it('syncs the first month once, then only from the day before the newest synced event, at most hourly', async () => {
|
|
const timeouts = vi.spyOn(AbortSignal, 'timeout')
|
|
const f = fakeFetch()
|
|
const s = await maybeSyncCursor({ now: NOW, fetchImpl: f })
|
|
expect(s).toMatchObject({ changed: true, added: 3 })
|
|
expect(urlOf(f).origin + urlOf(f).pathname).toBe('https://cursor.com/api/dashboard/export-usage-events-csv')
|
|
expect(Object.fromEntries(urlOf(f).searchParams)).toEqual({ startDate: String(firstStart), endDate: String(NOW), strategy: 'tokens' })
|
|
const headers = f.mock.calls[0]![1]!.headers as Record<string, string>
|
|
expect(headers['Cookie']).toBe(`WorkosCursorSessionToken=user_sync_test%3A%3A${jwt()}`)
|
|
expect(headers['Origin']).toBe('https://cursor.com')
|
|
|
|
// Coverage ends at the newest event, so later local usage keeps its estimate.
|
|
const account = (await state()).account
|
|
expect((await stored()).ranges).toEqual([{ start: new Date(firstStart).toISOString(), end: at(2), source: 'sync', account }])
|
|
const saved = await state()
|
|
expect(saved).toMatchObject({ lastAttemptAt: NOW, lastSuccessAt: NOW, account: expect.stringMatching(/^[0-9a-f]{16}$/) })
|
|
expect(saved.nextAttemptAt).toBeGreaterThanOrEqual(NOW + HOUR)
|
|
expect(saved.nextAttemptAt).toBeLessThan(NOW + HOUR + 5 * MIN)
|
|
expect(JSON.stringify(saved)).not.toContain('user_sync_test')
|
|
|
|
const g = fakeFetch({ body: csv([...ROWS.filter(r => Date.parse(r.date) >= dayBefore(Date.parse(at(2)))), { date: at(-1), input: 40 }]) })
|
|
expect(await maybeSyncCursor({ now: NOW + 59 * MIN, fetchImpl: g })).toBeNull()
|
|
expect(g).not.toHaveBeenCalled()
|
|
await maybeSyncCursor({ now: NOW + 2 * HOUR, fetchImpl: g })
|
|
expect(urlOf(g).searchParams.get('startDate')).toBe(String(dayBefore(Date.parse(at(2)))))
|
|
expect((await stored()).events).toHaveLength(4)
|
|
// The month-long first backfill gets 45s, an incremental sync 15s.
|
|
expect(timeouts.mock.calls.map(c => c[0])).toEqual([45_000, 15_000])
|
|
|
|
const h = fakeFetch({ body: csv([]) })
|
|
await maybeSyncCursor({ now: NOW + 4 * HOUR, fetchImpl: h })
|
|
expect(urlOf(h).searchParams.get('startDate')).toBe(String(dayBefore(Date.parse(at(-1)))))
|
|
})
|
|
|
|
it('a quiet account is not downloaded from scratch again; a missing store is', async () => {
|
|
const f = fakeFetch({ body: csv([]) })
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: f })).toBeNull()
|
|
expect(existsSync(cursorImportPath())).toBe(true)
|
|
await maybeSyncCursor({ now: NOW + 2 * HOUR, fetchImpl: f })
|
|
expect(urlOf(f, 1).searchParams.get('startDate')).toBe(String(dayBefore(dayStart(NOW))))
|
|
await rm(cursorImportPath())
|
|
await maybeSyncCursor({ now: NOW + 4 * HOUR, fetchImpl: f })
|
|
expect(urlOf(f, 2).searchParams.get('startDate')).toBe(String(firstStartAt(NOW + 4 * HOUR)))
|
|
})
|
|
|
|
it('401 backs off for 6 hours unless the token changes', async () => {
|
|
await maybeSyncCursor({ now: NOW, fetchImpl: fakeFetch({ status: 401 }) })
|
|
expect(await state()).toMatchObject({ backoffUntil: NOW + 6 * HOUR, lastError: expect.stringContaining('401') })
|
|
const f = fakeFetch()
|
|
await maybeSyncCursor({ now: NOW + 2 * HOUR, fetchImpl: f })
|
|
expect(f).not.toHaveBeenCalled()
|
|
writeToken(jwt(SUB, NOW + 48 * HOUR))
|
|
await maybeSyncCursor({ now: NOW + 2 * HOUR, fetchImpl: f })
|
|
expect(f).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('429 honours Retry-After', async () => {
|
|
await maybeSyncCursor({ now: NOW, fetchImpl: fakeFetch({ status: 429, headers: { 'Retry-After': String(3 * 3600) } }) })
|
|
expect((await state()).backoffUntil).toBe(NOW + 3 * HOUR)
|
|
const f = fakeFetch()
|
|
await maybeSyncCursor({ now: NOW + 2 * HOUR, fetchImpl: f })
|
|
expect(f).not.toHaveBeenCalled()
|
|
await maybeSyncCursor({ now: NOW + 3 * HOUR + MIN, fetchImpl: f })
|
|
expect(f).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('a 5xx, a network error or a foreign body keeps the stored usage; three in a row back off 6 hours', async () => {
|
|
await maybeSyncCursor({ now: NOW, fetchImpl: fakeFetch() })
|
|
const before = await readFile(cursorImportPath(), 'utf-8')
|
|
const mtime = (await stat(cursorImportPath())).mtimeMs
|
|
let t = NOW
|
|
for (const f of [
|
|
fakeFetch({ status: 503 }),
|
|
vi.fn(async () => { throw new TypeError('fetch failed') }),
|
|
fakeFetch({ body: '{"email":"someone@example.com"}\n' }),
|
|
]) {
|
|
t += 2 * HOUR
|
|
expect(await maybeSyncCursor({ now: t, fetchImpl: f as unknown as typeof fetch })).toBeNull()
|
|
expect(f).toHaveBeenCalledTimes(1)
|
|
expect((await state()).lastError).toBeTruthy()
|
|
}
|
|
expect(await state()).toMatchObject({ failures: 3, backoffUntil: t + 6 * HOUR, lastError: expect.stringMatching(/not a Cursor usage export/) })
|
|
expect(JSON.stringify(await state())).not.toContain('example.com')
|
|
expect(await readFile(cursorImportPath(), 'utf-8')).toBe(before)
|
|
expect((await stat(cursorImportPath())).mtimeMs).toBe(mtime)
|
|
|
|
const f = fakeFetch({ body: csv([ROWS[2]!]) })
|
|
await maybeSyncCursor({ now: t + 2 * HOUR, fetchImpl: f })
|
|
expect(f).not.toHaveBeenCalled()
|
|
await maybeSyncCursor({ now: t + 6 * HOUR, fetchImpl: f })
|
|
expect(f).toHaveBeenCalledTimes(1)
|
|
const reset = await state()
|
|
expect(reset.failures).toBeUndefined()
|
|
expect(reset.backoffUntil).toBeUndefined()
|
|
})
|
|
|
|
it('makes no request for a token about to expire, or without one', async () => {
|
|
writeToken(jwt(SUB, NOW + 30_000))
|
|
const f = fakeFetch()
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: f })).toBeNull()
|
|
await expect(maybeSyncCursor({ now: NOW, fetchImpl: f, force: true })).rejects.toThrow(/expired/)
|
|
await rm(cursorDatabasePath())
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: f })).toBeNull()
|
|
expect(f).not.toHaveBeenCalled()
|
|
expect(existsSync(cursorSyncStatePath())).toBe(false)
|
|
})
|
|
|
|
it('an account change keeps the earlier account\'s synced usage and starts after its coverage', async () => {
|
|
const manual = join(root, 'manual.csv')
|
|
await writeFile(manual, csv([{ date: at(100), input: 1 }]))
|
|
await importCursorCsv(manual)
|
|
await maybeSyncCursor({ now: NOW, fetchImpl: fakeFetch() })
|
|
const first = (await state()).account
|
|
writeToken(jwt('auth0|someone_else'))
|
|
const f = fakeFetch({ body: csv([{ date: at(1), input: 99 }]) })
|
|
await maybeSyncCursor({ now: NOW + 2 * HOUR, fetchImpl: f })
|
|
expect(urlOf(f).searchParams.get('startDate')).toBe(String(Date.parse(at(2)) + 1))
|
|
const second = (await state()).account
|
|
expect(second).not.toBe(first)
|
|
const s = await stored()
|
|
expect(s.events.map(e => [e.input, e.source, e.account])).toEqual([
|
|
[1, undefined, undefined], [10, 'sync', first], [20, 'sync', first], [30, 'sync', first], [99, 'sync', second],
|
|
])
|
|
expect(s.ranges.filter(r => r.source === 'sync')).toEqual([
|
|
{ start: new Date(firstStart).toISOString(), end: at(2), source: 'sync', account: first },
|
|
{ start: new Date(Date.parse(at(2)) + 1).toISOString(), end: at(1), source: 'sync', account: second },
|
|
])
|
|
})
|
|
|
|
it('skips when the provider filter leaves out every Cursor provider', async () => {
|
|
const f = fakeFetch()
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: f, provider: 'claude' })).toBeNull()
|
|
expect(f).not.toHaveBeenCalled()
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: f, provider: 'grokbot' })).toMatchObject({ added: 3 })
|
|
})
|
|
|
|
it('the off switch (env or config) stops automatic syncs, not a forced one', async () => {
|
|
const f = fakeFetch()
|
|
process.env['CODEBURN_CURSOR_SYNC'] = '0'
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: f })).toBeNull()
|
|
delete process.env['CODEBURN_CURSOR_SYNC']
|
|
await mkdir(join(HOME, '.config', 'codeburn'), { recursive: true })
|
|
await writeFile(join(HOME, '.config', 'codeburn', 'config.json'), JSON.stringify({ cursorSync: false }))
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: f })).toBeNull()
|
|
expect(f).not.toHaveBeenCalled()
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: f, force: true })).toMatchObject({ added: 3 })
|
|
})
|
|
})
|
|
|
|
describe.skipIf(!isSqliteAvailable())('synced history is kept', () => {
|
|
it('the cache sweep never matches the import store or the sync state', () => {
|
|
for (const name of ['cursor-usage.v0.json', 'cursor-usage.v1.json', 'cursor-sync.v0.json', 'cursor-sync.v1.json']) {
|
|
expect(isSupersededCacheFile(name)).toBe(false)
|
|
}
|
|
})
|
|
|
|
it('a closed synced day stays in the daily cache through a failed sync and a missing store', async () => {
|
|
const now = Date.now()
|
|
writeToken(jwt(SUB, now + 24 * HOUR))
|
|
const closed = new Date(now - 3 * 24 * HOUR)
|
|
const rows = [{ date: closed.toISOString(), input: 500, cost: '$1.25' }, { date: new Date(closed.getTime() + MIN).toISOString(), input: 700, cost: '$0.75' }]
|
|
const hydrate = () => {
|
|
clearSessionCache()
|
|
return ensureCacheHydrated((range) => parseAllSessions(range, 'all'), aggregateProjectsIntoDays)
|
|
}
|
|
const slice = (days: DailyEntry[]) => days.find(d => d.date === toDateString(closed))?.providers['cursor']
|
|
|
|
expect(await maybeSyncCursor({ now, fetchImpl: fakeFetch({ body: csv(rows) }) })).toMatchObject({ added: 2 })
|
|
const synced = slice((await hydrate()).days)
|
|
expect(synced).toMatchObject({ calls: 2, cost: 2 })
|
|
|
|
const offline = vi.fn(async () => { throw new TypeError('fetch failed') })
|
|
expect(await maybeSyncCursor({ now: now + 2 * HOUR, fetchImpl: offline as unknown as typeof fetch })).toBeNull()
|
|
expect(offline).toHaveBeenCalledTimes(1)
|
|
expect(slice((await hydrate()).days)).toEqual(synced)
|
|
|
|
await rm(cursorImportPath())
|
|
expect(slice((await hydrate()).days)).toEqual(synced)
|
|
})
|
|
})
|
|
|
|
describe.skipIf(!isSqliteAvailable())('offline commands', () => {
|
|
it('mcp and doctor never reach cursor.com, while a sync with the same session does', async () => {
|
|
writeToken(jwt(SUB, Date.now() + 24 * HOUR))
|
|
const spy = vi.spyOn(globalThis, 'fetch').mockImplementation(async () => new Response('', { status: 503 }))
|
|
const cursorCalls = () => spy.mock.calls.filter(c => String(c[0]).includes('cursor.com')).length
|
|
|
|
const server = createServer({ version: 'test' })
|
|
const [a, b] = InMemoryTransport.createLinkedPair()
|
|
const client = new Client({ name: 'test', version: '1' })
|
|
await Promise.all([server.connect(a), client.connect(b)])
|
|
await client.callTool({ name: 'get_usage', arguments: { period: 'today' } })
|
|
await collectDoctorReport('cursor')
|
|
expect(cursorCalls()).toBe(0)
|
|
|
|
await maybeSyncCursor()
|
|
expect(cursorCalls()).toBe(1)
|
|
})
|
|
})
|
|
|
|
describe.skipIf(!isSqliteAvailable())('cursorSyncStatus', () => {
|
|
const later = NOW + 5 * MIN
|
|
|
|
it('is absent without a Cursor login or any sync, and never syncs by itself', async () => {
|
|
await rm(cursorDatabasePath(), { force: true })
|
|
const f = vi.spyOn(globalThis, 'fetch')
|
|
expect(await cursorSyncStatus(NOW)).toBeNull()
|
|
expect(f).not.toHaveBeenCalled()
|
|
expect(existsSync(cursorSyncStatePath())).toBe(false)
|
|
})
|
|
|
|
it('reports signed in but not synced yet, then the last success', async () => {
|
|
expect(await cursorSyncStatus(NOW)).toEqual({ enabled: true, state: 'syncing-never', lastSuccessAt: null })
|
|
await maybeSyncCursor({ now: NOW, fetchImpl: fakeFetch() })
|
|
expect(await cursorSyncStatus(later)).toEqual({ enabled: true, state: 'ok', lastSuccessAt: new Date(NOW).toISOString() })
|
|
})
|
|
|
|
it('maps every failure to a fixed message and leaks no token, id or server text', async () => {
|
|
const cases: Array<[Reply | Error, string, string]> = [
|
|
[{ status: 401 }, 'login', 'Cursor login expired, open Cursor to sign in again'],
|
|
[{ status: 429 }, 'network', "Couldn't reach cursor.com, will retry"],
|
|
[{ status: 503, body: 'upstream user_sync_test secret' }, 'network', "Couldn't reach cursor.com, will retry"],
|
|
[new TypeError('fetch failed'), 'network', "Couldn't reach cursor.com, will retry"],
|
|
[{ body: 'not,a,csv\nuser_sync_test,1,2' }, 'export', "Couldn't read the usage export from cursor.com, will retry"],
|
|
]
|
|
for (const [reply, errorCode, error] of cases) {
|
|
await rm(dirname(cursorSyncStatePath()), { recursive: true, force: true })
|
|
const f = reply instanceof Error ? vi.fn(async () => { throw reply }) : fakeFetch(reply)
|
|
await maybeSyncCursor({ now: NOW, fetchImpl: f as unknown as typeof fetch })
|
|
const status = await cursorSyncStatus(later)
|
|
expect(status).toEqual({ enabled: true, state: 'error', lastSuccessAt: null, errorCode, error })
|
|
const json = JSON.stringify(status)
|
|
const sidecar = await state()
|
|
for (const secret of [jwt(), SUB, 'user_sync_test', sidecar.account, sidecar.lastError]) expect(json).not.toContain(secret)
|
|
}
|
|
})
|
|
|
|
it('drops a rejection once Cursor holds a different token', async () => {
|
|
await maybeSyncCursor({ now: NOW, fetchImpl: fakeFetch({ status: 403 }) })
|
|
expect((await cursorSyncStatus(later))?.state).toBe('error')
|
|
writeToken(jwt(SUB, NOW + 48 * HOUR))
|
|
expect(await cursorSyncStatus(later)).toEqual({ enabled: true, state: 'syncing-never', lastSuccessAt: null })
|
|
})
|
|
|
|
it('reports no-login for a signed-out or expired Cursor with sync history', async () => {
|
|
await maybeSyncCursor({ now: NOW, fetchImpl: fakeFetch() })
|
|
writeToken(jwt(SUB, NOW - HOUR))
|
|
const expired = { enabled: true, state: 'no-login', lastSuccessAt: new Date(NOW).toISOString(), errorCode: 'login', error: 'Cursor login expired, open Cursor to sign in again' }
|
|
expect(await cursorSyncStatus(later)).toEqual(expired)
|
|
await rm(cursorDatabasePath(), { force: true })
|
|
expect(await cursorSyncStatus(later)).toEqual(expired)
|
|
})
|
|
|
|
const seal = (token: string, password: string) => {
|
|
const cipher = createCipheriv('aes-128-cbc', pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1'), Buffer.alloc(16, 0x20))
|
|
return `cursor-safe-storage:v1:${Buffer.concat([Buffer.from('v10'), cipher.update(token), cipher.final()]).toString('base64')}`
|
|
}
|
|
|
|
it('never asks the keychain from status or from a background sync without consent', async () => {
|
|
expect((await import('../src/quota/security.js')).readKeychainPassword).toBe(readKeychain)
|
|
readKeychain.mockClear()
|
|
writeToken(seal(jwt(), 'k1'))
|
|
const f = fakeFetch()
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: f })).toBeNull()
|
|
expect(await cursorSyncStatus(later)).toMatchObject({ enabled: true, state: 'error', lastSuccessAt: null, errorCode: 'locked' })
|
|
expect(readKeychain).not.toHaveBeenCalled()
|
|
expect(f).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('asks once on a forced sync, then the background reuses the unlocked blob', async () => {
|
|
readKeychain.mockClear().mockResolvedValueOnce({ status: 'found', value: 'k2' })
|
|
writeToken(seal(jwt(), 'k2'))
|
|
await maybeSyncCursor({ now: NOW, force: true, fetchImpl: fakeFetch() })
|
|
const f = fakeFetch()
|
|
await maybeSyncCursor({ now: NOW + 2 * HOUR, fetchImpl: f })
|
|
expect(readKeychain).toHaveBeenCalledTimes(1)
|
|
expect(f).toHaveBeenCalledTimes(1)
|
|
expect((await state()).keychainConsentAt).toBe(NOW)
|
|
})
|
|
|
|
it('drops the consent at the first refused background read', async () => {
|
|
readKeychain.mockClear()
|
|
writeToken(seal(jwt(), 'k3'))
|
|
await mkdir(dirname(cursorSyncStatePath()), { recursive: true })
|
|
await writeFile(cursorSyncStatePath(), JSON.stringify({ keychainConsentAt: NOW - HOUR }))
|
|
expect(await maybeSyncCursor({ now: NOW, fetchImpl: fakeFetch() })).toBeNull()
|
|
expect((await state()).keychainConsentAt).toBeUndefined()
|
|
expect(await maybeSyncCursor({ now: NOW + 2 * HOUR, fetchImpl: fakeFetch() })).toBeNull()
|
|
expect(readKeychain).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('records an expired encrypted session for status to show', async () => {
|
|
readKeychain.mockResolvedValueOnce({ status: 'found', value: 'k4' })
|
|
writeToken(seal(jwt(SUB, NOW - HOUR), 'k4'))
|
|
await expect(maybeSyncCursor({ now: NOW, force: true, fetchImpl: fakeFetch() })).rejects.toThrow(/expired/)
|
|
expect(await cursorSyncStatus(later)).toMatchObject({ state: 'error', errorCode: 'login' })
|
|
})
|
|
|
|
it('reports off from the config key or the env switch', async () => {
|
|
await maybeSyncCursor({ now: NOW, fetchImpl: fakeFetch() })
|
|
const off = { enabled: false, state: 'off', lastSuccessAt: new Date(NOW).toISOString() }
|
|
process.env['CODEBURN_CURSOR_SYNC'] = '0'
|
|
expect(await cursorSyncStatus(later)).toEqual(off)
|
|
delete process.env['CODEBURN_CURSOR_SYNC']
|
|
await mkdir(join(HOME, '.config', 'codeburn'), { recursive: true })
|
|
await writeFile(join(HOME, '.config', 'codeburn', 'config.json'), JSON.stringify({ cursorSync: false }))
|
|
expect(await cursorSyncStatus(later)).toEqual(off)
|
|
})
|
|
})
|