opensteer 0.4.1 → 0.4.3

package/dist/cli/server.js

@@ -1,6 +1,6 @@
 import {
   Opensteer
-} from "../chunk-OXFW5I3Y.js";
+} from "../chunk-2NKR4JZ6.js";
 import "../chunk-3H5RRIMZ.js";
 
 // src/cli/server.ts
@@ -8,66 +8,63 @@ import { createServer } from "net";
 import { writeFileSync, unlinkSync, existsSync } from "fs";
 
 // src/cli/paths.ts
+import { tmpdir } from "os";
 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 prefix(namespace2) {
+  return `opensteer-${namespace2}`;
 }
-function getSocketPath() {
-  return join(getRuntimeDir(), "opensteer.sock");
+function getSocketPath(namespace2) {
+  return join(tmpdir(), `${prefix(namespace2)}.sock`);
 }
-function getPidPath() {
-  return join(getRuntimeDir(), "opensteer.pid");
+function getPidPath(namespace2) {
+  return join(tmpdir(), `${prefix(namespace2)}.pid`);
 }
 
 // src/cli/commands.ts
 import { writeFile } from "fs/promises";
 var commands = {
-  async navigate(ov, args) {
+  async navigate(opensteer, args) {
     const url = args.url;
     if (!url) throw new Error("Missing required argument: url");
-    await ov.goto(url, {
+    await opensteer.goto(url, {
       timeout: args.timeout,
       settleMs: args.settleMs,
       waitUntil: args.waitUntil
     });
-    return { url: ov.page.url() };
+    return { url: opensteer.page.url() };
   },
-  async back(ov) {
-    await ov.page.goBack();
-    return { url: ov.page.url() };
+  async back(opensteer) {
+    await opensteer.page.goBack();
+    return { url: opensteer.page.url() };
   },
-  async forward(ov) {
-    await ov.page.goForward();
-    return { url: ov.page.url() };
+  async forward(opensteer) {
+    await opensteer.page.goForward();
+    return { url: opensteer.page.url() };
   },
-  async reload(ov) {
-    await ov.page.reload();
-    return { url: ov.page.url() };
+  async reload(opensteer) {
+    await opensteer.page.reload();
+    return { url: opensteer.page.url() };
   },
-  async snapshot(ov, args) {
+  async snapshot(opensteer, args) {
     const mode = args.mode || "action";
-    const html = await ov.snapshot({ mode });
+    const html = await opensteer.snapshot({ mode });
     return { html };
   },
-  async state(ov) {
-    return await ov.state();
+  async state(opensteer) {
+    return await opensteer.state();
   },
-  async screenshot(ov, args) {
+  async screenshot(opensteer, args) {
     const file = args.file || "screenshot.png";
     const type = file.endsWith(".jpg") || file.endsWith(".jpeg") ? "jpeg" : "png";
-    const buffer = await ov.screenshot({
+    const buffer = await opensteer.screenshot({
       fullPage: args.fullPage,
       type
     });
     await writeFile(file, buffer);
     return { file };
   },
-  async click(ov, args) {
-    return await ov.click({
+  async click(opensteer, args) {
+    return await opensteer.click({
       element: args.element,
       selector: args.selector,
       description: args.description,
@@ -75,31 +72,31 @@ var commands = {
       clickCount: args.clickCount
     });
   },
-  async dblclick(ov, args) {
-    return await ov.dblclick({
+  async dblclick(opensteer, args) {
+    return await opensteer.dblclick({
       element: args.element,
       selector: args.selector,
       description: args.description
     });
   },
-  async rightclick(ov, args) {
-    return await ov.rightclick({
+  async rightclick(opensteer, args) {
+    return await opensteer.rightclick({
       element: args.element,
       selector: args.selector,
       description: args.description
     });
   },
-  async hover(ov, args) {
-    return await ov.hover({
+  async hover(opensteer, args) {
+    return await opensteer.hover({
       element: args.element,
       selector: args.selector,
       description: args.description
     });
   },
-  async input(ov, args) {
+  async input(opensteer, args) {
     const text = args.text;
     if (text == null) throw new Error("Missing required argument: text");
-    return await ov.input({
+    return await opensteer.input({
       element: args.element,
       selector: args.selector,
       description: args.description,
@@ -108,8 +105,8 @@ var commands = {
       pressEnter: args.pressEnter
     });
   },
-  async select(ov, args) {
-    return await ov.select({
+  async select(opensteer, args) {
+    return await opensteer.select({
       element: args.element,
       selector: args.selector,
       description: args.description,
@@ -118,8 +115,8 @@ var commands = {
       index: args.index
     });
   },
-  async scroll(ov, args) {
-    return await ov.scroll({
+  async scroll(opensteer, args) {
+    return await opensteer.scroll({
       element: args.element,
       selector: args.selector,
       description: args.description,
@@ -127,69 +124,69 @@ var commands = {
       amount: args.amount
     });
   },
-  async press(ov, args) {
+  async press(opensteer, args) {
     const key = args.key;
     if (!key) throw new Error("Missing required argument: key");
-    await ov.pressKey(key);
+    await opensteer.pressKey(key);
     return { key };
   },
-  async type(ov, args) {
+  async type(opensteer, args) {
     const text = args.text;
     if (text == null) throw new Error("Missing required argument: text");
-    await ov.type(text);
+    await opensteer.type(text);
     return { text };
   },
-  async "get-text"(ov, args) {
-    const text = await ov.getElementText({
+  async "get-text"(opensteer, args) {
+    const text = await opensteer.getElementText({
       element: args.element,
       selector: args.selector,
       description: args.description
     });
     return { text };
   },
-  async "get-value"(ov, args) {
-    const value = await ov.getElementValue({
+  async "get-value"(opensteer, args) {
+    const value = await opensteer.getElementValue({
       element: args.element,
       selector: args.selector,
       description: args.description
     });
     return { value };
   },
-  async "get-attrs"(ov, args) {
-    const attributes = await ov.getElementAttributes({
+  async "get-attrs"(opensteer, args) {
+    const attributes = await opensteer.getElementAttributes({
       element: args.element,
       selector: args.selector,
       description: args.description
     });
     return { attributes };
   },
-  async "get-html"(ov, args) {
-    const html = await ov.getHtml(args.selector);
+  async "get-html"(opensteer, args) {
+    const html = await opensteer.getHtml(args.selector);
     return { html };
   },
-  async tabs(ov) {
-    const tabs = await ov.tabs();
+  async tabs(opensteer) {
+    const tabs = await opensteer.tabs();
     return { tabs };
   },
-  async "tab-new"(ov, args) {
-    return await ov.newTab(args.url);
+  async "tab-new"(opensteer, args) {
+    return await opensteer.newTab(args.url);
   },
-  async "tab-switch"(ov, args) {
+  async "tab-switch"(opensteer, args) {
     const index = args.index;
     if (index == null) throw new Error("Missing required argument: index");
-    await ov.switchTab(index);
+    await opensteer.switchTab(index);
     return { index };
   },
-  async "tab-close"(ov, args) {
-    await ov.closeTab(args.index);
+  async "tab-close"(opensteer, args) {
+    await opensteer.closeTab(args.index);
     return {};
   },
-  async cookies(ov, args) {
-    const cookies = await ov.getCookies(args.url);
+  async cookies(opensteer, args) {
+    const cookies = await opensteer.getCookies(args.url);
     return { cookies };
   },
-  async "cookie-set"(ov, args) {
-    await ov.setCookie({
+  async "cookie-set"(opensteer, args) {
+    await opensteer.setCookie({
       name: args.name,
       value: args.value,
       url: args.url,
@@ -202,48 +199,48 @@ var commands = {
     });
     return {};
   },
-  async "cookies-clear"(ov) {
-    await ov.clearCookies();
+  async "cookies-clear"(opensteer) {
+    await opensteer.clearCookies();
     return {};
   },
-  async "cookies-export"(ov, args) {
+  async "cookies-export"(opensteer, args) {
     const file = args.file;
     if (!file) throw new Error("Missing required argument: file");
-    await ov.exportCookies(file, args.url);
+    await opensteer.exportCookies(file, args.url);
     return { file };
   },
-  async "cookies-import"(ov, args) {
+  async "cookies-import"(opensteer, args) {
     const file = args.file;
     if (!file) throw new Error("Missing required argument: file");
-    await ov.importCookies(file);
+    await opensteer.importCookies(file);
     return { file };
   },
-  async eval(ov, args) {
+  async eval(opensteer, args) {
     const expression = args.expression;
     if (!expression)
       throw new Error("Missing required argument: expression");
-    const result = await ov.page.evaluate(expression);
+    const result = await opensteer.page.evaluate(expression);
     return { result };
   },
-  async "wait-for"(ov, args) {
+  async "wait-for"(opensteer, args) {
     const text = args.text;
     if (!text) throw new Error("Missing required argument: text");
-    await ov.waitForText(text, {
+    await opensteer.waitForText(text, {
       timeout: args.timeout
     });
     return { text };
   },
-  async "wait-selector"(ov, args) {
+  async "wait-selector"(opensteer, args) {
     const selector = args.selector;
     if (!selector) throw new Error("Missing required argument: selector");
-    await ov.page.waitForSelector(selector, {
+    await opensteer.page.waitForSelector(selector, {
       timeout: args.timeout ?? 3e4
     });
     return { selector };
   },
-  async extract(ov, args) {
+  async extract(opensteer, args) {
     const schema = args.schema;
-    const data = await ov.extract({
+    const data = await opensteer.extract({
       schema,
       description: args.description,
       prompt: args.prompt
@@ -257,8 +254,14 @@ function getCommandHandler(name) {
 
 // src/cli/server.ts
 var instance = null;
-var socketPath = getSocketPath();
-var pidPath = getPidPath();
+var launchPromise = null;
+var namespace = process.env.OPENSTEER_NAME?.trim();
+if (!namespace) {
+  process.stderr.write("Missing OPENSTEER_NAME environment variable.\n");
+  process.exit(1);
+}
+var socketPath = getSocketPath(namespace);
+var pidPath = getPidPath(namespace);
 function cleanup() {
   try {
     unlinkSync(socketPath);
@@ -281,21 +284,47 @@ async function handleRequest(request, socket) {
     try {
       const url = args.url;
       const headless = args.headless;
-      const name = args.name;
-      const cdpUrl = args["cdp-url"];
+      const connectUrl = args["connect-url"];
       const channel = args.channel;
-      const userDataDir = args["user-data-dir"];
+      const profileDir = args["profile-dir"];
+      if (instance && !launchPromise) {
+        try {
+          const alive = !instance.page.isClosed();
+          if (!alive) {
+            await instance.close().catch(() => {
+            });
+            instance = null;
+          }
+        } catch {
+          await instance?.close().catch(() => {
+          });
+          instance = null;
+        }
+      }
       if (!instance) {
         instance = new Opensteer({
-          name: name ?? "cli",
+          name: namespace,
           browser: {
             headless: headless ?? false,
-            cdpUrl,
+            connectUrl,
             channel,
-            userDataDir
+            profileDir
           }
         });
-        await instance.launch({ headless: headless ?? false });
+        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);
@@ -303,7 +332,11 @@ async function handleRequest(request, socket) {
       sendResponse(socket, {
         id,
         ok: true,
-        result: { url: instance.page.url() }
+        result: {
+          url: instance.page.url(),
+          sessionId: instance.getRemoteSessionId() ?? void 0,
+          name: namespace
+        }
       });
     } catch (err) {
       sendResponse(socket, {
@@ -320,7 +353,11 @@ async function handleRequest(request, socket) {
         await instance.close();
         instance = null;
       }
-      sendResponse(socket, { id, ok: true, result: {} });
+      sendResponse(socket, {
+        id,
+        ok: true,
+        result: { sessionClosed: true }
+      });
     } catch (err) {
       sendResponse(socket, {
         id,
@@ -342,7 +379,7 @@ async function handleRequest(request, socket) {
     sendResponse(socket, {
       id,
       ok: false,
-      error: "No browser session. Call 'opensteer open' first."
+      error: `No browser session in namespace '${namespace}'. Call 'opensteer open --name ${namespace}' first, or use 'opensteer sessions' to list active sessions.`
     });
     return;
   }