@yeaft/webchat-agent 1.0.210 → 1.0.212

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.210",
+  "version": "1.0.212",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/mcp.js

@@ -141,8 +141,17 @@ class MCPServerConnection extends EventEmitter {
    */
   async start() {
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(`MCP server "${this.#name}" startup timeout (${STARTUP_TIMEOUT_MS}ms)`));
+      let settled = false;
+      let timer = null;
+      const failStart = async (err) => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        await this.stop();
+        reject(err);
+      };
+      timer = setTimeout(() => {
+        void failStart(new Error(`MCP server "${this.#name}" startup timeout (${STARTUP_TIMEOUT_MS}ms)`));
       }, STARTUP_TIMEOUT_MS);
 
       try {
@@ -181,23 +190,22 @@ class MCPServerConnection extends EventEmitter {
         });
 
         this.#process.on('error', (err) => {
-          clearTimeout(timer);
-          reject(err);
+          void failStart(err);
         });
 
         // Initialize MCP protocol
         this.#initialize().then(() => {
+          if (settled) return;
+          settled = true;
           clearTimeout(timer);
           this.#ready = true;
           resolve();
         }).catch((err) => {
-          clearTimeout(timer);
-          reject(err);
+          void failStart(err);
         });
 
       } catch (err) {
-        clearTimeout(timer);
-        reject(err);
+        void failStart(err);
       }
     });
   }
