xshat-lite 1.0.0

package/src/modules/local-intent-router.mjs

@@ -0,0 +1,280 @@
+function parseLocalCommand(input = '') {
+  const text = String(input ?? '').trim();
+  if (!text) {
+    return null;
+  }
+
+  const match = text.match(/^\/local\s+(\w+)(?:\s+([\s\S]+))?$/i);
+  if (!match) {
+    return null;
+  }
+
+  const action = match[1].toLowerCase();
+  const rest = String(match[2] || '').trim();
+
+  switch (action) {
+  case 'ls':
+  case 'dir':
+  case 'list':
+    return {
+      matched: true,
+      reason: 'list-workspace',
+      command: {
+        name: 'list_files',
+        args: { path: rest || '.' }
+      }
+    };
+  case 'exists': {
+    if (!rest) {
+      return null;
+    }
+    return {
+      matched: true,
+      reason: 'file-exists',
+      command: {
+        name: 'file_exists',
+        args: { path: rest }
+      }
+    };
+  }
+  case 'read': {
+    if (!rest) {
+      return null;
+    }
+    return {
+      matched: true,
+      reason: 'read-file',
+      command: {
+        name: 'read_file',
+        args: { path: rest }
+      }
+    };
+  }
+  case 'write': {
+    const writeMatch = rest.match(/^(\S+)(?:\s+([\s\S]*))?$/);
+    const path = writeMatch?.[1] || '';
+    const content = writeMatch?.[2] || '';
+    if (!path) {
+      return null;
+    }
+    return {
+      matched: true,
+      reason: 'write-file',
+      command: {
+        name: 'write_file',
+        args: {
+          path,
+          content
+        }
+      }
+    };
+  }
+  case 'rm':
+  case 'delete': {
+    if (!rest) {
+      return null;
+    }
+    return {
+      matched: true,
+      reason: 'delete-file',
+      command: {
+        name: 'delete_file',
+        args: { path: rest }
+      }
+    };
+  }
+  case 'shell': {
+    if (!rest) {
+      return null;
+    }
+    return {
+      matched: true,
+      reason: 'explicit-shell',
+      command: {
+        name: 'run_shell',
+        args: { command: rest }
+      }
+    };
+  }
+  default:
+    return null;
+  }
+}
+
+function normalizeText(text = '') {
+  return String(text ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, ' ');
+}
+
+function detectControlIntent(input = '') {
+  const raw = String(input ?? '').trim();
+  const text = normalizeText(raw);
+  if (!text) {
+    return null;
+  }
+
+  const providerPatterns = [
+    { id: 'gemini', match: /(切换|换|改).*(gemini|谷歌)|^(gemini|切到gemini|切换到gemini)$/i },
+    { id: 'duckai', match: /(切换|换|改).*(duck\.?ai|duckai)|^(duck\.?ai|duckai|切到duckai|切换到duckai)$/i },
+    { id: 'deepseek', match: /(切换|换|改).*(deepseek)|^(deepseek|切到deepseek|切换到deepseek)$/i },
+    { id: 'chatgpt', match: /(切换|换|改).*(chatgpt)|^(chatgpt|切到chatgpt|切换到chatgpt)$/i },
+    { id: 'copilot', match: /(切换|换|改).*(copilot)|^(copilot|切到copilot|切换到copilot)$/i },
+    { id: 'qwen', match: /(切换|换|改).*(qwen|通义)|^(qwen|通义|切到qwen|切换到qwen)$/i },
+    { id: 'you', match: /(切换|换|改).*(you\.com|you)|^(you\.com|you|切到you|切换到you)$/i },
+    { id: 'huggingchat', match: /(切换|换|改).*(huggingchat)|^(huggingchat|切到huggingchat|切换到huggingchat)$/i },
+    { id: 'deepai', match: /(切换|换|改).*(deepai)|^(deepai|切到deepai|切换到deepai)$/i }
+  ];
+
+  for (const provider of providerPatterns) {
+    if (provider.match.test(raw)) {
+      return {
+        matched: true,
+        reason: 'switch-provider-natural',
+        control: {
+          action: 'switch_provider',
+          providerId: provider.id
+        }
+      };
+    }
+  }
+
+  if (/(当前.*(provider|模型|服务商|提供方))|((provider|模型|服务商|提供方).*(是啥|是什么|是谁|状态))/.test(raw)) {
+    return {
+      matched: true,
+      reason: 'show-provider-status',
+      control: { action: 'show_provider_status' }
+    };
+  }
+
+  if (/(当前.*(状态|运行状态|应用状态|app state))|((状态|运行状态|应用状态).*(看看|查看|读取|显示))/.test(raw)) {
+    return {
+      matched: true,
+      reason: 'show-app-state',
+      control: { action: 'show_app_state' }
+    };
+  }
+
+  if (/(配置|设置).*(看看|查看|读取|显示|摘要)|((看看|查看|读取|显示).*(配置|设置))/.test(raw)) {
+    return {
+      matched: true,
+      reason: 'show-config-summary',
+      control: { action: 'show_config_summary' }
+    };
+  }
+
+  if (/(打开|进入|看看|查看).*(任务|task)/.test(raw)) {
+    return {
+      matched: true,
+      reason: 'open-task-panel',
+      control: { action: 'open_task_panel' }
+    };
+  }
+
+  if (/(打开|进入|看看|查看).*(记忆|memory)/.test(raw)) {
+    return {
+      matched: true,
+      reason: 'open-memory-panel',
+      control: { action: 'open_memory_panel' }
+    };
+  }
+
+  if (/(打开|进入|看看|查看).*(会话|历史|sessions)/.test(raw)) {
+    return {
+      matched: true,
+      reason: 'open-sessions-panel',
+      control: { action: 'open_sessions_panel' }
+    };
+  }
+
+  if (/(打开|进入|看看|查看).*(设置|配置|config)/.test(raw)) {
+    return {
+      matched: true,
+      reason: 'open-settings',
+      control: { action: 'open_settings' }
+    };
+  }
+
+  if (/(打开|进入|看看|查看).*(命令面板|命令|cmd)/.test(raw)) {
+    return {
+      matched: true,
+      reason: 'open-command-palette',
+      control: { action: 'open_command_palette' }
+    };
+  }
+
+  return null;
+}
+
+export function detectLocalIntent(message = '') {
+  return parseLocalCommand(message) || detectControlIntent(message) || { matched: false };
+}
+
+export function formatLocalIntentResult(intent, result) {
+  if (!result?.ok) {
+    return `本地执行失败：${result?.error || '未知错误'}`;
+  }
+
+  if (intent?.reason === 'show-app-state') {
+    try {
+      const state = JSON.parse(result.output || '{}');
+      return [
+        '当前应用状态：',
+        '',
+        `- Provider: ${state.provider || '(无)'}`,
+        `- Session: ${state.sessionTitle || '(无会话)'}`,
+        `- Messages: ${String(state.messageCount ?? 0)}`,
+        `- Chat URL: ${state.chatUrl || '(无)'}`,
+        `- Agent URL: ${state.agentUrl || '(无)'}`,
+        `- Chat Ready: ${String(Boolean(state.browser?.chatReady))}`,
+        `- Agent Ready: ${String(Boolean(state.browser?.agentReady))}`,
+        `- Share Auth: ${String(Boolean(state.browser?.shareAuthState))}`,
+        `- Agent Mode: ${String(Boolean(state.agent?.enabled))}`,
+        `- Auto Execute: ${String(Boolean(state.agent?.autoExecuteCommands))}`,
+        `- Allow Shell: ${String(Boolean(state.agent?.allowShell))}`,
+        `- Allow File Write: ${String(Boolean(state.agent?.allowFileWrite))}`,
+        `- Multi Agent: ${String(Boolean(state.agent?.multiAgent))}`,
+        `- Workspace: ${state.workspaceRoot || '(无)'}`
+      ].join('\n');
+    } catch {
+      return result.output || result.message || '已读取应用状态。';
+    }
+  }
+
+  switch (intent?.reason) {
+  case 'file-exists':
+    return result.output || result.message || '已完成文件检查。';
+  case 'list-workspace':
+    return [
+      '当前工作区文件如下：',
+      '',
+      result.output || '(空目录)'
+    ].join('\n');
+  case 'read-file':
+    return [
+      `已读取 ${intent.command?.args?.path || '文件'}：`,
+      '',
+      result.output || '(空文件)'
+    ].join('\n');
+  case 'write-file':
+    return result.message || '文件已写入。';
+  case 'delete-file':
+    return result.message || '文件已删除。';
+  case 'explicit-shell':
+    return result.output || result.message || '系统命令已执行。';
+  case 'switch-provider-natural':
+    return result.output || result.message || '已切换提供方。';
+  case 'show-provider-status':
+  case 'show-app-state':
+  case 'show-config-summary':
+  case 'open-task-panel':
+  case 'open-memory-panel':
+  case 'open-sessions-panel':
+  case 'open-settings':
+  case 'open-command-palette':
+    return result.output || result.message || '已执行应用控制操作。';
+  default:
+    return result.output || result.message || '本地任务已执行。';
+  }
+}

