@goodandready/dsh-kanban 0.2.33 → 0.2.35

package/lib/remote-relay.js

@@ -0,0 +1,149 @@
+/**
+ * Remote DSH server relay client (#390).
+ * Proxies board state, task actions, and sessions between PC client and server 111.
+ * Zero Cyrillic literals in lib/ according to Issue #366 standard.
+ */
+
+/**
+ * Check whether requests should be relayed to remote DSH server.
+ *
+ * @param {object} config
+ * @returns {boolean}
+ */
+export function shouldRelay(config) {
+  return Boolean(config && config.remoteMode && config.remoteServerUrl)
+}
+
+/**
+ * Resolve target URL on remote DSH server.
+ *
+ * @param {object} config
+ * @param {string} path
+ * @returns {string}
+ */
+export function getRemoteServerUrl(config, path = '') {
+  const base = String(config?.remoteServerUrl || 'http://192.168.1.111:3080').trim().replace(/\/+$/, '')
+  const cleanPath = path ? (path.startsWith('/') ? path : '/' + path) : ''
+  return `${base}${cleanPath}`
+}
+
+/**
+ * Build request headers including DSH auth token and cookies.
+ *
+ * @param {object} config
+ * @param {object} [originalHeaders]
+ * @returns {Record<string, string>}
+ */
+export function buildRemoteHeaders(config, originalHeaders = {}) {
+  const headers = {
+    'Accept': 'application/json, text/plain, */*',
+  }
+
+  if (originalHeaders && typeof originalHeaders === 'object') {
+    if (originalHeaders['content-type']) {
+      headers['Content-Type'] = originalHeaders['content-type']
+    }
+  }
+
+  const token = String(config?.remoteServerToken || '').trim()
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`
+    headers['Cookie'] = `dsh_token=${token}`
+  }
+
+  return headers
+}
+
+/**
+ * Relay an HTTP request to remote DSH server.
+ *
+ * @param {{
+ *   config: object,
+ *   path: string,
+ *   method?: string,
+ *   body?: any,
+ *   headers?: object,
+ *   timeoutMs?: number
+ * }} options
+ * @returns {Promise<{ status: number, body: any, headers?: object }>}
+ */
+export async function relayRequest({ config, path, urlPath, method = 'GET', body, headers, timeoutMs = 15000 }) {
+  const targetPath = urlPath || path || ''
+  const url = getRemoteServerUrl(config, targetPath)
+  const reqHeaders = buildRemoteHeaders(config, headers)
+
+  const fetchOptions = {
+    method,
+    headers: reqHeaders,
+    signal: AbortSignal.timeout(timeoutMs),
+  }
+
+  if (body !== undefined && body !== null && method !== 'GET' && method !== 'HEAD') {
+    if (typeof body === 'string') {
+      fetchOptions.body = body
+      if (!fetchOptions.headers['Content-Type']) {
+        fetchOptions.headers['Content-Type'] = 'application/json'
+      }
+    } else {
+      fetchOptions.body = JSON.stringify(body)
+      fetchOptions.headers['Content-Type'] = 'application/json'
+    }
+  }
+
+  try {
+    const res = await fetch(url, fetchOptions)
+    const contentType = res.headers.get('content-type') || ''
+    let parsedBody
+    if (contentType.includes('application/json')) {
+      parsedBody = await res.json()
+    } else {
+      parsedBody = await res.text()
+    }
+
+    return {
+      status: res.status,
+      body: parsedBody,
+    }
+  } catch (err) {
+    return {
+      status: 503,
+      body: {
+        error: 'remote-server-unavailable',
+        detail: `Failed to reach remote DSH server at ${url}: ${err.message}`,
+      },
+    }
+  }
+}
+
+/**
+ * Probe remote DSH server connection and kanban board endpoint.
+ *
+ * @param {object} config
+ * @returns {Promise<{ ok: boolean, latencyMs?: number, status?: number, error?: string }>}
+ */
+export async function testRemoteServer(config) {
+  const startTime = Date.now()
+  const res = await relayRequest({
+    config,
+    urlPath: '/dsh-kanban/board',
+    method: 'GET',
+    timeoutMs: 8000,
+  })
+
+  const latencyMs = Date.now() - startTime
+
+  if (res.status === 200) {
+    return {
+      ok: true,
+      latencyMs,
+      status: res.status,
+    }
+  }
+
+  return {
+    ok: false,
+    latencyMs,
+    status: res.status,
+    error: res.body?.detail || res.body?.error || `HTTP ${res.status}`,
+  }
+}

package/lib/remote-runner.js

@@ -0,0 +1,164 @@
+/**
+ * Remote SSH runner for git and worktree operations (#390).
+ * Allows DSH running on PC (Windows) to execute commands on remote server (111).
+ * Zero Cyrillic literals in lib/ according to Issue #366 standard.
+ */
+
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+
+/**
+ * Check whether remote execution mode is enabled in config.
+ *
+ * @param {object} config
+ * @returns {boolean}
+ */
+export function isRemoteMode(config) {
+  return Boolean(config && config.remoteMode)
+}
+
+/**
+ * Quote argument safely for remote POSIX shell execution.
+ *
+ * @param {string|number} s
+ * @returns {string}
+ */
+export function quoteArg(s) {
+  return "'" + String(s ?? '').replace(/'/g, "'\\''") + "'"
+}
+
+/**
+ * Build arguments array for SSH CLI process.
+ *
+ * @param {object} config
+ * @param {string} remoteCommand
+ * @returns {string[]}
+ */
+export function buildSshArgs(config, remoteCommand) {
+  const host = String(config?.remoteHost || '192.168.1.111').trim()
+  const port = Number(config?.remotePort) || 22
+  const user = String(config?.remoteUser || 'migrate').trim()
+  const keyPath = String(config?.remoteKeyPath || '').trim()
+  const sudoUser = config?.remoteSudoUser !== undefined ? String(config.remoteSudoUser).trim() : 'vadim'
+
+  const args = [
+    '-p', String(port),
+    '-o', 'BatchMode=yes',
+    '-o', 'StrictHostKeyChecking=accept-new',
+    '-o', 'ConnectTimeout=10',
+  ]
+
+  if (keyPath) {
+    args.push('-i', keyPath)
+  }
+
+  const target = `${user}@${host}`
+  args.push(target)
+
+  let fullCmd = remoteCommand
+  if (sudoUser) {
+    fullCmd = `sudo -u ${sudoUser} -H bash -c ${quoteArg(remoteCommand)}`
+  }
+
+  args.push(fullCmd)
+  return args
+}
+
+/**
+ * Create a git runner function that delegates to remote host over SSH when remoteMode is active.
+ * Conforms to (args, cwd) => Promise<{ stdout: string, stderr: string }>.
+ *
+ * @param {object} config
+ * @param {Function} [localGitRunner] fallback local runner
+ * @returns {Function}
+ */
+export function createRemoteGitRunner(config, localGitRunner) {
+  return async function remoteGitRunner(args, cwd) {
+    if (!isRemoteMode(config)) {
+      if (typeof localGitRunner === 'function') {
+        return localGitRunner(args, cwd)
+      }
+      throw new Error('[dsh-kanban] No local git runner available in non-remote mode')
+    }
+
+    const escapedArgs = (Array.isArray(args) ? args : []).map(quoteArg).join(' ')
+    const cdPart = cwd ? `cd ${quoteArg(cwd)} && ` : ''
+    const gitCmd = `${cdPart}git ${escapedArgs}`
+    const sshArgs = buildSshArgs(config, gitCmd)
+
+    try {
+      const { stdout, stderr } = await execFileAsync('ssh', sshArgs, {
+        maxBuffer: 10 * 1024 * 1024,
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' },
+      })
+      return { stdout: stdout ?? '', stderr: stderr ?? '' }
+    } catch (err) {
+      const error = new Error(`[dsh-kanban-remote] git ${args?.[0] || ''} failed on ${config?.remoteHost || 'remote'}: ${err.message}`)
+      error.code = err.code ?? 1
+      error.stdout = err.stdout ?? ''
+      error.stderr = err.stderr ?? err.message ?? ''
+      throw error
+    }
+  }
+}
+
+/**
+ * Check connectivity to remote server and verify remote root directory.
+ *
+ * @param {object} config
+ * @returns {Promise<{ ok: boolean, latencyMs?: number, remoteRootFound?: boolean, error?: string }>}
+ */
+export async function testRemoteConnection(config) {
+  const root = String(config?.remoteRoot || '/mnt/external/Project/DEV').trim()
+  const probeCmd = `test -d ${quoteArg(root)} && echo REMOTE_ROOT_OK || echo REMOTE_ROOT_MISSING`
+  const sshArgs = buildSshArgs(config, probeCmd)
+
+  const startTime = Date.now()
+  try {
+    const { stdout } = await execFileAsync('ssh', sshArgs, {
+      maxBuffer: 1024 * 1024,
+      timeout: 12000,
+      env: { ...process.env, LC_ALL: 'C' },
+    })
+    const latencyMs = Date.now() - startTime
+    const trimmed = (stdout || '').trim()
+    const remoteRootFound = trimmed.includes('REMOTE_ROOT_OK')
+
+    return {
+      ok: true,
+      latencyMs,
+      remoteRootFound,
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      error: err.stderr ? err.stderr.trim() : err.message,
+    }
+  }
+}
+
+/**
+ * Check if path exists on remote host.
+ *
+ * @param {string} remotePath
+ * @param {object} config
+ * @returns {Promise<boolean>}
+ */
+export async function remotePathExists(remotePath, config) {
+  if (!remotePath) return false
+  const probeCmd = `test -e ${quoteArg(remotePath)} && echo 1 || echo 0`
+  const sshArgs = buildSshArgs(config, probeCmd)
+
+  try {
+    const { stdout } = await execFileAsync('ssh', sshArgs, {
+      maxBuffer: 1024 * 1024,
+      timeout: 10000,
+      env: { ...process.env, LC_ALL: 'C' },
+    })
+    return (stdout || '').trim() === '1'
+  } catch {
+    return false
+  }
+}

package/lib/routes/board.js

@@ -0,0 +1,282 @@
+import { COLUMN_ORDER, columnsOf, wipLimitField, columnNamesOf } from '../config.js'
+import { parsePlan, planItems, planProgress, taskState, queuePosition } from '../plan.js'
+import { columnStats, doneWithin, stale } from '../metrics.js'
+import { isStale } from '../time.js'
+import { facetsOf, facetsOfTask, groupByRepo, sortByLife } from '../filters.js'
+import { computeNextRun } from '../cron.js'
+
+export function withPlan(task, liveOf, config, now, sameSession) {
+  const plan = parsePlan(task.plan)
+  // Registry error implies agent unavailable; do not fail whole board render.
+  let live
+  try {
+    if (typeof liveOf === 'function' && task.sessionId) live = liveOf(task.sessionId)
+  } catch { live = undefined }
+  const liveStatus = typeof live === 'object' && live !== null ? live.status : live
+  const liveStep = typeof live === 'object' && live !== null
+    ? (live.step || live.activity || live.stateDetail || '')
+    : ''
+
+  const costMetrics = task.costMetrics || null
+  const costLimitExceeded = (config?.costMeterEnabled !== false && Number(config?.taskCostLimit) > 0 && costMetrics?.costUsd)
+    ? costMetrics.costUsd >= Number(config.taskCostLimit)
+    : Boolean(task.costLimitExceeded)
+
+  return {
+    ...task,
+    plan: { items: planItems(plan), progress: planProgress(plan) },
+    state: taskState({ task, live: liveStatus }),
+    liveStep: liveStep || task.liveStep || '',
+    costMetrics,
+    costLimitExceeded,
+    // Queue position calculated dynamically across active tasks in same session.
+    queuePos: queuePosition(task, sameSession),
+    // Label facets extracted on server for consistent client filtering.
+    facets: facetsOfTask(task),
+    // Stale calculation performed on host where configuration resides.
+    stale: isStale({
+      now,
+      updatedAt: task.updatedAt,
+      sessionId: task.sessionId,
+      afterMinutes: config?.staleAfterMin,
+    }),
+    // Overdue calculated on host using server clock.
+    overdue: typeof task.dueAt === 'number' && task.dueAt > 0 && task.dueAt < now,
+  }
+}
+
+/** Order tasks: by column, grouped by repository, with active tasks on top. */
+function orderForBoard(tasks, columns) {
+  const out = []
+  for (const column of columns) {
+    const inColumn = tasks.filter((t) => t.column === column)
+    for (const group of groupByRepo(sortByLife(inColumn))) out.push(...group.tasks)
+  }
+  // Retain tasks in columns not visible on current board to prevent data loss.
+  const seen = new Set(out.map((t) => t.id))
+  for (const task of tasks) if (!seen.has(task.id)) out.push(task)
+  return out
+}
+
+/**
+ * Build board response payload: columns in canonical order, tasks, and limits.
+ */
+export function buildBoard({ store, config, board = 'main', repo, liveOf, sync, projectRoot, costMeterAvailable = false }) {
+  // Uniform timestamp across snapshot calculation.
+  const now = Date.now()
+  // Tasks are sorted and grouped on server: repo grouping with active items first.
+  const raw = store.listTasks({ board, repo })
+  // Queue position scoped per session.
+  const bySession = new Map()
+  for (const task of raw) {
+    const id = typeof task.sessionId === 'string' ? task.sessionId : ''
+    if (id === '') continue
+    if (!bySession.has(id)) bySession.set(id, [])
+    bySession.get(id).push(task)
+  }
+  const tasks = orderForBoard(
+    raw.map((task) => {
+      const enriched = withPlan(task, liveOf, config, now, bySession.get(task.sessionId) ?? [])
+      if (task.isEpic) {
+        enriched.subtasksCount = store.countSubtasks(task.id)
+      }
+      return enriched
+    }),
+    columnsOf(store.boardKind(board)),
+  )
+  const kind = store.boardKind(board)
+  // Column custom names sent from server; locale translation handled by client.
+  const names = columnNamesOf(config)
+  const columns = columnsOf(kind).map((id) => {
+    const count = tasks.filter((t) => t.column === id).length
+    const limit = wipLimitField(config, id)
+    return { id, name: names[id], count, limit, overLimit: limit !== undefined && count > limit }
+  })
+  // Filter counts calculated over all tasks on board.
+  return {
+    board, kind, now, boards: store.listBoards(), columns, tasks,
+    // Resolved project root {path, set} computed on host.
+    projectRoot: projectRoot ?? { path: '', set: false },
+
+    facets: facetsOf(tasks),
+    // Sync telemetry state attached directly to board snapshot.
+    sync: sync ?? { state: 'never' },
+    costMeterAvailable: Boolean(costMeterAvailable),
+    remoteMode: Boolean(config?.remoteMode),
+  }
+}
+
+/**
+ * Card move transition. WIP limit is advisory: move executes, and exceeded status
+ * is returned for UI highlighting.
+ */
+
+export function boardMetrics({ store, board = 'main', now = Date.now(), staleDays = 14 }) {
+  const tasks = store.listTasks({ board })
+  const byTask = new Map()
+  for (const row of store.listAllTransitions()) {
+    if (!byTask.has(row.taskId)) byTask.set(row.taskId, [])
+    byTask.get(row.taskId).push(row)
+  }
+  const rows = tasks.map((task) => ({ task, moves: byTask.get(task.id) ?? [] }))
+  const day = 24 * 60 * 60 * 1000
+
+  return {
+    tasks: tasks.length,
+    columns: columnStats(rows, now),
+    done: {
+      week: doneWithin(rows, now - 7 * day, now),
+      month: doneWithin(rows, now - 30 * day, now),
+    },
+    staleDays,
+    stale: stale(tasks, now, staleDays * day).slice(0, 50),
+  }
+}
+
+/**
+ * Check whether a task can be resumed.
+ * Eligible when task has recorded sessionId but no active agent is running.
+ */
+
+export function exportBoard({ store }) {
+  return store.exportAll()
+}
+
+/**
+ * Restore board from backup snapshot (idempotent; skips existing IDs).
+ *
+ * @returns {{imported: number, skipped: number, error?: string}}
+ */
+export function importBoard({ store, input }) {
+  let backupMeta = undefined
+  if (typeof store.backupDatabase === 'function') {
+    try {
+      backupMeta = store.backupDatabase()
+    } catch { /* backup best effort */ }
+  }
+  if (input === null || typeof input !== 'object') return { error: 'bad-import', status: 400 }
+  if (input.version !== 1) return { error: 'bad-import-version', status: 400 }
+  if (!Array.isArray(input.tasks)) return { error: 'bad-import', status: 400 }
+
+  let imported = 0
+  let skipped = 0
+
+  const doImport = () => {
+    for (const board of Array.isArray(input.boards) ? input.boards : []) {
+      if (typeof board?.id !== 'string' || board.id === '') continue
+      store.createBoard({
+        id: board.id,
+        title: board.title,
+        kind: board.kind,
+        position: board.position,
+        createdAt: board.createdAt,
+      })
+    }
+
+    for (const task of input.tasks) {
+      if (typeof task?.id !== 'string' || task.id === '') continue
+      if (store.getTask(task.id) !== undefined) { skipped += 1; continue }
+      if (typeof store.restoreTask === 'function') {
+        store.restoreTask(task)
+      } else {
+        store.createTask(task)
+      }
+      imported += 1
+    }
+
+    for (const trans of Array.isArray(input.transitions) ? input.transitions : []) {
+      if (typeof trans?.taskId !== 'string' || trans.taskId === '') continue
+      if (typeof store.restoreTransition === 'function') {
+        store.restoreTransition(trans)
+      } else if (typeof store.addTransition === 'function') {
+        store.addTransition(trans)
+      }
+    }
+  }
+
+  if (typeof store.withTransaction === 'function') {
+    store.withTransaction(doImport)
+  } else {
+    doImport()
+  }
+
+  return { imported, skipped, backup: backupMeta?.backup }
+}
+
+/**
+ * Export tasks to Excel-compatible CSV with UTF-8 BOM (#223).
+ *
+ * @param {{store: object, board?: string}} options
+ * @returns {string} CSV string with UTF-8 BOM prefix
+ */
+export function exportTasksCsv({ store, board = 'main' }) {
+  const tasks = store.listTasks({ board })
+  const headers = [
+    'ID',
+    'Title',
+    'Column',
+    'Priority',
+    'Repository',
+    'Issue #',
+    'Assignee',
+    'Model',
+    'Provider',
+    'Reasoning Effort',
+    'Workspace',
+    'Branch',
+    'Created',
+    'Updated',
+  ]
+
+  function escapeCsv(val) {
+    if (val === null || val === undefined) return ''
+    let str = String(val)
+    // OWASP CSV Injection mitigation (#340)
+    const trimmed = str.replace(/^[\s\t\r\n]+/, '')
+    if (/^[=+\-@\t\r]/.test(str) || (trimmed.length > 0 && /^[=+\-@]/.test(trimmed))) {
+      str = `'${str}`
+    }
+    if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+      return `"${str.replace(/"/g, '""')}"`
+    }
+    return str
+  }
+
+  function formatDate(ts) {
+    if (!ts || typeof ts !== 'number') return ''
+    try {
+      return new Date(ts).toISOString().replace('T', ' ').slice(0, 19)
+    } catch {
+      return ''
+    }
+  }
+
+  const rows = [headers.join(',')]
+  for (const t of tasks) {
+    const row = [
+      escapeCsv(t.id),
+      escapeCsv(t.title),
+      escapeCsv(t.column),
+      escapeCsv(t.priority),
+      escapeCsv(t.repo),
+      escapeCsv(t.issueNumber ?? ''),
+      escapeCsv(t.assignee),
+      escapeCsv(t.model),
+      escapeCsv(t.provider),
+      escapeCsv(t.reasoningEffort ?? ''),
+      escapeCsv(t.workspaceId),
+      escapeCsv(t.branch),
+      escapeCsv(formatDate(t.createdAt)),
+      escapeCsv(formatDate(t.updatedAt)),
+    ]
+    rows.push(row.join(','))
+  }
+
+  // UTF-8 BOM prefix for Microsoft Excel
+  return '\uFEFF' + rows.join('\r\n')
+}
+
+
+/**
+ * Clean up task worktree.
+ */