haltija 1.3.3 → 1.4.0

package/CHANGELOG.md

@@ -0,0 +1,64 @@
+# Changelog
+
+## 1.4.0
+
+**`hj` now routes to the server that owns your current directory.** If you run more than one
+project, this changes where your commands go — for the better, but read the first section.
+
+### Fixed: `hj` drove the wrong browser across projects
+
+`hj` never looked at your working directory. Every invocation, in every project, fell back to
+port 8700 and drove whatever browser was focused there — silently, with no error. The only way
+to target a project's own server was per-shell environment variables that agents spawning fresh
+shells routinely lose.
+
+Servers now record the directory they were started in, and `hj` picks the live server whose
+directory is the nearest ancestor of your cwd. Inside a project with its own server, plain
+`hj tree` just works — no flags, no env vars.
+
+- Falling back to the shared default port while other servers are running now **warns** on
+  stderr instead of quietly misrouting.
+- **`hj where`** tells you which port you're targeting, *why* it was chosen, and what's alive
+  there. Reach for it first when a command seems to hit the wrong page.
+- Precedence is unchanged and still wins: `--port` > `--name`/`HALTIJA_NAME` > `HALTIJA_PORT` >
+  `DEV_CHANNEL_PORT` > cwd match > port 8700.
+
+### Fixed: a stale server could hand every project an old `hj`
+
+`hj` is a single binary on your `PATH`, and every haltija server used to overwrite it on
+startup — so the last server to boot decided which `hj` *every project on the machine* ran. One
+forgotten `bunx haltija@beta` could silently downgrade the CLI for an unrelated, up-to-date
+project.
+
+- A **symlinked `hj` is never touched.** Point it at your own build and it stays put.
+- Servers **only bootstrap or repair** `hj` — they write it when nothing is there, or when
+  what's there is strictly older. They never downgrade it, and never rewrite it just because
+  the bytes differ. To find out what's installed they ask it (`hj --version`).
+- **`hj --version`**, and `hj` now warns when its version differs from the server it's driving.
+- `HALTIJA_NO_INSTALL=1` opts out of the install entirely.
+
+### New: pre-1.4.0 servers are retired on startup
+
+Older servers have none of the guards above and cannot be fixed in code that already shipped, so
+a 1.4.0+ server **asks** any haltija server **below 1.4.0** to stop when it starts, and says what
+it did. Retirement is `POST /shutdown` — an endpoint every haltija has understood since 0.1.7 —
+so it needs no process IDs and does no killing.
+
+This is deliberately narrow: it never stops a peer (1.4.0 and 1.4.1 coexist, and once 1.3.x is
+gone it never fires again), never touches a running desktop app, and never touches anything it
+cannot identify as haltija. When it can't stop a server, it complains rather than failing
+silently.
+
+`HALTIJA_NO_RETIRE=1` opts out. See "Housekeeping" in the README.
+
+### Also
+
+- HTTPS-only servers no longer advertise an HTTP port they aren't listening on.
+- Every REST response carries `X-Haltija-Version`.
+- **`hj` exits non-zero when an operation fails** (`success:false`) — not just with `--json`, but on action commands too (`hj click`, `navigate`, `key`, …). A click that didn't land, or any command with no browser connected, now exits 1 instead of 0, so an agent checking the exit code can't read a failed step as success. (Commands with their own human formatting were already this way; this closes the gap for the rest.)
+- `HALTIJA_REGISTRY_DIR` overrides the instance-registry location.
+- `hj` no longer auto-spawns a server against an **explicitly targeted** port (`--port`/`--name`/`HALTIJA_PORT`) or under `--no-launch` — a read-only command against a server you manage will not start a colliding one; it errors instead. Auto-spawn remains only for the bare default port.
+
+### Platform
+
+macOS and Linux. Native Windows is not supported — use WSL, where all of this works unmodified.

package/README.md

