@yeaft/webchat-agent 1.0.50 → 1.0.52

package/connection/upgrade.js

@@ -32,7 +32,7 @@ const isWin = platform() === 'win32';
 // macOS/Linux: use absolute path — launchd/systemd have minimal PATH.
 const npmPath = isWin ? 'npm' : join(nodeBinDir, 'npm');
 const pm2Path = isWin ? 'pm2' : join(nodeBinDir, 'pm2');
-const shellOpt = isWin ? { shell: true } : {};
+const shellOpt = isWin ? { shell: true, windowsHide: true } : {};
 
 // Ensure PATH includes nodeBinDir so that `#!/usr/bin/env node` shebangs
 // can locate node in launchd/systemd environments with minimal PATH.

package/crew/worktree.js

@@ -27,7 +27,7 @@ export async function initWorktrees(projectDir, roles) {
   // 获取 git 已知的 worktree 列表
   let knownWorktrees = new Set();
   try {
-    const { stdout } = await execFile('git', ['worktree', 'list', '--porcelain'], { cwd: projectDir });
+    const { stdout } = await execFile('git', ['worktree', 'list', '--porcelain'], { cwd: projectDir, windowsHide: true });
     for (const line of stdout.split('\n')) {
       if (line.startsWith('worktree ')) {
         knownWorktrees.add(line.slice('worktree '.length).trim());
@@ -66,13 +66,13 @@ export async function initWorktrees(projectDir, roles) {
     try {
       // 创建分支（如果不存在）
       try {
-        await execFile('git', ['branch', branch], { cwd: projectDir });
+        await execFile('git', ['branch', branch], { cwd: projectDir, windowsHide: true });
       } catch {
         // 分支已存在，忽略
       }
 
       // 创建 worktree
-      await execFile('git', ['worktree', 'add', wtDir, branch], { cwd: projectDir });
+      await execFile('git', ['worktree', 'add', wtDir, branch], { cwd: projectDir, windowsHide: true });
       console.log(`[Crew] Created worktree: ${wtDir} on branch ${branch}`);
       worktreeMap.set(idx, wtDir);
     } catch (e) {
@@ -104,14 +104,14 @@ export async function cleanupWorktrees(projectDir) {
       const branch = `crew/${entry}`;
 
       try {
-        await execFile('git', ['worktree', 'remove', wtDir, '--force'], { cwd: projectDir });
+        await execFile('git', ['worktree', 'remove', wtDir, '--force'], { cwd: projectDir, windowsHide: true });
         console.log(`[Crew] Removed worktree: ${wtDir}`);
       } catch (e) {
         console.warn(`[Crew] Failed to remove worktree ${wtDir}:`, e.message);
       }
 
       try {
-        await execFile('git', ['branch', '-D', branch], { cwd: projectDir });
+        await execFile('git', ['branch', '-D', branch], { cwd: projectDir, windowsHide: true });
         console.log(`[Crew] Deleted branch: ${branch}`);
       } catch (e) {
         console.warn(`[Crew] Failed to delete branch ${branch}:`, e.message);

package/history.js

@@ -2,6 +2,7 @@ import { homedir } from 'os';
 import { existsSync, readFileSync, readdirSync, statSync, openSync, readSync, closeSync, fstatSync } from 'fs';
 import { join } from 'path';
 import ctx from './context.js';
+import { normalizeClaudeMessage } from './sdk/message-normalize.js';
 import { getProvider, DEFAULT_PROVIDER } from './providers/index.js';
 
 // Claude 项目目录
@@ -227,7 +228,7 @@ function readTailMessages(filePath, limit) {
         const line = lines[i];
         if (!line || !line.trim()) continue;
         try {
-          const data = JSON.parse(line);
+          const data = normalizeClaudeMessage(JSON.parse(line));
           if (data.type === 'user' || data.type === 'assistant') {
             collected.push(data);
             if (collected.length >= limit) break;
@@ -241,7 +242,7 @@ function readTailMessages(filePath, limit) {
       const headLine = carry.toString('utf-8').trim();
       if (headLine) {
         try {
-          const data = JSON.parse(headLine);
+          const data = normalizeClaudeMessage(JSON.parse(headLine));
           if (data.type === 'user' || data.type === 'assistant') {
             collected.push(data);
           }
@@ -287,7 +288,7 @@ export function loadSessionHistory(workDir, claudeSessionId, limit = 500) {
 
     for (const line of lines) {
       try {
-        const data = JSON.parse(line);
+        const data = normalizeClaudeMessage(JSON.parse(line));
         if (data.type === 'user' || data.type === 'assistant') {
           messages.push(data);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.50",
+  "version": "1.0.52",
   "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/providers/copilot-models.js

@@ -99,7 +99,7 @@ function _probeAcpModels() {
       if (err) reject(err); else resolve(models || []);
     };
     try {
-      child = spawn('copilot', ['--acp'], { stdio: ['pipe', 'pipe', 'pipe'] });
+      child = spawn('copilot', ['--acp'], { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
     } catch (e) { return reject(e); }
     const timer = setTimeout(() => finish(new Error('ACP probe timeout')), PROBE_TIMEOUT_MS);
     child.on('error', (e) => finish(e));

package/sdk/message-normalize.js

@@ -0,0 +1,129 @@
+const TOOL_LIKE_BLOCK_TYPES = new Set([
+  'tool_use',
+  'tool_call',
+  'function_call',
+  'server_tool_use',
+  'call',
+]);
+
+/**
+ * Claude Code stream-json has changed its tool-call block spelling more than
+ * once. Normalize every known tool-like assistant content block to the
+ * Anthropic-compatible `tool_use` shape used by the rest of the app.
+ *
+ * @param {unknown} block
+ * @returns {unknown}
+ */
+export function normalizeAssistantContentBlock(block) {
+  if (!block || typeof block !== 'object') return block;
+  if (block.type === 'tool_use') return block;
+  if (!TOOL_LIKE_BLOCK_TYPES.has(block.type)) return block;
+
+  const input = normalizeToolInput(block);
+  const name = block.name
+    || block.tool_name
+    || block.toolName
+    || block.function?.name
+    || block.action?.name
+    || input?.name
+    || 'tool';
+  const id = block.id
+    || block.tool_use_id
+    || block.toolUseId
+    || block.tool_call_id
+    || block.toolCallId
+    || block.call_id
+    || block.callId
+    || stableFallbackToolId(name, block);
+
+  return {
+    type: 'tool_use',
+    id,
+    name,
+    input,
+  };
+}
+
+/**
+ * @param {unknown} content
+ * @returns {unknown}
+ */
+export function normalizeAssistantContent(content) {
+  if (!Array.isArray(content)) return content;
+  return content.map(normalizeAssistantContentBlock);
+}
+
+/**
+ * @param {unknown} message
+ * @returns {unknown}
+ */
+export function normalizeClaudeMessage(message) {
+  if (!message || typeof message !== 'object') return message;
+  if (message.type !== 'assistant' || !message.message) return message;
+  const content = message.message.content;
+  const normalized = normalizeAssistantContent(content);
+  if (normalized === content) return message;
+  return {
+    ...message,
+    message: {
+      ...message.message,
+      content: normalized,
+    },
+  };
+}
+
+/**
+ * Stream events should only emit text deltas from actual text blocks. Newer
+ * Claude Code builds may emit text-looking deltas while a tool-call block is
+ * being assembled (`call`, transient id, JSON argument text). Those bytes are
+ * transport detail, not assistant prose; the final complete assistant message
+ * carries the real tool_use block.
+ *
+ * @param {string|undefined|null} blockType
+ * @returns {boolean}
+ */
+export function shouldForwardTextDeltaForBlockType(blockType) {
+  if (!blockType) return true; // Back-compat for older CLIs without start events.
+  return blockType === 'text';
+}
+
+function stableFallbackToolId(name, block) {
+  const raw = stableStringify(block);
+  let hash = 2166136261;
+  for (let i = 0; i < raw.length; i++) {
+    hash ^= raw.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return `${name}-${hash.toString(36)}`;
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function normalizeToolInput(block) {
+  const raw = block.input
+    ?? block.arguments
+    ?? block.args
+    ?? block.parameters
+    ?? block.function?.arguments
+    ?? block.action?.arguments
+    ?? {};
+
+  if (typeof raw === 'string') {
+    const trimmed = raw.trim();
+    if (!trimmed) return {};
+    try {
+      const parsed = JSON.parse(trimmed);
+      return parsed && typeof parsed === 'object' ? parsed : { value: parsed };
+    } catch {
+      return { arguments: raw };
+    }
+  }
+  if (raw && typeof raw === 'object') return raw;
+  return {};
+}

package/sdk/query.js

@@ -7,6 +7,7 @@ import { spawn } from 'child_process';
 import { createInterface } from 'readline';
 import { Stream } from './stream.js';
 import { AbortError } from './types.js';
+import { normalizeClaudeMessage, shouldForwardTextDeltaForBlockType } from './message-normalize.js';
 import { getCleanEnv, logDebug, streamToStdin, resolveClaudeCommand } from './utils.js';
 
 
@@ -82,6 +83,7 @@ export class Query {
     // Track whether we've forwarded text deltas for the current assistant turn.
     // When true, the next complete `assistant` message's text blocks are redundant.
     let hasStreamedTextDeltas = false;
+    const streamBlockTypes = new Map();
 
     try {
       for await (const line of rl) {
@@ -114,36 +116,52 @@ export class Query {
               const event = message.event;
               if (!event) continue;
 
-              // content_block_delta with text_delta → convert to assistant message for streaming
+              if (event.type === 'content_block_start') {
+                streamBlockTypes.set(event.index, event.content_block?.type || null);
+                continue;
+              }
+              if (event.type === 'content_block_stop') {
+                streamBlockTypes.delete(event.index);
+                continue;
+              }
+              // content_block_delta with text_delta → convert to assistant message for streaming,
+              // but only while the active block is actually text. Some Claude Code builds
+              // expose tool-call assembly as text-looking deltas; forwarding those leaks
+              // raw `call`, transient ids, and JSON arguments into the chat transcript.
               if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta' && event.delta.text) {
-                hasStreamedTextDeltas = true;
-                this.inputStream.enqueue({
-                  type: 'assistant',
-                  message: {
-                    role: 'assistant',
-                    content: [{ type: 'text', text: event.delta.text }]
-                  }
-                });
+                const blockType = streamBlockTypes.get(event.index);
+                if (shouldForwardTextDeltaForBlockType(blockType)) {
+                  hasStreamedTextDeltas = true;
+                  this.inputStream.enqueue({
+                    type: 'assistant',
+                    message: {
+                      role: 'assistant',
+                      content: [{ type: 'text', text: event.delta.text }]
+                    }
+                  });
+                }
               }
-              // All other stream events (message_start, content_block_start,
-              // input_json_delta, content_block_stop, message_stop) are ignored.
-              // tool_use is handled via the complete assistant message.
+              // All other stream events (message_start, input_json_delta,
+              // message_stop) are ignored. Tool use is handled via the complete
+              // assistant message after block normalization below.
               continue;
             }
 
+            const normalizedMessage = normalizeClaudeMessage(message);
+
             // Deduplicate: when a complete assistant message arrives after we've
             // already streamed text deltas, strip the text blocks (already sent).
             // Keep tool_use blocks which are NOT sent incrementally.
-            if (message.type === 'assistant' && hasStreamedTextDeltas) {
+            if (normalizedMessage.type === 'assistant' && hasStreamedTextDeltas) {
               hasStreamedTextDeltas = false; // Reset for next assistant turn
 
-              const content = message.message?.content;
+              const content = normalizedMessage.message?.content;
               if (Array.isArray(content)) {
                 const nonTextBlocks = content.filter(b => b.type !== 'text');
                 if (nonTextBlocks.length > 0) {
                   // Forward only tool_use blocks (text already sent via deltas)
-                  message.message.content = nonTextBlocks;
-                  this.inputStream.enqueue(message);
+                  normalizedMessage.message.content = nonTextBlocks;
+                  this.inputStream.enqueue(normalizedMessage);
                 } else {
                   // Pure text message fully streamed — send finish-streaming signal
                   // so frontend clears isStreaming and typing dots can reappear
@@ -165,11 +183,12 @@ export class Query {
 
             // Reset delta tracking on non-assistant messages
             // (e.g., user, result, system — a new turn boundary)
-            if (message.type !== 'assistant') {
+            if (normalizedMessage.type !== 'assistant') {
               hasStreamedTextDeltas = false;
+              streamBlockTypes.clear();
             }
 
-            this.inputStream.enqueue(message);
+            this.inputStream.enqueue(normalizedMessage);
           } catch (e) {
             logDebug(`Non-JSON line: ${line.substring(0, 100)}`);
           }

package/yeaft/mcp.js

@@ -81,6 +81,7 @@ class MCPServerConnection extends EventEmitter {
         this.#process = spawn(this.config.command, this.config.args || [], {
           stdio: ['pipe', 'pipe', 'pipe'],
           env: { ...process.env, ...this.config.env },
+          windowsHide: true,
         });
 
         this.#process.stdout.on('data', (data) => {

package/yeaft/tools/bash.js

@@ -45,6 +45,7 @@ function runCommand(command, { cwd, timeout, signal, runtimePlatform }) {
       env,
       stdio: ['ignore', 'pipe', 'pipe'],
       detached: !platform.isWindows,
+      windowsHide: true,
     });
 
     let stdout = '';

package/yeaft/tools/enter-worktree.js

@@ -14,6 +14,12 @@ import { existsSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 import { randomUUID } from 'crypto';
 
+const HIDDEN_PROCESS_OPTIONS = { windowsHide: true };
+
+function gitExecFileSync(args, options = {}) {
+  return execFileSync('git', args, { ...options, ...HIDDEN_PROCESS_OPTIONS });
+}
+
 export default defineTool({
   name: 'EnterWorktree',
   description: {
@@ -61,7 +67,7 @@ Worktree 创建在 .yeaft/worktrees/ 中，基于 HEAD 创建新分支。返回
 
     // Verify we're in a git repo
     try {
-      execFileSync('git', ['rev-parse', '--git-dir'], { cwd, stdio: 'pipe' });
+      gitExecFileSync(['rev-parse', '--git-dir'], { cwd, stdio: 'pipe' });
     } catch {
       return JSON.stringify({ error: 'Not in a git repository' });
     }
@@ -93,7 +99,7 @@ Worktree 创建在 .yeaft/worktrees/ 中，基于 HEAD 创建新分支。返回
     try {
       // Create worktree with new branch. Use execFileSync args instead of
       // shell quoting so Windows drive letters and spaces in paths survive.
-      execFileSync('git', ['worktree', 'add', '-b', branchName, worktreeDir, baseRef], { cwd, stdio: 'pipe' });
+      gitExecFileSync(['worktree', 'add', '-b', branchName, worktreeDir, baseRef], { cwd, stdio: 'pipe' });
 
       return JSON.stringify({
         success: true,

package/yeaft/tools/exit-worktree.js

@@ -12,6 +12,12 @@ import { execFileSync } from 'child_process';
 import { existsSync } from 'fs';
 import { resolve } from 'path';
 
+const HIDDEN_PROCESS_OPTIONS = { windowsHide: true };
+
+function gitExecFileSync(args, options = {}) {
+  return execFileSync('git', args, { ...options, ...HIDDEN_PROCESS_OPTIONS });
+}
+
 export default defineTool({
   name: 'ExitWorktree',
   description: {
@@ -84,7 +90,7 @@ unless discard_changes is set to true.`,
       // Check for uncommitted changes
       if (!input.discard_changes) {
         try {
-          const status = execFileSync('git', ['status', '--porcelain'], {
+          const status = gitExecFileSync(['status', '--porcelain'], {
             cwd: worktreePath,
             encoding: 'utf8',
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -104,7 +110,7 @@ unless discard_changes is set to true.`,
       // Get branch name before removal
       let branchName = null;
       try {
-        branchName = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+        branchName = gitExecFileSync(['rev-parse', '--abbrev-ref', 'HEAD'], {
           cwd: worktreePath,
           encoding: 'utf8',
           stdio: ['pipe', 'pipe', 'pipe'],
@@ -115,7 +121,7 @@ unless discard_changes is set to true.`,
 
       // Remove worktree. Use argv form so Windows paths with spaces or drive
       // letters are passed to git unchanged.
-      execFileSync('git', ['worktree', 'remove', ...(input.discard_changes ? ['--force'] : []), worktreePath], {
+      gitExecFileSync(['worktree', 'remove', ...(input.discard_changes ? ['--force'] : []), worktreePath], {
         cwd: mainCwd,
         stdio: 'pipe',
       });
@@ -123,7 +129,7 @@ unless discard_changes is set to true.`,
       // Remove the branch if it was a yeaft worktree branch
       if (branchName && branchName.startsWith('yeaft-wt/')) {
         try {
-          execFileSync('git', ['branch', '-D', branchName], {
+          gitExecFileSync(['branch', '-D', branchName], {
             cwd: mainCwd,
             stdio: 'pipe',
           });

package/yeaft/tools/grep.js

@@ -30,7 +30,7 @@ const BINARY_EXTS = new Set([
  */
 function hasRipgrep() {
   return new Promise((resolve) => {
-    const proc = spawn('rg', ['--version'], { stdio: 'pipe' });
+    const proc = spawn('rg', ['--version'], { stdio: 'pipe', windowsHide: true });
     proc.on('close', (code) => resolve(code === 0));
     proc.on('error', () => resolve(false));
   });
@@ -60,7 +60,7 @@ function runRipgrep(pattern, searchPath, options) {
     if (options.multiline) args.push('-U', '--multiline-dotall');
     args.push('--max-count', String(options.maxResults || 500));
 
-    const proc = spawn('rg', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    const proc = spawn('rg', args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
     let stdout = '';
     let stderr = '';