@andypai/agent-kanban 0.3.3 → 0.3.5

package/src/__tests__/postgres-local-provider.test.ts

@@ -0,0 +1,129 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import postgres from 'postgres'
+
+import { run } from '../index'
+import type { Task, TaskComment, TaskWithColumn } from '../types'
+
+const databaseUrl = process.env['KANBAN_PG_TEST_URL'] ?? process.env['DATABASE_URL']
+const pgTest = databaseUrl ? test : test.skip
+
+function expectOk<T>(result: Awaited<ReturnType<typeof run>>): T {
+  expect(result.exitCode).toBe(0)
+  expect(result.output.ok).toBe(true)
+  if (!result.output.ok) throw new Error('expected successful CLI output')
+  return result.output.data as T
+}
+
+describe('postgres local provider', () => {
+  let previousStorage: string | undefined
+  let previousDatabaseUrl: string | undefined
+  let previousProvider: string | undefined
+  let previousDbPath: string | undefined
+  let previousDefaultColumns: string | undefined
+  let sql: postgres.Sql | null = null
+
+  beforeEach(async () => {
+    previousStorage = process.env['KANBAN_STORAGE']
+    previousDatabaseUrl = process.env['KANBAN_DATABASE_URL']
+    previousProvider = process.env['KANBAN_PROVIDER']
+    previousDbPath = process.env['KANBAN_DB_PATH']
+    previousDefaultColumns = process.env['KANBAN_DEFAULT_COLUMNS']
+
+    process.env['KANBAN_STORAGE'] = 'postgres'
+    process.env['KANBAN_DATABASE_URL'] = databaseUrl
+    process.env['KANBAN_PROVIDER'] = 'local'
+    delete process.env['KANBAN_DB_PATH']
+
+    if (databaseUrl) {
+      sql = postgres(databaseUrl, { max: 1, onnotice: () => {} })
+      await sql`DROP TABLE IF EXISTS comments`
+      await sql`DROP TABLE IF EXISTS column_time_tracking`
+      await sql`DROP TABLE IF EXISTS activity_log`
+      await sql`DROP TABLE IF EXISTS tasks`
+      await sql`DROP TABLE IF EXISTS columns`
+    }
+  })
+
+  afterEach(async () => {
+    if (sql) {
+      await sql.end({ timeout: 1 })
+      sql = null
+    }
+
+    if (previousStorage === undefined) delete process.env['KANBAN_STORAGE']
+    else process.env['KANBAN_STORAGE'] = previousStorage
+    if (previousDatabaseUrl === undefined) delete process.env['KANBAN_DATABASE_URL']
+    else process.env['KANBAN_DATABASE_URL'] = previousDatabaseUrl
+    if (previousProvider === undefined) delete process.env['KANBAN_PROVIDER']
+    else process.env['KANBAN_PROVIDER'] = previousProvider
+    if (previousDbPath === undefined) delete process.env['KANBAN_DB_PATH']
+    else process.env['KANBAN_DB_PATH'] = previousDbPath
+    if (previousDefaultColumns === undefined) delete process.env['KANBAN_DEFAULT_COLUMNS']
+    else process.env['KANBAN_DEFAULT_COLUMNS'] = previousDefaultColumns
+  })
+
+  pgTest('runs task and comment commands through Postgres storage', async () => {
+    const created = expectOk<TaskWithColumn>(
+      await run([
+        'task',
+        'add',
+        'Postgres-backed task',
+        '-d',
+        'Stored in Postgres',
+        '-c',
+        'recurring',
+        '-p',
+        'high',
+        '-a',
+        'garage',
+        '--project',
+        'Dispatch',
+        '-m',
+        '{"storage":"postgres"}',
+      ]),
+    )
+
+    expect(created.title).toBe('Postgres-backed task')
+    expect(created.column_name).toBe('recurring')
+    expect(created.version).toBe('0')
+
+    const listed = expectOk<Task[]>(await run(['task', 'list', '-c', 'recurring']))
+    expect(listed.map((task) => task.id)).toContain(created.id)
+
+    const updated = expectOk<Task>(
+      await run(['task', 'update', created.id, '--title', 'Updated from Postgres', '-p', 'urgent']),
+    )
+    expect(updated.title).toBe('Updated from Postgres')
+    expect(updated.priority).toBe('urgent')
+    expect(updated.version).toBe('1')
+
+    const comment = expectOk<TaskComment>(
+      await run(['comment', 'add', created.id, 'Projection comment stored in Postgres']),
+    )
+    expect(comment.task_id).toBe(created.id)
+
+    const comments = expectOk<TaskComment[]>(await run(['comment', 'list', created.id]))
+    expect(comments).toHaveLength(1)
+    expect(comments[0]!.body).toBe('Projection comment stored in Postgres')
+  })
+
+  pgTest('seeds custom default columns for Garage local compose', async () => {
+    process.env['KANBAN_DEFAULT_COLUMNS'] = 'Todo,In Progress,Human Review,Merging,Done'
+
+    const created = expectOk<TaskWithColumn>(
+      await run(['task', 'add', 'Garage column task', '-c', 'Todo']),
+    )
+
+    expect(created.column_name).toBe('Todo')
+  })
+
+  pgTest('defaults new tasks to the first configured column when backlog is absent', async () => {
+    process.env['KANBAN_DEFAULT_COLUMNS'] = 'Todo,In Progress,Human Review,Merging,Done'
+
+    const created = expectOk<TaskWithColumn>(
+      await run(['task', 'add', 'Garage default column task']),
+    )
+
+    expect(created.column_name).toBe('Todo')
+  })
+})