@@ -249,7 +249,11 @@ export HALTIJA_PORT=9123
 hj tree
 ```
 
-If you don't pass `--port`, haltija tries 8700 first and falls back to a kernel-assigned ephemeral port — `--name` records whichever port it ends up on so `hj` can find it. A different shell can target a different project; there's no global state, just one named instance per haltija server.
+If you don't pass `--port`, haltija tries 8700 first and falls back to a kernel-assigned ephemeral port.
+
+**You usually don't need `--name` at all.** A server records the directory it was started in, so **plain `hj` inside a project reaches that project's server** — no flags, no environment variables. `--name` and `--port` are overrides for when you want to address a server from *outside* its directory. `hj where` shows which server a shell is targeting and why.
+
+Haltija does keep a little state outside your project — a shared `hj` on your PATH and a registry of running servers. That's deliberate, and it's all logged: see [Housekeeping](#housekeeping--what-haltija-does-to-your-machine) below.
 
 **Production embedding.** When haltija is reachable beyond loopback, gate it with a shared-secret token:
 
@@ -302,6 +306,50 @@ app also exists but isn't required for either.
 
 ---
 
+## Housekeeping — what Haltija does to your machine
+
+Haltija acts at **machine** scope on purpose. "Which `hj` does every shell on this box
+run?" is not a question a per-project fix can answer — so a few things live outside your
+project directory. All of it is opt-out, and **all of it leaves a receipt.**
+
+**Everything Haltija does outside its own project is logged to
+`~/.haltija/machine-actions.log`** (timestamped, with the version and the *directory of the
+project that triggered it*) and announced on **stderr**. That matters because Haltija is
+often a transitive dependency: if some other project's `test-browser` script spawned it,
+you may not know what Haltija even is. The receipt tells you what happened, when, and which
+project caused it.
+
+**It installs `hj` into `~/.local/bin`.** One CLI, shared by every project. It will
+**never overwrite a symlink** (if you point `hj` at your own build, that's yours) and
+**never downgrade** a newer `hj` than the one it carries. `HALTIJA_NO_INSTALL=1` disables it.
+
+**It registers itself in `~/.haltija/servers/`,** recording the directory it was started
+in. That's what lets plain `hj` inside a project reach *that project's* server instead of
+whichever browser happens to be focused somewhere else. The entry is removed on shutdown.
+`hj where` shows what your shell is targeting and why.
+
+**It stops haltija servers older than 1.4.0.** Those versions overwrite the shared
+`~/.local/bin/hj` on every boot, so one stale server left running quietly hands every
+project on your machine an old CLI. A 1.4.0+ server **asks** them to stop on startup
+(`POST /shutdown`, which every haltija has understood since 0.1.7) and says so. It does
+not go hunting for processes to kill. It is deliberately narrow:
+
+- It only stops servers **below 1.4.0** — never a peer. Two projects on 1.4.0 and 1.4.1
+  coexist; nothing kills anything once 1.3.x is gone.
+- It **will not touch a running desktop app** (that would orphan a window you can see) —
+  it tells you to quit and update it instead.
+- It **asks rather than kills.** Retirement is an HTTP request to a server that already
+  told us what it is — no process IDs, no `kill`. (An earlier draft resolved a port to a
+  pid with `lsof` and signalled it; `lsof -i :PORT` also matches connected *clients*, so
+  that would have killed your **browser**. Asking makes that whole class of mistake
+  impossible.)
+- On the rare fallback paths that must free a port without waiting, it signals only
+  **listeners** that `ps` confirms are haltija — never something it cannot identify.
+
+`HALTIJA_NO_RETIRE=1` disables it.
+
+---
+
 ## Use Cases
 
 - **AI pair programming** — Agent sees your actual app, not a description of it

package/apps/desktop/main.js

@@ -1292,39 +1292,90 @@ async function startEmbeddedServer() {
 /**
  * Ensure Haltija server is available
  */
-async function killZombieOnPort(port) {
-  if (os.platform() === 'win32') return true
-
+/** Is anything listening on this port? Listeners only — never connected clients. */
+function listenerPidsOnPort(port) {
   const { execSync } = require('child_process')
+  try {
+    // `-sTCP:LISTEN` is load-bearing. `lsof -i :PORT` matches sockets whose local OR
+    // REMOTE port is PORT, so without it this also returns every connected CLIENT —
+    // i.e. the user's browser, holding a WebSocket to this very server. Browsers open
+    // since login have the lower pid and sort first, so killing what this returns used
+    // to kill the browser and leave the server running.
+    const out = execSync(`lsof -ti:${port} -sTCP:LISTEN 2>/dev/null`, { encoding: 'utf-8' }).trim()
+    if (!out) return []
+    return out.split('\n').filter(Boolean).map(Number)
+      .filter(pid => Number.isFinite(pid) && pid !== process.pid)
+  } catch {
+    return []
+  }
+}
 
-  for (let attempt = 1; attempt <= 3; attempt++) {
-    try {
-      const pids = execSync(`lsof -ti:${port} 2>/dev/null`, { encoding: 'utf-8' }).trim()
-      if (!pids) {
-        console.log(`[Haltija Desktop] Port ${port} is free`)
-        return true
-      }
-
-      console.log(`[Haltija Desktop] Attempt ${attempt}: Killing process(es) on port ${port}: ${pids.replace(/\n/g, ', ')}`)
+/** Only signal something we can positively identify as haltija. */
+function isHaltijaProcess(pid) {
+  const { execSync } = require('child_process')
+  try {
+    const cmd = execSync(`ps -p ${pid} -o command= 2>/dev/null`, { encoding: 'utf-8' }).trim()
+    return !!cmd && /haltija|tosijs-dev/i.test(cmd)
+  } catch {
+    return false
+  }
+}
 
-      const signal = attempt < 3 ? '' : '-9'
-      execSync(`lsof -ti:${port} | xargs kill ${signal} 2>/dev/null`, { encoding: 'utf-8' })
+/**
+ * Free a port held by an old haltija server.
+ *
+ * ASK FIRST. `POST /shutdown` has shipped since 0.1.7, so any haltija server on this
+ * port can stop itself — cleanly, and with no pid involved. That matters: this used to
+ * run `lsof -ti:PORT | xargs kill -9`, which kills every pid matching the port
+ * INCLUDING connected clients, i.e. the user's browser. It ran on the default launch
+ * path, whenever a server was already up — exactly when browsers are attached.
+ *
+ * Signalling is now the fallback only, restricted to LISTENERS that `ps` confirms are
+ * haltija, and it never escalates to -9 against something it could not identify.
+ */
+async function killZombieOnPort(port) {
+  if (os.platform() === 'win32') return true
 
-      await new Promise(r => setTimeout(r, 500 * attempt))
+  if (listenerPidsOnPort(port).length === 0) {
+    console.log(`[Haltija Desktop] Port ${port} is free`)
+    return true
+  }
 
-      try {
-        execSync(`lsof -ti:${port} 2>/dev/null`, { encoding: 'utf-8' })
-      } catch {
-        console.log(`[Haltija Desktop] Port ${port} freed successfully`)
-        return true
-      }
-    } catch {
-      console.log(`[Haltija Desktop] Port ${port} is free`)
+  // 1. Ask.
+  try {
+    await fetch(`http://localhost:${port}/shutdown`, {
+      method: 'POST',
+      signal: AbortSignal.timeout(1500),
+    })
+  } catch {
+    // Dying mid-response is a success; the liveness check below decides.
+  }
+  for (let i = 0; i < 20; i++) {
+    if (listenerPidsOnPort(port).length === 0) {
+      console.log(`[Haltija Desktop] Server on port ${port} shut down cleanly`)
       return true
     }
+    await new Promise(r => setTimeout(r, 100))
+  }
+
+  // 2. It didn't answer. Signal only what we can identify.
+  for (const pid of listenerPidsOnPort(port)) {
+    if (!isHaltijaProcess(pid)) {
+      console.error(`[Haltija Desktop] Port ${port} is held by pid ${pid}, which is not a haltija server — leaving it alone`)
+      continue
+    }
+    try {
+      process.kill(pid, 'SIGTERM')
+      console.log(`[Haltija Desktop] Stopped unresponsive haltija (pid ${pid}) on port ${port}`)
+    } catch {}
   }
