@petukhovart/agent-view 0.3.0 → 0.5.0

package/dist/server/server.js

@@ -5,16 +5,18 @@ import { homedir, tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { mkdirSync } from 'node:fs';
 import { getAdapter } from '../adapters/registry.js';
-import { formatAccessibilityTree } from '../inspectors/dom/index.js';
+import { formatAccessibilityTree, countAccessibilityNodes, diffDomText } from '../inspectors/dom/index.js';
 import { getSceneGraph, getRawScene, diffScenes } from '../inspectors/scene/index.js';
 import { RefStore } from './ref-store.js';
 import { launch, isRunning } from './launcher.js';
 import { readConfig } from '../config/manager.js';
 import { RuntimeType, WebGLEngine } from '../types.js';
-import { TargetType, ConsoleLevel, EvaluationError, } from '../cdp/types.js';
+import { TargetType, ConsoleLevel, EvaluationError, MouseButton, } from '../cdp/types.js';
 import { listSupportedTargets, connectToRuntime } from '../cdp/transport.js';
 import { ConsoleStream } from '../cdp/_tests/console-stream.js';
 import { AxTreeCache } from '../cdp/ax-cache.js';
+import { WatchSession } from './watch-session.js';
+import { StopReason, WATCH_MIN_INTERVAL_MS } from '../inspectors/watch/index.js';
 const SERVER_PORT = 47922;
 const VALID_RUNTIMES = new Set(Object.values(RuntimeType));
 const VALID_ENGINES = new Set(Object.values(WebGLEngine));
@@ -62,23 +64,23 @@ export function resolveDepth(filter, explicit) {
 }
 export async function textContentFallback(conn, filter) {
     const safeFilter = JSON.stringify(filter);
-    const js = `(() => {
-    const q = ${safeFilter};
-    const results = [];
-    for (const el of document.querySelectorAll('body *')) {
-      if (results.length >= 5) break;
-      const directText = Array.from(el.childNodes)
-        .filter(n => n.nodeType === Node.TEXT_NODE)
-        .map(n => n.textContent.trim())
-        .join(' ');
-      if (directText.toLowerCase().includes(q.toLowerCase()) && el.offsetParent !== null) {
-        const id = el.id ? '#' + el.id : '';
-        const cls = el.className && typeof el.className === 'string' && el.className.trim()
-          ? '.' + el.className.trim().split(/\\s+/)[0] : '';
-        results.push(el.tagName.toLowerCase() + id + cls);
-      }
-    }
-    return results.length ? results.join(', ') : null;
+    const js = `(() => {
+    const q = ${safeFilter};
+    const results = [];
+    for (const el of document.querySelectorAll('body *')) {
+      if (results.length >= 5) break;
+      const directText = Array.from(el.childNodes)
+        .filter(n => n.nodeType === Node.TEXT_NODE)
+        .map(n => n.textContent.trim())
+        .join(' ');
+      if (directText.toLowerCase().includes(q.toLowerCase()) && el.offsetParent !== null) {
+        const id = el.id ? '#' + el.id : '';
+        const cls = el.className && typeof el.className === 'string' && el.className.trim()
+          ? '.' + el.className.trim().split(/\\s+/)[0] : '';
+        results.push(el.tagName.toLowerCase() + id + cls);
+      }
+    }
+    return results.length ? results.join(', ') : null;
   })()`;
     const result = await conn.evaluate(js);
     if (!result || typeof result !== 'string') {
@@ -108,14 +110,17 @@ export class AgentViewServer {
     refStore = new RefStore();
     idleTimer = null;
     sceneCache = new Map();
+    domTextCache = new Map();
     axTreeCache = new AxTreeCache();
     consoleStream = new ConsoleStream();
     token = '';
+    activeWatches = new Set();
     handlers = {
         discover: (req) => this.handleDiscover(req),
         launch: (req) => this.handleLaunch(req),
         dom: (req) => this.handleDom(req),
         click: (req) => this.handleClick(req),
+        drag: (req) => this.handleDrag(req),
         fill: (req) => this.handleFill(req),
         wait: (req) => this.handleWait(req),
         screenshot: (req) => this.handleScreenshot(req),
@@ -126,7 +131,8 @@ export class AgentViewServer {
         console: (req) => this.handleConsole(req),
         stop: () => this.handleStop(),
     };
-    validCommands = new Set(Object.keys(this.handlers));
+    streamingCommands = new Set(['watch']);
+    validCommands = new Set([...Object.keys(this.handlers), ...this.streamingCommands]);
     async start() {
         mkdirSync(TOKEN_DIR, { recursive: true });
         this.token = randomBytes(32).toString('hex');
@@ -143,6 +149,11 @@ export class AgentViewServer {
     resetIdleTimer() {
         if (this.idleTimer)
             clearTimeout(this.idleTimer);
+        if (this.activeWatches.size > 0) {
+            // Pause idle shutdown while streaming handlers are alive.
+            this.idleTimer = null;
+            return;
+        }
         this.idleTimer = setTimeout(() => this.shutdown(), IDLE_TIMEOUT_MS);
     }
     handleSocket(socket) {
@@ -183,6 +194,10 @@ export class AgentViewServer {
                 socket.end(JSON.stringify({ ok: false, error: 'Invalid args' }) + DELIMITER);
                 return;
             }
+            if (this.streamingCommands.has(request.command)) {
+                await this.handleWatchStreaming(request, socket);
+                return;
+            }
             const response = await this.handleCommand(request);
             socket.end(JSON.stringify(response) + DELIMITER);
         }
@@ -281,17 +296,40 @@ export class AgentViewServer {
         const conn = await this.getPageSession(req, targetId);
         const filter = argStr(req.args, 'filter');
         const useText = argBool(req.args, 'text') ?? false;
-        const nodes = await conn.getAccessibilityTree();
+        const compact = argBool(req.args, 'compact') ?? false;
+        const useCount = argBool(req.args, 'count') ?? false;
+        const isDiff = argBool(req.args, 'diff') ?? false;
+        const cacheKey = `${req.port}:${targetId}`;
+        const { nodes, fromCache } = await conn.getAccessibilityTreeMeta();
+        if (useCount) {
+            const { count } = countAccessibilityNodes(nodes, {
+                filter,
+                depth: resolveDepth(filter, argNum(req.args, 'depth')),
+            });
+            return { ok: true, data: String(count) };
+        }
         const { text, refs, nextRef } = formatAccessibilityTree(nodes, {
             filter,
             depth: resolveDepth(filter, argNum(req.args, 'depth')),
             startRef: this.refStore.getNextRef(),
+            compact,
+            maxLines: argNum(req.args, 'maxLines'),
         });
         this.refStore.store(refs, req.port, targetId, nextRef);
+        if (isDiff) {
+            const prev = this.domTextCache.get(cacheKey);
+            this.domTextCache.set(cacheKey, text);
+            if (prev === undefined) {
+                // First call — no snapshot yet, return full tree
+                return { ok: true, data: text };
+            }
+            return { ok: true, data: diffDomText(prev, text) };
+        }
         if (useText && filter && text.startsWith('(no matching')) {
             return { ok: true, data: await textContentFallback(conn, filter) };
         }
-        return { ok: true, data: text };
+        const data = fromCache ? `[cache]\n${text}` : text;
+        return { ok: true, data };
     }
     async findByFilter(conn, filter, req, targetId, preferRoles) {
         const parsed = parseFilter(filter);
@@ -419,6 +457,45 @@ export class AgentViewServer {
         this.axTreeCache.invalidate(cacheKey);
         return { ok: true, data: `Clicked ref ${ref}` };
     }
+    async handleDrag(req) {
+        const { targetId } = await this.resolveWindow(req);
+        const conn = await this.getPageSession(req, targetId);
+        const cacheKey = `${req.port}:${targetId}`;
+        const from = await this.resolveDragPoint(req, conn, 'from', { scrollIntoView: true });
+        if ('error' in from)
+            return { ok: false, error: from.error };
+        const to = await this.resolveDragPoint(req, conn, 'to', { scrollIntoView: false });
+        if ('error' in to)
+            return { ok: false, error: to.error };
+        const opts = {
+            steps: argNum(req.args, 'steps'),
+            button: parseMouseButton(argStr(req.args, 'button')),
+            holdMs: argNum(req.args, 'holdMs'),
+        };
+        await conn.dragBetweenPositions(from.point, to.point, opts);
+        this.axTreeCache.invalidate(cacheKey);
+        return {
+            ok: true,
+            data: `Dragged (${from.point.x.toFixed(0)}, ${from.point.y.toFixed(0)}) → (${to.point.x.toFixed(0)}, ${to.point.y.toFixed(0)})`,
+        };
+    }
+    async resolveDragPoint(req, conn, side, opts) {
+        const ref = argNum(req.args, `${side}Ref`);
+        const x = argNum(req.args, `${side}X`);
+        const y = argNum(req.args, `${side}Y`);
+        if (ref !== undefined) {
+            const entry = this.refStore.get(ref);
+            if (!entry) {
+                return { error: `Invalid --${side} ref: ${ref}. Run \`agent-view dom\` to get fresh refs.` };
+            }
+            const point = await conn.getBoxCenter(entry.backendDOMNodeId, opts);
+            return { point };
+        }
+        if (x !== undefined && y !== undefined) {
+            return { point: { x, y } };
+        }
+        return { error: `drag requires --${side} <ref> or --${side}-pos <x,y>` };
+    }
     async handleFill(req) {
         const { targetId } = await this.resolveWindow(req);
         const conn = await this.getPageSession(req, targetId);
@@ -475,17 +552,32 @@ export class AgentViewServer {
         }
         return { ok: false, error: `Timeout: "${filter}" not found after ${timeout}s` };
     }
