@goodandready/dsh-kanban 0.2.34 → 0.2.36

package/lib/server/route-handlers.js

@@ -0,0 +1,367 @@
+import {
+  buildBoard,
+  boardMetrics,
+  listArchive,
+  exportBoard,
+  importBoard,
+  exportTasksCsv,
+  taskBySession,
+} from '../routes.js'
+import { runBatch, resolveModel, liveSessions } from '../launcher.js'
+import { listImportable, importIssue, createProjectTask, searchRepos } from '../import.js'
+import { shouldRelay, relayRequest, testRemoteServer } from '../remote-relay.js'
+import { testRemoteConnection, isRemoteMode } from '../remote-runner.js'
+import { rootOf } from '../config.js'
+import { TASK_TEMPLATES, getTemplateById } from '../templates.js'
+import { verifySignature, detectWebhookProvider, parseEvent } from '../webhook.js'
+import { isWatched } from '../intake.js'
+import { intakeAll, syncAll } from '../sync.js'
+import { SessionId } from '@deepseek-ai/dsh-session'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import { randomUUID } from 'node:crypto'
+
+export function createRouteHandlers(deps) {
+  const {
+    ctx,
+    store,
+    getConfig,
+    git,
+    gitea,
+    github,
+    getGitRunner,
+    eventHub,
+    syncState,
+    runSync,
+    liveOf,
+    defaultOwner,
+    whoAmI,
+    isCostMeterAvailable,
+    resolveSecret,
+    isTrusted,
+    urlOf,
+    writeJson,
+    reply,
+    readBody,
+    readRaw,
+    rejectUntrusted,
+  } = deps
+
+  return {
+    async handleProjectTask(req, res) {
+      if (req.method !== 'POST') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      try {
+        const input = await readBody(req)
+        reply(res, await createProjectTask({
+          gitea: git, store,
+          owner: input.owner || await defaultOwner(),
+          repo: input.repo, newRepo: input.newRepo,
+          title: input.title, body: input.body,
+          board: input.board ?? 'main',
+        }))
+      } catch (error) {
+        writeJson(res, error?.status ?? 500, { error: 'bad-request' })
+      }
+    },
+
+    async handlePresets(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const presets = ctx.get('agentPresets')
+      const permissions = ctx.get('permissionPresets')
+      let agentPresets = []
+      try {
+        const rows = presets === undefined ? [] : await presets.list()
+        agentPresets = rows.filter((row) => row?.broken === undefined).map((row) => ({
+          id: row.id, name: row.name || row.id, description: row.description,
+        }))
+      } catch (error) {
+        ctx.logger?.warn?.(`dsh-kanban: agent profiles failed to load: ${error?.message}`)
+      }
+      let access = []
+      let accessDefault = ''
+      try {
+        if (permissions !== undefined) {
+          access = permissions.names.map((name) => permissions.optionOf(name))
+          accessDefault = permissions.defaultPreset ?? ''
+        }
+      } catch (error) {
+        ctx.logger?.warn?.(`dsh-kanban: access levels failed to load: ${error?.message}`)
+      }
+      reply(res, {
+        agentPresets,
+        agentPresetDefault: presets?.defaultId ?? '',
+        access,
+        accessDefault,
+      })
+    },
+
+    handleSessions(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      reply(res, { sessions: liveSessions({ store, agents: ctx.agents }) })
+    },
+
+    async handleBatch(req, res) {
+      if (req.method !== 'POST') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      try {
+        const input = await readBody(req)
+        const ids = Array.isArray(input.ids) ? input.ids : []
+        const picked = ids.map((id) => store.getTask(id)).filter((task) => task !== undefined)
+        const chosen = resolveModel({
+          requested: input,
+          fallback: ctx.get('agentDefaultModel')?.currentSelection?.(),
+        })
+        if (chosen === undefined) { writeJson(res, 400, { error: 'model-required' }); return }
+        reply(res, await runBatch({
+          agents: ctx.agents, store, tasks: picked, config: getConfig(),
+          provider: chosen.provider, model: chosen.model,
+          mintSessionId: () => SessionId(`kanban-batch-${randomUUID()}`),
+          createMessage: createUserMessage,
+          cwdOf: undefined, logger: ctx.logger, text: input.text,
+          agentPreset: typeof input.agentPreset === 'string' ? input.agentPreset : undefined,
+          permission: typeof input.permission === 'string' ? input.permission : undefined,
+          permissions: ctx.get('permissionPresets'),
+          claimAs: await whoAmI(),
+        }))
+      } catch (error) {
+        writeJson(res, error?.status ?? 500, { error: 'batch-failed' })
+      }
+    },
+
+    handleArchive(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      reply(res, listArchive({ store }))
+    },
+
+    async handleSync(req, res) {
+      if (req.method !== 'POST') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      try {
+        writeJson(res, 200, await runSync())
+      } catch (error) {
+        writeJson(res, 502, { error: 'sync-failed' })
+      }
+    },
+
+    async handleWebhook(req, res) {
+      if (req.method !== 'POST') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      try {
+        const raw = await readRaw(req)
+        const isGithub = detectWebhookProvider(req.headers) === 'github'
+        const secretRef = isGithub
+          ? (getConfig().githubWebhookSecretRef || getConfig().webhookSecretRef)
+          : getConfig().webhookSecretRef
+        const secret = await resolveSecret(secretRef)
+        const sig = isGithub ? req.headers['x-hub-signature-256'] : req.headers['x-gitea-signature']
+        if (!verifySignature(secret, raw, sig)) {
+          writeJson(res, 401, { error: 'bad-signature' })
+          return
+        }
+        let payload
+        try { payload = JSON.parse(raw.toString('utf8')) } catch { payload = undefined }
+        const target = parseEvent(payload)
+        if (target === undefined) { writeJson(res, 202, { ignored: true }); return }
+
+        const activeGit = isGithub ? github : gitea
+        const owner = isGithub
+          ? (String(getConfig().githubOwner ?? '').trim() || target.owner)
+          : await defaultOwner()
+        const taken = target.owner === owner || isWatched({
+          config: getConfig(), owner: target.owner, defaultOwner: owner, repo: target.repo,
+        })
+          ? await intakeAll({
+            gitea: activeGit, store, config: getConfig(), owner, logger: ctx.logger,
+            only: (pair) => pair.owner === target.owner && pair.repo === target.repo,
+          })
+          : { added: 0, skipped: 0, failed: 0 }
+
+        const out = await syncAll({
+          gitea: git, store, logger: ctx.logger,
+          only: (t) => t.owner === target.owner && t.repo === target.repo
+            && (target.issueNumber === undefined || t.issueNumber === target.issueNumber),
+        })
+        writeJson(res, 200, { ...out, taken })
+      } catch (error) {
+        writeJson(res, error?.status ?? 500, { error: 'webhook-failed' })
+      }
+    },
+
+    async handleBoard(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const cfg = getConfig()
+      if (shouldRelay(cfg)) {
+        const url = urlOf(req)
+        const relayRes = await relayRequest({
+          config: cfg,
+          urlPath: '/dsh-kanban/board' + (url.search || ''),
+          method: 'GET',
+          headers: req.headers,
+        })
+        writeJson(res, relayRes.status, relayRes.body)
+        return
+      }
+      const url = urlOf(req)
+      reply(res, buildBoard({
+        store,
+        config: cfg,
+        board: url.searchParams.get('board') || 'main',
+        repo: url.searchParams.get('repo') || undefined,
+        liveOf,
+        sync: syncState.snapshot(),
+        projectRoot: rootOf(cfg),
+        costMeterAvailable: isCostMeterAvailable(ctx),
+      }))
+    },
+
+    async handleRemoteTest(req, res) {
+      if (req.method !== 'POST') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const cfg = getConfig()
+      const sshRes = await testRemoteConnection(cfg)
+      const serverRes = cfg.remoteServerUrl ? await testRemoteServer(cfg) : { ok: false, error: 'no-server-url' }
+      writeJson(res, 200, {
+        remoteMode: isRemoteMode(cfg),
+        ssh: sshRes,
+        server: serverRes,
+      })
+    },
+
+    handleMetrics(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const url = urlOf(req)
+      const days = Number(url.searchParams.get('staleDays'))
+      reply(res, boardMetrics({
+        store,
+        board: url.searchParams.get('board') || 'main',
+        staleDays: Number.isFinite(days) && days > 0 ? days : 14,
+      }))
+    },
+
+    async handleWhoami(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      reply(res, { login: await whoAmI() })
+    },
+
+    handleExportCsv(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const u = urlOf(req)
+      const board = u.searchParams.get('board') || 'main'
+      const csv = exportTasksCsv({ store, board })
+      res.writeHead(200, {
+        'Content-Type': 'text/csv; charset=utf-8',
+        'Content-Disposition': `attachment; filename="kanban-${board}-${new Date().toISOString().slice(0, 10)}.csv"`,
+        'Cache-Control': 'no-store',
+      })
+      res.end(csv)
+    },
+
+    handleEvents(req, res) {
+      eventHub.handleSseRequest(req, res, { isTrustedRequest: isTrusted })
+    },
+
+    handleTemplates(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const u = new URL(req.url, 'http://localhost')
+      const tid = u.searchParams.get('id')
+      if (tid) {
+        const tmpl = getTemplateById(tid)
+        if (!tmpl) { writeJson(res, 404, { error: 'template-not-found' }); return }
+        reply(res, { template: tmpl })
+        return
+      }
+      reply(res, { templates: TASK_TEMPLATES })
+    },
+
+    async handleSnapshot(req, res) {
+      if (rejectUntrusted(req, res)) return
+      if (req.method === 'GET') { reply(res, exportBoard({ store })); return }
+      if (req.method !== 'POST') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      try {
+        const input = await readBody(req)
+        const impResult = importBoard({ store, input })
+        if (impResult?.imported > 0) {
+          eventHub.broadcast('task:change', { action: 'imported', count: impResult.imported })
+        }
+        reply(res, impResult)
+      } catch {
+        writeJson(res, 400, { error: 'bad-request' })
+      }
+    },
+
+    async handleGiteaRepos(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const url = urlOf(req)
+      reply(res, await searchRepos({ gitea: git, query: url.searchParams.get('q') || '' }))
+    },
+
+    async handleGiteaIssues(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const url = urlOf(req)
+      reply(res, await listImportable({
+        gitea: git,
+        store,
+        owner: url.searchParams.get('owner') || undefined,
+        repo: url.searchParams.get('repo') || undefined,
+        board: url.searchParams.get('board') || 'main',
+      }))
+    },
+
+    async handleGiteaImport(req, res) {
+      if (req.method !== 'POST') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      try {
+        const input = await readBody(req)
+        reply(res, await importIssue({
+          gitea: git, store,
+          owner: input.owner, repo: input.repo, issueNumber: input.issueNumber,
+          board: input.board ?? 'main', column: input.column ?? 'backlog',
+          forge: input.forge || input.provider,
+        }))
+      } catch (error) {
+        writeJson(res, error?.status ?? 500, { error: 'bad-request' })
+      }
+    },
+
+    async handleModels(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const current = ctx.get('agentDefaultModel')?.currentSelection?.() ?? null
+      const llmService = ctx.get('llm')
+      let providers = []
+      try {
+        providers = ((llmService?.listProviders?.() ?? []).map((p) => ({ id: p.id, name: p.name ?? p.id })))
+      } catch { providers = [] }
+
+      const wanted = urlOf(req).searchParams.get('provider') || ''
+      if (wanted === '') { writeJson(res, 200, { current, providers, models: [] }); return }
+
+      try {
+        const rows = await llmService?.listModels?.(wanted)
+        writeJson(res, 200, {
+          current, providers,
+          models: (rows ?? []).map((m) => ({ id: m.id, name: m.name ?? m.id })),
+        })
+      } catch {
+        writeJson(res, 200, { current, providers, models: [] })
+      }
+    },
+
+    handleSessionTask(req, res) {
+      if (req.method !== 'GET') { writeJson(res, 405, { error: 'method-not-allowed' }); return }
+      if (rejectUntrusted(req, res)) return
+      const m = /^\/dsh-kanban\/session\/([^/]+)\/task\/?$/.exec(urlOf(req).pathname)
+      if (m === null) { writeJson(res, 404, { error: 'not-found' }); return }
+      reply(res, taskBySession({ store, sessionId: decodeURIComponent(m[1]), agents: ctx.agents }))
+    },
+  }
+}

