@linxin666/dsh-client-ui-task-board 0.2.9 → 0.3.1

package/src/core/controller.ts

@@ -2,22 +2,17 @@
  * Board controller: the single owner of task-ledger state and view state.
  *
  * In production it projects the Host ledger and submits confirmed actions;
- * the legacy store/execution seams remain for v1 migration tests. It also
- * closes the board whenever the user navigates to a session.
+ * the legacy store seam remains for v1 migration tests. It also closes the
+ * board whenever the user navigates to a session.
  * Framework-free (structural runtime faces) so the whole orchestration is
  * unit-testable with fakes.
  *
  * The per use-case domain transitions (create/update/delete/schedule) live in
  * dedicated modules under core/use-cases and are applied here; the controller
- * owns only the orchestration seam (state, persistence, notify, execution,
- * navigation, reconciliation).
+ * owns only the orchestration seam (state, persistence, notify, navigation).
  */
-import type { ExecutionEvent, ExecutionService } from './execution.ts'
 import type { TaskStore } from './store.ts'
-import {
-  settleExecution, startExecution, withStatus,
-  type NewTaskInput, type TaskRecord, type TaskStatus,
-} from './tasks.ts'
+import { withStatus, type NewTaskInput, type TaskRecord, type TaskStatus } from './tasks.ts'
 import { applyArchiveTask, applyRestoreTask } from './use-cases/task-archive.ts'
 import { applyCreateTask } from './use-cases/task-create.ts'
 import { applyDeleteTask } from './use-cases/task-delete.ts'
