wispy-cli 2.7.7 → 2.7.9

package/core/browser.mjs

@@ -0,0 +1,327 @@
+/**
+ * core/browser.mjs — Native browser integration via local-browser-bridge
+ *
+ * Connects to the local-browser-bridge HTTP API for browser control.
+ * Supports: health check, capabilities, diagnostics, tabs, attach,
+ * navigate, activate, screenshot, sessions.
+ *
+ * All HTTP calls use native fetch() (Node 18+).
+ */
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(execFile);
+const NOT_RUNNING_MSG =
+  "Bridge not running. Start with: npx local-browser-bridge serve";
+
+/**
+ * BrowserBridge — HTTP client for local-browser-bridge API.
+ *
+ * Usage:
+ *   const bridge = new BrowserBridge();
+ *   await bridge.ensureRunning();
+ *   const session = await bridge.autoAttach();
+ *   await bridge.navigate("https://example.com");
+ */
+export class BrowserBridge {
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl ?? "http://127.0.0.1:3000";
+    this.defaultBrowser = options.browser ?? "safari";
+    this._session = null; // current active session
+    this._engine = options.engine ?? null; // optional WispyEngine ref for audit/trust
+  }
+
+  // ── Private helpers ──────────────────────────────────────────────────────────
+
+  async _get(path, params = {}) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== undefined && v !== null) url.searchParams.set(k, v);
+    }
+    try {
+      const res = await fetch(url.toString(), {
+        signal: AbortSignal.timeout(10_000),
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        return { error: `HTTP ${res.status}: ${body.slice(0, 200)}` };
+      }
+      return res.json();
+    } catch (err) {
+      if (err.name === "AbortError" || err.name === "TimeoutError") {
+        return { error: NOT_RUNNING_MSG };
+      }
+      if (err.code === "ECONNREFUSED" || err.cause?.code === "ECONNREFUSED") {
+        return { error: NOT_RUNNING_MSG };
+      }
+      return { error: err.message ?? NOT_RUNNING_MSG };
+    }
+  }
+
+  async _post(path, body = {}) {
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(30_000),
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        return { error: `HTTP ${res.status}: ${text.slice(0, 200)}` };
+      }
+      return res.json();
+    } catch (err) {
+      if (err.name === "AbortError" || err.name === "TimeoutError") {
+        return { error: NOT_RUNNING_MSG };
+      }
+      if (err.code === "ECONNREFUSED" || err.cause?.code === "ECONNREFUSED") {
+        return { error: NOT_RUNNING_MSG };
+      }
+      return { error: err.message ?? NOT_RUNNING_MSG };
+    }
+  }
+
+  _audit(action, details = {}) {
+    if (!this._engine?.audit) return;
+    this._engine.audit.log({
+      type: "BROWSER_ACTION",
+      action,
+      ...details,
+    }).catch(() => {});
+  }
+
+  _trustLevel() {
+    if (!this._engine) return "careful";
+    return this._engine.config?.trustLevel ?? this._engine.permissions?.level ?? "careful";
+  }
+
+  _mayLog(action, detail) {
+    const level = this._trustLevel();
+    if (level !== "yolo") {
+      if (process.env.WISPY_DEBUG) {
+        process.stderr.write(`[browser] ${action}: ${detail}\n`);
+      }
+    }
+    this._audit(action, { detail });
+  }
+
+  // ── Health & discovery ───────────────────────────────────────────────────────
+
+  /** GET /health → { ok: true } */
+  async health() {
+    return this._get("/health");
+  }
+
+  /** GET /v1/capabilities?browser=X */
+  async capabilities(browser) {
+    return this._get("/v1/capabilities", { browser });
+  }
+
+  /** GET /v1/diagnostics?browser=X */
+  async diagnostics(browser) {
+    return this._get("/v1/diagnostics", { browser });
+  }
+
+  // ── Tab inspection ───────────────────────────────────────────────────────────
+
+  /** GET /v1/front-tab?browser=X */
+  async frontTab(browser) {
+    return this._get("/v1/front-tab", { browser: browser ?? this.defaultBrowser });
+  }
+
+  /**
+   * GET /v1/tab?browser=X&...
+   * query: { browser?, signature?, windowIndex?, tabIndex?, url?, title? }
+   */
+  async getTab(query = {}) {
+    const params = { browser: query.browser ?? this.defaultBrowser, ...query };
+    return this._get("/v1/tab", params);
+  }
+
+  /** GET /v1/tabs?browser=X */
+  async listTabs(browser) {
+    return this._get("/v1/tabs", { browser: browser ?? this.defaultBrowser });
+  }
+
+  // ── Session management ───────────────────────────────────────────────────────
+
+  /**
+   * POST /v1/attach { browser, mode?, tabTarget? }
+   * Stores the resulting session as this._session.
+   */
+  async attach(browser, opts = {}) {
+    const body = {
+      browser: browser ?? this.defaultBrowser,
+      ...opts,
+    };
+    const result = await this._post("/v1/attach", body);
+    if (!result.error) {
+      this._session = result;
+    }
+    return result;
+  }
+
+  /** GET /v1/sessions */
+  async listSessions() {
+    return this._get("/v1/sessions");
+  }
+
+  /** GET /v1/sessions/:id */
+  async getSession(id) {
+    return this._get(`/v1/sessions/${encodeURIComponent(id)}`);
+  }
+
+  /** POST /v1/sessions/:id/resume */
+  async resumeSession(id) {
+    const result = await this._post(`/v1/sessions/${encodeURIComponent(id)}/resume`);
+    if (!result.error) {
+      this._session = result;
+    }
+    return result;
+  }
+
+  // ── Actions (require active session) ─────────────────────────────────────────
+
+  /**
+   * Navigate to a URL.
+   * Uses session-scoped endpoint if sessionId/this._session is available.
+   */
+  async navigate(url, sessionId) {
+    this._mayLog("navigate", url);
+
+    const sid = sessionId ?? this._session?.id ?? this._session?.sessionId;
+    if (sid) {
+      return this._post(`/v1/sessions/${encodeURIComponent(sid)}/navigate`, { url });
+    }
+    return this._post("/v1/navigate", { url });
+  }
+
+  /**
+   * Bring browser tab to front / focus.
+   */
+  async activate(sessionId) {
+    this._mayLog("activate", sessionId ?? this._session?.id ?? "default");
+
+    const sid = sessionId ?? this._session?.id ?? this._session?.sessionId;
+    if (sid) {
+      return this._post(`/v1/sessions/${encodeURIComponent(sid)}/activate`);
+    }
+    return this._post("/v1/activate");
+  }
+
+  /**
+   * Take a screenshot.
+   * Returns { screenshot: "<base64>" } or { error }
+   */
+  async screenshot(sessionId) {
+    const sid = sessionId ?? this._session?.id ?? this._session?.sessionId;
+    if (sid) {
+      // Some implementations support GET, some POST
+      return this._get(`/v1/sessions/${encodeURIComponent(sid)}/screenshot`);
+    }
+    return this._post("/v1/screenshot");
+  }
+
+  // ── Lifecycle ────────────────────────────────────────────────────────────────
+
+  /**
+   * Check health, attempt to start bridge if not running.
+   * Returns { ok: boolean, started: boolean }
+   */
+  async ensureRunning() {
+    // 1. Try health
+    const h = await this.health();
+    if (h?.ok || (!h?.error && h !== null)) {
+      return { ok: true, started: false };
+    }
+
+    // 2. Try to start the bridge
+    let started = false;
+    try {
+      execFile("/bin/sh", ["-c", "npx local-browser-bridge serve --port 3000 &"], {
+        detached: true,
+        stdio: "ignore",
+      });
+      started = true;
+    } catch {
+      // ignore — may not have npx or may already be running
+    }
+
+    // 3. Wait up to 5 seconds for health to respond
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 500));
+      const h2 = await this.health();
+      if (h2?.ok || (!h2?.error && h2 !== null)) {
+        return { ok: true, started };
+      }
+    }
+
+    return { ok: false, started };
+  }
+
+  /**
+   * Auto-discover and attach to the best available browser.
+   * Order: safari-actionable > safari-readonly > chrome-actionable > chrome-readonly
+   */
+  async autoAttach() {
+    // 1. Get capabilities
+    const caps = await this.capabilities();
+    if (caps?.error) return { error: caps.error };
+
+    const browsers = Array.isArray(caps?.browsers)
+      ? caps.browsers
+      : Object.keys(caps ?? {}).filter((k) => k !== "error");
+
+    if (browsers.length === 0) {
+      return { error: "No browsers available via local-browser-bridge" };
+    }
+
+    // 2. Get diagnostics for each browser
+    const diagResults = [];
+    for (const browser of browsers) {
+      const d = await this.diagnostics(browser);
+      diagResults.push({ browser, diag: d });
+    }
+
+    // 3. Pick the best actionable browser
+    const priority = [
+      (d) => d.browser === "safari" && d.diag?.actionable === true,
+      (d) => d.browser === "chrome" && d.diag?.actionable === true,
+      (d) => d.diag?.actionable === true,
+      (d) => d.browser === "safari",
+      (d) => true,
+    ];
+
+    let chosen = null;
+    for (const pred of priority) {
+      chosen = diagResults.find(pred);
+      if (chosen) break;
+    }
+
+    if (!chosen) return { error: "No suitable browser found" };
+
+    // 4. Attach
+    const session = await this.attach(chosen.browser);
+    return session;
+  }
+
+  /** Summary status for display */
+  status() {
+    return {
+      baseUrl: this.baseUrl,
+      defaultBrowser: this.defaultBrowser,
+      session: this._session
+        ? {
+            id: this._session.id ?? this._session.sessionId,
+            browser: this._session.browser,
+            mode: this._session.mode,
+          }
+        : null,
+    };
+  }
+}
+
+export default BrowserBridge;