package/src/__tests__/storage-config.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from 'bun:test'
+
+import { resolveKanbanStorageConfig } from '../storage-config'
+
+describe('resolveKanbanStorageConfig', () => {
+  test('defaults to sqlite using the resolved board path', () => {
+    const config = resolveKanbanStorageConfig(
+      { HOME: '/tmp/kanban-home' },
+      { defaultSqlitePath: '/tmp/board.db' },
+    )
+
+    expect(config).toEqual({ mode: 'sqlite', sqlitePath: '/tmp/board.db' })
+  })
+
+  test('accepts uppercase postgres mode and requires a database URL', () => {
+    expect(() =>
+      resolveKanbanStorageConfig({ KANBAN_STORAGE: 'POSTGRES' }, { defaultSqlitePath: 'ignored' }),
+    ).toThrow('KANBAN_DATABASE_URL is required when KANBAN_STORAGE=postgres')
+
+    expect(
+      resolveKanbanStorageConfig(
+        {
+          KANBAN_STORAGE: 'POSTGRES',
+          KANBAN_DATABASE_URL: 'postgres://garage:garage@localhost:5432/garage',
+        },
+        { defaultSqlitePath: 'ignored' },
+      ),
+    ).toEqual({
+      mode: 'postgres',
+      databaseUrl: 'postgres://garage:garage@localhost:5432/garage',
+    })
+  })
+
+  test('rejects unknown storage modes', () => {
+    expect(() =>
+      resolveKanbanStorageConfig({ KANBAN_STORAGE: 'mysql' }, { defaultSqlitePath: 'ignored' }),
+    ).toThrow("Unsupported KANBAN_STORAGE 'mysql'")
+  })
+})

package/src/__tests__/sync-config.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from 'bun:test'
+import { ErrorCode, KanbanError } from '../errors'
+import {
+  DEFAULT_POLLING_SYNC_INTERVAL_MS,
+  MIN_POLLING_SYNC_INTERVAL_MS,
+  resolvePollingSyncIntervalMs,
+} from '../sync-config'
+
+describe('sync config', () => {
+  test('defaults when unset or blank', () => {
+    expect(resolvePollingSyncIntervalMs(undefined)).toBe(DEFAULT_POLLING_SYNC_INTERVAL_MS)
+    expect(resolvePollingSyncIntervalMs('   ')).toBe(DEFAULT_POLLING_SYNC_INTERVAL_MS)
+  })
+
+  test('accepts an integer millisecond interval', () => {
+    expect(resolvePollingSyncIntervalMs('5000')).toBe(5_000)
+  })
+
+  test('rejects invalid or too-aggressive intervals', () => {
+    for (const raw of ['999', '5s', '1000.5', '0']) {
+      let err: unknown
+      try {
+        resolvePollingSyncIntervalMs(raw)
+      } catch (caught) {
+        err = caught
+      }
+      expect(err).toBeInstanceOf(KanbanError)
+      expect((err as KanbanError).code).toBe(ErrorCode.INVALID_CONFIG)
+      expect((err as Error).message).toContain(String(MIN_POLLING_SYNC_INTERVAL_MS))
+    }
+  })
+})

