alvin-bot 4.4.1

package/dist/services/browser-manager.js

@@ -0,0 +1,161 @@
+/**
+ * Multi-Strategy Browser Manager
+ *
+ * Auto-selects between three browser strategies:
+ * - CLI: Headless Playwright, one-shot (screenshots, text extraction, PDF)
+ * - Gateway: Persistent HTTP browser server (interactive browsing, form-filling)
+ * - CDP: Attach to user's live Chrome via DevTools Protocol
+ */
+import { spawn } from "child_process";
+import http from "http";
+import fs from "fs";
+import { config } from "../config.js";
+import { BROWSE_SERVER_SCRIPT } from "../paths.js";
+import { screenshotUrl, extractText, generatePdf } from "./browser.js";
+/** Auto-select the best browser strategy for a task */
+export function selectStrategy(task = {}) {
+    if (task.useUserBrowser || config.cdpUrl)
+        return "cdp";
+    if (task.interactive || task.multiStep)
+        return "gateway";
+    return "cli";
+}
+// ── Gateway Management ────────────────────────────────────────────────
+let gatewayProcess = null;
+async function gatewayRequest(path, params = {}) {
+    const query = new URLSearchParams(params).toString();
+    const url = `http://127.0.0.1:${config.browseServerPort}${path}${query ? "?" + query : ""}`;
+    return new Promise((resolve, reject) => {
+        http.get(url, (res) => {
+            let data = "";
+            res.on("data", chunk => data += chunk);
+            res.on("end", () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch {
+                    reject(new Error(`Invalid JSON from gateway: ${data.slice(0, 200)}`));
+                }
+            });
+        }).on("error", reject);
+    });
+}
+async function ensureGateway() {
+    // Check if already running
+    try {
+        const health = await gatewayRequest("/health");
+        if (health.ok)
+            return true;
+    }
+    catch { /* not running */ }
+    // Start it
+    if (!fs.existsSync(BROWSE_SERVER_SCRIPT))
+        return false;
+    gatewayProcess = spawn("node", [BROWSE_SERVER_SCRIPT, String(config.browseServerPort)], {
+        stdio: "pipe",
+        detached: false,
+    });
+    gatewayProcess.on("exit", () => { gatewayProcess = null; });
+    // Wait for startup (max 10s)
+    for (let i = 0; i < 20; i++) {
+        await new Promise(r => setTimeout(r, 500));
+        try {
+            const health = await gatewayRequest("/health");
+            if (health.ok)
+                return true;
+        }
+        catch { /* still starting */ }
+    }
+    return false;
+}
+// ── Unified Operations ────────────────────────────────────────────────
+/** Navigate to URL using best strategy */
+export async function navigate(url, task = {}) {
+    const strategy = selectStrategy(task);
+    if (strategy === "gateway") {
+        await ensureGateway();
+        return gatewayRequest("/navigate", { url });
+    }
+    if (strategy === "cdp") {
+        // CDP: use playwright connectOverCDP
+        const { chromium } = await import("playwright");
+        const browser = await chromium.connectOverCDP(config.cdpUrl);
+        const contexts = browser.contexts();
+        const page = contexts[0]?.pages()[0] || await contexts[0]?.newPage() || await browser.newPage();
+        await page.goto(url, { waitUntil: "networkidle", timeout: 30000 });
+        const title = await page.title();
+        return { title, url: page.url() };
+    }
+    // CLI: simple text extraction
+    const text = await extractText(url);
+    return { title: url, url, tree: [text.slice(0, 500)] };
+}
+/** Take a screenshot */
+export async function screenshot(url, options = {}) {
+    const strategy = selectStrategy();
+    if (strategy === "gateway") {
+        await ensureGateway();
+        if (url)
+            await gatewayRequest("/navigate", { url });
+        const result = await gatewayRequest("/screenshot", options.fullPage ? { full: "true" } : {});
+        return result.path;
+    }
+    // CLI fallback
+    return screenshotUrl(url, { fullPage: options.fullPage });
+}
+/** Get accessibility tree (gateway only) */
+export async function getTree(limit = 100) {
+    await ensureGateway();
+    return gatewayRequest("/tree", { limit: String(limit) });
+}
+/** Click element by ref (gateway only) */
+export async function click(ref) {
+    await ensureGateway();
+    return gatewayRequest("/click", { ref });
+}
+/** Fill input (gateway only) */
+export async function fill(ref, value) {
+    await ensureGateway();
+    await gatewayRequest("/fill", { ref, value });
+}
+/** Type text (gateway only) */
+export async function type(ref, text) {
+    await ensureGateway();
+    await gatewayRequest("/type", { ref, text });
+}
+/** Press key (gateway only) */
+export async function press(key, ref) {
+    await ensureGateway();
+    await gatewayRequest("/press", ref ? { key, ref } : { key });
+}
+/** Scroll page (gateway only) */
+export async function scroll(direction, amount = 600) {
+    await ensureGateway();
+    return gatewayRequest("/scroll", { direction, amount: String(amount) });
+}
+/** Evaluate JS (gateway only) */
+export async function evaluate(js) {
+    await ensureGateway();
+    const result = await gatewayRequest("/eval", { js });
+    return result.result;
+}
+/** Generate PDF from URL */
+export async function pdf(url) {
+    return generatePdf(url);
+}
+/** Close browser / stop gateway */
+export async function close() {
+    try {
+        await gatewayRequest("/close");
+    }
+    catch { }
+    if (gatewayProcess) {
+        gatewayProcess.kill();
+        gatewayProcess = null;
+    }
+}
+/** Get current page info (gateway) */
+export async function info() {
+    await ensureGateway();
+    return gatewayRequest("/info");
+}