package/core/engine.mjs

@@ -27,6 +27,9 @@ import { Harness } from "./harness.mjs";
 import { SyncManager, getSyncManager } from "./sync.mjs";
 import { SkillManager } from "./skills.mjs";
 import { UserModel } from "./user-model.mjs";
+import { routeTask, classifyTask, filterAvailableModels } from "./task-router.mjs";
+import { decomposeTask, executeDecomposedPlan } from "./task-decomposer.mjs";
+import { BrowserBridge } from "./browser.mjs";
 
 const MAX_TOOL_ROUNDS = 10;
 const MAX_CONTEXT_CHARS = 40_000;
@@ -46,6 +49,7 @@ export class WispyEngine {
     this.sync = null; // SyncManager, initialized lazily
     this.skills = new SkillManager(WISPY_DIR, this);
     this.userModel = new UserModel(WISPY_DIR, this);
+    this.browser = new BrowserBridge({ engine: this });
     this._initialized = false;
     this._workMdContent = null;
     this._workMdLoaded = false;
@@ -87,9 +91,15 @@ export class WispyEngine {
     // Register skill tools
     this._registerSkillTools();
 
+    // Register routing + decomposition tools (v2.8)
+    this._registerRoutingTools();
+
     // Re-wire harness after tools are registered
     this.harness = new Harness(this.tools, this.permissions, this.audit, this.config);
 
+    // Start browser bridge (non-blocking, don't fail if unavailable)
+    this.browser.ensureRunning().catch(() => {});
+
     // Initialize MCP
     if (!opts.skipMcp) {
       await ensureDefaultMcpConfig(this.mcpManager.configPath);
@@ -347,6 +357,11 @@ export class WispyEngine {
       "node_list", "node_status", "node_execute",
       "update_work_context",
       "run_skill", "list_skills", "delete_skill",
+      "smart_route", "decompose_and_execute",
+      // Browser tools (v2.9)
+      "browser_status", "browser_tabs", "browser_navigate",
+      "browser_screenshot", "browser_front_tab", "browser_activate",
+      "browser_attach",
     ]);
 
     const harnessResult = await this.harness.execute(name, args, {
@@ -422,6 +437,26 @@ export class WispyEngine {
         return this._toolListSkills(args);
       case "delete_skill":
         return this._toolDeleteSkill(args);
+      // Smart routing + decomposition (v2.8)
+      case "smart_route":
+        return this._toolSmartRoute(args);
+      case "decompose_and_execute":
+        return this._toolDecomposeAndExecute(args, opts);
+      // Browser tools (v2.9)
+      case "browser_status":
+        return this._toolBrowserStatus();
+      case "browser_tabs":
+        return this._toolBrowserTabs(args);
+      case "browser_navigate":
+        return this._toolBrowserNavigate(args);
+      case "browser_screenshot":
+        return this._toolBrowserScreenshot(args);
+      case "browser_front_tab":
+        return this._toolBrowserFrontTab(args);
+      case "browser_activate":
+        return this._toolBrowserActivate(args);
+      case "browser_attach":
+        return this._toolBrowserAttach(args);
       default:
         return this.tools.execute(name, args);
     }
@@ -1191,6 +1226,210 @@ export class WispyEngine {
     return this.skills.delete(args.name);
   }
 
+  // ── Smart routing + decomposition tools (v2.8) ───────────────────────────────
+
+  _registerRoutingTools() {
+    const routingTools = [
+      {
+        name: "smart_route",
+        description: "Analyze a task and recommend the best model to handle it based on task type, complexity, and available providers.",
+        parameters: {
+          type: "object",
+          properties: {
+            task: { type: "string", description: "The task to analyze and route" },
+            cost_preference: {
+              type: "string",
+              enum: ["minimize", "balanced", "maximize-quality"],
+              description: "Tradeoff preference (default: balanced)",
+            },
+          },
+          required: ["task"],
+        },
+      },
+      {
+        name: "decompose_and_execute",
+        description: "Split a complex task into subtasks, route each to the best model, execute in parallel, and synthesize results into a coherent response.",
+        parameters: {
+          type: "object",
+          properties: {
+            task: { type: "string", description: "The complex task to decompose and execute" },
+            max_subtasks: { type: "number", description: "Maximum number of subtasks (default: 5)" },
+            cost_preference: {
+              type: "string",
+              enum: ["minimize", "balanced", "maximize-quality"],
+              description: "Cost/quality tradeoff preference (default: balanced)",
+            },
+          },
+          required: ["task"],
+        },
+      },
+    ];
+
+    for (const tool of routingTools) {
+      this.tools._definitions.set(tool.name, tool);
+    }
+  }
+
+  async _toolSmartRoute(args) {
+    try {
+      const classification = classifyTask(args.task ?? "");
+      const routing = routeTask(args.task ?? "", null, {
+        costPreference: args.cost_preference ?? "balanced",
+        defaultModel: this.model,
+      });
+
+      return {
+        success: true,
+        recommendation: routing,
+        classification,
+        availableModels: filterAvailableModels(
+          ["gpt-5.4", "gpt-4o", "gpt-4o-mini", "claude-opus-4-20250514", "claude-sonnet-4-20250514",
+           "claude-3-5-haiku-20241022", "gemini-2.5-pro", "gemini-2.5-flash",
+           "llama-3.3-70b-versatile", "deepseek-chat", "deepseek-reasoner"]
+        ),
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolDecomposeAndExecute(args, parentOpts = {}) {
+    try {
+      const task = args.task ?? "";
+      const maxSubtasks = args.max_subtasks ?? 5;
+      const costPreference = args.cost_preference ?? "balanced";
+
+      // Step 1: Decompose
+      const plan = await decomposeTask(task, {
+        maxSubtasks,
+        costPreference,
+        engine: this,
+      });
+
+      if (plan.subtasks.length === 0) {
+        return { success: false, error: "Failed to decompose task into subtasks" };
+      }
+
+      // Step 2: Execute
+      const executionResult = await executeDecomposedPlan(plan, this, {
+        costPreference,
+        onSubtaskStart: (st) => {
+          if (process.env.WISPY_DEBUG) {
+            console.error(`[decompose] Starting subtask ${st.id}: ${st.task.slice(0, 60)}`);
+          }
+        },
+        onSubtaskComplete: (st, result) => {
+          if (process.env.WISPY_DEBUG) {
+            console.error(`[decompose] Completed subtask ${st.id}`);
+          }
+        },
+      });
+
+      return {
+        success: true,
+        plan: {
+          subtaskCount: plan.subtasks.length,
+          parallelGroups: plan.parallelGroups.length,
+          estimatedCost: plan.estimatedCost,
+          estimatedTime: plan.estimatedTime,
+        },
+        subtasks: executionResult.results.map(r => ({
+          id: r.id,
+          type: r.type,
+          task: r.task.slice(0, 100),
+          resultPreview: r.result?.slice(0, 200) ?? null,
+        })),
+        errors: executionResult.errors,
+        synthesized: executionResult.synthesized,
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  // ── Browser tools (v2.9) ─────────────────────────────────────────────────────
+
+  async _toolBrowserStatus() {
+    try {
+      const health = await this.browser.health();
+      const status = this.browser.status();
+      return {
+        success: true,
+        health: health?.ok ?? false,
+        bridgeUrl: this.browser.baseUrl,
+        session: status.session,
+        hint: health?.error ? `Start bridge: npx local-browser-bridge serve` : undefined,
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserTabs(args) {
+    try {
+      const result = await this.browser.listTabs(args?.browser);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, tabs: result?.tabs ?? result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserNavigate(args) {
+    try {
+      const result = await this.browser.navigate(args.url);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, url: args.url, result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserScreenshot(args) {
+    try {
+      const result = await this.browser.screenshot(args?.sessionId);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, screenshot: result?.screenshot ?? result?.data, format: "base64" };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserFrontTab(args) {
+    try {
+      const result = await this.browser.frontTab(args?.browser);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, tab: result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserActivate(args) {
+    try {
+      const result = await this.browser.activate(args?.sessionId);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserAttach(args) {
+    try {
+      let result;
+      if (!args?.browser) {
+        result = await this.browser.autoAttach();
+      } else {
+        result = await this.browser.attach(args.browser, { mode: args.mode });
+      }
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, session: result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
   // ── Cleanup ──────────────────────────────────────────────────────────────────
 
   destroy() {