xshat-lite 1.0.0

package/src/modules/agent-helpers.mjs

@@ -0,0 +1,132 @@
+const RULES = [
+  {
+    kind: 'verification',
+    label: '人机验证',
+    reasons: [
+      /captcha/i,
+      /verify (that )?you(?:'| a)?re human/i,
+      /human verification/i,
+      /prove you(?:'| a)?re human/i,
+      /security check/i,
+      /not a robot/i,
+      /人机验证/,
+      /安全验证/,
+      /验证.*人类/,
+      /验证.*真人/
+    ]
+  },
+  {
+    kind: 'login',
+    label: '登录',
+    reasons: [
+      /\blog in\b/i,
+      /\blog on\b/i,
+      /\bsign in\b/i,
+      /please log in/i,
+      /please sign in/i,
+      /登录/,
+      /登入/,
+      /请先登录/,
+      /继续使用.*登录/,
+      /手机号登录/,
+      /验证码登录/
+    ]
+  },
+  {
+    kind: 'access',
+    label: '站点限制',
+    reasons: [
+      /unable to load site/i,
+      /access denied/i,
+      /request blocked/i,
+      /temporarily unavailable/i,
+      /service unavailable/i
+    ]
+  }
+];
+
+const URL_HINTS = [
+  {
+    kind: 'verification',
+    label: '人机验证',
+    pattern: /(captcha|challenge|verify)/i
+  },
+  {
+    kind: 'login',
+    label: '登录',
+    pattern: /(login|signin|sign-in|auth)/i
+  }
+];
+
+function compactText(text) {
+  return String(text ?? '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 4000);
+}
+
+export function analyzeInterventionState({
+  providerId = '',
+  url = '',
+  visibleText = '',
+  inputSelector = null,
+  sendSelector = null
+} = {}) {
+  const normalizedUrl = String(url ?? '');
+  const normalizedText = compactText(visibleText);
+  const matches = [];
+  let urlMatch = null;
+  let textMatch = null;
+
+  for (const hint of URL_HINTS) {
+    if (hint.pattern.test(normalizedUrl)) {
+      urlMatch = {
+        kind: hint.kind,
+        label: hint.label,
+        evidence: `URL: ${normalizedUrl}`
+      };
+      matches.push(urlMatch);
+      break;
+    }
+  }
+
+  for (const rule of RULES) {
+    const reason = rule.reasons.find((pattern) => pattern.test(normalizedText));
+    if (reason) {
+      textMatch = {
+        kind: rule.kind,
+        label: rule.label,
+        evidence: reason.source
+      };
+      matches.push(textMatch);
+      break;
+    }
+  }
+
+  const primary = matches[0] || null;
+  const missingComposer = !inputSelector && !sendSelector;
+  const blocked = Boolean(
+    urlMatch ||
+    (textMatch?.kind === 'verification') ||
+    (textMatch?.kind === 'login' && missingComposer) ||
+    (textMatch?.kind === 'access' && missingComposer)
+  );
+
+  return {
+    blocked,
+    providerId,
+    kind: primary?.kind || null,
+    label: primary?.label || null,
+    reason: primary
+      ? `检测到可能需要${primary.label}`
+      : '未检测到需要人工介入的阻塞',
+    url: normalizedUrl,
+    visibleText: normalizedText,
+    inputSelector: inputSelector || null,
+    sendSelector: sendSelector || null,
+    missingComposer,
+    urlMatched: Boolean(urlMatch),
+    textMatched: Boolean(textMatch),
+    evidence: matches.map((item) => item.evidence)
+  };
+}

package/src/modules/agent-loop.mjs

@@ -0,0 +1,181 @@
+import { buildAgentFollowupMessage } from './chat-helpers.mjs';
+import { inferAgentRoleFromCommand } from './multi-agent.mjs';
+import { normalizeResponseEnvelope } from './response-pipeline.mjs';
+
+function attachResultAgent(result, envelope) {
+  if (!result || typeof result !== 'object') {
+    return result;
+  }
+
+  if (!result.agent) {
+    result.agent = envelope?.agent || inferAgentRoleFromCommand(envelope?.command) || null;
+  }
+
+  return result;
+}
+
+export async function runAgentLoop({
+  initialEnvelope,
+  initialStep = 0,
+  maxSteps = 1,
+  agentExecutor,
+  requestFollowupResponse,
+  parseEnvelope = (rawResponse) => normalizeResponseEnvelope(rawResponse, {
+    agentMode: true
+  }),
+  onBeforeCommand,
+  onAfterCommand,
+  onFollowupResponse
+} = {}) {
+  let envelope = initialEnvelope;
+  let step = initialStep;
+  const cappedMaxSteps = Math.max(1, Number(maxSteps) || 1);
+
+  while (true) {
+    if (envelope?.kind === 'handoff') {
+      return {
+        status: 'handoff',
+        envelope,
+        step
+      };
+    }
+
+    if (envelope?.kind !== 'command' || !envelope?.command) {
+      return {
+        status: 'message',
+        envelope,
+        step
+      };
+    }
+
+    const nextStep = step + 1;
+
+    if (typeof onBeforeCommand === 'function') {
+      const gate = await onBeforeCommand({
+        envelope,
+        step: nextStep,
+        maxSteps: cappedMaxSteps
+      });
+
+      if (gate?.stop) {
+        return {
+          status: gate.status || 'cancelled',
+          envelope,
+          step: nextStep
+        };
+      }
+    }
+
+    const result = attachResultAgent(
+      await agentExecutor.execute(envelope.command),
+      envelope
+    );
+
+    if (typeof onAfterCommand === 'function') {
+      await onAfterCommand({
+        envelope,
+        result,
+        step: nextStep,
+        maxSteps: cappedMaxSteps
+      });
+    }
+
+    if (!result?.ok) {
+      if (result?.recoverable && nextStep < cappedMaxSteps) {
+        const followupMessage = buildAgentFollowupMessage(result, {
+          step: nextStep,
+          maxSteps: cappedMaxSteps,
+          completion: {
+            status: 'recoverable-error',
+            reason: result.error || '命令执行失败',
+            guidance:
+              '上一条浏览器/系统动作失败，但宿主判断这类错误可恢复。请不要重复同一命令原样硬点；应基于错误原因调整策略，例如换 selector、先 wait_for_selector、scroll_page、inspect_dom、extract_selector_text，或先读取页面状态再继续。'
+          }
+        });
+
+        const rawResponse = await requestFollowupResponse(followupMessage, {
+          followupStep: nextStep,
+          step: nextStep,
+          maxSteps: cappedMaxSteps,
+          result
+        });
+
+        envelope = parseEnvelope(rawResponse);
+        step = nextStep;
+
+        if (typeof onFollowupResponse === 'function') {
+          await onFollowupResponse({
+            rawResponse,
+            envelope,
+            step,
+            maxSteps: cappedMaxSteps
+          });
+        }
+
+        continue;
+      }
+
+      return {
+        status: 'error',
+        envelope,
+        result,
+        step: nextStep
+      };
+    }
+
+    if (result.handoff) {
+      return {
+        status: 'handoff',
+        envelope,
+        result,
+        step: nextStep
+      };
+    }
+
+    if (!agentExecutor.shouldContinue(result)) {
+      return {
+        status: 'completed',
+        envelope,
+        result,
+        step: nextStep
+      };
+    }
+
+    if (nextStep >= cappedMaxSteps) {
+      return {
+        status: 'limit',
+        envelope,
+        result,
+        step: nextStep
+      };
+    }
+
+    const followupMessage = buildAgentFollowupMessage(result, {
+      step: nextStep,
+      maxSteps: cappedMaxSteps
+    });
+
+    const rawResponse = await requestFollowupResponse(followupMessage, {
+      followupStep: nextStep,
+      step: nextStep,
+      maxSteps: cappedMaxSteps,
+      result
+    });
+
+    envelope = parseEnvelope(rawResponse);
+    step = nextStep;
+
+    if (typeof onFollowupResponse === 'function') {
+      await onFollowupResponse({
+        rawResponse,
+        envelope,
+        step,
+        maxSteps: cappedMaxSteps
+      });
+    }
+  }
+}
+
+export default {
+  runAgentLoop
+};

package/src/modules/agent.mjs

@@ -0,0 +1,152 @@
+function isAffirmative(answer) {
+  const normalized = String(answer ?? '')
+    .trim()
+    .toLowerCase();
+  return ['y', 'yes', 'done', 'ok', '好了', '完成'].includes(normalized);
+}
+
+function buildBlockedByPolicyRows({
+  diagnosis = {},
+  stage = '',
+  error = null
+} = {}) {
+  return [
+    { label: '阻塞类型', value: diagnosis.label || diagnosis.kind || '人工介入' },
+    { label: '阶段', value: stage || '(未知)' },
+    { label: '原因', value: diagnosis.reason || '检测到需要人工处理的页面状态' },
+    { label: '当前页面', value: diagnosis.url || '(未知)' },
+    {
+      label: '触发原因',
+      value: error?.message || '页面可能需要登录、验证码、权限确认或人工判断'
+    },
+    { label: '可见浏览器', value: '当前配置已禁用' },
+    {
+      label: '建议下一步',
+      value: '如需手动接管，请先在 /config 中开启“允许可见浏览器”，或改用已登录的 USER_DATA_DIR 后重试。'
+    }
+  ];
+}
+
+export class ConversationAgent {
+  constructor({ browserManager, ui, prompt }) {
+    this.browserManager = browserManager;
+    this.ui = ui;
+    this.prompt = prompt;
+  }
+
+  async diagnose(chatManager) {
+    if (!chatManager || typeof chatManager.inspectInterventionState !== 'function') {
+      return {
+        blocked: false,
+        reason: '',
+        url: '',
+        providerId: chatManager?.provider?.id || null
+      };
+    }
+
+    return chatManager.inspectInterventionState();
+  }
+
+  async handleIntervention({ chatManager, stage, error }) {
+    const diagnosis = await this.diagnose(chatManager);
+
+    if (!diagnosis.blocked) {
+      return {
+        handled: false,
+        diagnosis
+      };
+    }
+
+    this.ui.stopSpinner?.();
+    this.ui.printWarning(`${diagnosis.reason}，当前阶段: ${stage}`);
+    if (error?.message) {
+      this.ui.printInfo(`触发原因: ${error.message}`);
+    }
+    if (diagnosis.url) {
+      this.ui.printInfo(`当前页面: ${diagnosis.url}`);
+    }
+
+    const consent = await this.prompt(
+      '是否切换到可见浏览器，由你手动完成后继续？(y/n) '
+    );
+
+    if (!isAffirmative(consent)) {
+      return {
+        handled: false,
+        diagnosis,
+        declined: true
+      };
+    }
+
+    const targetUrl = diagnosis.url || chatManager.provider.url;
+    const shouldRestoreHeadless =
+      this.browserManager?.browserConfig?.headless !== false;
+    const allowVisibleBrowser =
+      this.browserManager?.browserConfig?.allowVisibleBrowser !== false;
+
+    if (!allowVisibleBrowser) {
+      if (typeof this.ui.printActionPanel === 'function') {
+        this.ui.printActionPanel(
+          '人工接管受限',
+          buildBlockedByPolicyRows({
+            diagnosis,
+            stage,
+            error
+          })
+        );
+      } else {
+        this.ui.printInfo('当前配置禁止切换到可见浏览器，请手动开启 browser.allowVisibleBrowser 后再进行人工接管。');
+      }
+      return {
+        handled: false,
+        diagnosis,
+        blockedByPolicy: true
+      };
+    }
+
+    await this.browserManager.relaunch({
+      headless: false,
+      url: targetUrl
+    });
+
+    this.ui.printSuccess('已切换到可见浏览器');
+    this.ui.printInfo('请在浏览器里完成登录、验证码或权限确认。');
+    if (this.browserManager?.browserConfig?.shareAuthState) {
+      this.ui.printInfo('登录状态会保留在当前 USER_DATA_DIR，并尽量同步到聊天/Agent 通道。');
+    }
+
+    while (true) {
+      const answer = await this.prompt(
+        '完成后输入 done 继续，输入 cancel 取消: '
+      );
+      const normalized = String(answer ?? '')
+        .trim()
+        .toLowerCase();
+
+      if (normalized === 'cancel' || normalized === 'n' || normalized === 'no') {
+        return {
+          handled: false,
+          diagnosis,
+          cancelled: true
+        };
+      }
+
+      if (isAffirmative(normalized)) {
+        if (shouldRestoreHeadless) {
+          await this.browserManager.relaunch({
+            headless: true,
+            url: targetUrl
+          });
+          this.ui.printSuccess('已恢复为默认浏览器模式');
+        }
+
+        return {
+          handled: true,
+          diagnosis
+        };
+      }
+    }
+  }
+}
+
+export default ConversationAgent;

package/src/modules/api-chat.mjs

@@ -0,0 +1,212 @@
+import config from '../utils/config.mjs';
+
+function normalizeMessages(messages = []) {
+  return messages
+    .map((message) => {
+      if (typeof message === 'string') {
+        return {
+          role: 'user',
+          content: message
+        };
+      }
+
+      return {
+        role: message.role || 'user',
+        content: String(message.content ?? '')
+      };
+    })
+    .filter((message) => message.content.trim());
+}
+
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function extractAssistantContent(data = {}) {
+  const message = data?.choices?.[0]?.message;
+  const directContent = message?.content ?? data?.choices?.[0]?.text ?? '';
+
+  if (typeof directContent === 'string') {
+    return directContent;
+  }
+
+  if (Array.isArray(directContent)) {
+    return directContent
+      .map((part) => {
+        if (typeof part === 'string') {
+          return part;
+        }
+
+        if (part && typeof part === 'object') {
+          return part.text || part.content || '';
+        }
+
+        return '';
+      })
+      .join('');
+  }
+
+  return '';
+}
+
+export default class ApiChatManager {
+  constructor(provider) {
+    this.provider = provider;
+    this.messageHistory = [];
+    this.pendingMessages = [];
+  }
+
+  get apiConfig() {
+    const providerApi = this.provider.api || {};
+    const globalApi = config.api || {};
+    const envPrefix = String(providerApi.envPrefix || 'OPENAI').toUpperCase();
+
+    return {
+      baseUrl:
+        process.env[`${envPrefix}_BASE_URL`] ||
+        providerApi.baseUrl ||
+        globalApi.baseUrl ||
+        'https://api.openai.com/v1',
+      apiKey:
+        process.env[`${envPrefix}_API_KEY`] ||
+        providerApi.apiKey ||
+        globalApi.apiKey ||
+        '',
+      model:
+        process.env[`${envPrefix}_MODEL`] ||
+        providerApi.model ||
+        globalApi.model ||
+        'gpt-4o-mini',
+      headers: providerApi.headers || {},
+      responseFormat:
+        providerApi.responseFormat ||
+        globalApi.responseFormat ||
+        null,
+      temperature:
+        Number.isFinite(providerApi.temperature)
+          ? providerApi.temperature
+          : Number.isFinite(globalApi.temperature)
+            ? globalApi.temperature
+            : 0.2
+    };
+  }
+
+  async sendMessage(message) {
+    const normalized = normalizeMessages(
+      Array.isArray(message) ? message : [{ role: 'user', content: message }]
+    );
+
+    if (normalized.length === 0) {
+      return false;
+    }
+
+    this.pendingMessages = normalized;
+    this.messageHistory.push(...deepClone(normalized));
+    return true;
+  }
+
+  rollbackPendingMessages() {
+    const pendingCount = this.pendingMessages.length;
+    if (pendingCount > 0 && this.messageHistory.length >= pendingCount) {
+      this.messageHistory.splice(this.messageHistory.length - pendingCount, pendingCount);
+    }
+    this.pendingMessages = [];
+  }
+
+  async waitForResponse(onChunk = () => {}) {
+    const {
+      baseUrl,
+      apiKey,
+      model,
+      headers,
+      responseFormat,
+      temperature
+    } = this.apiConfig;
+
+    if (!apiKey) {
+      throw new Error(
+        `API 提供方 ${this.provider.name} 缺少密钥，请设置 ${String(
+          this.provider.api?.envPrefix || 'OPENAI'
+        ).toUpperCase()}_API_KEY`
+      );
+    }
+
+    let response;
+
+    try {
+      const body = {
+        model,
+        messages: this.messageHistory,
+        temperature,
+        stream: false
+      };
+
+      if (responseFormat) {
+        body.response_format = responseFormat;
+      }
+
+      response = await fetch(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          authorization: `Bearer ${apiKey}`,
+          ...headers
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (error) {
+      this.rollbackPendingMessages();
+      throw error;
+    }
+
+    if (!response.ok) {
+      const detail = await response.text().catch(() => '');
+      this.rollbackPendingMessages();
+      throw new Error(`API 请求失败: ${response.status} ${detail}`.trim());
+    }
+
+    const data = await response.json();
+    const content = extractAssistantContent(data);
+
+    if (content) {
+      onChunk(content, true);
+      this.messageHistory.push({
+        role: 'assistant',
+        content
+      });
+    }
+
+    this.pendingMessages = [];
+    return String(content || '').trim();
+  }
+
+  async inspectSite() {
+    const { baseUrl, model } = this.apiConfig;
+    return {
+      provider: this.provider.id,
+      inputSelector: '(API 模式)',
+      sendSelector: '(HTTP 请求)',
+      readSelector: '(响应体)',
+      completionMode: 'api',
+      result: {
+        pending: false,
+        done: true,
+        error: null,
+        preview: `${baseUrl} :: ${model}`
+      },
+      intervention: null,
+      observation: null
+    };
+  }
+
+  async inspectInterventionState() {
+    return {
+      blocked: false,
+      reason: '',
+      url: '',
+      providerId: this.provider.id
+    };
+  }
+
+  cleanup() {}
+}