@townco/agent 0.1.54 → 0.1.56

package/dist/runner/langchain/tools/browser.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+interface BrowserNavigateResult {
+    success: boolean;
+    url?: string;
+    title?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserScreenshotResult {
+    success: boolean;
+    screenshotPath?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserExtractResult {
+    success: boolean;
+    content?: string;
+    url?: string;
+    title?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserClickResult {
+    success: boolean;
+    message?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserTypeResult {
+    success: boolean;
+    message?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserCloseResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export declare function makeBrowserTools(): readonly [import("langchain").DynamicStructuredTool<z.ZodObject<{
+    url: z.ZodString;
+    waitUntil: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        load: "load";
+        domcontentloaded: "domcontentloaded";
+        networkidle: "networkidle";
+    }>>>;
+}, z.core.$strip>, {
+    url: string;
+    waitUntil: "load" | "domcontentloaded" | "networkidle";
+}, {
+    url: string;
+    waitUntil?: "load" | "domcontentloaded" | "networkidle" | undefined;
+}, BrowserNavigateResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    fullPage: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    selector: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    fullPage: boolean;
+    selector?: string | undefined;
+}, {
+    fullPage?: boolean | undefined;
+    selector?: string | undefined;
+}, BrowserScreenshotResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    selector: z.ZodOptional<z.ZodString>;
+    extractType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        text: "text";
+        html: "html";
+    }>>>;
+}, z.core.$strip>, {
+    extractType: "text" | "html";
+    selector?: string | undefined;
+}, {
+    selector?: string | undefined;
+    extractType?: "text" | "html" | undefined;
+}, BrowserExtractResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    selector: z.ZodString;
+    button: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+        middle: "middle";
+    }>>>;
+}, z.core.$strip>, {
+    selector: string;
+    button: "left" | "right" | "middle";
+}, {
+    selector: string;
+    button?: "left" | "right" | "middle" | undefined;
+}, BrowserClickResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    selector: z.ZodString;
+    text: z.ZodString;
+    pressEnter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, {
+    selector: string;
+    text: string;
+    pressEnter: boolean;
+}, {
+    selector: string;
+    text: string;
+    pressEnter?: boolean | undefined;
+}, BrowserTypeResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{}, z.core.$strip>, Record<string, never>, Record<string, never>, BrowserCloseResult>];
+export {};

package/dist/runner/langchain/tools/browser.js

