opensteer 0.4.0 → 0.4.2

package/bin/opensteer.mjs

@@ -1,32 +1,22 @@
 #!/usr/bin/env node
 
-import { createHash } from 'crypto'
-import { spawn } from 'child_process'
-import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'fs'
 import { connect } from 'net'
-import { tmpdir } from 'os'
-import { basename, dirname, join } from 'path'
+import { spawn } from 'child_process'
+import { existsSync, readFileSync, unlinkSync, mkdirSync } from 'fs'
+import { join, dirname } from 'path'
+import { homedir } from 'os'
 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 getVersion() {
-    try {
-        const pkgPath = join(__dirname, '..', 'package.json')
-        return JSON.parse(readFileSync(pkgPath, 'utf-8')).version
-    } catch {
-        return 'unknown'
-    }
-}
 
 function parseArgs(argv) {
     const args = argv.slice(2)
@@ -35,11 +25,6 @@ function parseArgs(argv) {
         process.exit(0)
     }
 
-    if (args[0] === '--version' || args[0] === '-v') {
-        console.log(getVersion())
-        process.exit(0)
-    }
-
     const command = args[0]
     const flags = {}
     const positional = []
@@ -71,78 +56,10 @@ 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 getActiveNamespacePath() {
-    const hash = createHash('md5').update(process.cwd()).digest('hex').slice(0, 16)
-    return join(tmpdir(), `${RUNTIME_PREFIX}active-${hash}`)
-}
-
-function readActiveNamespace() {
-    try {
-        const filePath = getActiveNamespacePath()
-        if (!existsSync(filePath)) return null
-        const ns = readFileSync(filePath, 'utf-8').trim()
-        return ns || null
-    } catch {
-        return null
-    }
-}
-
-function writeActiveNamespace(namespace) {
-    try {
-        writeFileSync(getActiveNamespacePath(), namespace)
-    } catch { /* best-effort */ }
-}
-
-function resolveNamespace(flags) {
-    if (flags.name !== undefined && String(flags.name).trim().length > 0) {
-        return { namespace: sanitizeNamespace(String(flags.name)), source: 'flag' }
-    }
-
-    if (
-        typeof process.env.OPENSTEER_NAME === 'string' &&
-        process.env.OPENSTEER_NAME.trim().length > 0
-    ) {
-        return { namespace: sanitizeNamespace(process.env.OPENSTEER_NAME), source: 'env' }
-    }
-
-    const active = readActiveNamespace()
-    if (active && isServerRunning(active)) {
-        return { namespace: active, source: 'active' }
-    }
-
-    const cwdBase = basename(process.cwd())
-    if (cwdBase && cwdBase !== '.' && cwdBase !== '/') {
-        return { namespace: sanitizeNamespace(cwdBase), source: 'cwd' }
-    }
-
-    return { namespace: 'default', source: '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 ['headless', 'json', 'connect-url', 'channel', 'profile-dir']) {
+    for (const key of ['name', 'headless', 'json', 'connect-url', 'channel', 'profile-dir']) {
         if (key in flags) {
             globalFlags[key] = flags[key]
             delete flags[key]
@@ -248,66 +165,38 @@ function buildRequest(command, flags, positional) {
     return { id, command, args }
 }
 
-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) {
+function isServerRunning() {
+    if (!existsSync(PID_PATH)) return false
     try {
+        const pid = parseInt(readFileSync(PID_PATH, 'utf-8').trim(), 10)
         process.kill(pid, 0)
         return true
     } catch {
+        cleanStaleFiles()
         return false
     }
 }
 
-function cleanStaleFiles(namespace) {
+function cleanStaleFiles() {
     try {
-        unlinkSync(getSocketPath(namespace))
+        unlinkSync(SOCKET_PATH)
     } catch { }
     try {
-        unlinkSync(getPidPath(namespace))
+        unlinkSync(PID_PATH)
     } catch { }
 }
 
-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() {
+    mkdirSync(RUNTIME_DIR, { recursive: true })
 
-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(socketPath, timeout) {
+function waitForSocket(timeout) {
     return new Promise((resolve, reject) => {
         const start = Date.now()
 
@@ -317,7 +206,7 @@ function waitForSocket(socketPath, timeout) {
                 return
             }
 
-            if (existsSync(socketPath)) {
+            if (existsSync(SOCKET_PATH)) {
                 resolve()
                 return
             }
@@ -329,9 +218,9 @@ function waitForSocket(socketPath, timeout) {
     })
 }
 
-function sendCommand(socketPath, request) {
+function sendCommand(request) {
     return new Promise((resolve, reject) => {
-        const socket = connect(socketPath)
+        const socket = connect(SOCKET_PATH)
         let buffer = ''
         let settled = false
 
@@ -381,71 +270,6 @@ function sendCommand(socketPath, 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')
 }
@@ -465,11 +289,6 @@ 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
-  status                    Show resolved namespace and session state
 
 Observation:
   snapshot [--mode action]  Get page snapshot
@@ -515,7 +334,7 @@ Utility:
   extract <schema-json>     Extract structured data
 
 Global Flags:
-  --name <namespace>        Session namespace (default: CWD basename or OPENSTEER_NAME)
+  --name <namespace>        Storage namespace (default: "cli")
   --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)
@@ -524,10 +343,8 @@ Global Flags:
   --selector <css>          Target element by CSS selector
   --description <text>      Description for selector persistence
   --help                    Show this help
-  --version, -v             Show version
 
 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
@@ -536,66 +353,26 @@ Environment:
 
 async function main() {
     const { command, flags, positional } = parseArgs(process.argv)
-    const { namespace, source: namespaceSource } = resolveNamespace(flags)
-    const socketPath = getSocketPath(namespace)
-
-    if (command === 'sessions') {
-        output({ ok: true, sessions: listSessions() })
-        return
-    }
-
-    if (command === 'status') {
-        output({
-            ok: true,
-            namespace,
-            namespaceSource,
-            serverRunning: isServerRunning(namespace),
-            socketPath,
-            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(namespace)) {
-        if (command !== 'open') {
-            error(
-                `No server running for namespace '${namespace}' (resolved from ${namespaceSource}). Run 'opensteer open' first or use 'opensteer sessions' to see active sessions.`
-            )
-        }
+    if (!isServerRunning()) {
         if (!existsSync(SERVER_SCRIPT)) {
             error(
                 `Server script not found: ${SERVER_SCRIPT}. Run the build script first.`
             )
         }
-        startServer(namespace)
+        startServer()
         try {
-            await waitForSocket(socketPath, CONNECT_TIMEOUT)
+            await waitForSocket(CONNECT_TIMEOUT)
         } catch {
             error('Failed to start server. Check that the build is complete.')
         }
     }
 
     try {
-        const response = await sendCommand(socketPath, request)
+        const response = await sendCommand(request)
 
         if (response.ok) {
-            if (command === 'open') {
-                writeActiveNamespace(namespace)
-            }
             output({ ok: true, ...response.result })
         } else {
             process.stderr.write(
@@ -604,7 +381,7 @@ async function main() {
             process.exit(1)
         }
     } catch (err) {
-        error(err instanceof Error ? err.message : 'Connection failed')
+        error(err.message || 'Connection failed')
     }
 }