@@ -319,23 +327,27 @@ class MCPServerConnection extends EventEmitter {
    * Stop the MCP server process.
    */
   async stop() {
-    if (this.#process) {
-      this.#ready = false;
-      this.#process.kill('SIGTERM');
-      // Wait a bit then force kill. Test fakes do not emit close, so cap the
-      // wait at 2s and do not require a close event for cleanup to finish.
-      await Promise.race([
-        new Promise(resolve => {
-          if (this.#closed) return resolve();
-          this.#process.once('close', resolve);
-        }),
-        new Promise(resolve => setTimeout(resolve, 2000)),
-      ]);
-      if (this.#process && !this.#process.killed && !this.#closed) {
-        this.#process.kill('SIGKILL');
-      }
-      this.#process = null;
+    const child = this.#process;
+    if (!child) return;
+
+    this.#ready = false;
+    let closed = this.#closed;
+    if (!closed) {
+      child.kill('SIGTERM');
+      closed = await new Promise(resolve => {
+        let timer = null;
+        const finish = (didClose) => {
+          if (timer) clearTimeout(timer);
+          child.removeListener('close', onClose);
+          resolve(didClose);
+        };
+        const onClose = () => finish(true);
+        child.once('close', onClose);
+        timer = setTimeout(() => finish(false), 2000);
+      });
+      if (!closed) child.kill('SIGKILL');
     }
+    if (this.#process === child) this.#process = null;
   }
 }
 

package/yeaft/work-center/projection.js

@@ -42,6 +42,77 @@ function projectCurrentActionSummary(action, projectedAction = action) {
     assignmentMode: projectedAction.assignmentPolicy?.mode || (projectedAction.requiredRole ? 'fixed' : null),
     status: projectedAction.status,
     objective: truncateUtf8(action?.brief?.objective, 1_000) || null,
+    ...(projectedAction.assignedVp ? { assignedVp: projectedAction.assignedVp } : {}),
+  };
+}
+
+const BOARD_ACTION_STATUSES = ['completed', 'running', 'ready', 'waiting', 'failed'];
+
+function boardActionCounts(actions) {
+  const counts = Object.fromEntries(BOARD_ACTION_STATUSES.map(status => [status, 0]));
+  for (const action of Array.isArray(actions) ? actions : []) {
+    if (Object.hasOwn(counts, action?.status)) counts[action.status] += 1;
+  }
+  return counts;
+}
+
+export function workItemBoardLane(detail) {
+  const actions = (Array.isArray(detail?.actions) ? detail.actions : [])
+    .filter(action => !['superseded', 'cancelled'].includes(action?.status));
+  if (['done', 'cancelled'].includes(detail?.status)) return 'closed';
+  if (['draft', 'waiting', 'needs_attention'].includes(detail?.status)
+      || actions.some(action => ['waiting', 'failed'].includes(action?.status))) {
+    return 'needs_attention';
+  }
+  return 'active';
+}
+
+function boardActionSummary(action, runs, events) {
+  if (!action) return null;
+  const projected = projectAction(action, runs, events, false);
+  return {
+    id: projected.id,
+    type: projected.type,
+    stageId: projected.stageId,
+    status: projected.status,
+    objective: truncateUtf8(action?.brief?.objective, 1_000) || null,
+    assignedVp: projected.assignedVp || null,
+  };
+}
+
+function boardFields(detail) {
+  const actions = (Array.isArray(detail?.actions) ? detail.actions : [])
+    .filter(action => !['superseded', 'cancelled'].includes(action?.status));
+  const runs = Array.isArray(detail?.runs) ? detail.runs : [];
+  const events = Array.isArray(detail?.events) ? detail.events : [];
+  const bySequence = (left, right) => count(left?.sequence) - count(right?.sequence)
+    || String(left?.id || '').localeCompare(String(right?.id || ''));
+  const attentionAction = [...actions]
+    .filter(action => ['waiting', 'failed'].includes(action?.status))
+    .sort((left, right) => {
+      const priority = { waiting: 0, failed: 1 };
+      return priority[left.status] - priority[right.status] || bySequence(left, right);
+    })[0] || null;
+  const activeAction = [...actions]
+    .filter(action => ['running', 'ready'].includes(action?.status))
+    .sort((left, right) => {
+      const priority = { running: 0, ready: 1 };
+      return priority[left.status] - priority[right.status] || bySequence(left, right);
+    })[0] || null;
+  const executors = [];
+  const seenExecutors = new Set();
+  for (const action of actions) {
+    const assignedVp = projectAction(action, runs, events, false).assignedVp;
+    if (!assignedVp?.id || seenExecutors.has(assignedVp.id)) continue;
+    seenExecutors.add(assignedVp.id);
+    executors.push(assignedVp);
+  }
+  return {
+    boardLane: workItemBoardLane({ ...detail, actions }),
+    actionCounts: boardActionCounts(actions),
+    attentionAction: boardActionSummary(attentionAction, runs, events),
+    activeAction: boardActionSummary(activeAction, runs, events),
+    executors,
   };
 }
 
@@ -673,6 +744,11 @@ export function projectWorkItemSummary(detail) {
       attachmentCount: Array.isArray(detail.attachments) ? detail.attachments.length : 0,
       createdAt: detail.createdAt,
       updatedAt: detail.updatedAt,
+      boardLane: detail.boardLane || workItemBoardLane(detail),
+      actionCounts: detail.actionCounts || boardActionCounts([]),
+      attentionAction: detail.attentionAction || null,
+      activeAction: detail.activeAction || null,
+      executors: Array.isArray(detail.executors) ? detail.executors : [],
     };
   }
   const action = currentAction(detail);
@@ -704,6 +780,7 @@ export function projectWorkItemSummary(detail) {
     attachmentCount: Array.isArray(detail.attachments) ? detail.attachments.length : 0,
     createdAt: detail.createdAt,
     updatedAt: detail.updatedAt,
+    ...boardFields(detail),
   };
 }
 

package/yeaft/work-center/service.js

@@ -44,6 +44,44 @@ function requiredWorkDir(value) {
   return canonical;
 }
 