+  await new Promise(r => setTimeout(r, 500))
 
-  console.error(`[Haltija Desktop] Warning: Could not free port ${port} after 3 attempts`)
+  if (listenerPidsOnPort(port).length === 0) {
+    console.log(`[Haltija Desktop] Port ${port} freed`)
+    return true
+  }
+  console.error(`[Haltija Desktop] Warning: could not free port ${port}`)
   return false
 }
 

package/apps/desktop/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haltija-desktop",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "private": true,
   "description": "Haltija Desktop - God Mode Browser for AI Agents",
   "homepage": "https://github.com/tonioloewald/haltija",
@@ -10,12 +10,12 @@
   },
   "main": "main.js",
   "scripts": {
-    "start": "cd ../.. && bun run build && cd apps/desktop && electron .",
+    "start": "cd ../.. && bun run build && rm -f apps/desktop/resources/haltija-server-* && cd apps/desktop && electron .",
     "start:quick": "electron .",
     "icons": "electron scripts/generate-icons.js",
     "sync-version": "node -e \"const root = require('../../package.json'); const pkg = require('./package.json'); pkg.version = root.version; require('fs').writeFileSync('./package.json', JSON.stringify(pkg, null, 2) + '\\n')\"",
     "prebuild": "npm run sync-version && npm run icons && npm run compile:server",
-    "compile:server": "cd ../.. && bun run build && bun build --compile --target=bun-darwin-arm64 src/server.ts --outfile apps/desktop/resources/haltija-server-arm64 && bun build --compile --target=bun-darwin-x64 src/server.ts --outfile apps/desktop/resources/haltija-server-x64 && bun build --compile --target=bun-darwin-arm64 bin/hj.mjs --outfile apps/desktop/resources/hj-arm64 && bun build --compile --target=bun-darwin-x64 bin/hj.mjs --outfile apps/desktop/resources/hj-x64 && cp dist/component.js apps/desktop/resources/component.js && cp haltija-icon.svg apps/desktop/resources/icon.svg",
+    "compile:server": "cd ../.. && bun run build && bun build --compile --target=bun-darwin-arm64 src/server.ts --outfile apps/desktop/resources/haltija-server-arm64 && bun build --compile --target=bun-darwin-x64 src/server.ts --outfile apps/desktop/resources/haltija-server-x64 && cp dist/component.js apps/desktop/resources/component.js && cp haltija-icon.svg apps/desktop/resources/icon.svg",
     "compile:server:win": "cd ../.. && bun build --compile --target=bun-windows-x64 src/server.ts --outfile apps/desktop/resources/haltija-server-x64.exe",
     "compile:server:linux": "cd ../.. && bun build --compile --target=bun-linux-x64 src/server.ts --outfile apps/desktop/resources/haltija-server-x64 && bun build --compile --target=bun-linux-arm64 src/server.ts --outfile apps/desktop/resources/haltija-server-arm64",
     "build": "electron-builder",
@@ -94,8 +94,8 @@
         "to": "haltija-server-${arch}"
       },
       {
-        "from": "resources/hj-${arch}",
-        "to": "hj-${arch}"
+        "from": "resources/hj.mjs",
+        "to": "hj.mjs"
       },
       {
         "from": "resources/component.js",

package/apps/desktop/resources/component.js

@@ -46,7 +46,7 @@
   });
 
   // src/version.ts