@@ -45,15 +40,11 @@ export interface SessionsControllerFace {
 /** Controller dependencies (all swappable in tests). */
 export interface ControllerDeps {
   store: TaskStore
-  /** Legacy browser execution seam used only by isolated v1 tests. */
-  exec?: ExecutionService
   sessions: SessionsControllerFace
   /** Clock; defaults to Date.now. */
   now?: () => number
   /** Id minting; defaults to a random-uuid. */
   uuid?: () => string
-  /** Debounce (ms) for session-list-changed reconciles; defaults to 350. */
-  reconcileDebounceMs?: number
   /** Host-authoritative transport; absent keeps the legacy in-memory test path. */
   transport?: TaskBoardTransport
 }
@@ -147,7 +138,7 @@ export class BoardController {
   private remoteSubscribed = false
   private remoteInitialization: Promise<boolean> | undefined
 
-  /** @param deps - store, execution service, and the sessions navigation face. */
+  /** @param deps - store and the sessions navigation face. */
   constructor(private readonly deps: ControllerDeps) {
     this.now = deps.now ?? (() => Date.now())
     this.uuid = deps.uuid ?? randomUuid
@@ -158,11 +149,7 @@ export class BoardController {
   /** Load the persisted ledger and start the navigation/status subscriptions. */
   start(): void {
     this.tasks = this.deps.store.load()
-    if (this.deps.transport !== undefined) {
-      void this.initializeRemote()
-    } else {
-      void this.reconcileRunningTasks()
-    }
+    if (this.deps.transport !== undefined) void this.initializeRemote()
     // A sibling tab may have edited or deleted the ledger (same origin,
     // storage events). Reload on external change so a task deleted in
     // another tab stops firing here — and is never written back by this
@@ -182,8 +169,6 @@ export class BoardController {
   dispose(): void {
     for (const dispose of this.disposers.splice(0)) dispose()
     this.listeners.clear()
-    if (this.reconcileTimer !== undefined) clearTimeout(this.reconcileTimer)
-    this.reconcileTimer = undefined
   }
 
   // --- snapshot / subscription ------------------------------------------------
@@ -413,68 +398,30 @@ export class BoardController {
   // --- execution ---------------------------------------------------------------
 
   /**
-   * Execute a task for real: move it to 'running', open an execution record,
-   * and hand off to the ExecutionService. A second call while the task is
-   * already running is ignored.
+   * Request a Host execution for a task: the Host ledger owns the running
+   * transition, the execution record, and the settlement. A second call
+   * while the task is already running is ignored; without a Host transport
+   * the run is refused (returns false).
    */
   async runTask(id: string): Promise<boolean> {
     const task = this.tasks.find(candidate => candidate.id === id)
     if (task === undefined || task.archivedAt !== undefined || task.status === 'running') return false
-    if (this.deps.transport !== undefined) {
-      return await this.commitRemote({ kind: 'run', taskId: id }, id)
-    }
-    const { task: next, execution } = startExecution(task, this.now(), this.uuid())
-    this.tasks = this.tasks.map(candidate => candidate.id === id ? next : candidate)
-    this.persistAndNotify()
-    // This page owns the settlement of its own launches: the live watch
-    // (ExecutionService.run) settles on the turn boundary, and list
-    // reconciliation must not pre-empt it with a session that has not
-    // started a turn yet (its list row is idle, not completed).
-    this.activeExecutionIds.add(execution.id)
-    if (this.deps.exec === undefined) throw new Error('legacy execution service is unavailable')
-    await this.deps.exec.run(next, execution, (event) => { this.handleExecutionEvent(event) })
-    return true
+    if (this.deps.transport === undefined) return false
+    return await this.commitRemote({ kind: 'run', taskId: id }, id)
   }
 
-  /** Re-run a settled task: move it back to 'todo' first, then execute. */
+  /** Re-run a settled task through the Host (the Host replans and executes). */
   async rerunTask(id: string): Promise<void> {
     const task = this.tasks.find(candidate => candidate.id === id)
     if (task === undefined || task.archivedAt !== undefined) return
-    if (this.deps.transport !== undefined) {
-      await this.commitRemote({ kind: 'rerun', taskId: id }, id)
-      return
-    }
-    if (task.status !== 'running') {
-      this.tasks = this.tasks.map(candidate => candidate.id === id ? withStatus(candidate, 'todo', this.now()) : candidate)
-      this.persistAndNotify()
-    }
-    await this.runTask(id)
-  }
-
-  private handleExecutionEvent(event: ExecutionEvent): void {
-    if (event.kind === 'started') {
-      this.tasks = this.tasks.map(task => task.id === event.taskId
-        ? attachSessionId(task, event.executionId, event.sessionId, this.now())
-        : task)
-      this.persistAndNotify()
-      return
-    }
-    this.activeExecutionIds.delete(event.executionId)
-    this.tasks = this.tasks.map(task => task.id === event.taskId
-      ? settleExecution(task, event.executionId, event.outcome, this.now(), event.error)
-      : task)
-    this.persistAndNotify()
+    if (this.deps.transport === undefined) return
+    await this.commitRemote({ kind: 'rerun', taskId: id }, id)
   }
 
   // --- internals ---------------------------------------------------------------
 
-  /** Reconcile running tasks and close the board when the user navigates. */
+  /** Close the board when the user navigates to another session. */
   private onSessionsChanged(): void {
-    // Background/leftover executions settle through the session list (their
-    // conversation snapshots stay cold until opened). Coalesce the burst of
-    // list notifications into one reconcile pass instead of fanning out a
-    // history read per notification; see scheduleReconcile.
-    if (this.deps.transport === undefined) this.scheduleReconcile()
     if (!this.boardOpen) return
     const current = currentOf(this.deps.sessions)
     if (current !== this.lastCurrent) this.closeBoard()
@@ -483,74 +430,6 @@ export class BoardController {
 
   private lastCurrent: string | undefined = undefined
 
-  /** Execution ids launched on this page; they settle via their live watch, never list reconciliation. */
-  private readonly activeExecutionIds = new Set<string>()
-
-  /** Debounce timer for {@link reconcileRunningTasks}. */
-  private reconcileTimer: ReturnType<typeof setTimeout> | undefined = undefined
-
-  /** Whether a reconcile pass is underway (single-flight guard). */
-  private reconcileInFlight = false
-
-  /**
-   * Debounce + single-flight trigger for the running-task reconciliation.
-   * Session-list notifications arrive in bursts (one per session status
-   * change); both guards together keep a burst from reading the history API
-   * once per running task.
-   */
-  private scheduleReconcile(): void {
-    if (this.reconcileTimer !== undefined) return
-    this.reconcileTimer = setTimeout(() => {
-      this.reconcileTimer = undefined
-      void this.reconcileRunningTasks()
-    }, this.deps.reconcileDebounceMs ?? 350)
-  }
-
-  /** Settle tasks left 'running' whose sessions already finished. */
-  private async reconcileRunningTasks(): Promise<void> {
-    if (this.deps.exec === undefined) return
-    if (this.reconcileInFlight) {
-      // A session change arrived while a pass was in flight. The in-flight
-      // pass already captured the task list it iterates and will not revisit
-      // this task, so dropping the notification would leave it stuck
-      // 'running'. Re-arm the debounce so the change is reconciled once the
-      // current pass settles.
-      this.scheduleReconcile()
-      return
-    }
-    this.reconcileInFlight = true
-    try {
-      type Settled = Extract<ExecutionEvent, { kind: 'settled' }>
-      const events: Array<{ taskId: string; event: Settled }> = []
-      for (const task of this.tasks) {
-        if (task.status !== 'running') continue
-        const execution = task.executions[task.executions.length - 1]
-        // Runs launched on this page settle through their live watch (turn
-        // boundary); reconciliation exists for background/leftover runs.
-        if (execution !== undefined && this.activeExecutionIds.has(execution.id)) continue
-        const event = await this.deps.exec.reconcile(task)
-        if (event !== undefined && event.kind === 'settled') events.push({ taskId: task.id, event })
-      }
-      if (events.length === 0) return
-      let changed = false
-      for (const { taskId, event } of events) {
-        // The reconcile call above awaited: a sibling tab may have rewritten
-        // the ledger (storage event reload) meanwhile. Re-read the freshest
-        // record now so the stale task captured before the await can never
-        // overwrite fields the sibling wrote.
-        const task = this.tasks.find(candidate => candidate.id === taskId)
-        if (task === undefined) continue
-        const next = settleExecution(task, event.executionId, event.outcome, this.now(), event.error)
-        if (next === task) continue
-        this.tasks = this.tasks.map(candidate => candidate.id === taskId ? next : candidate)
-        changed = true
-      }
-      if (changed) this.persistAndNotify()
-    } finally {
-      this.reconcileInFlight = false
-    }
-  }
-
   private persistAndNotify(): void {
     if (this.deps.transport === undefined) this.deps.store.save(this.tasks)
     this.notify()
@@ -676,18 +555,3 @@ export class BoardController {
     for (const fn of [...this.listeners]) fn()
   }
 }
-
-/** Record which session ran an execution (once the execution service reports it). */
-function attachSessionId(
-  task: TaskRecord,
-  executionId: string,
-  sessionId: string,
-  now: number,
-): TaskRecord {
-  return {
-    ...task,
-    updatedAt: now,
-    executions: task.executions.map(execution =>
-      execution.id === executionId ? { ...execution, sessionId } : execution),
-  }
-}

package/src/core/tasks.ts

@@ -28,6 +28,27 @@ export interface ExecutionRecord {
   error: string | undefined
 }
 
+/**
+ * Maximum number of execution records retained per task. Older settled runs
+ * are trimmed when a new execution starts so per-action ledger cost stays
+ * bounded regardless of how often a task ran before.
+ */
+export const EXECUTION_HISTORY_LIMIT = 20
+
+/**
+ * Trim an execution list to at most {@link EXECUTION_HISTORY_LIMIT} records,
+ * most recent last. A running (unsettled) execution is never trimmed: the
+ * Host monitor and restart recovery depend on the active record, and a task
+ * cannot start a new run while one is still open.
+ */
+export function retainRecentExecutions(executions: readonly ExecutionRecord[]): ExecutionRecord[] {
+  if (executions.length <= EXECUTION_HISTORY_LIMIT) return [...executions]
+  const open = executions.filter(execution => execution.endedAt === undefined)
+  const settled = executions.filter(execution => execution.endedAt !== undefined)
+  const keepSettled = Math.max(EXECUTION_HISTORY_LIMIT - open.length, 0)
+  return [...settled.slice(Math.max(settled.length - keepSettled, 0)), ...open]
+}
+
 /**
  * A scheduled-run rule attached to a task. The Host scheduler triggers the
  * task when `nextRunAt` is due and persists the rule in the Host ledger.
@@ -59,7 +80,10 @@ export interface TaskRecord {
   createdAt: number
   /** Last mutation instant (ms epoch). */
   updatedAt: number
-  /** Every execution attempt, most recent last. */
+  /**
+   * Execution history retained on the task, most recent last: the latest
+   * {@link EXECUTION_HISTORY_LIMIT} attempts, oldest trimmed on append.
+   */
   executions: ExecutionRecord[]
   /** Optional scheduled-run rule (absent on tasks without a schedule). */
   schedule?: ScheduleRule
@@ -221,7 +245,12 @@ export function startExecution(
     error: undefined,
   }
   return {
-    task: { ...task, status: 'running', updatedAt: now, executions: [...task.executions, execution] },
+    task: {
+      ...task,
+      status: 'running',
+      updatedAt: now,
+      executions: retainRecentExecutions([...task.executions, execution]),
+    },
     execution,
   }
 }

package/src/host-ledger.ts

@@ -5,7 +5,7 @@ import { dirname, join } from 'node:path'
 import { dshHome } from './dsh-home.ts'
 import { isValidCron, nextRunAtMs } from './core/schedule.ts'
 import { parseLedger } from './core/store.ts'
-import { canMoveManually, settleExecution, startExecution, withStatus, type ExecutionRecord, type TaskRecord } from './core/tasks.ts'
+import { canMoveManually, retainRecentExecutions, settleExecution, startExecution, withStatus, type ExecutionRecord, type TaskRecord } from './core/tasks.ts'
 import { applyArchiveTask, applyRestoreTask } from './core/use-cases/task-archive.ts'
 import { applyCreateTask } from './core/use-cases/task-create.ts'
 import { applyDeleteTask } from './core/use-cases/task-delete.ts'
@@ -232,7 +232,8 @@ function mergeTask(a: TaskRecord, b: TaskRecord): TaskRecord {
     const previous = byId.get(entry.id)
     byId.set(entry.id, previous === undefined ? entry : betterExecution(previous, entry))
   }
-  return { ...newer, executions: [...byId.values()].sort((x, y) => x.startedAt - y.startedAt) }
+  const executions = [...byId.values()].sort((x, y) => x.startedAt - y.startedAt)
+  return { ...newer, executions: retainRecentExecutions(executions) }
 }
 
 function parseHostTasks(values: readonly unknown[]): TaskRecord[] {
@@ -574,7 +575,7 @@ export class HostTaskLedger {
     try {
       const parsed = JSON.parse(readFileSync(this.file, 'utf8')) as Partial<LedgerDocument>
       if (parsed.schemaVersion !== TASK_BOARD_SCHEMA_VERSION || !Array.isArray(parsed.tasks)) throw new Error('unsupported ledger schema')
-      const tasks = parseHostTasks(parsed.tasks)
+      const tasks = parseHostTasks(parsed.tasks).map(task => ({ ...task, executions: retainRecentExecutions(task.executions) }))
       const invalidScheduleIds = (parsed.tasks as unknown[]).flatMap(value => {
         if (typeof value !== 'object' || value === null) return []
         const row = value as { id?: unknown; schedule?: unknown }

package/src/host-routes.ts

@@ -2,6 +2,7 @@ import { timingSafeEqual } from 'node:crypto'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 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'
 
@@ -23,11 +24,6 @@ interface ResolvedRouteAccess {
   proxyToken?: string
 }
 
-function json(res: ServerResponse, status: number, body: unknown): void {
-  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
-  res.end(JSON.stringify(body))
-}
-
 function parseAuthority(authority: string): { canonical: string; url: URL } | undefined {
   if (authority.trim() !== authority) return undefined
   const match = authority.startsWith('[')
@@ -127,38 +123,38 @@ export function makeTaskBoardRoutes(service: TaskBoardHostService, access: TaskB
   const resolvedAccess = resolveAccess(access)
   const guard = (req: IncomingMessage, res: ServerResponse): boolean => {
     if (isTrustedTaskBoardRequest(req, resolvedAccess)) return true
-    json(res, 403, { ok: false, error: 'forbidden' })
+    writeJson(res, 403, { ok: false, error: 'forbidden' }, { 'cache-control': 'no-store' })
     return false
   }
   const state: WebRoute = {
     kind: 'exact',
     path: `${TASK_BOARD_API_PREFIX}/state`,
     handler: (req, res): void => {
-      if (req.method !== 'GET') return json(res, 405, { ok: false, error: 'method-not-allowed' })
+      if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'method-not-allowed' }, { 'cache-control': 'no-store' })
       if (!guard(req, res)) return
-      json(res, 200, service.snapshot())
+      writeJson(res, 200, service.snapshot(), { 'cache-control': 'no-store' })
     },
   }
   const action: WebRoute = {
     kind: 'exact',
     path: `${TASK_BOARD_API_PREFIX}/action`,
     handler: async (req, res): Promise<void> => {
-      if (req.method !== 'POST') return json(res, 405, { ok: false, error: 'method-not-allowed' })
+      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 json(res, 415, { ok: false, error: 'json-required' })
+        return writeJson(res, 415, { ok: false, error: 'json-required' }, { 'cache-control': 'no-store' })
       }
       try {
         const body = await readBody(req)
         const parsed = parseActionEnvelope(body.value)
-        if (parsed === undefined) return json(res, 400, { ok: false, error: 'invalid-action' })
+        if (parsed === undefined) return writeJson(res, 400, { ok: false, error: 'invalid-action' }, { 'cache-control': 'no-store' })
         if (parsed.action.kind !== 'import' && Buffer.byteLength(body.raw) > ACTION_LIMIT) {
-          return json(res, 413, { ok: false, error: 'body-too-large' })
+          return writeJson(res, 413, { ok: false, error: 'body-too-large' }, { 'cache-control': 'no-store' })
         }
-        json(res, 200, service.apply(parsed.requestId, parsed.action))
+        writeJson(res, 200, service.apply(parsed.requestId, parsed.action), { 'cache-control': 'no-store' })
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
-        json(res, message === 'body-too-large' ? 413 : 400, { ok: false, error: message })
+        writeJson(res, message === 'body-too-large' ? 413 : 400, { ok: false, error: message }, { 'cache-control': 'no-store' })
       }
     },
   }

package/src/host-service.ts

@@ -1,6 +1,5 @@
 import type { ApiProxy } from '@deepseek-ai/dsh-host-apiproxy'
 import { nextRunAtMs } from './core/schedule.ts'
-import type { TaskRecord } from './core/tasks.ts'
 import { HostTaskLedger, type OpenedRun, type OpenExecutionReference } from './host-ledger.ts'
 import { HostExecutionRunner, SessionLaunchError, type SessionCommandDispatcher, type SessionSummary } from './host-runner.ts'
 import { PowerInhibitor } from './power-inhibitor.ts'

package/src/http.ts

@@ -0,0 +1,105 @@
+// Generated by scripts/sync-shared.mjs from shared/host/http.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * Shared JSON body/response helpers for the host route families: one strict
+ * bounded body reader, one lenient bounded body reader, one JSON object
+ * narrow, and one JSON writer. Previously these were copy-pasted across the
+ * package route files (routes.ts, update-routes.ts, mobile-api.ts, and each
+ * family's route module) with drifting contracts: body caps ranging 4 KiB to
+ * 1 MiB and four distinct overflow behaviors (reject, undefined, null, throw).
+ *
+ * Packages receive this file as a generated copy via scripts/sync-shared.mjs;
+ * edit this shared source and re-run the sync instead of editing a copy.
+ * Consumer code is migrated onto it in follow-up waves; no call site changes
+ * belong in the same change as its introduction.
+ * @module dsh-web-ui-shared/host/http
+ */
+
+import type { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from 'node:http'
+
+/** Default body cap for readJsonBody: 64 KiB. */
+const DEFAULT_JSON_BODY_MAX_BYTES = 64 * 1024
+
+/** Family-default JSON response headers; callers may append or override. */
+const JSON_HEADERS = {
+  'content-type': 'application/json; charset=utf-8',
+  'referrer-policy': 'no-referrer',
+} satisfies OutgoingHttpHeaders
+
+/**
+ * Strict bounded body reader: parse a request body of at most maxBytes as
+ * JSON.
+ * @throws 'body too large' past the cap, or the JSON.parse error for an
+ *   invalid or empty payload.
+ */
+export async function readBoundedJson(req: IncomingMessage, maxBytes: number): Promise<unknown> {
+  const chunks: Buffer[] = []
+  let size = 0
+  for await (const chunk of req) {
+    const buffer = chunk as Buffer
+    size += buffer.length
+    if (size > maxBytes) throw new Error('body too large')
+    chunks.push(buffer)
+  }
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+}
+
+/**
+ * Lenient bounded body reader: parse a request body as JSON, or null on an
+ * empty body, invalid JSON, or a body past maxBytes (default 64 KiB).
+ * Overflow destroys the request instead of draining the remainder (no drain
+ * call, matching the current repo-wide behavior); callers must not keep
+ * reading the request afterwards. With objectOnly, non-JSON-object payloads
+ * also yield null.
+ */
+export async function readJsonBody(
+  req: IncomingMessage,
+  opts: { maxBytes?: number; objectOnly?: boolean } = {},
+): Promise<unknown | null> {
+  const maxBytes = opts.maxBytes ?? DEFAULT_JSON_BODY_MAX_BYTES
+  const chunks: Buffer[] = []
+  let size = 0
+  for await (const chunk of req) {
+    const buffer = chunk as Buffer
+    size += buffer.length
+    if (size > maxBytes) {
+      req.destroy()
+      return null
+    }
+    chunks.push(buffer)
+  }
+  const text = Buffer.concat(chunks).toString('utf8')
+  if (text === '') return null
+  try {
+    const parsed: unknown = JSON.parse(text)
+    if (opts.objectOnly && !isJsonObject(parsed)) return null
+    return parsed
+  } catch {
+    return null
+  }
+}
+
+/** Whether a value is a JSON object: typeof object, not null, not an array. */
+function isJsonObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/** Narrow a value to a JSON object, or undefined when it is not one. */
+export function asJsonObject(value: unknown): Record<string, unknown> | undefined {
+  return isJsonObject(value) ? value : undefined
+}
+
+/**
+ * Write one JSON response. Default headers are the family defaults
+ * (content-type and referrer-policy); caller headers are appended or
+ * override them.
+ */
+export function writeJson(
+  res: ServerResponse,
+  status: number,
+  body: unknown,
+  headers: OutgoingHttpHeaders = {},
+): void {
+  const payload = JSON.stringify(body)
+  res.writeHead(status, { ...JSON_HEADERS, ...headers })
+  res.end(payload)
+}