@yeaft/webchat-agent 0.1.1031 → 0.1.1033

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.1031",
+  "version": "0.1.1033",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/yeaft/config.js

@@ -498,31 +498,128 @@ export function loadConfig(overrides = {}) {
 /**
  * Load MCP server configuration.
  *
- * Reads from config.json "mcpServers" field first, then falls back to
- * standalone ~/.yeaft/mcp.json for backward compatibility.
+ * Merges two tiers, in priority order (highest first):
+ *   1. global  — ~/.yeaft authoritative config: config.json "mcpServers"
+ *      array, else standalone ~/.yeaft/mcp.json ({ servers: [...] }).
+ *   2. project — `<workDir>/.mcp.json` (Claude Code standard location), so a
+ *      project that integrates Claude Code works out of the box. Supplementary:
+ *      a project server whose name collides with a global one is dropped (the
+ *      explicit ~/.yeaft config wins).
  *
  * @param {string} yeaftDir
  * @param {object} [jsonConfig] — Already-parsed config.json (optional, avoids re-read)
- * @returns {{ servers: object[] }}
+ * @param {string} [workDir] — optional project working directory (project tier root)
+ * @returns {{ servers: object[], skipped: { name: string, reason: string, source: string }[] }}
+ */
+export function loadMCPConfig(yeaftDir, jsonConfig, workDir) {
+  // ── Global tier: ~/.yeaft authoritative config ──
+  const globalServers = loadGlobalMCPServers(yeaftDir, jsonConfig);
+
+  // ── Project tier: <workDir>/.mcp.json (Claude Code standard) ──
+  const project = workDir
+    ? loadProjectMCPServers(workDir)
+    : { servers: [], skipped: [] };
+
+  // Dedup: global (~/.yeaft explicit config) wins over project supplements.
+  const seen = new Set(globalServers.map(s => s.name));
+  const servers = [...globalServers];
+  for (const s of project.servers) {
+    if (seen.has(s.name)) continue;
+    seen.add(s.name);
+    servers.push(s);
+  }
+
+  return { servers, skipped: project.skipped };
+}
+
+/**
+ * Load the global (~/.yeaft) MCP server list.
+ *
+ * Reads from config.json "mcpServers" field first, then falls back to
+ * standalone ~/.yeaft/mcp.json for backward compatibility. Returns a plain
+ * array (not wrapped) so `loadMCPConfig` can merge tiers.
+ *
+ * @param {string} yeaftDir
+ * @param {object} [jsonConfig]
+ * @returns {object[]}
  */
-export function loadMCPConfig(yeaftDir, jsonConfig) {
+function loadGlobalMCPServers(yeaftDir, jsonConfig) {
   // Check config.json mcpServers field
   if (jsonConfig && Array.isArray(jsonConfig.mcpServers)) {
     const valid = jsonConfig.mcpServers.filter(s => s.name && s.command);
-    if (valid.length > 0) return { servers: valid };
+    if (valid.length > 0) return valid;
   }
 
   // Fallback: standalone mcp.json
   const mcpPath = join(yeaftDir, 'mcp.json');
-  if (!existsSync(mcpPath)) return { servers: [] };
+  if (!existsSync(mcpPath)) return [];
 
   try {
     const raw = readFileSync(mcpPath, 'utf8');
     const parsed = JSON.parse(raw);
-    if (!parsed.servers || !Array.isArray(parsed.servers)) return { servers: [] };
-    const valid = parsed.servers.filter(s => s.name && s.command);
-    return { servers: valid };
+    if (!parsed.servers || !Array.isArray(parsed.servers)) return [];
+    return parsed.servers.filter(s => s.name && s.command);
   } catch {
-    return { servers: [] };
+    return [];
   }
 }
+
+/**
+ * Parse a project's Claude Code MCP config at `<workDir>/.mcp.json`.
+ *
+ * Format (Claude Code standard):
+ *   { "mcpServers": { "<name>": { command, args?, env?, url?, type? } } }
+ *
+ * Only stdio servers (those with a `command`) are adapted into yeaft's
+ * { name, command, args?, env? } shape. SSE/HTTP servers (url/type, no
+ * command) cannot be spawned by the current MCPManager, so they're reported
+ * in `skipped` with reason 'unsupported-transport' rather than silently
+ * dropped or surfaced later as spawn failures.
+ *
+ * Robust by design: a missing file, malformed JSON, or a non-object
+ * `mcpServers` field all return gracefully with empty arrays — a broken
+ * project `.mcp.json` must never fail session creation.
+ *
+ * @param {string} workDir — project working directory
+ * @returns {{ servers: object[], skipped: { name: string, reason: string, source: string }[] }}
+ */
+export function loadProjectMCPServers(workDir) {
+  const empty = { servers: [], skipped: [] };
+  if (!workDir || typeof workDir !== 'string') return empty;
+
+  const mcpPath = join(workDir, '.mcp.json');
+  if (!existsSync(mcpPath)) return empty;
+
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(mcpPath, 'utf8'));
+  } catch {
+    return empty;
+  }
+
+  const mcpServers = parsed && parsed.mcpServers;
+  if (!mcpServers || typeof mcpServers !== 'object' || Array.isArray(mcpServers)) {
+    return empty;
+  }
+
+  const servers = [];
+  const skipped = [];
+  for (const [name, raw] of Object.entries(mcpServers)) {
+    if (!name || !raw || typeof raw !== 'object') continue;
+    if (typeof raw.command === 'string' && raw.command.length > 0) {
+      // stdio server → adapt to yeaft shape
+      const server = { name, command: raw.command };
+      if (Array.isArray(raw.args)) server.args = raw.args;
+      if (raw.env && typeof raw.env === 'object') server.env = raw.env;
+      servers.push(server);
+    } else if (typeof raw.url === 'string' || typeof raw.type === 'string') {
+      // SSE/HTTP transport — not spawnable by current MCPManager.
+      skipped.push({ name, reason: 'unsupported-transport', source: '.mcp.json' });
+    } else {
+      // No command and no url/type — malformed entry.
+      skipped.push({ name, reason: 'invalid-config', source: '.mcp.json' });
+    }
+  }
+
+  return { servers, skipped };
+}

