@optima-chat/browser-cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,480 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config.ts
+var BROWSER_API_URL = process.env.BROWSER_API_URL || "http://localhost:7292";
+
+// src/api.ts
+var BrowserAPIError = class extends Error {
+  constructor(statusCode, errorCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+    this.name = "BrowserAPIError";
+  }
+};
+async function request(path, options = {}) {
+  const url = `${BROWSER_API_URL}${path}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  } catch (err) {
+    throw new Error(
+      `Cannot connect to browser backend at ${BROWSER_API_URL}. Is the service running?`
+    );
+  }
+  if (!response.ok) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      throw new BrowserAPIError(
+        response.status,
+        "unknown",
+        `HTTP ${response.status}: ${response.statusText}`
+      );
+    }
+    throw new BrowserAPIError(response.status, body.error, body.message);
+  }
+  return await response.json();
+}
+async function requestBinary(path) {
+  const url = `${BROWSER_API_URL}${path}`;
+  let response;
+  try {
+    response = await fetch(url);
+  } catch {
+    throw new Error(
+      `Cannot connect to browser backend at ${BROWSER_API_URL}. Is the service running?`
+    );
+  }
+  if (!response.ok) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      throw new BrowserAPIError(
+        response.status,
+        "unknown",
+        `HTTP ${response.status}: ${response.statusText}`
+      );
+    }
+    throw new BrowserAPIError(response.status, body.error, body.message);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+var BrowserAPI = class {
+  async createSession(url) {
+    const body = url ? { url } : {};
+    return request("/api/sessions", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async closeSession(sessionId) {
+    await request(`/api/sessions/${sessionId}`, { method: "DELETE" });
+  }
+  async getStatus(sessionId) {
+    return request(`/api/sessions/${sessionId}/status`);
+  }
+  async navigate(sessionId, url) {
+    return request(`/api/sessions/${sessionId}/navigate`, {
+      method: "POST",
+      body: JSON.stringify({ url })
+    });
+  }
+  async back(sessionId) {
+    return request(`/api/sessions/${sessionId}/back`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  async refresh(sessionId) {
+    return request(`/api/sessions/${sessionId}/refresh`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  async click(sessionId, index) {
+    return request(`/api/sessions/${sessionId}/click`, {
+      method: "POST",
+      body: JSON.stringify({ index })
+    });
+  }
+  async input(sessionId, index, text, clear = true) {
+    return request(`/api/sessions/${sessionId}/input`, {
+      method: "POST",
+      body: JSON.stringify({ index, text, clear })
+    });
+  }
+  async scroll(sessionId, down, pages = 1) {
+    return request(`/api/sessions/${sessionId}/scroll`, {
+      method: "POST",
+      body: JSON.stringify({ down, pages })
+    });
+  }
+  async keys(sessionId, keys) {
+    return request(`/api/sessions/${sessionId}/keys`, {
+      method: "POST",
+      body: JSON.stringify({ keys })
+    });
+  }
+  async select(sessionId, index, text) {
+    return request(`/api/sessions/${sessionId}/select`, {
+      method: "POST",
+      body: JSON.stringify({ index, text })
+    });
+  }
+  async getState(sessionId) {
+    return request(`/api/sessions/${sessionId}/state`);
+  }
+  async getScreenshot(sessionId) {
+    return requestBinary(`/api/sessions/${sessionId}/screenshot`);
+  }
+  async search(sessionId, pattern) {
+    return request(`/api/sessions/${sessionId}/search`, {
+      method: "POST",
+      body: JSON.stringify({ pattern })
+    });
+  }
+  async find(sessionId, selector) {
+    return request(`/api/sessions/${sessionId}/find`, {
+      method: "POST",
+      body: JSON.stringify({ selector })
+    });
+  }
+  async getTabs(sessionId) {
+    return request(`/api/sessions/${sessionId}/tabs`);
+  }
+  async switchTab(sessionId, tabId) {
+    return request(`/api/sessions/${sessionId}/switch`, {
+      method: "POST",
+      body: JSON.stringify({ tab_id: tabId })
+    });
+  }
+  async closeTab(sessionId, tabId) {
+    return request(
+      `/api/sessions/${sessionId}/tabs/${tabId}`,
+      { method: "DELETE" }
+    );
+  }
+};
+var api = new BrowserAPI();
+
+// src/session.ts
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from "fs";
+var SESSION_FILE = "/tmp/browser-session-id";
+function saveSessionId(id) {
+  writeFileSync(SESSION_FILE, id, "utf-8");
+}
+function loadSessionId() {
+  if (!existsSync(SESSION_FILE)) {
+    throw new Error(
+      "No active browser session. Run 'browser-cli launch' first."
+    );
+  }
+  return readFileSync(SESSION_FILE, "utf-8").trim();
+}
+function clearSessionId() {
+  if (existsSync(SESSION_FILE)) {
+    unlinkSync(SESSION_FILE);
+  }
+}
+
+// src/formatter.ts
+function formatPageState(state) {
+  const lines = [];
+  lines.push(`Page: ${state.title} (${state.url})`);
+  lines.push("");
+  lines.push("DOM:");
+  lines.push(state.dom);
+  lines.push("");
+  lines.push(`Tabs: ${formatTabsInline(state.tabs)}`);
+  return lines.join("\n");
+}
+function formatLaunch(state) {
+  const lines = [];
+  lines.push(`\u2713 Browser launched (session: ${state.session_id})`);
+  lines.push(formatPageState(state));
+  return lines.join("\n");
+}
+function formatClose(sessionId) {
+  return `\u2713 Browser closed (session: ${sessionId})`;
+}
+function formatStatus(status) {
+  const lines = [];
+  lines.push(`Session: ${status.session_id}`);
+  lines.push(`Status: ${status.status}`);
+  lines.push(`Created: ${status.created_at}`);
+  lines.push(`Idle: ${status.idle_seconds}s`);
+  return lines.join("\n");
+}
+function formatScreenshot(filePath) {
+  return `\u2713 Screenshot saved to ${filePath}`;
+}
+function formatTabs(tabList) {
+  const lines = ["Tabs:"];
+  for (const tab of tabList.tabs) {
+    lines.push(`  [${tab.tab_id}] ${tab.title} (${tab.url})`);
+  }
+  return lines.join("\n");
+}
+function formatSearch(result) {
+  if (result.total === 0) {
+    return "No matches found.";
+  }
+  const lines = [`Found ${result.total} match(es):`, ""];
+  for (const match of result.matches) {
+    lines.push(match.text);
+  }
+  return lines.join("\n");
+}
+function formatFind(result) {
+  if (result.total === 0) {
+    return "No elements found.";
+  }
+  const lines = [`Found ${result.total} element(s):`, ""];
+  for (const match of result.matches) {
+    const attrs = Object.entries(match.attributes).map(([k, v]) => `${k}="${v}"`).join(" ");
+    lines.push(`  [${match.index}] <${match.tag} ${attrs}>`);
+  }
+  return lines.join("\n");
+}
+function formatError(err) {
+  if (err instanceof Error) {
+    return `\u2717 Error: ${err.message}`;
+  }
+  return `\u2717 Error: ${String(err)}`;
+}
+function formatTabsInline(tabs) {
+  return tabs.map((t) => `[${t.tab_id}] ${t.title}`).join(", ");
+}
+
+// src/commands/lifecycle.ts
+function registerLifecycleCommands(program2) {
+  program2.command("launch").description("Launch a browser session").option("--url <url>", "Navigate to URL after launch").action(async (opts) => {
+    try {
+      const state = await api.createSession(opts.url);
+      saveSessionId(state.session_id);
+      console.log(formatLaunch(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("close").description("Close the active browser session").action(async () => {
+    try {
+      const sessionId = loadSessionId();
+      await api.closeSession(sessionId);
+      clearSessionId();
+      console.log(formatClose(sessionId));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("status").description("Show session status").action(async () => {
+    try {
+      const sessionId = loadSessionId();
+      const status = await api.getStatus(sessionId);
+      console.log(formatStatus(status));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/navigation.ts
+function registerNavigationCommands(program2) {
+  program2.command("navigate").description("Navigate to a URL").argument("<url>", "URL to navigate to").action(async (url) => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.navigate(sessionId, url);
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("back").description("Go back to the previous page").action(async () => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.back(sessionId);
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("refresh").description("Refresh the current page").action(async () => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.refresh(sessionId);
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/interaction.ts
+function registerInteractionCommands(program2) {
+  program2.command("click").description("Click an element by index").argument("<index>", "Element index from DOM").action(async (index) => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.click(sessionId, parseInt(index, 10));
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("input").description("Input text into an element").argument("<index>", "Element index from DOM").argument("<text>", "Text to input").option("--no-clear", "Do not clear existing content before input").action(async (index, text, opts) => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.input(
+        sessionId,
+        parseInt(index, 10),
+        text,
+        opts.clear
+      );
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("scroll").description("Scroll the page up or down").argument("<direction>", "Scroll direction: up or down").option("--pages <n>", "Number of pages to scroll", "1").action(async (direction, opts) => {
+    try {
+      const sessionId = loadSessionId();
+      const down = direction.toLowerCase() === "down";
+      const pages = parseInt(opts.pages, 10);
+      const state = await api.scroll(sessionId, down, pages);
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("keys").description("Send keyboard keys").argument("<keys>", "Key name (e.g. Enter, Tab, Escape, ArrowDown)").action(async (keys) => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.keys(sessionId, keys);
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("select").description("Select an option from a dropdown").argument("<index>", "Dropdown element index from DOM").argument("<option>", "Option text to select").action(async (index, option) => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.select(sessionId, parseInt(index, 10), option);
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/info.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+function registerInfoCommands(program2) {
+  program2.command("dom").description("Get the current page DOM").action(async () => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.getState(sessionId);
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("screenshot").description("Take a screenshot of the current page").argument("[file]", "File path to save screenshot", "/tmp/screenshot.png").action(async (file) => {
+    try {
+      const sessionId = loadSessionId();
+      const buffer = await api.getScreenshot(sessionId);
+      writeFileSync2(file, buffer);
+      console.log(formatScreenshot(file));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("search").description("Search for text in the page DOM").argument("<pattern>", "Text pattern to search for").action(async (pattern) => {
+    try {
+      const sessionId = loadSessionId();
+      const result = await api.search(sessionId, pattern);
+      console.log(formatSearch(result));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("find").description("Find elements by CSS selector").argument("<selector>", "CSS selector").action(async (selector) => {
+    try {
+      const sessionId = loadSessionId();
+      const result = await api.find(sessionId, selector);
+      console.log(formatFind(result));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/tabs.ts
+function registerTabCommands(program2) {
+  program2.command("tabs").description("List all open tabs").action(async () => {
+    try {
+      const sessionId = loadSessionId();
+      const tabList = await api.getTabs(sessionId);
+      console.log(formatTabs(tabList));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("switch").description("Switch to a tab").argument("<tab_id>", "Tab ID to switch to").action(async (tabId) => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.switchTab(sessionId, tabId);
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("close-tab").description("Close a tab").argument("<tab_id>", "Tab ID to close").action(async (tabId) => {
+    try {
+      const sessionId = loadSessionId();
+      const state = await api.closeTab(sessionId, tabId);
+      console.log(formatPageState(state));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("browser-cli").description("CLI client for browser-backend").version("0.1.0");
+registerLifecycleCommands(program);
+registerNavigationCommands(program);
+registerInteractionCommands(program);
+registerInfoCommands(program);
+registerTabCommands(program);
+program.parse();

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@optima-chat/browser-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "browser-cli": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "@types/node": "^20.11.0",
+    "vitest": "^3.0.0"
+  }
+}