agentmb 0.3.1 → 0.4.0

package/dist/daemon/routes/sessions.js

@@ -57,10 +57,34 @@ function sanitizeCdpError(raw) {
         .trim()
         .slice(0, 300);
 }
+function isRetryableProfileDeleteError(err) {
+    const code = String(err?.code ?? '');
+    const message = String(err?.message ?? '');
+    if (code === 'EBUSY' || code === 'EPERM' || code === 'ENOTEMPTY')
+        return true;
+    return /resource busy|locked|not empty/i.test(message);
+}
+async function removeProfileDirWithRetry(profilePath, attempts = 6) {
+    let lastError;
+    for (let i = 0; i < attempts; i += 1) {
+        try {
+            await fs_1.default.promises.rm(profilePath, { recursive: true, force: true });
+            return;
+        }
+        catch (err) {
+            lastError = err;
+            if (!isRetryableProfileDeleteError(err) || i === attempts - 1)
+                break;
+            // Give the browser process a brief window to release filesystem handles.
+            await new Promise((resolve) => setTimeout(resolve, 120 * (i + 1)));
+        }
+    }
+    throw lastError;
+}
 function registerSessionRoutes(server, registry) {
     // POST /api/v1/sessions — create session
     server.post('/api/v1/sessions', async (req, reply) => {
-        const { profile, headless = true, agent_id, accept_downloads = false, ephemeral, browser_channel, executable_path, launch_mode, cdp_url, } = req.body ?? {};
+        const { profile, headless = true, agent_id, accept_downloads = false, ephemeral, browser_channel, executable_path, launch_mode, cdp_url, proxy_url, record_video, allow_dirs, allow_extensions, } = req.body ?? {};
         const manager = server.browserManager;
         if (!manager) {
             return reply.code(503).send({ error: 'Browser manager not initialized' });
@@ -87,7 +111,7 @@ function registerSessionRoutes(server, registry) {
         const id = registry.create({
             profile, headless, agentId: agent_id,
             ephemeral, browserChannel: browser_channel, executablePath: executable_path,
-            launchMode: launch_mode, cdpUrl: cdp_url,
+            launchMode: launch_mode, cdpUrl: cdp_url, allowExtensions: allow_extensions,
         });
         try {
             if (launch_mode === 'attach') {
@@ -115,6 +139,8 @@ function registerSessionRoutes(server, registry) {
                 await manager.launchSession(id, {
                     profile, headless, acceptDownloads: accept_downloads,
                     channel: browser_channel, executablePath: executable_path, ephemeral,
+                    proxyUrl: proxy_url, recordVideo: record_video, allowDirs: allow_dirs,
+                    allowExtensions: allow_extensions,
                 });
             }
         }
@@ -133,6 +159,7 @@ function registerSessionRoutes(server, registry) {
             ephemeral: s.ephemeral ?? false,
             browser_channel: s.browserChannel ?? null,
             launch_mode: s.launchMode ?? 'managed',
+            allow_extensions: s.allowExtensions ?? false,
         });
     });
     // GET /api/v1/sessions — list (normalized to snake_case for SDK)
@@ -175,8 +202,9 @@ function registerSessionRoutes(server, registry) {
         const s = registry.get(req.params.id);
         if (!s)
             return reply.code(404).send({ error: 'Not found' });
-        if (s.sealed) {
-            return reply.code(423).send({ error: 'session_sealed', message: 'Session is sealed and cannot be deleted. Use seal=false if you need to unseal.' });
+        const force = req.query.force === 'true';
+        if (s.sealed && !force) {
+            return reply.code(423).send({ error: 'session_sealed', message: 'Session is sealed and cannot be deleted. Use ?force=true or POST /unseal first.' });
         }
         // Clean up BrowserManager internal state first, then registry
         const manager = server.browserManager;
@@ -223,6 +251,286 @@ function registerSessionRoutes(server, registry) {
             warning: 'close will disconnect only; remote browser process is not terminated',
         };
     });
+    // ---------------------------------------------------------------------------
+    // R10-T03: session adopt — extract CDP browser state → new managed session
+    // NOTE: register /sessions/adopt BEFORE /sessions/:id/* so Fastify matches static first
+    // ---------------------------------------------------------------------------
+    server.post('/api/v1/sessions/adopt', async (req, reply) => {
+        const manager = server.browserManager;
+        if (!manager)
+            return reply.code(503).send({ error: 'Browser manager not initialized' });
+        const { cdp_url, profile: targetProfile, headed } = req.body ?? {};
+        if (!cdp_url)
+            return reply.code(400).send({ error: 'cdp_url is required' });
+        if (!cdp_url.startsWith('http://') && !cdp_url.startsWith('https://') && !cdp_url.startsWith('ws://') && !cdp_url.startsWith('wss://')) {
+            return reply.code(400).send({ error: 'cdp_url must be http/https/ws/wss' });
+        }
+        if (!targetProfile)
+            return reply.code(400).send({ error: 'profile is required' });
+        const headless = !headed;
+        // Step 1: NON-INVASIVELY extract state from external browser via CDP
+        const { chromium: chromiumPw } = await Promise.resolve().then(() => __importStar(require('playwright-core')));
+        let storageState;
+        let cdpBrowser;
+        try {
+            cdpBrowser = await chromiumPw.connectOverCDP(cdp_url);
+            const contexts = cdpBrowser.contexts();
+            if (contexts.length === 0) {
+                await cdpBrowser.close();
+                return reply.code(422).send({ error: 'No browser context found at the CDP URL. Make sure the browser is open with --remote-debugging-port.' });
+            }
+            storageState = await contexts[0].storageState();
+        }
+        catch (err) {
+            try {
+                await cdpBrowser?.close();
+            }
+            catch { /* ignore */ }
+            return reply.code(502).send({ error: `Failed to connect/extract from CDP: ${err.message}` });
+        }
+        finally {
+            // Disconnect WITHOUT closing remote browser
+            try {
+                await cdpBrowser?.close();
+            }
+            catch { /* ignore */ }
+        }
+        // Step 2: Create and launch new managed Chromium session
+        const newId = registry.create({ profile: targetProfile, headless, launchMode: 'managed' });
+        try {
+            await manager.launchSession(newId, { profile: targetProfile, headless });
+        }
+        catch (err) {
+            await registry.close(newId);
+            return reply.code(500).send({ error: `Failed to launch session: ${err.message}` });
+        }
+        // Step 3: Inject cookies (immediate)
+        const cookies = storageState.cookies ?? [];
+        let cookieWarning;
+        try {
+            if (cookies.length > 0)
+                await manager.addCookies(newId, cookies);
+        }
+        catch (err) {
+            cookieWarning = `Cookie injection failed: ${err.message}`;
+        }
+        // Step 4: Inject localStorage via initScript (deferred until page load at each origin)
+        const origins = (storageState.origins ?? []).filter(o => o.localStorage?.length > 0);
+        if (origins.length > 0) {
+            const chunks = origins.map(o => {
+                const kv = o.localStorage.map(item => `localStorage.setItem(${JSON.stringify(item.name)},${JSON.stringify(item.value)})`).join(';');
+                return `if(location.origin===${JSON.stringify(o.origin)}){${kv}}`;
+            });
+            try {
+                await manager.addInitScript(newId, chunks.join(';'));
+            }
+            catch { /* non-fatal */ }
+        }
+        getLogger()?.write({
+            session_id: newId,
+            action_id: 'act_' + crypto_1.default.randomBytes(6).toString('hex'),
+            type: 'session',
+            action: 'adopt',
+            params: { source_cdp_url: cdp_url, profile: targetProfile },
+            result: { cookies_injected: cookies.length, origins_pending: origins.length },
+        });
+        return reply.code(201).send({
+            session_id: newId,
+            profile: targetProfile,
+            channel: 'chromium',
+            source_cdp_url: cdp_url,
+            cookies_injected: cookies.length,
+            origins_pending: origins.length,
+            note: 'Source browser untouched — state extracted read-only. New managed session ready.',
+            ...(cookieWarning ? { warning: cookieWarning } : {}),
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // R10-T03: session fork — clone state from live session into new session
+    // ---------------------------------------------------------------------------
+    server.post('/api/v1/sessions/:id/fork', async (req, reply) => {
+        const live = registry.getLive(req.params.id);
+        if ('notFound' in live)
+            return reply.code(404).send({ error: `Session not found: ${req.params.id}` });
+        if ('zombie' in live)
+            return reply.code(410).send({ error: 'Session browser is not running', state: 'zombie' });
+        const manager = server.browserManager;
+        if (!manager)
+            return reply.code(503).send({ error: 'Browser manager not initialized' });
+        const { channel, profile: targetProfile, headed } = req.body ?? {};
+        const headless = !headed;
+        const VALID_CHANNELS = ['chromium', 'chrome', 'msedge'];
+        if (channel && !VALID_CHANNELS.includes(channel)) {
+            return reply.code(400).send({ error: `Invalid channel '${channel}'. Valid: ${VALID_CHANNELS.join(', ')}` });
+        }
+        // Step 1: Export state from source session
+        let storageState;
+        try {
+            storageState = await manager.getStorageState(req.params.id);
+        }
+        catch (err) {
+            return reply.code(500).send({ error: `Failed to export storage state: ${err.message}` });
+        }
+        // Step 2: Create and launch forked session
+        const resolvedProfile = targetProfile ?? live.profile;
+        // 'chromium' is default channel → pass undefined so launchSession uses default
+        const resolvedChannel = (channel && channel !== 'chromium') ? channel : undefined;
+        const newId = registry.create({
+            profile: resolvedProfile,
+            headless,
+            browserChannel: resolvedChannel,
+            launchMode: 'managed',
+        });
+        try {
+            await manager.launchSession(newId, {
+                profile: resolvedProfile,
+                headless,
+                channel: resolvedChannel,
+            });
+        }
+        catch (err) {
+            await registry.close(newId);
+            return reply.code(500).send({ error: `Failed to launch fork session: ${err.message}` });
+        }
+        // Step 3: Inject cookies (immediate)
+        const cookies = storageState.cookies ?? [];
+        let cookieWarning;
+        try {
+            if (cookies.length > 0)
+                await manager.addCookies(newId, cookies);
+        }
+        catch (err) {
+            cookieWarning = `Cookie injection failed: ${err.message}`;
+        }
+        // Step 4: Inject localStorage via initScript (runs on each subsequent page load at each origin)
+        const origins = (storageState.origins ?? []).filter(o => o.localStorage?.length > 0);
+        if (origins.length > 0) {
+            const chunks = origins.map(o => {
+                const kv = o.localStorage.map(item => `localStorage.setItem(${JSON.stringify(item.name)},${JSON.stringify(item.value)})`).join(';');
+                return `if(location.origin===${JSON.stringify(o.origin)}){${kv}}`;
+            });
+            try {
+                await manager.addInitScript(newId, chunks.join(';'));
+            }
+            catch { /* non-fatal */ }
+        }
+        getLogger()?.write({
+            session_id: newId,
+            action_id: 'act_' + crypto_1.default.randomBytes(6).toString('hex'),
+            type: 'session',
+            action: 'fork',
+            params: { source_session_id: req.params.id, channel: channel ?? 'chromium', profile: resolvedProfile },
+            result: { cookies_injected: cookies.length, origins_pending: origins.length },
+        });
+        return reply.code(201).send({
+            session_id: newId,
+            profile: resolvedProfile,
+            channel: channel ?? 'chromium',
+            source_session_id: req.params.id,
+            cookies_injected: cookies.length,
+            origins_pending: origins.length,
+            ...(cookieWarning ? { warning: cookieWarning } : {}),
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // R10-T04: switch-engine — hot-swap Chromium ↔ Chrome/Edge with state transfer
+    // ---------------------------------------------------------------------------
+    server.put('/api/v1/sessions/:id/switch-engine', async (req, reply) => {
+        const live = registry.getLive(req.params.id);
+        if ('notFound' in live)
+            return reply.code(404).send({ error: `Session not found: ${req.params.id}` });
+        if ('zombie' in live)
+            return reply.code(410).send({ error: 'Session browser is not running', state: 'zombie' });
+        const manager = server.browserManager;
+        if (!manager)
+            return reply.code(503).send({ error: 'Browser manager not initialized' });
+        const { target_channel, keep_source = false, headed = false } = req.body ?? {};
+        const headless = !headed;
+        const VALID_CHANNELS = ['chromium', 'chrome', 'msedge'];
+        if (!target_channel)
+            return reply.code(400).send({ error: 'target_channel is required' });
+        if (!VALID_CHANNELS.includes(target_channel)) {
+            return reply.code(400).send({ error: `Invalid target_channel '${target_channel}'. Valid: ${VALID_CHANNELS.join(', ')}` });
+        }
+        const sourceSession = registry.get(req.params.id);
+        const oldChannel = sourceSession.browserChannel ?? 'chromium';
+        // Step 1: Export state from source session (rollback-safe: source untouched until new session launches)
+        let storageState;
+        try {
+            storageState = await manager.getStorageState(req.params.id);
+        }
+        catch (err) {
+            return reply.code(500).send({ error: `Failed to export storage state: ${err.message}` });
+        }
+        // Step 2: Create new session with target channel
+        const resolvedChannel = target_channel !== 'chromium' ? target_channel : undefined;
+        const newId = registry.create({
+            profile: sourceSession.profile,
+            headless,
+            browserChannel: resolvedChannel,
+            launchMode: 'managed',
+        });
+        try {
+            await manager.launchSession(newId, {
+                profile: sourceSession.profile,
+                headless,
+                channel: resolvedChannel,
+            });
+        }
+        catch (err) {
+            // Rollback: clean up temp session, source session untouched
+            await registry.close(newId);
+            return reply.code(502).send({ error: `Target engine failed to start: ${err.message}`, old_channel: oldChannel, new_channel: target_channel });
+        }
+        // Step 3: Inject cookies into new session
+        const cookies = storageState.cookies ?? [];
+        let cookieWarning;
+        try {
+            if (cookies.length > 0)
+                await manager.addCookies(newId, cookies);
+        }
+        catch (err) {
+            cookieWarning = `Cookie transfer failed: ${err.message}`;
+        }
+        // Step 4: Inject localStorage via initScript (deferred per origin)
+        const origins = (storageState.origins ?? []).filter(o => o.localStorage?.length > 0);
+        if (origins.length > 0) {
+            const chunks = origins.map(o => {
+                const kv = o.localStorage.map(item => `localStorage.setItem(${JSON.stringify(item.name)},${JSON.stringify(item.value)})`).join(';');
+                return `if(location.origin===${JSON.stringify(o.origin)}){${kv}}`;
+            });
+            try {
+                await manager.addInitScript(newId, chunks.join(';'));
+            }
+            catch { /* non-fatal */ }
+        }
+        // Step 5: Close source session if not keeping it
+        if (!keep_source) {
+            if (manager)
+                await manager.closeSession(req.params.id);
+            await registry.close(req.params.id);
+        }
+        getLogger()?.write({
+            session_id: newId,
+            action_id: 'act_' + crypto_1.default.randomBytes(6).toString('hex'),
+            type: 'session',
+            action: 'switch_engine',
+            params: { source_session_id: req.params.id, old_channel: oldChannel, new_channel: target_channel, keep_source },
+            result: { cookies_transferred: cookies.length, origins_transferred: origins.length },
+        });
+        return reply.code(200).send({
+            session_id: newId,
+            old_session_id: keep_source ? req.params.id : null,
+            old_channel: oldChannel,
+            new_channel: target_channel,
+            profile: sourceSession.profile,
+            headless,
+            cookies_transferred: cookies.length,
+            origins_transferred: origins.length,
+            keep_source,
+            ...(cookieWarning ? { warning: cookieWarning } : {}),
+        });
+    });
     // POST /api/v1/sessions/:id/seal — mark session as sealed (blocks DELETE)
     server.post('/api/v1/sessions/:id/seal', async (req, reply) => {
         const s = registry.get(req.params.id);
@@ -236,6 +544,19 @@ function registerSessionRoutes(server, registry) {
         }
         return { status: 'ok', session_id: req.params.id, sealed: true };
     });
+    // POST /api/v1/sessions/:id/unseal — T06: remove seal so session can be deleted
+    server.post('/api/v1/sessions/:id/unseal', async (req, reply) => {
+        const s = registry.get(req.params.id);
+        if (!s)
+            return reply.code(404).send({ error: 'Not found' });
+        try {
+            registry.unseal(req.params.id);
+        }
+        catch (err) {
+            return reply.code(400).send({ error: err.message });
+        }
+        return { status: 'ok', session_id: req.params.id, sealed: false };
+    });
     // POST /api/v1/sessions/:id/mode — switch headless/headed
     server.post('/api/v1/sessions/:id/mode', async (req, reply) => {
         const s = registry.get(req.params.id);
@@ -649,41 +970,165 @@ function registerSessionRoutes(server, registry) {
         };
     });
     // ---------------------------------------------------------------------------
-    // R08-R14: Profile lifecycle — list + reset
+    // R10-T07: Runtime permission grant — browserContext.grantPermissions()
     // ---------------------------------------------------------------------------
-    function getProfilesDir() {
+    server.post('/api/v1/sessions/:id/grant-permission', async (req, reply) => {
+        const live = registry.getLive(req.params.id);
+        if ('notFound' in live)
+            return reply.code(404).send({ error: `Session not found: ${req.params.id}` });
+        if ('zombie' in live)
+            return reply.code(410).send({ error: 'Session browser is not running', state: 'zombie' });
+        const { permissions, origin } = req.body ?? {};
+        if (!Array.isArray(permissions) || permissions.length === 0) {
+            return reply.code(400).send({ error: 'permissions must be a non-empty array' });
+        }
+        const VALID_PERMISSIONS = new Set([
+            'camera', 'microphone', 'notifications', 'geolocation',
+            'clipboard-read', 'clipboard-write', 'accelerometer', 'background-sync',
+            'magnetometer', 'gyroscope', 'midi', 'payment-handler', 'persistent-storage',
+        ]);
+        const invalid = permissions.filter(p => !VALID_PERMISSIONS.has(p));
+        if (invalid.length > 0) {
+            return reply.code(400).send({ error: `Unknown permission(s): ${invalid.join(', ')}` });
+        }
+        try {
+            const grantOpts = origin ? { origin } : {};
+            await live.context.grantPermissions(permissions, grantOpts);
+            return { status: 'ok', session_id: req.params.id, permissions, origin: origin ?? null };
+        }
+        catch (err) {
+            return reply.code(500).send({ error: err.message });
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // R08-R14 / R10-T05: Profile lifecycle — list + reset + delete (with zone)
+    // ---------------------------------------------------------------------------
+    /**
+     * zone 'managed' → profiles/ (Playwright-managed Chromium)
+     * zone 'stable'  → chrome-profiles/ (Chrome/Edge native browser)
+     */
+    function getZoneDir(zone) {
         const dataDir = process.env.AGENTMB_DATA_DIR ?? path_1.default.join(os_1.default.homedir(), '.agentmb');
-        return path_1.default.join(dataDir, 'profiles');
+        return zone === 'stable'
+            ? path_1.default.join(dataDir, 'chrome-profiles')
+            : path_1.default.join(dataDir, 'profiles');
     }
-    server.get('/api/v1/profiles', async (_req, reply) => {
-        const dir = getProfilesDir();
+    /** Recursively sum file sizes in a directory. */
+    async function dirSize(dirPath) {
+        let total = 0;
         try {
-            if (!fs_1.default.existsSync(dir))
-                return { profiles: [], count: 0 };
-            const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
-            const profiles = await Promise.all(entries
-                .filter(e => e.isDirectory())
-                .map(async (e) => {
-                const profilePath = path_1.default.join(dir, e.name);
-                let last_used = null;
-                try {
-                    const stat = await fs_1.default.promises.stat(profilePath);
-                    last_used = stat.mtime.toISOString();
+            const items = await fs_1.default.promises.readdir(dirPath, { withFileTypes: true });
+            await Promise.all(items.map(async (item) => {
+                const fullPath = path_1.default.join(dirPath, item.name);
+                if (item.isDirectory()) {
+                    total += await dirSize(fullPath);
+                }
+                else if (item.isFile()) {
+                    try {
+                        total += (await fs_1.default.promises.stat(fullPath)).size;
+                    }
+                    catch { /* ignore */ }
                 }
-                catch { /* ignore */ }
-                return { name: e.name, path: profilePath, last_used };
             }));
+        }
+        catch { /* ignore */ }
+        return total;
+    }
+    /** Scan one zone directory and return enriched profile entries. */
+    async function listZoneProfiles(zone) {
+        const dir = getZoneDir(zone);
+        if (!fs_1.default.existsSync(dir))
+            return [];
+        const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
+        return Promise.all(entries
+            .filter(e => e.isDirectory())
+            .map(async (e) => {
+            const profilePath = path_1.default.join(dir, e.name);
+            let last_modified = null;
+            try {
+                const stat = await fs_1.default.promises.stat(profilePath);
+                last_modified = stat.mtime.toISOString();
+            }
+            catch { /* ignore */ }
+            const size_bytes = await dirSize(profilePath);
+            const liveSessions = registry.list().filter(s => s.profile === e.name && s.state === 'live');
+            return {
+                zone,
+                name: e.name,
+                path: profilePath,
+                size_bytes,
+                sessions_live: liveSessions.length,
+                session_ids: liveSessions.map(s => s.id),
+                last_modified,
+            };
+        }));
+    }
+    // GET /api/v1/profiles[?zone=managed|stable] — list profiles with zone/size/session info
+    server.get('/api/v1/profiles', async (req, reply) => {
+        const { zone } = req.query ?? {};
+        if (zone && zone !== 'managed' && zone !== 'stable') {
+            return reply.code(400).send({ error: "zone must be 'managed' or 'stable'" });
+        }
+        try {
+            let profiles = [];
+            if (!zone || zone === 'managed')
+                profiles = profiles.concat(await listZoneProfiles('managed'));
+            if (!zone || zone === 'stable')
+                profiles = profiles.concat(await listZoneProfiles('stable'));
             return { profiles, count: profiles.length };
         }
         catch (err) {
             return reply.code(500).send({ error: err.message });
         }
     });
+    // DELETE /api/v1/profiles/:name[?zone=managed|stable][&force=true] — T05 profile delete
+    server.delete('/api/v1/profiles/:name', async (req, reply) => {
+        const { name } = req.params;
+        const zone = (req.query.zone ?? 'managed');
+        const force = req.query.force === 'true';
+        if (!/^[\w\-]+$/.test(name))
+            return reply.code(400).send({ error: 'Invalid profile name; only alphanumeric, dash, underscore allowed' });
+        if (zone !== 'managed' && zone !== 'stable') {
+            return reply.code(400).send({ error: "zone must be 'managed' or 'stable'" });
+        }
+        const dir = getZoneDir(zone);
+        const profilePath = path_1.default.join(dir, name);
+        // Safety: no path traversal
+        if (!profilePath.startsWith(dir + path_1.default.sep))
+            return reply.code(400).send({ error: 'Invalid profile name' });
+        if (!fs_1.default.existsSync(profilePath)) {
+            return reply.code(404).send({ error: `Profile '${name}' not found in zone '${zone}'` });
+        }
+        // Destruction protection: check for live sessions
+        const liveSessions = registry.list().filter(s => s.profile === name && s.state === 'live');
+        if (liveSessions.length > 0 && !force) {
+            return reply.code(423).send({
+                error: 'profile_locked',
+                message: `Profile '${name}' has ${liveSessions.length} live session(s). Use --force to override.`,
+                session_ids: liveSessions.map(s => s.id),
+            });
+        }
+        try {
+            if (force && liveSessions.length > 0) {
+                const manager = server.browserManager;
+                for (const s of liveSessions) {
+                    if (manager)
+                        await manager.closeSession(s.id);
+                    await registry.close(s.id);
+                }
+            }
+            await removeProfileDirWithRetry(profilePath);
+            return reply.code(204).send();
+        }
+        catch (err) {
+            return reply.code(500).send({ error: err.message });
+        }
+    });
     server.post('/api/v1/profiles/:name/reset', async (req, reply) => {
         const { name } = req.params;
         if (!/^[\w\-]+$/.test(name))
             return reply.code(400).send({ error: 'Invalid profile name; only alphanumeric, dash, underscore allowed' });
-        const dir = getProfilesDir();
+        const dir = getZoneDir('managed');
         const profilePath = path_1.default.join(dir, name);
         // Safety: ensure profilePath is inside dir (no path traversal)
         if (!profilePath.startsWith(dir + path_1.default.sep))
@@ -708,5 +1153,110 @@ function registerSessionRoutes(server, registry) {
             return reply.code(500).send({ error: err.message });
         }
     });
+    async function scanDir(dirPath, depth) {
+        const entries = [];
+        let items;
+        try {
+            items = await fs_1.default.promises.readdir(dirPath, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        for (const item of items) {
+            const fullPath = path_1.default.join(dirPath, item.name);
+            if (item.isDirectory()) {
+                const entry = { name: item.name, type: 'dir', path: fullPath };
+                if (depth > 1)
+                    entry.children = await scanDir(fullPath, depth - 1);
+                entries.push(entry);
+            }
+            else if (item.isFile()) {
+                let size;
+                try {
+                    size = (await fs_1.default.promises.stat(fullPath)).size;
+                }
+                catch { /* ignore */ }
+                entries.push({ name: item.name, type: 'file', path: fullPath, size });
+            }
+        }
+        return entries;
+    }
+    /** Shared ls handler — used by both GET and POST endpoints. */
+    async function handleLs(bm, session_id, reqPath, depthStr, reply) {
+        if (!bm)
+            return reply.code(503).send({ error: 'Browser manager not initialized' });
+        if (!session_id)
+            return reply.code(400).send({ error: 'session_id is required' });
+        if (!reqPath)
+            return reply.code(400).send({ error: 'path is required' });
+        const s = registry.get(session_id);
+        if (!s)
+            return reply.code(404).send({ error: `Session ${session_id} not found` });
+        const allowDirs = bm.getAllowDirs(session_id);
+        if (allowDirs.length === 0) {
+            return reply.code(403).send({ error: 'No allowed directories for this session. Set allow_dirs when creating session.' });
+        }
+        // R09-C07-P0: resolve symlinks via realpath to prevent symlink traversal attacks.
+        // path.resolve() only does string manipulation; fs.realpath follows symlinks on disk.
+        let abs;
+        try {
+            abs = await fs_1.default.promises.realpath(reqPath);
+        }
+        catch {
+            return reply.code(404).send({ error: `Path ${reqPath} does not exist or is not accessible.` });
+        }
+        const allowed = allowDirs.some(d => abs === d || abs.startsWith(d + path_1.default.sep));
+        if (!allowed) {
+            return reply.code(403).send({ error: `Path ${reqPath} is not within allowed directories.` });
+        }
+        const depth = Math.min(parseInt(depthStr ?? '1', 10) || 1, 5);
+        const entries = await scanDir(abs, depth);
+        return { path: abs, entries, session_id };
+    }
+    // GET variant (query params — ASCII paths, backward compatible)
+    server.get('/api/v1/utils/ls', async (req, reply) => {
+        const { session_id, path: reqPath, depth: depthStr } = req.query;
+        return handleLs(server.browserManager, session_id, reqPath, depthStr, reply);
+    });
+    // POST variant (JSON body — supports non-ASCII / Unicode paths, R09-C06-P2)
+    server.post('/api/v1/utils/ls', async (req, reply) => {
+        const { session_id, path: reqPath, depth } = req.body ?? {};
+        return handleLs(server.browserManager, session_id, reqPath, depth !== undefined ? String(depth) : undefined, reply);
+    });
+    // ---------------------------------------------------------------------------
+    // R09-C04-T08: Video recording endpoints
+    // ---------------------------------------------------------------------------
+    server.get('/api/v1/sessions/:id/video', async (req, reply) => {
+        const s = registry.get(req.params.id);
+        if (!s)
+            return reply.code(404).send({ error: 'Not found' });
+        const manager = server.browserManager;
+        if (!manager)
+            return reply.code(503).send({ error: 'Browser manager not initialized' });
+        const videoPath = await manager.getVideoPath(req.params.id);
+        return { session_id: req.params.id, video_path: videoPath };
+    });
+    server.post('/api/v1/sessions/:id/video/save', async (req, reply) => {
+        const s = registry.get(req.params.id);
+        if (!s)
+            return reply.code(404).send({ error: 'Not found' });
+        const manager = server.browserManager;
+        if (!manager)
+            return reply.code(503).send({ error: 'Browser manager not initialized' });
+        const videoPath = await manager.getVideoPath(req.params.id);
+        if (!videoPath)
+            return reply.code(404).send({ error: 'No video available for this session. Ensure record_video=true was set on session creation.' });
+        const { dest_path } = req.body ?? {};
+        if (!dest_path)
+            return reply.code(400).send({ error: 'dest_path is required' });
+        try {
+            await fs_1.default.promises.mkdir(path_1.default.dirname(dest_path), { recursive: true });
+            await fs_1.default.promises.copyFile(videoPath, dest_path);
+            return { session_id: req.params.id, saved_to: dest_path, source: videoPath };
+        }
+        catch (err) {
+            return reply.code(500).send({ error: err.message });
+        }
+    });
 }
 //# sourceMappingURL=sessions.js.map