playwriter 0.3.1 → 0.4.0

package/dist/cdp-relay.js

@@ -9,6 +9,9 @@ import util from 'node:util';
 Buffer.prototype[util.inspect.custom] = function () {
     return `<Buffer ${this.length} bytes>`;
 };
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { EventEmitter } from 'node:events';
 import { VERSION, EXTENSION_IDS, shouldAutoEnablePlaywriter } from './utils.js';
 import { createCdpLogger } from './cdp-log.js';
@@ -105,21 +108,6 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
         }
         return null;
     };
-    const buildStableExtensionKey = (info, connectionId) => {
-        if (info.id) {
-            return `profile:${info.id}`;
-        }
-        if (info.email) {
-            return `email:${info.email}`;
-        }
-        if (info.installId) {
-            return `install:${info.browser || 'unknown'}:${info.installId}`;
-        }
-        if (info.browser) {
-            return `browser:${info.browser}`;
-        }
-        return `connection:${connectionId}`;
-    };
     const normalizeSessionId = (value) => {
         if (value === undefined || value === null) {
             return null;
@@ -613,6 +601,11 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
         });
     }
     const app = new Hono();
+    // Global error handler — ensures server errors are logged, not silently swallowed
+    app.onError((err, c) => {
+        logger?.error('Unhandled route error:', err);
+        return c.json({ error: err.message }, 500);
+    });
     // CORS middleware for HTTP endpoints - only allows our specific extension IDs.
     // This prevents other extensions from reading responses via fetch/XHR.
     // WebSocket connections have their own separate origin validation.