+    async captureScreenshotToFile(conn, opts = {}) {
+        const { buffer, format } = await conn.captureScreenshot(opts);
+        const ext = format === 'jpeg' ? 'jpg' : format;
+        const filename = `agent-view-screenshot-${Date.now()}.${ext}`;
+        const filepath = join(tmpdir(), filename);
+        await writeFile(filepath, buffer);
+        return filepath;
+    }
     async handleScreenshot(req) {
         const { targetId } = await this.resolveWindow(req);
         const conn = await this.getPageSession(req, targetId);
         const scale = argNum(req.args, 'scale');
-        const opts = scale !== undefined ? { scale } : undefined;
-        const buffer = await conn.captureScreenshot(opts);
-        const ext = scale !== undefined && scale < 1 ? 'jpg' : 'png';
-        const filename = `agent-view-screenshot-${Date.now()}.${ext}`;
-        const filepath = join(tmpdir(), filename);
-        await writeFile(filepath, buffer);
-        return { ok: true, data: filepath };
+        const cropFilter = argStr(req.args, 'crop');
+        let warning;
+        let clip;
+        if (cropFilter !== undefined) {
+            const found = await this.findByFilter(conn, cropFilter, req, targetId);
+            if (!found) {
+                warning = `crop filter '${cropFilter}' matched nothing — capturing full window`;
+            }
+            else {
+                clip = await conn.getBoxRect(found.backendDOMNodeId, { scrollIntoView: true });
+            }
+        }
+        const filepath = await this.captureScreenshotToFile(conn, { scale, clip });
+        return { ok: true, data: filepath, warning };
     }
     async handleScene(req) {
         const { targetId } = await this.resolveWindow(req);
@@ -495,6 +587,7 @@ export class AgentViewServer {
         const sceneFilter = argStr(req.args, 'filter');
         const sceneDepth = argNum(req.args, 'depth');
         const sceneVerbose = argBool(req.args, 'verbose');
+        const sceneCompact = argBool(req.args, 'compact');
         if (isDiff) {
             const curr = await getRawScene(conn, req.engine);
             if (!curr) {
@@ -507,6 +600,7 @@ export class AgentViewServer {
                     filter: sceneFilter,
                     depth: sceneDepth,
                     verbose: sceneVerbose,
+                    compact: sceneCompact,
                 });
                 return { ok: true, data: text };
             }
@@ -516,6 +610,7 @@ export class AgentViewServer {
             filter: sceneFilter,
             depth: sceneDepth,
             verbose: sceneVerbose,
+            compact: sceneCompact,
         });
         return { ok: true, data: text };
     }
