@yeaft/webchat-agent 0.1.667 → 0.1.669

package/connection/message-router.js

@@ -35,7 +35,7 @@ import {
 import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
-import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings } from '../unify/config-api.js';
+import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../unify/config-api.js';
 import { handleUnifyChat, handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyFeatureMessage, handleUnifyFetchSummaryHistory, handleUnifyFeatureCrud, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyDeleteGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
@@ -355,6 +355,29 @@ export async function handleMessage(msg) {
       break;
     }
 
+    // Search settings (web-search backend + Tavily key) — read/write the
+    // `search` section of config.json. `get_tavily_usage` hits Tavily's
+    // /usage endpoint with the saved key and is fired from the UI only
+    // when the Search tab opens or the user clicks "Refresh" (no polling
+    // — the user explicitly asked for live read on open).
+    case 'get_search_settings': {
+      const settings = getSearchSettings(ctx.CONFIG?.yeaftDir);
+      sendToServer({ type: 'search_settings', ...settings });
+      break;
+    }
+
+    case 'update_search_settings': {
+      const result = updateSearchSettings(msg.settings || msg.config || {}, ctx.CONFIG?.yeaftDir);
+      sendToServer({ type: 'search_settings_updated', ...result });
+      break;
+    }
+
+    case 'get_tavily_usage': {
+      const usage = await fetchTavilyUsage(ctx.CONFIG?.yeaftDir);
+      sendToServer({ type: 'tavily_usage', ...usage });
+      break;
+    }
+
     // Unify — independent chat via Engine
     case 'unify_chat':
       await handleUnifyChat(msg);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.667",
+  "version": "0.1.669",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",
@@ -10,7 +10,8 @@
   },
   "scripts": {
     "start": "node index.js",
-    "dev": "nodemon index.js"
+    "dev": "nodemon index.js",
+    "postinstall": "node scripts/check-pty.js"
   },
   "engines": {
     "node": ">=22.5.0"

package/scripts/check-pty.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * agent/scripts/check-pty.js — postinstall sanity check for node-pty.
+ *
+ * Why this exists:
+ *   `node-pty` is an optionalDependency. npm install swallows install
+ *   failures silently — when the native module fails to build (e.g.
+ *   Linux x64, where node-pty's tarball ships no prebuilds and the
+ *   host g++ is too old to compile C++20), the agent loses its
+ *   `terminal` capability with zero user-facing signal. The web UI's
+ *   Terminal tab silently disappears.
+ *
+ *   This postinstall script makes that failure visible: if we're on a
+ *   platform where node-pty was supposed to install but didn't, print
+ *   a clear warning with the recovery command. We never fail the
+ *   install — pty is genuinely optional, and required-feature mode
+ *   would block users who don't need a Terminal tab.
+ *
+ * Exit code is always 0 — we only print, never abort.
+ */
+
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { platform } from 'os';
+
+const require = createRequire(import.meta.url);
+
+function tryResolveNodePty() {
+  try {
+    return require.resolve('node-pty');
+  } catch {
+    return null;
+  }
+}
+
+function tryLoadBinary() {
+  // node-pty's lib/index.js does `require('../build/Release/pty.node')`
+  // — if the binary is missing or ABI-incompatible, that throws. We
+  // mimic the load eagerly so the warning fires at install time, not
+  // at agent startup.
+  try {
+    require('node-pty');
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+const resolved = tryResolveNodePty();
+if (!resolved) {
+  // node-pty was never installed at all — npm skipped it for the
+  // current platform/engine combination.
+  const plat = platform();
+  if (plat === 'linux' || plat === 'darwin' || plat === 'win32') {
+    console.warn('');
+    console.warn('  ⚠  node-pty was not installed on this host.');
+    console.warn('     The agent will run, but the web UI Terminal tab');
+    console.warn('     will be hidden (terminal capability missing).');
+    if (plat === 'linux') {
+      console.warn('');
+      console.warn('     Linux fix: install a C++20-capable compiler');
+      console.warn('     (g++-10 or newer) and rebuild:');
+      console.warn('');
+      console.warn('       sudo apt-get install -y g++-10');
+      console.warn('       CXX=g++-10 npm install node-pty --include=optional');
+    } else {
+      console.warn('');
+      console.warn('     Reinstall to retry:  npm install node-pty');
+    }
+    console.warn('');
+  }
+  process.exit(0);
+}
+
+const loaded = tryLoadBinary();
+if (!loaded.ok) {
+  console.warn('');
+  console.warn('  ⚠  node-pty resolved but failed to load native binary.');
+  console.warn(`     Error: ${loaded.error}`);
+  console.warn('     The agent will run without Terminal tab support.');
+  console.warn('     Recover: npm rebuild node-pty');
+  console.warn('');
+  process.exit(0);
+}
+
+// Silent on success — clean install output.
+process.exit(0);

package/unify/config-api.js

@@ -215,3 +215,154 @@ export function updateUnifySettings(update, dir) {
 
   return merged;
 }
+
+// ─── Search settings (web-search backend selection + Tavily key) ────
+
+/**
+ * Valid backend values. `playwright` is reserved for the upcoming
+ * playwright-service tool — its UI option is currently disabled, but we
+ * accept the literal so a hand-edited config doesn't trip validation.
+ * Anything else is rejected on write and normalized to `tavily` on read.
+ */
+const VALID_BACKENDS = ['tavily', 'playwright'];
+
+function maskKey(key) {
+  if (!key || typeof key !== 'string') return null;
+  if (key.length <= 10) return '***';
+  return `${key.slice(0, 6)}...${key.slice(-4)}`;
+}
+
+/**
+ * Read the `search` section of config.json. Tavily key is returned in
+ * masked form (`tvly-d...j3dgV`) — the raw key never leaves the agent.
+ * UI uses `tavilyKeyConfigured` to decide whether the input shows a
+ * "(unchanged)" placeholder vs an empty box.
+ *
+ * @param {string} [dir]
+ * @returns {{ backend: string, tavilyKeyConfigured: boolean, tavilyKeyMasked: string|null, disableHtmlFallback: boolean } | { error: string }}
+ */
+export function getSearchSettings(dir) {
+  const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const configPath = join(root, 'config.json');
+  const defaults = {
+    backend: 'tavily',
+    tavilyKeyConfigured: false,
+    tavilyKeyMasked: null,
+    disableHtmlFallback: false,
+  };
+  if (!existsSync(configPath)) return defaults;
+  try {
+    const json = JSON.parse(readFileSync(configPath, 'utf8'));
+    const s = (json && typeof json.search === 'object' && json.search) || {};
+    const backend = VALID_BACKENDS.includes(s.backend) ? s.backend : 'tavily';
+    const key = typeof s.tavilyApiKey === 'string' ? s.tavilyApiKey : '';
+    return {
+      backend,
+      tavilyKeyConfigured: !!key,
+      tavilyKeyMasked: key ? maskKey(key) : null,
+      disableHtmlFallback: !!s.disableHtmlFallback,
+    };
+  } catch (e) {
+    return { error: `Failed to read config.json: ${e.message}` };
+  }
+}
+
+/**
+ * Update the `search` section of config.json. Update is shallow-merged:
+ * any field omitted from `update` keeps its previous value. Pass
+ * `tavilyApiKey: ''` explicitly to clear the key; pass `undefined` (or
+ * omit) to keep it unchanged — this is what the UI relies on so the
+ * "(unchanged)" placeholder doesn't accidentally wipe a saved key when
+ * the user only touches the backend radio.
+ *
+ * @param {{ backend?: string, tavilyApiKey?: string, disableHtmlFallback?: boolean }} update
+ * @param {string} [dir]
+ * @returns {ReturnType<typeof getSearchSettings>}
+ */
+export function updateSearchSettings(update, dir) {
+  const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const configPath = join(root, 'config.json');
+
+  if (!update || typeof update !== 'object') {
+    return { error: 'update payload required' };
+  }
+  if (update.backend !== undefined && !VALID_BACKENDS.includes(update.backend)) {
+    return { error: `backend must be one of: ${VALID_BACKENDS.join(', ')}` };
+  }
+  if (update.tavilyApiKey !== undefined && typeof update.tavilyApiKey !== 'string') {
+    return { error: 'tavilyApiKey must be a string' };
+  }
+
+  let existing = {};
+  if (existsSync(configPath)) {
+    try {
+      existing = JSON.parse(readFileSync(configPath, 'utf8'));
+    } catch {
+      existing = {};
+    }
+  }
+  const prev = (existing && typeof existing.search === 'object' && existing.search) || {};
+  const merged = { ...prev };
+  if (update.backend !== undefined) merged.backend = update.backend;
+  if (update.tavilyApiKey !== undefined) merged.tavilyApiKey = update.tavilyApiKey;
+  if (update.disableHtmlFallback !== undefined) merged.disableHtmlFallback = !!update.disableHtmlFallback;
+  existing.search = merged;
+
+  try {
+    writeFileSync(configPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+  } catch (e) {
+    return { error: `Failed to write config.json: ${e.message}` };
+  }
+  return getSearchSettings(root);
+}
+
+/**
+ * Probe Tavily's `/usage` endpoint with the currently-saved key. Returns
+ * the plan + usage fields the UI shows, or `{ error }` for any of:
+ *   - no key configured
+ *   - HTTP error from Tavily (401 = bad key, etc.)
+ *   - network failure
+ *
+ * Called only when the user opens the Search settings tab (the user
+ * explicitly asked for "open settings → live read, don't poll"). No
+ * caching here — a stale display is more confusing than a fresh probe.
+ *
+ * @param {string} [dir]
+ * @returns {Promise<{ plan: string, used: number, limit: number|null, paygoUsed: number, paygoLimit: number|null } | { error: string }>}
+ */
+export async function fetchTavilyUsage(dir) {
+  const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const configPath = join(root, 'config.json');
+  if (!existsSync(configPath)) return { error: 'config.json not found' };
+  let key;
+  try {
+    const json = JSON.parse(readFileSync(configPath, 'utf8'));
+    key = json?.search?.tavilyApiKey;
+  } catch (e) {
+    return { error: `Failed to read config.json: ${e.message}` };
+  }
+  if (!key) return { error: 'Tavily API key not configured' };
+
+  try {
+    const res = await fetch('https://api.tavily.com/usage', {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      return { error: `${res.status} ${res.statusText} ${text.slice(0, 200)}` };
+    }
+    const data = await res.json();
+    const account = data?.account || {};
+    return {
+      plan: account.current_plan || 'unknown',
+      used: Number(account.plan_usage) || 0,
+      limit: account.plan_limit ?? null,
+      paygoUsed: Number(account.paygo_usage) || 0,
+      paygoLimit: account.paygo_limit ?? null,
+    };
+  } catch (e) {
+    return { error: e.message || String(e) };
+  }
+}
+

package/unify/tools/web-search.js

@@ -60,6 +60,14 @@ Guidelines:
     const signal = ctx?.signal;
     const errors = [];
 
+    // Backend preference set in UnifySettings → Search tab. When the
+    // user picks `playwright` we'd normally call the playwright-service;
+    // that service is not yet shipped (next PR), so the preference is
+    // recorded for forward-compat and we transparently fall through to
+    // Tavily / HTML scrape. Once the service lands we'll insert a
+    // tryPlaywright backend here ahead of Tavily.
+    // Anything other than 'playwright' is treated as 'tavily'.
+
     // 1. Tavily — default, fast, structured.
     if (search.tavilyApiKey) {
       const r = await tryTavily(query, limit, search.tavilyApiKey, signal);