@@ -1094,7 +1087,7 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
         const connectionId = `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
         return {
             onOpen(_event, ws) {
-                const stableKey = buildStableExtensionKey(incomingExtensionInfo, connectionId);
+                const stableKey = relayState.buildStableExtensionKey(incomingExtensionInfo, connectionId);
                 // Check for existing connection with same stableKey and close it
                 const existingExt = relayState.findExtensionByStableKey(store.getState(), stableKey);
                 if (existingExt && existingExt.id !== connectionId) {
@@ -1542,8 +1535,26 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
             if (!existingExecutor) {
                 return c.json({ text: `Session ${sessionId} not found. Run 'playwriter session new' first.`, images: [], screenshots: [], isError: true }, 404);
             }
-            const result = await existingExecutor.execute(code, timeout);
-            return c.json(result);
+            // Touch cloud session activity tracking if this session is cloud-backed
+            const cloudTracking = cloudSessionTracking.get(sessionId);
+            if (cloudTracking) {
+                cloudTracking.lastActivityAt = Date.now();
+                cloudTracking.activeExecutions++;
+            }
+            let result;
+            try {
+                result = await existingExecutor.execute(code, timeout);
+            }
+            finally {
+                if (cloudTracking) {
+                    cloudTracking.activeExecutions--;
+                    cloudTracking.lastActivityAt = Date.now();
+                }
+            }
+            // Use the cloudTracking snapshot captured before execute (not a fresh
+            // map lookup) so long-running executes that outlive idle cleanup still
+            // report isCloud correctly.
+            return c.json({ ...result, isCloud: Boolean(cloudTracking) });
         }
         catch (error) {
             logger?.error('Execute endpoint error:', error);
@@ -1585,6 +1596,37 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
         const body = (await c.req.json().catch(() => ({})));
         const sessionId = String(nextSessionNumber++);
         const cwd = body.cwd;
+        // Headless mode: launch Chrome via chromium.launch(), no extension needed.
+        // Force connection immediately so missing Chrome errors surface at creation time,
+        // not on first execute call.
+        if (body.headless) {
+            const manager = await getExecutorManager();
+            const executor = manager.getExecutor({
+                sessionId,
+                cwd,
+                cdpConfig: { headless: true },
+                sessionMetadata: {
+                    extensionId: null,
+                    browser: 'Chrome (Headless)',
+                    profile: null,
+                },
+            });
+            try {
+                await executor.reset();
+            }
+            catch (error) {
+                manager.deleteExecutor(sessionId);
+                return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
+            }
+            const metadata = executor.getSessionMetadata();
+            return c.json({
+                id: sessionId,
+                mode: 'headless',
+                extensionId: metadata.extensionId,
+                browser: metadata.browser,
+                profile: metadata.profile,
+            });
+        }
         // Direct CDP mode: skip extension lookup, pass direct WebSocket URL to executor
         if (body.cdpEndpoint) {
             if (!body.cdpEndpoint.startsWith('ws://') && !body.cdpEndpoint.startsWith('wss://')) {
@@ -1592,6 +1634,9 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
             }
             // Use first profile from discovery for session metadata (if available)
             const firstProfile = body.profiles?.[0];
+            const cloudTimeoutAt = body.cloud?.timeoutAt
+                ? (typeof body.cloud.timeoutAt === 'string' ? new Date(body.cloud.timeoutAt).getTime() : body.cloud.timeoutAt)
+                : undefined;
             const manager = await getExecutorManager();
             const executor = manager.getExecutor({
                 sessionId,
@@ -1602,8 +1647,21 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
                     browser: body.browser || null,
                     profile: firstProfile ? { email: firstProfile.email, id: firstProfile.name } : null,
                 },
+                cloudSession: body.cloud ? { timeoutAt: cloudTimeoutAt, blockProxyResources: body.cloud.blockProxyResources } : undefined,
             });
             const metadata = executor.getSessionMetadata();
+            // Register cloud session tracking if cloud metadata was provided
+            if (body.cloud) {
+                cloudSessionTracking.set(sessionId, {
+                    cloudSessionId: body.cloud.cloudSessionId,
+                    cloudBaseUrl: body.cloud.cloudBaseUrl,
+                    cloudToken: body.cloud.cloudToken,
+                    lastActivityAt: Date.now(),
+                    activeExecutions: 0,
+                    timeoutAt: cloudTimeoutAt,
+                });
+                persistCloudSessions();
+            }
             return c.json({
                 id: sessionId,
                 mode: 'direct',
@@ -1658,10 +1716,27 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
                 return c.json({ error: 'sessionId is required' }, 400);
             }
             const manager = await getExecutorManager();
+            const executor = manager.getSession(sessionId);
+            // Close headless context before deleting to prevent context/page leaks
+            // on the shared headless browser. Only affects headless sessions.
+            if (executor) {
+                await executor.closeHeadlessContext();
+            }
             const deleted = manager.deleteExecutor(sessionId);
             if (!deleted) {
                 return c.json({ error: `Session ${sessionId} not found` }, 404);
             }
+            // If this was a cloud-backed session, stop the VM only if no other
+            // relay session is still using the same cloud VM (reference counting).
+            const cloudTracking = cloudSessionTracking.get(sessionId);
+            if (cloudTracking) {
+                const shouldStopVm = !hasOtherCloudReferences(sessionId, cloudTracking.cloudSessionId);
+                cloudSessionTracking.delete(sessionId);
+                persistCloudSessions();
+                if (shouldStopVm) {
+                    disconnectCloudVm(cloudTracking);
+                }
+            }
             return c.json({ success: true });
         }
         catch (error) {
@@ -1724,6 +1799,156 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
         const result = await relay.cancelRecording(cancelParams);
         return c.json(result);
     });
+    const cloudSessionTracking = new Map();
+    const CLOUD_IDLE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+    /** Check if any OTHER relay session references the same cloud VM.
+     *  Used to prevent stopping a VM that's still used by another relay session
+     *  (e.g. user attached twice via `session new --browser cloud-1`). */
+    function hasOtherCloudReferences(relaySessionId, cloudSessionId) {
+        for (const [otherId, tracking] of cloudSessionTracking) {
+            if (otherId !== relaySessionId && tracking.cloudSessionId === cloudSessionId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Disconnect a cloud VM via the website API (best-effort, non-blocking). */
+    function disconnectCloudVm(tracking) {
+        fetch(new URL('/api/cloud/disconnect', tracking.cloudBaseUrl).toString(), {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${tracking.cloudToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ cloudSessionId: tracking.cloudSessionId }),
+        }).catch((err) => {
+            logger?.error('[Cloud] Failed to disconnect cloud session:', err);
+        });
+    }
+    // ── Cloud session crash recovery ──────────────────────────────────
+    // Persist cloud session IDs to disk so orphaned VMs can be cleaned up
+    // if the relay process crashes. On startup, read the file and disconnect
+    // any leftover VMs (best-effort).
+    const CLOUD_SESSIONS_FILE = path.join(os.homedir(), '.playwriter', 'cloud-sessions.json');
+    function persistCloudSessions() {
+        // Dedupe by cloudSessionId — multiple relay sessions can reference the same VM
+        const seen = new Set();
+        const entries = [];
+        for (const t of cloudSessionTracking.values()) {
+            if (seen.has(t.cloudSessionId))
+                continue;
+            seen.add(t.cloudSessionId);
+            entries.push({
+                cloudSessionId: t.cloudSessionId,
+                cloudBaseUrl: t.cloudBaseUrl,
+                cloudToken: t.cloudToken,
+            });
+        }
+        try {
+            const dir = path.dirname(CLOUD_SESSIONS_FILE);
+            fs.mkdirSync(dir, { recursive: true });
+            if (entries.length > 0) {
+                // Atomic write: write to temp file then rename, so a crash mid-write
+                // doesn't leave corrupt JSON that blocks future cleanup.
+                const tmpFile = CLOUD_SESSIONS_FILE + '.tmp';
+                fs.writeFileSync(tmpFile, JSON.stringify(entries), { encoding: 'utf-8', mode: 0o600 });
+                fs.renameSync(tmpFile, CLOUD_SESSIONS_FILE);
+            }
+            else {
+                // No active sessions — remove file to avoid stale data
+                try {
+                    fs.unlinkSync(CLOUD_SESSIONS_FILE);
+                }
+                catch { /* already gone */ }
+            }
+        }
+        catch {
+            // Best-effort: don't crash relay if disk write fails
+        }
+    }
+    function cleanupOrphanedCloudSessions() {
+        let raw;
+        try {
+            raw = fs.readFileSync(CLOUD_SESSIONS_FILE, 'utf-8');
+        }
+        catch {
+            return; // No file — nothing to clean up
+        }
+        let entries;
+        try {
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return;
+            // Validate shape: each entry must have cloudSessionId and cloudBaseUrl
+            entries = parsed.filter((e) => {
+                return e && typeof e.cloudSessionId === 'string' && typeof e.cloudBaseUrl === 'string' && typeof e.cloudToken === 'string';
+            });
+        }
+        catch {
+            // Corrupt JSON (e.g. crash during non-atomic write) — just remove it
+            try {
+                fs.unlinkSync(CLOUD_SESSIONS_FILE);
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        if (!entries.length) {
+            try {
+                fs.unlinkSync(CLOUD_SESSIONS_FILE);
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        logger?.log(pc.yellow(`[Cloud] Found ${entries.length} orphaned cloud session(s) from previous relay. Cleaning up...`));
+        // Remove file after we've read it — disconnect calls are best-effort async.
+        // If they fail, the BU VM will eventually hit its own timeout anyway.
+        try {
+            fs.unlinkSync(CLOUD_SESSIONS_FILE);
+        }
+        catch { /* ignore */ }
+        for (const entry of entries) {
+            disconnectCloudVm({
+                cloudSessionId: entry.cloudSessionId,
+                cloudBaseUrl: entry.cloudBaseUrl,
+                cloudToken: entry.cloudToken,
+                lastActivityAt: 0,
+                activeExecutions: 0,
+            });
+        }
+    }
+    const cloudIdleInterval = setInterval(async () => {
+        const now = Date.now();
+        // Collect idle sessions first, then process — avoid mutating map during iteration
+        const idleSessions = [];
+        for (const [sessionId, tracking] of cloudSessionTracking) {
+            // VM already past BU hard timeout — schedule for cleanup regardless of activity
+            if (tracking.timeoutAt && tracking.timeoutAt <= now) {
+                idleSessions.push([sessionId, tracking]);
+                continue;
+            }
+            // Timeout warnings are handled by the executor on each execute() call
+            // (deduped by minute bucket) — no need to enqueue from the relay interval.
+            if (tracking.activeExecutions > 0)
+                continue;
+            if (now - tracking.lastActivityAt > CLOUD_IDLE_TIMEOUT_MS) {
+                idleSessions.push([sessionId, tracking]);
+            }
+        }
+        if (idleSessions.length > 0) {
+            for (const [sessionId, tracking] of idleSessions) {
+                logger?.log(pc.yellow(`[Cloud] Stopping idle relay session ${sessionId} (idle > 10 min)`));
+                // Check if other relay sessions reference the same cloud VM.
+                // Only stop the VM when this is the last relay session for it.
+                const shouldStopVm = !hasOtherCloudReferences(sessionId, tracking.cloudSessionId);
+                cloudSessionTracking.delete(sessionId);
+                executorManager?.deleteExecutor(sessionId);
+                if (shouldStopVm) {
+                    disconnectCloudVm(tracking);
+                }
+            }
+            persistCloudSessions();
+        }
+    }, 60_000);
     // Use createAdaptorServer instead of serve() so we control the listen()
     // timing. This lets us inject WebSocket upgrade handlers before binding and
     // await the bind to surface EADDRINUSE as a catchable error (issue #75).
@@ -1742,6 +1967,10 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
         server.once('error', onError);
         server.listen(port, host);
     });
+    // Clean up orphaned cloud sessions from a previous relay crash.
+    // Must run AFTER successful listen — if another relay is already running,
+    // we'd fail with EADDRINUSE but only after killing its live VMs.
+    cleanupOrphanedCloudSessions();
     const wsHost = `ws://${host}:${port}`;
     const cdpEndpoint = `${wsHost}/cdp`;
     const extensionEndpoint = `${wsHost}/extension`;
@@ -1762,11 +1991,18 @@ export async function startPlayWriterCDPRelayServer({ port = 19988, host = '127.
                 }
                 ext.ws?.close(1000, 'Server stopped');
             }
+            // Close shared headless browser if any headless sessions were created (fire-and-forget)
+            void import('./executor.js').then(({ PlaywrightExecutor }) => {
+                return PlaywrightExecutor.closeSharedHeadlessBrowser();
+            });
             // Reset store state
             store.setState({
                 extensions: new Map(),
                 playwrightClients: new Map(),
             });
+            clearInterval(cloudIdleInterval);
+            cloudSessionTracking.clear();
+            persistCloudSessions(); // Remove the file on graceful shutdown
             server.close();
             emitter.removeAllListeners();
         },