@ww_nero/mini-cli 1.0.56

package/src/request.js

@@ -0,0 +1,328 @@
+const fetch = require('node-fetch');
+const { createParser } = require('eventsource-parser');
+const { COMPACT_SUMMARY_PROMPT } = require('./config');
+
+const joinUrl = (base, pathname) => {
+  const normalizedBase = String(base || '').replace(/\/$/, '');
+  const normalizedPath = pathname.startsWith('/') ? pathname : `/${pathname}`;
+  return `${normalizedBase}${normalizedPath}`;
+};
+
+const createAbortError = () => {
+  if (typeof DOMException === 'function') {
+    return new DOMException('Aborted', 'AbortError');
+  }
+  const error = new Error('Aborted');
+  error.name = 'AbortError';
+  return error;
+};
+
+const createFetchOptions = (endpoint, body, abortController) => ({
+  method: 'POST',
+  headers: {
+    Authorization: `Bearer ${endpoint.key}`,
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify(body),
+  signal: abortController.signal
+});
+
+const makeRequestWithRetry = async (endpoint, requestBody, abortController, options = {}) => {
+  const { maxRetries = 5, retryDelay = 3000, onRetry = null } = options;
+  const url = joinUrl(endpoint.baseUrl, '/chat/completions');
+
+  const attemptRequest = async () => {
+    try {
+      const response = await fetch(url, createFetchOptions(endpoint, requestBody, abortController));
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return { response, error: null };
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        throw createAbortError();
+      }
+      return { response: null, error };
+    }
+  };
+
+  let attempt = 0;
+  let result = await attemptRequest();
+
+  while (!result.response && attempt < maxRetries) {
+    attempt += 1;
+    if (typeof onRetry === 'function') {
+      onRetry(attempt, result.error);
+    }
+    await new Promise(resolve => {
+      const handleAbort = () => {
+        abortController.signal.removeEventListener('abort', handleAbort);
+        clearTimeout(timeout);
+        resolve();
+      };
+      const timeout = setTimeout(() => {
+        abortController.signal.removeEventListener('abort', handleAbort);
+        resolve();
+      }, retryDelay);
+      abortController.signal.addEventListener('abort', handleAbort);
+    });
+    if (abortController.signal.aborted) {
+      throw createAbortError();
+    }
+    result = await attemptRequest();
+  }
+
+  if (!result.response) {
+    throw result.error;
+  }
+
+  return result.response;
+};
+
+const processStreamResponse = (response, options = {}) => {
+  const {
+    onContent = null,
+    onReasoningContent = null,
+    onComplete = null,
+    abortController = null,
+    includeToolCalls = false
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    let abortHandler = null;
+    const cleanupAbortListener = () => {
+      if (abortController && abortHandler) {
+        abortController.signal.removeEventListener('abort', abortHandler);
+        abortHandler = null;
+      }
+    };
+
+    const rejectWithAbort = () => {
+      cleanupAbortListener();
+      if (response.body && typeof response.body.destroy === 'function') {
+        response.body.destroy();
+      }
+      reject(createAbortError());
+    };
+
+    const checkAbort = () => {
+      if (abortController && abortController.signal.aborted) {
+        rejectWithAbort();
+        return true;
+      }
+      return false;
+    };
+
+    try {
+      let fullContent = '';
+      let toolCalls = [];
+      let currentMessage = null;
+      let fullReasoningContent = '';
+      let usage = null;
+      const decoder = new TextDecoder('utf-8', { fatal: false });
+
+      const handleEvent = (event) => {
+        if (checkAbort()) return;
+        if (!event || event.type !== 'event') {
+          return;
+        }
+        if (!event.data || event.data === '[DONE]') {
+          return;
+        }
+        try {
+          const payload = JSON.parse(event.data);
+          if (payload.usage && typeof payload.usage === 'object') {
+            usage = payload.usage;
+          }
+          const choice = payload.choices && payload.choices[0];
+          if (!choice || !choice.delta) return;
+          const delta = choice.delta;
+          const contentChunk = delta.content || '';
+          if (contentChunk) {
+            fullContent += contentChunk;
+            if (onContent) {
+              onContent(contentChunk, fullContent);
+            }
+          }
+
+          const reasoningChunk = delta.reasoning_content || '';
+          if (reasoningChunk) {
+            fullReasoningContent += reasoningChunk;
+            if (onReasoningContent) {
+              onReasoningContent(reasoningChunk, fullReasoningContent);
+            }
+          }
+
+          if (includeToolCalls && Array.isArray(delta.tool_calls)) {
+            delta.tool_calls.forEach((call, index) => {
+              if (!toolCalls[index]) {
+                toolCalls[index] = {
+                  id: call.id || '',
+                  type: call.type || 'function',
+                  function: {
+                    name: (call.function && call.function.name) || '',
+                    arguments: ''
+                  }
+                };
+              }
+
+              if (call.function && typeof call.function.arguments === 'string') {
+                toolCalls[index].function.arguments += call.function.arguments;
+              }
+            });
+          }
+
+          if (includeToolCalls) {
+            currentMessage = {
+              role: 'assistant',
+              content: fullContent || null,
+              ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+              ...(fullReasoningContent ? { reasoning_content: fullReasoningContent } : {})
+            };
+          }
+        } catch (error) {
+          console.warn('SSE parse error:', error.message);
+        }
+      };
+
+      const parser = createParser(handleEvent);
+
+      const safeFeed = (text) => {
+        try {
+          parser.feed(text);
+        } catch (error) {
+          console.warn('SSE error:', error.message);
+        }
+      };
+
+      response.body.on('data', chunk => {
+        if (checkAbort()) return;
+        const text = decoder.decode(chunk, { stream: true });
+        safeFeed(text);
+      });
+
+      response.body.on('end', () => {
+        if (checkAbort()) return;
+        cleanupAbortListener();
+        const rest = decoder.decode();
+        if (rest) {
+          safeFeed(rest);
+        }
+        onComplete && onComplete();
+        if (includeToolCalls) {
+          const filteredToolCalls = toolCalls.filter(Boolean);
+          const assistantMessage = currentMessage || {
+            role: 'assistant',
+            content: fullContent || null,
+            ...(filteredToolCalls.length > 0 ? { tool_calls: filteredToolCalls } : {})
+          };
+
+          if (fullReasoningContent && !assistantMessage.reasoning_content) {
+            assistantMessage.reasoning_content = fullReasoningContent;
+          }
+
+          resolve({
+            content: fullContent,
+            toolCalls: filteredToolCalls,
+            message: assistantMessage,
+            reasoningContent: fullReasoningContent,
+            usage
+          });
+        } else {
+          resolve({
+            content: fullContent,
+            reasoningContent: fullReasoningContent,
+            usage
+          });
+        }
+      });
+
+      response.body.on('error', (error) => {
+        cleanupAbortListener();
+        reject(error);
+      });
+
+      if (abortController) {
+        abortHandler = () => {
+          rejectWithAbort();
+        };
+        abortController.signal.addEventListener('abort', abortHandler);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+const buildConversationForSummary = (messages) => {
+  const parts = [];
+  for (const msg of messages) {
+    if (msg.role === 'system') continue;
+
+    const role = msg.role === 'user' ? '用户' : msg.role === 'assistant' ? '助手' : '工具';
+    let content = msg.content || '';
+
+    if (msg.tool_call_id) {
+      parts.push(`[工具返回 ${msg.tool_call_id}]: ${content}`);
+    } else if (msg.tool_calls && msg.tool_calls.length > 0) {
+      const toolNames = msg.tool_calls.map(tc => tc.function?.name || '未知工具').join(', ');
+      parts.push(`[${role}]: ${content || ''}\n[调用工具: ${toolNames}]`);
+    } else {
+      parts.push(`[${role}]: ${content}`);
+    }
+  }
+  return parts.join('\n\n');
+};
+
+const performCompactSummary = async (endpoint, messages, abortController) => {
+  const conversationText = buildConversationForSummary(messages);
+
+  const summaryMessages = [
+    {
+      role: 'system',
+      content: COMPACT_SUMMARY_PROMPT
+    },
+    {
+      role: 'user',
+      content: `以下是需要总结的对话内容：\n\n${conversationText}`
+    }
+  ];
+
+  const requestBody = {
+    stream: false,
+    messages: summaryMessages,
+    model: endpoint.model
+  };
+
+  const url = joinUrl(endpoint.baseUrl, '/chat/completions');
+
+  try {
+    const response = await fetch(url, createFetchOptions(endpoint, requestBody, abortController));
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+    const choice = data.choices && data.choices[0];
+
+    if (choice && choice.message && choice.message.content) {
+      return choice.message.content;
+    }
+
+    throw new Error('无法获取总结内容');
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      throw error;
+    }
+    console.error('Compact 总结请求失败:', error);
+    throw error;
+  }
+};
+
+module.exports = {
+  makeRequestWithRetry,
+  processStreamResponse,
+  buildConversationForSummary,
+  performCompactSummary
+};

package/src/tools/bash.js

@@ -0,0 +1,241 @@
+const { spawn } = require('child_process');
+const { resolveWorkspacePath } = require('../utils/helpers');
+const { DEFAULT_ALLOWED_COMMANDS } = require('../config');
+
+const OUTPUT_MAX_LENGTH = 12000;
+const EXECUTION_TIMEOUT = 300000;
+const SERVICE_RETURN_DELAY = 5000;
+
+// Git 只读命令白名单
+const GIT_READONLY_COMMANDS = ['show', 'diff', 'log', 'status', 'branch', 'tag', 'ls-files', 'ls-tree', 'rev-parse', 'reflog', 'blame', 'shortlog', 'describe', 'config --get', 'config --list', 'remote', 'ls-remote', 'fetch --dry-run', 'grep'];
+
+// Git 禁止的命令（会修改状态的命令）
+const GIT_FORBIDDEN_COMMANDS = ['add', 'commit', 'push', 'pull', 'merge', 'rebase', 'reset', 'revert', 'cherry-pick', 'apply', 'stash', 'clean', 'rm', 'mv', 'checkout', 'switch', 'restore', 'tag -a', 'tag -d', 'branch -d', 'branch -D', 'config --add', 'config --unset', 'submodule', 'clone', 'init'];
+
+const splitShellCommands = (commandString = '') => {
+  const operators = ['&&', '||'];
+  const pattern = '(' + operators.map(op => op.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|') + ')';
+  return commandString
+    .split(new RegExp(pattern))
+    .map(part => part.trim())
+    .filter(part => part && !operators.includes(part));
+};
+
+const validateSingleCommand = (commandString = '', allowedCommands = []) => {
+  const parts = commandString.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+  if (parts.length === 0) {
+    return { isValid: false, reason: '命令为空' };
+  }
+
+  const command = parts[0];
+  if (!allowedCommands.includes(command)) {
+    return { isValid: false, reason: `命令 ${command} 不在允许名单内` };
+  }
+
+  if ((command === 'rm' || command === 'rmdir') && parts.slice(1).some(arg => !arg.startsWith('-') && arg.includes('.git'))) {
+    return { isValid: false, reason: '禁止对 .git 目录执行删除操作' };
+  }
+
+  // Git 命令额外验证
+  if (command === 'git') {
+    if (parts.length < 2) {
+      return { isValid: false, reason: 'git 命令缺少子命令' };
+    }
+
+    const gitSubCommand = parts[1];
+    const gitArgs = parts.slice(2).join(' ');
+    const fullGitCommand = gitSubCommand + (gitArgs ? ' ' + gitArgs : '');
+
+    // 检查是否是禁止的命令
+    for (const forbidden of GIT_FORBIDDEN_COMMANDS) {
+      if (gitSubCommand === forbidden || fullGitCommand.startsWith(forbidden)) {
+        return {
+          isValid: false,
+          reason: `禁止执行会修改仓库状态的 git 命令: ${forbidden}。只允许执行只读命令如: ${GIT_READONLY_COMMANDS.join(', ')}`
+        };
+      }
+    }
+
+    // 检查是否是允许的只读命令
+    let isReadOnly = false;
+    for (const readonly of GIT_READONLY_COMMANDS) {
+      if (gitSubCommand === readonly || fullGitCommand.startsWith(readonly)) {
+        isReadOnly = true;
+        break;
+      }
+    }
+
+    if (!isReadOnly) {
+      return {
+        isValid: false,
+        reason: `git 子命令 ${gitSubCommand} 不在只读命令白名单内。允许的命令: ${GIT_READONLY_COMMANDS.join(', ')}`
+      };
+    }
+  }
+
+  return { isValid: true, reason: '' };
+};
+
+const executeCommand = async ({ command, workingDirectory = '.', isService = false } = {}, context = {}) => {
+  if (!command || typeof command !== 'string' || !command.trim()) {
+    return 'command 参数不能为空';
+  }
+
+  const normalizedCommand = command.replace(/\bpython3\b/g, 'python');
+
+  const allowedCommands = Array.isArray(context.allowedCommands) && context.allowedCommands.length > 0
+    ? context.allowedCommands
+    : DEFAULT_ALLOWED_COMMANDS;
+  const commands = splitShellCommands(normalizedCommand);
+  if (commands.length === 0) {
+    return '未找到有效的命令';
+  }
+
+  for (let i = 0; i < commands.length; i += 1) {
+    const validation = validateSingleCommand(commands[i], allowedCommands);
+    if (!validation.isValid) {
+      return [
+        '命令未通过安全校验',
+        `第 ${i + 1} 个指令: ${commands[i]}`,
+        `原因: ${validation.reason}`,
+        '允许的命令: ' + allowedCommands.join(', '),
+        '附加限制: rm/rmdir 禁止修改`.git`目录'
+      ].join('\n');
+    }
+  }
+
+  let cwd;
+  try {
+    cwd = resolveWorkspacePath(context.workspaceRoot, workingDirectory || '.');
+  } catch (error) {
+    return `工作目录无效: ${error.message}`;
+  }
+
+  return new Promise((resolve) => {
+    const child = spawn('bash', ['-lc', normalizedCommand], {
+      cwd,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+
+    const cleanup = () => {
+      child.stdout.removeAllListeners();
+      child.stderr.removeAllListeners();
+    };
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+      if (stdout.length > OUTPUT_MAX_LENGTH) {
+        stdout = stdout.slice(0, OUTPUT_MAX_LENGTH);
+      }
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+      if (stderr.length > OUTPUT_MAX_LENGTH) {
+        stderr = stderr.slice(0, OUTPUT_MAX_LENGTH);
+      }
+    });
+
+    const handleProcessError = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(`命令执行失败: ${error.message}`);
+    };
+
+    const handleProcessClose = (code) => {
+      cleanup();
+      if (settled) return;
+      settled = true;
+      if (code === 0) {
+        const output = stdout.trim();
+        resolve(output || '命令执行成功，无额外输出');
+      } else {
+        const errOutput = stderr.trim();
+        const stdOutput = stdout.trim();
+        resolve(`命令执行失败，退出码 ${code}${errOutput ? `\n错误: ${errOutput}` : ''}${stdOutput ? `\n输出: ${stdOutput}` : ''}`);
+      }
+    };
+
+    if (isService) {
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const stdOutput = stdout.trim();
+        const errOutput = stderr.trim();
+        const captured = stdOutput || errOutput ? `\n当前输出:\n${stdOutput}${errOutput ? `\n错误:\n${errOutput}` : ''}` : '\n暂无输出';
+        resolve(`已等待 ${SERVICE_RETURN_DELAY / 1000}s，命令已在后台持续运行（PID: ${child.pid}）。${captured}`);
+      }, SERVICE_RETURN_DELAY);
+
+      const serviceErrorHandler = (error) => {
+        clearTimeout(timer);
+        handleProcessError(error);
+      };
+
+      child.on('error', serviceErrorHandler);
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        handleProcessClose(code);
+      });
+    } else {
+      child.on('error', handleProcessError);
+      child.on('close', handleProcessClose);
+
+      setTimeout(() => {
+        if (settled) return;
+        child.kill('SIGTERM');
+        cleanup();
+        resolve('命令执行超时 (超过 300s)');
+      }, EXECUTION_TIMEOUT);
+    }
+  });
+};
+
+const createBashToolSchema = (context = {}) => {
+  const allowedCommands = Array.isArray(context.allowedCommands) && context.allowedCommands.length > 0
+    ? context.allowedCommands
+    : DEFAULT_ALLOWED_COMMANDS;
+  const descriptionParts = ['在指定目录运行 bash 命令，支持使用 && / || 连接多个命令。'];
+  descriptionParts.push(`支持的命令: ${allowedCommands.join(', ')}。`);
+  descriptionParts.push('git 命令仅支持只读操作（show/diff/log/status 等），严禁执行 add/commit/push/reset 等会修改仓库状态的命令。');
+  descriptionParts.push('isService=true 时在后台运行服务，等待 5 秒返回初始输出，进程继续运行并持续捕获输出；默认等待命令执行完成，超时为 300 秒。');
+
+  return {
+    type: 'function',
+    function: {
+      name: 'execute_bash',
+      description: descriptionParts.join(' '),
+      parameters: {
+        type: 'object',
+        properties: {
+          command: {
+            type: 'string',
+            description: '要执行的 bash 命令'
+          },
+          workingDirectory: {
+            type: 'string',
+            description: '相对工作目录，默认为项目根目录',
+            default: '.'
+          },
+          isService: {
+            type: 'boolean',
+            description: '是否为启动长时间运行服务的命令。为 true 时后台运行并在 5 秒后返回捕获的输出。',
+            default: false
+          }
+        },
+        required: ['command']
+      }
+    }
+  };
+};
+
+module.exports = {
+  name: 'execute_bash',
+  schema: createBashToolSchema,
+  handler: executeCommand
+};