-  var VERSION = "1.3.3";
+  var VERSION = "1.4.0";
 
   // src/text-selector.ts
   var TEXT_PSEUDO_RE = /:(?:text-is|has-text|text)\(/;
@@ -598,13 +598,13 @@
   }
   function resolveRefOrSelector(ref, selector) {
     if (ref) {
-      const result2 = refRegistry.resolveWithStatus(ref);
-      if (result2.element) {
+      const result = refRegistry.resolveWithStatus(ref);
+      if (result.element) {
         stats.refsResolved++;
-        return { element: result2.element, targetDesc: `@${ref}` };
+        return { element: result.element, targetDesc: `@${ref}` };
       }
       stats.refsStale++;
-      const errorMsg = result2.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result2.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
+      const errorMsg = result.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
       return { element: null, targetDesc: `@${ref}`, error: errorMsg };
     }
     if (selector) {
@@ -615,13 +615,13 @@
   }
   function resolveRefOrSelectorAll(ref, selector) {
     if (ref) {
-      const result2 = refRegistry.resolveWithStatus(ref);
-      if (result2.element) {
+      const result = refRegistry.resolveWithStatus(ref);
+      if (result.element) {
         stats.refsResolved++;
-        return { elements: [result2.element], targetDesc: `@${ref}` };
+        return { elements: [result.element], targetDesc: `@${ref}` };
       }
       stats.refsStale++;
-      const errorMsg = result2.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result2.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
+      const errorMsg = result.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
       return { elements: [], targetDesc: `@${ref}`, error: errorMsg };
     }
     if (selector) {
@@ -2870,8 +2870,8 @@
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ action: "start", window: this.windowId })
         });
-        const result2 = await response.json();
-        if (result2.success) {
+        const result = await response.json();
+        if (result.success) {
           this.isRecording = true;
           this.serverManagedRecording = true;
           this.recordingStartTime = Date.now();
@@ -2883,7 +2883,7 @@
           this.updateRecordingUI(true);
           console.log("[Haltija] Recording started (server-managed)");
         } else {
-          console.error("[Haltija] Failed to start recording:", result2.error);
+          console.error("[Haltija] Failed to start recording:", result.error);
         }
       } catch (err) {
         console.error("[Haltija] Failed to start recording:", err);
@@ -2898,10 +2898,10 @@
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ action: "stop", window: this.windowId })
         });
