@petukhovart/agent-view 0.13.0 → 0.14.0

package/dist/server/server.js

@@ -18,6 +18,8 @@ import { ConsoleStream } from '../cdp/_tests/console-stream.js';
 import { NetworkStream } from '../cdp/network-stream.js';
 import { formatNetworkList, formatNetworkDetail } from '../inspectors/network/index.js';
 import { formatDialogStatus, describePolicy, describeArm } from '../inspectors/dialog/index.js';
+import { formatCoverage } from '../inspectors/coverage/index.js';
+import { formatListeners } from '../inspectors/listeners/index.js';
 import { buildTauriArmScript, buildTauriStatusScript, TauriShimResult } from './tauri-dialog-shim.js';
 import { NetworkResourceType } from '../cdp/types.js';
 import { AxTreeCache } from '../cdp/ax-cache.js';
@@ -164,13 +166,9 @@ export class AgentViewServer {
     sceneCache = new Map();
     domTextCache = new Map();
     axTreeCache = new AxTreeCache();
-    consoleStream = new ConsoleStream();
-    networkStream = new NetworkStream();
-    networkRefs = new Map();
-    networkNextRef = 1;
+    portStates = new Map();
     token = '';
     activeWatches = new Set();
-    logRecorder = null;
     handlers = {
         discover: (req) => this.handleDiscover(req),
         launch: (req) => this.handleLaunch(req),
@@ -189,6 +187,8 @@ export class AgentViewServer {
         logs: (req) => this.handleLogs(req),
         upload: (req) => this.handleUpload(req),
         dialog: (req) => this.handleDialog(req),
+        coverage: (req) => this.handleCoverage(req),
+        listeners: (req) => this.handleListeners(req),
         stop: () => this.handleStop(),
     };
     streamingCommands = new Set(['watch']);
@@ -210,10 +210,31 @@ export class AgentViewServer {
         });
         await writeFile(TOKEN_PATH, this.token, { mode: 0o600 });
     }
