@linxin666/dsh-client-ui-task-board 0.3.22 → 0.3.23

package/src/host-ai.ts

@@ -0,0 +1,152 @@
+/**
+ * One-shot model parse behind the board's "parse pasted text" action
+ * (issue #1540).
+ *
+ * The browser half never talks to a model: it posts the pasted text and the
+ * route the user picked to the Host, which calls the injected `llm` service
+ * once and answers with the three draft fields the new-task form accepts. The
+ * reply is untrusted text, so extraction is defensive: code fences are
+ * stripped, the first JSON object wins, and an unusable reply falls back to
+ * the user's own words instead of an empty form.
+ */
+import { createUserMessage, type GenerateOptions, type LlmRuntime } from '@deepseek-ai/dsh-llm'
+import type { TaskBoardParseDraft, TaskBoardParseRequest } from './protocol.ts'
+
+/** How long one parse may take before the Host gives up on the model. */
+export const TASK_PARSE_TIMEOUT_MS = 45_000
+/** Largest pasted text one parse accepts (bytes). */
+export const TASK_PARSE_MAX_INPUT = 16 * 1024
+/** Longest title the form is willing to receive from a model. */
+const TASK_PARSE_TITLE_LIMIT = 120
+
+export type TaskParseFailureCode = 'no-model' | 'model-error' | 'parse-failed' | 'timeout'
+
+/** Typed parse failure; the route maps the code onto a status and a body. */
+export class TaskParseError extends Error {
+  constructor(readonly code: TaskParseFailureCode, message: string) {
+    super(message)
+    this.name = 'TaskParseError'
+  }
+}
+
+const SYSTEM_PROMPT = [
+  'You turn one pasted note into a task for a kanban board.',
+  'Reply with a single JSON object and nothing else, with exactly these keys:',
+  '{"title": string, "description": string, "prompt": string}',
+  '- title: one line, at most 80 characters, in the language of the note.',
+  '- description: what the task is and the context the note carries, as plain text.',
+  '- prompt: the instruction an agent should execute, keeping every fact that matters.',
+].join('\n')
+
+/** Split a qualified `provider/model` route the same way the runner does. */
+export function splitModelRoute(qualified: string | undefined): { provider: string; model: string } | undefined {
+  const raw = qualified?.trim() ?? ''
+  if (raw === '') return undefined
+  const slash = raw.indexOf('/')
+  if (slash <= 0 || slash === raw.length - 1) return undefined
+  const provider = raw.slice(0, slash).trim()
+  const model = raw.slice(slash + 1).trim()
+  if (provider === '' || model === '') return undefined
+  return { provider, model }
+}
+
+/** Trim one model-provided field to a single-line, bounded string. */
+function field(value: unknown, limit?: number): string {
+  if (typeof value !== 'string') return ''
+  const text = value.trim()
+  return limit === undefined || text.length <= limit ? text : text.slice(0, limit).trim()
+}
+
+/** First non-empty line of the pasted text, used when the model omits a title. */
+function firstLine(source: string): string {
+  const line = source.split(/\r?\n/).map(entry => entry.trim()).find(entry => entry !== '') ?? ''
+  return line.length <= TASK_PARSE_TITLE_LIMIT ? line : line.slice(0, TASK_PARSE_TITLE_LIMIT).trim()
+}
+
+/**
+ * Read the draft out of a model reply. Fences and surrounding prose are
+ * tolerated; anything unusable returns undefined so the caller can decide
+ * between a typed failure and a fallback.
+ * @param reply - raw model text.
+ */
+export function extractTaskParseReply(reply: string): Partial<TaskBoardParseDraft> | undefined {
+  const withoutFences = reply.replace(/```[a-zA-Z]*\s*/g, '')
+  const start = withoutFences.indexOf('{')
+  const end = withoutFences.lastIndexOf('}')
+  if (start === -1 || end <= start) return undefined
+  let payload: unknown
+  try {
+    payload = JSON.parse(withoutFences.slice(start, end + 1))
+  } catch {
+    return undefined
+  }
+  if (typeof payload !== 'object' || payload === null) return undefined
+  const record = payload as { title?: unknown; description?: unknown; prompt?: string }
+  const draft: Partial<TaskBoardParseDraft> = {
+    title: field(record.title, TASK_PARSE_TITLE_LIMIT),
+    description: field(record.description),
+    prompt: field(record.prompt),
+  }
+  return draft.title === '' && draft.description === '' && draft.prompt === '' ? undefined : draft
+}
+
+/**
+ * Fill the three form fields, falling back to the pasted text so a weak model
+ * reply never loses what the user actually wrote.
+ * @param reply - raw model text.
+ * @param source - the text the user pasted.
+ */
+export function draftFromReply(reply: string, source: string): TaskBoardParseDraft {
+  const parsed = extractTaskParseReply(reply)
+  return {
+    title: parsed?.title !== undefined && parsed.title !== '' ? parsed.title : firstLine(source),
+    description: parsed?.description ?? '',
+    prompt: parsed?.prompt !== undefined && parsed.prompt !== '' ? parsed.prompt : source.trim(),
+  }
+}
+
+/**
+ * Parse one pasted text through the injected `llm` service.
+ * @param llm - the Host's llm service.
+ * @param request - pasted text plus the qualified model route.
+ * @param signal - caller cancellation (client disconnect); combined with the timeout.
+ * @returns the draft fields.
+ * @throws TaskParseError with a code the route maps onto a status.
+ */
+export async function parseTaskDraft(
+  llm: LlmRuntime,
+  request: TaskBoardParseRequest,
+  signal?: AbortSignal,
+): Promise<TaskBoardParseDraft> {
+  const text = request.text.trim()
+  if (text === '') throw new TaskParseError('parse-failed', 'there is nothing to parse')
+  const route = splitModelRoute(request.model)
+  if (route === undefined) throw new TaskParseError('no-model', 'no model route was selected for parsing')
+  const timeout = new AbortController()
+  const timer = setTimeout(() => { timeout.abort() }, TASK_PARSE_TIMEOUT_MS)
+  const abortFromCaller = (): void => { timeout.abort() }
+  signal?.addEventListener('abort', abortFromCaller, { once: true })
+  try {
+    const options: GenerateOptions = {
+      provider: route.provider,
+      model: route.model,
+      system: SYSTEM_PROMPT,
+      messages: [createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } })],
+      signal: timeout.signal,
+    }
+    let reply = ''
+    for await (const chunk of llm.stream(options)) {
+      if (chunk.type === 'text-delta') reply += chunk.text
+    }
+    return draftFromReply(reply, text)
+  } catch (error) {
+    if (error instanceof TaskParseError) throw error
+    if (timeout.signal.aborted) {
+      throw new TaskParseError('timeout', `the model did not answer within ${TASK_PARSE_TIMEOUT_MS / 1_000}s`)
+    }
+    throw new TaskParseError('model-error', error instanceof Error ? error.message : String(error))
+  } finally {
+    clearTimeout(timer)
+    signal?.removeEventListener('abort', abortFromCaller)
+  }
+}

package/src/host-ledger.ts

@@ -216,6 +216,16 @@ function ownProcessStartTimeMs(): number | undefined {
  */
 const LEGACY_START_TOLERANCE_MS = 2000
 
+/**
+ * How long an unreadable lock must sit untouched before it may be reclaimed.
+ * The owner writes and fsyncs its record immediately after creating the file
+ * with O_EXCL, so a lock that cannot be parsed may still be mid-write by a
+ * live owner; only one that has been unreadable for longer than any write can
+ * take is treated as an unclean-shutdown leftover (issue #1528: a 0-byte lock
+ * kept the Host half from mounting until it was deleted by hand).
+ */
+const UNREADABLE_LOCK_GRACE_MS = 60_000
+
 /** Whether the recorded start time proves the recorded PID is another process. */
 function startTimeMismatch(recorded: number, actual: number, exact: boolean): boolean {
   return exact ? recorded !== actual : Math.abs(recorded - actual) > LEGACY_START_TOLERANCE_MS
@@ -842,9 +852,21 @@ export class HostTaskLedger {
           if (typeof owner.startedAt === 'number') ownerStartedAt = owner.startedAt
           ownerExact = owner.probe === 'exact'
         } catch {
-          // A power-loss mid-write can leave a truncated lock; the same event
-          // killed the writer, so fail closed but explain the recovery.
-          throw new Error(`task-board ledger lock is unreadable: ${this.lockFile}; if this is a leftover from an unclean shutdown and no other DSH host is running, remove it manually and retry`)
+          // A power-loss mid-write can leave an empty or truncated lock. Such a
+          // lock still fails closed while it is fresh (a live owner may be
+          // mid-write); once it is older than the grace window nothing can be
+          // writing it, so the leftover is reclaimed instead of blocking every
+          // later start until someone deletes it by hand (issue #1528).
+          const age = (() => {
+            try { return this.now() - statSync(this.lockFile).mtimeMs } catch { return Number.POSITIVE_INFINITY }
+          })()
+          if (age < UNREADABLE_LOCK_GRACE_MS) {
+            throw new Error(`task-board ledger lock is unreadable: ${this.lockFile}; if this is a leftover from an unclean shutdown and no other DSH host is running, remove it manually and retry`)
+          }
+          try { unlinkSync(this.lockFile) } catch (unlinkError) {
+            if ((unlinkError as NodeJS.ErrnoException).code !== 'ENOENT') throw unlinkError
+          }
+          continue
         }
         if (pid !== undefined && processIsAlive(pid)) {
           const actualStartedAt = pid === process.pid ? ownProcessStartTimeMs() : processStartTimeMs(pid)

package/src/host-routes.ts

@@ -4,7 +4,14 @@ import type { WebRoute } from '@deepseek-ai/dsh-host-webserver'
 import type { TaskBoardHostService } from './host-service.ts'
 import { writeJson } from './http.ts'
 import { isLoopbackAddress, isLoopbackRequest } from './loopback.ts'
-import { parseActionEnvelope, TASK_BOARD_API_PREFIX } from './protocol.ts'
+import { TaskParseError, TASK_PARSE_MAX_INPUT } from './host-ai.ts'
+import {
+  parseActionEnvelope,
+  parseTaskParseRequest,
+  TASK_BOARD_API_PREFIX,
+  type TaskBoardParseDraft,
+  type TaskBoardParseRequest,
+} from './protocol.ts'
 
 const ACTION_LIMIT = 64 * 1024
 const IMPORT_LIMIT = 2 * 1024 * 1024
@@ -19,6 +26,16 @@ export interface TaskBoardRouteAccess {
   proxyToken?: string
 }
 
+/**
+ * Host faces the routes need beyond the ledger service. The parse face is
+ * resolved lazily by the caller, so a deployment without an llm service still
+ * registers the route and answers with a typed "no model" failure instead of
+ * leaving the panel with an unmounted path (issue #1540).
+ */
+export interface TaskBoardRouteOptions {
+  parseTask?: (request: TaskBoardParseRequest, signal: AbortSignal) => Promise<TaskBoardParseDraft>
+}
+
 interface ResolvedRouteAccess {
   trustedProxyHosts: ReadonlySet<string>
   proxyToken?: string
@@ -119,7 +136,11 @@ async function readBody(req: IncomingMessage): Promise<{ raw: string; value: unk
   return { raw, value: JSON.parse(raw) }
 }
 
-export function makeTaskBoardRoutes(service: TaskBoardHostService, access: TaskBoardRouteAccess = {}): WebRoute[] {
+export function makeTaskBoardRoutes(
+  service: TaskBoardHostService,
+  access: TaskBoardRouteAccess = {},
+  options: TaskBoardRouteOptions = {},
+): WebRoute[] {
   const resolvedAccess = resolveAccess(access)
   const guard = (req: IncomingMessage, res: ServerResponse): boolean => {
     if (isTrustedTaskBoardRequest(req, resolvedAccess)) return true
@@ -188,5 +209,49 @@ export function makeTaskBoardRoutes(service: TaskBoardHostService, access: TaskB
       push()
     },
   }
-  return [state, action, events]
+  const parse: WebRoute = {
+    kind: 'exact',
+    path: `${TASK_BOARD_API_PREFIX}/parse`,
+    handler: async (req, res): Promise<void> => {
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'method-not-allowed' }, { 'cache-control': 'no-store' })
+      if (!guard(req, res)) return
+      if (!(req.headers['content-type'] ?? '').toLowerCase().startsWith('application/json')) {
+        return writeJson(res, 415, { ok: false, error: 'json-required' }, { 'cache-control': 'no-store' })
+      }
+      let body: { raw: string; value: unknown }
+      try {
+        body = await readBody(req)
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        return writeJson(res, message === 'body-too-large' ? 413 : 400, { ok: false, error: message }, { 'cache-control': 'no-store' })
+      }
+      const request = parseTaskParseRequest(body.value)
+      if (request === undefined) return writeJson(res, 400, { ok: false, error: 'invalid-parse-request' }, { 'cache-control': 'no-store' })
+      if (Buffer.byteLength(request.text, 'utf8') > TASK_PARSE_MAX_INPUT) {
+        return writeJson(res, 413, { ok: false, error: 'text-too-large' }, { 'cache-control': 'no-store' })
+      }
+      const parseTask = options.parseTask
+      if (parseTask === undefined) {
+        return writeJson(res, 503, { ok: false, code: 'no-model', error: 'task-board parsing is unavailable' }, { 'cache-control': 'no-store' })
+      }
+      // The model call outlives a closed tab: stop it when the response goes
+      // away instead of holding the provider request open for the full timeout.
+      const controller = new AbortController()
+      const onClose = (): void => { controller.abort() }
+      res.once('close', onClose)
+      try {
+        const draft = await parseTask(request, controller.signal)
+        writeJson(res, 200, { ok: true, draft }, { 'cache-control': 'no-store' })
+      } catch (error) {
+        const failure = error instanceof TaskParseError
+          ? error
+          : new TaskParseError('model-error', error instanceof Error ? error.message : String(error))
+        const status = failure.code === 'no-model' ? 503 : failure.code === 'timeout' ? 504 : 502
+        writeJson(res, status, { ok: false, code: failure.code, error: failure.message }, { 'cache-control': 'no-store' })
+      } finally {
+        res.off('close', onClose)
+      }
+    },
+  }
+  return [state, action, events, parse]
 }

package/src/index.ts

@@ -15,7 +15,9 @@ import type {} from '@deepseek-ai/dsh-system-prompt'
 import type {} from '@deepseek-ai/dsh-api-gateway'
 import type {} from '@deepseek-ai/dsh-workspace'
 import type {} from '@deepseek-ai/dsh-host-webserver'
+import type { LlmRuntime } from '@deepseek-ai/dsh-llm'
 import { TaskBoardHostService } from './host-service.ts'
+import { parseTaskDraft, TaskParseError } from './host-ai.ts'
 import { TASK_PERMISSIONS, type TaskPermission } from './core/tasks.ts'
 import { DEFAULT_SESSION_PERMISSION } from './core/handover.ts'
 import { makeTaskBoardRoutes } from './host-routes.ts'
@@ -88,6 +90,22 @@ export function resolveProxyAccess(config: Config | undefined, env: NodeJS.Proce
 /** Schema default, re-read for hand-built test contexts (the loader applies them normally). */
 const DEFAULT_ANNOUNCE = false
 
+/**
+ * Read the optional `llm` service. The board deliberately does not inject it:
+ * a deployment without a model must still mount the board, and the parse route
+ * answers a typed failure instead of the plugin failing to load (issue #1540).
+ * @param ctx - the plugin context.
+ * @returns the llm service, or undefined when this deployment serves none.
+ */
+export function resolveLlmRuntime(ctx: Context): LlmRuntime | undefined {
+  try {
+    const llm = ctx.get('llm') as LlmRuntime | undefined
+    return llm !== undefined && typeof (llm as { stream?: unknown }).stream === 'function' ? llm : undefined
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * Register the board's announcement section, gated on the composition entry's
  * `announceToAgent` (and the live settings value once the web settings
@@ -115,7 +133,14 @@ function applyImpl(ctx: Context, config?: Config): void {
   ctx.effect(() => {
     const disposers: Array<() => void> = []
     try {
-      for (const route of makeTaskBoardRoutes(host, resolveProxyAccess(config))) disposers.push(ctx.webServer.register(route))
+      const routes = makeTaskBoardRoutes(host, resolveProxyAccess(config), {
+        parseTask: async (request, signal) => {
+          const llm = resolveLlmRuntime(ctx)
+          if (llm === undefined) throw new TaskParseError('no-model', 'this deployment serves no llm service')
+          return await parseTaskDraft(llm, request, signal)
+        },
+      })
+      for (const route of routes) disposers.push(ctx.webServer.register(route))
     } catch (error) {
       for (const dispose of disposers) dispose()
       host.dispose()

package/src/protocol.ts

@@ -49,6 +49,40 @@ export interface TaskBoardEventPayload {
   power: TaskBoardPowerSnapshot
 }
 
+/**
+ * Request body of `POST {TASK_BOARD_API_PREFIX}/parse` (issue #1540): the text
+ * the user pasted plus the `provider/model` route that should parse it.
+ */
+export interface TaskBoardParseRequest {
+  text: string
+  /** Qualified route from the model picker; absent when no route was chosen. */
+  model?: string
+}
+
+/** Draft fields a parse returns; the user reviews them before creating the task. */
+export interface TaskBoardParseDraft {
+  title: string
+  description: string
+  prompt: string
+}
+
+/** Strict parse of a `/parse` request body; undefined rejects the request. */
+export function parseTaskParseRequest(value: unknown): TaskBoardParseRequest | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const record = value as { text?: unknown; model?: unknown }
+  if (typeof record.text !== 'string' || record.text.trim() === '') return undefined
+  if (record.model !== undefined && typeof record.model !== 'string') return undefined
+  const model = typeof record.model === 'string' ? record.model.trim() : ''
+  return { text: record.text, ...(model === '' ? {} : { model }) }
+}
+
+/** Whether a decoded reply carries the three draft strings the form accepts. */
+export function isTaskParseDraft(value: unknown): value is TaskBoardParseDraft {
+  if (typeof value !== 'object' || value === null) return false
+  const record = value as { title?: unknown; description?: unknown; prompt?: unknown }
+  return typeof record.title === 'string' && typeof record.description === 'string' && typeof record.prompt === 'string'
+}
+
 export type TaskBoardAction =
   | { kind: 'import'; sourceId: string; tasks: TaskRecord[] }
   | { kind: 'create'; id: string; input: NewTaskInput }