bingocode 1.0.27 → 1.0.28

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

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

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

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

package/stubs/ant-claude-for-chrome-mcp.ts

@@ -1,24 +0,0 @@
-export type PermissionMode =
-  | 'ask'
-  | 'skip_all_permission_checks'
-  | 'follow_a_plan';
-
-export type Logger = {
-  silly?: (...args: unknown[]) => void;
-  debug?: (...args: unknown[]) => void;
-  info?: (...args: unknown[]) => void;
-  warn?: (...args: unknown[]) => void;
-  error?: (...args: unknown[]) => void;
-};
-
-export type ClaudeForChromeContext = Record<string, unknown>;
-
-export const BROWSER_TOOLS: Array<{ name: string }> = [];
-
-export function createClaudeForChromeMcpServer(
-  _context: ClaudeForChromeContext,
-) {
-  return {
-    async connect(_transport: unknown): Promise<void> {},
-  };
-}

package/stubs/color-diff-napi.ts

@@ -1,45 +0,0 @@
-export type SyntaxTheme = {
-  theme: string;
-  source: string | null;
-};
-
-export class ColorDiff {
-  private hunk: { oldStart: number; oldLines: number; newStart: number; newLines: number; lines: string[] };
-  private filePath: string;
-  private firstLine: string | null;
-  private prefixContent: string | null;
-
-  constructor(
-    hunk: { oldStart: number; oldLines: number; newStart: number; newLines: number; lines: string[] },
-    firstLine: string | null,
-    filePath: string,
-    prefixContent?: string | null,
-  ) {
-    this.hunk = hunk;
-    this.filePath = filePath;
-    this.firstLine = firstLine;
-    this.prefixContent = prefixContent ?? null;
-  }
-
-  render(themeName: string, width: number, dim: boolean): string[] | null {
-    return null;
-  }
-}
-
-export class ColorFile {
-  private code: string;
-  private filePath: string;
-
-  constructor(code: string, filePath: string) {
-    this.code = code;
-    this.filePath = filePath;
-  }
-
-  render(themeName: string, width: number, dim: boolean): string[] | null {
-    return null;
-  }
-}
-
-export function getSyntaxTheme(themeName: string): SyntaxTheme {
-  return { theme: themeName, source: null };
-}

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowJs": true,
-    "jsx": "react-jsx",
-    "baseUrl": ".",
-    "paths": {
-      "@ant/claude-for-chrome-mcp": [
-        "./stubs/ant-claude-for-chrome-mcp.ts"
-      ],
-      "color-diff-napi": [
-        "./stubs/color-diff-napi.ts"
-      ],
-      "src/*": [
-        "./src/*"
-      ]
-    },
-    "types": [
-      "bun-types"
-    ]
-  }
-}