package/src/modules/logger.mjs

@@ -0,0 +1,111 @@
+import fs from 'node:fs/promises';
+import { resolve } from 'node:path';
+import config from '../utils/config.mjs';
+
+export class Logger {
+  constructor({
+    dir = config.logger.dir,
+    filename = config.logger.filename,
+    maxSize = config.logger.maxSize,
+    maxFiles = config.logger.maxFiles,
+    fsModule = fs,
+    clock = () => new Date()
+  } = {}) {
+    this.dir = dir;
+    this.filename = filename;
+    this.maxSize = maxSize;
+    this.maxFiles = maxFiles;
+    this.fs = fsModule;
+    this.clock = clock;
+    this.logFile = resolve(this.dir, this.filename);
+    this.queue = [];
+    this.writing = false;
+  }
+
+  async init() {
+    try {
+      await this.fs.mkdir(this.dir, { recursive: true });
+    } catch (error) {
+      console.error('Failed to create log directory:', error.message);
+    }
+  }
+
+  async log(role, content) {
+    const timestamp = this.clock().toLocaleString('zh-CN');
+    const entry = `[${timestamp}] ${role}: ${content}\n`;
+
+    this.queue.push(entry);
+
+    if (!this.writing) {
+      await this._flush();
+    }
+  }
+
+  async _flush() {
+    if (this.queue.length === 0) return;
+
+    this.writing = true;
+
+    while (this.queue.length > 0) {
+      const entries = this.queue.splice(0, 10);
+      try {
+        await this.fs.appendFile(this.logFile, entries.join(''));
+        await this._rotateIfNeeded();
+      } catch (error) {
+        console.error('Failed to write log:', error.message);
+        this.queue.unshift(...entries);
+        break;
+      }
+    }
+
+    this.writing = false;
+  }
+
+  async _rotateIfNeeded() {
+    try {
+      const stats = await this.fs.stat(this.logFile);
+
+      if (stats.size > this.maxSize) {
+        const timestamp = this.clock().toISOString().replace(/[:.]/g, '-');
+        const archivePath = this.logFile.replace('.txt', `_${timestamp}.txt`);
+        await this.fs.rename(this.logFile, archivePath);
+
+        await this._cleanOldLogs();
+      }
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.error('Failed to rotate log:', error.message);
+      }
+    }
+  }
+
+  async _cleanOldLogs() {
+    try {
+      const files = await this.fs.readdir(this.dir);
+      const logFiles = files
+        .filter((file) => file.startsWith('chat_history') && file.endsWith('.txt'))
+        .map((file) => ({
+          name: file,
+          path: resolve(this.dir, file)
+        }));
+
+      if (logFiles.length > this.maxFiles) {
+        const stats = await Promise.all(
+          logFiles.map(async (file) => ({
+            ...file,
+            mtime: (await this.fs.stat(file.path)).mtime
+          }))
+        );
+
+        stats.sort((a, b) => a.mtime - b.mtime);
+
+        const toDelete = stats.slice(0, stats.length - this.maxFiles);
+        await Promise.all(toDelete.map((file) => this.fs.unlink(file.path)));
+      }
+    } catch (error) {
+      console.error('Failed to clean old logs:', error.message);
+    }
+  }
+}
+
+export default new Logger();