-        const result2 = await response.json();
-        if (result2.success && result2.data) {
-          this.recordingEvents = result2.data.events || [];
-          this.recordingStartTime = result2.data.startTime || this.recordingStartTime;
+        const result = await response.json();
+        if (result.success && result.data) {
+          this.recordingEvents = result.data.events || [];
+          this.recordingStartTime = result.data.startTime || this.recordingStartTime;
           const recordingId = `rec_${this.recordingStartTime}_${Math.random().toString(36).slice(2, 8)}`;
           this.lastRecordingId = recordingId;
           console.log(`[Haltija] Recording stopped (${this.recordingEvents.length} events)`);
@@ -3214,15 +3214,15 @@
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ description, agentId })
         });
-        const result2 = await response.json();
-        if (result2.error) {
+        const result = await response.json();
+        if (result.error) {
           if (successMsg) {
-            successMsg.textContent = `⚠️ ${result2.error}`;
+            successMsg.textContent = `⚠️ ${result.error}`;
             successMsg.style.color = "#f59e0b";
           }
         } else {
           if (successMsg) {
-            successMsg.textContent = `✓ Sent to ${agentName}${result2.interrupted ? " (interrupted)" : ""}`;
+            successMsg.textContent = `✓ Sent to ${agentName}${result.interrupted ? " (interrupted)" : ""}`;
             successMsg.style.color = "#22c55e";
           }
           setTimeout(() => this.closeTestModal(), 1500);
@@ -3753,13 +3753,13 @@
         const haltija = window.haltija;
         if (haltija?.openAgentTab) {
           newAgentText.textContent = "Creating...";
-          const result2 = await haltija.openAgentTab();
-          if (result2?.shellId) {
+          const result = await haltija.openAgentTab();
+          if (result?.shellId) {
             await new Promise((r) => setTimeout(r, 300));
             if (type === "selection") {
-              this.sendSelectionToAgent(result2.shellId, result2.name || "agent");
+              this.sendSelectionToAgent(result.shellId, result.name || "agent");
             } else if (type === "recording") {
-              this.sendRecordingToAgent(result2.shellId, result2.name || "agent");
+              this.sendRecordingToAgent(result.shellId, result.name || "agent");
             }
           } else {
             console.error(`${LOG_PREFIX} Failed to create agent tab`);
@@ -3828,8 +3828,8 @@ ${elementSummary}${moreText}`;
             context: `selection from ${window.location.host}`
           })
         });
-        const result2 = await response.json();
-        if (result2.sent) {
+        const result = await response.json();
+        if (result.sent) {
           this.clearSelection();
           console.log(`${LOG_PREFIX} Selection sent to ${agentName}`);
         }
@@ -5344,11 +5344,11 @@ ${elementSummary}${moreText}`;
           this.respond(msg2.id, false, undefined, "Video capture requires the Haltija Desktop app. Run: npx haltija@latest -f");
           return;
         }
-        haltija.startVideoCapture({ maxDuration: payload2.maxDuration }).then((result2) => {
-          if (result2.success) {
-            this.respond(msg2.id, true, { recordingId: result2.recordingId });
+        haltija.startVideoCapture({ maxDuration: payload2.maxDuration }).then((result) => {
+          if (result.success) {
+            this.respond(msg2.id, true, { recordingId: result.recordingId });
           } else {
-            this.respond(msg2.id, false, undefined, result2.error || "Failed to start video");
+            this.respond(msg2.id, false, undefined, result.error || "Failed to start video");
           }
         }).catch((err) => {
           this.respond(msg2.id, false, undefined, `Failed to start video: ${err.message}`);
@@ -5358,11 +5358,11 @@ ${elementSummary}${moreText}`;
           this.respond(msg2.id, false, undefined, "Video capture requires the Haltija Desktop app. Run: npx haltija@latest -f");
           return;
         }
-        haltija.stopVideoCapture().then((result2) => {
-          if (result2.success) {
-            this.respond(msg2.id, true, { path: result2.path, duration: result2.duration, size: result2.size, format: result2.format });
+        haltija.stopVideoCapture().then((result) => {
+          if (result.success) {
+            this.respond(msg2.id, true, { path: result.path, duration: result.duration, size: result.size, format: result.format });
           } else {
-            this.respond(msg2.id, false, undefined, result2.error || "Failed to stop video");
+            this.respond(msg2.id, false, undefined, result.error || "Failed to stop video");
           }
         }).catch((err) => {
           this.respond(msg2.id, false, undefined, `Failed to stop video: ${err.message}`);
@@ -5372,8 +5372,8 @@ ${elementSummary}${moreText}`;
           this.respond(msg2.id, true, { recording: false });
           return;
         }
-        haltija.videoStatus().then((result2) => {
-          this.respond(msg2.id, true, result2);
+        haltija.videoStatus().then((result) => {
+          this.respond(msg2.id, true, result);
         }).catch(() => {
           this.respond(msg2.id, true, { recording: false });
         });
@@ -5390,8 +5390,8 @@ ${elementSummary}${moreText}`;
           this.respond(msg2.id, false, undefined, notAvailable);
           return;
         }
-        haltija.networkWatch(payload2 || {}).then((result2) => {
-          this.respond(msg2.id, result2.success !== false, result2);
+        haltija.networkWatch(payload2 || {}).then((result) => {
+          this.respond(msg2.id, result.success !== false, result);
         }).catch((err) => {
           this.respond(msg2.id, false, undefined, err.message);
         });
@@ -5400,8 +5400,8 @@ ${elementSummary}${moreText}`;
           this.respond(msg2.id, false, undefined, notAvailable);
           return;
         }
-        haltija.networkUnwatch().then((result2) => {
-          this.respond(msg2.id, true, result2);
+        haltija.networkUnwatch().then((result) => {
+          this.respond(msg2.id, true, result);
         }).catch((err) => {
           this.respond(msg2.id, false, undefined, err.message);
         });
@@ -5410,8 +5410,8 @@ ${elementSummary}${moreText}`;
           this.respond(msg2.id, false, undefined, notAvailable);
           return;
         }
-        haltija.networkLog(payload2 || {}).then((result2) => {
-          this.respond(msg2.id, true, result2);
+        haltija.networkLog(payload2 || {}).then((result) => {
+          this.respond(msg2.id, true, result);
         }).catch((err) => {
           this.respond(msg2.id, false, undefined, err.message);
         });
@@ -5420,8 +5420,8 @@ ${elementSummary}${moreText}`;
           this.respond(msg2.id, false, undefined, notAvailable);
           return;
         }
-        haltija.networkStats().then((result2) => {
-          this.respond(msg2.id, true, result2);
+        haltija.networkStats().then((result) => {
+          this.respond(msg2.id, true, result);
         }).catch((err) => {
           this.respond(msg2.id, false, undefined, err.message);
         });
@@ -5430,8 +5430,8 @@ ${elementSummary}${moreText}`;
           this.respond(msg2.id, false, undefined, notAvailable);
           return;
         }
-        haltija.networkClear().then((result2) => {
-          this.respond(msg2.id, true, result2);
+        haltija.networkClear().then((result) => {
+          this.respond(msg2.id, true, result);
         }).catch((err) => {
           this.respond(msg2.id, false, undefined, err.message);
         });
@@ -5877,9 +5877,9 @@ ${elementSummary}${moreText}`;
             try {
               const capturePromise = targetSelector ? haltija.captureElement(targetSelector) : haltija.capturePage();
               const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve({ success: false, error: "Screenshot capture timed out after 10s" }), 1e4));
-              const result2 = await Promise.race([capturePromise, timeoutPromise]);
-              if (result2?.success && result2.data) {
-                const converted = await convertFormat(result2.data);
+              const result = await Promise.race([capturePromise, timeoutPromise]);
+              if (result?.success && result.data) {
+                const converted = await convertFormat(result.data);
                 this.respond(msg2.id, true, {
                   image: converted.image,
                   viewport,
@@ -5889,8 +5889,8 @@ ${elementSummary}${moreText}`;
                   source: "electron"
                 });
                 return;
-              } else if (result2 && !result2.success) {
-                this.respond(msg2.id, false, null, result2.error || "Electron capture failed");
+              } else if (result && !result.success) {
+                this.respond(msg2.id, false, null, result.error || "Electron capture failed");
                 return;
               }
             } catch (err) {
@@ -5961,14 +5961,29 @@ ${elementSummary}${moreText}`;
         this.respond(msg2.id, true);
       }
     }
-    async handleEvalMessage(msg) {
+    async handleEvalMessage(msg2) {
       try {
-        const result = eval(msg.payload.code);
+        const result = this.evalCode(msg2.payload.code);
         const resolved = result instanceof Promise ? await result : result;
-        this.respond(msg.id, true, resolved);
+        this.respond(msg2.id, true, resolved);
       } catch (err) {
-        this.respond(msg.id, false, null, err.message);
+        this.respond(msg2.id, false, null, err.message);
+      }
+    }
+    evalCode(code) {
+      try {
+        return eval(code);
+      } catch (err) {
+        if (!(err instanceof SyntaxError) || !/\b(await|return)\b/.test(code))
+          throw err;
+      }
+      try {
+        return eval(`(async () => (${code}))()`);
+      } catch (err) {
+        if (!(err instanceof SyntaxError))
+          throw err;
       }
+      return eval(`(async () => { ${code} })()`);
     }
     async handleFetchMessage(msg2) {
       const { url } = msg2.payload;
@@ -6046,14 +6061,14 @@ ${elementSummary}${moreText}`;
       let el = null;
       let targetDesc = "";
       if (ref) {
-        const result2 = refRegistry.resolveWithStatus(ref);
-        el = result2.element;
+        const result = refRegistry.resolveWithStatus(ref);
+        el = result.element;
         targetDesc = `@${ref}`;
         if (el) {
           stats.refsResolved++;
         } else {
           stats.refsStale++;
-          const errorMsg = result2.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result2.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
+          const errorMsg = result.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
           this.respond(responseId, false, null, errorMsg);
           return;
         }
@@ -6398,14 +6413,14 @@ ${elementSummary}${moreText}`;
       let el = null;
       let targetDesc = "";
       if (payload2.ref) {
-        const result2 = refRegistry.resolveWithStatus(payload2.ref);
-        el = result2.element;
+        const result = refRegistry.resolveWithStatus(payload2.ref);
+        el = result.element;
         targetDesc = `@${payload2.ref}`;
         if (el) {
           stats.refsResolved++;
         } else {
           stats.refsStale++;
-          const errorMsg = result2.status === "never_assigned" ? `Ref @${payload2.ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result2.status === "removed_from_dom" ? `Ref @${payload2.ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${payload2.ref} is stale - element was garbage collected (try refreshing /tree)`;
+          const errorMsg = result.status === "never_assigned" ? `Ref @${payload2.ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result.status === "removed_from_dom" ? `Ref @${payload2.ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${payload2.ref} is stale - element was garbage collected (try refreshing /tree)`;
           this.respond(responseId, false, null, errorMsg);
           return;
         }
@@ -6474,15 +6489,15 @@ ${elementSummary}${moreText}`;
         let target = null;
         let targetDesc = "";
         if (ref) {
-          const result2 = refRegistry.resolveWithStatus(ref);
-          target = result2.element;
+          const result = refRegistry.resolveWithStatus(ref);
+          target = result.element;
           targetDesc = `@${ref}`;
           if (target) {
             stats.refsResolved++;
             target.focus();
           } else {
             stats.refsStale++;
-            const errorMsg = result2.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result2.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
+            const errorMsg = result.status === "never_assigned" ? `Ref @${ref} was never assigned (highest ref is @${refRegistry.getStats().highWaterMark})` : result.status === "removed_from_dom" ? `Ref @${ref} points to an element that was removed from the DOM (try refreshing /tree)` : `Ref @${ref} is stale - element was garbage collected (try refreshing /tree)`;
             this.respond(responseId, false, null, errorMsg);
             return;
           }
@@ -6874,9 +6889,9 @@ ${elementSummary}${moreText}`;
         });
       } else if (action2 === "result") {
         if (this.selectionResult) {
-          const result2 = this.selectionResult;
+          const result = this.selectionResult;
           this.clearSelection();
-          this.respond(msg2.id, true, result2);
+          this.respond(msg2.id, true, result);
         } else {
           this.respond(msg2.id, false, null, "No selection available");
         }