@@ -0,0 +1,412 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import Kernel from "@onkernel/sdk";
+import { tool } from "langchain";
+import { z } from "zod";
+let _kernelClient = null;
+let _sessionId = null;
+let _liveViewUrl = null;
+function getKernelClient() {
+    if (_kernelClient) {
+        return _kernelClient;
+    }
+    const apiKey = process.env.KERNEL_API_KEY;
+    if (!apiKey) {
+        throw new Error("KERNEL_API_KEY environment variable is required to use the browser tool. " +
+            "Please set it to your Kernel API key from https://onkernel.com");
+    }
+    _kernelClient = new Kernel({ apiKey });
+    return _kernelClient;
+}
+async function ensureBrowserSession() {
+    if (_sessionId && _liveViewUrl) {
+        return { sessionId: _sessionId, liveViewUrl: _liveViewUrl };
+    }
+    const kernel = getKernelClient();
+    let kernelBrowser;
+    try {
+        kernelBrowser = await kernel.browsers.create();
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to create Kernel browser. Check KERNEL_API_KEY is valid. Error: ${msg}`);
+    }
+    _sessionId = kernelBrowser.session_id;
+    // biome-ignore lint/suspicious/noExplicitAny: browser_live_view_url not yet typed in @onkernel/sdk
+    _liveViewUrl = kernelBrowser.browser_live_view_url;
+    if (!_sessionId) {
+        throw new Error("Kernel browser created but no session_id returned.");
+    }
+    if (!_liveViewUrl) {
+        throw new Error("Kernel browser created but no browser_live_view_url returned.");
+    }
+    return { sessionId: _sessionId, liveViewUrl: _liveViewUrl };
+}
+// biome-ignore lint/suspicious/noExplicitAny: Kernel SDK playwright.execute not yet typed
+async function executePlaywright(code) {
+    const kernel = getKernelClient();
+    const { sessionId } = await ensureBrowserSession();
+    // biome-ignore lint/suspicious/noExplicitAny: playwright.execute not yet typed in @onkernel/sdk
+    const response = await kernel.browsers.playwright.execute(sessionId, {
+        code,
+        timeout_sec: 60,
+    });
+    return response;
+}
+export function makeBrowserTools() {
+    // Browser Navigate tool
+    const browserNavigate = tool(async ({ url, waitUntil = "domcontentloaded", }) => {
+        try {
+            const { liveViewUrl } = await ensureBrowserSession();
+            const code = `
+          await page.goto('${url.replace(/'/g, "\\'")}', { 
+            waitUntil: '${waitUntil}',
+            timeout: 30000 
+          });
+          return { url: page.url(), title: await page.title() };
+        `;
+            const response = await executePlaywright(code);
+            return {
+                success: true,
+                url: response.result?.url,
+                title: response.result?.title,
+                liveViewUrl,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                success: false,
+                error: `Navigation failed: ${errorMessage}`,
+                ...(_liveViewUrl ? { liveViewUrl: _liveViewUrl } : {}),
+            };
+        }
+    }, {
+        name: "BrowserNavigate",
+        description: "Navigate a cloud browser to a specified URL using Kernel's browser-as-a-service.\n" +
+            "- Opens web pages in a cloud-hosted browser\n" +
+            "- Returns the final URL (after redirects), page title, and a liveViewUrl\n" +
+            "- The liveViewUrl allows viewing the browser session in real-time\n" +
+            "- Browser session persists across tool calls\n" +
+            "\n" +
+            "Usage notes:\n" +
+            "  - First call creates a new browser session\n" +
+            "  - Subsequent calls reuse the same browser\n" +
+            "  - Share the liveViewUrl with users so they can watch the browser\n" +
+            "  - Use BrowserClose when done to release resources\n",
+        schema: z.object({
+            url: z.string().url().describe("The URL to navigate to"),
+            waitUntil: z
+                .enum(["load", "domcontentloaded", "networkidle"])
+                .optional()
+                .default("domcontentloaded")
+                .describe("When to consider navigation complete"),
+        }),
+    });
+    browserNavigate.prettyName = "Browser Navigate";
+    browserNavigate.icon = "Globe";
+    // Browser Screenshot tool
+    const browserScreenshot = tool(async ({ fullPage = false, selector, }) => {
+        try {
+            const { liveViewUrl } = await ensureBrowserSession();
+            let code;
+            if (selector) {
+                code = `
+            const element = await page.$('${selector.replace(/'/g, "\\'")}');
+            if (!element) {
+              return { error: 'Element not found: ${selector.replace(/'/g, "\\'")}' };
+            }
+            const screenshot = await element.screenshot({ type: 'png' });
+            return { screenshot: screenshot.toString('base64') };
+          `;
+            }
+            else {
+                code = `
+            const screenshot = await page.screenshot({ type: 'png', fullPage: ${fullPage} });
+            return { screenshot: screenshot.toString('base64') };
+          `;
+            }
+            const response = await executePlaywright(code);
+            if (response.result?.error) {
+                return {
+                    success: false,
+                    error: response.result.error,
+                    liveViewUrl,
+                };
+            }
+            // Save screenshot to local file instead of returning base64
+            const screenshotsDir = join(process.cwd(), "screenshots");
+            await mkdir(screenshotsDir, { recursive: true });
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+            const filename = `screenshot-${timestamp}.png`;
+            const filepath = join(screenshotsDir, filename);
+            const imageBuffer = Buffer.from(response.result?.screenshot, "base64");
+            await Bun.write(filepath, imageBuffer);
+            return {
+                success: true,
+                screenshotPath: filepath,
+                liveViewUrl,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                success: false,
+                error: `Screenshot failed: ${errorMessage}`,
+                ...(_liveViewUrl ? { liveViewUrl: _liveViewUrl } : {}),
+            };
+        }
+    }, {
+        name: "BrowserScreenshot",
+        description: "Take a screenshot of the current browser page or a specific element.\n" +
+            "- Captures the current viewport or full page\n" +
+            "- Can target specific elements using CSS selectors\n" +
+            "- Saves the screenshot to a local file and returns the file path\n" +
+            "\n" +
+            "Usage notes:\n" +
+            "  - Use fullPage=true to capture the entire scrollable page\n" +
+            "  - Use selector to capture a specific element\n" +
+            "  - Requires an active browser session (call BrowserNavigate first)\n" +
+            "  - Screenshots are saved in the 'screenshots' folder in the current working directory\n",
+        schema: z.object({
+            fullPage: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Whether to capture the full scrollable page"),
+            selector: z
+                .string()
+                .optional()
+                .describe("CSS selector of element to screenshot (captures whole page if not provided)"),
+        }),
+    });
+    browserScreenshot.prettyName = "Browser Screenshot";
+    browserScreenshot.icon = "Camera";
+    // Browser Extract Content tool
+    const browserExtract = tool(async ({ selector, extractType = "text", }) => {
+        try {
+            const { liveViewUrl } = await ensureBrowserSession();
+            let code;
+            if (selector) {
+                if (extractType === "html") {
+                    code = `
+              const element = await page.$('${selector.replace(/'/g, "\\'")}');
+              if (!element) {
+                return { error: 'Element not found: ${selector.replace(/'/g, "\\'")}' };
+              }
+              const content = await element.innerHTML();
+              return { content, url: page.url(), title: await page.title() };
+            `;
+                }
+                else {
+                    code = `
+              const element = await page.$('${selector.replace(/'/g, "\\'")}');
+              if (!element) {
+                return { error: 'Element not found: ${selector.replace(/'/g, "\\'")}' };
+              }
+              const content = await element.innerText();
+              return { content, url: page.url(), title: await page.title() };
+            `;
+                }
+            }
+            else {
+                if (extractType === "html") {
+                    code = `
+              const content = await page.content();
+              return { content, url: page.url(), title: await page.title() };
+            `;
+                }
+                else {
+                    code = `
+              const content = await page.innerText('body');
+              return { content, url: page.url(), title: await page.title() };
+            `;
+                }
+            }
+            const response = await executePlaywright(code);
+            if (response.result?.error) {
+                return {
+                    success: false,
+                    error: response.result.error,
+                    liveViewUrl,
+                };
+            }
+            return {
+                success: true,
+                content: response.result?.content,
+                url: response.result?.url,
+                title: response.result?.title,
+                liveViewUrl,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                success: false,
+                error: `Content extraction failed: ${errorMessage}`,
+                ...(_liveViewUrl ? { liveViewUrl: _liveViewUrl } : {}),
+            };
+        }
+    }, {
+        name: "BrowserExtract",
+        description: "Extract text or HTML content from the current page or a specific element.\n" +
+            "- Gets readable text content from web pages\n" +
+            "- Can extract HTML for structured data\n" +
+            "- Supports CSS selectors for targeting specific elements\n" +
+            "\n" +
+            "Usage notes:\n" +
+            "  - Default extracts text from the entire page body\n" +
+            "  - Use selector to target specific page sections\n" +
+            "  - Use extractType='html' when you need the raw HTML structure\n",
+        schema: z.object({
+            selector: z
+                .string()
+                .optional()
+                .describe("CSS selector of element to extract from (extracts from body if not provided)"),
+            extractType: z
+                .enum(["text", "html"])
+                .optional()
+                .default("text")
+                .describe("Type of content to extract"),
+        }),
+    });
+    browserExtract.prettyName = "Browser Extract";
+    browserExtract.icon = "FileText";
+    // Browser Click tool
+    const browserClick = tool(async ({ selector, button = "left" }) => {
+        try {
+            const { liveViewUrl } = await ensureBrowserSession();
+            const code = `
+          await page.click('${selector.replace(/'/g, "\\'")}', { 
+            button: '${button}',
+            timeout: 10000,
+          });
+          await page.waitForTimeout(500);
+          return { success: true };
+        `;
+            await executePlaywright(code);
+            return {
+                success: true,
+                message: `Clicked element: ${selector}`,
+                liveViewUrl,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                success: false,
+                error: `Click failed: ${errorMessage}`,
+                ...(_liveViewUrl ? { liveViewUrl: _liveViewUrl } : {}),
+            };
+        }
+    }, {
+        name: "BrowserClick",
+        description: "Click on an element in the current browser page.\n" +
+            "- Supports left, right, and middle mouse buttons\n" +
+            "- Waits for the element to be visible before clicking\n" +
+            "- Useful for interacting with buttons, links, and other clickable elements\n" +
+            "\n" +
+            "Usage notes:\n" +
+            "  - Provide a CSS selector to identify the target element\n" +
+            "  - The tool waits briefly after clicking for page updates\n",
+        schema: z.object({
+            selector: z.string().describe("CSS selector of the element to click"),
+            button: z
+                .enum(["left", "right", "middle"])
+                .optional()
+                .default("left")
+                .describe("Which mouse button to use"),
+        }),
+    });
+    browserClick.prettyName = "Browser Click";
+    browserClick.icon = "MousePointer";
+    // Browser Type tool
+    const browserType = tool(async ({ selector, text, pressEnter = false, }) => {
+        try {
+            const { liveViewUrl } = await ensureBrowserSession();
+            const code = `
+          await page.fill('${selector.replace(/'/g, "\\'")}', '${text.replace(/'/g, "\\'")}', { timeout: 10000 });
+          ${pressEnter ? `await page.press('${selector.replace(/'/g, "\\'")}', 'Enter'); await page.waitForTimeout(500);` : ""}
+          return { success: true };
+        `;
+            await executePlaywright(code);
+            return {
+                success: true,
+                message: `Typed text into element: ${selector}${pressEnter ? " (pressed Enter)" : ""}`,
+                liveViewUrl,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                success: false,
+                error: `Type failed: ${errorMessage}`,
+                ...(_liveViewUrl ? { liveViewUrl: _liveViewUrl } : {}),
+            };
+        }
+    }, {
+        name: "BrowserType",
+        description: "Type text into an input field in the current browser page.\n" +
+            "- Fills text into input fields, textareas, and contenteditable elements\n" +
+            "- Can optionally press Enter after typing (useful for search forms)\n" +
+            "- Clears existing content before typing\n" +
+            "\n" +
+            "Usage notes:\n" +
+            "  - Provide a CSS selector to identify the input element\n" +
+            "  - Set pressEnter=true to submit forms after typing\n",
+        schema: z.object({
+            selector: z.string().describe("CSS selector of the input element"),
+            text: z.string().describe("The text to type into the element"),
+            pressEnter: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Whether to press Enter after typing"),
+        }),
+    });
+    browserType.prettyName = "Browser Type";
+    browserType.icon = "Type";
+    // Browser Close tool
+    const browserClose = tool(async () => {
+        try {
+            if (_sessionId) {
+                const kernel = getKernelClient();
+                await kernel.browsers.deleteByID(_sessionId);
+            }
+            _sessionId = null;
+            _liveViewUrl = null;
+            return {
+                success: true,
+                message: "Browser session closed successfully",
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                success: false,
+                error: `Close failed: ${errorMessage}`,
+            };
+        }
+    }, {
+        name: "BrowserClose",
+        description: "Close the current browser session and release cloud resources.\n" +
+            "- Terminates the active browser connection\n" +
+            "- Frees up cloud browser resources\n" +
+            "- Call this when done with browser automation\n" +
+            "\n" +
+            "Usage notes:\n" +
+            "  - A new browser session will be created on the next BrowserNavigate call\n" +
+            "  - Calling this when no browser is active has no effect\n",
+        schema: z.object({}),
+    });
+    browserClose.prettyName = "Browser Close";
+    browserClose.icon = "X";
+    return [
+        browserNavigate,
+        browserScreenshot,
+        browserExtract,
+        browserClick,
+        browserType,
+        browserClose,
+    ];
+}

package/dist/runner/langchain/tools/port-utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if a port is available
+ */
+export declare function isPortAvailable(port: number): Promise<boolean>;
+/**
+ * Find the next available port starting from the given port
+ */
+export declare function findAvailablePort(startPort: number, maxAttempts?: number): Promise<number>;

package/dist/runner/langchain/tools/port-utils.js

@@ -0,0 +1,35 @@
+import { createServer } from "node:net";
+/**
+ * Check if a port is available
+ */
+export async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                resolve(false);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once("listening", () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port);
+    });
+}
+/**
+ * Find the next available port starting from the given port
+ */
+export async function findAvailablePort(startPort, maxAttempts = 100) {
+    for (let i = 0; i < maxAttempts; i++) {
+        const port = startPort + i;
+        const available = await isPortAvailable(port);
+        if (available) {
+            return port;
+        }
+    }
+    throw new Error(`Could not find an available port between ${startPort} and ${startPort + maxAttempts - 1}`);
+}