package/src/modules/multi-agent.mjs

@@ -0,0 +1,183 @@
+const AGENT_ROLE_DEFINITIONS = {
+  orchestrator: {
+    id: 'orchestrator',
+    label: '主控',
+    description: '负责拆解目标、选择下一步和汇总结果'
+  },
+  browser: {
+    id: 'browser',
+    label: '网页侦察',
+    description: '负责打开网页、读取页面、提取内容和浏览器操作'
+  },
+  shell: {
+    id: 'shell',
+    label: '系统执行',
+    description: '负责系统命令、脚本运行和工作区环境探查'
+  },
+  files: {
+    id: 'files',
+    label: '文件执行',
+    description: '负责读取、写入、删除和整理工作区文件'
+  },
+  operator: {
+    id: 'operator',
+    label: '人工接管',
+    description: '负责登录、验证码、授权和必须人工判断的步骤'
+  }
+};
+
+const ROLE_ALIASES = new Map([
+  ['planner', 'orchestrator'],
+  ['supervisor', 'orchestrator'],
+  ['manager', 'orchestrator'],
+  ['brain', 'orchestrator'],
+  ['browser', 'browser'],
+  ['web', 'browser'],
+  ['research', 'browser'],
+  ['researcher', 'browser'],
+  ['navigator', 'browser'],
+  ['shell', 'shell'],
+  ['terminal', 'shell'],
+  ['command', 'shell'],
+  ['executor', 'shell'],
+  ['files', 'files'],
+  ['file', 'files'],
+  ['writer', 'files'],
+  ['editor', 'files'],
+  ['operator', 'operator'],
+  ['handoff', 'operator'],
+  ['human', 'operator'],
+  ['manual', 'operator']
+]);
+
+const COMMAND_ROLE_HINTS = new Map([
+  ['open_url', 'browser'],
+  ['read_agent_page', 'browser'],
+  ['send_agent_page', 'browser'],
+  ['click_selector', 'browser'],
+  ['type_selector', 'browser'],
+  ['wait_for_text', 'browser'],
+  ['extract_selector_text', 'browser'],
+  ['wait_for_selector', 'browser'],
+  ['wait_for_navigation', 'browser'],
+  ['hover_selector', 'browser'],
+  ['press_key', 'browser'],
+  ['check_checkbox', 'browser'],
+  ['uncheck_checkbox', 'browser'],
+  ['select_option', 'browser'],
+  ['scroll_page', 'browser'],
+  ['screenshot_agent_page', 'browser'],
+  ['inspect_dom', 'browser'],
+  ['run_shell', 'shell'],
+  ['list_files', 'files'],
+  ['file_exists', 'files'],
+  ['read_file', 'files'],
+  ['write_file', 'files'],
+  ['delete_file', 'files'],
+  ['get_app_state', 'orchestrator'],
+  ['send_message', 'orchestrator'],
+  ['focus_chat_input', 'browser'],
+  ['send_chat_input', 'browser'],
+  ['submit_current_input', 'browser'],
+  ['start_new_chat', 'browser'],
+  ['handoff', 'operator']
+]);
+
+export function normalizeAgentRole(value) {
+  const normalized = String(value ?? '')
+    .trim()
+    .toLowerCase();
+
+  if (!normalized) {
+    return null;
+  }
+
+  return ROLE_ALIASES.get(normalized) || null;
+}
+
+export function inferAgentRoleFromCommand(command) {
+  if (!command?.name) {
+    return null;
+  }
+
+  return COMMAND_ROLE_HINTS.get(command.name) || null;
+}
+
+export function resolveEnvelopeAgentRole(payload = {}) {
+  return (
+    normalizeAgentRole(payload.agent) ||
+    normalizeAgentRole(payload.role) ||
+    normalizeAgentRole(payload.specialist) ||
+    inferAgentRoleFromCommand(payload.command) ||
+    (payload.type === 'handoff' ? 'operator' : null)
+  );
+}
+
+export function getAgentRoleLabel(role) {
+  return AGENT_ROLE_DEFINITIONS[role]?.label || '未指定';
+}
+
+export function getAgentRoleDescription(role) {
+  return AGENT_ROLE_DEFINITIONS[role]?.description || '';
+}
+
+export function getEnabledAgentRoster({
+  multiAgentEnabled = false,
+  allowShell = true,
+  allowFileWrite = true
+} = {}) {
+  const roster = [
+    AGENT_ROLE_DEFINITIONS.orchestrator,
+    AGENT_ROLE_DEFINITIONS.browser
+  ];
+
+  if (multiAgentEnabled && allowShell) {
+    roster.push(AGENT_ROLE_DEFINITIONS.shell);
+  }
+
+  if (multiAgentEnabled && allowFileWrite) {
+    roster.push(AGENT_ROLE_DEFINITIONS.files);
+  }
+
+  roster.push(AGENT_ROLE_DEFINITIONS.operator);
+  return roster;
+}
+
+export function buildMultiAgentPromptSection(options = {}) {
+  const {
+    multiAgentEnabled = false,
+    allowShell = true,
+    allowFileWrite = true
+  } = options;
+
+  if (!multiAgentEnabled) {
+    return '';
+  }
+
+  const roster = getEnabledAgentRoster({
+    multiAgentEnabled,
+    allowShell,
+    allowFileWrite
+  });
+
+  const rosterText = roster
+    .map((agent) => `${agent.id}: ${agent.description}`)
+    .join('；');
+
+  return [
+    '当前启用了多 Agent 协作模式。',
+    `可用角色: ${rosterText}。`,
+    '你仍然只代表一个总控 Agent 输出一个 JSON 对象，但要像在调度一支小队那样工作。',
+    '请优先思考哪一个角色最适合执行当前这一步，并尽量在 JSON 中附带可选字段 agent，值只能是 orchestrator、browser、shell、files、operator 之一。',
+    '如果这一步是观察网页、读取页面、点击或提取内容，agent 应优先是 browser。',
+    '如果这一步是系统命令或脚本执行，agent 应优先是 shell。',
+    '如果这一步是读写删文件，agent 应优先是 files。',
+    '如果这一步是需要你汇总、判断、继续规划或向模型发送后续消息，agent 应优先是 orchestrator。',
+    '如果这一步需要用户登录、验证码、授权或人工判断，agent 应优先是 operator，并使用 handoff。'
+  ].join(' ');
+}
+
+export {
+  AGENT_ROLE_DEFINITIONS,
+  COMMAND_ROLE_HINTS
+};

