xshat-lite 1.0.0

package/src/modules/chat.mjs

@@ -0,0 +1,589 @@
+import config from '../utils/config.mjs';
+import ui from './ui.mjs';
+import { analyzeInterventionState } from './agent-helpers.mjs';
+import {
+  buildCompleteConfig,
+  deriveEffectiveText,
+  normalizeResult,
+  sanitizeMessage,
+  summarizeResult
+} from './chat-helpers.mjs';
+import {
+  getProviderInterruptedRetryLimit,
+  isProviderInterruptedText,
+  isProviderTransientText
+} from './provider-strategies.mjs';
+import { isStructuredResponseIncomplete } from './response-parser.mjs';
+
+class ChatManager {
+  constructor(page, provider) {
+    this.page = page;
+    this.provider = provider;
+    this.pollTimer = null;
+    this.debug = Boolean(config.debug?.enabled);
+    this.lastDebugSnapshot = '';
+    this.responseBaseline = null;
+  }
+
+  get steps() {
+    return this.provider.steps || {};
+  }
+
+  debugLog(message, details = null) {
+    if (!this.debug) return;
+
+    const time = new Date().toLocaleTimeString('zh-CN', { hour12: false });
+    const suffix = details ? ` ${JSON.stringify(details)}` : '';
+    process.stderr.write(`[DEBUG ${time}] [${this.provider.id}] ${message}${suffix}\n`);
+  }
+
+  async findFirstSelector(selectors, label = 'selector') {
+    for (const selector of selectors) {
+      try {
+        const count = await this.page.locator(selector).count();
+        if (count > 0) {
+          this.debugLog(`命中${label}`, { selector, count });
+          return selector;
+        }
+      } catch (error) {
+        this.debugLog('选择器异常', { label, selector, error: error.message });
+      }
+    }
+
+    this.debugLog(`未命中${label}`, { selectors });
+    return null;
+  }
+
+  async sendMessage(message) {
+    const cleanMessage = sanitizeMessage(message);
+
+    try {
+      await this.waitForIdleBeforeSend();
+      await this.runPreflight();
+      this.responseBaseline = await this.captureResponseBaseline();
+      await this.typeInInput(cleanMessage, {
+        waitAfterMs: config.chat.inputTimeout
+      });
+      await this.submitInput();
+
+      return true;
+    } catch (error) {
+      ui.printWarning(`消息注入失败: ${error.message}`);
+      return false;
+    }
+  }
+
+  async waitForIdleBeforeSend() {
+    const timeoutMs = Number(config.chat.idleBeforeSendTimeout) || 15000;
+    const stableThreshold = Number(config.chat.idleStableThreshold) || 2;
+    const idleAfterCompleteMs = Number(config.chat.idleAfterCompleteMs) || 1200;
+    const startTime = Date.now();
+    let stableCount = 0;
+    let lastFingerprint = '';
+    let lastChangedAt = Date.now();
+
+    while (Date.now() - startTime < timeoutMs) {
+      const result = this.normalizeResult(await this.getResult());
+
+      if (result.error) {
+        return;
+      }
+
+      const fingerprint = JSON.stringify({
+        text: result.text,
+        pending: result.pending,
+        done: result.done,
+        transient: result.transient,
+        count: result.count
+      });
+
+      if (fingerprint !== lastFingerprint) {
+        lastFingerprint = fingerprint;
+        lastChangedAt = Date.now();
+        stableCount = 0;
+      }
+
+      const quietForMs = Date.now() - lastChangedAt;
+      const idleCandidate =
+        !result.pending &&
+        !result.transient &&
+        (result.done || !result.text);
+
+      if (idleCandidate && quietForMs >= idleAfterCompleteMs) {
+        stableCount++;
+        if (stableCount >= stableThreshold) {
+          return;
+        }
+      } else {
+        stableCount = 0;
+      }
+
+      await this.page.waitForTimeout(config.chat.pollInterval);
+    }
+  }
+
+  async prepareInput(selector) {
+    const locator = this.page.locator(selector).first();
+    await locator.click({ force: true });
+    await locator.focus();
+
+    const modifier = process.platform === 'darwin' ? 'Meta' : 'Control';
+    await this.page.keyboard.press(`${modifier}+A`);
+    await this.page.keyboard.press('Backspace');
+  }
+
+  async injectText(text) {
+    const modifier = process.platform === 'darwin' ? 'Meta' : 'Control';
+    await this.page.evaluate(async (value) => {
+      await navigator.clipboard.writeText(value);
+    }, text);
+    await this.page.keyboard.press(`${modifier}+KeyV`);
+  }
+
+  async focusInput() {
+    const inputSelector = await this.findFirstSelector(
+      this.steps.input?.selectors || [],
+      '输入框'
+    );
+
+    if (!inputSelector) {
+      throw new Error('未找到输入框');
+    }
+
+    await this.prepareInput(inputSelector);
+    return inputSelector;
+  }
+
+  async typeInInput(text, options = {}) {
+    const inputSelector = await this.findFirstSelector(
+      this.steps.input?.selectors || [],
+      '输入框'
+    );
+
+    if (!inputSelector) {
+      throw new Error('未找到输入框');
+    }
+
+    await this.prepareInput(inputSelector);
+    await this.injectText(sanitizeMessage(text));
+
+    if (options.waitAfterMs !== 0) {
+      await this.page.waitForTimeout(
+        Number(options.waitAfterMs ?? config.chat.inputTimeout) || 0
+      );
+    }
+
+    return inputSelector;
+  }
+
+  async submitInput() {
+    const sendSelector = await this.findFirstSelector(
+      this.steps.send?.selectors || [],
+      '发送按钮'
+    );
+
+    if (sendSelector) {
+      await this.page.locator(sendSelector).first().click();
+      return sendSelector;
+    }
+
+    await this.page.keyboard.press('Enter');
+    return 'Enter';
+  }
+
+  async startNewChat() {
+    const candidates = [
+      ...(this.steps.newChat?.selectors || []),
+      'a[href*="/new"]',
+      'button[aria-label*="新建"]',
+      'button[aria-label*="New chat"]',
+      'button:has-text("新建对话")',
+      'button:has-text("新对话")',
+      'button:has-text("New chat")',
+      'button:has-text("New Chat")'
+    ];
+
+    const selector = await this.findFirstSelector(candidates, '新建聊天');
+
+    if (!selector) {
+      throw new Error('未找到新建聊天入口');
+    }
+
+    await this.page.locator(selector).first().click({
+      timeout: 5000,
+      force: true
+    });
+    await this.page.waitForTimeout(800);
+    this.responseBaseline = await this.captureResponseBaseline();
+    return selector;
+  }
+
+  async runPreflight() {
+    const preflight = this.steps.preflight || {};
+    const clickSelectors = preflight.clickSelectors || [];
+    const waitAfterMs = preflight.waitAfterMs || 500;
+
+    for (const selector of clickSelectors) {
+      try {
+        const locator = this.page.locator(selector).first();
+        const count = await this.page.locator(selector).count();
+
+        if (count === 0) {
+          continue;
+        }
+
+        this.debugLog('执行预处理点击', { selector, count });
+        await locator.click({ force: true, timeout: 2000 });
+        await this.page.waitForTimeout(waitAfterMs);
+      } catch (error) {
+        this.debugLog('预处理点击失败', {
+          selector,
+          error: error.message
+        });
+      }
+    }
+  }
+
+  buildCompleteConfig() {
+    return buildCompleteConfig(this.steps);
+  }
+
+  async captureResponseBaseline() {
+    const complete = this.buildCompleteConfig();
+    const selector = await this.findFirstSelector(
+      complete.selectors.response,
+      '基线读取节点'
+    );
+
+    if (!selector) {
+      return {
+        selector: null,
+        count: 0,
+        text: ''
+      };
+    }
+
+    const locator = this.page.locator(selector);
+    const count = await locator.count();
+    const text =
+      count > 0 ? (await locator.nth(count - 1).textContent()) || '' : '';
+
+    return {
+      selector,
+      count,
+      text
+    };
+  }
+
+  normalizeResult(result) {
+    const normalized = normalizeResult(result);
+    if (!normalized.transient && isProviderTransientText(this.provider.id, normalized.text)) {
+      return {
+        ...normalized,
+        transient: true
+      };
+    }
+    return normalized;
+  }
+
+  async runCompletionScript(script, selectors) {
+    const fn = new Function(`
+      return ({ selectors }) => {
+        const runner = (${script.trim()});
+        const result = runner({ selectors }) || {};
+
+        if (!Number.isFinite(result.count)) {
+          let count = 0;
+
+          for (const selector of selectors.response || []) {
+            try {
+              const nodes = document.querySelectorAll(selector);
+              if (nodes.length > 0) {
+                count = nodes.length;
+                break;
+              }
+            } catch {
+              // ignore invalid selectors and keep trying candidates
+            }
+          }
+
+          result.count = count;
+        }
+
+        return result;
+      };
+    `)();
+    const result = await this.page.evaluate(fn, { selectors });
+    return this.normalizeResult(result || null);
+  }
+
+  async getResult() {
+    try {
+      const complete = this.buildCompleteConfig();
+
+      if (complete.mode === 'script' && complete.script) {
+        return await this.runCompletionScript(complete.script, complete.selectors);
+      }
+
+      const responseSelector = await this.findFirstSelector(
+        complete.selectors.response,
+        '读取节点'
+      );
+
+      if (!responseSelector) {
+        return this.normalizeResult(null);
+      }
+
+      const locator = this.page.locator(responseSelector);
+      const count = await locator.count();
+      const text = count > 0 ? await locator.nth(count - 1).textContent() : '';
+      return this.normalizeResult({
+        text: text || '',
+        pending: false,
+        done: !!text,
+        count
+      });
+    } catch (error) {
+      return this.normalizeResult({ error: error.message });
+    }
+  }
+
+  summarizeResult(result) {
+    return summarizeResult(result);
+  }
+
+  async inspectSite() {
+    const inputSelector = await this.findFirstSelector(
+      this.steps.input?.selectors || [],
+      '输入框'
+    );
+    const sendSelector = await this.findFirstSelector(
+      this.steps.send?.selectors || [],
+      '发送按钮'
+    );
+    const readSelector = await this.findFirstSelector(
+      this.steps.read?.selectors || [],
+      '读取节点'
+    );
+    const complete = this.buildCompleteConfig();
+    const result = await this.getResult();
+    const intervention = await this.inspectInterventionState({
+      inputSelector,
+      sendSelector
+    });
+    const observation = await this.inspectPageObservation();
+
+    return {
+      provider: this.provider.id,
+      inputSelector,
+      sendSelector,
+      readSelector,
+      completionMode: complete.mode,
+      result: this.summarizeResult(result),
+      intervention,
+      observation
+    };
+  }
+
+  async inspectPageObservation() {
+    const browserManager = this.page?.__xshatBrowserManager;
+    const channelName = this.page?.__xshatChannelName || 'chat';
+
+    if (!browserManager || typeof browserManager.readChannelSnapshot !== 'function') {
+      return null;
+    }
+
+    try {
+      return await browserManager.readChannelSnapshot(channelName, {
+        maxChars: 1500,
+        includeDomSummary: true,
+        includeObservation: true
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  async readVisibleText() {
+    try {
+      return await this.page.evaluate(() => document.body?.innerText || '');
+    } catch {
+      return '';
+    }
+  }
+
+  async inspectInterventionState(prefetched = {}) {
+    const inputSelector =
+      prefetched.inputSelector !== undefined
+        ? prefetched.inputSelector
+        : await this.findFirstSelector(this.steps.input?.selectors || [], '输入框');
+    const sendSelector =
+      prefetched.sendSelector !== undefined
+        ? prefetched.sendSelector
+        : await this.findFirstSelector(this.steps.send?.selectors || [], '发送按钮');
+
+    return analyzeInterventionState({
+      providerId: this.provider.id,
+      url: this.page?.url?.() || '',
+      visibleText: await this.readVisibleText(),
+      inputSelector,
+      sendSelector
+    });
+  }
+
+  async waitForResponse(onChunk, options = {}) {
+    return new Promise((resolve, reject) => {
+      let textLength = 0;
+      let stableCount = 0;
+      let finalContent = '';
+      let lastEffectiveText = '';
+      let noChangeCount = 0;
+      let interruptedCount = 0;
+      const startTime = Date.now();
+      let lastTextChangeAt = startTime;
+      const timeoutMs = Number(options.timeoutMs) || config.chat.responseTimeout;
+      const quietAfterChangeMs =
+        Number(options.quietAfterChangeMs) ||
+        Number(config.chat.idleAfterCompleteMs) ||
+        1200;
+      const allowEmptyOnTimeout = Boolean(options.allowEmptyOnTimeout);
+      const allowInterruptedRetry = options.allowInterruptedRetry !== false;
+      const interruptedRetryLimit = getProviderInterruptedRetryLimit(this.provider.id);
+      const baseline = this.responseBaseline || {
+        selector: null,
+        count: 0,
+        text: ''
+      };
+
+      this.pollTimer = setInterval(async () => {
+        try {
+          if (Date.now() - startTime > timeoutMs) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+            if (finalContent) {
+              resolve(finalContent.trim());
+            } else if (allowEmptyOnTimeout) {
+              resolve('');
+            } else {
+              reject(new Error('响应超时'));
+            }
+            return;
+          }
+
+          const result = this.normalizeResult(await this.getResult());
+          const { text, done, pending, error, count, transient } = result;
+          const effectiveText = deriveEffectiveText(result, baseline);
+
+          if (this.debug) {
+            const snapshot = JSON.stringify({
+              textLength: text.length,
+              pending,
+              done,
+              error,
+              count,
+              transient
+            });
+
+            if (snapshot !== this.lastDebugSnapshot) {
+              this.lastDebugSnapshot = snapshot;
+              this.debugLog('轮询结果', this.summarizeResult(result));
+            }
+          }
+
+          if (error) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+            reject(new Error(error));
+            return;
+          }
+
+          if (transient) {
+            return;
+          }
+
+          if (
+            allowInterruptedRetry &&
+            isProviderInterruptedText(this.provider.id, effectiveText)
+          ) {
+            interruptedCount++;
+            if (interruptedCount <= interruptedRetryLimit) {
+              noChangeCount = 0;
+              stableCount = 0;
+              return;
+            }
+          }
+
+          if (pending && !effectiveText) {
+            return;
+          }
+
+          const textChanged = effectiveText !== lastEffectiveText;
+
+          if (textChanged) {
+            const previousText = lastEffectiveText;
+            const canStreamIncrementally =
+              effectiveText.length > previousText.length &&
+              effectiveText.startsWith(previousText);
+
+            if (canStreamIncrementally) {
+              const newText = effectiveText.slice(previousText.length);
+              if (typeof onChunk === 'function' && newText) {
+                onChunk(newText, previousText.length === 0);
+              }
+            }
+
+            finalContent = effectiveText;
+            textLength = effectiveText.length;
+            lastEffectiveText = effectiveText;
+            lastTextChangeAt = Date.now();
+            stableCount = 0;
+            noChangeCount = 0;
+          } else {
+            noChangeCount++;
+          }
+
+          const quietForMs = Date.now() - lastTextChangeAt;
+          const settled = quietForMs >= quietAfterChangeMs;
+
+          if (done && effectiveText.length === textLength && textLength > 0 && settled) {
+            if (isStructuredResponseIncomplete(finalContent)) {
+              stableCount = 0;
+              return;
+            }
+            stableCount++;
+          }
+
+          if (noChangeCount > 30 && finalContent.length > 0 && settled) {
+            if (isStructuredResponseIncomplete(finalContent)) {
+              noChangeCount = 0;
+              return;
+            }
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+            resolve(finalContent.trim());
+            return;
+          }
+
+          if (stableCount >= config.chat.stableThreshold) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+            resolve(finalContent.trim());
+          }
+        } catch (error) {
+          clearInterval(this.pollTimer);
+          this.pollTimer = null;
+          reject(error);
+        }
+      }, config.chat.pollInterval);
+    });
+  }
+
+  cleanup() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+}
+
+export default ChatManager;

package/src/modules/docs.mjs

@@ -0,0 +1,88 @@
+export function buildQuickStartDoc() {
+  return `
+# XShat 使用说明
+
+## 1. 开始使用
+
+1. 启动程序后选择：
+- \`c\` 继续当前聊天（有活跃会话时出现）
+- \`1\` 新建聊天
+- \`2\` 恢复历史会话
+- \`s\` 系统设置
+- \`d\` 查看文档
+- \`q\` 退出程序
+
+2. 默认提供方在系统设置里统一管理。
+   新建聊天、任务执行都会优先使用这里设置的默认提供方。
+
+3. 直接输入问题开始聊天。
+
+---
+
+## 2. 常用命令
+
+- \`/help\`：查看聊天内可用命令
+- 历史会话 / 任务面板支持 \`W/S\` 或方向键选择，\`A/D\` 或左右键翻页，\`Q\` / \`Esc\` 返回
+- \`/status\`：查看当前运行状态、阻塞信息与推荐操作
+- \`/doc\`：查看这份简要文档
+- \`/menu\`：返回主菜单
+- \`/quit\`：退出程序
+- \`/sessions\`：打开历史会话浏览器
+- \`/resume\`：恢复最近一条历史会话
+- \`/rename-session\`：修改当前会话标题
+- \`/delete-session\`：删除当前会话
+- \`/task\`：打开任务面板
+- \`/mode\`：切换普通模式 / Agent 模式
+- \`/model\`：打开系统设置中的提供方配置
+- \`/inspect\`：检查当前聊天网页适配状态
+- \`/agent\`：手动进入人工接管流程
+- \`/paste\`：进入多行粘贴模式
+- \`/config\`：进入系统设置
+- 主菜单 \`s\`：进入系统设置
+
+---
+
+## 3. Agent 模式说明
+
+- Agent 模式会要求网页模型尽量输出结构化 JSON。
+- 程序会解析回复，识别普通回答、命令、人工接管、错误。
+- 如果模型要求打开网页、读取页面、执行命令，程序会先询问你是否执行；开启自动执行后会自动运行。
+- 遇到登录、验证码、人工验证时，可以手动接管。
+- 开启“多 Agent 协作”后，会按主控、网页侦察、系统执行、文件执行、人工接管这几类角色来分工和显示时间线。
+- XShat 的底层思路不是只绑定一个模型，而是优先使用免费网页大模型；当前提供方卡住时，可以自动切换到下一个提供方继续任务。
+
+---
+
+## 4. Agent 能做什么
+
+- 打开网页、等待页面加载、读取页面文本
+- 点击、输入、滚动、按键、下拉框选择
+- 读取应用内部状态
+- 直接聚焦聊天输入框、填写聊天框、提交消息、新建网页对话
+- 读取、写入、删除工作区文件
+- 执行系统命令
+- 如果开启“统一登录态”，聊天通道和 Agent 通道会尽量同步登录状态
+
+---
+
+## 5. 小提示
+
+- 多行内容可以先输入 \`/paste\`，粘贴完成后单独输入 \`/end\` 发送，输入 \`/cancel\` 取消。
+- 如果多轮对话变长，程序会自动压缩较早上下文，只保留最近几轮原文。
+- 如果某个网页模型回复不稳定，可以去系统设置切换默认提供方后继续当前任务。
+- 也可以在系统设置中开启“自动故障切换”，让程序优先在多个网页提供方之间自动接力。
+- 如果想使用 API 提供方，可设置环境变量：
+  - \`OPENAI_API_KEY\` / \`OPENAI_BASE_URL\` / \`OPENAI_MODEL\`
+  - \`DEEPSEEK_API_KEY\` / \`DEEPSEEK_BASE_URL\` / \`DEEPSEEK_MODEL\`
+- 如果页面卡在登录或验证，输入 \`/agent\` 更方便。
+- 如果你不希望程序弹出可见浏览器，可在系统设置中关闭“允许可见浏览器”；关闭后，遇到登录或验证只会提示你手动处理，不会自动开窗口。
+- 如果要长期挂着干活，可以在系统设置里打开“长时运行模式”和“自动恢复”。
+- 如果想让 Agent 更像任务型产品，可以在系统设置里打开“多 Agent 协作”，更容易看出当前是哪一类角色在推进。
+- 任务面板支持单次执行、持续循环、轮询监控、定时间隔，并可设置失败重试。
+- 程序启动时会自动清理临时文件，并把超出保留上限的旧会话、旧任务归档到 \`runtime/archive\`。
+`.trim();
+}
+
+export default {
+  buildQuickStartDoc
+};