@danypops/pi-web-spider 0.10.8 → 0.11.0

package/test/daemon-client.test.ts

@@ -0,0 +1,158 @@
+/**
+ * daemon-client.ts is a deliberate duplication of @danypops/web-spider-daemon's
+ * client.ts/state.ts (see daemon-client.ts's own doc comment for why) — this
+ * suite mirrors that package's state.test.ts/daemon.test.ts coverage so the
+ * duplicate stays correct independently.
+ */
+import { afterEach, describe, expect, it } from "vitest"
+import { mkdtempSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import {
+  connectOrStartWebSpiderClient,
+  connectWebSpiderClient,
+  ensureAuthToken,
+  readDaemonHandle,
+  resolveWebSpiderPaths,
+  WebSpiderClient,
+  type WebSpiderPaths,
+} from "../src/daemon-client.js"
+
+function tempPaths(): { root: string; paths: WebSpiderPaths; env: Record<string, string> } {
+  const root = mkdtempSync(join(tmpdir(), "pi-web-spider-daemon-client-"))
+  const env = {
+    ...(process.env as Record<string, string>),
+    // HOME and WEB_SPIDER_CACHE_PATH matter too, not just the three XDG_*
+    // vars: the daemon's one-time legacy-cache importer falls back to the
+    // real home directory when WEB_SPIDER_CACHE_PATH is unset — verified
+    // happening in practice (twice) without this, importing (and renaming)
+    // the operator's real ~/.cache/web-spider/pages.json.
+    HOME: root,
+    XDG_DATA_HOME: join(root, "data"),
+    XDG_STATE_HOME: join(root, "state"),
+    XDG_RUNTIME_DIR: join(root, "run"),
+    WEB_SPIDER_CACHE_PATH: join(root, "no-legacy-cache-here.json"),
+  }
+  return {
+    root,
+    // resolveWebSpiderPaths() must see the *same* XDG overrides the spawned
+    // child's env carries, or the parent polls a handle path the child never
+    // writes to — a real bug this test setup previously had.
+    paths: resolveWebSpiderPaths({ env, home: root, uid: 1000 }),
+    env,
+  }
+}
+
+describe("resolveWebSpiderPaths", () => {
+  it("places each path under the correct XDG root", () => {
+    const { paths } = tempPaths()
+    expect(paths.database).toContain(join("data", "web-spider", "web-spider.db"))
+    expect(paths.token).toContain(join("state", "web-spider", "auth-token"))
+    expect(paths.handle).toContain(join("run", "web-spider", "daemon.json"))
+  })
+})
+
+describe("ensureAuthToken", () => {
+  it("creates a 64-char hex token and reuses it on subsequent calls", () => {
+    const { root, paths } = tempPaths()
+    try {
+      const first = ensureAuthToken(paths)
+      expect(first).toMatch(/^[a-f0-9]{64}$/)
+      expect(ensureAuthToken(paths)).toBe(first)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("readDaemonHandle", () => {
+  it("returns null when no handle file exists", () => {
+    const { root, paths } = tempPaths()
+    try {
+      expect(readDaemonHandle(paths)).toBeNull()
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("WebSpiderClient", () => {
+  it("calls the operation endpoint with a bearer token and returns the result", async () => {
+    let capturedRequest: Request | undefined
+    const client = new WebSpiderClient("http://127.0.0.1:1", "test-token", async (request) => {
+      capturedRequest = request
+      return new Response(JSON.stringify({ result: { ok: true } }), { status: 200 })
+    })
+    const result = await client.call("cache.list", {})
+    expect(result).toEqual({ ok: true })
+    expect(capturedRequest?.headers.get("authorization")).toBe("Bearer test-token")
+    expect(capturedRequest?.url).toBe("http://127.0.0.1:1/api/v1/ops")
+  })
+
+  it("throws the daemon's error message on a non-ok response", async () => {
+    const client = new WebSpiderClient("http://127.0.0.1:1", "test-token", async () =>
+      new Response(JSON.stringify({ error: "bad request" }), { status: 400 }))
+    await expect(client.call("fetch", { url: "https://x.test" })).rejects.toThrow("bad request")
+  })
+
+  it("health() validates ok:true and a string version", async () => {
+    const client = new WebSpiderClient("http://127.0.0.1:1", "test-token", async () =>
+      new Response(JSON.stringify({ ok: true, version: "0.1.0" }), { status: 200 }))
+    await expect(client.health()).resolves.toEqual({ ok: true, version: "0.1.0" })
+  })
+})
+
+describe("connectWebSpiderClient", () => {
+  it("fails closed with an actionable message when no daemon is running", () => {
+    const { root, paths } = tempPaths()
+    try {
+      expect(() => connectWebSpiderClient(paths)).toThrow(/daemon is not running/)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("connectOrStartWebSpiderClient — real subprocess integration", () => {
+  const cleanups: Array<() => void> = []
+  afterEach(() => {
+    for (const cleanup of cleanups.splice(0)) cleanup()
+  })
+
+  it("auto-starts the real daemon when none is running, then connects", async () => {
+    const { root, paths, env } = tempPaths()
+    cleanups.push(() => rmSync(root, { recursive: true, force: true }))
+
+    const client = await connectOrStartWebSpiderClient(paths, { env })
+    const health = await client.health()
+    expect(health.ok).toBe(true)
+
+    const listing = await client.call("cache.list", {})
+    expect(listing).toEqual({ total: 0, filtered: 0, offset: 0, limit: 20, pages: [] })
+
+    // Best-effort shutdown of the daemon we started, so the test doesn't leak a process.
+    const handle = readDaemonHandle(paths)
+    if (handle) {
+      try { process.kill(handle.pid, "SIGTERM") } catch { /* already gone */ }
+    }
+  }, 15_000)
+
+  it("reuses an already-running daemon instead of starting a second one", async () => {
+    const { root, paths, env } = tempPaths()
+    cleanups.push(() => rmSync(root, { recursive: true, force: true }))
+
+    const first = await connectOrStartWebSpiderClient(paths, { env })
+    await first.health()
+    const handleAfterFirst = readDaemonHandle(paths)
+
+    const second = await connectOrStartWebSpiderClient(paths, { env })
+    await second.health()
+    const handleAfterSecond = readDaemonHandle(paths)
+
+    expect(handleAfterSecond).toEqual(handleAfterFirst) // same daemon, not a second one started
+
+    if (handleAfterFirst) {
+      try { process.kill(handleAfterFirst.pid, "SIGTERM") } catch { /* already gone */ }
+    }
+  }, 15_000)
+})

package/test/daemon-isolation.ts

@@ -0,0 +1,56 @@
+/**
+ * Shared per-test daemon isolation. Every test that boots the extension can
+ * reach getClient() → connectOrStartWebSpiderClient(), which auto-starts a
+ * real `web-spider serve` subprocess using ambient XDG_DATA_HOME/
+ * XDG_STATE_HOME/XDG_RUNTIME_DIR when no override is given — verified in
+ * practice: running this suite without isolation left four real daemon
+ * processes running and real state under the operator's actual
+ * ~/.local/share/web-spider, ~/.local/state/web-spider, and
+ * $XDG_RUNTIME_DIR/web-spider (cleaned up once, by hand, when discovered).
+ *
+ * Every createExtensionHarness() call in this package's tests must pass
+ * `env: isolatedDaemonEnv().env` and call `.cleanup()` in an after hook.
+ */
+import { mkdtempSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { readDaemonHandle, resolveWebSpiderPaths, type WebSpiderPaths } from "../src/daemon-client.js"
+
+export interface IsolatedDaemonEnv {
+  root: string
+  env: Record<string, string>
+  paths: WebSpiderPaths
+  /** Kills any daemon this test started and removes the temp root. Call in afterAll/afterEach. */
+  cleanup(): void
+}
+
+export function isolatedDaemonEnv(prefix = "pi-web-spider-test-"): IsolatedDaemonEnv {
+  const root = mkdtempSync(join(tmpdir(), prefix))
+  const env: Record<string, string> = {
+    ...(process.env as Record<string, string>),
+    // HOME and WEB_SPIDER_CACHE_PATH matter too, not just the three XDG_* vars:
+    // the daemon's one-time legacy-cache importer (resolveLegacyCachePath())
+    // falls back to the real home directory when WEB_SPIDER_CACHE_PATH is unset
+    // — verified happening in practice, twice, importing (and renaming) the
+    // operator's real ~/.cache/web-spider/pages.json into an "isolated" daemon
+    // that only isolated the three XDG vars.
+    HOME: root,
+    XDG_DATA_HOME: join(root, "data"),
+    XDG_STATE_HOME: join(root, "state"),
+    XDG_RUNTIME_DIR: join(root, "run"),
+    WEB_SPIDER_CACHE_PATH: join(root, "no-legacy-cache-here.json"),
+  }
+  const paths = resolveWebSpiderPaths({ env, home: root, uid: 1000 })
+  return {
+    root,
+    env,
+    paths,
+    cleanup() {
+      const handle = readDaemonHandle(paths)
+      if (handle) {
+        try { process.kill(handle.pid, "SIGTERM") } catch { /* already gone */ }
+      }
+      rmSync(root, { recursive: true, force: true })
+    },
+  }
+}

package/test/e2e-jiti.test.ts

@@ -6,11 +6,12 @@
  * via mock-pi-cli.mjs so the real jiti context is exercised end-to-end.
  */
 
-import { readFileSync, mkdirSync } from "node:fs"
+import { mkdirSync } from "node:fs"
 import { spawn }  from "node:child_process"
-import { resolve, dirname } from "node:path"
+import { resolve, dirname, join } from "node:path"
 import { fileURLToPath } from "node:url"
-import { describe, expect, it } from "vitest"
+import { afterEach, describe, expect, it } from "vitest"
+import { readDaemonHandle, resolveWebSpiderPaths } from "../src/daemon-client.js"
 
 const __dirname   = dirname(fileURLToPath(import.meta.url))
 const CLI         = resolve(__dirname, "fixtures/mock-pi-cli.mjs")
@@ -25,8 +26,25 @@ interface Event { type: string; [k: string]: unknown }
 interface RunResult {
   events: Event[]
   diagPath: string
+  /** XDG_RUNTIME_DIR used for this run — read the daemon handle from here for cleanup. */
+  xdgRuntimeDir: string
 }
 
+// Every run's spawned daemon (auto-started by the extension, detached + unref'd
+// so it survives this test's own subprocess exit) is killed in afterEach —
+// otherwise every single test run in this file leaks a real, permanently
+// running `web-spider serve` process.
+const runtimeDirsToClean: string[] = []
+afterEach(() => {
+  for (const xdgRuntimeDir of runtimeDirsToClean.splice(0)) {
+    const paths = resolveWebSpiderPaths({ env: { XDG_RUNTIME_DIR: xdgRuntimeDir } })
+    const handle = readDaemonHandle(paths)
+    if (handle) {
+      try { process.kill(handle.pid, "SIGTERM") } catch { /* already gone */ }
+    }
+  }
+})
+
 function runCli(opts: {
   tool?: string
   /** Single invocation. Mutually exclusive with paramsList. */
@@ -40,10 +58,20 @@ function runCli(opts: {
   return new Promise((resolve, reject) => {
     mkdirSync(CACHE_DIR, { recursive: true })
     const tag = `${Date.now()}-${Math.random().toString(36).slice(2)}`
-    // Unique cache per run — prevents cross-test hits from masking errors.
-    const cachePath = `${CACHE_DIR}/cache-${tag}.json`
-    // Unique diag path — lets tests read and assert the boot probe.
+    // Unique diag path — lets tests read diagnostics.
     const diagPath  = `${CACHE_DIR}/diag-${tag}.log`
+    // Isolated XDG roots (+ HOME + WEB_SPIDER_CACHE_PATH) per run — without
+    // ALL of these, the extension's daemon auto-start uses the operator's
+    // real ~/.local/share, ~/.local/state, $XDG_RUNTIME_DIR, and (for the
+    // one-time legacy-cache importer, which falls back to the real home
+    // directory when WEB_SPIDER_CACHE_PATH is unset) the operator's real
+    // ~/.cache/web-spider/pages.json — every one of these verified happening
+    // in practice, more than once, before this fix covered all of them.
+    const xdgRoot = `${CACHE_DIR}/xdg-${tag}`
+    const xdgDataHome = join(xdgRoot, "data")
+    const xdgStateHome = join(xdgRoot, "state")
+    const xdgRuntimeDir = join(xdgRoot, "run")
+    runtimeDirsToClean.push(xdgRuntimeDir)
 
     const invocations = opts.paramsList ?? [opts.params ?? {}]
 
@@ -53,8 +81,12 @@ function runCli(opts: {
       // Each element becomes a separate --params flag; mock-pi-cli.mjs
       // invokes the tool once per flag in the same process.
       ...invocations.flatMap(p => ["--params", JSON.stringify(p)]),
-      "--env",       `WEB_SPIDER_CACHE_PATH=${cachePath}`,
       "--env",       `WEB_SPIDER_DIAG_PATH=${diagPath}`,
+      "--env",       `HOME=${xdgRoot}`,
+      "--env",       `WEB_SPIDER_CACHE_PATH=${join(xdgRoot, "no-legacy-cache-here.json")}`,
+      "--env",       `XDG_DATA_HOME=${xdgDataHome}`,
+      "--env",       `XDG_STATE_HOME=${xdgStateHome}`,
+      "--env",       `XDG_RUNTIME_DIR=${xdgRuntimeDir}`,
       ...Object.entries(opts.env ?? {}).flatMap(([k, v]) => ["--env", `${k}=${v}`]),
     ]
 
@@ -77,7 +109,7 @@ function runCli(opts: {
     proc.on("close", () => {
       clearTimeout(timer)
       try {
-        resolve({ events: lines.map(l => JSON.parse(l) as Event), diagPath })
+        resolve({ events: lines.map(l => JSON.parse(l) as Event), diagPath, xdgRuntimeDir })
       } catch (e) {
         reject(new Error(`failed to parse NDJSON: ${e}\nlines: ${lines.join("\n")}\nstderr: ${stderr.join("")}`))
       }
@@ -85,19 +117,6 @@ function runCli(opts: {
   })
 }
 
-/** Read and parse the boot-probe line from a diag log written by the extension. */
-function readBootProbe(diagPath: string): Record<string, unknown> | null {
-  let raw: string
-  try { raw = readFileSync(diagPath, "utf8") } catch { return null }
-  for (const line of raw.split("\n")) {
-    try {
-      const obj = JSON.parse(line) as Record<string, unknown>
-      if (obj["tag"] === "boot-probe") return obj
-    } catch { /* skip malformed lines */ }
-  }
-  return null
-}
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -123,42 +142,26 @@ describe("E2E: production jiti load (tryNative:true + alias)", () => {
     expect(text).toHaveProperty("title")
   }, 25000)
 
-  it("Playwright error propagates as { error } — auto-fallback path", async () => {
-    // enhanced:true forces Playwright regardless of jsRendered, exercising the
-    // same error-propagation code path as the jsRendered auto-fallback.
-    // GitHub's server-side HTML now has enough content for Readability (wordCount>0)
-    // so jsRendered stays false on plain fetch — enhanced:true is the reliable trigger.
+  it("Playwright error propagates through the native error event", async () => {
     const { events } = await runCli({
       params: { url: "https://example.com", enhanced: true },
       env:    { WEB_SPIDER_PLAYWRIGHT_EXECUTABLE: "/nonexistent" },
       timeoutMs: 20000,
     })
 
-    const end = events.find(e => e.type === "tool_execution_end")
-    expect(end).toBeDefined()
-
-    const result = (end as { result: { content: { text: string }[] } }).result
-    const text   = JSON.parse(result.content[0].text)
-
-    expect(text).toHaveProperty("error")
-    expect(typeof text.error).toBe("string")
-    expect(text.error).toMatch(/executable|launch|nonexistent/i)
+    const error = events.find(e => e.type === "tool_execution_error")
+    expect(error).toBeDefined()
+    expect((error as { error: string }).error).toMatch(/executable|launch|nonexistent/i)
   }, 25000)
 
-  it("enhanced=true with missing binary returns { error } immediately", async () => {
+  it("enhanced=true with missing binary emits an error immediately", async () => {
     const { events } = await runCli({
       params: { url: "https://example.com", enhanced: true },
       env:    { WEB_SPIDER_PLAYWRIGHT_EXECUTABLE: "/nonexistent" },
       timeoutMs: 20000,
     })
 
-    const end = events.find(e => e.type === "tool_execution_end")
-    expect(end).toBeDefined()
-
-    const result = (end as { result: { content: { text: string }[] } }).result
-    const text   = JSON.parse(result.content[0].text)
-
-    expect(text).toHaveProperty("error")
+    expect(events.find(e => e.type === "tool_execution_error")).toBeDefined()
   }, 25000)
 
   it("process exits cleanly — does not hang", async () => {
@@ -194,17 +197,4 @@ describe("E2E: production jiti load (tryNative:true + alias)", () => {
     expect(exit).toBeDefined()
     expect((exit as { code: number }).code).toBe(0)
   }, 30000)
-
-  it("boot probe: storeIsMap===false and cacheClass===DiskCache (realm-safe storage)", async () => {
-    const { diagPath } = await runCli({
-      params: { url: "https://example.com", format: "lean" },
-      timeoutMs: 25000,
-    })
-
-    const probe = readBootProbe(diagPath)
-    expect(probe).not.toBeNull()
-    expect(probe!["cacheClass"]).toBe("DiskCache")
-    expect(probe!["storeIsMap"]).toBe(false)
-    expect(probe!["storeTag"]).toBe("[object Object]")
-  }, 30000)
 })

package/test/execute-contract.test.ts

@@ -1,21 +1,24 @@
-/**
- * execute() contract: never throw, always return content.
- * Unhandled exceptions propagate to the Pi TUI and crash the session.
- */
-
-import { describe, it, expect, beforeAll, afterAll } from "vitest"
+import { afterAll, beforeAll, describe, expect, it } from "vitest"
 import { createExtensionHarness, type ExtensionHarness } from "./harness/index.ts"
+import { isolatedDaemonEnv, type IsolatedDaemonEnv } from "./daemon-isolation.js"
+import { startFixtureServer, type FixtureServer } from "./helpers/fixture-server.js"
 import piFactory from "../src/index.js"
 
 let h: ExtensionHarness
+let isolated: IsolatedDaemonEnv
+let server: FixtureServer
 
 beforeAll(async () => {
-  h = createExtensionHarness(piFactory, { cwd: "/tmp" })
+  isolated = isolatedDaemonEnv("pi-web-spider-execute-contract-test-")
+  server = await startFixtureServer()
+  h = createExtensionHarness(piFactory, { cwd: "/tmp", env: isolated.env })
   await h.boot()
 })
 
 afterAll(async () => {
   await h.shutdown()
+  await server.close()
+  isolated.cleanup()
 })
 
 describe("stream hygiene: extension must not write to stdout or stderr", () => {
@@ -24,46 +27,73 @@ describe("stream hygiene: extension must not write to stdout or stderr", () => {
   })
 })
 
-describe("execute() error contract: never throws, always returns content", () => {
-  it("invalid URL scheme returns error, does not throw", async () => {
-    const result = await h.invokeTool("web_fetch", { url: "ftp://not-supported.example.com" }) as any
-    expect(result).toHaveProperty("content")
-    const text = JSON.parse(result.content[0].text)
-    expect(text).toHaveProperty("error")
-    expect(typeof text.error).toBe("string")
+describe("execute() result and failure channels", () => {
+  it("registers native call and result renderers", () => {
+    const definition = h.tools.get("web_fetch")?.definition
+    expect(definition).toBeDefined()
+    expect(typeof definition?.renderCall).toBe("function")
+    expect(typeof definition?.renderResult).toBe("function")
+  })
+
+  it("throws invalid URL failures through Pi's native error channel", async () => {
+    await expect(h.invokeTool("web_fetch", { url: "ftp://not-supported.example.com" }))
+      .rejects.toThrow("Unsupported protocol")
   })
 
-  it("unreachable host returns error, does not throw", async () => {
-    const result = await h.invokeTool("web_fetch", {
+  it("throws unreachable-host failures through Pi's native error channel", async () => {
+    await expect(h.invokeTool("web_fetch", {
       url: "http://this-host-does-not-exist-pivi-test.invalid",
       timeoutMs: 3000,
-    }) as any
-    expect(result).toHaveProperty("content")
-    const text = JSON.parse(result.content[0].text)
-    expect(text).toHaveProperty("error")
+    })).rejects.toThrow("web_fetch failed")
   })
 
-  it("missing url returns cache listing (not error), does not throw", async () => {
-    // No url → local materialized view path: returns cache listing, not an error.
-    // This is intentional: omitting url is the way to query the session cache.
+  it("missing url returns a typed cache listing", async () => {
     const result = await h.invokeTool("web_fetch", {}) as any
     expect(result).toHaveProperty("content")
     const text = JSON.parse(result.content[0].text)
     expect(text).not.toHaveProperty("error")
     expect(text).toHaveProperty("total")
-    expect(typeof text.total).toBe("number")
-    expect(text).toHaveProperty("pages")
     expect(Array.isArray(text.pages)).toBe(true)
+    expect(result.details).toMatchObject({ kind: "web", operation: "cache-list", cache: "listing" })
   })
 
-  it("highlights without query returns error, does not throw", async () => {
-    const result = await h.invokeTool("web_fetch", {
+  it("validates highlights query before attempting a fetch", async () => {
+    await expect(h.invokeTool("web_fetch", {
       url: "http://127.0.0.1:1",
       format: "highlights",
-    }) as any
-    expect(result).toHaveProperty("content")
-    const text = JSON.parse(result.content[0].text)
-    expect(text).toHaveProperty("error")
+    })).rejects.toThrow("highlights format requires a query")
+  })
+
+  it("returns robots denial as a typed blocked outcome", async () => {
+    // A real robots.txt served by the real (isolated) daemon's own RobotsCache
+    // fetch — replaces mocking globalThis.fetch, which the daemon (a separate
+    // process) never sees.
+    server.set("/robots.txt", "User-agent: *\nDisallow: /private", "text/plain")
+    server.set("/private", "<html><body><article><h1>Secret</h1><p>Should never be fetched.</p></article></body></html>")
+
+    const result = await h.invokeTool("web_fetch", { url: `${server.baseUrl}/private` }) as any
+    expect(JSON.parse(result.content[0].text)).toMatchObject({ blocked: true, reason: "robots.txt" })
+    expect(result.details).toMatchObject({ kind: "web", status: "blocked", blockedBy: "robots.txt" })
+  })
+})
+
+describe("ingest: explicit opt-in Papyrus wiring", () => {
+  it("never calls papyrus.ingest when ingest is omitted (default behavior unchanged)", async () => {
+    server.set("/plain", "<html><body><article><h1>Plain</h1><p>No mesh.</p></article></body></html>")
+    const result = await h.invokeTool("web_fetch", { url: `${server.baseUrl}/plain`, format: "lean" }) as any
+    expect(JSON.parse(result.content[0].text)).not.toHaveProperty("papyrus")
+    expect(result.details.papyrusDocs).toBeUndefined()
+  })
+
+  it("forwards ingest:true for a single-page fetch to the daemon's papyrus.ingest op, which fails closed with no Papyrus daemon reachable in this isolated test environment", async () => {
+    server.set("/ingest-me", "<html><body><article><h1>Ingest me</h1><p>Worth keeping.</p></article></body></html>")
+    await expect(h.invokeTool("web_fetch", { url: `${server.baseUrl}/ingest-me`, format: "lean", ingest: true }))
+      .rejects.toThrow(/Papyrus daemon is not running|Papyrus daemon state is stale/)
   })
 
+  // The search-path wiring (maybeIngestSearch) uses the exact same call() helper and
+  // papyrus.ingest operation as the fetch path exercised above; a live-network search-
+  // engine round trip isn't repeated here to avoid a flaky, network-dependent test.
+  // Search-specific mapping/bounding is covered by web-spider-daemon's
+  // papyrus-mapping.test.ts and papyrus-ingest-service.test.ts.
 })

package/test/fixtures/mock-pi-cli.mjs

@@ -19,8 +19,8 @@
  */
 
 import { createJiti } from "jiti";
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolve, dirname } from "node:path";
 import { createRequire } from "node:module";
 
 // ---------------------------------------------------------------------------
@@ -50,16 +50,12 @@ for (const [k, v] of Object.entries(envOverrides)) process.env[k] = v;
 
 // tryNative:true (default) — matches the real Pi Node.js binary.
 // The test harness uses tryNative:false, which breaks vi.mock interception.
-const __dirname  = dirname(fileURLToPath(import.meta.url));
-const piDistRoot = resolve(__dirname, "../../../../../pi-mono/packages/coding-agent/dist");
-const require    = createRequire(import.meta.url);
+const require = createRequire(import.meta.url);
 
 const alias = {
-  "@earendil-works/pi-coding-agent": resolve(piDistRoot, "index.js"),
-  "@earendil-works/pi-agent-core":   resolve(piDistRoot, "../../agent/dist/index.js"),
-  "@earendil-works/pi-tui":          resolve(piDistRoot, "../../tui/dist/index.js"),
-  "@earendil-works/pi-ai":           resolve(piDistRoot, "../../ai/dist/index.js"),
-  "typebox":                         require.resolve("typebox"),
+  "@earendil-works/pi-coding-agent": fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent")),
+  "@earendil-works/pi-tui": fileURLToPath(import.meta.resolve("@earendil-works/pi-tui")),
+  "typebox": require.resolve("typebox"),
 };
 
 const jiti = createJiti(import.meta.url, { moduleCache: false, alias });

package/test/helpers/fixture-server.ts

@@ -0,0 +1,48 @@
+/**
+ * Real local HTTP server serving fixture HTML — replaces mocking
+ * globalThis.fetch, which no longer works for these tests: the daemon that
+ * actually performs fetches runs in a separate process and never sees this
+ * test process's mocked fetch. Serving fixtures over real localhost HTTP is
+ * simple, fast, and exercises the real network path end to end.
+ */
+import { createServer, type Server } from "node:http"
+import type { AddressInfo } from "node:net"
+
+export interface FixtureServer {
+  baseUrl: string
+  /** Register or replace the response body for an exact path (e.g. "/article"). 404 for anything unregistered. */
+  set(path: string, body: string, contentType?: string): void
+  close(): Promise<void>
+}
+
+export async function startFixtureServer(): Promise<FixtureServer> {
+  const routes = new Map<string, { body: string; contentType: string }>()
+  // robots.txt/sitemap.xml are fetched by the daemon's RobotsCache/fetchSitemapUrls
+  // directly; both fail open on a 404, so no explicit route is needed for them.
+  const server: Server = createServer((req, res) => {
+    const path = req.url ?? "/"
+    const route = routes.get(path)
+    if (!route) {
+      res.writeHead(404, { "content-type": "text/plain" })
+      res.end("not found")
+      return
+    }
+    res.writeHead(200, { "content-type": route.contentType })
+    res.end(route.body)
+  })
+
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve))
+  const { port } = server.address() as AddressInfo
+
+  return {
+    baseUrl: `http://127.0.0.1:${port}`,
+    set(path, body, contentType = "text/html") {
+      routes.set(path, { body, contentType })
+    },
+    close() {
+      return new Promise<void>((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()))
+      })
+    },
+  }
+}

package/test/live-fetch.test.ts

@@ -25,6 +25,7 @@ import {
 } from "./harness/index.ts"
 import { dirname, join } from "node:path"
 import { fileURLToPath } from "node:url"
+import { isolatedDaemonEnv, type IsolatedDaemonEnv } from "./daemon-isolation.js"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const EXTENSION_PATH = join(__dirname, "../src/index.ts")
@@ -62,17 +63,20 @@ async function assertWikipediaFetch(h: ExtensionHarness) {
 
 describe("live fetch — native ESM (pi Node.js runtime path)", () => {
   let h: ExtensionHarness
+  let isolated: IsolatedDaemonEnv
 
   beforeAll(async () => {
+    isolated = isolatedDaemonEnv("pi-web-spider-live-fetch-native-")
     // Direct import — no jiti. This is how pi loads extensions in Node.js dev
     // mode: the factory is imported natively, then wrapped in createExtensionHarness.
     const { default: factory } = await import("../src/index.js")
-    h = createExtensionHarness(factory, { cwd: "/tmp" })
+    h = createExtensionHarness(factory, { cwd: "/tmp", env: isolated.env })
     await h.boot()
   })
 
   afterAll(async () => {
     await h.shutdown()
+    isolated.cleanup()
   })
 
   it("fetches Wikipedia lean — no Map errors, correct shape", async () => {
@@ -109,15 +113,18 @@ describe("live fetch — native ESM (pi Node.js runtime path)", () => {
 
 describe("live fetch — jiti tryNative:false (Bun binary path)", () => {
   let h: ExtensionHarness
+  let isolated: IsolatedDaemonEnv
 
   beforeAll(async () => {
+    isolated = isolatedDaemonEnv("pi-web-spider-live-fetch-jiti-")
     const factory = await loadExtensionViaJiti(EXTENSION_PATH)
-    h = createExtensionHarness(factory, { cwd: "/tmp" })
+    h = createExtensionHarness(factory, { cwd: "/tmp", env: isolated.env })
     await h.boot()
   })
 
   afterAll(async () => {
     await h.shutdown()
+    isolated.cleanup()
   })
 
   it("fetches Wikipedia lean — no Map errors, correct shape", async () => {