package/src/modules/navigation-recovery.mjs

@@ -0,0 +1,35 @@
+export function isRecoverableNavigationError(error) {
+  const message = String(error?.message || '');
+
+  return /ERR_CONNECTION_TIMED_OUT|ERR_TIMED_OUT|ERR_NAME_NOT_RESOLVED|ERR_CONNECTION_RESET|ERR_NETWORK_CHANGED|ERR_INTERNET_DISCONNECTED|ERR_CONNECTION_CLOSED|ERR_ABORTED|Timeout/i.test(
+    message
+  );
+}
+
+export function summarizeNavigationError(error) {
+  const message = String(error?.message || '未知错误');
+  return message.split('\n')[0].trim();
+}
+
+export function buildNavigationRecoveryRows({
+  title = '页面连接失败',
+  url = '',
+  attempt = 1,
+  maxAttempts = 1,
+  error = null
+} = {}) {
+  return {
+    title,
+    rows: [
+      { label: '目标', value: url || '(未知 URL)' },
+      { label: '尝试', value: `${attempt}/${maxAttempts}` },
+      { label: '错误', value: summarizeNavigationError(error) }
+    ]
+  };
+}
+
+export default {
+  isRecoverableNavigationError,
+  summarizeNavigationError,
+  buildNavigationRecoveryRows
+};