+function boardCursor(item) {
+  return Buffer.from(JSON.stringify([Number(item.updatedAt) || 0, String(item.id || '')]), 'utf8')
+    .toString('base64url');
+}
+
+function parseBoardCursor(value) {
+  if (typeof value !== 'string' || !value) return null;
+  try {
+    const parsed = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+    if (!Array.isArray(parsed) || parsed.length !== 2 || !Number.isFinite(Number(parsed[0]))) return null;
+    return [Number(parsed[0]), String(parsed[1] || '')];
+  } catch {
+    return null;
+  }
+}
+
+function listBoardItems(store, payload) {
+  const limit = Math.min(Math.max(Number(payload.limit) || 100, 1), 200);
+  const cursor = parseBoardCursor(payload.cursor);
+  const lane = ['needs_attention', 'active', 'closed'].includes(payload.lane) ? payload.lane : null;
+  const vpId = typeof payload.vpId === 'string' ? payload.vpId.trim() : '';
+  const workItemType = typeof payload.workItemType === 'string' ? payload.workItemType.trim() : '';
+  const projected = store.listWorkItems({
+    ...payload,
+    lane,
+    vpId,
+    workItemType,
+    cursorUpdatedAt: cursor?.[0],
+    cursorId: cursor?.[1],
+    limit: limit + 1,
+  }).map(projectWorkItemSummary);
+  const items = projected.slice(0, limit);
+  return {
+    items,
+    nextCursor: projected.length > limit && items.length > 0 ? boardCursor(items.at(-1)) : null,
+  };
+}
+
 export class WorkCenterService {
   constructor(options) {
     const yeaftDir = requiredString(options?.yeaftDir, 'yeaftDir');
@@ -83,11 +121,13 @@ export class WorkCenterService {
 
   async handle(op, payload = {}, requestContext = {}) {
     switch (op) {
-      case 'list':
+      case 'list': {
+        const page = listBoardItems(this.store, payload);
         return {
-          items: this.store.listWorkItems(payload).map(projectWorkItemSummary),
+          ...page,
           watcher: this.watcher.status(),
         };
+      }
       case 'get':
         return this.#requiredItem(payload.id);
       case 'get_action_messages': {

package/yeaft/work-center/store.js

@@ -1192,11 +1192,55 @@ export class WorkItemStore {
       where.push('(instr(w.origin, ?) > 0 OR instr(w.linked_session_ids, ?) > 0)');
       values.push(`\"sessionId\":${JSON.stringify(sessionId)}`, JSON.stringify(sessionId));
     }
-    if (typeof filters.search === 'string' && filters.search.trim()) {
+    const keyword = typeof filters.keyword === 'string' ? filters.keyword.trim()
+      : typeof filters.search === 'string' ? filters.search.trim() : '';
+    if (keyword) {
       where.push('(w.title LIKE ? OR w.goal LIKE ?)');
-      const query = `%${filters.search.trim()}%`;
+      const query = `%${keyword}%`;
       values.push(query, query);
     }
+    const createdFrom = Number(filters.createdFrom);
+    const createdTo = Number(filters.createdTo);
+    const updatedFrom = Number(filters.updatedFrom);
+    const updatedTo = Number(filters.updatedTo);
+    if (Number.isFinite(createdFrom) && createdFrom > 0) { where.push('w.created_at >= ?'); values.push(createdFrom); }
+    if (Number.isFinite(createdTo) && createdTo > 0) { where.push('w.created_at <= ?'); values.push(createdTo); }
+    if (Number.isFinite(updatedFrom) && updatedFrom > 0) { where.push('w.updated_at >= ?'); values.push(updatedFrom); }
+    if (Number.isFinite(updatedTo) && updatedTo > 0) { where.push('w.updated_at <= ?'); values.push(updatedTo); }
+    if (typeof filters.workItemType === 'string' && filters.workItemType.trim()) {
+      where.push('instr(w.workflow_snapshot, ?) > 0');
+      values.push(`\"workItemType\":${JSON.stringify(filters.workItemType.trim())}`);
+    }
+    if (typeof filters.vpId === 'string' && filters.vpId.trim()) {
+      where.push(`EXISTS (SELECT 1 FROM actions executor_action
+        JOIN runs executor_run ON executor_run.id = (
+          SELECT latest_executor_run.id FROM runs latest_executor_run
+          WHERE latest_executor_run.action_id = executor_action.id
+          ORDER BY latest_executor_run.started_at DESC, latest_executor_run.progress_revision DESC
+          LIMIT 1)
+        WHERE executor_action.work_item_id = w.id
+          AND executor_action.status NOT IN ('superseded', 'cancelled')
+          AND instr(executor_run.vp_snapshot, ?) > 0)`);
+      values.push(`\"id\":${JSON.stringify(filters.vpId.trim())}`);
+    }
+    if (filters.lane === 'closed') {
+      where.push("w.status IN ('done', 'cancelled')");
+    } else if (filters.lane === 'needs_attention') {
+      where.push(`w.status NOT IN ('done', 'cancelled') AND (
+        w.status IN ('draft', 'waiting', 'needs_attention') OR EXISTS (
+          SELECT 1 FROM actions attention_action WHERE attention_action.work_item_id = w.id
+            AND attention_action.status IN ('waiting', 'failed')))`);
+    } else if (filters.lane === 'active') {
+      where.push(`w.status NOT IN ('done', 'cancelled', 'draft', 'waiting', 'needs_attention')
+        AND NOT EXISTS (SELECT 1 FROM actions attention_action WHERE attention_action.work_item_id = w.id
+          AND attention_action.status IN ('waiting', 'failed'))`);
+    }
+    const cursorUpdatedAt = Number(filters.cursorUpdatedAt);
+    const cursorId = typeof filters.cursorId === 'string' ? filters.cursorId : '';
+    if (Number.isFinite(cursorUpdatedAt) && cursorUpdatedAt >= 0 && cursorId) {
+      where.push('(w.updated_at < ? OR (w.updated_at = ? AND w.id < ?))');
+      values.push(cursorUpdatedAt, cursorUpdatedAt, cursorId);
+    }
     const limit = Math.min(Math.max(Number(filters.limit) || 100, 1), 500);
     const sql = `SELECT w.*,
         current_action.type AS current_action_type,
@@ -1219,12 +1263,24 @@ export class WorkItemStore {
       LEFT JOIN actions current_action ON current_action.id = w.current_action_id
       LEFT JOIN runs r ON r.work_item_id = w.id
       ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
-      GROUP BY w.id ORDER BY w.updated_at DESC LIMIT ?`;
-    return this.db.prepare(sql).all(...values, limit).map(mapWorkItem).map(workItem => {
-      if (!isGraphWorkItem(workItem)) return workItem;
-      const actions = this.db.prepare('SELECT * FROM actions WHERE work_item_id = ? ORDER BY sequence')
-        .all(workItem.id).map(mapAction);
-      return graphExecutionState(workItem, actions);
+      GROUP BY w.id ORDER BY w.updated_at DESC, w.id DESC LIMIT ?`;
+    const workItems = this.db.prepare(sql).all(...values, limit).map(mapWorkItem);
+    if (workItems.length === 0) return [];
+    const placeholders = workItems.map(() => '?').join(',');
+    const ids = workItems.map(item => item.id);
+    const actionsByWorkItem = new Map(ids.map(id => [id, []]));
+    for (const row of this.db.prepare(`SELECT * FROM actions WHERE work_item_id IN (${placeholders})
+      ORDER BY work_item_id, sequence`).all(...ids)) {
+      actionsByWorkItem.get(row.work_item_id).push(mapAction(row));
+    }
+    const runsByWorkItem = new Map(ids.map(id => [id, []]));
+    for (const row of this.db.prepare(`SELECT * FROM runs WHERE work_item_id IN (${placeholders})
+      ORDER BY work_item_id, started_at DESC`).all(...ids)) {
+      runsByWorkItem.get(row.work_item_id).push(mapRun(row));
+    }
+    return workItems.map(workItem => {
+      const actions = actionsByWorkItem.get(workItem.id) || [];
+      return graphExecutionState({ ...workItem, actions, runs: runsByWorkItem.get(workItem.id) || [] }, actions);
     });
   }