@agentorg/computer 0.0.7 → 0.0.8

package/dist/agentcomputer.js

@@ -2295,7 +2295,7 @@ var require_websocket = __commonJS({
     var net = __require("net");
     var querystring = __require("querystring");
     var tls = __require("tls");
-    var { randomBytes: randomBytes5, createHash: createHash2 } = __require("crypto");
+    var { randomBytes: randomBytes6, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable: Readable5 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2845,7 +2845,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes5(16).toString("base64");
+      const key = randomBytes6(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -3095,21 +3095,21 @@ var require_websocket = __commonJS({
         process.nextTick(cb, err);
       }
     }
-    function receiverOnConclude(code, reason2) {
+    function receiverOnConclude(code, reason3) {
       const websocket = this[kWebSocket];
       websocket._closeFrameReceived = true;
       websocket._closeCode = code;
-      if (reason2.length === 0) {
+      if (reason3.length === 0) {
         websocket._closeMessage = EMPTY_BUFFER;
       } else {
-        websocket._closeMessage = Buffer.allocUnsafeSlow(reason2.length);
-        websocket._closeMessage.set(reason2);
+        websocket._closeMessage = Buffer.allocUnsafeSlow(reason3.length);
+        websocket._closeMessage.set(reason3);
       }
       if (websocket._socket[kWebSocket] === void 0) return;
       websocket._socket.removeListener("data", socketOnData);
       process.nextTick(resume, websocket._socket);
       if (code === 1005) websocket.close();
-      else websocket.close(code, reason2);
+      else websocket.close(code, reason3);
     }
     function receiverOnDrain() {
       const websocket = this[kWebSocket];
@@ -3268,7 +3268,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open3() {
+          ws.once("open", function open4() {
             duplex._final(callback);
           });
           return;
@@ -3289,7 +3289,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open3() {
+          ws.once("open", function open4() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -3753,7 +3753,7 @@ var require_websocket_server = __commonJS({
 // src/main.ts
 import { readFileSync as readFileSync6 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { isAbsolute as isAbsolute2, join as join11, resolve as resolve5 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join12, resolve as resolve5 } from "node:path";
 import { parseArgs } from "node:util";
 import { isMainThread as isMainThread2 } from "node:worker_threads";
 
@@ -3772,9 +3772,9 @@ var playwright = () => {
 // src/browser-host.ts
 var sandboxFor = (options) => options.sandbox ?? (process.platform !== "linux" || !options.executable && !["chromium", "chrome-for-testing"].includes(options.channel ?? "chrome"));
 async function hostBrowser(options) {
-  const run3 = mkdtempSync(join("/tmp", "agentcomputer-"));
-  process.env.XDG_RUNTIME_DIR = run3;
-  process.env.TMPDIR = run3;
+  const run2 = mkdtempSync(join("/tmp", "agentcomputer-"));
+  process.env.XDG_RUNTIME_DIR = run2;
+  process.env.TMPDIR = run2;
   const context = await playwright().chromium.launchPersistentContext(options.profile, {
     headless: true,
     chromiumSandbox: sandboxFor(options),
@@ -3783,7 +3783,7 @@ async function hostBrowser(options) {
   const browser = context.browser();
   if (!browser) throw new Error("The browser can't be shared.");
   const { endpoint } = await browser.bind("agentcomputer");
-  if (!endpoint.startsWith(run3 + sep)) {
+  if (!endpoint.startsWith(run2 + sep)) {
     await context.close();
     throw new Error(`The browser's socket isn't in its own folder: ${endpoint}`);
   }
@@ -3797,26 +3797,66 @@ async function hostBrowser(options) {
     });
     await context.close().catch(() => {
     });
-    rmSync(run3, { recursive: true, force: true });
+    rmSync(run2, { recursive: true, force: true });
     process.exit(0);
   };
   for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => void stop());
   context.on("close", () => void stop());
 }
 
+// src/browser-mcp.ts
+import { createRequire as createRequire2 } from "node:module";
+var require2 = createRequire2(import.meta.url);
+var mcpParts = () => require2("playwright-core/lib/coreBundle").tools;
+async function serveBrowserMcp(options) {
+  const parts = mcpParts();
+  parts.setupExitWatchdog();
+  const config3 = await parts.resolveCLIConfigForMCP({
+    endpoint: options.endpoint,
+    outputDir: options.outputDir,
+    host: "127.0.0.1",
+    port: 0,
+    // The tool that closes the browser refuses, as it does for any browser its clients share.
+    sharedBrowserContext: true
+  });
+  const tools = parts.filteredTools(config3);
+  await parts.start(
+    {
+      name: "Playwright",
+      nameInConfig: "playwright",
+      // playwright-core's, as Playwright MCP's program gives it.
+      version: require2("playwright-core/package.json").version,
+      toolSchemas: tools.map((tool) => tool.schema),
+      ignoreRoots: config3.ignoreRoots,
+      /** One for each client's session: a connection of its own to the one browser. */
+      create: async () => {
+        const browser = await playwright().chromium.connect(options.endpoint);
+        const context = browser.contexts()[0];
+        if (!context) {
+          await browser.close();
+          throw new Error("The browser has no context to work in.");
+        }
+        return new parts.BrowserBackend(config3, context, tools, {
+          dispose: () => browser.close()
+        });
+      }
+    },
+    config3.server
+  );
+}
+
 // src/container.ts
 import { execFile, spawn as spawn3 } from "node:child_process";
 import { readFileSync as readFileSync3 } from "node:fs";
 import { connect } from "node:net";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 import { Readable as Readable3 } from "node:stream";
 import { promisify } from "node:util";
 
 // src/browser.ts
 import { spawn } from "node:child_process";
-import { createRequire as createRequire2 } from "node:module";
-import { dirname, join as join2 } from "node:path";
+import { join as join2 } from "node:path";
 import { createInterface } from "node:readline";
 import { pipeline, Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
@@ -15120,7 +15160,7 @@ function linkedRoundAbort(outer) {
   if (outer?.aborted) controller.abort(outer.reason);
   return {
     signal: controller.signal,
-    abort: (reason2) => controller.abort(reason2),
+    abort: (reason3) => controller.abort(reason3),
     dispose: () => outer?.removeEventListener("abort", onOuterAbort)
   };
 }
@@ -15963,8 +16003,8 @@ var Protocol = class {
         return;
       }
       if (options?.signal?.aborted) {
-        const reason2 = options.signal.reason;
-        throw reason2 instanceof SdkError ? reason2 : new SdkError(SdkErrorCode.RequestTimeout, String(reason2));
+        const reason3 = options.signal.reason;
+        throw reason3 instanceof SdkError ? reason3 : new SdkError(SdkErrorCode.RequestTimeout, String(reason3));
       }
       const requestAbort = codec2.era === MODERN_WIRE_REVISION && this._transport.hasPerRequestStream === true ? new AbortController() : void 0;
       const messageId = this._requestMessageId++;
@@ -15986,7 +16026,7 @@ var Protocol = class {
       }
       const outbound = this._envelopeOutbound(jsonrpcRequest);
       let responseReceived = false;
-      const cancel = (reason2) => {
+      const cancel = (reason3) => {
         if (responseReceived) return;
         this._progressHandlers.delete(messageId);
         if (requestAbort === void 0) {
@@ -15995,7 +16035,7 @@ var Protocol = class {
             method: "notifications/cancelled",
             params: {
               requestId: messageId,
-              reason: String(reason2)
+              reason: String(reason3)
             }
           }), {
             relatedRequestId,
@@ -16003,7 +16043,7 @@ var Protocol = class {
             onresumptiontoken
           }).catch((error62) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error62}`)));
         } else requestAbort.abort();
-        reject(reason2 instanceof SdkError ? reason2 : new SdkError(SdkErrorCode.RequestTimeout, String(reason2)));
+        reject(reason3 instanceof SdkError ? reason3 : new SdkError(SdkErrorCode.RequestTimeout, String(reason3)));
       };
       this._responseHandlers.set(messageId, (response) => {
         if (options?.signal?.aborted) return;
@@ -20413,7 +20453,7 @@ var require_core$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
     }
     errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
       if (!errors || errors.length === 0) return "No errors";
-      return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text2, msg) => text2 + separator + msg);
+      return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text3, msg) => text3 + separator + msg);
     }
     $dataMetaSchema(metaSchema, keywordsJsonPointers) {
       const rules = this.RULES.all;
@@ -23818,8 +23858,8 @@ async function random(size) {
   const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
   let result = "";
   while (result.length < size) {
-    const randomBytes5 = await getRandomValues(size - result.length);
-    for (const randomByte of randomBytes5) {
+    const randomBytes6 = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes6) {
       if (randomByte < evenDistCutoff) {
         result += mask[randomByte % mask.length];
       }
@@ -25485,11 +25525,11 @@ function normalizeReply(reply, timeoutMs) {
         error: error62
       };
       if (error62 instanceof SdkHttpError) {
-        const text2 = error62.data?.text;
+        const text3 = error62.data?.text;
         return {
           kind: "http-error",
           status: error62.data.status,
-          body: typeof text2 === "string" ? text2 : void 0,
+          body: typeof text3 === "string" ? text3 : void 0,
           statusText: error62.data.statusText
         };
       }
@@ -25731,10 +25771,10 @@ var Client = class extends Protocol {
     this._discoverResult = void 0;
     this._autoOpenedSubscription = void 0;
     if (this._listenState.size > 0) {
-      const reason2 = new SdkError(SdkErrorCode.ConnectionClosed, "subscriptions/listen: client reconnected or closed; subscription state from the previous connection was reset");
+      const reason3 = new SdkError(SdkErrorCode.ConnectionClosed, "subscriptions/listen: client reconnected or closed; subscription state from the previous connection was reset");
       for (const entry of this._listenState.values()) entry.settle({
         cause: "remote",
-        error: reason2
+        error: reason3
       });
     }
     this._listenState.clear();
@@ -26478,8 +26518,8 @@ var Client = class extends Protocol {
     const hit = await this._cache.read(method, params).catch((error62) => void this._reportStoreError(error62));
     if (hit !== void 0) {
       if (options?.signal?.aborted) {
-        const reason2 = options.signal.reason;
-        throw reason2 instanceof SdkError ? reason2 : new SdkError(SdkErrorCode.RequestTimeout, String(reason2));
+        const reason3 = options.signal.reason;
+        throw reason3 instanceof SdkError ? reason3 : new SdkError(SdkErrorCode.RequestTimeout, String(reason3));
       }
       return hit.value;
     }
@@ -26620,8 +26660,8 @@ var Client = class extends Protocol {
       protocolVersion: negotiated
     });
     if (options?.signal?.aborted) {
-      const reason2 = options.signal.reason;
-      throw reason2 instanceof SdkError ? reason2 : new SdkError(SdkErrorCode.RequestTimeout, String(reason2));
+      const reason3 = options.signal.reason;
+      throw reason3 instanceof SdkError ? reason3 : new SdkError(SdkErrorCode.RequestTimeout, String(reason3));
     }
     const requestAbort = new AbortController();
     const listenId = `listen:${this._nextListenId++}`;
@@ -26684,10 +26724,10 @@ var Client = class extends Protocol {
       const callerSignal = options.signal;
       onCallerAbort = () => {
         if (state === "closed") return;
-        const reason2 = callerSignal.reason;
+        const reason3 = callerSignal.reason;
         settle3({
           cause: "local",
-          error: reason2 instanceof Error ? reason2 : new Error(String(reason2 ?? "Aborted"))
+          error: reason3 instanceof Error ? reason3 : new Error(String(reason3 ?? "Aborted"))
         });
         wireTeardown().catch(() => {
         });
@@ -26814,10 +26854,10 @@ var Client = class extends Protocol {
   */
   _onclose() {
     if (this._listenState.size > 0) {
-      const reason2 = new SdkError(SdkErrorCode.ConnectionClosed, "Connection closed");
+      const reason3 = new SdkError(SdkErrorCode.ConnectionClosed, "Connection closed");
       for (const entry of this._listenState.values()) entry.settle({
         cause: "remote",
-        error: reason2
+        error: reason3
       });
       this._listenState.clear();
     }
@@ -27467,8 +27507,8 @@ var StreamableHTTPClientTransport = class {
   }
   /** Error text for a redirect `response` that was not followed, or `undefined` for any other response. */
   _unfollowedRedirect(url3, response) {
-    const text2 = this._redirectPolicy === "follow" ? void 0 : unfollowedRedirect(url3, response);
-    return text2 && `${text2} (redirectPolicy: 'same-origin')`;
+    const text3 = this._redirectPolicy === "follow" ? void 0 : unfollowedRedirect(url3, response);
+    return text3 && `${text3} (redirectPolicy: 'same-origin')`;
   }
   async _commonHeaders() {
     const headers = new Headers(this._requestInit?.headers || void 0);
@@ -27559,13 +27599,13 @@ var StreamableHTTPClientTransport = class {
         if (response.status === 403) {
           const { resourceMetadataUrl, scope, error: error62, errorDescription } = extractWWWAuthenticateParams(response);
           if (error62 === "insufficient_scope") {
-            const text2 = await response.text?.().catch(() => null);
+            const text3 = await response.text?.().catch(() => null);
             if (await this._stepUpAuthorize({
               scope,
               resourceMetadataUrl,
               errorDescription,
               statusText: response.statusText,
-              text: text2
+              text: text3
             }, stepUpRetries) !== "AUTHORIZED") throw markAuthSeamEscape(new UnauthorizedError());
             return this._startOrAuthSse(options, isAuthRetry, stepUpRetries + 1);
           }
@@ -27576,8 +27616,8 @@ var StreamableHTTPClientTransport = class {
           options.onRequestStreamEnd?.();
           return;
         }
-        const reason2 = this._unfollowedRedirect(this._url, response) ?? response.statusText;
-        throw new SdkHttpError(SdkErrorCode.ClientHttpFailedToOpenStream, `Failed to open SSE stream: ${reason2}`, {
+        const reason3 = this._unfollowedRedirect(this._url, response) ?? response.statusText;
+        throw new SdkHttpError(SdkErrorCode.ClientHttpFailedToOpenStream, `Failed to open SSE stream: ${reason3}`, {
           status: response.status,
           statusText: response.statusText
         });
@@ -27797,7 +27837,7 @@ var StreamableHTTPClientTransport = class {
           }));
           throw markAuthSeamEscape(new UnauthorizedError());
         }
-        const text2 = await response.text?.().catch(() => null);
+        const text3 = await response.text?.().catch(() => null);
         if (response.status === 403) {
           const { resourceMetadataUrl, scope, error: error62, errorDescription } = extractWWWAuthenticateParams(response);
           if (error62 === "insufficient_scope") {
@@ -27806,13 +27846,13 @@ var StreamableHTTPClientTransport = class {
               resourceMetadataUrl,
               errorDescription,
               statusText: response.statusText,
-              text: text2
+              text: text3
             }, stepUpRetries) !== "AUTHORIZED") throw markAuthSeamEscape(new UnauthorizedError());
             return this._send(message, options, isAuthRetry, stepUpRetries + 1);
           }
         }
-        if (response.status === 400 && typeof text2 === "string" && this._isModernEnvelopedRequest(message)) try {
-          const parsed = JSONRPCMessageSchema.parse(JSON.parse(text2));
+        if (response.status === 400 && typeof text3 === "string" && this._isModernEnvelopedRequest(message)) try {
+          const parsed = JSONRPCMessageSchema.parse(JSON.parse(text3));
           const requests = (Array.isArray(message) ? message : [message]).filter((m) => isJSONRPCRequest(m));
           if (isJSONRPCErrorResponse(parsed) && requests.some((r) => r.id === parsed.id)) {
             this.onmessage?.(parsed);
@@ -27820,11 +27860,11 @@ var StreamableHTTPClientTransport = class {
           }
         } catch {
         }
-        const reason2 = this._unfollowedRedirect(this._url, response) ?? text2;
-        throw new SdkHttpError(SdkErrorCode.ClientHttpNotImplemented, `Error POSTing to endpoint: ${reason2}`, {
+        const reason3 = this._unfollowedRedirect(this._url, response) ?? text3;
+        throw new SdkHttpError(SdkErrorCode.ClientHttpNotImplemented, `Error POSTing to endpoint: ${reason3}`, {
           status: response.status,
           statusText: response.statusText,
-          text: text2
+          text: text3
         });
       }
       if (response.status === 202) {
@@ -27938,18 +27978,16 @@ function sendAnswer(upstream, response) {
   pipeline(Readable.fromWeb(upstream.body), response, () => {
   });
 }
-var mcpCli = () => join2(dirname(createRequire2(import.meta.url).resolve("@playwright/mcp/package.json")), "cli.js");
 var self = fileURLToPath(import.meta.url);
-var ANSWERS = /* @__PURE__ */ new Set(["browser_handle_dialog", "browser_file_upload"]);
-function withoutHidden(text2, hidden) {
+function withoutHidden(text3, hidden) {
   const clean = (json4) => {
     const message = JSON.parse(json4);
     if (message.result?.tools)
       message.result.tools = message.result.tools.filter((tool) => !hidden.has(tool.name));
     return JSON.stringify(message);
   };
-  if (text2.trimStart().startsWith("{")) return clean(text2);
-  return text2.replace(/^data: (\{.*\})$/gm, (_, json4) => `data: ${clean(json4)}`);
+  if (text3.trimStart().startsWith("{")) return clean(text3);
+  return text3.replace(/^data: (\{.*\})$/gm, (_, json4) => `data: ${clean(json4)}`);
 }
 async function end(child) {
   if (child.exitCode !== null || child.signalCode !== null) return;
@@ -28012,17 +28050,7 @@ var Browser = class {
         if (this.#stopping) return failed(new Error("It stopped."));
         const mcp = spawn(
           process.execPath,
-          [
-            mcpCli(),
-            "--host",
-            "127.0.0.1",
-            "--port",
-            "0",
-            "--endpoint",
-            endpoint,
-            "--output-dir",
-            join2(folder, "output")
-          ],
+          [self, "browser-mcp", "--endpoint", endpoint, "--output", join2(folder, "output")],
           // Its own limit on which files it touches is the folder it starts in.
           { cwd, stdio: ["ignore", "pipe", "pipe"] }
         );
@@ -28075,27 +28103,24 @@ var Browser = class {
     } catch {
     }
     const tool = message.method === "tools/call" ? String(message.params?.name) : void 0;
-    const refuse = (text2, code = -32e3) => {
+    if (tool && this.#hidden.has(tool)) {
       response.writeHead(200, { "Content-Type": "application/json" });
-      response.end(
+      return void response.end(
         JSON.stringify({
           jsonrpc: "2.0",
           id: message.id ?? null,
-          ...code === -32602 ? { error: { code, message: text2 } } : { result: { content: [{ type: "text", text: text2 }], isError: true } }
+          error: { code: -32602, message: `Unknown tool: ${tool}` }
         })
       );
-    };
-    if (tool && this.#hidden.has(tool)) return refuse(`Unknown tool: ${tool}`, -32602);
-    if (tool && this.gate) {
-      const answer = await this.gate.wait();
-      if (answer) return refuse(answer);
     }
     const headers = {};
     for (const name of FORWARDED) {
       const value = request.headers[name];
       if (typeof value === "string") headers[name] = value;
     }
-    if (tool && this.gate?.takeAnsweredChooser())
+    const session = headers["mcp-session-id"] ?? "";
+    if (request.method === "DELETE") this.gate?.sessionEnded(session);
+    if (tool && this.gate?.takeAnsweredChooser(session) && tool !== "browser_file_upload")
       await fetch(`${origin}/mcp`, {
         method: "POST",
         headers,
@@ -28107,15 +28132,15 @@ var Browser = class {
         })
       }).then((answer) => answer.text()).catch(() => {
       });
-    if (tool && ANSWERS.has(tool)) this.gate?.agentAnswered();
+    if (tool === "browser_file_upload") this.gate?.agentAnsweredChooser();
     const upstream = await fetch(`${origin}/mcp`, {
       method: request.method,
       headers,
       ...body.length > 0 ? { body } : {}
     });
     if (message.method === "tools/list" && this.#hidden.size > 0) {
-      const text2 = withoutHidden(await upstream.text(), this.#hidden);
-      return sendAnswer(new Response(text2, upstream), response);
+      const text3 = withoutHidden(await upstream.text(), this.#hidden);
+      return sendAnswer(new Response(text3, upstream), response);
     }
     sendAnswer(upstream, response);
   }
@@ -28128,10 +28153,10 @@ var Browser = class {
 // src/inside.ts
 import { createServer as createServer3 } from "node:http";
 import { homedir } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/runtime.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // node_modules/@agentorg/exec/dist/lib.js
 import { realpathSync } from "node:fs";
@@ -28139,9 +28164,22 @@ import { resolve as resolve3 } from "node:path";
 import { STATUS_CODES, ServerResponse, createServer } from "node:http";
 import { Http2ServerRequest, constants } from "node:http2";
 import { Readable as Readable2 } from "node:stream";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { lstat as lstat2, open as open2, readdir as readdir2, rename as rename2, rm as rm2, stat as stat2 } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { lstat, readdir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
-import { basename, dirname as dirname2, join as join3, resolve, sep as sep2 } from "node:path";
+import {
+  chmod,
+  lstat,
+  readdir,
+  readFile,
+  realpath,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { basename, dirname, join as join4, resolve, sep as sep2 } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { StringDecoder } from "node:string_decoder";
@@ -28373,7 +28411,7 @@ var require_ignore = __commonJS2({
         //   ever starts again inside it -- `(\\+?) ` did, which made a long run
         //   quadratic.
         /(\\+)( ?)/g,
-        (_, run22, space) => space ? run22.slice(0, run22.length - run22.length % 2) + SPACE2 : run22,
+        (_, run2, space) => space ? run2.slice(0, run2.length - run2.length % 2) + SPACE2 : run2,
         ESCAPE + SPACE2
       ],
       // git's wildmatch() reads a run of two or more asterisks as one globstar
@@ -28559,10 +28597,10 @@ var require_ignore = __commonJS2({
     var REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
     var replaceTrailingDoublestar = () => ".+(?=$|\\/$)";
     var WILDCARD2 = "[^\\/]*";
-    var separatorAfter = (run22, at) => {
+    var separatorAfter = (run2, at) => {
       let separator = EMPTY;
-      for (let index = at + 1; index < run22.length && !run22[index].wildcard; index++) {
-        separator += run22[index].single;
+      for (let index = at + 1; index < run2.length && !run2[index].wildcard; index++) {
+        separator += run2[index].single;
       }
       return separator;
     };
@@ -28622,26 +28660,26 @@ var require_ignore = __commonJS2({
         }
       }
       let out = EMPTY;
-      let run22 = [];
+      let run2 = [];
       const flush = () => {
         let lastWildcard;
-        run22.forEach((token, at) => {
+        run2.forEach((token, at) => {
           if (token.wildcard) {
             lastWildcard = at;
           }
         });
-        run22.forEach((token, at) => {
+        run2.forEach((token, at) => {
           if (!token.wildcard) {
             out += token.single;
             return;
           }
-          out += at === lastWildcard ? WILDCARD2 : `(?:(?!${separatorAfter(run22, at)})[^\\/])*`;
+          out += at === lastWildcard ? WILDCARD2 : `(?:(?!${separatorAfter(run2, at)})[^\\/])*`;
         });
-        run22 = [];
+        run2 = [];
       };
       tokens.forEach((token) => {
         if (token.boundary === void 0) {
-          run22.push(token);
+          run2.push(token);
           return;
         }
         flush();
@@ -34276,7 +34314,7 @@ function bucketFor2(state, inst) {
   return bucket;
 }
 var handoff2;
-var open2 = [];
+var open3 = [];
 var memo3 = {
   alloc(_inst, payload, empty) {
     const bucket = handoff2;
@@ -34285,7 +34323,7 @@ var memo3 = {
     handoff2 = void 0;
     const entry = { value: empty, issues: null };
     bucket.set(payload.value, entry);
-    open2.push(entry);
+    open3.push(entry);
     return empty;
   },
   guard(inst) {
@@ -34356,10 +34394,10 @@ var memo3 = {
           return payload;
         }
         handoff2 = bucket;
-        const depth = open2.length;
+        const depth = open3.length;
         const result = base(payload, ctx);
         handoff2 = void 0;
-        const entry = open2.length > depth ? open2.pop() : void 0;
+        const entry = open3.length > depth ? open3.pop() : void 0;
         if (result instanceof Promise) {
           return result.then((r) => {
             if (entry)
@@ -38340,8 +38378,8 @@ function ko_default() {
     localeError: error32()
   };
 }
-var capitalizeFirstCharacter = (text2) => {
-  return text2.charAt(0).toUpperCase() + text2.slice(1);
+var capitalizeFirstCharacter = (text22) => {
+  return text22.charAt(0).toUpperCase() + text22.slice(1);
 };
 function getUnitTypeFromNumber(number42) {
   const abs = Math.abs(number42);
@@ -48403,7 +48441,7 @@ function visit(schema, fnOrHandlers) {
     return h ? h(node22, rewritten) : node22;
   };
   const cache = /* @__PURE__ */ new Map();
-  function run22(s) {
+  function run2(s) {
     const cached22 = cache.get(s);
     if (cached22 === RESOLVING) {
       return new $ZodLazy2({
@@ -48426,69 +48464,69 @@ function visit(schema, fnOrHandlers) {
       case "object": {
         const oldShape = def.shape;
         const keys = Object.keys(oldShape);
-        let changed = false;
+        let changed2 = false;
         const newShape = {};
         for (const k of keys) {
-          const mapped = run22(oldShape[k]);
+          const mapped = run2(oldShape[k]);
           if (mapped !== oldShape[k])
-            changed = true;
+            changed2 = true;
           newShape[k] = mapped;
         }
         let newCatchall = def.catchall;
         if (def.catchall) {
-          newCatchall = run22(def.catchall);
+          newCatchall = run2(def.catchall);
           if (newCatchall !== def.catchall)
-            changed = true;
+            changed2 = true;
         }
-        return changed ? clone2(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
+        return changed2 ? clone2(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
       }
       case "array": {
-        const mapped = run22(def.element);
+        const mapped = run2(def.element);
         return mapped === def.element ? s : clone2(s, { ...def, element: mapped });
       }
       case "tuple": {
         const oldItems = def.items;
-        let changed = false;
+        let changed2 = false;
         const newItems = [];
         for (const item of oldItems) {
-          const mapped = run22(item);
+          const mapped = run2(item);
           if (mapped !== item)
-            changed = true;
+            changed2 = true;
           newItems.push(mapped);
         }
         let newRest = def.rest;
         if (def.rest) {
-          newRest = run22(def.rest);
+          newRest = run2(def.rest);
           if (newRest !== def.rest)
-            changed = true;
+            changed2 = true;
         }
-        return changed ? clone2(s, { ...def, items: newItems, rest: newRest }) : s;
+        return changed2 ? clone2(s, { ...def, items: newItems, rest: newRest }) : s;
       }
       case "record":
       case "map": {
-        const newKey = run22(def.keyType);
-        const newVal = run22(def.valueType);
+        const newKey = run2(def.keyType);
+        const newVal = run2(def.valueType);
         return newKey === def.keyType && newVal === def.valueType ? s : clone2(s, { ...def, keyType: newKey, valueType: newVal });
       }
       case "set": {
-        const newVal = run22(def.valueType);
+        const newVal = run2(def.valueType);
         return newVal === def.valueType ? s : clone2(s, { ...def, valueType: newVal });
       }
       case "union": {
         const oldOptions = def.options;
-        let changed = false;
+        let changed2 = false;
         const newOptions = [];
         for (const opt of oldOptions) {
-          const mapped = run22(opt);
+          const mapped = run2(opt);
           if (mapped !== opt)
-            changed = true;
+            changed2 = true;
           newOptions.push(mapped);
         }
-        return changed ? clone2(s, { ...def, options: newOptions }) : s;
+        return changed2 ? clone2(s, { ...def, options: newOptions }) : s;
       }
       case "intersection": {
-        const newLeft = run22(def.left);
-        const newRight = run22(def.right);
+        const newLeft = run2(def.left);
+        const newRight = run2(def.right);
         return newLeft === def.left && newRight === def.right ? s : clone2(s, { ...def, left: newLeft, right: newRight });
       }
       case "optional":
@@ -48500,23 +48538,23 @@ function visit(schema, fnOrHandlers) {
       case "nonoptional":
       case "promise":
       case "success": {
-        const newInner = run22(def.innerType);
+        const newInner = run2(def.innerType);
         return newInner === def.innerType ? s : clone2(s, { ...def, innerType: newInner });
       }
       case "pipe": {
-        const newIn = run22(def.in);
-        const newOut = run22(def.out);
+        const newIn = run2(def.in);
+        const newOut = run2(def.out);
         return newIn === def.in && newOut === def.out ? s : clone2(s, { ...def, in: newIn, out: newOut });
       }
       case "function": {
-        const newInput = run22(def.input);
-        const newOutput = run22(def.output);
+        const newInput = run2(def.input);
+        const newOutput = run2(def.output);
         return newInput === def.input && newOutput === def.output ? s : clone2(s, { ...def, input: newInput, output: newOutput });
       }
       case "lazy": {
         const original = def.getter;
         const { _cachedInner, ...rest } = def;
-        return clone2(s, { ...rest, getter: () => run22(original()) });
+        return clone2(s, { ...rest, getter: () => run2(original()) });
       }
       // A leaf by choice: `parts` are regex fragments, not data positions.
       case "template_literal":
@@ -48547,7 +48585,7 @@ function visit(schema, fnOrHandlers) {
       }
     }
   }
-  return run22(schema);
+  return run2(schema);
 }
 function deepPartial(schema) {
   return visit(schema, {
@@ -52975,7 +53013,7 @@ function linkedRoundAbort2(outer) {
   if (outer?.aborted) controller.abort(outer.reason);
   return {
     signal: controller.signal,
-    abort: (reason2) => controller.abort(reason2),
+    abort: (reason22) => controller.abort(reason22),
     dispose: () => outer?.removeEventListener("abort", onOuterAbort)
   };
 }
@@ -53770,8 +53808,8 @@ var Protocol2 = class {
         return;
       }
       if (options?.signal?.aborted) {
-        const reason2 = options.signal.reason;
-        throw reason2 instanceof SdkError2 ? reason2 : new SdkError2(SdkErrorCode2.RequestTimeout, String(reason2));
+        const reason22 = options.signal.reason;
+        throw reason22 instanceof SdkError2 ? reason22 : new SdkError2(SdkErrorCode2.RequestTimeout, String(reason22));
       }
       const requestAbort = codec2.era === MODERN_WIRE_REVISION2 && this._transport.hasPerRequestStream === true ? new AbortController() : void 0;
       const messageId = this._requestMessageId++;
@@ -53793,7 +53831,7 @@ var Protocol2 = class {
       }
       const outbound = this._envelopeOutbound(jsonrpcRequest);
       let responseReceived = false;
-      const cancel = (reason2) => {
+      const cancel = (reason22) => {
         if (responseReceived) return;
         this._progressHandlers.delete(messageId);
         if (requestAbort === void 0) {
@@ -53802,7 +53840,7 @@ var Protocol2 = class {
             method: "notifications/cancelled",
             params: {
               requestId: messageId,
-              reason: String(reason2)
+              reason: String(reason22)
             }
           }), {
             relatedRequestId,
@@ -53810,7 +53848,7 @@ var Protocol2 = class {
             onresumptiontoken
           }).catch((error62) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error62}`)));
         } else requestAbort.abort();
-        reject(reason2 instanceof SdkError2 ? reason2 : new SdkError2(SdkErrorCode2.RequestTimeout, String(reason2)));
+        reject(reason22 instanceof SdkError2 ? reason22 : new SdkError2(SdkErrorCode2.RequestTimeout, String(reason22)));
       };
       this._responseHandlers.set(messageId, (response) => {
         if (options?.signal?.aborted) return;
@@ -58131,7 +58169,7 @@ var require_core$32 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     }
     errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
       if (!errors || errors.length === 0) return "No errors";
-      return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text2, msg) => text2 + separator + msg);
+      return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text22, msg) => text22 + separator + msg);
     }
     $dataMetaSchema(metaSchema, keywordsJsonPointers) {
       const rules = this.RULES.all;
@@ -63273,21 +63311,21 @@ async function readRequestBody(request, maxBytes = DEFAULT_MAX_REQUEST_BODY_SIZE
   const reader = request.body.getReader();
   const decoder = new TextDecoder();
   let received = 0;
-  let text2 = "";
+  let text22 = "";
   try {
     for (; ; ) {
       const { done, value } = await reader.read();
       if (done) break;
       received += value.byteLength;
       if (received > maxBytes) return { tooLarge: true };
-      text2 += decoder.decode(value, { stream: true });
+      text22 += decoder.decode(value, { stream: true });
     }
   } finally {
     reader.releaseLock();
   }
   return {
     tooLarge: false,
-    text: text2 + decoder.decode()
+    text: text22 + decoder.decode()
   };
 }
 var WebStandardStreamableHTTPServerTransport = class {
@@ -64356,8 +64394,8 @@ var readRawBodyIfAvailable = (request) => {
 };
 var normalizeAbortError = (request, incoming) => {
   if (incoming.errored) return incoming.errored;
-  const reason2 = request[abortReasonKey];
-  if (reason2 !== void 0) return reason2 instanceof Error ? reason2 : new Error(String(reason2));
+  const reason22 = request[abortReasonKey];
+  if (reason22 !== void 0) return reason22 instanceof Error ? reason22 : new Error(String(reason22));
   return /* @__PURE__ */ new Error("Client connection prematurely closed.");
 };
 var readBodyDirect = (request) => {
@@ -64451,10 +64489,10 @@ var requestPrototype = {
   get headers() {
     return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
   },
-  [abortRequest](reason2) {
-    if (this[abortReasonKey] === void 0) this[abortReasonKey] = reason2;
+  [abortRequest](reason22) {
+    if (this[abortReasonKey] === void 0) this[abortReasonKey] = reason22;
     const abortController = this[abortControllerKey];
-    if (abortController && !abortController.signal.aborted) abortController.abort(reason2);
+    if (abortController && !abortController.signal.aborted) abortController.abort(reason22);
   },
   [getAbortController]() {
     this[abortControllerKey] ||= new AbortController();
@@ -65098,8 +65136,8 @@ var upgradeWebSocket = defineWebSocketHelper(async (c, events, options) => {
     ws.on("message", bufferMessage);
     const ctx = {
       binaryType: "arraybuffer",
-      close(code, reason2) {
-        ws.close(code, reason2);
+      close(code, reason22) {
+        ws.close(code, reason22);
       },
       protocol: ws.protocol,
       raw: ws,
@@ -65129,11 +65167,11 @@ var upgradeWebSocket = defineWebSocketHelper(async (c, events, options) => {
     ws.on("message", (data, isBinary) => {
       handleMessage(data, isBinary);
     });
-    ws.on("close", (code, reason2) => {
+    ws.on("close", (code, reason22) => {
       try {
         events?.onClose?.(new CloseEvent("close", {
           code,
-          reason: reason2.toString()
+          reason: reason22.toString()
         }), ctx);
       } catch (e) {
         (options?.onError ?? console.error)(e);
@@ -65757,9 +65795,9 @@ function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader
     } }));
   }
 }
-function splitLines(text2) {
-  const hasTrailingNl = text2.endsWith("\n");
-  const result = text2.split("\n").map((line) => line + "\n");
+function splitLines(text22) {
+  const hasTrailingNl = text22.endsWith("\n");
+  const result = text22.split("\n").map((line) => line + "\n");
   if (hasTrailingNl) {
     result.pop();
   } else {
@@ -65769,26 +65807,26 @@ function splitLines(text2) {
 }
 var CHARS_PER_TOKEN = 4;
 var HELD = 1024 * 1024;
-function cut(text2, max) {
-  if (text2.length <= max) return text2;
+function cut(text22, max) {
+  if (text22.length <= max) return text22;
   const half = Math.max(1, Math.floor(max / 2));
-  const head = text2.slice(0, half).replace(/[\uD800-\uDBFF]$/, "");
-  const tail = text2.slice(-half).replace(/^[\uDC00-\uDFFF]/, "");
+  const head = text22.slice(0, half).replace(/[\uD800-\uDBFF]$/, "");
+  const tail = text22.slice(-half).replace(/^[\uDC00-\uDFFF]/, "");
   return `${head}
-\u2026 ${text2.length - head.length - tail.length} characters cut \u2026
+\u2026 ${text22.length - head.length - tail.length} characters cut \u2026
 ${tail}`;
 }
 var Pending = class {
   #head = "";
   #tail = "";
   #dropped = 0;
-  add(text2) {
+  add(text22) {
     const room = HELD / 2 - this.#head.length;
     if (room > 0) {
-      this.#head += text2.slice(0, room);
-      text2 = text2.slice(room);
+      this.#head += text22.slice(0, room);
+      text22 = text22.slice(room);
     }
-    this.#tail += text2;
+    this.#tail += text22;
     const over = this.#tail.length - HELD / 2;
     if (over > 0) {
       this.#tail = this.#tail.slice(over);
@@ -65797,13 +65835,13 @@ var Pending = class {
   }
   /** What is pending, leaving nothing. */
   take() {
-    const text2 = this.#dropped ? `${this.#head}
+    const text22 = this.#dropped ? `${this.#head}
 \u2026 ${this.#dropped} characters cut \u2026
 ${this.#tail}` : this.#head + this.#tail;
     this.#head = "";
     this.#tail = "";
     this.#dropped = 0;
-    return text2;
+    return text22;
   }
 };
 var MIN_YIELD_MS = 250;
@@ -65885,9 +65923,9 @@ var Sessions = class {
     ]) {
       const decoder = new StringDecoder("utf8");
       stream.on("data", (chunk) => {
-        const text2 = decoder.write(chunk);
-        pending.add(text2);
-        if (text2) this.#emit({ type: "output", id, stream: name, text: text2 });
+        const text22 = decoder.write(chunk);
+        pending.add(text22);
+        if (text22) this.#emit({ type: "output", id, stream: name, text: text22 });
       });
     }
     child.stdin.on("error", () => {
@@ -65980,6 +66018,7 @@ var refusing = async (work) => {
     throw new ExecRefused(reason(error62));
   }
 };
+var foldersFirst = (a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name);
 async function inside(root, path) {
   const refused2 = () => new ExecRefused(`${path} is outside the workspace.`);
   const wanted = resolve(root, path);
@@ -65994,26 +66033,33 @@ async function inside(root, path) {
         () => false
       ))
         throw refused2();
-      const above = dirname2(at);
+      const above = dirname(at);
       if (above === at) throw refused2();
-      return join3(await real(above), basename(at));
+      return join4(await real(above), basename(at));
     }
   };
   const found = await real(wanted);
   if (found !== root && !found.startsWith(root + sep2)) throw refused2();
   return found;
 }
+async function aFile(path, given) {
+  const found = await stat(path);
+  if (found.isDirectory()) throw new ExecRefused(`${given} is a folder.`);
+  if (!found.isFile()) throw new ExecRefused(`${given} isn't a file that can be read.`);
+  return found;
+}
 function createFiles(root) {
   const at = (path) => inside(root, path);
-  const text2 = async (path) => {
+  const text22 = async (path, given) => {
+    await aFile(path, given);
     const bytes = await readFile(path);
-    if (bytes.includes(0)) throw new ExecRefused(`${path} is a binary file.`);
+    if (bytes.includes(0)) throw new ExecRefused(`${given} is a binary file.`);
     return bytes.toString("utf8");
   };
   return {
     /** Numbered lines of a file. */
     read: (input2) => refusing(async () => {
-      const lines = (await text2(await at(input2.path))).split("\n");
+      const lines = (await text22(await at(input2.path), input2.path)).split("\n");
       const first = Math.max(input2.offset ?? 1, 1);
       const shown = lines.slice(first - 1, first - 1 + (input2.limit ?? DEFAULT_LINES)).map((line, i) => `${first + i}	${cut(line, MAX_LINE_CHARS)}`);
       const last = first + shown.length - 1;
@@ -66024,13 +66070,11 @@ ${cut(shown.join("\n"), MAX_READ_CHARS)}`;
     list: (input2) => refusing(async () => {
       const folder = await at(input2.path ?? ".");
       const entries = await readdir(folder, { withFileTypes: true });
-      entries.sort(
-        (a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name)
-      );
+      entries.sort(foldersFirst);
       const lines = await Promise.all(
         entries.slice(0, MAX_ENTRIES).map(async (entry) => {
           if (entry.isDirectory()) return `${entry.name}/`;
-          const { size } = await lstat(join3(folder, entry.name));
+          const { size } = await lstat(join4(folder, entry.name));
           return `${entry.name}	${size}`;
         })
       );
@@ -66050,7 +66094,7 @@ ${cut(shown.join("\n"), MAX_READ_CHARS)}`;
       });
       if (found && found.size > MAX_EDIT_BYTES)
         throw new ExecRefused(`${input2.path} is too large to edit here.`);
-      const before = found ? await text2(path) : "";
+      const before = found ? await text22(path, input2.path) : "";
       let after;
       if (input2.old_text === "") {
         if (before !== "")
@@ -66067,9 +66111,10 @@ ${cut(shown.join("\n"), MAX_READ_CHARS)}`;
         after = before.split(input2.old_text).join(input2.new_text);
       }
       if (after === before) throw new ExecRefused("That edit changes nothing.");
-      const temporary = join3(dirname2(path), `.agentexec-${randomBytes2(6).toString("hex")}`);
+      const temporary = join4(dirname(path), `.agentexec-${randomBytes2(6).toString("hex")}`);
       try {
         await writeFile(temporary, after, found ? { mode: found.mode } : {});
+        if (found) await chmod(temporary, found.mode & 511);
         await rename(temporary, path);
       } catch (error62) {
         await rm(temporary, { force: true });
@@ -66084,32 +66129,18 @@ var DEADLINE_MS = 2e4;
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 var MAX_LINE_CHARS2 = 500;
 var DEFAULT_MATCHES = 200;
+var MAX_CHANGES = 1e3;
 var SKIPPED = /* @__PURE__ */ new Set([".git", "node_modules"]);
-function run(job) {
-  const start = resolve2(job.root, job.path ?? ".");
-  const pattern = job.regex ? job.pattern : job.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const matcher = new RegExp(pattern, job.ignore_case ? "i" : "");
-  const limit = job.limit ?? DEFAULT_MATCHES;
-  const out = [];
-  const name = (path) => relative(job.root, path) || path;
-  const scan = (file2) => {
-    if (statSync(file2).size > MAX_FILE_BYTES) return;
-    const bytes = readFileSync(file2);
-    if (bytes.includes(0)) return;
-    bytes.toString("utf8").split("\n").forEach((line, i) => {
-      if (out.length <= limit && matcher.test(line))
-        out.push(`${name(file2)}:${i + 1}:${line.slice(0, MAX_LINE_CHARS2)}`);
-    });
-  };
+function eachFile(start, visit2) {
   const walk = (folder, rules) => {
     let here = rules;
     try {
-      const own22 = (0, import_ignore.default)().add(readFileSync(join22(folder, ".gitignore"), "utf8"));
-      here = [...rules, { base: folder, ignore: own22 }];
+      const own22 = join22(folder, ".gitignore");
+      if (statSync(own22).isFile())
+        here = [...rules, { base: folder, ignore: (0, import_ignore.default)().add(readFileSync(own22, "utf8")) }];
     } catch {
     }
     for (const entry of readdirSync(folder, { withFileTypes: true })) {
-      if (out.length > limit) return;
       if (SKIPPED.has(entry.name) || entry.isSymbolicLink()) continue;
       const path = join22(folder, entry.name);
       const suffix = entry.isDirectory() ? "/" : "";
@@ -66118,30 +66149,78 @@ function run(job) {
       );
       if (ignored) continue;
       try {
-        if (entry.isDirectory()) walk(path, here);
-        else if (entry.isFile()) scan(path);
+        const carryOn = entry.isDirectory() ? walk(path, here) : !entry.isFile() || visit2(path);
+        if (!carryOn) return false;
       } catch {
       }
     }
+    return true;
   };
-  if (statSync(start).isDirectory()) walk(start, []);
+  walk(start, []);
+}
+function searched(job) {
+  const start = resolve2(job.root, job.path ?? ".");
+  const pattern = job.regex ? job.pattern : job.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const matcher = new RegExp(pattern, job.ignore_case ? "i" : "");
+  const limit = job.limit ?? DEFAULT_MATCHES;
+  const out = [];
+  const name = (path) => relative(job.root, path) || path;
+  const scan = (file2) => {
+    const found = statSync(file2);
+    if (!found.isFile() || found.size > MAX_FILE_BYTES) return;
+    const bytes = readFileSync(file2);
+    if (bytes.includes(0)) return;
+    bytes.toString("utf8").split("\n").forEach((line, i) => {
+      if (out.length <= limit && matcher.test(line))
+        out.push(`${name(file2)}:${i + 1}:${line.slice(0, MAX_LINE_CHARS2)}`);
+    });
+  };
+  if (statSync(start).isDirectory())
+    eachFile(start, (file2) => {
+      scan(file2);
+      return out.length <= limit;
+    });
   else scan(start);
   const more = out.length > limit;
   return (more ? [...out.slice(0, limit), `\u2026 more than ${limit} matches`] : out).join("\n");
 }
-async function search(root, input2) {
-  const path = await inside(root, input2.path ?? ".");
+function changed(job) {
+  const changes = [];
+  let more = false;
+  const newest = () => {
+    changes.sort(
+      (a, b) => b.modifiedAt.localeCompare(a.modifiedAt) || a.path.localeCompare(b.path)
+    );
+    if (changes.length <= MAX_CHANGES) return;
+    more = true;
+    changes.length = MAX_CHANGES;
+  };
+  eachFile(job.root, (file2) => {
+    const { mtime, size } = statSync(file2);
+    if (mtime.getTime() > job.since) {
+      changes.push({
+        path: relative(job.root, file2).split(sep22).join("/"),
+        size,
+        modifiedAt: mtime.toISOString()
+      });
+      if (changes.length >= 2 * MAX_CHANGES) newest();
+    }
+    return true;
+  });
+  newest();
+  return { changes, more };
+}
+function onThread(job, what) {
   return new Promise((done, failed) => {
-    const workerData2 = { ...input2, path, root, agentexecSearch: true };
-    const worker = new Worker(fileURLToPath2(import.meta.url), { workerData: workerData2 });
+    const worker = new Worker(fileURLToPath2(import.meta.url), { workerData: job });
     const timer = setTimeout(() => {
       void worker.terminate();
-      failed(new ExecRefused(`That search took over ${DEADLINE_MS / 1e3} s, so it was stopped.`));
+      failed(new ExecRefused(`${what} took over ${DEADLINE_MS / 1e3} s, so it was stopped.`));
     }, DEADLINE_MS);
-    worker.once("message", (text2) => {
+    worker.once("message", (answer) => {
       clearTimeout(timer);
       void worker.terminate();
-      done(text2);
+      done(answer);
     });
     worker.once("error", (error62) => {
       clearTimeout(timer);
@@ -66149,8 +66228,136 @@ async function search(root, input2) {
     });
   });
 }
-if (!isMainThread && workerData?.agentexecSearch)
-  parentPort?.postMessage(run(workerData));
+async function search(root, input2) {
+  const path = await inside(root, input2.path ?? ".");
+  return onThread({ ...input2, path, root, agentexecSearch: true }, "That search");
+}
+function changedSince(root, since) {
+  return onThread({ root, since, agentexecSearch: true }, "Looking for what changed");
+}
+if (!isMainThread && workerData?.agentexecSearch) {
+  const job = workerData;
+  parentPort?.postMessage("since" in job ? changed(job) : searched(job));
+}
+var MAX_READ_BYTES = 1024 * 1024;
+function createHostFiles(root, level) {
+  const uploads = /* @__PURE__ */ new Set();
+  let closes = 0;
+  const files = {
+    list: (path = ".") => refusing(async () => {
+      const folder = await inside(root, path);
+      const found = await readdir2(folder, { withFileTypes: true });
+      found.sort(foldersFirst);
+      const entries = await Promise.all(
+        found.slice(0, MAX_ENTRIES).map(async (entry) => {
+          const own22 = await lstat2(join3(folder, entry.name)).catch(() => void 0);
+          return own22 && {
+            name: entry.name,
+            kind: entry.isDirectory() ? "folder" : entry.isSymbolicLink() ? "link" : "file",
+            size: own22.size,
+            modifiedAt: own22.mtime.toISOString()
+          };
+        })
+      );
+      return {
+        entries: entries.filter((entry) => entry !== void 0),
+        more: found.length > MAX_ENTRIES
+      };
+    }),
+    read: (path, offset, length) => refusing(async () => {
+      if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(length) || length < 1 || length > MAX_READ_BYTES)
+        throw new ExecRefused("A read starts at 0 or later and takes 1 to 1,048,576 bytes.");
+      const real = await inside(root, path);
+      const found = await aFile(real, path);
+      const file2 = await open2(real, "r");
+      try {
+        const bytes = Buffer.alloc(Math.max(0, Math.min(length, found.size - offset)));
+        const { bytesRead } = await file2.read(bytes, 0, bytes.length, offset);
+        return {
+          bytes: bytes.subarray(0, bytesRead),
+          size: found.size,
+          modifiedAt: found.mtime.toISOString()
+        };
+      } finally {
+        await file2.close();
+      }
+    }),
+    changed: (since) => refusing(async () => {
+      const from = since.getTime();
+      if (Number.isNaN(from)) throw new ExecRefused("That isn't a time.");
+      return changedSince(root, from);
+    }),
+    upload: (path) => refusing(async () => {
+      if (level === "read") throw new ExecRefused("Files here can be read, not written.");
+      const opening = closes;
+      const target = await inside(root, path);
+      const before = await stat2(target).catch((error62) => {
+        if (error62.code === "ENOENT") return void 0;
+        throw error62;
+      });
+      if (before?.isDirectory()) throw new ExecRefused(`${path} is a folder.`);
+      await stat2(dirname2(target));
+      const temporary = join3(dirname2(target), `.agentexec-${randomBytes3(6).toString("hex")}`);
+      const file2 = await open2(temporary, "wx");
+      const discard = async () => {
+        await file2.close().catch(() => {
+        });
+        await rm2(temporary, { force: true });
+      };
+      let ended = false;
+      let written = Promise.resolve();
+      const end2 = () => {
+        if (ended) throw new ExecRefused("That upload has ended.");
+        ended = true;
+        uploads.delete(upload);
+      };
+      const upload = {
+        write: (bytes) => refusing(async () => {
+          if (ended) throw new ExecRefused("That upload has ended.");
+          written = written.then(() => file2.appendFile(bytes));
+          await written;
+        }),
+        finish: () => refusing(async () => {
+          end2();
+          try {
+            await written;
+            await file2.close();
+            await rename2(temporary, target);
+          } catch (error62) {
+            await discard();
+            throw error62;
+          }
+          const after = await stat2(target);
+          return { size: after.size, modifiedAt: after.mtime.toISOString() };
+        }),
+        abort: () => refusing(async () => {
+          if (ended) return;
+          end2();
+          await written.catch(() => {
+          });
+          await discard();
+        })
+      };
+      try {
+        if (before) await file2.chmod(before.mode & 511);
+        if (closes !== opening) throw new ExecRefused("It closed before that upload began.");
+      } catch (error62) {
+        await discard();
+        throw error62;
+      }
+      uploads.add(upload);
+      return upload;
+    })
+  };
+  return {
+    files,
+    /** Give up every upload still open, and any that is opening. */
+    close: async () => {
+      closes++;
+      await Promise.all([...uploads].map((upload) => upload.abort()));
+    }
+  };
+}
 var text = (value) => ({ content: [{ type: "text", text: value }] });
 var refused = (error62) => {
   if (!(error62 instanceof ExecRefused)) throw error62;
@@ -66271,7 +66478,7 @@ function createServer2(root, sessions, version22, level) {
     );
   return server;
 }
-var VERSION = "0.0.3";
+var VERSION = "0.0.4";
 function createAgentExec(options) {
   const root = realpathSync(resolve3(options.workspace));
   const level = options.level ?? "read";
@@ -66283,6 +66490,7 @@ function createAgentExec(options) {
       } catch {
       }
   });
+  const host = createHostFiles(root, level);
   return {
     async handle(request, response, body) {
       const server = createServer2(root, sessions, VERSION, level);
@@ -66298,23 +66506,46 @@ function createAgentExec(options) {
       listeners.add(listener);
       return () => void listeners.delete(listener);
     },
-    close: () => sessions.stopAll()
+    files: host.files,
+    async close() {
+      await Promise.all([sessions.stopAll(), host.close()]);
+    }
   };
 }
 
 // src/screencast.ts
+var FIRST_FRAME_MS = 500;
+var RESTARTS = 3;
 async function startScreencast(page, onFrame) {
-  await page.screencast.start({
+  let seen = false;
+  let stopped = false;
+  const start = () => page.screencast.start({
     quality: 70,
-    onFrame: ({ data, viewportWidth, viewportHeight }) => onFrame({ data, width: viewportWidth, height: viewportHeight })
-  });
-  return () => page.screencast.stop().catch(() => {
+    onFrame: ({ data, viewportWidth, viewportHeight }) => {
+      seen = true;
+      onFrame({ data, width: viewportWidth, height: viewportHeight });
+    }
   });
+  await start();
+  void (async () => {
+    for (let left = RESTARTS; left > 0; left--) {
+      await new Promise((done) => setTimeout(done, FIRST_FRAME_MS).unref());
+      if (seen || stopped) return;
+      await page.screencast.stop().catch(() => {
+      });
+      if (stopped) return;
+      if (!await start().then(() => true).catch(() => false))
+        return;
+    }
+  })();
+  return async () => {
+    stopped = true;
+    await page.screencast.stop().catch(() => {
+    });
+  };
 }
 
 // src/browser-live.ts
-var WAIT_MS = 25e3;
-var IDLE_MS = 6e4;
 var TITLE_CHECK_MS = 1e3;
 var STEP_MS = 2e3;
 var MAX_BUFFERED = 4 * 1024 * 1024;
@@ -66322,269 +66553,292 @@ var sleep3 = (ms) => new Promise((done) => setTimeout(done, ms));
 var within = (work, ms) => Promise.race([work, sleep3(ms).then(() => void 0)]);
 var BrowserLive = class {
   #endpoint;
-  #sockets = /* @__PURE__ */ new Map();
-  #viewer;
+  #viewers = /* @__PURE__ */ new Map();
+  #client;
   #context;
   #ids = /* @__PURE__ */ new Map();
   #nextId = 1;
-  #shown;
-  #stopCast;
-  #size = { width: 0, height: 0 };
-  #dialog;
-  #chooser;
-  #choice;
-  #swallowUp = false;
-  #driver;
-  #lastInput = 0;
-  #agentWaiting = 0;
-  #answeredChooser = false;
+  #casts = /* @__PURE__ */ new Map();
+  /** A page's cast that is still stopping, which its next one waits for. */
+  #stopping = /* @__PURE__ */ new Map();
+  #dialogs = /* @__PURE__ */ new Map();
+  #choosers = /* @__PURE__ */ new Map();
+  /** The agent's MCP sessions seen so far. */
+  #sessions = /* @__PURE__ */ new Set();
+  /** Those still to be told that a person answered a file chooser. */
+  #owed = /* @__PURE__ */ new Set();
   /** The tabs last sent, to send them again only when something about them changed. */
   #lastTabs = "";
   #titles;
   #checking = false;
-  #steps = Promise.resolve();
+  /** Counts each time everyone has left, so a connection begun before that knows it is stale. */
+  #ended = 0;
   constructor(endpoint) {
     this.#endpoint = endpoint;
   }
   // ---- The agent's side
-  async wait() {
-    if (!this.#held()) return void 0;
-    this.#agentWaiting++;
-    this.#announceDriver();
-    try {
-      const deadline = Date.now() + WAIT_MS;
-      while (this.#held() && Date.now() < deadline) await sleep3(200);
-      return this.#held() ? "A person has the browser now, so this didn't run. Try again later." : "A person used the browser, so this didn't run and the page may have changed. Take a new snapshot before you act.";
-    } finally {
-      this.#agentWaiting--;
-      this.#announceDriver();
-    }
+  takeAnsweredChooser(session) {
+    this.#sessions.add(session);
+    return this.#owed.delete(session);
   }
-  takeAnsweredChooser() {
-    const answered2 = this.#answeredChooser;
-    this.#answeredChooser = false;
-    return answered2;
+  sessionEnded(session) {
+    this.#sessions.delete(session);
+    this.#owed.delete(session);
   }
-  agentAnswered() {
-    this.#dialog = void 0;
-    this.#chooser = void 0;
-    this.#broadcast({ type: "dialog", open: false });
-    this.#broadcast({ type: "file-chooser", open: false });
+  agentAnsweredChooser() {
+    this.#choosers.clear();
+    for (const ws of this.#viewers.keys()) this.#send(ws, { type: "file-chooser", open: false });
   }
   // ---- The person's side
   open(ws, mode) {
-    this.#sockets.set(ws, mode);
-    if (mode === "operate") {
-      this.#driver = ws;
-      this.#lastInput = Date.now();
-    }
+    const viewer = { mode, chose: false, swallowUp: false, steps: Promise.resolve() };
+    this.#viewers.set(ws, viewer);
     ws.on("close", () => this.#left(ws));
     ws.on("message", (data, binary) => {
-      if (binary || this.#sockets.get(ws) !== "operate") return;
+      if (binary || viewer.mode !== "operate") return;
       let message;
       try {
         message = JSON.parse(data.toString());
       } catch {
         return;
       }
-      this.#input(ws, message);
+      this.#input(ws, viewer, message);
     });
     this.#begin().then(
-      () => this.#greet(ws),
+      // Unless it chose a tab while this was starting, it is shown the newest.
+      () => viewer.chose ? void 0 : this.#show(ws, this.#newest()),
       () => ws.close(1011, "The browser can't be reached.")
     );
   }
   async close() {
-    for (const ws of this.#sockets.keys()) ws.close(1001, "It stopped.");
+    for (const ws of this.#viewers.keys()) ws.close(1001, "It stopped.");
     await this.#end();
   }
-  #held() {
-    return this.#driver !== void 0 && Date.now() - this.#lastInput < IDLE_MS;
-  }
   #send(ws, message) {
     if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(message));
   }
-  #broadcast(message) {
-    for (const ws of this.#sockets.keys()) this.#send(ws, message);
+  /** The sockets shown a page. */
+  #shownTo(page) {
+    return [...this.#viewers].filter(([, viewer]) => viewer.shown === page).map(([ws]) => ws);
   }
-  #announceDriver() {
-    for (const ws of this.#sockets.keys())
-      this.#send(ws, {
-        type: "driver",
-        you: ws === this.#driver && this.#held(),
-        held: this.#held(),
-        agentWaiting: this.#agentWaiting > 0
-      });
+  #newest() {
+    return this.#context?.pages().at(-1);
   }
   async #begin() {
-    this.#viewer ??= (async () => {
-      const viewer = await playwright().chromium.connect(await this.#endpoint);
-      const context = viewer.contexts()[0] ?? await viewer.newContext();
+    this.#client ??= (async () => {
+      const ended = this.#ended;
+      const client = await playwright().chromium.connect(await this.#endpoint);
+      const context = client.contexts()[0] ?? await client.newContext();
+      if (ended !== this.#ended) return client;
       this.#context = context;
       for (const page of context.pages()) this.#track(page);
       context.on("page", (page) => {
         this.#track(page);
-        void this.#show(page);
+        for (const [ws, viewer] of this.#viewers)
+          if (!viewer.chose || !viewer.shown) void this.#show(ws, page);
+        void this.#tabs();
       });
-      await this.#show(context.pages().at(-1) ?? await context.newPage());
-      this.#titles = setInterval(() => void this.#checkTabs(), TITLE_CHECK_MS);
-      return viewer;
+      if (context.pages().length === 0) await context.newPage();
+      if (ended === this.#ended)
+        this.#titles = setInterval(() => void this.#checkTabs(), TITLE_CHECK_MS);
+      return client;
     })();
-    await this.#viewer;
+    await this.#client;
   }
+  /** Everyone has left. All of it is forgotten at once, so a socket that opens next starts anew. */
   async #end() {
-    const viewer = this.#viewer;
-    this.#viewer = void 0;
+    const client = this.#client;
+    const casts = [...this.#casts.values()];
+    this.#ended++;
+    this.#client = void 0;
+    this.#context = void 0;
     clearInterval(this.#titles);
     this.#titles = void 0;
     this.#lastTabs = "";
-    await this.#stopCast?.();
-    this.#stopCast = void 0;
-    this.#shown = void 0;
+    this.#casts.clear();
+    this.#stopping.clear();
     this.#ids.clear();
-    await (await viewer?.catch(() => void 0))?.close().catch(() => {
+    this.#dialogs.clear();
+    this.#choosers.clear();
+    await Promise.all(casts.map((cast) => cast.stop.then((stop) => stop?.()).catch(() => {
+    })));
+    await (await client?.catch(() => void 0))?.close().catch(() => {
     });
   }
   #left(ws) {
-    this.#sockets.delete(ws);
-    if (this.#driver === ws) {
-      this.#driver = void 0;
-      this.#announceDriver();
-    }
-    if (this.#sockets.size === 0) void this.#end();
-  }
-  async #greet(ws) {
-    await this.#tabs(ws);
-    if (this.#size.width) this.#send(ws, { type: "viewport", ...this.#size });
-    if (this.#dialog)
-      this.#send(ws, {
-        type: "dialog",
-        open: true,
-        kind: this.#dialog.type(),
-        message: this.#dialog.message()
-      });
-    if (this.#chooser)
-      this.#send(ws, { type: "file-chooser", open: true, multiple: this.#chooser.isMultiple() });
-    this.#announceDriver();
+    const shown = this.#viewers.get(ws)?.shown;
+    this.#viewers.delete(ws);
+    if (this.#viewers.size === 0) return void this.#end();
+    if (shown) void this.#uncast(shown);
   }
   #track(page) {
     if (this.#ids.has(page)) return;
     this.#ids.set(page, this.#nextId++);
     page.on("dialog", (dialog) => {
-      this.#dialog = dialog;
-      this.#broadcast({
-        type: "dialog",
-        open: true,
-        kind: dialog.type(),
-        message: dialog.message(),
-        ...dialog.defaultValue() ? { defaultValue: dialog.defaultValue() } : {}
-      });
+      this.#dialogs.set(page, dialog);
+      for (const ws of this.#shownTo(page)) this.#tellDialog(ws, page);
+    });
+    page.on("dialogclosed", () => {
+      this.#dialogs.delete(page);
+      for (const ws of this.#shownTo(page)) this.#tellDialog(ws, page);
     });
     page.on("filechooser", (chooser) => {
-      this.#chooser = chooser;
-      this.#broadcast({ type: "file-chooser", open: true, multiple: chooser.isMultiple() });
+      this.#choosers.set(page, chooser);
+      for (const ws of this.#shownTo(page)) this.#tellChooser(ws, page);
     });
     page.on("framenavigated", (frame) => {
       if (frame === page.mainFrame()) void this.#tabs();
     });
     page.on("close", () => {
       this.#ids.delete(page);
-      if (this.#shown === page) void this.#show(this.#context?.pages().at(-1));
-      else void this.#tabs();
+      this.#dialogs.delete(page);
+      this.#choosers.delete(page);
+      this.#casts.delete(page);
+      this.#stopping.delete(page);
+      for (const ws of this.#shownTo(page)) void this.#show(ws, this.#newest());
+      void this.#tabs();
     });
   }
-  /** Which page the frames are of: the newest by default, or the one the person picked. */
-  async #show(page) {
-    if (page === this.#shown) return;
-    await this.#stopCast?.();
-    this.#stopCast = void 0;
-    this.#shown = page;
-    this.#choice = void 0;
+  #tellDialog(ws, page) {
+    const dialog = this.#dialogs.get(page);
+    this.#send(
+      ws,
+      dialog ? {
+        type: "dialog",
+        open: true,
+        kind: dialog.type(),
+        message: dialog.message(),
+        ...dialog.defaultValue() ? { defaultValue: dialog.defaultValue() } : {}
+      } : { type: "dialog", open: false }
+    );
+  }
+  #tellChooser(ws, page) {
+    const chooser = this.#choosers.get(page);
+    this.#send(
+      ws,
+      chooser ? { type: "file-chooser", open: true, multiple: chooser.isMultiple() } : { type: "file-chooser", open: false }
+    );
+  }
+  /** The cast of a page, started if no socket was shown it yet. */
+  #cast(page) {
+    const running = this.#casts.get(page);
+    if (running) return running;
+    const onFrame = (frame) => {
+      const watching = this.#shownTo(page);
+      if (frame.width !== cast.size.width || frame.height !== cast.size.height) {
+        cast.size = { width: frame.width, height: frame.height };
+        for (const ws of watching) this.#send(ws, { type: "viewport", ...cast.size });
+      }
+      cast.last = frame.data;
+      for (const ws of watching)
+        if (ws.readyState === ws.OPEN && ws.bufferedAmount < MAX_BUFFERED) ws.send(frame.data);
+    };
+    const cast = {
+      size: { width: 0, height: 0 },
+      // A page has one screencast at a time, so this one starts once the last has stopped.
+      stop: (this.#stopping.get(page) ?? Promise.resolve()).then(() => startScreencast(page, onFrame)).catch(() => void 0)
+    };
+    this.#casts.set(page, cast);
+    return cast;
+  }
+  /** Stop casting a page no socket is shown any more. */
+  async #uncast(page) {
+    const cast = this.#casts.get(page);
+    if (!cast || this.#shownTo(page).length > 0) return;
+    this.#casts.delete(page);
+    const stopped = cast.stop.then((stop) => stop?.()).catch(() => {
+    });
+    this.#stopping.set(page, stopped);
+    await stopped;
+    if (this.#stopping.get(page) === stopped) this.#stopping.delete(page);
+  }
+  /** Change the page a socket is shown, and tell it what that page is waiting on. */
+  async #show(ws, page) {
+    const viewer = this.#viewers.get(ws);
+    if (!viewer || page && viewer.shown === page) return;
+    const before = viewer.shown;
+    viewer.shown = page;
+    viewer.choice = void 0;
+    viewer.swallowUp = false;
+    if (before) await this.#uncast(before);
+    if (this.#viewers.get(ws) !== viewer || viewer.shown !== page) return;
     if (page) {
-      this.#stopCast = await startScreencast(page, (frame) => {
-        if (frame.width !== this.#size.width || frame.height !== this.#size.height) {
-          this.#size = { width: frame.width, height: frame.height };
-          this.#broadcast({ type: "viewport", ...this.#size });
-        }
-        for (const ws of this.#sockets.keys())
-          if (ws.readyState === ws.OPEN && ws.bufferedAmount < MAX_BUFFERED) ws.send(frame.data);
-      }).catch(() => void 0);
+      const cast = this.#cast(page);
+      if (cast.size.width) this.#send(ws, { type: "viewport", ...cast.size });
+      if (cast.last && ws.readyState === ws.OPEN) ws.send(cast.last);
+      this.#tellDialog(ws, page);
+      this.#tellChooser(ws, page);
     }
-    await this.#tabs();
+    await this.#tabs(ws);
   }
   async #tabList() {
-    const tabs = await Promise.all(
+    return Promise.all(
       [...this.#ids].map(async ([page, id]) => ({
         id,
         url: page.url(),
         title: await within(page.title(), STEP_MS).catch(() => void 0) ?? ""
       }))
     );
-    return { type: "tabs", tabs, shown: (this.#shown && this.#ids.get(this.#shown)) ?? null };
   }
-  async #tabs(only) {
-    const message = await this.#tabList();
-    this.#lastTabs = JSON.stringify(message);
-    if (only) this.#send(only, message);
-    else this.#broadcast(message);
+  /** The tabs, to one socket or to all, each told which one it is shown. */
+  async #tabs(only, listed) {
+    const tabs = listed ?? await this.#tabList();
+    if (!only) this.#lastTabs = JSON.stringify(tabs);
+    for (const [ws, viewer] of this.#viewers)
+      if (!only || ws === only)
+        this.#send(ws, {
+          type: "tabs",
+          tabs,
+          shown: (viewer.shown && this.#ids.get(viewer.shown)) ?? null
+        });
   }
   /** Send the tabs again if anything about them changed, such as a title. */
   async #checkTabs() {
     if (this.#checking) return;
     this.#checking = true;
     try {
-      const message = await this.#tabList();
-      const text2 = JSON.stringify(message);
-      if (text2 === this.#lastTabs) return;
-      this.#lastTabs = text2;
-      this.#broadcast(message);
+      const tabs = await this.#tabList();
+      if (JSON.stringify(tabs) !== this.#lastTabs) await this.#tabs(void 0, tabs);
     } finally {
       this.#checking = false;
     }
   }
   /** Each step in order, none waiting on another for long: a dialog blocks the page's input. */
-  #step(work) {
-    this.#steps = this.#steps.then(() => within(work(), STEP_MS)).catch(() => {
+  #step(viewer, work) {
+    viewer.steps = viewer.steps.then(() => within(work(), STEP_MS)).catch(() => {
     });
   }
-  #input(ws, message) {
-    if (message.type === "release") {
-      if (this.#driver === ws) this.#driver = void 0;
-      return this.#announceDriver();
-    }
-    const changed = this.#driver !== ws || !this.#held();
-    this.#driver = ws;
-    this.#lastInput = Date.now();
-    if (changed) this.#announceDriver();
-    const page = this.#shown;
+  #input(ws, viewer, message) {
+    const page = viewer.shown;
     switch (message.type) {
       case "mouse":
         if (!page) return;
-        return this.#step(() => this.#mouse(page, message));
+        return this.#step(viewer, () => this.#mouse(ws, viewer, page, message));
       case "key":
         if (!page) return;
         return this.#step(
+          viewer,
           () => message.action === "down" ? page.keyboard.down(message.key) : page.keyboard.up(message.key)
         );
       case "text":
         if (!page) return;
-        return this.#step(() => page.keyboard.insertText(message.text));
+        return this.#step(viewer, () => page.keyboard.insertText(message.text));
       case "dialog": {
-        const dialog = this.#dialog;
-        this.#dialog = void 0;
-        this.#broadcast({ type: "dialog", open: false });
+        const dialog = page && this.#dialogs.get(page);
         if (!dialog) return;
         return this.#step(
+          viewer,
           () => message.accept ? dialog.accept(message.text ?? void 0) : dialog.dismiss()
         );
       }
       case "files": {
-        const chooser = this.#chooser;
-        this.#chooser = void 0;
-        this.#broadcast({ type: "file-chooser", open: false });
-        if (!chooser) return;
-        this.#answeredChooser = true;
+        const chooser = page && this.#choosers.get(page);
+        if (!page || !chooser) return;
+        this.#choosers.delete(page);
+        for (const socket of this.#shownTo(page)) this.#tellChooser(socket, page);
+        for (const session of this.#sessions) this.#owed.add(session);
         return this.#step(
+          viewer,
           () => chooser.setFiles(
             message.files.map((file2) => ({
               name: file2.name,
@@ -66595,16 +66849,16 @@ var BrowserLive = class {
         );
       }
       case "choice": {
-        const choice = this.#choice;
-        this.#choice = void 0;
+        const choice = viewer.choice;
+        viewer.choice = void 0;
         if (!choice) return;
-        return this.#step(() => choice.selectOption(message.values));
+        return this.#step(viewer, () => choice.selectOption(message.values));
       }
       case "tab":
-        return this.#step(() => this.#tab(message));
+        return this.#step(viewer, () => this.#tab(ws, viewer, message));
       case "navigate":
         if (!page) return;
-        return this.#step(async () => {
+        return this.#step(viewer, async () => {
           if (message.to === "back") await page.goBack();
           else if (message.to === "forward") await page.goForward();
           else if (message.to === "reload") await page.reload();
@@ -66612,15 +66866,15 @@ var BrowserLive = class {
         });
     }
   }
-  async #mouse(page, message) {
+  async #mouse(ws, viewer, page, message) {
     const { x, y } = message;
     if (message.action === "move") return page.mouse.move(x, y);
     if (message.action === "wheel")
       return page.mouse.wheel(message.deltaX ?? 0, message.deltaY ?? 0);
     const button = message.button ?? "left";
     if (message.action === "up") {
-      if (this.#swallowUp) {
-        this.#swallowUp = false;
+      if (viewer.swallowUp) {
+        viewer.swallowUp = false;
         return;
       }
       return page.mouse.up({ button });
@@ -66646,20 +66900,29 @@ var BrowserLive = class {
           ([px, py]) => document.elementFromPoint(px, py),
           [x, y]
         );
-        this.#choice = handle.asElement() ?? void 0;
-        this.#swallowUp = true;
-        return this.#broadcast({ type: "choice", ...choice });
+        viewer.choice = handle.asElement() ?? void 0;
+        viewer.swallowUp = true;
+        return this.#send(ws, { type: "choice", ...choice });
       }
     }
     await page.mouse.move(x, y);
     return page.mouse.down({ button });
   }
-  async #tab(message) {
+  /** Showing or opening a tab makes the socket's page its own from then on. */
+  async #tab(ws, viewer, message) {
     const byId = (id) => [...this.#ids].find(([, known]) => known === id)?.[0];
-    if (message.action === "show") return this.#show(byId(message.id));
     if (message.action === "close") return byId(message.id)?.close();
+    if (message.action === "show") {
+      const page2 = byId(message.id);
+      if (!page2) return;
+      viewer.chose = true;
+      return this.#show(ws, page2);
+    }
     const page = await this.#context?.newPage();
-    if (page && message.url) await page.goto(message.url).catch(() => {
+    if (!page) return;
+    viewer.chose = true;
+    await this.#show(ws, page);
+    if (message.url) await page.goto(message.url).catch(() => {
     });
   }
 };
@@ -66667,7 +66930,7 @@ var BrowserLive = class {
 // src/live.ts
 import { chmodSync, existsSync, statSync as statSync2 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { dirname as dirname3, join as join5 } from "node:path";
 
 // node_modules/ws/wrapper.mjs
 var import_stream2 = __toESM(require_stream(), 1);
@@ -66679,10 +66942,178 @@ var import_subprotocol = __toESM(require_subprotocol(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 
+// src/files-live.ts
+var MAX_PART = 1024 * 1024;
+var MAX_BUFFERED2 = 4 * 1024 * 1024;
+var MAX_UPLOADS = 64;
+var reason2 = (error62) => error62 instanceof Error ? error62.message : String(error62);
+var text2 = (value) => typeof value === "string";
+var whole = (value) => Number.isSafeInteger(value);
+var sleep4 = (ms) => new Promise((done) => setTimeout(done, ms));
+var FilesLive = class {
+  #files;
+  #sockets = /* @__PURE__ */ new Set();
+  /** One walk of the workspace at a time, however many ask. */
+  #walking = Promise.resolve();
+  /** How many files are part written, over every socket. */
+  #uploads = 0;
+  constructor(files) {
+    this.#files = files;
+  }
+  close() {
+    for (const ws of this.#sockets) ws.close(1001, "It stopped.");
+  }
+  open(ws, mode) {
+    this.#sockets.add(ws);
+    const uploads = /* @__PURE__ */ new Map();
+    let awaited;
+    let writing = Promise.resolve();
+    let waiting = 0;
+    let reading = Promise.resolve();
+    let closed = false;
+    const send2 = (answer) => {
+      if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(answer));
+    };
+    const refuse = (id, message) => send2({ type: "refused", id, message });
+    const giveUp = async (path) => {
+      const had = uploads.get(path);
+      if (!had) return;
+      uploads.delete(path);
+      this.#uploads--;
+      await had.upload.abort().catch(() => {
+      });
+    };
+    const drained = async () => {
+      while (!closed && ws.bufferedAmount > MAX_BUFFERED2) await sleep4(50);
+    };
+    const writePart = async (write, bytes) => {
+      const { id, path, offset, last } = write;
+      if (bytes.length !== write.length)
+        throw new Error(`It said ${write.length} bytes, and ${bytes.length} came.`);
+      if (offset === 0) {
+        await giveUp(path);
+        if (this.#uploads >= MAX_UPLOADS)
+          throw new Error(`${MAX_UPLOADS} files are part written here. Finish one first.`);
+        this.#uploads++;
+        try {
+          uploads.set(path, { upload: await this.#files.upload(path), size: 0 });
+        } catch (error62) {
+          this.#uploads--;
+          throw error62;
+        }
+      }
+      const file2 = uploads.get(path);
+      if (!file2 || file2.size !== offset)
+        throw new Error(`The next part of ${path} starts at ${file2?.size ?? 0}.`);
+      await file2.upload.write(bytes);
+      file2.size += bytes.length;
+      if (!last) return void 0;
+      uploads.delete(path);
+      this.#uploads--;
+      return { type: "written", id, path, size: (await file2.upload.finish()).size };
+    };
+    const inTurn = (work) => {
+      const done = reading.then(async () => {
+        await drained();
+        if (!closed) await work();
+      });
+      reading = done.catch(() => {
+      });
+      return done;
+    };
+    const handle = async (request) => {
+      const { id } = request;
+      switch (request.type) {
+        case "list": {
+          const path = request.path ?? ".";
+          if (!text2(path)) throw new Error("A path is text.");
+          return inTurn(
+            async () => send2({ type: "entries", id, path, ...await this.#files.list(path) })
+          );
+        }
+        case "read": {
+          const { path, offset, length } = request;
+          if (!text2(path)) throw new Error("A path is text.");
+          return inTurn(async () => {
+            const { bytes, size, modifiedAt } = await this.#files.read(path, offset, length);
+            if (ws.readyState !== ws.OPEN) return;
+            send2({ type: "data", id, path, offset, length: bytes.length, size, modifiedAt });
+            ws.send(bytes);
+          });
+        }
+        case "changed": {
+          const { since } = request;
+          if (!text2(since)) throw new Error("That isn't a time.");
+          const walked = this.#walking.then(
+            () => ws.readyState === ws.OPEN ? this.#files.changed(new Date(since)) : void 0
+          );
+          this.#walking = walked.catch(() => {
+          });
+          const found = await walked;
+          await drained();
+          if (found) send2({ type: "changes", id, since, ...found });
+          return;
+        }
+        case "write": {
+          awaited = "refused";
+          if (mode !== "operate") throw new Error("This socket watches: it can't write.");
+          const { path, offset, length, last } = request;
+          if (!text2(path) || !whole(offset) || offset < 0 || !whole(length) || length < 0 || length > MAX_PART || typeof last !== "boolean")
+            throw new Error(
+              "A write names a path, where it starts, 0 to 1,048,576 bytes, and last."
+            );
+          awaited = request;
+          return;
+        }
+        default:
+          throw new Error("That isn't something files@1 does.");
+      }
+    };
+    ws.on("close", () => {
+      closed = true;
+      this.#sockets.delete(ws);
+      void writing.finally(() => Promise.all([...uploads.keys()].map(giveUp)));
+    });
+    ws.on("message", (data, binary) => {
+      const write = awaited;
+      awaited = void 0;
+      if (binary) {
+        if (write === "refused") return;
+        if (!write) return ws.close(1008, "Those bytes belong to no write.");
+        waiting++;
+        ws.pause();
+        writing = writing.then(() => closed ? void 0 : writePart(write, data)).then(
+          (done) => done && send2(done),
+          async (error62) => {
+            await giveUp(write.path);
+            refuse(write.id, reason2(error62));
+          }
+        ).finally(() => {
+          if (--waiting === 0) ws.resume();
+        });
+        return;
+      }
+      if (write && write !== "refused") refuse(write.id, "Its bytes didn't follow it.");
+      let request;
+      try {
+        request = JSON.parse(data.toString());
+      } catch {
+        return refuse("", "That isn't JSON.");
+      }
+      const { id, type } = request ?? {};
+      if (type === "write") awaited = "refused";
+      if (!text2(id) || id.length < 1 || id.length > 64)
+        return refuse("", "Every request has an id of 1 to 64 characters.");
+      handle(request).catch((error62) => refuse(id, reason2(error62)));
+    });
+  }
+};
+
 // src/live.ts
 var PROTOCOLS = {
   commands: "commands@1",
   terminal: "pty@1",
+  files: "files@1",
   browser: "screencast@1"
 };
 var MAX_EVENTS = 2e3;
@@ -66691,20 +67122,21 @@ var OUTPUT = 48;
 var INPUT = 48;
 var RESIZE = 49;
 var sockets = new import_websocket_server.default({ noServer: true });
+var fileSockets = new import_websocket_server.default({ noServer: true, maxPayload: MAX_PART });
 var pty;
 var loadPty = () => {
   pty ??= (async () => {
-    const require2 = createRequire3(import.meta.url);
+    const require3 = createRequire3(import.meta.url);
     let loaded2;
     try {
-      loaded2 = require2("node-pty");
+      loaded2 = require3("node-pty");
     } catch {
       return "The terminal needs node-pty, which isn't installed with this service.";
     }
-    const root = dirname3(require2.resolve("node-pty/package.json"));
+    const root = dirname3(require3.resolve("node-pty/package.json"));
     for (const helper of [
-      join4(root, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper"),
-      join4(root, "build", "Release", "spawn-helper")
+      join5(root, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper"),
+      join5(root, "build", "Release", "spawn-helper")
     ])
       try {
         if (existsSync(helper) && (statSync2(helper).mode & 73) === 0) chmodSync(helper, 493);
@@ -66724,9 +67156,14 @@ var Live = class {
   #shell;
   #scrollback = "";
   #browser;
-  constructor(exec, workspace, terminal, browser) {
+  #files;
+  /** Whether a person may write files here: not where the agent can only read them. */
+  #writes;
+  constructor(exec, workspace, access, browser) {
     this.#workspace = workspace;
-    this.#terminal = terminal && exec !== void 0;
+    this.#terminal = access === "terminal" && exec !== void 0;
+    this.#files = exec && new FilesLive(exec.files);
+    this.#writes = access !== "read";
     this.#browser = browser;
     exec?.onCommand((event) => this.#heard(event));
   }
@@ -66744,6 +67181,8 @@ var Live = class {
         }
       );
     }
+    if (this.#files)
+      surfaces.push({ surface: "files", protocol: PROTOCOLS.files, operate: this.#writes });
     if (this.#browser)
       surfaces.push({ surface: "browser", protocol: PROTOCOLS.browser, operate: true });
     return surfaces;
@@ -66751,9 +67190,11 @@ var Live = class {
   /** Take an upgraded request as a socket on one surface. */
   open(surface, mode, request, socket, head) {
     socket.on("error", () => socket.destroy());
-    sockets.handleUpgrade(request, socket, head, (ws) => {
+    const server = surface === "files" ? fileSockets : sockets;
+    server.handleUpgrade(request, socket, head, (ws) => {
       ws.on("error", () => ws.terminate());
       if (surface === "commands") this.#watch(ws);
+      else if (surface === "files" && this.#files) this.#files.open(ws, mode);
       else if (surface === "browser" && this.#browser) this.#browser.open(ws, mode);
       else if (surface === "terminal") this.#attach(ws, mode).catch(() => ws.terminate());
       else ws.close(1011, `There's no ${surface} here.`);
@@ -66761,6 +67202,7 @@ var Live = class {
   }
   close() {
     void this.#browser?.close();
+    this.#files?.close();
     for (const ws of [...this.#watchers, ...this.#shells.keys()]) ws.close(1001, "It stopped.");
     this.#shell?.kill();
     this.#shell = void 0;
@@ -66826,14 +67268,14 @@ var Live = class {
 };
 
 // src/store.ts
-import { createHash, randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
+import { createHash, randomBytes as randomBytes4, timingSafeEqual } from "node:crypto";
 import { chmodSync as chmodSync2, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
-import { join as join5 } from "node:path";
-var newToken = () => randomBytes3(32).toString("base64url");
+import { join as join6 } from "node:path";
+var newToken = () => randomBytes4(32).toString("base64url");
 var digestOf = (token) => createHash("sha256").update(token).digest("hex");
 var sameToken = (token, digest) => timingSafeEqual(Buffer.from(digestOf(token), "hex"), Buffer.from(digest, "hex"));
-function writePrivate(file2, text2) {
-  writeFileSync(`${file2}.tmp`, text2, { mode: 384, flush: true });
+function writePrivate(file2, text3) {
+  writeFileSync(`${file2}.tmp`, text3, { mode: 384, flush: true });
   renameSync(`${file2}.tmp`, file2);
   chmodSync2(file2, 384);
 }
@@ -66843,7 +67285,7 @@ var privateFolder = (dir) => {
   return dir;
 };
 function controlToken(data) {
-  const file2 = join5(data, "control-token");
+  const file2 = join6(data, "control-token");
   try {
     return readFileSync2(file2, "utf8").trim();
   } catch (error62) {
@@ -66882,7 +67324,7 @@ var ProcessRuntime = class {
     let browser;
     let browserDown = false;
     if (spec.browser) {
-      const own3 = privateFolder(join6(folder, "browser"));
+      const own3 = privateFolder(join7(folder, "browser"));
       browser = new Browser(
         this.#config,
         own3,
@@ -66906,10 +67348,19 @@ var ProcessRuntime = class {
       browserLive = new BrowserLive(browser.endpoint);
       browser.gate = browserLive;
     }
-    const live = new Live(exec, spec.workspace, spec.access === "terminal", browserLive);
+    const live = new Live(exec, spec.workspace, spec.access, browserLive);
+    const surfaces = await live.surfaces();
     return {
       browserTools: browser?.tools ?? [],
-      surfaces: await live.surfaces(),
+      /** As they are now: a browser that has stopped can't be opened, and says so. */
+      get surfaces() {
+        return surfaces.map(
+          (one) => one.surface === "browser" && browserDown ? {
+            ...one,
+            unavailable: "Its browser has stopped. Stop the computer and start it again."
+          } : one
+        );
+      },
       openLive: async (surface, mode, request, socket, head) => live.open(surface, mode, request, socket, head),
       handle: async (endpoint, request, response) => {
         if (endpoint === "computer") return exec.handle(request, response);
@@ -66939,13 +67390,13 @@ async function serveInside(options) {
       ...options,
       ...options.access === "none" ? {} : { workspace: "/workspace" }
     },
-    privateFolder(join7(homedir(), ".agentcomputer")),
+    privateFolder(join8(homedir(), ".agentcomputer")),
     {
       log: (line) => process.stdout.write(`${line}
 `),
       // The service sees the container end, and shows the computer as failed.
-      failed: (reason2) => {
-        process.stderr.write(`${reason2}
+      failed: (reason3) => {
+        process.stderr.write(`${reason3}
 `);
         process.exit(1);
       }
@@ -66974,7 +67425,7 @@ async function serveInside(options) {
     socket.on("error", () => socket.destroy());
     const given = /^Bearer (\S+)$/.exec(request.headers.authorization ?? "")?.[1];
     const url3 = new URL(request.url ?? "/", "http://localhost");
-    const surface = /^\/live\/(commands|terminal|browser)$/.exec(url3.pathname)?.[1];
+    const surface = /^\/live\/(commands|terminal|files|browser)$/.exec(url3.pathname)?.[1];
     const mode = url3.searchParams.get("mode");
     if (!given || !sameToken(given, digest) || !surface || mode !== "watch" && mode !== "operate")
       return void socket.end("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
@@ -66989,7 +67440,7 @@ async function serveInside(options) {
 }
 
 // src/container.ts
-var run2 = promisify(execFile);
+var run = promisify(execFile);
 var START_MS2 = 6e4;
 var STOP_SECONDS = "5";
 var NOT_FORWARDED = /* @__PURE__ */ new Set([
@@ -67003,7 +67454,7 @@ var NOT_FORWARDED = /* @__PURE__ */ new Set([
 ]);
 async function docker(args, env = process.env) {
   try {
-    return (await run2("docker", args, { env, maxBuffer: 16 * 1024 * 1024 })).stdout.trim();
+    return (await run("docker", args, { env, maxBuffer: 16 * 1024 * 1024 })).stdout.trim();
   } catch (error62) {
     const { stderr, message } = error62;
     throw new Error(stderr?.trim() || message);
@@ -67018,7 +67469,7 @@ var UPGRADE_HEADERS = [
   "sec-websocket-protocol"
 ];
 var nameOf = (id) => `agentcomputer-${id}`;
-var sleep4 = (ms) => new Promise((done) => setTimeout(done, ms));
+var sleep5 = (ms) => new Promise((done) => setTimeout(done, ms));
 var ContainerRuntime = class {
   isolation = "container";
   #image;
@@ -67082,7 +67533,7 @@ var ContainerRuntime = class {
   }
   /** The token between the service and this container, which a restart has to find again. */
   #tokenIn(folder) {
-    const file2 = join8(folder, "inner-token");
+    const file2 = join9(folder, "inner-token");
     try {
       return readFileSync3(file2, "utf8");
     } catch {
@@ -67130,7 +67581,16 @@ var ContainerRuntime = class {
       throw error62;
     }
     return {
-      ...ready,
+      browserTools: ready.browserTools,
+      /** As they are now: nothing of a container that has stopped can be opened. */
+      get surfaces() {
+        return ready.surfaces.map(
+          (one) => ended ? {
+            ...one,
+            unavailable: "Its container has stopped. Stop the computer and start it again."
+          } : one
+        );
+      },
       stop,
       openLive: async (surface, mode, request, socket, head) => pipeUpgrade(
         Number(port),
@@ -67155,7 +67615,7 @@ var ContainerRuntime = class {
         if (answer.ok) return await answer.json();
       } catch {
       }
-      await sleep4(100);
+      await sleep5(100);
     }
     throw new Error("Its container didn't start. Its logs say why.");
   }
@@ -67212,7 +67672,7 @@ async function forward(url3, authorization, request, response) {
 }
 
 // src/handlers.ts
-var VERSION2 = "0.0.7";
+var VERSION2 = "0.0.8";
 function createHandlers(computers) {
   return {
     getInfo: async () => ({ version: VERSION2, isolation: computers.isolation }),
@@ -67761,9 +68221,9 @@ var Endpoint = class {
   async #call(name, args) {
     const client = await this.#connected();
     const result = await client.callTool({ name, arguments: args });
-    const text2 = result.content.map((block) => block.text ?? "").join("");
-    if (result.isError) throw new ComputerError(400, text2);
-    return { text: text2, structured: result.structuredContent };
+    const text3 = result.content.map((block) => block.text ?? "").join("");
+    if (result.isError) throw new ComputerError(400, text3);
+    return { text: text3, structured: result.structuredContent };
   }
   async text(name, args) {
     return (await this.#call(name, args)).text;
@@ -67798,8 +68258,8 @@ var INPUT2 = 48;
 var RESIZE2 = 49;
 var Pty = class {
   #open;
-  constructor(open3) {
-    this.#open = open3;
+  constructor(open4) {
+    this.#open = open4;
   }
   /** Attach to its shell, starting one if none is running. Every attachment shares it. */
   async connect(opts) {
@@ -67810,8 +68270,8 @@ var Pty = class {
       const frame = new Uint8Array(data);
       if (frame[0] === INPUT2) opts.onData(decoder.decode(frame.subarray(1), { stream: true }));
     });
-    const send2 = (type, text2) => {
-      const body = new TextEncoder().encode(text2);
+    const send2 = (type, text3) => {
+      const body = new TextEncoder().encode(text3);
       const frame = new Uint8Array(body.length + 1);
       frame[0] = type;
       frame.set(body, 1);
@@ -67828,9 +68288,9 @@ var Pty = class {
 var Commands = class {
   #endpoint;
   #open;
-  constructor(endpoint, open3) {
+  constructor(endpoint, open4) {
     this.#endpoint = endpoint;
-    this.#open = open3;
+    this.#open = open4;
   }
   /** Each of the agent's commands as it runs: the ones already heard first, then as they come. */
   async watch(onEvent) {
@@ -67897,16 +68357,16 @@ var Files = class {
   }
   /** A folder's entries, the first thousand. */
   async list(path = ".") {
-    const text2 = await this.#endpoint.text("list", { path });
-    return text2.split("\n").filter((line) => line.endsWith("/") || line.includes("	")).map((line) => {
+    const text3 = await this.#endpoint.text("list", { path });
+    return text3.split("\n").filter((line) => line.endsWith("/") || line.includes("	")).map((line) => {
       const [name = "", size] = line.split("	");
       return name.endsWith("/") ? { name: name.slice(0, -1), type: "dir" } : { name, type: "file", size: Number(size) };
     });
   }
   /** Lines matching text under a folder, as `path:line:text`. */
   async search(pattern, opts = {}) {
-    const text2 = await this.#endpoint.text("search", { pattern, ...opts });
-    return text2 ? text2.split("\n") : [];
+    const text3 = await this.#endpoint.text("search", { pattern, ...opts });
+    return text3 ? text3.split("\n") : [];
   }
 };
 var pathOf = (computerID) => ({ params: { path: { computerID } } });
@@ -67925,9 +68385,9 @@ var Computer = class _Computer {
     this.#token = token;
     this.#urls = info.endpoints;
     this.#computer = new Endpoint(info.endpoints.computer, token);
-    const open3 = (surface, mode) => this.liveSession(surface, mode);
-    this.commands = new Commands(this.#computer, open3);
-    this.pty = new Pty(open3);
+    const open4 = (surface, mode) => this.liveSession(surface, mode);
+    this.commands = new Commands(this.#computer, open4);
+    this.pty = new Pty(open4);
     this.files = new Files(this.#computer);
   }
   static async create(opts) {
@@ -68048,7 +68508,7 @@ import {
   STATUS_CODES as STATUS_CODES3
 } from "node:http";
 import { createServer as createTlsServer } from "node:https";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // node_modules/@modelcontextprotocol/server/dist/chunk-vYduTEsO.mjs
 var __create4 = Object.create;
@@ -71509,7 +71969,7 @@ var REQUEST_STATE_ONLY_LEG_PACING_MS3 = 250;
 function inputRequiredRoundsExceededMessage3(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
 }
-function sleep5(ms, signal) {
+function sleep6(ms, signal) {
   return new Promise((resolve6, reject) => {
     if (signal?.aborted) {
       reject(signal.reason instanceof SdkError3 ? signal.reason : new SdkError3(SdkErrorCode3.RequestTimeout, String(signal.reason)));
@@ -71533,7 +71993,7 @@ function linkedRoundAbort3(outer) {
   if (outer?.aborted) controller.abort(outer.reason);
   return {
     signal: controller.signal,
-    abort: (reason2) => controller.abort(reason2),
+    abort: (reason3) => controller.abort(reason3),
     dispose: () => outer?.removeEventListener("abort", onOuterAbort)
   };
 }
@@ -72328,8 +72788,8 @@ var Protocol3 = class {
         return;
       }
       if (options?.signal?.aborted) {
-        const reason2 = options.signal.reason;
-        throw reason2 instanceof SdkError3 ? reason2 : new SdkError3(SdkErrorCode3.RequestTimeout, String(reason2));
+        const reason3 = options.signal.reason;
+        throw reason3 instanceof SdkError3 ? reason3 : new SdkError3(SdkErrorCode3.RequestTimeout, String(reason3));
       }
       const requestAbort = codec2.era === MODERN_WIRE_REVISION3 && this._transport.hasPerRequestStream === true ? new AbortController() : void 0;
       const messageId = this._requestMessageId++;
@@ -72351,7 +72811,7 @@ var Protocol3 = class {
       }
       const outbound = this._envelopeOutbound(jsonrpcRequest);
       let responseReceived = false;
-      const cancel = (reason2) => {
+      const cancel = (reason3) => {
         if (responseReceived) return;
         this._progressHandlers.delete(messageId);
         if (requestAbort === void 0) {
@@ -72360,7 +72820,7 @@ var Protocol3 = class {
             method: "notifications/cancelled",
             params: {
               requestId: messageId,
-              reason: String(reason2)
+              reason: String(reason3)
             }
           }), {
             relatedRequestId,
@@ -72368,7 +72828,7 @@ var Protocol3 = class {
             onresumptiontoken
           }).catch((error62) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error62}`)));
         } else requestAbort.abort();
-        reject(reason2 instanceof SdkError3 ? reason2 : new SdkError3(SdkErrorCode3.RequestTimeout, String(reason2)));
+        reject(reason3 instanceof SdkError3 ? reason3 : new SdkError3(SdkErrorCode3.RequestTimeout, String(reason3)));
       };
       this._responseHandlers.set(messageId, (response) => {
         if (options?.signal?.aborted) return;
@@ -76706,7 +77166,7 @@ var require_core$33 = /* @__PURE__ */ __commonJSMin3(((exports) => {
     }
     errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
       if (!errors || errors.length === 0) return "No errors";
-      return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text2, msg) => text2 + separator + msg);
+      return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text3, msg) => text3 + separator + msg);
     }
     $dataMetaSchema(metaSchema, keywordsJsonPointers) {
       const rules = this.RULES.all;
@@ -80506,7 +80966,7 @@ var LegacyInputRequiredShim2 = class {
         } finally {
           roundAbort.dispose();
         }
-      } else await sleep5(REQUEST_STATE_ONLY_LEG_PACING_MS3, outerSignal);
+      } else await sleep6(REQUEST_STATE_ONLY_LEG_PACING_MS3, outerSignal);
       let ctxNext = {
         ...ctx,
         mcpReq: {
@@ -81852,21 +82312,21 @@ async function readRequestBody2(request, maxBytes = DEFAULT_MAX_REQUEST_BODY_SIZ
   const reader = request.body.getReader();
   const decoder = new TextDecoder();
   let received = 0;
-  let text2 = "";
+  let text3 = "";
   try {
     for (; ; ) {
       const { done, value } = await reader.read();
       if (done) break;
       received += value.byteLength;
       if (received > maxBytes) return { tooLarge: true };
-      text2 += decoder.decode(value, { stream: true });
+      text3 += decoder.decode(value, { stream: true });
     }
   } finally {
     reader.releaseLock();
   }
   return {
     tooLarge: false,
-    text: text2 + decoder.decode()
+    text: text3 + decoder.decode()
   };
 }
 var WebStandardStreamableHTTPServerTransport2 = class {
@@ -82950,8 +83410,8 @@ var readRawBodyIfAvailable2 = (request) => {
 };
 var normalizeAbortError2 = (request, incoming) => {
   if (incoming.errored) return incoming.errored;
-  const reason2 = request[abortReasonKey2];
-  if (reason2 !== void 0) return reason2 instanceof Error ? reason2 : new Error(String(reason2));
+  const reason3 = request[abortReasonKey2];
+  if (reason3 !== void 0) return reason3 instanceof Error ? reason3 : new Error(String(reason3));
   return /* @__PURE__ */ new Error("Client connection prematurely closed.");
 };
 var readBodyDirect2 = (request) => {
@@ -83045,10 +83505,10 @@ var requestPrototype2 = {
   get headers() {
     return this[headersKey2] ||= newHeadersFromIncoming2(this[incomingKey2]);
   },
-  [abortRequest2](reason2) {
-    if (this[abortReasonKey2] === void 0) this[abortReasonKey2] = reason2;
+  [abortRequest2](reason3) {
+    if (this[abortReasonKey2] === void 0) this[abortReasonKey2] = reason3;
     const abortController = this[abortControllerKey2];
-    if (abortController && !abortController.signal.aborted) abortController.abort(reason2);
+    if (abortController && !abortController.signal.aborted) abortController.abort(reason3);
   },
   [getAbortController2]() {
     this[abortControllerKey2] ||= new AbortController();
@@ -83692,8 +84152,8 @@ var upgradeWebSocket2 = defineWebSocketHelper2(async (c, events, options) => {
     ws.on("message", bufferMessage);
     const ctx = {
       binaryType: "arraybuffer",
-      close(code, reason2) {
-        ws.close(code, reason2);
+      close(code, reason3) {
+        ws.close(code, reason3);
       },
       protocol: ws.protocol,
       raw: ws,
@@ -83723,11 +84183,11 @@ var upgradeWebSocket2 = defineWebSocketHelper2(async (c, events, options) => {
     ws.on("message", (data, isBinary) => {
       handleMessage(data, isBinary);
     });
-    ws.on("close", (code, reason2) => {
+    ws.on("close", (code, reason3) => {
       try {
         events?.onClose?.(new CloseEvent2("close", {
           code,
-          reason: reason2.toString()
+          reason: reason3.toString()
         }), ctx);
       } catch (e) {
         (options?.onError ?? console.error)(e);
@@ -83862,9 +84322,9 @@ var NodeStreamableHTTPServerTransport2 = class {
 };
 
 // src/computers.ts
-import { randomBytes as randomBytes4 } from "node:crypto";
+import { randomBytes as randomBytes5 } from "node:crypto";
 import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync as rmSync2, statSync as statSync3 } from "node:fs";
-import { isAbsolute, join as join9, resolve as resolve4 } from "node:path";
+import { isAbsolute, join as join10, resolve as resolve4 } from "node:path";
 var TOOLS = {
   read: ["read", "list", "search"],
   files: ["read", "list", "search", "edit"],
@@ -83886,7 +84346,7 @@ var Computers = class {
     this.#data = data;
     this.#base = base;
     this.#runtime = runtime;
-    this.#file = join9(data, "computers.json");
+    this.#file = join10(data, "computers.json");
     if (existsSync2(this.#file))
       for (const entry of JSON.parse(readFileSync4(this.#file, "utf8")))
         this.#stored.set(entry.id, entry);
@@ -83924,7 +84384,7 @@ var Computers = class {
       if (!folder) throw new ApiError(400, `There's no folder at ${input2.workspace}.`);
       workspace = resolve4(input2.workspace);
     }
-    const id = `c_${randomBytes4(9).toString("hex")}`;
+    const id = `c_${randomBytes5(9).toString("hex")}`;
     const token = newToken();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const stored = {
@@ -83941,7 +84401,7 @@ var Computers = class {
       ...timeout === void 0 ? {} : { endAt: expiry(timeout) }
     };
     if (!workspace && access !== "none") {
-      stored.workspace = join9(this.#folder(id), "workspace");
+      stored.workspace = join10(this.#folder(id), "workspace");
       mkdirSync2(stored.workspace, { recursive: true, mode: 448 });
     }
     this.#stored.set(id, stored);
@@ -84023,12 +84483,12 @@ var Computers = class {
   }
   logs(id) {
     this.#found(id);
-    let text2 = "";
+    let text3 = "";
     try {
-      text2 = readFileSync4(this.#logFile(id), "utf8");
+      text3 = readFileSync4(this.#logFile(id), "utf8");
     } catch {
     }
-    return text2.split("\n").filter(Boolean).map((entry) => ({
+    return text3.split("\n").filter(Boolean).map((entry) => ({
       timestamp: entry.slice(0, entry.indexOf(" ")),
       line: entry.slice(entry.indexOf(" ") + 1)
     }));
@@ -84060,7 +84520,7 @@ var Computers = class {
     const now = Date.now();
     for (const [key, ticket2] of this.#tickets)
       if (ticket2.expiresAt <= now) this.#tickets.delete(key);
-    const ticket = `l_${randomBytes4(24).toString("base64url")}`;
+    const ticket = `l_${randomBytes5(24).toString("base64url")}`;
     const expiresAt = now + TICKET_MS;
     this.#tickets.set(ticket, { computerID: id, surface, mode, expiresAt });
     return {
@@ -84092,10 +84552,10 @@ var Computers = class {
     return stored;
   }
   #folder(id) {
-    return privateFolder(join9(this.#data, "computers", id));
+    return privateFolder(join10(this.#data, "computers", id));
   }
   #logFile(id) {
-    return join9(this.#folder(id), "log");
+    return join10(this.#folder(id), "log");
   }
   #log(id, line) {
     if (!this.#stored.has(id)) return;
@@ -84144,9 +84604,9 @@ var Computers = class {
       this.#folder(stored.id),
       {
         log: (line) => this.#log(stored.id, line),
-        failed: (reason2) => {
+        failed: (reason3) => {
           live.failed = true;
-          this.#log(stored.id, reason2);
+          this.#log(stored.id, reason3);
         }
       }
     );
@@ -84187,7 +84647,7 @@ var OPENAPI = {
   "openapi": "3.1.0",
   "info": {
     "title": "AgentComputer",
-    "version": "0.0.7",
+    "version": "0.0.8",
     "description": "Computers for agents. This file is the source of truth: the HTTP API, the MCP control tools and the SDK are all generated from it. An operation with `x-mcp-tool` is also an MCP tool of that name.",
     "license": {
       "name": "Apache-2.0",
@@ -84508,7 +84968,7 @@ var OPENAPI = {
       "post": {
         "operationId": "createLiveSession",
         "x-mcp-tool": "computer_live",
-        "summary": "A one-time ticket to watch or operate one of its surfaces live: the agent's commands as they run, or a shell of your own. Open its url as a WebSocket within 60 seconds.",
+        "summary": "A one-time ticket to watch or operate one of its surfaces live: the agent's commands as they run, a shell of your own, its files, or its browser. Open its url as a WebSocket within 60 seconds.",
         "requestBody": {
           "required": true,
           "content": {
@@ -84849,9 +85309,10 @@ var OPENAPI = {
         "enum": [
           "commands",
           "terminal",
+          "files",
           "browser"
         ],
-        "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Opening it to operate makes you the driver: the agent's browser calls wait up to 25 seconds while you are, then answer that a person has or had it. You stop being the driver when you send release, close the socket, or send nothing for 60 seconds, and sending input takes it again."
+        "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes."
       },
       "LiveMode": {
         "type": "string",
@@ -84859,7 +85320,7 @@ var OPENAPI = {
           "watch",
           "operate"
         ],
-        "description": "In watch, what you send is dropped."
+        "description": "In watch you see and don't act: what you send is dropped, except that a files socket may still ask to list, to read and for what changed."
       },
       "SurfaceInfo": {
         "type": "object",
@@ -84882,8 +85343,7 @@ var OPENAPI = {
           },
           "unavailable": {
             "type": "string",
-            "description": "Why it can't be opened here",
-            "if it can't.": null
+            "description": "Why it can't be opened now, if it can't."
           }
         }
       },
@@ -84942,7 +85402,7 @@ var OPENAPI = {
         "oneOf": [
           {
             "type": "object",
-            "description": "The open tabs, and which one the frames are of, sent again whenever a tab opens, closes, navigates or changes its title.",
+            "description": "The open tabs, and which one this socket's frames are of, sent again whenever a tab opens, closes, navigates or changes its title, or the socket is shown another.",
             "required": [
               "type",
               "tabs",
@@ -85090,30 +85550,6 @@ var OPENAPI = {
                 }
               }
             }
-          },
-          {
-            "type": "object",
-            "description": "Who holds the browser, and whether the agent is waiting for it.",
-            "required": [
-              "type",
-              "you",
-              "held",
-              "agentWaiting"
-            ],
-            "properties": {
-              "type": {
-                "const": "driver"
-              },
-              "you": {
-                "type": "boolean"
-              },
-              "held": {
-                "type": "boolean"
-              },
-              "agentWaiting": {
-                "type": "boolean"
-              }
-            }
           }
         ]
       },
@@ -85276,6 +85712,7 @@ var OPENAPI = {
           },
           {
             "type": "object",
+            "description": "Show this socket another tab, open one and show it, or close one. After show or open, the socket's page is its own and no longer follows new tabs.",
             "required": [
               "type",
               "action"
@@ -85312,20 +85749,321 @@ var OPENAPI = {
               },
               "to": {
                 "type": "string",
-                "description": "A URL",
-                "or back": null,
-                "forward or reload.": null
+                "description": "A URL, or back, forward or reload."
+              }
+            }
+          }
+        ]
+      },
+      "FilesRequest": {
+        "description": "What a socket sends on files@1, as JSON text. Each has an id of its own choosing, which the answer repeats; answers come as they are ready, in any order, and ids aren't checked for repeats. A request still unanswered when the socket closes gets no answer. A path is from the workspace, with / between its parts, or absolute inside it, and nothing outside the workspace is reached. A binary message that follows no write closes the socket, and so does any message over 1,048,576 bytes.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "A folder's entries, folders first, the first thousand. There is no asking for the rest.",
+            "required": [
+              "type",
+              "id"
+            ],
+            "properties": {
+              "type": {
+                "const": "list"
+              },
+              "id": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 64
+              },
+              "path": {
+                "type": "string",
+                "description": "The workspace itself, if left out."
               }
             }
           },
           {
             "type": "object",
+            "description": "Bytes of a file from an offset. The answer is a data message and then one binary message, the bytes: fewer than asked for at the file's end, and none past it.",
             "required": [
-              "type"
+              "type",
+              "id",
+              "path",
+              "offset",
+              "length"
             ],
             "properties": {
               "type": {
-                "const": "release"
+                "const": "read"
+              },
+              "id": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 64
+              },
+              "path": {
+                "type": "string"
+              },
+              "offset": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "length": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 1048576
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "The files modified after a time, in whole milliseconds: the newest thousand, the newest first. It skips what .gitignore files ignore, .git, node_modules and links, and a file that was removed isn't one of them. Each one asked walks the workspace once, and a computer walks for one at a time. Nothing is walked that wasn't asked for.",
+            "required": [
+              "type",
+              "id",
+              "since"
+            ],
+            "properties": {
+              "type": {
+                "const": "changed"
+              },
+              "id": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 64
+              },
+              "since": {
+                "type": "string",
+                "format": "date-time"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "The next part of a file, on an operate socket, followed by one binary message of exactly length bytes, with no message between them. The part at offset 0 starts the file, or starts it again, and each one after starts where the last ended. Nothing is at the path until the part marked last, which puts the file there whole, over any that was there, and is answered with written. Only that part, and a part that is refused, is answered. It makes no folders. A file not finished when the socket closes is given up.",
+            "required": [
+              "type",
+              "id",
+              "path",
+              "offset",
+              "length",
+              "last"
+            ],
+            "properties": {
+              "type": {
+                "const": "write"
+              },
+              "id": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 64
+              },
+              "path": {
+                "type": "string"
+              },
+              "offset": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "length": {
+                "type": "integer",
+                "minimum": 0,
+                "maximum": 1048576
+              },
+              "last": {
+                "type": "boolean"
+              }
+            }
+          }
+        ]
+      },
+      "FilesAnswer": {
+        "description": "What the service sends on files@1, as JSON text, each with the id it answers. Nothing comes between a data message and its bytes.",
+        "oneOf": [
+          {
+            "type": "object",
+            "required": [
+              "type",
+              "id",
+              "path",
+              "entries",
+              "more"
+            ],
+            "properties": {
+              "type": {
+                "const": "entries"
+              },
+              "id": {
+                "type": "string"
+              },
+              "path": {
+                "type": "string"
+              },
+              "entries": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "description": "A link is not followed, and its size and date are its own.",
+                  "required": [
+                    "name",
+                    "kind",
+                    "size",
+                    "modifiedAt"
+                  ],
+                  "properties": {
+                    "name": {
+                      "type": "string"
+                    },
+                    "kind": {
+                      "type": "string",
+                      "enum": [
+                        "file",
+                        "folder",
+                        "link"
+                      ]
+                    },
+                    "size": {
+                      "type": "integer"
+                    },
+                    "modifiedAt": {
+                      "type": "string",
+                      "format": "date-time"
+                    }
+                  }
+                }
+              },
+              "more": {
+                "type": "boolean",
+                "description": "Whether the folder has more than these."
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "What the binary message after it is, and the file's whole size and date.",
+            "required": [
+              "type",
+              "id",
+              "path",
+              "offset",
+              "length",
+              "size",
+              "modifiedAt"
+            ],
+            "properties": {
+              "type": {
+                "const": "data"
+              },
+              "id": {
+                "type": "string"
+              },
+              "path": {
+                "type": "string"
+              },
+              "offset": {
+                "type": "integer"
+              },
+              "length": {
+                "type": "integer",
+                "description": "How many bytes follow."
+              },
+              "size": {
+                "type": "integer"
+              },
+              "modifiedAt": {
+                "type": "string",
+                "format": "date-time"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": [
+              "type",
+              "id",
+              "since",
+              "changes",
+              "more"
+            ],
+            "properties": {
+              "type": {
+                "const": "changes"
+              },
+              "id": {
+                "type": "string"
+              },
+              "since": {
+                "type": "string",
+                "format": "date-time"
+              },
+              "changes": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "required": [
+                    "path",
+                    "size",
+                    "modifiedAt"
+                  ],
+                  "properties": {
+                    "path": {
+                      "type": "string"
+                    },
+                    "size": {
+                      "type": "integer"
+                    },
+                    "modifiedAt": {
+                      "type": "string",
+                      "format": "date-time"
+                    }
+                  }
+                }
+              },
+              "more": {
+                "type": "boolean",
+                "description": "Whether more than these changed."
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "The file is in place.",
+            "required": [
+              "type",
+              "id",
+              "path",
+              "size"
+            ],
+            "properties": {
+              "type": {
+                "const": "written"
+              },
+              "id": {
+                "type": "string"
+              },
+              "path": {
+                "type": "string"
+              },
+              "size": {
+                "type": "integer"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "It wasn't done, and why. The id is empty when what was sent had none to repeat.",
+            "required": [
+              "type",
+              "id",
+              "message"
+            ],
+            "properties": {
+              "type": {
+                "const": "refused"
+              },
+              "id": {
+                "type": "string"
+              },
+              "message": {
+                "type": "string"
               }
             }
           }
@@ -85871,9 +86609,10 @@ var OPERATIONS = [
                     "enum": [
                       "commands",
                       "terminal",
+                      "files",
                       "browser"
                     ],
-                    "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Opening it to operate makes you the driver: the agent's browser calls wait up to 25 seconds while you are, then answer that a person has or had it. You stop being the driver when you send release, close the socket, or send nothing for 60 seconds, and sending input takes it again."
+                    "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes."
                   },
                   "protocol": {
                     "type": "string"
@@ -85885,8 +86624,7 @@ var OPERATIONS = [
                   },
                   "unavailable": {
                     "type": "string",
-                    "description": "Why it can't be opened here",
-                    "if it can't.": null
+                    "description": "Why it can't be opened now, if it can't."
                   }
                 }
               }
@@ -86390,7 +87128,7 @@ var OPERATIONS = [
     "method": "POST",
     "path": "/v1/computers/{computerID}/live",
     "tool": "computer_live",
-    "summary": "A one-time ticket to watch or operate one of its surfaces live: the agent's commands as they run, or a shell of your own. Open its url as a WebSocket within 60 seconds.",
+    "summary": "A one-time ticket to watch or operate one of its surfaces live: the agent's commands as they run, a shell of your own, its files, or its browser. Open its url as a WebSocket within 60 seconds.",
     "status": 201,
     "hasBody": true,
     "pathParameters": [
@@ -86411,9 +87149,10 @@ var OPERATIONS = [
           "enum": [
             "commands",
             "terminal",
+            "files",
             "browser"
           ],
-          "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Opening it to operate makes you the driver: the agent's browser calls wait up to 25 seconds while you are, then answer that a person has or had it. You stop being the driver when you send release, close the socket, or send nothing for 60 seconds, and sending input takes it again."
+          "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes."
         },
         "mode": {
           "allOf": [
@@ -86423,7 +87162,7 @@ var OPERATIONS = [
                 "watch",
                 "operate"
               ],
-              "description": "In watch, what you send is dropped."
+              "description": "In watch you see and don't act: what you send is dropped, except that a files socket may still ask to list, to read and for what changed."
             }
           ],
           "default": "watch"
@@ -86457,9 +87196,10 @@ var OPERATIONS = [
           "enum": [
             "commands",
             "terminal",
+            "files",
             "browser"
           ],
-          "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Opening it to operate makes you the driver: the agent's browser calls wait up to 25 seconds while you are, then answer that a person has or had it. You stop being the driver when you send release, close the socket, or send nothing for 60 seconds, and sending input takes it again."
+          "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes."
         },
         "mode": {
           "type": "string",
@@ -86467,7 +87207,7 @@ var OPERATIONS = [
             "watch",
             "operate"
           ],
-          "description": "In watch, what you send is dropped."
+          "description": "In watch you see and don't act: what you send is dropped, except that a files socket may still ask to list, to read and for what changed."
         },
         "expiresAt": {
           "type": "string",
@@ -86531,13 +87271,13 @@ function parseListen(listen) {
 }
 var bearerOf = (request) => /^Bearer (\S+)$/.exec(request.headers.authorization ?? "")?.[1];
 async function jsonBody(request) {
-  let text2 = "";
+  let text3 = "";
   for await (const chunk of request) {
-    text2 += String(chunk);
-    if (text2.length > MAX_BODY2) throw new ApiError(413, "That request is too large.");
+    text3 += String(chunk);
+    if (text3.length > MAX_BODY2) throw new ApiError(413, "That request is too large.");
   }
   try {
-    const parsed = JSON.parse(text2 || "{}");
+    const parsed = JSON.parse(text3 || "{}");
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed))
       return parsed;
   } catch {
@@ -86565,7 +87305,7 @@ async function serve(options) {
     pattern: new RegExp(`^${operation.path.replace(/\{[^}]+\}/g, "([^/]+)")}$`),
     check: fromJsonSchema3(operation.input)
   }));
-  const run3 = async (route2, input2) => {
+  const run2 = async (route2, input2) => {
     const checked = await route2.check["~standard"].validate(input2);
     if (checked.issues)
       throw new ApiError(400, checked.issues.map((issue3) => issue3.message).join("; "));
@@ -86580,7 +87320,7 @@ async function serve(options) {
           { description: route2.operation.summary, inputSchema: route2.check },
           async (input2) => {
             try {
-              const output2 = await run3(route2, input2) ?? {};
+              const output2 = await run2(route2, input2) ?? {};
               return { content: [{ type: "text", text: JSON.stringify(output2) }] };
             } catch (error62) {
               if (!(error62 instanceof ApiError)) throw error62;
@@ -86632,7 +87372,7 @@ async function serve(options) {
         const value = url3.searchParams.get(name);
         if (value !== null) input2[name] = value;
       }
-      return send(response, operation.status, await run3(candidate, input2));
+      return send(response, operation.status, await run2(candidate, input2));
     }
     throw pathMatched ? new ApiError(405, "Not allowed.") : new ApiError(404, "Not found.");
   };
@@ -86679,7 +87419,7 @@ ${JSON.stringify({ code: status, message })}
   const scheme = options.tls ? "https" : "http";
   base = options.publicUrl?.replace(/\/+$/, "") ?? `${scheme}://${bound.family === "IPv6" ? `[${bound.address}]` : bound.address}:${bound.port}`;
   await computers.resume();
-  const record3 = join10(data, "server.json");
+  const record3 = join11(data, "server.json");
   writePrivate(
     record3,
     JSON.stringify({ url: base, pid: process.pid, isolation: options.runtime.isolation })
@@ -86719,7 +87459,7 @@ var USAGE = `Usage: agentcomputer <command> [--data DIR]
   stop <id>                         stop it, keeping its folder and token
   start <id> [--timeout SECONDS]    start a stopped computer again
   logs <id>                         what its servers wrote
-  live <id> --surface commands|terminal [--mode watch|operate]
+  live <id> --surface commands|terminal|files|browser [--mode watch|operate]
                                     a one-time ticket to open one live, as a WebSocket
   kill <id>                         stop it and remove what the service made
 
@@ -86732,13 +87472,13 @@ var UsageError = class extends Error {
 function dataFolder(given) {
   const xdg = process.env.XDG_DATA_HOME;
   return resolve5(
-    given ?? process.env.AGENTCOMPUTER_DATA ?? (xdg && isAbsolute2(xdg) ? join11(xdg, "agentcomputer") : join11(homedir2(), ".local", "share", "agentcomputer"))
+    given ?? process.env.AGENTCOMPUTER_DATA ?? (xdg && isAbsolute2(xdg) ? join12(xdg, "agentcomputer") : join12(homedir2(), ".local", "share", "agentcomputer"))
   );
 }
 function connectionTo(data) {
   try {
-    const { url: url3 } = JSON.parse(readFileSync6(join11(data, "server.json"), "utf8"));
-    return { apiUrl: url3, apiKey: readFileSync6(join11(data, "control-token"), "utf8").trim() };
+    const { url: url3 } = JSON.parse(readFileSync6(join12(data, "server.json"), "utf8"));
+    return { apiUrl: url3, apiKey: readFileSync6(join12(data, "control-token"), "utf8").trim() };
   } catch {
     throw new Error(
       `No service is running with its data in ${data}. Start one: agentcomputer serve`
@@ -86767,6 +87507,8 @@ async function main() {
       channel: { type: "string" },
       executable: { type: "string" },
       "no-sandbox": { type: "boolean" },
+      endpoint: { type: "string" },
+      output: { type: "string" },
       access: { type: "string" },
       workspace: { type: "string" },
       name: { type: "string" },
@@ -86813,6 +87555,11 @@ async function main() {
       executable: values.executable,
       sandbox: values["no-sandbox"] ? false : void 0
     });
+  if (command === "browser-mcp")
+    return serveBrowserMcp({
+      endpoint: values.endpoint ?? "",
+      outputDir: values.output ?? ""
+    });
   if (command === "inside")
     return serveInside({
       access: values.access,