browser-pilot-cli 0.3.0-rc.1 → 0.3.0-rc.3

package/dist/daemon.js

@@ -2,7 +2,7 @@
 import http2 from "http";
 import { unlinkSync as unlinkSync2, chmodSync as chmodSync2 } from "fs";
 import { createHash as createHash5, randomUUID as randomUUID14 } from "crypto";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 
 // src/paths.ts
 import { createHash } from "crypto";
@@ -2344,10 +2344,10 @@ var MemoryCommandRuntime = class {
       throw new BrowserPilotError("internal_error", "Invalid or duplicate Command ID");
     }
     const acceptedAt = this.now();
-    let resolve3;
+    let resolve2;
     let reject;
     const completion = new Promise((resolvePromise, rejectPromise) => {
-      resolve3 = resolvePromise;
+      resolve2 = resolvePromise;
       reject = rejectPromise;
     });
     const record = {
@@ -2368,7 +2368,7 @@ var MemoryCommandRuntime = class {
       scopeKey,
       cancellation: input.cancellation,
       abortController: new AbortController(),
-      resolve: resolve3,
+      resolve: resolve2,
       reject,
       completion,
       settled: false
@@ -2988,8 +2988,8 @@ var MemoryBrokerRuntime = class {
     if (connection.notificationWaiter) {
       throw invalidArgument("Only one notification poll may be active per bridge Connection");
     }
-    return new Promise((resolve3) => {
-      const waiter = { resolve: resolve3, signal: options.signal };
+    return new Promise((resolve2) => {
+      const waiter = { resolve: resolve2, signal: options.signal };
       const finish = () => this.resolveNotificationWaiter(connection, void 0);
       waiter.timer = setTimeout(finish, waitMs);
       waiter.timer.unref();
@@ -5458,8 +5458,8 @@ async function waitForLoad(transport, sessionId, timeout = 3e4) {
   let interactiveSince = null;
   const deadlineReached = /* @__PURE__ */ Symbol("page-load-deadline");
   let deadlineTimer;
-  const deadline = new Promise((resolve3) => {
-    deadlineTimer = setTimeout(() => resolve3(deadlineReached), timeout);
+  const deadline = new Promise((resolve2) => {
+    deadlineTimer = setTimeout(() => resolve2(deadlineReached), timeout);
   });
   const injectBorder = async () => {
     await Promise.race([
@@ -5491,7 +5491,7 @@ async function waitForLoad(transport, sessionId, timeout = 3e4) {
         }
       }
       const sleep = await Promise.race([
-        new Promise((resolve3) => setTimeout(() => resolve3("poll"), 200)),
+        new Promise((resolve2) => setTimeout(() => resolve2("poll"), 200)),
         deadline
       ]);
       if (sleep === deadlineReached) throw new PageLoadTimeoutError(timeout);
@@ -5675,7 +5675,7 @@ var InputDispatcher = class {
       }
       hooks.afterCharacter?.({ character: char, index });
       index += 1;
-      if (delayMs > 0) await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+      if (delayMs > 0) await new Promise((resolve2) => setTimeout(resolve2, delayMs));
     }
   }
   async insertText(text) {
@@ -5719,7 +5719,7 @@ var ObservationService = class {
   }
   async observeAfterAction(limit = OBSERVATION_V1_LIMITS.defaultElements) {
     if (this.settleDelayMs > 0) {
-      await new Promise((resolve3) => setTimeout(resolve3, this.settleDelayMs));
+      await new Promise((resolve2) => setTimeout(resolve2, this.settleDelayMs));
     }
     await this.loadWaiter(this.transport, this.sessionId, this.loadTimeoutMs);
     return this.observe(limit);
@@ -6076,7 +6076,7 @@ var ActionService = class {
           await this.input.click(point.x, point.y, { button, clickCount });
           this.markDispatched(run);
           if (this.readbackDelayMs > 0) {
-            await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
+            await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
           }
           let after;
           try {
@@ -6128,7 +6128,7 @@ var ActionService = class {
       await this.input.press(key);
       this.markDispatched(run);
       if (this.readbackDelayMs > 0) {
-        await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
+        await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
       }
       let after;
       try {
@@ -6194,7 +6194,7 @@ var ActionService = class {
           this.markDispatched(run);
         }
         if (this.readbackDelayMs > 0) {
-          await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
+          await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
         }
         const after = await this.readElementState(objectId);
         evidence = inputEvidence("type", before, after, text, !!options.clear);
@@ -6226,7 +6226,7 @@ var ActionService = class {
         this.willDispatch();
         await this.input.click(location.x, location.y);
         this.markDispatched(run);
-        if (this.focusDelayMs > 0) await new Promise((resolve3) => setTimeout(resolve3, this.focusDelayMs));
+        if (this.focusDelayMs > 0) await new Promise((resolve2) => setTimeout(resolve2, this.focusDelayMs));
       }
       await this.captureFocus(run, "capture_input_focus");
       const before = await this.readActiveState();
@@ -6248,7 +6248,7 @@ var ActionService = class {
         },
         afterCharacter: () => this.markDispatched(run)
       });
-      if (this.readbackDelayMs > 0) await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
+      if (this.readbackDelayMs > 0) await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
       const after = await this.readActiveState();
       const evidence = inputEvidence("keyboard", before, after, text, !!options.clear);
       this.requireVerification(evidence, options.verification);
@@ -6608,8 +6608,8 @@ var CdpActionContinuityGuard = class _CdpActionContinuityGuard {
 
 // src/services/download-controller.ts
 import { randomUUID as randomUUID6 } from "crypto";
-import { chmod, lstat, mkdir, readdir, rm, stat, unlink } from "fs/promises";
-import { basename as basename2, join as join4, resolve } from "path";
+import { lstat } from "fs/promises";
+import { isAbsolute as isAbsolute3 } from "path";
 
 // src/services/agent-hint-service.ts
 var MAX_HINT_REFS = 32;
@@ -6710,6 +6710,15 @@ function repeatedActionAgentHint(streak, value) {
 // src/services/download-controller.ts
 var MAX_EVENT_URL_LENGTH = 16384;
 var MAX_FILE_NAME_LENGTH = 4096;
+var MAX_FILE_PATH_LENGTH = 32768;
+var DownloadFinalizeError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.name = "DownloadFinalizeError";
+    this.code = code;
+  }
+};
 function boundedString(value, maxLength) {
   return typeof value === "string" ? value.slice(0, maxLength) : "";
 }
@@ -6718,14 +6727,13 @@ function finiteBytes(value) {
 }
 function safeFileName(value) {
   const candidate = boundedString(value, MAX_FILE_NAME_LENGTH).replace(/[\u0000-\u001f\u007f]/g, "").trim();
-  const leaf = basename2(candidate);
+  const leaf = candidate.split(/[\\/]/).at(-1) ?? "";
   return leaf && leaf !== "." && leaf !== ".." ? leaf : "download";
 }
 var DownloadController = class {
   constructor(transport, artifacts, options = {}) {
     this.transport = transport;
     this.artifacts = artifacts;
-    this.directory = resolve(options.directory ?? DOWNLOAD_DIR);
     this.maxDownloadBytes = options.maxDownloadBytes ?? artifacts.maxItemBytes;
     this.maxActivePerSession = options.maxActivePerSession ?? 8;
     this.maxActivePerWorkspace = options.maxActivePerWorkspace ?? 32;
@@ -6737,102 +6745,87 @@ var DownloadController = class {
       this.maxActivePerWorkspace,
       this.maxActiveTotal
     ].some((value) => !Number.isSafeInteger(value) || value <= 0) || this.maxDownloadBytes > artifacts.maxItemBytes) {
-      throw new Error("Invalid download size limit");
+      throw new Error("Invalid DownloadController limit");
     }
     this.installHandlers();
   }
   sessions = /* @__PURE__ */ new Map();
   attachments = /* @__PURE__ */ new Map();
-  attachmentContexts = /* @__PURE__ */ new Map();
-  cancelledAttachments = /* @__PURE__ */ new Set();
-  directory;
+  downloadsByGuid = /* @__PURE__ */ new Map();
+  configurations = /* @__PURE__ */ new Map();
   maxDownloadBytes;
   maxActivePerSession;
   maxActivePerWorkspace;
   maxActiveTotal;
   publishEvent;
-  initializePromise;
+  latestConfigurationGeneration = 0;
   attachSession(context) {
-    if (this.sessions.has(context.sessionId)) {
-      return Promise.resolve(this.sessions.get(context.sessionId).available);
-    }
     const pending = this.attachments.get(context.sessionId);
     if (pending) return pending;
+    const existing = this.sessions.get(context.sessionId);
+    if (existing) return Promise.resolve(existing.available);
     const attachment = this.configureSession(context).finally(() => {
       if (this.attachments.get(context.sessionId) === attachment) {
         this.attachments.delete(context.sessionId);
       }
-      this.attachmentContexts.delete(context.sessionId);
-      this.cancelledAttachments.delete(context.sessionId);
     });
     this.attachments.set(context.sessionId, attachment);
-    this.attachmentContexts.set(context.sessionId, { ...context });
     return attachment;
   }
   async configureSession(context) {
-    const directory = join4(this.directory, randomUUID6());
     const session = {
       context: { ...context },
-      directory,
       available: false,
       closed: false,
       downloads: /* @__PURE__ */ new Map()
     };
-    let stagingReady = false;
-    try {
-      await this.initialize();
-      await mkdir(directory, { recursive: true, mode: 448 });
-      await chmod(directory, 448).catch(() => {
-      });
-      stagingReady = true;
-      if (this.cancelledAttachments.has(context.sessionId)) {
-        await rm(directory, { recursive: true, force: true }).catch(() => {
-        });
-        return false;
-      }
-      this.sessions.set(context.sessionId, session);
-      await this.transport.send("Page.setDownloadBehavior", {
-        behavior: "allowAndName",
-        downloadPath: directory,
-        eventsEnabled: true
-      }, context.sessionId);
-      if (session.closed || this.sessions.get(context.sessionId) !== session) {
-        await rm(directory, { recursive: true, force: true }).catch(() => {
-        });
-        return false;
-      }
-      session.available = true;
-      return true;
-    } catch {
-      this.sessions.delete(context.sessionId);
-      session.closed = true;
-      await rm(directory, { recursive: true, force: true }).catch(() => {
-      });
+    this.sessions.set(context.sessionId, session);
+    const available = await this.enableBrowserDownloadEvents(context);
+    if (session.closed || this.sessions.get(context.sessionId) !== session) return false;
+    session.available = available;
+    if (!available) {
       this.publish(session, {
         state: "capture_unavailable",
-        reason: stagingReady ? "target_session_api_unavailable" : "staging_unavailable"
+        reason: "browser_download_events_unavailable"
       });
-      return false;
     }
+    return available;
+  }
+  enableBrowserDownloadEvents(context) {
+    if (context.browserConnectionGeneration > this.latestConfigurationGeneration) {
+      this.latestConfigurationGeneration = context.browserConnectionGeneration;
+      for (const generation of this.configurations.keys()) {
+        if (generation < context.browserConnectionGeneration) this.configurations.delete(generation);
+      }
+    }
+    let contexts = this.configurations.get(context.browserConnectionGeneration);
+    if (!contexts) {
+      contexts = /* @__PURE__ */ new Map();
+      this.configurations.set(context.browserConnectionGeneration, contexts);
+    }
+    const key = context.cdpBrowserContextId ?? "";
+    const existing = contexts.get(key);
+    if (existing) return existing;
+    const configured = this.transport.send("Browser.setDownloadBehavior", {
+      behavior: "default",
+      eventsEnabled: true,
+      ...context.cdpBrowserContextId ? { browserContextId: context.cdpBrowserContextId } : {}
+    }).then(() => true, () => {
+      if (contexts?.get(key) === configured) contexts.delete(key);
+      return false;
+    });
+    contexts.set(key, configured);
+    return configured;
   }
   detachSession(sessionId, reason2) {
-    if (this.attachments.has(sessionId)) this.cancelledAttachments.add(sessionId);
     const session = this.sessions.get(sessionId);
     if (!session) return;
     this.sessions.delete(sessionId);
     session.closed = true;
-    if (session.available) {
-      void this.transport.send("Page.setDownloadBehavior", {
-        behavior: "default",
-        eventsEnabled: false
-      }, sessionId).catch(() => {
-      });
-    }
-    for (const download of session.downloads.values()) {
+    for (const download of [...session.downloads.values()]) {
       if (download.state === "terminal") continue;
       download.state = "terminal";
-      void this.transport.send("Browser.cancelDownload", { guid: download.guid }).catch(() => {
-      });
+      this.removeBinding(session, download);
       this.publish(session, {
         downloadId: download.id,
         state: "cancelled",
@@ -6841,21 +6834,13 @@ var DownloadController = class {
         ...download.totalBytes !== void 0 ? { totalBytes: download.totalBytes } : {}
       });
     }
-    void rm(session.directory, { recursive: true, force: true }).catch(() => {
-    });
   }
   releaseLease(leaseId) {
-    for (const context of [...this.attachmentContexts.values()]) {
-      if (context.leaseId === leaseId) this.detachSession(context.sessionId, "lease_released");
-    }
     for (const session of [...this.sessions.values()]) {
       if (session.context.leaseId === leaseId) this.detachSession(session.context.sessionId, "lease_released");
     }
   }
   releaseWorkspace(workspaceId) {
-    for (const context of [...this.attachmentContexts.values()]) {
-      if (context.workspaceId === workspaceId) this.detachSession(context.sessionId, "workspace_released");
-    }
     for (const session of [...this.sessions.values()]) {
       if (session.context.workspaceId === workspaceId) {
         this.detachSession(session.context.sessionId, "workspace_released");
@@ -6868,13 +6853,20 @@ var DownloadController = class {
       const session = this.sessions.get(sessionId);
       const guid = boundedString(params?.guid, 512);
       if (!session || !session.available || session.closed || !/^[A-Za-z0-9._-]{1,512}$/.test(guid)) return;
-      if (session.downloads.has(guid)) return;
-      if (!this.hasDownloadCapacity(session)) {
-        const downloadId = `download:${randomUUID6()}`;
-        void this.transport.send("Browser.cancelDownload", { guid }).catch(() => {
+      const collision = this.downloadsByGuid.get(guid);
+      if (collision) {
+        if (collision.session === session) return;
+        this.failDownload(collision.session, collision.download, "download_identity_collision");
+        this.publish(session, {
+          downloadId: `download:${randomUUID6()}`,
+          state: "failed",
+          reason: "download_identity_collision"
         });
+        return;
+      }
+      if (!this.hasDownloadCapacity(session)) {
         this.publish(session, {
-          downloadId,
+          downloadId: `download:${randomUUID6()}`,
           state: "failed",
           reason: "concurrency_limit_exceeded"
         });
@@ -6883,13 +6875,13 @@ var DownloadController = class {
       const download = {
         id: `download:${randomUUID6()}`,
         guid,
-        path: join4(session.directory, guid),
         url: boundedString(params?.url, MAX_EVENT_URL_LENGTH),
         fileName: safeFileName(params?.suggestedFilename),
         receivedBytes: 0,
         state: "active"
       };
       session.downloads.set(guid, download);
+      this.downloadsByGuid.set(guid, { session, download });
       this.publish(session, {
         downloadId: download.id,
         state: "started",
@@ -6899,63 +6891,49 @@ var DownloadController = class {
     });
     this.transport.on?.("Page.downloadProgress", (params, sessionId) => {
       if (!sessionId) return;
-      const session = this.sessions.get(sessionId);
-      const guid = boundedString(params?.guid, 512);
-      const download = session?.downloads.get(guid);
-      if (!session || !download) return;
-      const receivedBytes = finiteBytes(params?.receivedBytes);
-      const totalBytes = finiteBytes(params?.totalBytes);
-      if (receivedBytes !== void 0) download.receivedBytes = receivedBytes;
-      if (totalBytes !== void 0) download.totalBytes = totalBytes;
-      if (download.state === "terminal") {
-        if (params?.state === "completed" || params?.state === "canceled") {
-          session.downloads.delete(download.guid);
-          void unlink(download.path).catch(() => {
-          });
-        }
-        return;
-      }
-      if (download.receivedBytes > this.maxDownloadBytes || download.totalBytes !== void 0 && download.totalBytes > this.maxDownloadBytes) {
-        this.failOversized(session, download);
-        return;
+      const binding = this.downloadsByGuid.get(boundedString(params?.guid, 512));
+      if (!binding || binding.session.context.sessionId !== sessionId) return;
+      this.updateBytes(binding.download, params);
+      if (this.isOversized(binding.download)) {
+        this.failOversized(binding.session, binding.download);
+      } else if (params?.state === "canceled") {
+        this.cancelDownload(binding.session, binding.download, "browser_cancelled");
       }
-      if (this.exceedsStagingQuota(session)) {
-        this.failDownload(session, download, "staging_quota_exceeded", {
-          maxWorkspaceBytes: this.artifacts.maxWorkspaceCapacityBytes,
-          maxTotalBytes: this.artifacts.maxTotalCapacityBytes
-        });
+    });
+    this.transport.on?.("Browser.downloadProgress", (params) => {
+      const binding = this.downloadsByGuid.get(boundedString(params?.guid, 512));
+      if (!binding) return;
+      this.updateBytes(binding.download, params);
+      if (this.isOversized(binding.download)) {
+        this.failOversized(binding.session, binding.download);
         return;
       }
-      if (params?.state === "completed" && download.state === "active") {
-        download.state = "finalizing";
-        void this.finalize(session, download);
+      if (params?.state === "completed" && binding.download.state === "active") {
+        binding.download.state = "finalizing";
+        void this.finalize(binding.session, binding.download, params?.filePath);
       } else if (params?.state === "canceled") {
-        download.state = "terminal";
-        this.publish(session, {
-          downloadId: download.id,
-          state: "cancelled",
-          reason: "browser_cancelled",
-          receivedBytes: download.receivedBytes,
-          ...download.totalBytes !== void 0 ? { totalBytes: download.totalBytes } : {}
-        });
-        void unlink(download.path).catch(() => {
-        });
-        session.downloads.delete(download.guid);
+        this.cancelDownload(binding.session, binding.download, "browser_cancelled");
       }
     });
   }
+  updateBytes(download, params) {
+    const receivedBytes = finiteBytes(params?.receivedBytes);
+    const totalBytes = finiteBytes(params?.totalBytes);
+    if (receivedBytes !== void 0) download.receivedBytes = receivedBytes;
+    if (totalBytes !== void 0) download.totalBytes = totalBytes;
+  }
+  isOversized(download) {
+    return download.receivedBytes > this.maxDownloadBytes || download.totalBytes !== void 0 && download.totalBytes > this.maxDownloadBytes;
+  }
   failOversized(session, download) {
     this.failDownload(session, download, "size_limit_exceeded", {
       maxDownloadBytes: this.maxDownloadBytes
     });
   }
-  failDownload(session, download, reason2, limits) {
+  failDownload(session, download, reason2, limits = {}) {
     if (download.state === "terminal") return;
     download.state = "terminal";
-    void this.transport.send("Browser.cancelDownload", { guid: download.guid }).catch(() => {
-    });
-    void unlink(download.path).catch(() => {
-    });
+    this.removeBinding(session, download);
     this.publish(session, {
       downloadId: download.id,
       state: "failed",
@@ -6965,48 +6943,77 @@ var DownloadController = class {
       ...limits
     });
   }
-  async finalize(session, download) {
+  cancelDownload(session, download, reason2) {
+    if (download.state === "terminal") return;
+    download.state = "terminal";
+    this.removeBinding(session, download);
+    this.publish(session, {
+      downloadId: download.id,
+      state: "cancelled",
+      reason: reason2,
+      receivedBytes: download.receivedBytes,
+      ...download.totalBytes !== void 0 ? { totalBytes: download.totalBytes } : {}
+    });
+  }
+  async finalize(session, download, rawFilePath) {
     try {
-      const linkInfo = await lstat(download.path);
-      if (linkInfo.isSymbolicLink()) throw new Error("download_not_regular_file");
-      const info = await stat(download.path);
-      if (!info.isFile()) throw new Error("download_not_regular_file");
-      if (info.size > this.maxDownloadBytes) {
-        download.receivedBytes = info.size;
+      const completedFile = await this.validateCompletedFile(rawFilePath);
+      if (completedFile.size > this.maxDownloadBytes) {
+        download.receivedBytes = completedFile.size;
         this.failOversized(session, download);
         return;
       }
-      const record = await this.artifacts.ingestDownload(
+      if (!this.isTracked(session, download)) return;
+      const record = await this.artifacts.ingestDownloadCopy(
         session.context.workspaceId,
-        download.path,
+        completedFile.path,
         download.fileName
       );
-      if (session.closed || download.state === "terminal") {
+      if (!this.isTracked(session, download)) {
         await this.artifacts.release(session.context.workspaceId, record.descriptor.id);
         return;
       }
       download.state = "terminal";
+      this.removeBinding(session, download);
       this.publish(session, {
         downloadId: download.id,
         state: "completed",
         artifact: record.descriptor
       });
-      session.downloads.delete(download.guid);
     } catch (error) {
       if (download.state === "terminal") return;
-      download.state = "terminal";
-      await unlink(download.path).catch(() => {
-      });
-      this.publish(session, {
-        downloadId: download.id,
-        state: "failed",
-        reason: error instanceof Error && "code" in error && typeof error.code === "string" ? error.code.slice(0, 128) : "artifact_ingest_failed",
-        receivedBytes: download.receivedBytes,
-        ...download.totalBytes !== void 0 ? { totalBytes: download.totalBytes } : {}
-      });
-      session.downloads.delete(download.guid);
+      const code = error instanceof DownloadFinalizeError ? error.code : error instanceof Error && "code" in error && error.code === "result_too_large" ? "artifact_quota_exceeded" : error instanceof Error && "code" in error && error.code === "invalid_argument" ? "download_file_unavailable" : "artifact_ingest_failed";
+      this.failDownload(session, download, code);
+    }
+  }
+  async validateCompletedFile(rawFilePath) {
+    if (typeof rawFilePath !== "string" || rawFilePath.length === 0) {
+      throw new DownloadFinalizeError("download_file_path_unavailable");
+    }
+    if (rawFilePath.length > MAX_FILE_PATH_LENGTH || rawFilePath.includes("\0") || !isAbsolute3(rawFilePath)) {
+      throw new DownloadFinalizeError("download_file_path_invalid");
+    }
+    try {
+      const info = await lstat(rawFilePath);
+      if (info.isSymbolicLink() || !info.isFile()) {
+        throw new DownloadFinalizeError("download_not_regular_file");
+      }
+      return { path: rawFilePath, size: info.size };
+    } catch (error) {
+      if (error instanceof DownloadFinalizeError) throw error;
+      throw new DownloadFinalizeError("download_file_unavailable");
     }
   }
+  removeBinding(session, download) {
+    if (session.downloads.get(download.guid) === download) session.downloads.delete(download.guid);
+    const binding = this.downloadsByGuid.get(download.guid);
+    if (binding?.session === session && binding.download === download) {
+      this.downloadsByGuid.delete(download.guid);
+    }
+  }
+  isTracked(session, download) {
+    return !session.closed && session.downloads.get(download.guid) === download && this.downloadsByGuid.get(download.guid)?.download === download;
+  }
   publish(session, payload) {
     if (!this.publishEvent) return;
     const hint = this.agentHint(payload);
@@ -7044,44 +7051,12 @@ var DownloadController = class {
     return void 0;
   }
   hasDownloadCapacity(session) {
-    const active = (candidate) => candidate.state !== "terminal";
-    const sessionCount = [...session.downloads.values()].filter(active).length;
+    const sessionCount = session.downloads.size;
     let workspaceCount = 0;
-    let totalCount = 0;
-    for (const candidate of this.sessions.values()) {
-      for (const download of candidate.downloads.values()) {
-        if (!active(download)) continue;
-        totalCount += 1;
-        if (candidate.context.workspaceId === session.context.workspaceId) workspaceCount += 1;
-      }
-    }
-    return sessionCount < this.maxActivePerSession && workspaceCount < this.maxActivePerWorkspace && totalCount < this.maxActiveTotal;
-  }
-  exceedsStagingQuota(currentSession) {
-    let workspaceBytes = 0;
-    let totalBytes = 0;
-    for (const session of this.sessions.values()) {
-      for (const download of session.downloads.values()) {
-        if (download.state === "terminal") continue;
-        const bytes = Math.max(download.receivedBytes, download.totalBytes ?? 0);
-        totalBytes += bytes;
-        if (session.context.workspaceId === currentSession.context.workspaceId) workspaceBytes += bytes;
-      }
+    for (const binding of this.downloadsByGuid.values()) {
+      if (binding.session.context.workspaceId === session.context.workspaceId) workspaceCount += 1;
     }
-    return workspaceBytes > this.artifacts.maxWorkspaceCapacityBytes || totalBytes > this.artifacts.maxTotalCapacityBytes;
-  }
-  initialize() {
-    if (!this.initializePromise) {
-      this.initializePromise = (async () => {
-        await mkdir(this.directory, { recursive: true, mode: 448 });
-        await chmod(this.directory, 448).catch(() => {
-        });
-        const entries = await readdir(this.directory, { withFileTypes: true });
-        await Promise.all(entries.map((entry) => rm(join4(this.directory, entry.name), { recursive: true, force: true }).catch(() => {
-        })));
-      })();
-    }
-    return this.initializePromise;
+    return sessionCount < this.maxActivePerSession && workspaceCount < this.maxActivePerWorkspace && this.downloadsByGuid.size < this.maxActiveTotal;
   }
 };
 
@@ -9511,7 +9486,7 @@ var TargetInventoryService = class {
 };
 
 // src/services/upload-service.ts
-import { basename as basename3 } from "path";
+import { basename as basename2 } from "path";
 var FILE_INPUT_BLOCK_REASONS = /* @__PURE__ */ new Set([
   "detached",
   "disabled",
@@ -9634,7 +9609,7 @@ var UploadService = class {
       backendNodeId
     }, this.sessionId);
     if (this.readbackDelayMs > 0) {
-      await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
+      await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
     }
     let after;
     try {
@@ -9656,7 +9631,7 @@ var UploadService = class {
         reason: "target_unavailable"
       };
     }
-    const nameMatched = after.firstFileName === basename3(filePath);
+    const nameMatched = after.firstFileName === basename2(filePath);
     const status = after.fileCount === 1 && nameMatched ? "verified" : "mismatch";
     const reason2 = after.fileCount !== 1 ? "file_count_mismatch" : !nameMatched ? "file_name_mismatch" : void 0;
     return {
@@ -11753,13 +11728,13 @@ var BrowserToolService = class {
       await this.transport.send("Target.closeTarget", { targetId });
     } catch {
     }
-    for (let attempt = 0; attempt < 5; attempt += 1) {
+    for (let attempt = 0; attempt < 20; attempt += 1) {
       try {
         const current = await this.transport.send("Target.getTargets");
         if (Array.isArray(current?.targetInfos) && !current.targetInfos.some((target) => target?.targetId === targetId)) return true;
       } catch {
       }
-      if (attempt < 4) await new Promise((resolve3) => setTimeout(resolve3, 50));
+      if (attempt < 19) await new Promise((resolve2) => setTimeout(resolve2, 50));
     }
     return false;
   }
@@ -11861,9 +11836,9 @@ var BrowserToolService = class {
           context: { profileContextId: profile.id }
         });
       }
-      for (let attempt = 0; attempt < 40; attempt += 1) {
+      for (let attempt = 0; attempt < 100; attempt += 1) {
         const current = await this.transport.send("Target.getTargets");
-        const markerTargets = Array.isArray(current?.targetInfos) ? current.targetInfos.filter((target) => target && typeof target.targetId === "string" && !existing.has(target.targetId) && target.type === "page" && target.openerId === representative.cdpTargetId && target.url === marker) : [];
+        const markerTargets = Array.isArray(current?.targetInfos) ? current.targetInfos.filter((target) => target && typeof target.targetId === "string" && !existing.has(target.targetId) && target.type === "page" && target.url === marker) : [];
         for (const target of markerTargets) spawnedTargetIds.add(target.targetId);
         if (markerTargets.length > 1) {
           throw new BrowserPilotError("profile_context_unavailable", "Chrome created ambiguous managed window targets", {
@@ -11889,10 +11864,25 @@ var BrowserToolService = class {
               }
             );
           }
+          if (candidate.openerId !== representative.cdpTargetId && !await this.targetWindowNameMatches(candidate.targetId, windowName)) {
+            throw new BrowserPilotError(
+              "profile_context_unavailable",
+              "Chrome could not prove ownership of the managed Profile window",
+              {
+                retryable: true,
+                context: { profileContextId: profile.id },
+                remediation: {
+                  code: "relist_profile_contexts",
+                  message: "List Profile contexts again and retry with a current Profile context.",
+                  actionRequired: true
+                }
+              }
+            );
+          }
           candidateTargetId = candidate.targetId;
           break;
         }
-        await new Promise((resolve3) => setTimeout(resolve3, 50));
+        await new Promise((resolve2) => setTimeout(resolve2, 50));
       }
       if (!candidateTargetId) {
         throw this.managedTargetUnknownOutcome(profile);
@@ -11912,6 +11902,37 @@ var BrowserToolService = class {
       if (cleanup2.some((closed) => !closed)) throw this.managedTargetUnknownOutcome(profile);
     }
   }
+  async targetWindowNameMatches(targetId, expected) {
+    let sessionId;
+    try {
+      const attached = await this.transport.send("Target.attachToTarget", {
+        targetId,
+        flatten: true
+      });
+      if (typeof attached?.sessionId !== "string") return false;
+      sessionId = attached.sessionId;
+      for (let attempt = 0; attempt < 10; attempt += 1) {
+        try {
+          const result = await this.transport.send("Runtime.evaluate", {
+            expression: "window.name",
+            returnByValue: true
+          }, sessionId);
+          if (result?.result?.value === expected) return true;
+          if (result?.result?.value !== void 0) return false;
+        } catch {
+        }
+        if (attempt < 9) await new Promise((resolve2) => setTimeout(resolve2, 25));
+      }
+      return false;
+    } catch {
+      return false;
+    } finally {
+      if (sessionId) {
+        await this.transport.send("Target.detachFromTarget", { sessionId }).catch(() => {
+        });
+      }
+    }
+  }
   async resolveTargetSession(context, targetId, operation) {
     const inventoryContext = this.inventoryContext(context);
     await this.inventory.refresh(inventoryContext);
@@ -11948,13 +11969,15 @@ var BrowserToolService = class {
     if (typeof attached?.sessionId !== "string") {
       throw new BrowserPilotError("internal_error", "Chrome returned an invalid CDP session");
     }
+    const profile = this.profileContexts.forTarget(cdpTargetId, context.browserConnectionGeneration);
     const session = {
       workspaceId: context.workspaceId,
       leaseId: context.leaseId,
       targetId,
       browserConnectionGeneration: context.browserConnectionGeneration,
       cdpTargetId,
-      sessionId: attached.sessionId
+      sessionId: attached.sessionId,
+      ...profile?.cdpBrowserContextId ? { cdpBrowserContextId: profile.cdpBrowserContextId } : {}
     };
     this.sessions.set(key, session);
     this.ownedSessionIds.add(attached.sessionId);
@@ -13137,19 +13160,19 @@ var BrowserToolRouter = class {
 // src/services/artifact-store.ts
 import { randomUUID as randomUUID12 } from "crypto";
 import {
-  chmod as chmod2,
+  chmod,
   copyFile,
   lstat as lstat2,
-  mkdir as mkdir2,
+  mkdir,
   realpath,
-  readdir as readdir2,
-  rm as rm2,
-  stat as stat2,
-  unlink as unlink2,
+  readdir,
+  rm,
+  stat,
+  unlink,
   writeFile
 } from "fs/promises";
 import { constants as fsConstants } from "fs";
-import { basename as basename4, dirname as dirname2, extname, isAbsolute as isAbsolute3, join as join5, relative, resolve as resolve2, sep } from "path";
+import { basename as basename3, dirname as dirname2, extname, isAbsolute as isAbsolute4, join as join4, relative, resolve, sep } from "path";
 var ARTIFACT_ID_PATTERN2 = /^artifact:[A-Za-z0-9][A-Za-z0-9._:-]{0,118}$/;
 function clone2(record) {
   return { descriptor: { ...record.descriptor }, path: record.path };
@@ -13187,7 +13210,7 @@ var ArtifactStore = class {
   initialized = false;
   mutationTail = Promise.resolve();
   constructor(options = {}) {
-    this.directory = resolve2(options.directory ?? ARTIFACT_DIR);
+    this.directory = resolve(options.directory ?? ARTIFACT_DIR);
     this.ttlMs = options.ttlMs ?? 15 * 6e4;
     this.retainedTtlMs = options.retainedTtlMs ?? 24 * 60 * 6e4;
     this.maxArtifactBytes = options.maxArtifactBytes ?? 100 * 1024 * 1024;
@@ -13223,10 +13246,10 @@ var ArtifactStore = class {
       kind: "upload_input",
       sensitivity: "user_file",
       mimeType,
-      removeSource: false
+      rejectSymbolicLink: false
     });
   }
-  async ingestDownload(workspaceId, sourcePath, fileName, mimeType) {
+  async ingestDownloadCopy(workspaceId, sourcePath, fileName, mimeType) {
     return this.ingestFile({
       workspaceId,
       sourcePath,
@@ -13234,7 +13257,7 @@ var ArtifactStore = class {
       sensitivity: "user_file",
       fileName,
       mimeType,
-      removeSource: true
+      rejectSymbolicLink: true
     });
   }
   async initialize() {
@@ -13244,8 +13267,8 @@ var ArtifactStore = class {
     return this.withLock(async () => clone2(await this.requireRecordUnlocked(workspaceId, artifactId)));
   }
   async export(workspaceId, artifactId, destination, overwrite = false) {
-    if (!isAbsolute3(destination)) throw invalidArgument("Artifact export path must be absolute", "path");
-    const target = resolve2(destination);
+    if (!isAbsolute4(destination)) throw invalidArgument("Artifact export path must be absolute", "path");
+    const target = resolve(destination);
     if (this.isInsideStore(target)) {
       throw invalidArgument("Artifact export path must be outside Broker storage", "path");
     }
@@ -13262,7 +13285,7 @@ var ArtifactStore = class {
         });
       }
       const canonicalStore = await realpath(this.directory);
-      if (this.isWithin(canonicalStore, join5(canonicalParent, basename4(target)))) {
+      if (this.isWithin(canonicalStore, join4(canonicalParent, basename3(target)))) {
         throw invalidArgument("Artifact export path must be outside Broker storage", "path");
       }
       if (overwrite) {
@@ -13282,7 +13305,7 @@ var ArtifactStore = class {
           cause
         });
       });
-      await chmod2(target, 384).catch(() => {
+      await chmod(target, 384).catch(() => {
       });
       return { artifact: { ...record.descriptor }, path: target };
     });
@@ -13339,8 +13362,8 @@ var ArtifactStore = class {
     return this.maxTotalBytes;
   }
   async ingestFile(input) {
-    if (!isAbsolute3(input.sourcePath)) throw invalidArgument("Artifact import path must be absolute", "path");
-    const source = resolve2(input.sourcePath);
+    if (!isAbsolute4(input.sourcePath)) throw invalidArgument("Artifact import path must be absolute", "path");
+    const source = resolve(input.sourcePath);
     if (this.isInsideStore(source)) {
       throw invalidArgument("Artifact import path must be outside Broker storage", "path");
     }
@@ -13348,6 +13371,21 @@ var ArtifactStore = class {
       await this.sweepUnlocked();
       await this.ensureDirectory();
       const canonicalStore = await realpath(this.directory);
+      if (input.rejectSymbolicLink) {
+        let sourceLinkInfo;
+        try {
+          sourceLinkInfo = await lstat2(source);
+        } catch (cause) {
+          throw new BrowserPilotError("invalid_argument", "Artifact import file is not accessible", {
+            context: { field: "path" },
+            rpcCode: -32602,
+            cause
+          });
+        }
+        if (sourceLinkInfo.isSymbolicLink() || !sourceLinkInfo.isFile()) {
+          throw invalidArgument("Artifact import path must identify a regular file", "path");
+        }
+      }
       let canonicalSource;
       try {
         canonicalSource = await realpath(source);
@@ -13363,7 +13401,7 @@ var ArtifactStore = class {
       }
       let sourceInfo;
       try {
-        sourceInfo = await stat2(canonicalSource);
+        sourceInfo = await stat(canonicalSource);
       } catch (cause) {
         throw new BrowserPilotError("invalid_argument", "Artifact import file is not accessible", {
           context: { field: "path" },
@@ -13373,8 +13411,8 @@ var ArtifactStore = class {
       }
       if (!sourceInfo.isFile()) throw invalidArgument("Artifact import path must identify a regular file", "path");
       this.assertQuota(input.workspaceId, sourceInfo.size);
-      const fileName = input.fileName ?? basename4(source);
-      if (!fileName || fileName === "." || fileName === ".." || basename4(fileName) !== fileName || fileName.length > 4096 || /[\u0000-\u001f\u007f]/.test(fileName)) {
+      const fileName = input.fileName ?? basename3(source);
+      if (!fileName || fileName === "." || fileName === ".." || basename3(fileName) !== fileName || fileName.length > 4096 || /[\u0000-\u001f\u007f]/.test(fileName)) {
         throw invalidArgument("Artifact import filename is invalid or too long", "path");
       }
       const resolvedMimeType = input.mimeType ?? inferredMimeType(fileName);
@@ -13382,14 +13420,14 @@ var ArtifactStore = class {
         throw invalidArgument("Artifact MIME type is invalid or too long", "mimeType");
       }
       const id = this.nextArtifactId();
-      const storageDirectory = join5(this.directory, randomUUID12());
-      const destination = join5(storageDirectory, fileName);
-      await mkdir2(storageDirectory, { mode: 448 });
+      const storageDirectory = join4(this.directory, randomUUID12());
+      const destination = join4(storageDirectory, fileName);
+      await mkdir(storageDirectory, { mode: 448 });
       try {
         await copyFile(canonicalSource, destination, fsConstants.COPYFILE_EXCL);
-        await chmod2(destination, 384).catch(() => {
+        await chmod(destination, 384).catch(() => {
         });
-        const copied = await stat2(destination);
+        const copied = await stat(destination);
         if (!copied.isFile() || copied.size !== sourceInfo.size) {
           throw new BrowserPilotError("invalid_argument", "Artifact import file changed while it was being copied", {
             context: { field: "path" },
@@ -13411,11 +13449,9 @@ var ArtifactStore = class {
         };
         const record = { descriptor: descriptor2, path: destination };
         this.records.set(id, record);
-        if (input.removeSource) await unlink2(canonicalSource).catch(() => {
-        });
         return clone2(record);
       } catch (error) {
-        await rm2(storageDirectory, { recursive: true, force: true }).catch(() => {
+        await rm(storageDirectory, { recursive: true, force: true }).catch(() => {
         });
         throw error;
       }
@@ -13427,10 +13463,10 @@ var ArtifactStore = class {
     this.assertQuota(input.workspaceId, byteSize);
     await this.ensureDirectory();
     const id = this.nextArtifactId();
-    const file = join5(this.directory, `${randomUUID12()}.bin`);
+    const file = join4(this.directory, `${randomUUID12()}.bin`);
     const createdAt = this.now();
     await writeFile(file, input.bytes, { mode: 384, flag: "wx" });
-    await chmod2(file, 384).catch(() => {
+    await chmod(file, 384).catch(() => {
     });
     const descriptor2 = {
       id,
@@ -13460,7 +13496,7 @@ var ArtifactStore = class {
       throw this.notFound(artifactId);
     }
     try {
-      const info = await stat2(record.path);
+      const info = await stat(record.path);
       if (!info.isFile() || info.size !== record.descriptor.byteSize) throw new Error("Artifact file mismatch");
     } catch {
       this.records.delete(artifactId);
@@ -13484,15 +13520,15 @@ var ArtifactStore = class {
   }
   async ensureDirectory() {
     if (!this.initialized) {
-      await mkdir2(this.directory, { recursive: true, mode: 448 });
+      await mkdir(this.directory, { recursive: true, mode: 448 });
       if (this.purgeOrphansOnInitialize) {
-        const entries = await readdir2(this.directory, { withFileTypes: true });
-        await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".bin") || entry.isDirectory()).map((entry) => rm2(join5(this.directory, entry.name), { recursive: true, force: true }).catch(() => {
+        const entries = await readdir(this.directory, { withFileTypes: true });
+        await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".bin") || entry.isDirectory()).map((entry) => rm(join4(this.directory, entry.name), { recursive: true, force: true }).catch(() => {
         })));
       }
       this.initialized = true;
     }
-    await chmod2(this.directory, 448).catch(() => {
+    await chmod(this.directory, 448).catch(() => {
     });
   }
   notFound(artifactId) {
@@ -13507,11 +13543,11 @@ var ArtifactStore = class {
   }
   isInsideStore(path) {
     const child = relative(this.directory, path);
-    return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute3(child);
+    return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute4(child);
   }
   isWithin(parent, path) {
     const child = relative(parent, path);
-    return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute3(child);
+    return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute4(child);
   }
   nextArtifactId() {
     const id = this.idFactory();
@@ -13539,11 +13575,11 @@ var ArtifactStore = class {
     }
   }
   async removeStoredFile(path) {
-    await unlink2(path).catch(() => {
+    await unlink(path).catch(() => {
     });
     const parent = dirname2(path);
     if (parent !== this.directory && this.isInsideStore(parent)) {
-      await rm2(parent, { recursive: true, force: true }).catch(() => {
+      await rm(parent, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -13755,8 +13791,8 @@ var ManagedTargetJanitorClient = class {
     });
     this.worker = worker;
     this.ready = false;
-    const ready = new Promise((resolve3, reject) => {
-      this.readyResolve = resolve3;
+    const ready = new Promise((resolve2, reject) => {
+      this.readyResolve = resolve2;
       this.readyReject = reject;
     });
     worker.on("message", (value) => this.handleWorkerMessage(worker, value));
@@ -13861,7 +13897,7 @@ var ManagedTargetJanitorClient = class {
     }
     const id = this.nextRequestId++;
     const request = { id, method, params };
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(method === "create" ? new BrowserPilotError(
@@ -13871,7 +13907,7 @@ var ManagedTargetJanitorClient = class {
         ) : new Error(`Managed browser connection timeout: ${method}`));
       }, REQUEST_TIMEOUT_MS);
       timer.unref();
-      this.pendingRequests.set(id, { resolve: resolve3, reject, timer, method });
+      this.pendingRequests.set(id, { resolve: resolve2, reject, timer, method });
       worker.send?.(request, (error) => {
         if (!error) return;
         const pending = this.pendingRequests.get(id);
@@ -13901,19 +13937,19 @@ var ManagedTargetJanitorClient = class {
     this.expectedExits.add(worker);
     if (cleanup2 && worker.stdin && !worker.stdin.destroyed) worker.stdin.end();
     else worker.kill("SIGTERM");
-    await new Promise((resolve3) => {
+    await new Promise((resolve2) => {
       if (worker.exitCode !== null || worker.signalCode !== null) {
-        resolve3();
+        resolve2();
         return;
       }
       const timer = setTimeout(() => {
         worker.kill("SIGKILL");
-        resolve3();
+        resolve2();
       }, STOP_TIMEOUT_MS);
       timer.unref();
       worker.once("exit", () => {
         clearTimeout(timer);
-        resolve3();
+        resolve2();
       });
     });
     if (this.worker === worker) this.failWorker(worker, this.unavailableError());
@@ -13943,7 +13979,7 @@ var ManagedTargetJanitorClient = class {
 };
 
 // src/version.ts
-var BROWSER_PILOT_VERSION = "0.3.0-rc.1";
+var BROWSER_PILOT_VERSION = "0.3.0-rc.3";
 
 // src/daemon.ts
 var CLI_EXECUTABLE_PATH = publicExecutablePath(import.meta.url);
@@ -13957,7 +13993,7 @@ var browserProfile = process.argv[4] || "";
 ensureBrokerDirectoriesSync();
 for (const legacyFile of ["state.json", "refs.json"]) {
   try {
-    unlinkSync2(join6(STATE_DIR, legacyFile));
+    unlinkSync2(join5(STATE_DIR, legacyFile));
   } catch {
   }
 }
@@ -13977,7 +14013,7 @@ function cleanup(brokerProcessIdentity) {
   removeBrokerLocatorSync(brokerProcessIdentity);
 }
 function readBody(req, maxBytes = 5 * 1024 * 1024) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve2, reject) => {
     const chunks = [];
     let byteLength = 0;
     req.on("data", (value) => {
@@ -13990,7 +14026,7 @@ function readBody(req, maxBytes = 5 * 1024 * 1024) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -14057,8 +14093,6 @@ async function syncFetchAll(cdp, currentSessionId) {
 async function main() {
   const startedAt = Date.now();
   const brokerProcessIdentity = `${process.pid}:${startedAt}`;
-  writeBrokerStartingSync({ pid: process.pid, startedAt, brokerProcessIdentity });
-  process.once("exit", () => cleanup(brokerProcessIdentity));
   const cdp = new ManagedTargetJanitorClient({
     onLog: (message) => process.stderr.write(`Managed browser connection: ${message}
 `)
@@ -14075,8 +14109,10 @@ async function main() {
   const requestTermination = () => {
     void terminate();
   };
+  process.once("exit", () => cleanup(brokerProcessIdentity));
   process.on("SIGTERM", requestTermination);
   process.on("SIGINT", requestTermination);
+  writeBrokerStartingSync({ pid: process.pid, startedAt, brokerProcessIdentity });
   if (initialWsUrl) await cdp.connect(initialWsUrl);
   let activeSessionId;
   let currentWsUrl = initialWsUrl;