package/src/modules/provider-debug.mjs

@@ -0,0 +1,98 @@
+import fs from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+function sanitizeFilePart(value) {
+  return String(value ?? '')
+    .trim()
+    .replace(/[<>:"/\\|?*\x00-\x1F]/g, '-')
+    .replace(/\s+/g, '-')
+    .slice(0, 80);
+}
+
+export function parseProviderFilter(raw = '') {
+  return raw
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function filterProviders(providers, filterIds = []) {
+  if (filterIds.length === 0) {
+    return providers.filter((provider) => provider.enabled !== false);
+  }
+
+  const allow = new Set(filterIds);
+  return providers.filter((provider) => allow.has(provider.id));
+}
+
+export async function ensureArtifactDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+export async function saveProviderArtifacts({
+  artifactRoot,
+  providerId,
+  page,
+  payload
+}) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const safeProviderId = sanitizeFilePart(providerId);
+  const baseDir = resolve(artifactRoot, `${safeProviderId}-${stamp}`);
+
+  await ensureArtifactDir(baseDir);
+
+  const artifact = {
+    dir: baseDir
+  };
+
+  if (payload) {
+    const payloadPath = resolve(baseDir, 'result.json');
+    await fs.writeFile(payloadPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf-8');
+    artifact.payloadPath = payloadPath;
+  }
+
+  const browserManager = page?.__xshatBrowserManager;
+  const channelName = page?.__xshatChannelName || 'chat';
+  if (browserManager && typeof browserManager.readChannelSnapshot === 'function') {
+    try {
+      const snapshot = await browserManager.readChannelSnapshot(channelName, {
+        maxChars: 3000,
+        includeDomSummary: true,
+        includeObservation: true,
+        includeHtml: true
+      });
+      const observationPath = resolve(baseDir, 'page-observation.json');
+      await fs.writeFile(
+        observationPath,
+        `${JSON.stringify(snapshot, null, 2)}\n`,
+        'utf-8'
+      );
+      artifact.observationPath = observationPath;
+    } catch (error) {
+      artifact.observationError = error.message;
+    }
+  }
+
+  if (page?.content) {
+    try {
+      const html = await page.content();
+      const htmlPath = resolve(baseDir, 'page.html');
+      await fs.writeFile(htmlPath, html, 'utf-8');
+      artifact.htmlPath = htmlPath;
+    } catch (error) {
+      artifact.htmlError = error.message;
+    }
+  }
+
+  if (page?.screenshot) {
+    try {
+      const screenshotPath = resolve(baseDir, 'page.png');
+      await page.screenshot({ path: screenshotPath, fullPage: true });
+      artifact.screenshotPath = screenshotPath;
+    } catch (error) {
+      artifact.screenshotError = error.message;
+    }
+  }
+
+  return artifact;
+}