@@ -524,6 +619,7 @@ export class AgentViewServer {
         const conn = await this.getPageSession(req, targetId);
         const snapFilter = argStr(req.args, 'filter');
         const snapDepth = argNum(req.args, 'depth');
+        const snapScale = argNum(req.args, 'scale');
         const nodes = await conn.getAccessibilityTree();
         const { text: domText, refs, nextRef } = formatAccessibilityTree(nodes, {
             filter: snapFilter,
@@ -541,6 +637,10 @@ export class AgentViewServer {
                 sections.push(`=== Scene ===\n${sceneText}`);
             }
         }
+        if (snapScale !== undefined) {
+            const filepath = await this.captureScreenshotToFile(conn, { scale: snapScale });
+            sections.push(`=== Screenshot ===\n${filepath}`);
+        }
         return { ok: true, data: sections.join('\n\n') };
     }
     // ── New v0.3.0 commands ────────────────────────────────────────────────────
@@ -557,13 +657,9 @@ export class AgentViewServer {
         const windowArg = argStr(req.args, 'window');
         const allTargets = await listSupportedTargets(req.port);
         if (explicitId) {
-            const byId = allTargets.find(t => t.id === explicitId);
-            if (byId)
-                return byId;
-            const bySubstr = allTargets.find(t => t.title.toLowerCase().includes(explicitId.toLowerCase())
-                || t.url.toLowerCase().includes(explicitId.toLowerCase()));
-            if (bySubstr)
-                return bySubstr;
+            const found = findTargetByIdOrSubstring(allTargets, explicitId);
+            if (found)
+                return found;
             throw new Error(`Target not found: "${explicitId}". Run \`agent-view targets\` for the full list.`);
         }
         if (windowArg) {
@@ -618,6 +714,91 @@ export class AgentViewServer {
             return { ok: false, error: err instanceof Error ? err.message : String(err) };
         }
     }
+    async handleWatchStreaming(req, socket) {
+        const writeFrame = (frame) => {
+            if (socket.writableEnded || socket.destroyed)
+                return false;
+            return socket.write(JSON.stringify(frame) + DELIMITER);
+        };
+        const writeError = (msg) => {
+            if (!socket.writableEnded && !socket.destroyed) {
+                socket.end(JSON.stringify({ ok: false, error: msg }) + DELIMITER);
+            }
+        };
+        const cwd = argStr(req.args, 'cwd');
+        if (!cwd)
+            return writeError('watch requires cwd to validate allowEval policy');
+        const config = readConfig(resolve(cwd));
+        if (!config?.allowEval) {
+            return writeError('watch is disabled. Set "allowEval": true in agent-view.config.json to enable.');
+        }
+        const expression = argStr(req.args, 'expression');
+        if (!expression)
+            return writeError('watch requires --expression');
+        const intervalRaw = argNum(req.args, 'intervalMs') ?? 250;
+        const intervalMs = Math.max(WATCH_MIN_INTERVAL_MS, intervalRaw);
+        const durationS = argNum(req.args, 'durationS') ?? 30;
+        const maxChanges = argNum(req.args, 'maxChanges') ?? 10;
+        const until = argStr(req.args, 'until');
+        if (maxChanges <= 0)
+            return writeError('--max-changes must be > 0');
+        if (durationS <= 0)
+            return writeError('--duration must be > 0');
+        let target;
+        try {
+            target = await this.resolveTarget(req);
+        }
+        catch (err) {
+            return writeError(err instanceof Error ? err.message : String(err));
+        }
+        if (!RUNTIME_ONLY_TARGETS.has(target.type) && target.type !== TargetType.Page && target.type !== TargetType.Iframe) {
+            return writeError(`Target type "${target.type}" does not support watch.`);
+        }
+        let session;
+        try {
+            session = await this.getRuntimeSession(req, target);
+        }
+        catch (err) {
+            return writeError(err instanceof Error ? err.message : String(err));
+        }
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+        const watch = new WatchSession(session, {
+            expression,
+            intervalMs,
+            durationS,
+            maxChanges,
+            until,
+            emit: writeFrame,
+        });
+        this.activeWatches.add(watch);
+        const cleanup = () => {
+            if (!this.activeWatches.has(watch))
+                return;
+            this.activeWatches.delete(watch);
+            if (!socket.writableEnded && !socket.destroyed)
+                socket.end();
+            if (this.activeWatches.size === 0)
+                this.resetIdleTimer();
+        };
+        watch.onStop(cleanup);
+        socket.on('close', () => {
+            // Client closed (e.g. SIGINT). Stop watch with sigint reason if not already stopped.
+            watch.stop(StopReason.Sigint, true);
+        });
+        socket.on('error', () => {
+            watch.stop(StopReason.Sigint, true);
+        });
+        try {
+            await watch.start();
+        }
+        catch (err) {
+            writeFrame({ type: 'error', ts: new Date().toISOString(), message: err instanceof Error ? err.message : String(err) });
+            watch.stop(StopReason.EvalFailed, false);
+        }
+    }
     async handleConsole(req) {
         const cwd = argStr(req.args, 'cwd');
         const config = cwd ? readConfig(resolve(cwd)) : null;
@@ -626,9 +807,19 @@ export class AgentViewServer {
             // Recreate with config-tuned capacity on first attach
             this.consoleStream = new ConsoleStream({ capacity: bufferSize });
         }
+        const targetQuery = argStr(req.args, 'target');
+        // Fuzzy-resolve the target query once (id exact → title substring → url substring)
+        const all = await listSupportedTargets(req.port);
+        let resolvedTargetId;
+        if (targetQuery) {
+            const resolved = findTargetByIdOrSubstring(all, targetQuery);
+            if (!resolved) {
+                return { ok: false, error: `Target not found: "${targetQuery}". Run \`agent-view targets\` for the full list.` };
+            }
+            resolvedTargetId = resolved.id;
+        }
         if (argBool(req.args, 'clear')) {
-            const targetId = argStr(req.args, 'target');
-            this.consoleStream.clear(targetId);
+            this.consoleStream.clear(resolvedTargetId);
             return { ok: true, data: 'Console buffer cleared' };
         }
         const requestedTypes = argStrArray(req.args, 'consoleTargets')
@@ -638,16 +829,14 @@ export class AgentViewServer {
             .filter((t) => typeof t === 'string')
             .filter((t) => Object.values(TargetType).includes(t)));
         // Lazy attach: ensure every matching target has a session
-        const all = await listSupportedTargets(req.port);
-        const explicitTarget = argStr(req.args, 'target');
         if (process.env.AV_DEBUG_CONSOLE) {
             // eslint-disable-next-line no-console
-            console.error(`[av-debug] handleConsole: targets=${all.length} explicit=${explicitTarget ?? 'none'} types=${[...allowedTypes].join(',')}`);
+            console.error(`[av-debug] handleConsole: targets=${all.length} explicit=${resolvedTargetId ?? 'none'} types=${[...allowedTypes].join(',')}`);
         }
         for (const t of all) {
-            if (explicitTarget && t.id !== explicitTarget)
+            if (resolvedTargetId && t.id !== resolvedTargetId)
                 continue;
-            if (!explicitTarget && !allowedTypes.has(t.type))
+            if (!resolvedTargetId && !allowedTypes.has(t.type))
                 continue;
             if (!RUNTIME_ONLY_TARGETS.has(t.type) && t.type !== TargetType.Page && t.type !== TargetType.Iframe)
                 continue;
@@ -669,36 +858,54 @@ export class AgentViewServer {
         const levelFilter = parseLevelFilter(argStrArray(req.args, 'levels'));
         const since = argNum(req.args, 'since');
         const follow = argBool(req.args, 'follow') ?? false;
+        const untilPattern = argStr(req.args, 'until');
+        if (untilPattern && !follow) {
+            return { ok: false, error: '--until requires --follow' };
+        }
         if (follow) {
             const timeoutSec = argNum(req.args, 'timeout') ?? 10;
             const collected = this.consoleStream.drain({
                 since,
                 level: levelFilter,
-                targetId: explicitTarget,
+                targetId: resolvedTargetId,
             });
             const seenAt = collected.length > 0 ? collected[collected.length - 1].ts : (since ?? Date.now());
-            await new Promise((resolveFollow) => {
+            const matcher = untilPattern ? buildMatcher(untilPattern) : null;
+            // Check if pattern already matched in buffered messages
+            const earlyMatch = matcher ? collected.findIndex(m => matcher(m.text)) : -1;
+            if (earlyMatch !== -1) {
+                return { ok: true, data: formatConsoleMessages(collected.slice(0, earlyMatch + 1)) };
+            }
+            const timedOut = await new Promise((resolveFollow) => {
                 const dispose = this.consoleStream.subscribe((msg) => {
-                    if (explicitTarget && msg.targetId !== explicitTarget)
+                    if (resolvedTargetId && msg.targetId !== resolvedTargetId)
                         return;
                     if (levelFilter && !levelFilter.has(msg.level))
                         return;
                     if (msg.ts <= seenAt)
                         return;
                     collected.push(msg);
+                    if (matcher && matcher(msg.text)) {
+                        clearTimeout(timer);
+                        dispose();
+                        resolveFollow(false);
+                    }
                 });
                 const timer = setTimeout(() => {
                     dispose();
-                    resolveFollow();
+                    resolveFollow(true);
                 }, timeoutSec * 1000);
                 timer.unref?.();
             });
+            if (timedOut && matcher) {
+                return { ok: false, error: `Timeout: pattern not seen in ${timeoutSec}s` };
+            }
             return { ok: true, data: formatConsoleMessages(collected) };
         }
         const messages = this.consoleStream.drain({
             since,
             level: levelFilter,
-            targetId: explicitTarget,
+            targetId: resolvedTargetId,
         });
         return { ok: true, data: formatConsoleMessages(messages) };
     }
@@ -709,6 +916,9 @@ export class AgentViewServer {
     async shutdown() {
         if (this.idleTimer)
             clearTimeout(this.idleTimer);
+        for (const watch of [...this.activeWatches]) {
+            watch.stop(StopReason.ServerShutdown, false);
+        }
         await unlink(TOKEN_PATH).catch(() => { });
         this.consoleStream.detach();
         for (const cached of this.connections.values()) {
@@ -723,6 +933,19 @@ export class AgentViewServer {
     }
 }
 // ── helpers ──────────────────────────────────────────────────────────────────
+export function findTargetByIdOrSubstring(targets, query) {
+    const byId = targets.find(t => t.id === query);
+    if (byId)
+        return byId;
+    const q = query.toLowerCase();
+    return targets.find(t => t.title.toLowerCase().includes(q) || t.url.toLowerCase().includes(q)) ?? null;
+}
+function parseMouseButton(value) {
+    if (!value)
+        return undefined;
+    const valid = Object.values(MouseButton);
+    return valid.includes(value) ? value : undefined;
+}
 function parseLevelFilter(levels) {
     if (!levels || levels.length === 0)
         return undefined;
@@ -734,6 +957,14 @@ function parseLevelFilter(levels) {
     }
     return set.size > 0 ? set : undefined;
 }
+function buildMatcher(pattern) {
+    const regexMatch = /^\/(.+)\/([gimsuy]*)$/.exec(pattern);
+    if (regexMatch) {
+        const re = new RegExp(regexMatch[1], regexMatch[2]);
+        return (text) => re.test(text);
+    }
+    return (text) => text.includes(pattern);
+}
 function formatConsoleMessages(msgs) {
     if (msgs.length === 0)
         return '(no console messages)';