package/src/errors.ts

@@ -9,6 +9,7 @@ export const ErrorCode = {
   INVALID_PRIORITY: 'INVALID_PRIORITY',
   INVALID_METADATA: 'INVALID_METADATA',
   INVALID_POSITION: 'INVALID_POSITION',
+  INVALID_CONFIG: 'INVALID_CONFIG',
   CONFLICT: 'CONFLICT',
   MISSING_ARGUMENT: 'MISSING_ARGUMENT',
   UNKNOWN_COMMAND: 'UNKNOWN_COMMAND',

package/src/index.ts

@@ -4,14 +4,17 @@ import { parseArgs } from 'node:util'
 import { Database } from 'bun:sqlite'
 import { KanbanError, ErrorCode } from './errors'
 import { formatOutput, error, success } from './output'
-import { openDb, getDbPath, initSchema, migrateSchema, seedDefaultColumns } from './db'
+import { getDbPath, initSchema, seedDefaultColumns } from './db'
 import { boardInit, boardReset } from './commands/board'
 import { columnAdd, columnDelete, columnList, columnRename, columnReorder } from './commands/column'
 import { bulkClearDoneCmd, bulkMoveAllCmd } from './commands/bulk'
 import { getConfigPath, loadConfig, saveConfig } from './config'
 import type { CliOutput, Priority } from './types'
-import { createProvider } from './providers/index'
 import { unsupportedOperation } from './providers/errors'
+import { openKanbanRuntime } from './provider-runtime'
+import { trackerConfigFromEnv } from './tracker-config'
+import type { KanbanProvider } from './providers/types'
+import { resolvePollingSyncIntervalMs } from './sync-config'
 
 interface ParsedArgs {
   values: Record<string, unknown>
@@ -48,7 +51,7 @@ function requireLocalProvider(providerType: string, feature: string): void {
 }
 
 async function routeTask(
-  provider: ReturnType<typeof createProvider>,
+  provider: KanbanProvider,
   action: string | undefined,
   positionals: string[],
   values: Record<string, unknown>,
@@ -140,7 +143,7 @@ async function routeTask(
 }
 
 async function routeComment(
-  provider: ReturnType<typeof createProvider>,
+  provider: KanbanProvider,
   action: string | undefined,
   positionals: string[],
 ): Promise<CliOutput> {
@@ -224,7 +227,7 @@ function routeBulk(
 }
 
 async function routeConfig(
-  provider: ReturnType<typeof createProvider>,
+  provider: KanbanProvider,
   dbPath: string,
   action: string | undefined,
   positionals: string[],
@@ -288,7 +291,7 @@ async function routeConfig(
 
 async function routeBoard(
   db: Database,
-  provider: ReturnType<typeof createProvider>,
+  provider: KanbanProvider,
   action: string | undefined,
 ): Promise<CliOutput> {
   switch (action) {
@@ -316,23 +319,29 @@ async function run(argv: string[]): Promise<{ output: CliOutput; exitCode: numbe
     return { output: { ok: true, data: { message: HELP_TEXT } }, exitCode: 0 }
   }
 
-  const dbPath = (values.db as string | undefined) ?? getDbPath()
-  const db = openDb(dbPath)
-  migrateSchema(db)
+  const runtime = await openKanbanRuntime({
+    dbPath: (values.db as string | undefined) ?? getDbPath(),
+  })
 
   try {
-    const provider = createProvider(db, dbPath)
+    const { provider, sqliteDb, dbPath } = runtime
     const group = positionals[0]
     const action = positionals[1]
 
     if (!group) {
-      return { output: await routeBoard(db, provider, undefined), exitCode: 0 }
+      if (sqliteDb) return { output: await routeBoard(sqliteDb, provider, undefined), exitCode: 0 }
+      return { output: success(await provider.getBoard()), exitCode: 0 }
     }
 
     let output: CliOutput
     switch (group) {
       case 'board':
-        output = await routeBoard(db, provider, action)
+        if (sqliteDb) {
+          output = await routeBoard(sqliteDb, provider, action)
+        } else {
+          if (action === 'view' || action === undefined) output = success(await provider.getBoard())
+          else unsupportedOperation(`board ${action} is not available with KANBAN_STORAGE=postgres`)
+        }
         break
       case 'task':
         output = await routeTask(provider, action, positionals, values)
@@ -341,13 +350,24 @@ async function run(argv: string[]): Promise<{ output: CliOutput; exitCode: numbe
         output = await routeComment(provider, action, positionals)
         break
       case 'column':
-        output = routeColumn(db, provider.type, action, positionals, values)
+        if (!sqliteDb)
+          unsupportedOperation('Column commands are not available with KANBAN_STORAGE=postgres')
+        output = routeColumn(sqliteDb, provider.type, action, positionals, values)
         break
       case 'bulk':
-        output = routeBulk(db, provider.type, action, positionals)
+        if (!sqliteDb)
+          unsupportedOperation('Bulk commands are not available with KANBAN_STORAGE=postgres')
+        output = routeBulk(sqliteDb, provider.type, action, positionals)
         break
       case 'config':
-        output = await routeConfig(provider, dbPath, action, positionals, values)
+        if (sqliteDb) {
+          output = await routeConfig(provider, dbPath, action, positionals, values)
+        } else {
+          if (action === 'show' || action === undefined)
+            output = success(await provider.getConfig())
+          else
+            unsupportedOperation(`config ${action} is not available with KANBAN_STORAGE=postgres`)
+        }
         break
       default:
         throw new KanbanError(ErrorCode.UNKNOWN_COMMAND, `Unknown command group '${group}'`)
@@ -355,7 +375,7 @@ async function run(argv: string[]): Promise<{ output: CliOutput; exitCode: numbe
 
     return { output, exitCode: 0 }
   } finally {
-    db.close()
+    await runtime.close()
   }
 }
 
@@ -397,18 +417,19 @@ Commands:
   config add-project <name>   Add project
   config remove-project <name> Remove project
 
-  serve                       Start web dashboard [--port 3000]
+  serve                       Start web dashboard [--port 3000] [--sync-interval-ms ms]
   mcp                         Run as an MCP server over stdio (for Claude Desktop, etc.)
 
 Options:
   --pretty      Human-readable output (default: JSON)
-  --db <path>   Database path (default: local ./.kanban if present, else ~/.kanban if present, else create ./.kanban)
+  --db <path>   SQLite database path (default: local ./.kanban if present, else ~/.kanban if present, else create ./.kanban)
   --project <n> Filter/set project
   -h, --help    Show this help`
 
 export interface ServeOptions {
   db?: string
   port: number
+  syncIntervalMs?: number
   tunnel: boolean
 }
 
@@ -418,6 +439,7 @@ export function parseServeArgs(argv: string[]): ServeOptions {
     options: {
       db: { type: 'string' },
       port: { type: 'string' },
+      'sync-interval-ms': { type: 'string' },
       tunnel: { type: 'boolean', default: false },
     },
     strict: false,
@@ -429,10 +451,17 @@ export function parseServeArgs(argv: string[]): ServeOptions {
   return {
     db: values.db as string | undefined,
     port,
+    ...(values['sync-interval-ms']
+      ? { syncIntervalMs: parseSyncIntervalMs(values['sync-interval-ms'] as string) }
+      : {}),
     tunnel: Boolean(values.tunnel),
   }
 }
 
+function parseSyncIntervalMs(raw: string): number {
+  return resolvePollingSyncIntervalMs(raw, { label: '--sync-interval-ms' })
+}
+
 export interface McpOptions {
   db?: string
 }
@@ -452,21 +481,29 @@ if (import.meta.main) {
 
   if (argv[0] === 'mcp') {
     const opts = parseMcpArgs(argv)
-    const dbPath = opts.db ?? getDbPath()
-    const db = openDb(dbPath)
-    migrateSchema(db)
-    const provider = createProvider(db, dbPath)
+    const runtime = await openKanbanRuntime({ dbPath: opts.db ?? getDbPath() })
     const { startStdioMcpServer } = await import('./commands/mcp')
-    await startStdioMcpServer(provider)
+    try {
+      await startStdioMcpServer(runtime.provider)
+    } finally {
+      await runtime.close()
+    }
   } else if (argv[0] === 'serve') {
     const opts = parseServeArgs(argv)
 
-    const dbPath = opts.db ?? getDbPath()
-    const db = openDb(dbPath)
-    migrateSchema(db)
-    const provider = createProvider(db, dbPath)
+    const runtime = await openKanbanRuntime({
+      dbPath: opts.db ?? getDbPath(),
+      ...(opts.syncIntervalMs !== undefined
+        ? {
+            tracker: {
+              ...trackerConfigFromEnv(process.env),
+              syncIntervalMs: opts.syncIntervalMs,
+            },
+          }
+        : {}),
+    })
     const { startServer } = await import('./server')
-    startServer(provider, opts.port)
+    startServer(runtime.provider, opts.port, { syncIntervalMs: runtime.syncIntervalMs })
 
     if (opts.tunnel) {
       const { startCloudflareTunnel } = await import('./tunnel')

package/src/mcp/errors.ts

@@ -39,6 +39,7 @@ function providerError(code: ErrorCodeValue): TrackerMcpErrorCode {
     case ErrorCode.INVALID_METADATA:
     case ErrorCode.INVALID_POSITION:
     case ErrorCode.INVALID_PRIORITY:
+    case ErrorCode.INVALID_CONFIG:
     case ErrorCode.MISSING_ARGUMENT:
     case ErrorCode.UNSUPPORTED_OPERATION:
     case ErrorCode.CONFLICT:

package/src/provider-runtime.ts

@@ -0,0 +1,110 @@
+import { Database } from 'bun:sqlite'
+import postgres from 'postgres'
+
+import { getDbPath, migrateSchema, openDb } from './db'
+import { unsupportedOperation } from './providers/errors'
+import { createProvider } from './providers/index'
+import { PostgresJiraProvider } from './providers/postgres-jira'
+import { PostgresLinearProvider } from './providers/postgres-linear'
+import { PostgresLocalProvider } from './providers/postgres-local'
+import type { KanbanProvider } from './providers/types'
+import { resolveKanbanStorageConfig } from './storage-config'
+import type { KanbanStorageConfig } from './storage-config'
+import { trackerConfigFromEnv, type TrackerConfig } from './tracker-config'
+
+export interface KanbanRuntime {
+  provider: KanbanProvider
+  dbPath: string
+  trackerConfig: TrackerConfig
+  sqliteDb?: Database
+  syncIntervalMs?: number
+  close(): Promise<void>
+}
+
+export async function openKanbanRuntime(
+  opts: { dbPath?: string; storage?: KanbanStorageConfig; tracker?: TrackerConfig } = {},
+): Promise<KanbanRuntime> {
+  const dbPath = opts.dbPath ?? getDbPath()
+  const storage =
+    opts.storage ?? resolveKanbanStorageConfig(process.env, { defaultSqlitePath: dbPath })
+  const trackerConfig = opts.tracker ?? trackerConfigFromEnv(process.env)
+
+  if (storage.mode === 'postgres') {
+    const sql = postgres(storage.databaseUrl, { max: 5, onnotice: () => {} })
+    if (trackerConfig.provider === 'local') {
+      const provider = new PostgresLocalProvider(sql, trackerConfig)
+      await provider.initialize()
+      return {
+        provider,
+        dbPath,
+        trackerConfig,
+        syncIntervalMs: trackerConfig.syncIntervalMs,
+        async close() {
+          await sql.end({ timeout: 1 })
+        },
+      }
+    }
+    if (trackerConfig.provider === 'jira') {
+      const provider = new PostgresJiraProvider(sql, {
+        baseUrl: trackerConfig.baseUrl,
+        email: trackerConfig.email,
+        apiToken: trackerConfig.apiToken,
+        projectKey: trackerConfig.projectKey,
+        ...(trackerConfig.boardId !== undefined ? { boardId: trackerConfig.boardId } : {}),
+        defaultIssueType: trackerConfig.defaultIssueType ?? 'Task',
+        pollingSyncIntervalMs: trackerConfig.syncIntervalMs,
+      })
+      await provider.initialize()
+      return {
+        provider,
+        dbPath,
+        trackerConfig,
+        syncIntervalMs: trackerConfig.syncIntervalMs,
+        async close() {
+          await sql.end({ timeout: 1 })
+        },
+      }
+    }
+    if (trackerConfig.provider === 'linear') {
+      const provider = new PostgresLinearProvider(
+        sql,
+        trackerConfig.teamId,
+        trackerConfig.apiKey,
+        trackerConfig.syncIntervalMs,
+      )
+      await provider.initialize()
+      return {
+        provider,
+        dbPath,
+        trackerConfig,
+        syncIntervalMs: trackerConfig.syncIntervalMs,
+        async close() {
+          await sql.end({ timeout: 1 })
+        },
+      }
+    }
+    try {
+      const _exhaustive: never = trackerConfig
+      unsupportedOperation(
+        `KANBAN_STORAGE=postgres currently supports KANBAN_PROVIDER=local, linear, or jira in agent-kanban.`,
+      )
+      void _exhaustive
+    } catch (err) {
+      await sql.end({ timeout: 1 })
+      throw err
+    }
+  }
+
+  const db = openDb(storage.sqlitePath)
+  migrateSchema(db)
+  return {
+    provider: createProvider(db, trackerConfig, storage.sqlitePath),
+    dbPath: storage.sqlitePath,
+    trackerConfig,
+    sqliteDb: db,
+    syncIntervalMs: trackerConfig.syncIntervalMs,
+    async close() {
+      db.close()
+    },
+  }
+}

package/src/providers/index.ts

@@ -1,50 +1,29 @@
 import type { Database } from 'bun:sqlite'
 import { getDbPath, initSchema, seedDefaultColumns } from '../db'
-import { providerNotConfigured } from './errors'
 import { JiraProvider } from './jira'
 import { LinearProvider } from './linear'
 import { LocalProvider } from './local'
+import type { TrackerConfig } from '../tracker-config'
 import type { KanbanProvider } from './types'
 
-export function createProvider(db: Database, dbPath = getDbPath()): KanbanProvider {
-  const providerType = (process.env['KANBAN_PROVIDER'] ?? 'local') as 'local' | 'linear' | 'jira'
-
-  if (providerType === 'linear') {
-    const apiKey = process.env['LINEAR_API_KEY']
-    const teamId = process.env['LINEAR_TEAM_ID']
-    if (!apiKey || !teamId) {
-      providerNotConfigured(
-        'LINEAR_API_KEY and LINEAR_TEAM_ID are required when KANBAN_PROVIDER=linear',
-      )
-    }
-    return new LinearProvider(db, teamId!, apiKey!)
+export function createProvider(
+  db: Database,
+  config: TrackerConfig,
+  dbPath = getDbPath(),
+): KanbanProvider {
+  if (config.provider === 'linear') {
+    return new LinearProvider(db, config.teamId, config.apiKey, config.syncIntervalMs)
   }
 
-  if (providerType === 'jira') {
-    const baseUrl = process.env['JIRA_BASE_URL']
-    const email = process.env['JIRA_EMAIL']
-    const apiToken = process.env['JIRA_API_TOKEN']
-    const projectKey = process.env['JIRA_PROJECT_KEY']
-    const missing: string[] = []
-    if (!baseUrl) missing.push('JIRA_BASE_URL')
-    if (!email) missing.push('JIRA_EMAIL')
-    if (!apiToken) missing.push('JIRA_API_TOKEN')
-    if (!projectKey) missing.push('JIRA_PROJECT_KEY')
-    if (missing.length > 0) {
-      providerNotConfigured(
-        `${missing.join(', ')} ${missing.length === 1 ? 'is' : 'are'} required when KANBAN_PROVIDER=jira`,
-      )
-    }
-    const boardIdRaw = process.env['JIRA_BOARD_ID']
-    const boardId = boardIdRaw ? Number.parseInt(boardIdRaw, 10) : undefined
-    const defaultIssueType = process.env['JIRA_ISSUE_TYPE'] ?? 'Task'
+  if (config.provider === 'jira') {
     return new JiraProvider(db, {
-      baseUrl: baseUrl!,
-      email: email!,
-      apiToken: apiToken!,
-      projectKey: projectKey!,
-      boardId: Number.isFinite(boardId) ? boardId : undefined,
-      defaultIssueType,
+      baseUrl: config.baseUrl,
+      email: config.email,
+      apiToken: config.apiToken,
+      projectKey: config.projectKey,
+      ...(config.boardId !== undefined ? { boardId: config.boardId } : {}),
+      defaultIssueType: config.defaultIssueType ?? 'Task',
+      pollingSyncIntervalMs: config.syncIntervalMs,
     })
   }
 

package/src/providers/jira.ts

@@ -49,8 +49,8 @@ import type {
   TaskListFilters,
   UpdateTaskInput,
 } from './types'
+import { DEFAULT_POLLING_SYNC_INTERVAL_MS } from '../sync-config'
 
-const SYNC_INTERVAL_MS = 30_000
 const FULL_RECONCILE_INTERVAL_MS = 5 * 60_000
 
 function shouldRunFullReconcile(lastFullSyncAt: string | null, now: number): boolean {
@@ -78,11 +78,13 @@ export interface JiraProviderConfig {
   projectKey: string
   boardId?: number
   defaultIssueType?: string
+  pollingSyncIntervalMs?: number
 }
 
 export class JiraProvider implements KanbanProvider {
   readonly type = 'jira' as const
   private readonly client: JiraClient
+  private readonly pollingSyncIntervalMs: number
 
   constructor(
     private readonly db: Database,
@@ -90,6 +92,7 @@ export class JiraProvider implements KanbanProvider {
     client?: JiraClient,
   ) {
     initJiraCacheSchema(db)
+    this.pollingSyncIntervalMs = config.pollingSyncIntervalMs ?? DEFAULT_POLLING_SYNC_INTERVAL_MS
     this.client =
       client ??
       new JiraClient({
@@ -103,7 +106,7 @@ export class JiraProvider implements KanbanProvider {
     const meta = loadJiraSyncMeta(this.db)
     const lastSyncAtMs = meta.lastSyncAt ? Date.parse(meta.lastSyncAt) : 0
     const now = Date.now()
-    if (!force && lastSyncAtMs && now - lastSyncAtMs < SYNC_INTERVAL_MS) return
+    if (!force && lastSyncAtMs && now - lastSyncAtMs < this.pollingSyncIntervalMs) return
     const fullReconcile = force || shouldRunFullReconcile(meta.lastFullSyncAt, now)
 
     // 1. Resolve project.

package/src/providers/linear.ts

@@ -41,8 +41,8 @@ import type {
   TaskListFilters,
   UpdateTaskInput,
 } from './types'
+import { DEFAULT_POLLING_SYNC_INTERVAL_MS } from '../sync-config'
 
-const SYNC_INTERVAL_MS = 30_000
 const FULL_RECONCILIATION_INTERVAL_MS = 5 * 60_000
 
 function parseTimestamp(value: string | null | undefined): number {
@@ -81,6 +81,7 @@ export class LinearProvider implements KanbanProvider {
     private readonly db: Database,
     private readonly teamId: string,
     apiKey: string,
+    private readonly pollingSyncIntervalMs = DEFAULT_POLLING_SYNC_INTERVAL_MS,
   ) {
     initLinearCacheSchema(db)
     this.client = new LinearClient(apiKey)
@@ -105,7 +106,7 @@ export class LinearProvider implements KanbanProvider {
     const lastSyncAtMs = parseTimestamp(meta.lastSyncAt)
     const lastFullSyncAtMs = parseTimestamp(meta.lastFullSyncAt)
     const now = Date.now()
-    if (!force && lastSyncAtMs && now - lastSyncAtMs < SYNC_INTERVAL_MS) return
+    if (!force && lastSyncAtMs && now - lastSyncAtMs < this.pollingSyncIntervalMs) return
 
     const shouldFullSync =
       force ||