opensteer 0.2.0 → 0.3.0

package/bin/opensteer.mjs

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
 
-import { connect } from 'net'
 import { spawn } from 'child_process'
-import { existsSync, readFileSync, unlinkSync, mkdirSync } from 'fs'
-import { join, dirname } from 'path'
-import { homedir } from 'os'
+import { existsSync, readFileSync, readdirSync, unlinkSync } from 'fs'
+import { connect } from 'net'
+import { tmpdir } from 'os'
+import { basename, dirname, join } from 'path'
 import { fileURLToPath } from 'url'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
-
-const RUNTIME_DIR = join(homedir(), '.opensteer')
-const SOCKET_PATH = join(RUNTIME_DIR, 'opensteer.sock')
-const PID_PATH = join(RUNTIME_DIR, 'opensteer.pid')
 const SERVER_SCRIPT = join(__dirname, '..', 'dist', 'cli', 'server.js')
 
 const CONNECT_TIMEOUT = 15000
 const POLL_INTERVAL = 100
 const RESPONSE_TIMEOUT = 120000
+const RUNTIME_PREFIX = 'opensteer-'
+const SOCKET_SUFFIX = '.sock'
+const PID_SUFFIX = '.pid'
+const CLOSE_ALL_REQUEST = { id: 1, command: 'close', args: {} }
 
 function parseArgs(argv) {
     const args = argv.slice(2)
@@ -56,10 +56,51 @@ function parseValue(str) {
     return str
 }
 
+function sanitizeNamespace(value) {
+    const trimmed = String(value || '').trim()
+    if (!trimmed || trimmed === '.' || trimmed === '..') {
+        return 'default'
+    }
+
+    const replaced = trimmed.replace(/[^a-zA-Z0-9_-]+/g, '_')
+    const collapsed = replaced.replace(/_+/g, '_')
+    const bounded = collapsed.replace(/^_+|_+$/g, '')
+
+    return bounded || 'default'
+}
+
+function resolveNamespace(flags) {
+    if (flags.name !== undefined && String(flags.name).trim().length > 0) {
+        return sanitizeNamespace(String(flags.name))
+    }
+
+    if (
+        typeof process.env.OPENSTEER_NAME === 'string' &&
+        process.env.OPENSTEER_NAME.trim().length > 0
+    ) {
+        return sanitizeNamespace(process.env.OPENSTEER_NAME)
+    }
+
+    const cwdBase = basename(process.cwd())
+    if (cwdBase && cwdBase !== '.' && cwdBase !== '/') {
+        return sanitizeNamespace(cwdBase)
+    }
+
+    return 'default'
+}
+
+function getSocketPath(namespace) {
+    return join(tmpdir(), `${RUNTIME_PREFIX}${namespace}${SOCKET_SUFFIX}`)
+}
+
+function getPidPath(namespace) {
+    return join(tmpdir(), `${RUNTIME_PREFIX}${namespace}${PID_SUFFIX}`)
+}
+
 function buildRequest(command, flags, positional) {
     const id = 1
     const globalFlags = {}
-    for (const key of ['name', 'headless', 'json', 'connect-url', 'channel', 'profile-dir']) {
+    for (const key of ['headless', 'json', 'connect-url', 'channel', 'profile-dir']) {
         if (key in flags) {
             globalFlags[key] = flags[key]
             delete flags[key]
@@ -165,38 +206,66 @@ function buildRequest(command, flags, positional) {
     return { id, command, args }
 }
 
-function isServerRunning() {
-    if (!existsSync(PID_PATH)) return false
+function readPid(pidPath) {
+    if (!existsSync(pidPath)) {
+        return null
+    }
+
+    const parsed = Number.parseInt(readFileSync(pidPath, 'utf-8').trim(), 10)
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return null
+    }
+
+    return parsed
+}
+
+function isPidAlive(pid) {
     try {
-        const pid = parseInt(readFileSync(PID_PATH, 'utf-8').trim(), 10)
         process.kill(pid, 0)
         return true
     } catch {
-        cleanStaleFiles()
         return false
     }
 }
 
-function cleanStaleFiles() {
+function cleanStaleFiles(namespace) {
     try {
-        unlinkSync(SOCKET_PATH)
+        unlinkSync(getSocketPath(namespace))
     } catch { }
     try {
-        unlinkSync(PID_PATH)
+        unlinkSync(getPidPath(namespace))
     } catch { }
 }
 
-function startServer() {
-    mkdirSync(RUNTIME_DIR, { recursive: true })
+function isServerRunning(namespace) {
+    const pidPath = getPidPath(namespace)
+    const pid = readPid(pidPath)
+    if (!pid) {
+        cleanStaleFiles(namespace)
+        return false
+    }
+
+    if (!isPidAlive(pid)) {
+        cleanStaleFiles(namespace)
+        return false
+    }
+
+    return existsSync(getSocketPath(namespace))
+}
 
+function startServer(namespace) {
     const child = spawn('node', [SERVER_SCRIPT], {
         detached: true,
         stdio: ['ignore', 'ignore', 'ignore'],
+        env: {
+            ...process.env,
+            OPENSTEER_NAME: namespace,
+        },
     })
     child.unref()
 }
 
-function waitForSocket(timeout) {
+function waitForSocket(socketPath, timeout) {
     return new Promise((resolve, reject) => {
         const start = Date.now()
 
@@ -206,7 +275,7 @@ function waitForSocket(timeout) {
                 return
             }
 
-            if (existsSync(SOCKET_PATH)) {
+            if (existsSync(socketPath)) {
                 resolve()
                 return
             }
@@ -218,9 +287,9 @@ function waitForSocket(timeout) {
     })
 }
 
-function sendCommand(request) {
+function sendCommand(socketPath, request) {
     return new Promise((resolve, reject) => {
-        const socket = connect(SOCKET_PATH)
+        const socket = connect(socketPath)
         let buffer = ''
         let settled = false
 
@@ -270,6 +339,71 @@ function sendCommand(request) {
     })
 }
 
+function listSessions() {
+    const sessions = []
+    const entries = readdirSync(tmpdir())
+
+    for (const entry of entries) {
+        if (!entry.startsWith(RUNTIME_PREFIX) || !entry.endsWith(PID_SUFFIX)) {
+            continue
+        }
+
+        const name = entry.slice(
+            RUNTIME_PREFIX.length,
+            entry.length - PID_SUFFIX.length
+        )
+        if (!name) {
+            continue
+        }
+
+        const pid = readPid(join(tmpdir(), entry))
+        if (!pid || !isPidAlive(pid)) {
+            cleanStaleFiles(name)
+            continue
+        }
+
+        sessions.push({ name, pid })
+    }
+
+    sessions.sort((a, b) => a.name.localeCompare(b.name))
+    return sessions
+}
+
+async function closeAllSessions() {
+    const sessions = listSessions()
+    const closed = []
+    const failures = []
+
+    for (const session of sessions) {
+        const socketPath = getSocketPath(session.name)
+        if (!existsSync(socketPath)) {
+            cleanStaleFiles(session.name)
+            continue
+        }
+
+        try {
+            const response = await sendCommand(socketPath, CLOSE_ALL_REQUEST)
+            if (response && response.ok === true) {
+                closed.push(session)
+            } else {
+                failures.push(
+                    `${session.name}: ${response?.error || 'unknown close error'}`
+                )
+            }
+        } catch (err) {
+            failures.push(
+                `${session.name}: ${err instanceof Error ? err.message : String(err)}`
+            )
+        }
+    }
+
+    if (failures.length > 0) {
+        throw new Error(`Failed to close sessions: ${failures.join('; ')}`)
+    }
+
+    return closed
+}
+
 function output(data) {
     process.stdout.write(JSON.stringify(data) + '\n')
 }
@@ -289,6 +423,10 @@ Navigation:
   forward                   Go forward
   reload                    Reload page
   close                     Close browser and server
+  close --all               Close all active namespace-scoped servers
+
+Sessions:
+  sessions                  List active namespace-scoped sessions
 
 Observation:
   snapshot [--mode action]  Get page snapshot
@@ -334,7 +472,7 @@ Utility:
   extract <schema-json>     Extract structured data
 
 Global Flags:
-  --name <namespace>        Storage namespace (default: "cli")
+  --name <namespace>        Session namespace (default: CWD basename or OPENSTEER_NAME)
   --headless                Launch browser in headless mode
   --connect-url <url>       Connect to a running browser (e.g. http://localhost:9222)
   --channel <browser>       Use installed browser (chrome, chrome-beta, msedge)
@@ -345,6 +483,7 @@ Global Flags:
   --help                    Show this help
 
 Environment:
+  OPENSTEER_NAME            Default session namespace when --name is omitted
   OPENSTEER_MODE            Runtime mode: "local" (default) or "remote"
   OPENSTEER_API_KEY         Required when remote mode is selected
   OPENSTEER_BASE_URL        Override remote control-plane base URL
@@ -353,24 +492,44 @@ Environment:
 
 async function main() {
     const { command, flags, positional } = parseArgs(process.argv)
+    const namespace = resolveNamespace(flags)
+    const socketPath = getSocketPath(namespace)
+
+    if (command === 'sessions') {
+        output({ ok: true, sessions: listSessions() })
+        return
+    }
+
+    if (command === 'close' && flags.all === true) {
+        try {
+            const closed = await closeAllSessions()
+            output({ ok: true, closed })
+        } catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to close sessions')
+        }
+        return
+    }
+
+    delete flags.name
+    delete flags.all
     const request = buildRequest(command, flags, positional)
 
-    if (!isServerRunning()) {
+    if (!isServerRunning(namespace)) {
         if (!existsSync(SERVER_SCRIPT)) {
             error(
                 `Server script not found: ${SERVER_SCRIPT}. Run the build script first.`
             )
         }
-        startServer()
+        startServer(namespace)
         try {
-            await waitForSocket(CONNECT_TIMEOUT)
+            await waitForSocket(socketPath, CONNECT_TIMEOUT)
         } catch {
             error('Failed to start server. Check that the build is complete.')
         }
     }
 
     try {
-        const response = await sendCommand(request)
+        const response = await sendCommand(socketPath, request)
 
         if (response.ok) {
             output({ ok: true, ...response.result })
@@ -381,7 +540,7 @@ async function main() {
             process.exit(1)
         }
     } catch (err) {
-        error(err.message || 'Connection failed')
+        error(err instanceof Error ? err.message : 'Connection failed')
     }
 }
 

package/dist/cli/server.cjs

@@ -35,30 +35,30 @@ function flattenExtractionDataToFieldPlan(data) {
   flattenExtractionDataToFieldPlanRecursive(data, "", fields);
   return fields;
 }
-function flattenExtractionDataToFieldPlanRecursive(value, prefix, out) {
+function flattenExtractionDataToFieldPlanRecursive(value, prefix2, out) {
   if (value == null) return;
   if (typeof value === "number" && Number.isFinite(value)) {
-    const key = String(prefix || "").trim();
+    const key = String(prefix2 || "").trim();
     if (!key) return;
     out[key] = { element: Math.trunc(value) };
     return;
   }
   if (typeof value === "string" && value.trim().toUpperCase() === CURRENT_URL_SENTINEL) {
-    const key = String(prefix || "").trim();
+    const key = String(prefix2 || "").trim();
     if (!key) return;
     out[key] = { source: "current_url" };
     return;
   }
   const counterLeaf = parseCounterLeafDescriptor(value);
   if (counterLeaf) {
-    const key = String(prefix || "").trim();
+    const key = String(prefix2 || "").trim();
     if (!key) return;
     out[key] = counterLeaf;
     return;
   }
   if (Array.isArray(value)) {
     for (let i = 0; i < value.length; i++) {
-      const nextPrefix = prefix ? `${prefix}[${i}]` : `[${i}]`;
+      const nextPrefix = prefix2 ? `${prefix2}[${i}]` : `[${i}]`;
       flattenExtractionDataToFieldPlanRecursive(value[i], nextPrefix, out);
     }
     return;
@@ -67,7 +67,7 @@ function flattenExtractionDataToFieldPlanRecursive(value, prefix, out) {
   for (const [key, child] of Object.entries(
     value
   )) {
-    const nextPrefix = prefix ? `${prefix}.${key}` : key;
+    const nextPrefix = prefix2 ? `${prefix2}.${key}` : key;
     flattenExtractionDataToFieldPlanRecursive(child, nextPrefix, out);
   }
 }
@@ -103,8 +103,8 @@ var init_extract_field_plan = __esm({
 
 // src/ai/model.ts
 function resolveProviderInfo(modelStr) {
-  for (const [prefix, info] of Object.entries(PROVIDER_MAP)) {
-    if (modelStr.startsWith(prefix)) {
+  for (const [prefix2, info] of Object.entries(PROVIDER_MAP)) {
+    if (modelStr.startsWith(prefix2)) {
       return info;
     }
   }
@@ -335,7 +335,7 @@ var init_extractor = __esm({
 
 // src/cli/server.ts
 var import_net = require("net");
-var import_fs5 = require("fs");
+var import_fs4 = require("fs");
 
 // src/opensteer.ts
 var import_crypto2 = require("crypto");
@@ -817,15 +817,15 @@ function normalizeNamespace(input) {
   if (!segments.length) return DEFAULT_NAMESPACE;
   return segments.join("/");
 }
-function resolveNamespaceDir(rootDir, namespace) {
+function resolveNamespaceDir(rootDir, namespace2) {
   const selectorsRoot = import_path2.default.resolve(rootDir, ".opensteer", "selectors");
-  const normalizedNamespace = normalizeNamespace(namespace);
+  const normalizedNamespace = normalizeNamespace(namespace2);
   const namespaceDir = import_path2.default.resolve(selectorsRoot, normalizedNamespace);
   const relative = import_path2.default.relative(selectorsRoot, namespaceDir);
   if (relative === "" || relative === ".") return namespaceDir;
   if (relative.startsWith("..") || import_path2.default.isAbsolute(relative)) {
     throw new Error(
-      `Namespace "${namespace}" resolves outside selectors root.`
+      `Namespace "${namespace2}" resolves outside selectors root.`
     );
   }
   return namespaceDir;
@@ -1275,9 +1275,9 @@ function createEmptyRegistry(name) {
 var LocalSelectorStorage = class {
   rootDir;
   namespace;
-  constructor(rootDir, namespace) {
+  constructor(rootDir, namespace2) {
     this.rootDir = rootDir;
-    this.namespace = normalizeNamespace(namespace);
+    this.namespace = normalizeNamespace(namespace2);
   }
   getRootDir() {
     return this.rootDir;
@@ -1461,7 +1461,7 @@ function shouldKeepAttributeForPath(name, value, options = {}) {
   if (key === "c") return false;
   if (/^on[a-z]/i.test(key)) return false;
   if (ATTRIBUTE_DENY_KEYS.has(key)) return false;
-  if (INTERNAL_ATTR_PREFIXES.some((prefix) => key.startsWith(prefix)))
+  if (INTERNAL_ATTR_PREFIXES.some((prefix2) => key.startsWith(prefix2)))
     return false;
   if (options.allowClass === false && key === "class") return false;
   if (isMediaTag(options.tag) && VOLATILE_LAZY_LOADING_ATTRS.has(key)) {
@@ -1711,7 +1711,7 @@ async function buildElementPathFromHandle(handle) {
         if (/^on[a-z]/i.test(normalized)) return false;
         if (ATTRIBUTE_DENY_KEYS2.has(normalized)) return false;
         if (INTERNAL_ATTR_PREFIXES2.some(
-          (prefix) => normalized.startsWith(prefix)
+          (prefix2) => normalized.startsWith(prefix2)
         )) {
           return false;
         }
@@ -5884,12 +5884,12 @@ function isPersistedArrayNode(node) {
 function isPersistedObjectNode(node) {
   return !!node && typeof node === "object" && !Array.isArray(node) && !isPersistedValueNode(node) && !isPersistedSourceNode(node) && !isPersistedArrayNode(node);
 }
-function collectArrayItemFieldDescriptors(node, prefix = "") {
+function collectArrayItemFieldDescriptors(node, prefix2 = "") {
   if (isPersistedValueNode(node)) {
     return [
       {
         kind: "path",
-        path: prefix,
+        path: prefix2,
         selector: {
           elementPath: cloneElementPath(node.$path),
           attribute: node.attribute
@@ -5901,7 +5901,7 @@ function collectArrayItemFieldDescriptors(node, prefix = "") {
     return [
       {
         kind: "source",
-        path: prefix,
+        path: prefix2,
         source: "current_url"
       }
     ];
@@ -5913,7 +5913,7 @@ function collectArrayItemFieldDescriptors(node, prefix = "") {
   }
   const out = [];
   for (const [key, child] of Object.entries(node)) {
-    const nextPath = joinDataPath(prefix, key);
+    const nextPath = joinDataPath(prefix2, key);
     out.push(...collectArrayItemFieldDescriptors(child, nextPath));
   }
   return out;
@@ -6973,7 +6973,7 @@ function withTokenQuery(wsUrl, token) {
 var import_fs3 = __toESM(require("fs"), 1);
 var import_path5 = __toESM(require("path"), 1);
 function collectLocalSelectorCacheEntries(storage) {
-  const namespace = storage.getNamespace();
+  const namespace2 = storage.getNamespace();
   const namespaceDir = storage.getNamespaceDir();
   if (!import_fs3.default.existsSync(namespaceDir)) return [];
   const entries = [];
@@ -6994,7 +6994,7 @@ function collectLocalSelectorCacheEntries(storage) {
       continue;
     }
     entries.push({
-      namespace,
+      namespace: namespace2,
       siteOrigin,
       method,
       descriptionHash,
@@ -7403,6 +7403,9 @@ var Opensteer = class _Opensteer {
     }
     return this.contextRef;
   }
+  getRemoteSessionId() {
+    return this.remote?.sessionId ?? null;
+  }
   async launch(options = {}) {
     if (this.pageRef && !this.ownsBrowser) {
       throw new Error(
@@ -9033,9 +9036,9 @@ var Opensteer = class _Opensteer {
     );
     return fields;
   }
-  async collectFieldTargetsFromSchemaObject(obj, prefix, fields) {
+  async collectFieldTargetsFromSchemaObject(obj, prefix2, fields) {
     for (const [key, value] of Object.entries(obj)) {
-      const fieldKey = prefix ? `${prefix}.${key}` : key;
+      const fieldKey = prefix2 ? `${prefix2}.${key}` : key;
       await this.collectFieldTargetsFromValue(fieldKey, value, fields);
     }
   }
@@ -9496,19 +9499,16 @@ function getScrollDelta2(options) {
 }
 
 // src/cli/paths.ts
-var import_path6 = require("path");
 var import_os2 = require("os");
-var import_fs4 = require("fs");
-function getRuntimeDir() {
-  const dir = (0, import_path6.join)((0, import_os2.homedir)(), ".opensteer");
-  (0, import_fs4.mkdirSync)(dir, { recursive: true });
-  return dir;
+var import_path6 = require("path");
+function prefix(namespace2) {
+  return `opensteer-${namespace2}`;
 }
-function getSocketPath() {
-  return (0, import_path6.join)(getRuntimeDir(), "opensteer.sock");
+function getSocketPath(namespace2) {
+  return (0, import_path6.join)((0, import_os2.tmpdir)(), `${prefix(namespace2)}.sock`);
 }
-function getPidPath() {
-  return (0, import_path6.join)(getRuntimeDir(), "opensteer.pid");
+function getPidPath(namespace2) {
+  return (0, import_path6.join)((0, import_os2.tmpdir)(), `${prefix(namespace2)}.pid`);
 }
 
 // src/cli/commands.ts
@@ -9746,15 +9746,20 @@ function getCommandHandler(name) {
 // src/cli/server.ts
 var instance = null;
 var launchPromise = null;
-var socketPath = getSocketPath();
-var pidPath = getPidPath();
+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 {
-    (0, import_fs5.unlinkSync)(socketPath);
+    (0, import_fs4.unlinkSync)(socketPath);
   } catch {
   }
   try {
-    (0, import_fs5.unlinkSync)(pidPath);
+    (0, import_fs4.unlinkSync)(pidPath);
   } catch {
   }
 }
@@ -9770,13 +9775,12 @@ async function handleRequest(request, socket) {
     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",
+          name: namespace,
           browser: {
             headless: headless ?? false,
             connectUrl,
@@ -9805,7 +9809,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, {
@@ -9822,7 +9830,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,
@@ -9868,8 +9880,8 @@ async function handleRequest(request, socket) {
     });
   }
 }
-if ((0, import_fs5.existsSync)(socketPath)) {
-  (0, import_fs5.unlinkSync)(socketPath);
+if ((0, import_fs4.existsSync)(socketPath)) {
+  (0, import_fs4.unlinkSync)(socketPath);
 }
 var server = (0, import_net.createServer)((socket) => {
   let buffer = "";
@@ -9895,7 +9907,7 @@ var server = (0, import_net.createServer)((socket) => {
   });
 });
 server.listen(socketPath, () => {
-  (0, import_fs5.writeFileSync)(pidPath, String(process.pid));
+  (0, import_fs4.writeFileSync)(pidPath, String(process.pid));
   if (process.send) {
     process.send("ready");
   }