@andypai/agent-kanban 0.3.4 → 0.3.6

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/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,52 +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'
-import { resolvePollingSyncIntervalMs } from '../sync-config'
 
-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!, resolvePollingSyncIntervalMs())
+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,
-      pollingSyncIntervalMs: resolvePollingSyncIntervalMs(),
+      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

@@ -11,7 +11,12 @@ import type {
   TaskComment,
   Task,
 } from '../types'
-import { headerLower, verifyHmacSha256, type WebhookRequest, type WebhookResult } from '../webhooks'
+import {
+  headerLower,
+  verifySha256HmacSignatureHeader,
+  type WebhookRequest,
+  type WebhookResult,
+} from '../webhooks'
 import { adfToPlainText, plainTextToAdf, type AdfDocument } from './jira-adf'
 import { JIRA_CAPABILITIES } from './capabilities'
 import { providerUpstreamError, unsupportedOperation } from './errors'
@@ -49,7 +54,7 @@ import type {
   TaskListFilters,
   UpdateTaskInput,
 } from './types'
-import { resolvePollingSyncIntervalMs } from '../sync-config'
+import { DEFAULT_POLLING_SYNC_INTERVAL_MS } from '../sync-config'
 
 const FULL_RECONCILE_INTERVAL_MS = 5 * 60_000
 
@@ -92,7 +97,7 @@ export class JiraProvider implements KanbanProvider {
     client?: JiraClient,
   ) {
     initJiraCacheSchema(db)
-    this.pollingSyncIntervalMs = config.pollingSyncIntervalMs ?? resolvePollingSyncIntervalMs()
+    this.pollingSyncIntervalMs = config.pollingSyncIntervalMs ?? DEFAULT_POLLING_SYNC_INTERVAL_MS
     this.client =
       client ??
       new JiraClient({
@@ -712,8 +717,8 @@ export class JiraProvider implements KanbanProvider {
   async handleWebhook(payload: WebhookRequest): Promise<WebhookResult> {
     const secret = process.env['JIRA_WEBHOOK_SECRET']
     if (secret) {
-      const sig = headerLower(payload.headers, 'x-hub-signature-256')
-      if (!verifyHmacSha256(secret, payload.rawBody, sig)) {
+      const sig = headerLower(payload.headers, 'x-hub-signature')
+      if (!verifySha256HmacSignatureHeader(secret, payload.rawBody, sig)) {
         return { handled: false, unauthorized: true, message: 'Invalid signature' }
       }
     }

package/src/providers/linear.ts

@@ -41,7 +41,7 @@ import type {
   TaskListFilters,
   UpdateTaskInput,
 } from './types'
-import { resolvePollingSyncIntervalMs } from '../sync-config'
+import { DEFAULT_POLLING_SYNC_INTERVAL_MS } from '../sync-config'
 
 const FULL_RECONCILIATION_INTERVAL_MS = 5 * 60_000
 
@@ -81,7 +81,7 @@ export class LinearProvider implements KanbanProvider {
     private readonly db: Database,
     private readonly teamId: string,
     apiKey: string,
-    private readonly pollingSyncIntervalMs = resolvePollingSyncIntervalMs(),
+    private readonly pollingSyncIntervalMs = DEFAULT_POLLING_SYNC_INTERVAL_MS,
   ) {
     initLinearCacheSchema(db)
     this.client = new LinearClient(apiKey)