package/dist/services/browser.js

@@ -0,0 +1,121 @@
+/**
+ * Browser Service — Web browsing via Playwright.
+ *
+ * Capabilities:
+ * - Screenshot a URL
+ * - Extract text content from a URL
+ * - Fill forms (basic)
+ * - PDF generation
+ *
+ * Playwright is an optional dependency — browser features are only available if installed.
+ */
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+const TEMP_DIR = path.join(os.tmpdir(), "alvin-bot", "browser");
+if (!fs.existsSync(TEMP_DIR))
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+/** Check if Playwright is available */
+export function hasPlaywright() {
+    try {
+        execSync("npx playwright --version", { stdio: "pipe", timeout: 10000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Take a screenshot of a URL.
+ * Returns path to the screenshot image.
+ */
+export async function screenshotUrl(url, options = {}) {
+    const { fullPage = false, width = 1280, height = 720 } = options;
+    const outputPath = path.join(TEMP_DIR, `screenshot_${Date.now()}.png`);
+    // Use a standalone Node script to avoid importing playwright at module level
+    const script = `
+    const { chromium } = require('playwright');
+    (async () => {
+      const browser = await chromium.launch({ headless: true });
+      const page = await browser.newPage({ viewport: { width: ${width}, height: ${height} } });
+      await page.goto(${JSON.stringify(url)}, { waitUntil: 'networkidle', timeout: 30000 });
+      await page.screenshot({ path: ${JSON.stringify(outputPath)}, fullPage: ${fullPage} });
+      await browser.close();
+    })().catch(err => { console.error(err.message); process.exit(1); });
+  `;
+    try {
+        execSync(`node -e '${script.replace(/'/g, "\\'")}'`, {
+            stdio: "pipe",
+            timeout: 45000,
+            env: { ...process.env, PLAYWRIGHT_BROWSERS_PATH: "0" },
+        });
+        if (!fs.existsSync(outputPath))
+            throw new Error("Screenshot not created");
+        return outputPath;
+    }
+    catch (err) {
+        const error = err;
+        throw new Error(`Screenshot failed: ${error.stderr?.toString()?.trim() || error.message}`);
+    }
+}
+/**
+ * Extract text content from a URL.
+ * Returns the visible text content.
+ */
+export async function extractText(url) {
+    const script = `
+    const { chromium } = require('playwright');
+    (async () => {
+      const browser = await chromium.launch({ headless: true });
+      const page = await browser.newPage();
+      await page.goto(${JSON.stringify(url)}, { waitUntil: 'networkidle', timeout: 30000 });
+      const text = await page.evaluate(() => document.body.innerText);
+      console.log(text);
+      await browser.close();
+    })().catch(err => { console.error(err.message); process.exit(1); });
+  `;
+    try {
+        const result = execSync(`node -e '${script.replace(/'/g, "\\'")}'`, {
+            stdio: "pipe",
+            timeout: 45000,
+            env: { ...process.env, PLAYWRIGHT_BROWSERS_PATH: "0" },
+        });
+        return result.toString().trim();
+    }
+    catch (err) {
+        const error = err;
+        throw new Error(`Text extraction failed: ${error.stderr?.toString()?.trim() || error.message}`);
+    }
+}
+/**
+ * Generate PDF from a URL.
+ * Returns path to the PDF file.
+ */
+export async function generatePdf(url) {
+    const outputPath = path.join(TEMP_DIR, `page_${Date.now()}.pdf`);
+    const script = `
+    const { chromium } = require('playwright');
+    (async () => {
+      const browser = await chromium.launch({ headless: true });
+      const page = await browser.newPage();
+      await page.goto(${JSON.stringify(url)}, { waitUntil: 'networkidle', timeout: 30000 });
+      await page.pdf({ path: ${JSON.stringify(outputPath)}, format: 'A4', printBackground: true });
+      await browser.close();
+    })().catch(err => { console.error(err.message); process.exit(1); });
+  `;
+    try {
+        execSync(`node -e '${script.replace(/'/g, "\\'")}'`, {
+            stdio: "pipe",
+            timeout: 45000,
+            env: { ...process.env, PLAYWRIGHT_BROWSERS_PATH: "0" },
+        });
+        if (!fs.existsSync(outputPath))
+            throw new Error("PDF not created");
+        return outputPath;
+    }
+    catch (err) {
+        const error = err;
+        throw new Error(`PDF generation failed: ${error.stderr?.toString()?.trim() || error.message}`);
+    }
+}

package/dist/services/compaction.js

@@ -0,0 +1,129 @@
+/**
+ * Context Compaction Service — Auto-summarize long non-SDK sessions.
+ *
+ * When conversation history grows too long (by message count or token count),
+ * older entries are summarized via AI, flushed to daily memory log, and replaced
+ * with a compact system summary message.
+ */
+import { config } from "../config.js";
+import { appendDailyLog } from "./memory.js";
+import { getRegistry } from "../engine.js";
+/** How many recent messages to keep verbatim after compaction. */
+const KEEP_LAST = 10;
+/** Fallback: if AI summary fails, keep this many recent messages. */
+const FALLBACK_KEEP = 5;
+/** Max chars per message when building the summary input. */
+const MAX_CHARS_PER_ENTRY = 500;
+/**
+ * Check whether a session needs compaction.
+ * Returns true if history is long enough or token usage is high.
+ */
+export function shouldCompact(session) {
+    if (session.history.length <= KEEP_LAST)
+        return false;
+    return (session.history.length >= 25 ||
+        session.totalInputTokens >= config.compactionThreshold);
+}
+/**
+ * Compact a session's conversation history.
+ *
+ * 1. Separate history into "to summarize" (older) and "to keep" (recent).
+ * 2. Flush a textual summary of the older entries to daily memory log.
+ * 3. Try to generate an AI summary; fall back to raw truncation on failure.
+ * 4. Replace session.history with [summary system message, ...kept messages].
+ */
+export async function compactSession(session) {
+    const history = session.history;
+    // Nothing to compact if we have fewer messages than we'd keep
+    if (history.length <= KEEP_LAST) {
+        return { removedEntries: 0, summaryTokens: 0, flushedToMemory: false };
+    }
+    const toSummarize = history.slice(0, history.length - KEEP_LAST);
+    const toKeep = history.slice(history.length - KEEP_LAST);
+    // Build text representation of entries to summarize
+    const summaryInput = toSummarize
+        .map((msg) => {
+        const content = msg.content.length > MAX_CHARS_PER_ENTRY
+            ? msg.content.slice(0, MAX_CHARS_PER_ENTRY) + "..."
+            : msg.content;
+        return `${msg.role}: ${content}`;
+    })
+        .join("\n\n");
+    // Flush to daily memory BEFORE removing entries
+    let flushedToMemory = false;
+    try {
+        const flushText = [
+            `**Context Compaction** — ${toSummarize.length} messages archived:`,
+            "",
+            summaryInput.length > 2000
+                ? summaryInput.slice(0, 2000) + "\n[...truncated]"
+                : summaryInput,
+        ].join("\n");
+        appendDailyLog(flushText);
+        flushedToMemory = true;
+    }
+    catch (err) {
+        console.error("Compaction: failed to flush to memory:", err);
+    }
+    // Try AI-powered summary
+    let summaryText = null;
+    try {
+        summaryText = await generateAISummary(summaryInput);
+    }
+    catch (err) {
+        console.warn("Compaction: AI summary failed, using fallback:", err);
+    }
+    let summaryMessage;
+    let removedEntries;
+    if (summaryText) {
+        // AI summary succeeded — replace old entries with a single system message
+        summaryMessage = {
+            role: "system",
+            content: `[Conversation summary of ${toSummarize.length} earlier messages]\n\n${summaryText}`,
+        };
+        removedEntries = toSummarize.length;
+        session.history = [summaryMessage, ...toKeep];
+    }
+    else {
+        // Fallback — just keep the last FALLBACK_KEEP entries from the to-keep set
+        // plus a minimal note that earlier context was dropped
+        const fallbackKeep = history.slice(-FALLBACK_KEEP);
+        summaryMessage = {
+            role: "system",
+            content: `[Earlier conversation context (${history.length - FALLBACK_KEEP} messages) was compacted due to length. Recent context follows.]`,
+        };
+        removedEntries = history.length - FALLBACK_KEEP;
+        session.history = [summaryMessage, ...fallbackKeep];
+    }
+    const summaryTokens = Math.ceil(summaryMessage.content.length / 4); // rough estimate
+    return {
+        removedEntries,
+        summaryTokens,
+        flushedToMemory,
+    };
+}
+/**
+ * Generate an AI-powered summary of conversation entries using the active provider.
+ * Uses effort "low" to keep cost minimal.
+ */
+async function generateAISummary(text) {
+    const registry = getRegistry();
+    const opts = {
+        prompt: `Summarize the following conversation in under 300 words. Focus on key topics, decisions, and any action items. Be concise.\n\n${text}`,
+        systemPrompt: "You are a conversation summarizer. Output only the summary, no preamble.",
+        effort: "low",
+    };
+    let result = "";
+    for await (const chunk of registry.queryWithFallback(opts)) {
+        if (chunk.type === "text" && chunk.text) {
+            result = chunk.text;
+        }
+        if (chunk.type === "error") {
+            throw new Error(chunk.error || "AI summary generation failed");
+        }
+    }
+    if (!result.trim()) {
+        throw new Error("AI summary returned empty result");
+    }
+    return result.trim();
+}