@petukhovart/agent-view 0.12.0 → 0.13.1

package/dist/server/server.js

@@ -17,6 +17,8 @@ import { listSupportedTargets, connectToRuntime } from '../cdp/transport.js';
 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 { buildTauriArmScript, buildTauriStatusScript, TauriShimResult } from './tauri-dialog-shim.js';
 import { NetworkResourceType } from '../cdp/types.js';
 import { AxTreeCache } from '../cdp/ax-cache.js';
 import { WatchSession } from './watch-session.js';
@@ -135,6 +137,25 @@ export function parseFilter(filter) {
     }
     return { kind: 'simple', name: filter };
 }
+/**
+ * CDP takes any path without complaint and the app then reads an empty `File`,
+ * so this is the only place a bad path stays diagnosable. A directory has to be
+ * rejected too — it passes an existence check and produces that same empty
+ * `File`, which is the failure the check exists to prevent.
+ */
+export function resolveUploadPath(cwd, raw) {
+    const abs = resolve(cwd, raw);
+    let stats;
+    try {
+        stats = statSync(abs);
+    }
+    catch {
+        return { error: `File not found: ${abs}` };
+    }
+    if (!stats.isFile())
+        return { error: `Not a file: ${abs}` };
+    return { path: abs };
+}
 export class AgentViewServer {
     server = null;
     connections = new Map();
@@ -143,13 +164,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),
@@ -166,6 +183,8 @@ export class AgentViewServer {
         console: (req) => this.handleConsole(req),
         network: (req) => this.handleNetwork(req),
         logs: (req) => this.handleLogs(req),
+        upload: (req) => this.handleUpload(req),
+        dialog: (req) => this.handleDialog(req),
         stop: () => this.handleStop(),
     };
     streamingCommands = new Set(['watch']);
@@ -187,10 +206,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;
@@ -303,8 +343,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(() => { });
     }
@@ -418,8 +459,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,
             });
@@ -430,7 +472,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 */ }
         }
@@ -675,6 +717,167 @@ export class AgentViewServer {
         this.axTreeCache.invalidate(cacheKey);
         return { ok: true, data: `Filled ref ${fillRef} with "${value}"` };
     }