+    /** Per-port state bucket, created on first use. */
+    stateFor(port) {
+        let state = this.portStates.get(port);
+        if (!state) {
+            state = {
+                consoleStream: new ConsoleStream(),
+                networkStream: new NetworkStream(),
+                networkRefs: new Map(),
+                networkNextRef: 1,
+                logRecorder: null,
+            };
+            this.portStates.set(port, state);
+        }
+        return state;
+    }
+    isAnyRecording() {
+        for (const state of this.portStates.values())
+            if (state.logRecorder)
+                return true;
+        return false;
+    }
     resetIdleTimer() {
         if (this.idleTimer)
             clearTimeout(this.idleTimer);
-        if (this.activeWatches.size > 0 || this.logRecorder !== null) {
+        if (this.activeWatches.size > 0 || this.isAnyRecording()) {
             // Pause idle shutdown while streaming handlers or a log recording are alive —
             // a recording that dies at the 5-min mark loses exactly the long scenario it was for.
             this.idleTimer = null;
@@ -326,8 +347,9 @@ export class AgentViewServer {
             return;
         this.connections.delete(connKey);
         const targetId = cached.session.target.id;
-        this.consoleStream.detach(targetId);
-        this.networkStream.detach(targetId);
+        const state = this.portStates.get(Number(connKey.slice(0, connKey.indexOf(':'))));
+        state?.consoleStream.detach(targetId);
+        state?.networkStream.detach(targetId);
         this.axTreeCache.invalidate(connKey);
         cached.session.close().catch(() => { });
     }
@@ -441,8 +463,9 @@ export class AgentViewServer {
      * mirroring the consoleStream pattern.
      */
     async ensureNetworkAttached(req, config) {
-        if (this.networkStream.attachedCount === 0) {
-            this.networkStream = new NetworkStream({
+        const state = this.stateFor(req.port);
+        if (state.networkStream.attachedCount === 0) {
+            state.networkStream = new NetworkStream({
                 capacity: config?.networkBufferSize ?? DEFAULT_NETWORK_BUFFER,
                 captureBody: config?.captureBody ?? false,
             });
@@ -453,7 +476,7 @@ export class AgentViewServer {
                 continue;
             try {
                 const session = await this.getPageSession(req, t.id);
-                await this.networkStream.attach(session);
+                await state.networkStream.attach(session);
             }
             catch { /* a single unreachable target shouldn't abort capture */ }
         }
@@ -593,8 +616,11 @@ export class AgentViewServer {
         const conn = await this.getPageSession(req, targetId);
         const cacheKey = `${req.port}:${targetId}`;
         const clicks = argBool(req.args, 'double') ? 2 : 1;
-        const clickOpts = clicks > 1 ? { clicks } : undefined;
-        const verb = clicks > 1 ? 'Double-clicked' : 'Clicked';
+        const right = argBool(req.args, 'right');
+        const clickOpts = clicks > 1 || right
+            ? { ...(clicks > 1 ? { clicks } : {}), ...(right ? { button: MouseButton.Right } : {}) }
+            : undefined;
+        const verb = right ? 'Right-clicked' : clicks > 1 ? 'Double-clicked' : 'Clicked';
         if (req.args.pos && typeof req.args.pos === 'object') {
             const pos = req.args.pos;
             const x = typeof pos.x === 'number' ? pos.x : 0;
@@ -859,6 +885,67 @@ export class AgentViewServer {
             return { patched: false, armed: false, fired: [] };
         }
     }
+    /**
+     * Forward reachability. `--clear` opens a coverage window, the next call closes
+     * it and reports what ran inside — so a click can be attributed to the functions
+     * it actually executed. Purchases only positive answers: an empty delta proves
+     * that *this* action did not reach the code, never that nothing can.
+     */
+    async handleCoverage(req) {
+        const target = await this.resolveTarget(req);
+        const conn = await this.getRuntimeSession(req, target);
+        if (argBool(req.args, 'clear')) {
+            await conn.startCoverage();
+            return { ok: true, data: 'Coverage window cleared' };
+        }
+        const scripts = await conn.takeCoverage();
+        if (scripts === null) {
+            return {
+                ok: false,
+                error: 'No coverage window open. Run `agent-view coverage --clear` before the action you want to attribute.',
+            };
+        }
+        const result = formatCoverage(scripts, {
+            filter: argStr(req.args, 'filter'),
+            file: argStr(req.args, 'file'),
+            all: argBool(req.args, 'all'),
+            maxLines: argNum(req.args, 'maxLines'),
+        });
+        if (argBool(req.args, 'count'))
+            return { ok: true, data: String(result.functions) };
+        return { ok: true, data: result.text };
+    }
+    /** Which handlers are wired to a node, and where each was declared. */
+    async handleListeners(req) {
+        const { targetId } = await this.resolveWindow(req);
+        const conn = await this.getPageSession(req, targetId);
+        const depth = argNum(req.args, 'depth') ?? 0;
+        const selector = argStr(req.args, 'selector');
+        if (selector) {
+            const listeners = await conn.getEventListenersBySelector(selector, depth);
+            if (listeners === null)
+                return { ok: false, error: `No element matches selector "${selector}"` };
+            return { ok: true, data: formatListeners(`"${selector}"`, listeners) };
+        }
+        const filter = argStr(req.args, 'filter');
+        if (filter) {
+            const found = await this.findByFilter(conn, filter, req, targetId);
+            if (!found)
+                return { ok: false, error: `No element found matching "${filter}"` };
+            const listeners = await conn.getEventListeners(found.backendDOMNodeId, depth);
+            return { ok: true, data: formatListeners(`"${found.name}"`, listeners) };
+        }
+        const ref = argNum(req.args, 'ref');
+        if (ref === undefined) {
+            return { ok: false, error: 'listeners requires --filter, --ref, or --selector' };
+        }
+        const entry = this.refStore.get(ref);
+        if (!entry) {
+            return { ok: false, error: `Invalid ref: ${ref}. Run \`agent-view dom\` to get fresh refs.` };
+        }
+        const listeners = await conn.getEventListeners(entry.backendDOMNodeId, depth);
+        return { ok: true, data: formatListeners(`[ref=${ref}]`, listeners) };
+    }
     async handleWait(req) {
         const filter = argStr(req.args, 'filter');
         if (!filter) {
@@ -1153,6 +1240,7 @@ export class AgentViewServer {
      */
     async attachConsoleTargets(req, opts) {
         const sessions = [];
+        const state = this.stateFor(req.port);
         if (process.env.AV_DEBUG_CONSOLE) {
             // eslint-disable-next-line no-console
             console.error(`[av-debug] attachConsoleTargets: targets=${opts.targets.length} explicit=${opts.targetId ?? 'none'} types=${[...opts.allowedTypes].join(',')}`);
@@ -1166,11 +1254,11 @@ export class AgentViewServer {
                 continue;
             try {
                 const session = await this.getRuntimeSession(req, t);
-                this.consoleStream.attach(session);
+                state.consoleStream.attach(session);
                 sessions.push(session);
                 if (process.env.AV_DEBUG_CONSOLE) {
                     // eslint-disable-next-line no-console
-                    console.error(`[av-debug] attachConsoleTargets: attached ${t.type}:${t.id.slice(0, 8)} (stream now has ${this.consoleStream.attachedCount})`);
+                    console.error(`[av-debug] attachConsoleTargets: attached ${t.type}:${t.id.slice(0, 8)} (stream now has ${state.consoleStream.attachedCount})`);
                 }
             }
             catch (err) {
@@ -1186,10 +1274,11 @@ export class AgentViewServer {
         const cwd = argStr(req.args, 'cwd');
         const config = cwd ? readConfig(resolve(cwd)) : null;
         const bufferSize = config?.consoleBufferSize ?? 500;
-        if (this.consoleStream.attachedCount === 0 && this.logRecorder === null) {
+        const state = this.stateFor(req.port);
+        if (state.consoleStream.attachedCount === 0 && state.logRecorder === null) {
             // Recreate with config-tuned capacity on first attach. Never while recording — the
             // recorder's subscription lives on the stream instance and would be dropped silently.
-            this.consoleStream = new ConsoleStream({ capacity: bufferSize });
+            state.consoleStream = new ConsoleStream({ capacity: bufferSize });
         }
         const targetQuery = argStr(req.args, 'target');
         // Fuzzy-resolve the target query once (id exact → title substring → url substring)
@@ -1203,7 +1292,7 @@ export class AgentViewServer {
             resolvedTargetId = match.target.id;
         }
         if (argBool(req.args, 'clear')) {
-            this.consoleStream.clear(resolvedTargetId);
+            state.consoleStream.clear(resolvedTargetId);
             return { ok: true, data: 'Console buffer cleared' };
         }
         await this.attachConsoleTargets(req, {
@@ -1220,7 +1309,7 @@ export class AgentViewServer {
         }
         if (follow) {
             const timeoutSec = argNum(req.args, 'timeout') ?? 10;
-            const collected = this.consoleStream.drain({
+            const collected = state.consoleStream.drain({
                 since,
                 level: levelFilter,
                 targetId: resolvedTargetId,
@@ -1233,7 +1322,7 @@ export class AgentViewServer {
                 return { ok: true, data: formatConsoleMessages(collected.slice(0, earlyMatch + 1)) };
             }
             const timedOut = await new Promise((resolveFollow) => {
-                const dispose = this.consoleStream.subscribe((msg) => {
+                const dispose = state.consoleStream.subscribe((msg) => {
                     if (resolvedTargetId && msg.targetId !== resolvedTargetId)
                         return;
                     if (levelFilter && !levelFilter.has(msg.level))
@@ -1258,7 +1347,7 @@ export class AgentViewServer {
             }
             return { ok: true, data: formatConsoleMessages(collected) };
         }
-        const messages = this.consoleStream.drain({
+        const messages = state.consoleStream.drain({
             since,
             level: levelFilter,
             targetId: resolvedTargetId,
@@ -1269,6 +1358,7 @@ export class AgentViewServer {
         const cwd = argStr(req.args, 'cwd');
         const config = cwd ? readConfig(resolve(cwd)) : null;
         await this.ensureNetworkAttached(req, config);
+        const state = this.stateFor(req.port);
         let resolvedTargetId;
         const targetQuery = argStr(req.args, 'target') ?? argStr(req.args, 'window');
         if (targetQuery) {
@@ -1281,18 +1371,18 @@ export class AgentViewServer {
         }
         const reqN = argNum(req.args, 'req');
         if (reqN !== undefined) {
-            const ref = this.networkRefs.get(reqN);
+            const ref = state.networkRefs.get(reqN);
             if (!ref) {
                 return { ok: false, error: `Invalid req: ${reqN}. Run \`agent-view network\` to get fresh handles.` };
             }
-            const entry = this.networkStream.getEntry(ref.targetId, ref.requestId);
+            const entry = state.networkStream.getEntry(ref.targetId, ref.requestId);
             if (!entry) {
                 return { ok: false, error: `Request ${reqN} is no longer buffered (evicted or app restarted).` };
             }
             return { ok: true, data: formatNetworkDetail(entry, { rawHeaders: argBool(req.args, 'rawHeaders') ?? false }) };
         }
         if (argBool(req.args, 'clear')) {
-            this.networkStream.clear(resolvedTargetId);
+            state.networkStream.clear(resolvedTargetId);
             return { ok: true, data: 'Network buffer cleared' };
         }
         const filter = {
@@ -1312,31 +1402,33 @@ export class AgentViewServer {
         if (follow) {
             return this.followNetwork(req, filter, maxLines, untilPattern);
         }
-        const entries = this.networkStream.drain(filter);
-        return { ok: true, data: this.renderNetworkList(entries, maxLines) };
+        const entries = state.networkStream.drain(filter);
+        return { ok: true, data: this.renderNetworkList(req.port, entries, maxLines) };
     }
-    renderNetworkList(entries, maxLines) {
-        const { text, refs, nextRef } = formatNetworkList(entries, { startRef: this.networkNextRef, maxLines });
-        this.networkRefs.clear();
+    renderNetworkList(port, entries, maxLines) {
+        const state = this.stateFor(port);
+        const { text, refs, nextRef } = formatNetworkList(entries, { startRef: state.networkNextRef, maxLines });
+        state.networkRefs.clear();
         for (const r of refs)
-            this.networkRefs.set(r.ref, { targetId: r.targetId, requestId: r.requestId });
-        this.networkNextRef = nextRef;
+            state.networkRefs.set(r.ref, { targetId: r.targetId, requestId: r.requestId });
+        state.networkNextRef = nextRef;
         return text;
     }
     async followNetwork(req, filter, maxLines, untilPattern) {
         const timeoutSec = argNum(req.args, 'timeout') ?? 10;
         const matcher = untilPattern ? buildMatcher(untilPattern) : null;
         const matchText = (e) => `${e.method ?? (e.isWebSocket ? 'WS' : e.isEventSource ? 'SSE' : '')} ${e.status ?? e.state} ${e.url}`;
+        const state = this.stateFor(req.port);
         if (matcher) {
-            const pre = this.networkStream.drain(filter);
+            const pre = state.networkStream.drain(filter);
             const hit = pre.findIndex(e => matcher(matchText(e)));
             if (hit !== -1)
-                return { ok: true, data: this.renderNetworkList(pre.slice(0, hit + 1), maxLines) };
+                return { ok: true, data: this.renderNetworkList(req.port, pre.slice(0, hit + 1), maxLines) };
         }
         const matched = await new Promise((resolveFollow) => {
             const dispose = matcher
-                ? this.networkStream.subscribe(() => {
-                    const cur = this.networkStream.drain(filter);
+                ? state.networkStream.subscribe(() => {
+                    const cur = state.networkStream.drain(filter);
                     if (cur.some(e => matcher(matchText(e)))) {
                         clearTimeout(timer);
                         dispose();
@@ -1353,8 +1445,8 @@ export class AgentViewServer {
         if (matcher && !matched) {
             return { ok: false, error: `Timeout: pattern not seen in ${timeoutSec}s` };
         }
-        const entries = this.networkStream.drain(filter);
-        return { ok: true, data: this.renderNetworkList(entries, maxLines) };
+        const entries = state.networkStream.drain(filter);
+        return { ok: true, data: this.renderNetworkList(req.port, entries, maxLines) };
     }
     /**
      * Durable side of the console feed. `console` answers from a ring buffer that dies with the
@@ -1367,25 +1459,35 @@ export class AgentViewServer {
         const projectDir = cwd ? resolve(cwd) : process.cwd();
         const config = cwd ? readConfig(projectDir) : null;
         const explicitFile = argStr(req.args, 'file');
-        // An active recording owns the feed path — only an explicit --file overrides it.
+        // An active recording owns the feed path — only an explicit --file overrides it. "Active"
+        // means *this port's* recording: another slot's recorder must never redirect this feed.
+        const state = this.stateFor(req.port);
         const file = explicitFile
             ? resolveLogFile(projectDir, explicitFile)
-            : this.logRecorder?.file ?? resolveLogFile(projectDir, config?.logFile);
+            : state.logRecorder?.file ?? resolveLogFile(projectDir, config?.logFile);
         switch (action) {
             case 'start': return this.startLogRecording(req, config, file);
-            case 'stop': return this.stopLogRecording();
-            case 'status': return { ok: true, data: this.logRecorder ? formatRecorderStatus(this.logRecorder.status()) : formatIdleFeed(file) };
-            case 'clear': return this.clearLogFeed(file);
+            case 'stop': return this.stopLogRecording(req.port);
+            case 'status': return { ok: true, data: state.logRecorder ? formatRecorderStatus(state.logRecorder.status()) : formatIdleFeed(file) };
+            case 'clear': return this.clearLogFeed(req.port, file);
             case 'tail': return this.tailLogFeed(req, file);
             default: return { ok: false, error: `Unknown logs action: ${action}` };
         }
     }
     async startLogRecording(req, config, file) {
-        if (this.logRecorder) {
-            if (this.logRecorder.file === file) {
-                return { ok: true, data: `Already recording\n${formatRecorderStatus(this.logRecorder.status())}` };
+        const state = this.stateFor(req.port);
+        if (state.logRecorder) {
+            if (state.logRecorder.file === file) {
+                return { ok: true, data: `Already recording\n${formatRecorderStatus(state.logRecorder.status())}` };
+            }
+            return { ok: false, error: `Already recording into ${state.logRecorder.file}. Run \`agent-view logs stop\` first.` };
+        }
+        // Two checkouts pointed at one feed file interleave records and truncate each other, which is
+        // exactly the cross-slot corruption port-scoping removes elsewhere — refuse it instead.
+        for (const [otherPort, other] of this.portStates) {
+            if (otherPort !== req.port && other.logRecorder?.file === file) {
+                return { ok: false, error: `Port ${otherPort} is already recording into ${file}. Use a per-slot feed path (--file) or stop that recording first.` };
             }
-            return { ok: false, error: `Already recording into ${this.logRecorder.file}. Run \`agent-view logs stop\` first.` };
         }
         const probes = parseProbes(req.args);
         if (probes.length > 0 && !config?.allowEval) {
@@ -1401,8 +1503,8 @@ export class AgentViewServer {
             }
             resolvedTargetId = match.target.id;
         }
-        if (this.consoleStream.attachedCount === 0) {
-            this.consoleStream = new ConsoleStream({ capacity: config?.consoleBufferSize ?? 500 });
+        if (state.consoleStream.attachedCount === 0) {
+            state.consoleStream = new ConsoleStream({ capacity: config?.consoleBufferSize ?? 500 });
         }
         const allowedTypes = this.resolveConsoleTypes(req, config);
         const recorder = new LogRecorder({
@@ -1418,7 +1520,7 @@ export class AgentViewServer {
                 allowedTypes,
                 targetId: resolvedTargetId,
             }),
-            subscribe: (handler) => this.consoleStream.subscribe(handler),
+            subscribe: (handler) => state.consoleStream.subscribe(handler),
         });
         try {
             await recorder.start();
@@ -1427,23 +1529,25 @@ export class AgentViewServer {
             recorder.stop('start failed');
             return { ok: false, error: `Could not start recording into ${file}: ${err instanceof Error ? err.message : String(err)}` };
         }
-        this.logRecorder = recorder;
+        state.logRecorder = recorder;
         this.resetIdleTimer();
         return { ok: true, data: formatRecorderStatus(recorder.status()) };
     }
-    async stopLogRecording() {
-        if (!this.logRecorder)
+    async stopLogRecording(port) {
+        const state = this.stateFor(port);
+        if (!state.logRecorder)
             return { ok: true, data: 'Not recording' };
-        const { file, lines } = this.logRecorder.status();
-        this.logRecorder.stop('stop requested');
-        this.logRecorder = null;
+        const { file, lines } = state.logRecorder.status();
+        state.logRecorder.stop('stop requested');
+        state.logRecorder = null;
         this.resetIdleTimer();
         return { ok: true, data: `Recording stopped — ${lines} lines in ${file}` };
     }
-    async clearLogFeed(file) {
-        this.consoleStream.clear();
-        if (this.logRecorder?.file === file) {
-            this.logRecorder.clearFeed();
+    async clearLogFeed(port, file) {
+        const state = this.stateFor(port);
+        state.consoleStream.clear();
+        if (state.logRecorder?.file === file) {
+            state.logRecorder.clearFeed();
             return { ok: true, data: `Feed cleared, recording continues — ${file}` };
         }
         if (!existsSync(file)) {
@@ -1465,6 +1569,7 @@ export class AgentViewServer {
             }
             since = parsed;
         }
+        const state = this.stateFor(req.port);
         const { lines, scanTruncated } = readFeedLines(file);
         const selected = filterLogLines(lines, {
             grep: argStr(req.args, 'grep'),
@@ -1480,7 +1585,7 @@ export class AgentViewServer {
             dropped > 0 ? `Output cap hit — ${dropped} older matching records omitted.` : null,
             scanTruncated ? `Feed exceeds the scan window — older records are only in ${file}.` : null,
             // Without this, a static feed reads as "the app went quiet" instead of "nobody is recording".
-            this.logRecorder?.file === file ? null : 'Not recording — this feed is static. Run `agent-view logs start`.',
+            state.logRecorder?.file === file ? null : 'Not recording — this feed is static. Run `agent-view logs start`.',
         ].filter((w) => w !== null);
         return { ok: true, data: text, warning: warnings.length > 0 ? warnings.join(' ') : undefined };
     }
@@ -1494,11 +1599,16 @@ export class AgentViewServer {
         for (const watch of [...this.activeWatches]) {
             watch.stop(StopReason.ServerShutdown, false);
         }
-        this.logRecorder?.stop('server shutdown');
-        this.logRecorder = null;
+        for (const state of this.portStates.values()) {
+            state.logRecorder?.stop('server shutdown');
+            state.logRecorder = null;
+        }
         await unlink(TOKEN_PATH).catch(() => { });
-        this.consoleStream.detach();
-        this.networkStream.detach();
+        for (const state of this.portStates.values()) {
+            state.consoleStream.detach();
+            state.networkStream.detach();
+        }
+        this.portStates.clear();
         for (const cached of this.connections.values()) {
             try {
                 await cached.session.close();