package/yeaft/engine.js

@@ -2051,6 +2051,20 @@ export class Engine {
           signal,
           onRawExchange: captureRawExchange,
         })) {
+          // task-325a (abort-stop fix): per-event abort short-circuit.
+          // The adapter is expected to throw AbortError when fetch's
+          // signal fires, but in practice undici/HTTP-2/proxy layers
+          // can hand us a batch of SSE chunks that were already buffered
+          // when abort was requested. Those chunks would otherwise be
+          // forwarded to the caller (web-bridge → WS → browser) for
+          // 1–2s after the user pressed Stop, producing the exact
+          // symptom "Stop button doesn't stop the turn". Drop every
+          // post-abort event by throwing into the outer catch, which
+          // converges on the same `aborted` + `turn_end` terminal pair
+          // as the adapter-throws-AbortError path.
+          if (signal?.aborted) {
+            throw new LLMAbortError();
+          }
           switch (event.type) {
             case 'text_delta':
               if (ttfbMs === null) ttfbMs = Date.now() - startTime;

package/yeaft/session.js

@@ -370,6 +370,14 @@ export async function loadSession(options = {}) {
   }
 
   // ─── 6. Load skills ────────────────────────────────────
+  // Project tier root for skills + MCP project assets. Per-session/per-group
+  // workdirs override at tool-execution time via ToolContext.cwd; for the
+  // SYSTEM-PROMPT skill set and the project MCP servers we use the agent
+  // process cwd, the common case when an agent is launched inside a project
+  // the user wants project-tier assets for. Shared so skills (.claude/skills,
+  // .yeaft/skills) and MCP (.mcp.json) resolve from the same root.
+  const projectTierRoot = process.cwd();
+
   let skillManager;
   if (skipSkills) {
     // Pass the literal user-tier dir (matches the normal branch's tier 2)
@@ -378,17 +386,11 @@ export async function loadSession(options = {}) {
     skillManager = new SkillManager(join(yeaftDir, 'skills'));
     // Don't call .load() — empty skill manager
   } else {
-    // Pass the agent's current working directory as the project tier root.
-    // Per-session/per-group workdirs override at tool-execution time via
-    // ToolContext.cwd; for the SYSTEM-PROMPT skill set we just use the
-    // agent process cwd, which is the common case when an agent is
-    // launched inside a project the user wants project-tier skills for.
-    const projectTierRoot = process.cwd();
     skillManager = createSkillManager(yeaftDir, projectTierRoot);
   }
 
   // ─── 7. Connect MCP servers ────────────────────────────
-  const mcpConfig = loadMCPConfig(yeaftDir);
+  const mcpConfig = loadMCPConfig(yeaftDir, undefined, projectTierRoot);
   const mcpManager = new MCPManager();
   let mcpStatus = { connected: [], failed: [] };
 
@@ -548,6 +550,10 @@ export async function loadSession(options = {}) {
     skills: skillManager.size,
     mcpServers: mcpStatus.connected,
     mcpFailed: mcpStatus.failed,
+    // Project `.mcp.json` servers we couldn't spawn (e.g. SSE/HTTP transport).
+    // Surfaced (not silently dropped) so the UI can explain why a configured
+    // server isn't available.
+    mcpSkipped: mcpConfig.skipped || [],
     tools: toolRegistry.size,
   };
 

package/yeaft/skills.js

@@ -34,9 +34,14 @@
  *   tier 2 (user):    <yeaftDir>/skills (e.g. ~/.yeaft/skills). User edits
  *           land here. `save()` writes here. `init.js` seeds it from tier 1
  *           on first boot so users start with the full bundled set.
- *   tier 3 (project): <workDir>/.yeaft/skills (if provided). Highest
+ *   tier 3 (project-claude): <workDir>/.claude/skills (if provided). Claude
+ *           Code project assets, loaded so a Claude-Code-integrated project
+ *           works out of the box. Higher than user (project-local beats
+ *           user-global), lower than the yeaft-native project tier.
+ *   tier 4 (project): <workDir>/.yeaft/skills (if provided). Highest
  *           priority — a project can pin a skill version without affecting
- *           the user's other projects.
+ *           the user's other projects, and overrides a borrowed
+ *           `.claude/skills` skill of the same name.
  *
  * Reference: yeaft-yeaft-design.md §8, yeaft-yeaft-core-systems.md
  */
@@ -694,10 +699,16 @@ export class SkillManager {
  * Create a SkillManager wired with the standard layered tier list and load it.
  *
  * Tier order (lowest → highest priority):
- *   1. bundled — the yeaft-skills package on disk, located via
+ *   1. bundled        — the yeaft-skills package on disk, located via
  *      `bundledYeaftSkillsDir()` (typically ~/.claude/skills/yeaft-skills/skills/).
- *   2. user    — `<yeaftDir>/skills` (e.g. ~/.yeaft/skills). User edits + saves.
- *   3. project — `<workDir>/.yeaft/skills` when a workDir is provided.
+ *   2. user           — `<yeaftDir>/skills` (e.g. ~/.yeaft/skills). User edits + saves.
+ *   3. project-claude — `<workDir>/.claude/skills` when a workDir is provided.
+ *      Claude Code project assets, loaded so a project that integrates Claude
+ *      Code works out of the box. Ranks above `user` (project-local beats
+ *      user-global) but below the yeaft-native project tier.
+ *   4. project        — `<workDir>/.yeaft/skills` when a workDir is provided.
+ *      Highest priority: a yeaft-native skill pinned in the project overrides
+ *      a borrowed `.claude/skills` skill of the same name.
  *
  * `save()` / `remove()` always target the USER tier, matching Claude Code.
  *
@@ -708,12 +719,14 @@ export class SkillManager {
 export function createSkillManager(yeaftDir, workDir) {
   const bundled = bundledYeaftSkillsDir();
   const userDir = join(yeaftDir, 'skills');
+  const claudeProjectDir = workDir ? join(workDir, '.claude', 'skills') : null;
   const projectDir = workDir ? join(workDir, '.yeaft', 'skills') : null;
 
-  const dirs = [bundled, userDir, projectDir].filter(Boolean);
+  const dirs = [bundled, userDir, claudeProjectDir, projectDir].filter(Boolean);
   const tierByDir = {};
   if (bundled) tierByDir[bundled] = 'bundled';
   tierByDir[userDir] = 'user';
+  if (claudeProjectDir) tierByDir[claudeProjectDir] = 'project-claude';
   if (projectDir) tierByDir[projectDir] = 'project';
 
   const manager = new SkillManager(dirs, { userDir, tierByDir });