+    /**
+     * Puts files straight into a file input. The native chooser never opens, so
+     * there is nothing to close and nothing to arm — this is the cheapest path
+     * whenever the input exists in the DOM before the click.
+     */
+    async handleUpload(req) {
+        const rawFiles = argStrArray(req.args, 'files') ?? [];
+        if (rawFiles.length === 0) {
+            return { ok: false, error: 'upload requires at least one --file' };
+        }
+        const cwd = argStr(req.args, 'cwd') ?? process.cwd();
+        const files = [];
+        for (const raw of rawFiles) {
+            const resolved = resolveUploadPath(cwd, raw);
+            if ('error' in resolved)
+                return { ok: false, error: resolved.error };
+            files.push(resolved.path);
+        }
+        const { targetId } = await this.resolveWindow(req);
+        const conn = await this.getPageSession(req, targetId);
+        const cacheKey = `${req.port}:${targetId}`;
+        const label = files.map(f => f.split(/[\\/]/).pop()).join(', ');
+        const selector = argStr(req.args, 'selector');
+        if (selector) {
+            const found = await conn.uploadBySelector(selector, files);
+            if (!found)
+                return { ok: false, error: `No element matches selector "${selector}"` };
+            this.axTreeCache.invalidate(cacheKey);
+            return { ok: true, data: `Set ${files.length} file(s) on "${selector}": ${label}` };
+        }
+        // No `--filter` here, unlike `click`/`fill`: an accessible name resolves to
+        // whatever node carries it, which for an upload control is the label or the
+        // button, not the `<input type=file>` behind it. Setting files on the wrong
+        // node fails deep inside CDP. `--selector` addresses the input itself.
+        const ref = argNum(req.args, 'ref');
+        if (ref === undefined) {
+            return { ok: false, error: 'upload requires --selector or --ref' };
+        }
+        const entry = this.refStore.get(ref);
+        if (!entry) {
+            return { ok: false, error: `Invalid ref: ${ref}. Run \`agent-view dom\` to get fresh refs.` };
+        }
+        await conn.uploadByNodeId(entry.backendDOMNodeId, files);
+        this.axTreeCache.invalidate(cacheKey);
+        return { ok: true, data: `Set ${files.length} file(s) on ref ${ref}: ${label}` };
+    }
+    /**
+     * `dialog` covers JS modals only — `alert`/`confirm`/`prompt`/`beforeunload`.
+     * They are answered automatically the moment they open (see
+     * `attachJsDialogSubscription`); the commands here read that log, change the
+     * standing answer, and force an answer for a dialog that was already open
+     * before agent-view attached.
+     */
+    async handleDialog(req) {
+        const { targetId } = await this.resolveWindow(req);
+        const conn = await this.getPageSession(req, targetId);
+        const action = argStr(req.args, 'action') ?? 'status';
+        const text = argStr(req.args, 'text');
+        if (action === 'accept' || action === 'dismiss') {
+            const accept = action === 'accept';
+            try {
+                await conn.answerJsDialog(accept, text);
+            }
+            catch (err) {
+                const detail = err instanceof Error ? err.message : String(err);
+                return { ok: false, error: `No JS dialog is showing on this window (${detail}).` };
+            }
+            const suffix = accept && text !== undefined ? ` with "${text}"` : '';
+            return { ok: true, data: `Dialog ${accept ? 'accepted' : 'dismissed'}${suffix}.` };
+        }
+        if (action === 'policy') {
+            const mode = argStr(req.args, 'mode');
+            if (mode !== 'accept' && mode !== 'dismiss') {
+                return { ok: false, error: 'dialog policy requires accept or dismiss' };
+            }
+            // Storing prompt text alongside a dismiss would be dead state the status
+            // output cannot show — rejecting it keeps what is stored and what is
+            // reported the same thing.
+            if (mode === 'dismiss' && text !== undefined) {
+                return { ok: false, error: '--text applies to accept only; a dismissed prompt returns null' };
+            }
+            const policy = { accept: mode === 'accept', ...(text === undefined ? {} : { promptText: text }) };
+            conn.setJsDialogPolicy(policy);
+            return { ok: true, data: `JS dialog policy: ${describePolicy(policy)}` };
+        }
+        if (action === 'arm' || action === 'disarm') {
+            return this.armFileChooser(req, conn, action === 'arm');
+        }
+        if (action !== 'status') {
+            return { ok: false, error: `Unknown dialog action: "${action}". Use status, accept, dismiss, policy, arm, or disarm.` };
+        }
+        const shim = await this.readTauriShimStatus(conn);
+        const status = {
+            policy: conn.getJsDialogPolicy(),
+            dialogs: conn.recentJsDialogs(),
+            chooserArm: conn.fileChooserArm(),
+            choosers: conn.recentFileChoosers(),
+            tauriPatched: shim.patched,
+            // The shim's arm lives in the page, the CDP arm lives in the session —
+            // different lifetimes. A dropped session leaves the page still armed, and
+            // reporting only the CDP half would call that "not armed".
+            tauriArmed: shim.armed,
+        };
+        return { ok: true, data: formatDialogStatus(status, localStamp) };
+    }
+    /**
+     * Arms both engines at once. Which one fires depends on how the app opens its
+     * dialog — a webview `<input>` goes through CDP, `@tauri-apps/plugin-dialog`
+     * goes through the IPC shim — and the caller has no reason to know which.
+     */
+    async armFileChooser(req, conn, arming) {
+        let arm = null;
+        if (arming) {
+            const cancel = argBool(req.args, 'cancel') ?? false;
+            const rawFiles = argStrArray(req.args, 'files') ?? [];
+            if (cancel && rawFiles.length > 0) {
+                return { ok: false, error: 'dialog arm takes either --file or --cancel, not both' };
+            }
+            if (!cancel && rawFiles.length === 0) {
+                return { ok: false, error: 'dialog arm requires at least one --file, or --cancel' };
+            }
+            if (cancel) {
+                arm = { kind: 'cancel' };
+            }
+            else {
+                const cwd = argStr(req.args, 'cwd') ?? process.cwd();
+                const files = [];
+                for (const raw of rawFiles) {
+                    const resolved = resolveUploadPath(cwd, raw);
+                    if ('error' in resolved)
+                        return { ok: false, error: resolved.error };
+                    files.push(resolved.path);
+                }
+                arm = { kind: 'files', files };
+            }
+        }
+        // The IPC shim goes first because it is the failure-prone half: it runs a
+        // script inside the page. Arming CDP only after it succeeds keeps the two
+        // engines from disagreeing — a reported failure must not leave a live
+        // intercept behind, which would silently swallow a later real chooser.
+        const tauri = await conn.evaluate(buildTauriArmScript(arm));
+        try {
+            await conn.armFileChooser(arm);
+        }
+        catch (err) {
+            await conn.evaluate(buildTauriArmScript(null)).catch(() => { });
+            throw err;
+        }
+        const engines = tauri === TauriShimResult.Armed ? 'CDP + Tauri IPC' : 'CDP';
+        if (!arming)
+            return { ok: true, data: `File chooser disarmed (${engines}).` };
+        return { ok: true, data: `File chooser ${describeArm(arm)} (${engines}). Arm before the click that opens it.` };
+    }
+    async readTauriShimStatus(conn) {
+        try {
+            return await conn.evaluate(buildTauriStatusScript());
+        }
+        catch {
+            return { patched: false, armed: false, fired: [] };
+        }
+    }
     async handleWait(req) {
         const filter = argStr(req.args, 'filter');
         if (!filter) {
@@ -969,6 +1172,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(',')}`);
@@ -982,11 +1186,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) {
@@ -1002,10 +1206,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)
@@ -1019,7 +1224,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, {
@@ -1036,7 +1241,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,
@@ -1049,7 +1254,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))
@@ -1074,7 +1279,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,
@@ -1085,6 +1290,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) {
@@ -1097,18 +1303,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 = {
@@ -1128,31 +1334,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();
@@ -1169,8 +1377,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
@@ -1183,25 +1391,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) {
@@ -1217,8 +1435,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({
@@ -1234,7 +1452,7 @@ export class AgentViewServer {
                 allowedTypes,
                 targetId: resolvedTargetId,
             }),
-            subscribe: (handler) => this.consoleStream.subscribe(handler),
+            subscribe: (handler) => state.consoleStream.subscribe(handler),
         });
         try {
             await recorder.start();
@@ -1243,23 +1461,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)) {
@@ -1281,6 +1501,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'),
@@ -1296,7 +1517,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 };
     }
@@ -1310,11 +1531,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();