opensteer 0.1.0

package/dist/cli/server.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli/server.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli/server.js

@@ -0,0 +1,433 @@
+import {
+  Opensteer
+} from "../chunk-6L24FEKD.js";
+import "../chunk-3H5RRIMZ.js";
+
+// src/cli/server.ts
+import { createServer } from "net";
+import { writeFileSync, unlinkSync, existsSync } from "fs";
+
+// src/cli/paths.ts
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+function getRuntimeDir() {
+  const dir = join(homedir(), ".opensteer");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function getSocketPath() {
+  return join(getRuntimeDir(), "opensteer.sock");
+}
+function getPidPath() {
+  return join(getRuntimeDir(), "opensteer.pid");
+}
+
+// src/cli/commands.ts
+import { writeFile } from "fs/promises";
+var commands = {
+  async navigate(opensteer, args) {
+    const url = args.url;
+    if (!url) throw new Error("Missing required argument: url");
+    await opensteer.goto(url, {
+      timeout: args.timeout,
+      settleMs: args.settleMs,
+      waitUntil: args.waitUntil
+    });
+    return { url: opensteer.page.url() };
+  },
+  async back(opensteer) {
+    await opensteer.page.goBack();
+    return { url: opensteer.page.url() };
+  },
+  async forward(opensteer) {
+    await opensteer.page.goForward();
+    return { url: opensteer.page.url() };
+  },
+  async reload(opensteer) {
+    await opensteer.page.reload();
+    return { url: opensteer.page.url() };
+  },
+  async snapshot(opensteer, args) {
+    const mode = args.mode || "action";
+    const html = await opensteer.snapshot({ mode });
+    return { html };
+  },
+  async state(opensteer) {
+    return await opensteer.state();
+  },
+  async screenshot(opensteer, args) {
+    const file = args.file || "screenshot.png";
+    const type = file.endsWith(".jpg") || file.endsWith(".jpeg") ? "jpeg" : "png";
+    const buffer = await opensteer.screenshot({
+      fullPage: args.fullPage,
+      type
+    });
+    await writeFile(file, buffer);
+    return { file };
+  },
+  async click(opensteer, args) {
+    return await opensteer.click({
+      element: args.element,
+      selector: args.selector,
+      description: args.description,
+      button: args.button,
+      clickCount: args.clickCount
+    });
+  },
+  async dblclick(opensteer, args) {
+    return await opensteer.dblclick({
+      element: args.element,
+      selector: args.selector,
+      description: args.description
+    });
+  },
+  async rightclick(opensteer, args) {
+    return await opensteer.rightclick({
+      element: args.element,
+      selector: args.selector,
+      description: args.description
+    });
+  },
+  async hover(opensteer, args) {
+    return await opensteer.hover({
+      element: args.element,
+      selector: args.selector,
+      description: args.description
+    });
+  },
+  async input(opensteer, args) {
+    const text = args.text;
+    if (text == null) throw new Error("Missing required argument: text");
+    return await opensteer.input({
+      element: args.element,
+      selector: args.selector,
+      description: args.description,
+      text,
+      clear: args.clear,
+      pressEnter: args.pressEnter
+    });
+  },
+  async select(opensteer, args) {
+    return await opensteer.select({
+      element: args.element,
+      selector: args.selector,
+      description: args.description,
+      value: args.value,
+      label: args.label,
+      index: args.index
+    });
+  },
+  async scroll(opensteer, args) {
+    return await opensteer.scroll({
+      element: args.element,
+      selector: args.selector,
+      description: args.description,
+      direction: args.direction,
+      amount: args.amount
+    });
+  },
+  async press(opensteer, args) {
+    const key = args.key;
+    if (!key) throw new Error("Missing required argument: key");
+    await opensteer.pressKey(key);
+    return { key };
+  },
+  async type(opensteer, args) {
+    const text = args.text;
+    if (text == null) throw new Error("Missing required argument: text");
+    await opensteer.type(text);
+    return { text };
+  },
+  async "get-text"(opensteer, args) {
+    const text = await opensteer.getElementText({
+      element: args.element,
+      selector: args.selector,
+      description: args.description
+    });
+    return { text };
+  },
+  async "get-value"(opensteer, args) {
+    const value = await opensteer.getElementValue({
+      element: args.element,
+      selector: args.selector,
+      description: args.description
+    });
+    return { value };
+  },
+  async "get-attrs"(opensteer, args) {
+    const attributes = await opensteer.getElementAttributes({
+      element: args.element,
+      selector: args.selector,
+      description: args.description
+    });
+    return { attributes };
+  },
+  async "get-html"(opensteer, args) {
+    const html = await opensteer.getHtml(args.selector);
+    return { html };
+  },
+  async tabs(opensteer) {
+    const tabs = await opensteer.tabs();
+    return { tabs };
+  },
+  async "tab-new"(opensteer, args) {
+    return await opensteer.newTab(args.url);
+  },
+  async "tab-switch"(opensteer, args) {
+    const index = args.index;
+    if (index == null) throw new Error("Missing required argument: index");
+    await opensteer.switchTab(index);
+    return { index };
+  },
+  async "tab-close"(opensteer, args) {
+    await opensteer.closeTab(args.index);
+    return {};
+  },
+  async cookies(opensteer, args) {
+    const cookies = await opensteer.getCookies(args.url);
+    return { cookies };
+  },
+  async "cookie-set"(opensteer, args) {
+    await opensteer.setCookie({
+      name: args.name,
+      value: args.value,
+      url: args.url,
+      domain: args.domain,
+      path: args.path,
+      expires: args.expires,
+      httpOnly: args.httpOnly,
+      secure: args.secure,
+      sameSite: args.sameSite
+    });
+    return {};
+  },
+  async "cookies-clear"(opensteer) {
+    await opensteer.clearCookies();
+    return {};
+  },
+  async "cookies-export"(opensteer, args) {
+    const file = args.file;
+    if (!file) throw new Error("Missing required argument: file");
+    await opensteer.exportCookies(file, args.url);
+    return { file };
+  },
+  async "cookies-import"(opensteer, args) {
+    const file = args.file;
+    if (!file) throw new Error("Missing required argument: file");
+    await opensteer.importCookies(file);
+    return { file };
+  },
+  async eval(opensteer, args) {
+    const expression = args.expression;
+    if (!expression)
+      throw new Error("Missing required argument: expression");
+    const result = await opensteer.page.evaluate(expression);
+    return { result };
+  },
+  async "wait-for"(opensteer, args) {
+    const text = args.text;
+    if (!text) throw new Error("Missing required argument: text");
+    await opensteer.waitForText(text, {
+      timeout: args.timeout
+    });
+    return { text };
+  },
+  async "wait-selector"(opensteer, args) {
+    const selector = args.selector;
+    if (!selector) throw new Error("Missing required argument: selector");
+    await opensteer.page.waitForSelector(selector, {
+      timeout: args.timeout ?? 3e4
+    });
+    return { selector };
+  },
+  async extract(opensteer, args) {
+    const schema = args.schema;
+    const data = await opensteer.extract({
+      schema,
+      description: args.description,
+      prompt: args.prompt
+    });
+    return { data };
+  }
+};
+function getCommandHandler(name) {
+  return commands[name];
+}
+
+// src/cli/server.ts
+var instance = null;
+var launchPromise = null;
+var socketPath = getSocketPath();
+var pidPath = getPidPath();
+function cleanup() {
+  try {
+    unlinkSync(socketPath);
+  } catch {
+  }
+  try {
+    unlinkSync(pidPath);
+  } catch {
+  }
+}
+function sendResponse(socket, response) {
+  try {
+    socket.write(JSON.stringify(response) + "\n");
+  } catch {
+  }
+}
+async function handleRequest(request, socket) {
+  const { id, command, args } = request;
+  if (command === "open") {
+    try {
+      const url = args.url;
+      const headless = args.headless;
+      const name = args.name;
+      const connectUrl = args["connect-url"];
+      const channel = args.channel;
+      const profileDir = args["profile-dir"];
+      if (!instance) {
+        instance = new Opensteer({
+          name: name ?? "cli",
+          browser: {
+            headless: headless ?? false,
+            connectUrl,
+            channel,
+            profileDir
+          }
+        });
+        launchPromise = instance.launch({
+          headless: headless ?? false,
+          timeout: connectUrl ? 12e4 : 3e4
+        });
+        try {
+          await launchPromise;
+        } catch (err) {
+          instance = null;
+          throw err;
+        } finally {
+          launchPromise = null;
+        }
+      } else if (launchPromise) {
+        await launchPromise;
+      }
+      if (url) {
+        await instance.page.goto(url);
+      }
+      sendResponse(socket, {
+        id,
+        ok: true,
+        result: { url: instance.page.url() }
+      });
+    } catch (err) {
+      sendResponse(socket, {
+        id,
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return;
+  }
+  if (command === "close") {
+    try {
+      if (instance) {
+        await instance.close();
+        instance = null;
+      }
+      sendResponse(socket, { id, ok: true, result: {} });
+    } catch (err) {
+      sendResponse(socket, {
+        id,
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    setTimeout(() => {
+      cleanup();
+      process.exit(0);
+    }, 100);
+    return;
+  }
+  if (command === "ping") {
+    sendResponse(socket, { id, ok: true, result: { pong: true } });
+    return;
+  }
+  if (!instance) {
+    sendResponse(socket, {
+      id,
+      ok: false,
+      error: "No browser session. Call 'opensteer open' first."
+    });
+    return;
+  }
+  const handler = getCommandHandler(command);
+  if (!handler) {
+    sendResponse(socket, {
+      id,
+      ok: false,
+      error: `Unknown command: ${command}`
+    });
+    return;
+  }
+  try {
+    const result = await handler(instance, args);
+    sendResponse(socket, { id, ok: true, result });
+  } catch (err) {
+    sendResponse(socket, {
+      id,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+if (existsSync(socketPath)) {
+  unlinkSync(socketPath);
+}
+var server = createServer((socket) => {
+  let buffer = "";
+  socket.on("data", (chunk) => {
+    buffer += chunk.toString();
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const request = JSON.parse(line);
+        handleRequest(request, socket);
+      } catch {
+        sendResponse(socket, {
+          id: 0,
+          ok: false,
+          error: "Invalid JSON request"
+        });
+      }
+    }
+  });
+  socket.on("error", () => {
+  });
+});
+server.listen(socketPath, () => {
+  writeFileSync(pidPath, String(process.pid));
+  if (process.send) {
+    process.send("ready");
+  }
+});
+server.on("error", (err) => {
+  console.error("Server error:", err.message);
+  cleanup();
+  process.exit(1);
+});
+async function shutdown() {
+  if (instance) {
+    try {
+      await instance.close();
+    } catch {
+    }
+    instance = null;
+  }
+  server.close();
+  cleanup();
+  process.exit(0);
+}
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);

package/dist/extractor-K5VU7HVC.js

@@ -0,0 +1,8 @@
+import {
+  createExtractCallback
+} from "./chunk-DQIHOUXH.js";
+import "./chunk-3H5RRIMZ.js";
+import "./chunk-L4FHT64T.js";
+export {
+  createExtractCallback
+};