bingocode 1.0.29 → 1.0.30

package/src/utils/__tests__/cronFrequency.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  frequencyToCron,
+  cronToFrequency,
+  FREQUENCY_OPTIONS,
+} from '../cronFrequency.js'
+
+describe('frequencyToCron', () => {
+  test('manual returns empty string', () => {
+    expect(frequencyToCron('manual')).toBe('')
+    expect(frequencyToCron('manual', '09:00')).toBe('')
+  })
+
+  test('hourly returns minute-only cron', () => {
+    expect(frequencyToCron('hourly')).toBe('0 * * * *')
+    expect(frequencyToCron('hourly', '15')).toBe('') // malformed: must be HH:MM
+    expect(frequencyToCron('hourly', '0 * * * *')).toBe('') // malformed time
+    expect(frequencyToCron('hourly', ':15')).toBe('') // malformed
+    expect(frequencyToCron('hourly', '00:15')).toBe('15 * * * *')
+  })
+
+  test('daily returns correct cron', () => {
+    expect(frequencyToCron('daily', '09:00')).toBe('0 9 * * *')
+    expect(frequencyToCron('daily', '14:30')).toBe('30 14 * * *')
+  })
+
+  test('weekdays returns cron with 1-5 dow', () => {
+    expect(frequencyToCron('weekdays', '09:00')).toBe('0 9 * * 1-5')
+    expect(frequencyToCron('weekdays', '08:30')).toBe('30 8 * * 1-5')
+  })
+
+  test('weekly returns cron with dow=1', () => {
+    expect(frequencyToCron('weekly', '09:00')).toBe('0 9 * * 1')
+    expect(frequencyToCron('weekly', '17:00')).toBe('0 17 * * 1')
+  })
+
+  test('rejects invalid time formats', () => {
+    expect(frequencyToCron('daily', '')).toBe('')
+    expect(frequencyToCron('daily', '25:00')).toBe('')
+    expect(frequencyToCron('daily', '09:60')).toBe('')
+    expect(frequencyToCron('daily', 'abc')).toBe('')
+    expect(frequencyToCron('daily', '9')).toBe('')
+    expect(frequencyToCron('daily', ':30')).toBe('')
+  })
+
+  test('defaults to 09:00 for missing time', () => {
+    expect(frequencyToCron('daily')).toBe('0 9 * * *')
+    expect(frequencyToCron('weekdays')).toBe('0 9 * * 1-5')
+    expect(frequencyToCron('weekly')).toBe('0 9 * * 1')
+  })
+})
+
+describe('cronToFrequency', () => {
+  test('empty cron returns manual', () => {
+    expect(cronToFrequency('')).toEqual({ frequency: 'manual' })
+    expect(cronToFrequency('   ')).toEqual({ frequency: 'manual' })
+  })
+
+  test('invalid cron returns manual', () => {
+    expect(cronToFrequency('not a cron')).toEqual({ frequency: 'manual' })
+    expect(cronToFrequency('*')).toEqual({ frequency: 'manual' })
+    expect(cronToFrequency('* *')).toEqual({ frequency: 'manual' })
+  })
+
+  test('hourly pattern detected', () => {
+    expect(cronToFrequency('7 * * * *')).toEqual({ frequency: 'hourly' })
+    expect(cronToFrequency('0 * * * *')).toEqual({ frequency: 'hourly' })
+    expect(cronToFrequency('30 * * * *')).toEqual({ frequency: 'hourly' })
+  })
+
+  test('daily pattern detected', () => {
+    expect(cronToFrequency('0 9 * * *')).toEqual({ frequency: 'daily', time: '09:00' })
+    expect(cronToFrequency('30 14 * * *')).toEqual({ frequency: 'daily', time: '14:30' })
+  })
+
+  test('weekdays pattern detected', () => {
+    expect(cronToFrequency('0 9 * * 1-5')).toEqual({ frequency: 'weekdays', time: '09:00' })
+    expect(cronToFrequency('30 8 * * 1-5')).toEqual({ frequency: 'weekdays', time: '08:30' })
+  })
+
+  test('weekly pattern detected', () => {
+    expect(cronToFrequency('0 9 * * 1')).toEqual({ frequency: 'weekly', time: '09:00' })
+    expect(cronToFrequency('0 17 * * 1')).toEqual({ frequency: 'weekly', time: '17:00' })
+  })
+
+  test('complex crons return manual', () => {
+    expect(cronToFrequency('0 9 1-15 * *')).toEqual({ frequency: 'manual' })
+    expect(cronToFrequency('0 9 * * 0,6')).toEqual({ frequency: 'manual' })
+    expect(cronToFrequency('0 9 * 1,2 *')).toEqual({ frequency: 'manual' })
+    expect(cronToFrequency('0 */2 * * *')).toEqual({ frequency: 'manual' })
+  })
+
+  test('hourly when minute is step but hour is wildcard', () => {
+    // */5 in minute + * in hour matches the first branch: hour === '*' && all wildcards
+    expect(cronToFrequency('*/5 * * * *')).toEqual({ frequency: 'hourly' })
+  })
+
+  test('out-of-range values return manual', () => {
+    expect(cronToFrequency('60 25 * * *')).toEqual({ frequency: 'manual' })
+    expect(cronToFrequency('99 99 * * *')).toEqual({ frequency: 'manual' })
+  })
+
+  test('pads hour and minute correctly', () => {
+    expect(cronToFrequency('5 9 * * *')).toEqual({ frequency: 'daily', time: '09:05' })
+    expect(cronToFrequency('30 0 * * *')).toEqual({ frequency: 'daily', time: '00:30' })
+  })
+})
+
+describe('FREQUENCY_OPTIONS', () => {
+  test('contains all expected frequencies', () => {
+    const values = FREQUENCY_OPTIONS.map(o => o.value)
+    expect(values).toContain('manual')
+    expect(values).toContain('hourly')
+    expect(values).toContain('daily')
+    expect(values).toContain('weekdays')
+    expect(values).toContain('weekly')
+  })
+
+  test('all have labels', () => {
+    for (const opt of FREQUENCY_OPTIONS) {
+      expect(typeof opt.label).toBe('string')
+      expect(opt.label.length).toBeGreaterThan(0)
+    }
+  })
+})
+
+describe('round-trip: frequency → cron → frequency', () => {
+  test('daily round-trip preserves data', () => {
+    const cron = frequencyToCron('daily', '09:00')
+    const result = cronToFrequency(cron)
+    expect(result).toEqual({ frequency: 'daily', time: '09:00' })
+  })
+
+  test('weekdays round-trip preserves data', () => {
+    const cron = frequencyToCron('weekdays', '08:30')
+    const result = cronToFrequency(cron)
+    expect(result).toEqual({ frequency: 'weekdays', time: '08:30' })
+  })
+
+  test('weekly round-trip preserves data', () => {
+    const cron = frequencyToCron('weekly', '17:00')
+    const result = cronToFrequency(cron)
+    expect(result).toEqual({ frequency: 'weekly', time: '17:00' })
+  })
+
+  test('hourly round-trip preserves minute', () => {
+    // frequencyToCron('hourly', '00:15') produces "15 * * * *"
+    // cronToFrequency('15 * * * *') returns 'hourly' (minute is numeric, hour is '*')
+    const cron = frequencyToCron('hourly', '00:15')
+    const result = cronToFrequency(cron)
+    expect(result).toEqual({ frequency: 'hourly' })
+  })
+})