package/lib/server/services.js

@@ -0,0 +1,225 @@
+import { PowerInhibitor } from '../power.js'
+import { createWatchdogService } from '../watchdog.js'
+import { WorkflowBridge } from '../workflow-bridge.js'
+import { buildPromptSectionText } from '../config.js'
+import { handleSessionEvent } from '../lifecycle.js'
+import { dispatchNextQueuedTask } from '../launcher.js'
+import { SessionId } from '@deepseek-ai/dsh-session'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import { randomUUID } from 'node:crypto'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import {
+  boardMoveDefinition,
+  boardPlanDefinition,
+  boardChecklistDefinition,
+  boardReportDefinition,
+  boardCommentsDefinition,
+  boardCommentAddDefinition,
+  boardDecomposeDefinition,
+  boardChecklistItemDefinition,
+} from '../board-tool.js'
+
+export function registerKanbanServices(ctx, deps) {
+  const {
+    store,
+    getConfig,
+    eventHub,
+    git,
+    rearmers,
+  } = deps
+
+  const watchdog = createWatchdogService()
+
+  const powerInhibitor = new PowerInhibitor({
+    platform: process.platform,
+    pid: process.pid,
+  })
+
+  const workflowBridge = new WorkflowBridge({
+    get store() { return store },
+    get workflowEngine() { return ctx.get('workflowEngine') },
+    get agentPresets() { return ctx.get('agentPresets') },
+    get agents() { return ctx.agents },
+    git,
+    getConfig,
+    logger: ctx.logger,
+    eventHub,
+  })
+
+  const unbindCoreWorkflow = workflowBridge.bindCoreEvents(ctx)
+  if (typeof ctx.on === 'function') {
+    ctx.on('dispose', () => {
+      unbindCoreWorkflow?.()
+    })
+  }
+
+  const syncPower = () => {
+    try {
+      const cfg = getConfig()
+      powerInhibitor.setEnabled(cfg.preventIdleSleep === true)
+      if (store) {
+        const activeCount = store.countInColumn('main', 'in-progress') + store.countInColumn('simple', 'in-progress')
+        powerInhibitor.setReasons(activeCount)
+      }
+    } catch { /* ignore */ }
+  }
+  rearmers.add(syncPower)
+  ctx.effect(() => {
+    syncPower()
+    return () => { powerInhibitor.destroy() }
+  }, 'dsh-kanban: power inhibitor')
+
+  let disposePromptSection
+  const syncPromptSection = () => {
+    if (disposePromptSection) {
+      try { disposePromptSection() } catch { /* cleanup best effort */ }
+      disposePromptSection = undefined
+    }
+    const cfg = getConfig()
+    const sp = ctx.get('systemPrompt')
+    const promptText = buildPromptSectionText(cfg)
+    if (promptText && sp && typeof sp.section === 'function') {
+      try {
+        disposePromptSection = sp.section({
+          name: 'plugin:dsh-kanban',
+          order: 200,
+          text: promptText,
+        })
+      } catch (err) {
+        ctx.logger?.warn?.(`dsh-kanban: failed to register system prompt section: ${err?.message}`)
+      }
+    }
+  }
+  rearmers.add(syncPromptSection)
+  ctx.effect(() => {
+    syncPromptSection()
+    return () => { if (disposePromptSection) { try { disposePromptSection() } catch { /* cleanup best effort */ } } }
+  }, 'dsh-kanban: system prompt section')
+
+  ctx.effect(() => ctx.on('session/event', (session, event) => {
+    try {
+      const sessionIdStr = String(session?.id ?? '')
+      if (
+        getConfig().autoSyncSessions === true &&
+        session &&
+        !session.isSubagent &&
+        session.origin !== 'subagent' &&
+        session.parentId === undefined &&
+        session.meta?.origin !== 'subagent' &&
+        !sessionIdStr.startsWith('kanban-') &&
+        !sessionIdStr.startsWith('kanban_')
+      ) {
+        let existingTask = store?.findTaskBySession?.(sessionIdStr)
+        if (!existingTask && (event?.type === 'turn/start' || event?.type === 'session/created' || event?.type === 'input/user' || event?.type === 'message')) {
+          const userText = (event?.content?.[0]?.text ?? event?.text ?? '').trim()
+          const sessionTitle = session.title || session.name || (userText ? userText.slice(0, 50) : `Dialog ${sessionIdStr.slice(0, 8)}`)
+          const createdTask = store.createTask({
+            title: sessionTitle,
+            body: userText || `Automatically created from chat session ${sessionIdStr}`,
+            column: 'in-progress',
+            board: 'main',
+            sessionId: sessionIdStr,
+            labels: ['chat-sync'],
+          })
+          if (createdTask) {
+            existingTask = createdTask
+            eventHub.broadcast('task:change', { taskId: createdTask.id, action: 'created' })
+          }
+        } else if (existingTask) {
+          if (event?.type === 'turn/end' || event?.type === 'turn/completed') {
+            if (existingTask.column === 'in-progress') {
+              store.moveTask(existingTask.id, { column: 'review' })
+              eventHub.broadcast('task:change', { taskId: existingTask.id, action: 'moved', toCol: 'review' })
+            }
+          } else if (event?.type === 'turn/error' || event?.type === 'session/error') {
+            if (existingTask.column === 'in-progress') {
+              store.moveTask(existingTask.id, { column: 'todo' })
+              eventHub.broadcast('task:change', { taskId: existingTask.id, action: 'moved', toCol: 'todo' })
+            }
+          }
+        }
+      }
+
+      const text = event?.content?.[0]?.text ?? event?.text ?? ''
+      if (existingTask) {
+        if (event?.type === 'tool/error' || event?.type === 'turn/error' || event?.type === 'session/error') {
+          watchdog.recordError(existingTask.id, event.error || text)
+        } else {
+          watchdog.recordActivity(existingTask.id, event?.type)
+          if (event?.type === 'tool/result' || event?.type === 'turn/completed' || event?.type === 'turn/end') {
+            watchdog.clearError(existingTask.id)
+          }
+        }
+      }
+      handleSessionEvent({
+        store,
+        sessionId: String(session?.id ?? ''),
+        session,
+        type: event?.type,
+        text,
+        error: event?.error,
+      })
+      syncPower()
+      if (event?.type === 'turn/end' || event?.type === 'turn/completed' || event?.type === 'session/error' || event?.type === 'turn/error') {
+        dispatchNextQueuedTask({
+          agents: ctx.agents,
+          store,
+          config: getConfig(),
+          mintSessionId: () => SessionId(`kanban-queued-${randomUUID()}`),
+          createMessage: createUserMessage,
+          logger: ctx.logger,
+          permissions: ctx.get('permissionPresets'),
+          workspaceRegistry: ctx.get('workspaceRegistry'),
+          claimAs: 'queue-dispatcher',
+        }).catch(() => {})
+      }
+    } catch (error) {
+      ctx.logger?.warn?.(`dsh-kanban: session event handler failed: ${error?.message}`)
+    }
+  }), 'dsh-kanban: session events')
+
+  ctx.effect(() => {
+    let unregister
+    const arm = () => {
+      const wanted = getConfig().boardToolEnabled === true
+      if (wanted === (unregister !== undefined)) return
+      if (!wanted) { unregister?.(); unregister = undefined; return }
+      unregister = registerBoardTool()
+    }
+
+    const registerBoardTool = () => {
+      const off = [
+        ctx.tools.register(defineTool(boardMoveDefinition({ store, config: getConfig, eventHub }))),
+        ctx.tools.register(defineTool(boardPlanDefinition({ store, eventHub }))),
+        ctx.tools.register(defineTool(boardChecklistDefinition({ store, eventHub }))),
+        ctx.tools.register(defineTool(boardReportDefinition({ store }))),
+        ctx.tools.register(defineTool(boardCommentsDefinition({ store }))),
+        ctx.tools.register(defineTool(boardCommentAddDefinition({ store }))),
+        ctx.tools.register(defineTool(boardDecomposeDefinition({ store, gitea: git }))),
+        ctx.tools.register(defineTool(boardChecklistItemDefinition({ store, eventHub }))),
+      ]
+      return () => { for (const stop of off) stop?.() }
+    }
+
+    arm()
+    rearmers.add(arm)
+    return () => { rearmers.delete(arm); unregister?.() }
+  }, 'dsh-kanban: board tool')
+
+  const liveOf = (sessionId) => {
+    try {
+      const a = ctx.agents?.get?.(sessionId)
+      if (!a) return undefined
+      return {
+        status: a.status || (typeof a.isIdle === 'function' && a.isIdle() ? 'idle' : 'running'),
+        state: a.state || a.lifecycleState,
+        step: a.step || a.currentStep || a.stateDetail || a.activity || '',
+        activity: a.activity || a.statusDetail || '',
+      }
+    } catch {
+      return undefined
+    }
+  }
+
+  return { powerInhibitor, syncPower, workflowBridge, liveOf, watchdog }
+}