package/src/utils/__tests__/cronTasks.test.ts

@@ -0,0 +1,204 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test'
+import { mkdir, writeFile, rm } from 'fs/promises'
+import { join } from 'path'
+import { randomUUID } from 'crypto'
+
+// We'll test the updateCronTask by directly exercising the exported functions
+// through a temporary directory approach.
+// Note: These are integration tests that use actual filesystem operations.
+
+describe('updateCronTask integration', () => {
+  const tmpDir = join('/tmp', `cron-test-${randomUUID().slice(0, 8)}`)
+
+  beforeEach(async () => {
+    // Create temp project structure
+    await mkdir(join(tmpDir, '.claude'), { recursive: true })
+  })
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+
+  test('CRON_FILE_REL constant is correct', async () => {
+    // Import and verify the file relative path
+    const { getCronFilePath } = await import('../cronTasks.js')
+    const filePath = getCronFilePath(tmpDir)
+    expect(filePath).toContain('.claude')
+    expect(filePath).toContain('scheduled_tasks.json')
+  })
+
+  test('getCronFilePath returns correct path', async () => {
+    const { getCronFilePath } = await import('../cronTasks.js')
+    const filePath = getCronFilePath(tmpDir)
+    expect(filePath).toBe(join(tmpDir, '.claude', 'scheduled_tasks.json'))
+  })
+
+  test('getCronFilePath uses project root when no dir provided', async () => {
+    const { getCronFilePath } = await import('../cronTasks.js')
+    // Without dir, should use getProjectRoot() which is process.cwd()
+    // Just verify it returns a valid-looking path
+    const filePath = getCronFilePath()
+    expect(filePath).toContain('scheduled_tasks.json')
+  })
+})
+
+describe('CronTaskMeta type coverage', () => {
+  test('all UI fields are optional on CronTask', async () => {
+    // Verify all new fields exist on the type by creating tasks with them
+    const { addCronTask } = await import('../cronTasks.js')
+
+    // Create a task with all metadata fields (durable=true writes to disk in test dir)
+    const tmpDir = join('/tmp', `cron-meta-test-${randomUUID().slice(0, 8)}`)
+    await mkdir(join(tmpDir, '.claude'), { recursive: true })
+
+    const id = await addCronTask(
+      '0 9 * * *',
+      'test prompt',
+      true, // recurring
+      true, // durable (writes to disk)
+      undefined, // agentId
+      {
+        name: 'test-name',
+        description: 'test description',
+        folder: '/test/folder',
+        model: 'claude-opus-4-7',
+        permissionMode: 'ask',
+        worktree: false,
+        frequency: 'daily',
+        scheduledTime: '09:00',
+      },
+    )
+
+    expect(typeof id).toBe('string')
+    expect(id.length).toBe(8) // Short ID
+
+    // Clean up
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+})
+
+describe('readCronTasks backward compatibility', () => {
+  test('handles empty file', async () => {
+    const { readCronTasks } = await import('../cronTasks.js')
+    const tmpDir = join('/tmp', `cron-empty-${randomUUID().slice(0, 8)}`)
+    await mkdir(join(tmpDir, '.claude'), { recursive: true })
+
+    const tasks = await readCronTasks(tmpDir)
+    expect(Array.isArray(tasks)).toBe(true)
+    expect(tasks.length).toBe(0)
+
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+
+  test('skips malformed JSON', async () => {
+    const { readCronTasks } = await import('../cronTasks.js')
+    const tmpDir = join('/tmp', `cron-malformed-${randomUUID().slice(0, 8)}`)
+    await mkdir(join(tmpDir, '.claude'), { recursive: true })
+
+    // Write malformed JSON
+    const filePath = join(tmpDir, '.claude', 'scheduled_tasks.json')
+    await writeFile(filePath, 'not valid json{{{')
+
+    const tasks = await readCronTasks(tmpDir)
+    expect(tasks.length).toBe(0) // Malformed entries skipped
+
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+
+  test('skips tasks with invalid cron strings', async () => {
+    const { readCronTasks } = await import('../cronTasks.js')
+    const tmpDir = join('/tmp', `cron-invalid-${randomUUID().slice(0, 8)}`)
+    await mkdir(join(tmpDir, '.claude'), { recursive: true })
+
+    // Write task with invalid cron
+    const filePath = join(tmpDir, '.claude', 'scheduled_tasks.json')
+    await writeFile(
+      filePath,
+      JSON.stringify({
+        tasks: [
+          {
+            id: 'abcd1234',
+            cron: 'invalid-cron',
+            prompt: 'test',
+            createdAt: Date.now(),
+          },
+        ],
+      }),
+    )
+
+    const tasks = await readCronTasks(tmpDir)
+    expect(tasks.length).toBe(0) // Invalid cron skipped
+
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+
+  test('preserves new fields when reading', async () => {
+    const { readCronTasks } = await import('../cronTasks.js')
+    const tmpDir = join('/tmp', `cron-preserve-${randomUUID().slice(0, 8)}`)
+    await mkdir(join(tmpDir, '.claude'), { recursive: true })
+
+    const filePath = join(tmpDir, '.claude', 'scheduled_tasks.json')
+    const task = {
+      id: 'abcd1234',
+      cron: '0 9 * * *',
+      prompt: 'test prompt',
+      createdAt: Date.now(),
+      recurring: true,
+      name: 'my-task',
+      description: 'A test task',
+      folder: '/project',
+      model: 'claude-sonnet-4-6',
+      permissionMode: 'bypass',
+      worktree: true,
+      frequency: 'daily',
+      scheduledTime: '09:00',
+    }
+    await writeFile(filePath, JSON.stringify({ tasks: [task] }))
+
+    const tasks = await readCronTasks(tmpDir)
+    expect(tasks.length).toBe(1)
+    expect(tasks[0].name).toBe('my-task')
+    expect(tasks[0].description).toBe('A test task')
+    expect(tasks[0].folder).toBe('/project')
+    expect(tasks[0].model).toBe('claude-sonnet-4-6')
+    expect(tasks[0].permissionMode).toBe('bypass')
+    expect(tasks[0].worktree).toBe(true)
+    expect(tasks[0].frequency).toBe('daily')
+    expect(tasks[0].scheduledTime).toBe('09:00')
+
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+})
+
+describe('writeCronTasks strips runtime fields', () => {
+  test('strips durable and agentId on write', async () => {
+    const { readCronTasks, writeCronTasks } = await import('../cronTasks.js')
+    const tmpDir = join('/tmp', `cron-strip-${randomUUID().slice(0, 8)}`)
+    await mkdir(join(tmpDir, '.claude'), { recursive: true })
+
+    const taskWithRuntimeFields = {
+      id: 'abcd1234',
+      cron: '0 9 * * *',
+      prompt: 'test',
+      createdAt: Date.now(),
+      recurring: true,
+      durable: true, // runtime-only, should be stripped
+      agentId: 'agent-123', // runtime-only, should be stripped
+      name: 'test-task', // new field, should be preserved
+    }
+
+    await writeCronTasks([taskWithRuntimeFields as any], tmpDir)
+
+    // Read back and verify runtime fields are stripped
+    const filePath = join(tmpDir, '.claude', 'scheduled_tasks.json')
+    const { readFileSync } = await import('fs')
+    const raw = readFileSync(filePath, 'utf-8')
+    const parsed = JSON.parse(raw)
+
+    expect(parsed.tasks[0].durable).toBeUndefined()
+    expect(parsed.tasks[0].agentId).toBeUndefined()
+    expect(parsed.tasks[0].name).toBe('test-task')
+
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+})

package/src/utils/computerUse/permissions.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'bun:test'
+import { normalizeOsPermissions } from './permissions.js'
+
+describe('normalizeOsPermissions', () => {
+  it('treats explicit grants as granted', () => {
+    expect(
+      normalizeOsPermissions({ accessibility: true, screenRecording: true }),
+    ).toEqual({
+      granted: true,
+      accessibility: true,
+      screenRecording: true,
+    })
+  })
+
+  it('treats screen recording unknown as non-blocking when accessibility is granted', () => {
+    expect(
+      normalizeOsPermissions({ accessibility: true, screenRecording: null }),
+    ).toEqual({
+      granted: true,
+      accessibility: true,
+      screenRecording: true,
+    })
+  })
+
+  it('still blocks when accessibility is missing', () => {
+    expect(
+      normalizeOsPermissions({ accessibility: false, screenRecording: null }),
+    ).toEqual({
+      granted: false,
+      accessibility: false,
+      screenRecording: true,
+    })
+  })
+
+  it('blocks when screen recording is explicitly denied', () => {
+    expect(
+      normalizeOsPermissions({ accessibility: true, screenRecording: false }),
+    ).toEqual({
+      granted: false,
+      accessibility: true,
+      screenRecording: false,
+    })
+  })
+})