@inetafrica/open-claudia 3.5.28 → 3.5.47

package/CHANGELOG.md

@@ -1,30 +1,20 @@
 # Changelog
 
-## 3.5.28
+## 3.5.47
 
-The Browser app is always on: opening it while the bot is not browsing opens the bot's browser, instead of a dead end (Sumeet, 10 Oct: "half the time i have to ask you switch on the browser"; 11 Oct 07:43 EAT network-mon's Browser showed only "isn't open right now"). A canary build for the Browser canary bot, on 3.5.26; it does not carry 3.5.27 (calls, Sumeet's own bot).
+Your rules for a group now beat the guard's blanket "never share" line (Sumeet, 11 Oct 20:57 EAT: the network bot kept bringing NOC and Knock requests to him although his rules for both groups allow read-only diagnostics). Built on 3.5.33, the fleet's version; a canary for the network bot first.
 
-- **`POST /api/browser/start`** (Agent Space's control token only, like every Browser app route). With no browser open, the bot's own default session opens on a start page (`https://www.google.com/`), with the bot's own agent-browser environment and socket folder (`AGENT_BROWSER_SOCKET_DIR`, else `~/.agent-browser`), exactly as its own `agent-browser open` would, so the bot carries on in that tab. A browser already open is answered as it is (the newest session), and two people opening the app at once start one browser. `GET /api/browser/control` says `start: true`; Agent Space's front door (223b978) asks only bots that say so.
-- **Tests:** `test-browser-control.js`, `test-web-browser-app.js`.
+- **The guard judge's floor is scoped, not blanket** (`core/enforcer.js`). It said: whatever any layer says, never allow other people's private information or internal infrastructure details. A network bot's useful replies nearly always carry both (customer accounts, NAS names, IPs on blocklists), so the owner's channel rules never won and each reply became an owner card: 17 on the network bot on 11 Oct. Now credentials, secrets, passwords, tokens and keys stay blocked whatever any layer says; the owner's own private information needs a layer that explicitly allows it; infrastructure details and other people's information are allowed only where a channel rule or mandate clearly permits that kind of information or the work that produces it.
+- **Proof:** two replies the network bot held on 11 Oct, replayed against the judge (claude-sonnet-5-5): with the old line 5 of 6 verdicts escalated, quoting it; with the new wording 4 of 4 allowed, and a made-up reply carrying a NAS password and RADIUS secret was blocked 2 of 2.
+- **Tests:** `test-enforcer.js` checks the credentials floor is absolute and the blanket line is gone (it fails on the old wording).
 
-## 3.5.26
+## 3.5.33
 
-The Browser app's phone and web view stays sharp after a page load. A canary build for the Browser canary bot first; the fleet waits for Sumeet's OK.
+Quiet chats by default (Sumeet, 11 Oct 08:51 EAT, on Kazee unread counts: one voice note brought a "Heard:" echo, a progress message and "Recalled my notes" lines before the answer, each a new unread and often a push; 09:16 EAT "Yes" to turning them off by default on every bot). Built on 3.5.24, the fleet's version: the Browser canaries (3.5.25, 3.5.26, 3.5.28) and the call builds on Sumeet's own bot (3.5.27 and later) are not in it.
 
-- **Sharp after every page.** On the canary's Chrome 150 (Linux) the driver's pictures dropped from the view's density to 1x at the first page load (the view kept its density; the picture did not). After a main-frame navigation or a load, the window is now resized by a pixel and back, which brings the density back: 906x1760 pictures for a 412x800 phone at 2.2x on duckduckgo.com, en.m.wikipedia.org and example.com, 1 to 4 s after each load.
-- **Tests:** `test-browser-drive.js`.
-
-## 3.5.25
-
-The Browser app feels like a browser on the phone and on the web (Sumeet, 10 Oct 08:53 EAT on his phone: "it feels like a browser on my phone… like Google Chrome app", and 09:18: "the web and mobile still need to also feel native… don't forget the website"). A canary build for the Browser canary bot first; the fleet waits for his OK.
-
-- **The bot's tab takes the driver's screen.** With Chrome in its own container, a take (or a `fit` when the screen changes: a turned phone, a resized panel, a keyboard that opens) that carries the driver's screen (`viewport`: CSS size, pixel density, phone layout, touch) fits the bot's tab to it through `core/browser-drive.js`. A phone gets the page's phone layout, full screen and sharp; the web gets a desktop page at the panel's size. Handing back puts the tab back to its own size. The browser's identity (user agent) never changes, so sites signed into stay signed in after the hand back. `GET /api/browser/control` says `fit: true`.
-- **The driver's input goes straight to Chrome,** through the view's own DevTools session, in order. Touches keep their timing, so a swipe flings; typed text is inserted whole (`input_text`, at most 500 characters: accents, emoji, the keyboard's corrections); every point is scaled by the view's density, because Chrome reads input in the drawn picture's pixels. A bot without the view takes `input_text` as key presses.
-- **The page's text fields.** The view reads where the page's text fields are and what kind they are (never a value) and streams them as `fields` events, so the Browser page opens the phone's own keyboard of the right kind the moment a field is tapped.
-- **Pictures.** The view streams its own screencast at the driver's size (at most 1.6 million pixels, 30 a second). `/api/browser/stream` serves it while someone drives, up to 30 fps, and keeps the newest frame while a slow viewer drains instead of dropping it, so the last picture of a scroll always arrives.
-- **A hand back wakes the bot only when it waits for that person:** it sent them an Open Browser card (cards now record `openApp`), or one of its browser commands was refused while they drove (the tool guard marks it). Otherwise the hand back is only logged. On 9 Oct a test hand back set off a 28-minute tangent on the canary.
-- **Correction to 3.5.24:** in container mode, sessions are not pinned to tabs (Agent Space dropped `AGENT_BROWSER_PIN_TAB` in a98f239); a session uses the tab that is open.
-- **Tests:** `test-browser-drive.js` (new), `test-browser-control.js`, `test-web-browser-app.js`.
+- **One message in, one answer out.** By default a turn now shows "typing" while it works and sends only its answer: no "Heard: …" echo of a voice note or audio file, no live progress message, and no "📖 Recalled my notes on …", "✏️ Updating my notes on …", new pack, entity, skill or "🧩 Reused" lines. Recall-failure alerts, /recall, /tooltrace, wake-up notices and limit warnings are unchanged.
+- **Each comes back with its own command** (`core/chatter.js`): `/heard`, `/notes` and `/progress` (on, off, or no argument for the current value and buttons), saved per person like /verbose. `/verbose` streams thinking into the progress message, so it turns the progress message on too: anyone with /verbose on keeps it until they turn /verbose off.
+- **Tests:** `test-quiet-defaults.js` (new, in `npm test`), `test-thread-lanes.js` (its live-preview check turns /progress on).
 
 ## 3.5.24
 

package/core/actions.js

@@ -6,6 +6,7 @@ const fs = require("fs");
 const path = require("path");
 const { CONFIG_DIR, WORKSPACE, CHAT_ID } = require("./config");
 const { send } = require("./io");
+const { TOGGLES: chatterToggles } = require("./chatter");
 const {
   currentState, saveState,
   getActiveProvider, getProjectKey, consumeSessionCallbackToken,
@@ -959,6 +960,13 @@ async function handleAction(envelope) {
     await send(`Verbose thinking: ${state.settings.showThinking ? "on" : "off"}`);
     return;
   }
+  const chatterToggle = chatterToggles.find((toggle) => d.startsWith(`${toggle.callback}:`));
+  if (chatterToggle) {
+    state.settings[chatterToggle.key] = d.slice(chatterToggle.callback.length + 1) === "on";
+    saveState();
+    await send(`${chatterToggle.label}: ${state.settings[chatterToggle.key] ? "on" : "off"}`);
+    return;
+  }
   if (d.startsWith("cw:")) {
     const v = d.slice(3);
     if (v === "default") state.settings.compactWindow = null;

package/core/browser-control.js

@@ -13,30 +13,18 @@
 //     after the input before them, with the bot's own agent-browser environment and never a
 //     launch flag (core/agent-browser-cli.js: other launch settings would restart the browser).
 //     Only public internet addresses (core/browser-address.js).
-//   - the phone and web view (core/browser-drive.js): a take or a "fit" with the driver's screen
-//     makes the bot's tab take its size, phone layout and touch, and then the driver's input goes
-//     straight to Chrome through that view (typed text too: input_text). Only with Chrome in its
-//     own container; elsewhere the browser keeps its size and input goes through agent-browser.
-//   - always on: a person who opens the Browser app while the bot's browser is not open gets it
-//     opened on a start page, in the bot's own default session (the one its `agent-browser open`
-//     uses), with the bot's own agent-browser environment, so the bot carries on in that tab.
 //   - hand back (release, a closed panel, or a lock found expired by the 30 s sweeper): the lock
-//     goes, the view and the socket close, any recording stops, and the bot is woken in the
-//     person's own chat (C6), but only when it waits for them: it sent them an Open Browser card,
-//     or one of its browser commands was refused while they drove. A recording stopped at the
-//     same time folds into one wake-up. Otherwise the hand back is only logged.
+//     goes, the socket closes, any recording stops, and the bot is woken in the person's own chat
+//     to carry on (C6). A recording stopped at the same time folds into one wake-up.
 //
 // Every route answers { status, body }; web.js writes it. Agent Space reaches these routes with
 // the control token only.
 
-const os = require("os");
-const path = require("path");
 const WebSocket = require("ws");
 const lockFile = require("./browser-lock");
 const view = require("./browser-view");
 const teach = require("./browser-teach");
 const address = require("./browser-address");
-const drive = require("./browser-drive");
 const { runAgentBrowser } = require("./agent-browser-cli");
 
 const LOCK_TTL_MS = lockFile.LOCK_TTL_MS;
@@ -53,13 +41,6 @@ const ID_RE = /^[A-Za-z0-9._:-]{1,100}$/;
 // An address-bar command still running after this is killed, and the person told it failed.
 const NAVIGATE_TIMEOUT_MS = 20 * 1000;
 const NAVIGATIONS = new Set(["open", "back", "forward", "reload"]);
-// Always on: the page a browser opened for a person starts on, and the session it opens (the one
-// the bot's own `agent-browser` commands use when they name none).
-const START_PAGE = "https://www.google.com/";
-const START_SESSION = "default";
-
-// An Open Browser card counts as a request for a person this long.
-const REQUEST_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 
 const HAND_BACK_REASONS = {
   closed: " (they closed the Browser)",
@@ -126,7 +107,6 @@ const MOUSE_EVENTS = new Set(["mousePressed", "mouseReleased", "mouseMoved", "mo
 const MOUSE_BUTTONS = new Set(["none", "left", "middle", "right"]);
 const KEY_EVENTS = new Set(["keyDown", "keyUp", "char"]);
 const TOUCH_EVENTS = new Set(["touchStart", "touchMove", "touchEnd", "touchCancel"]);
-const TEXT_MAX = drive.TEXT_MAX;
 
 const isNumber = (v) => typeof v === "number" && Number.isFinite(v);
 const inRange = (v, lo, hi) => isNumber(v) && v >= lo && v <= hi;
@@ -183,34 +163,11 @@ function checkEvent(ev) {
     }
     const out = { type: "input_touch", eventType: ev.eventType, touchPoints };
     if (!optional(out, "modifiers", modifiers)) return null;
-    // When the finger moved, on the driver's device (ms): keeps a swipe's speed (core/browser-drive.js).
-    if (!optional(out, "t", (v) => inRange(v, 0, 1e13))) return null;
     return out;
   }
-  // Text the driver typed (their phone keyboard, a paste), inserted where the page's caret is.
-  if (ev.type === "input_text") {
-    if (typeof ev.text !== "string" || !ev.text || Array.from(ev.text).length > TEXT_MAX) return null;
-    return { type: "input_text", text: ev.text };
-  }
   return null;
 }
 
-// input_text as key presses, for a bot without the driver's view (agent-browser's socket takes
-// no text) and for Teach me, which counts typing from key presses.
-function textAsKeys(text) {
-  const out = [];
-  for (const ch of Array.from(text)) {
-    if (ch === "\n" || ch === "\r") {
-      out.push({ type: "input_keyboard", eventType: "keyDown", key: "Enter", code: "Enter", text: "\r", windowsVirtualKeyCode: 13 });
-      out.push({ type: "input_keyboard", eventType: "keyUp", key: "Enter", code: "Enter", windowsVirtualKeyCode: 13 });
-    } else {
-      out.push({ type: "input_keyboard", eventType: "keyDown", key: ch, text: ch });
-      out.push({ type: "input_keyboard", eventType: "keyUp", key: ch });
-    }
-  }
-  return out;
-}
-
 // ---------------------------------------------------------------------------
 // Input sockets: one per agent-browser session, opened on take (or on the first input after a
 // restart), closed on hand back.
@@ -368,23 +325,7 @@ function wakeChat({ chatId, userId }, prompt, label) {
 
 function handBackLine(name, reason) {
   const who = teach.cleanName(name) || "Someone";
-  return `[Browser] ${who} handed the browser back${HAND_BACK_REASONS[reason] || ""}. Check the page first (it may have changed), then carry on with what you were waiting on them for.`;
-}
-
-// Was the bot waiting for this person when they handed back? It asked for them with an Open
-// Browser card in their chat (since the day before they took over), or one of its own browser
-// commands was refused while they drove.
-function botWasWaiting(lock) {
-  let asked = [];
-  try {
-    const since = Date.parse(lock.since);
-    asked = require("./cards").takeBrowserRequests(lock.chatId, (Number.isFinite(since) ? since : deps.now()) - REQUEST_MAX_AGE_MS, deps.now());
-  } catch (e) {
-    console.error(`[browser] reading the bot's Open Browser cards failed: ${e.message}`);
-  }
-  const refused = lockFile.waitedDuring(lock);
-  lockFile.clearWaiting();
-  return asked.length > 0 || refused;
+  return `[Browser] ${who} handed the browser back${HAND_BACK_REASONS[reason] || ""}. If you were waiting on them, check the page first (it may have changed) and carry on; otherwise just note it.`;
 }
 
 // ---------------------------------------------------------------------------
@@ -394,39 +335,7 @@ function lockBody(lock) {
   return { driving: true, driver: { name: lock.name } };
 }
 
-// The driver's view on this lock's session: start it (or move it to a new screen) and remember it
-// in the lock, so a restarted bot can bring it back. -> the fit, or null (the browser keeps its size).
-async function startView(lock, viewport) {
-  if (!viewport || !drive.supported()) return null;
-  const info = sessionInfo(lock.session);
-  if (!info) return null;
-  const r = drive.active(lock.session)
-    ? await drive.fit(viewport)
-    : await drive.start({ session: info, viewport, savedBounds: lock.bounds || null });
-  const now = lockFile.readLock();
-  // The lock changed hands (or was handed back) while the view started: undo it.
-  if (!now || now.since !== lock.since || now.userId !== lock.userId) {
-    if (r.ok && drive.active(lock.session)) await drive.stop();
-    return null;
-  }
-  if (!r.ok) return null;
-  now.fit = r.fit;
-  if (r.bounds) now.bounds = r.bounds;
-  lockFile.writeLock(now);
-  return r.fit;
-}
-
-// After a bot restart the lock remembers a view that is no longer live: bring it back. Once at a
-// time, in the background.
-let reviving = null;
-function reviveView(lock) {
-  if (!lock || !lock.fit || reviving || drive.active(lock.session) || !drive.supported()) return;
-  reviving = startView(lock, lock.fit)
-    .catch((e) => console.error(`[browser] bringing the driver's view back failed: ${e.message}`))
-    .finally(() => { reviving = null; });
-}
-
-async function take({ session, who, viewport } = {}) {
+async function take({ session, who } = {}) {
   if (!validSession(session) || !validWho(who, { needChat: true })) return reply(400, { error: "bad-request" });
   // A lock that ran out but has not been swept yet is handed back first, the sweeper's way: its
   // driver's chat is woken and their recording stopped, whoever takes over now.
@@ -445,25 +354,9 @@ async function take({ session, who, viewport } = {}) {
     since: current && current.session === session ? current.since : iso(now),
     expiresAt: iso(now + LOCK_TTL_MS),
   };
-  // The same person taking again (a reloaded page) keeps the window's size from before their view.
-  if (current && current.session === session && sameUser(current, who) && current.bounds) lock.bounds = current.bounds;
   lockFile.writeLock(lock);
   openInputSocket(session);
-  if (!viewport) return reply(200, lockBody(lock));
-  // fit: the driver's view now live, or null (this bot's browser keeps its own size).
-  const fitted = await startView(lock, viewport);
-  return reply(200, { ...lockBody(lock), fit: fitted });
-}
-
-// The driver's screen changed (a turned phone, a resized panel): { session, who, viewport }.
-async function fitView({ session, who, viewport } = {}) {
-  if (!validSession(session) || !validWho(who)) return reply(400, { error: "bad-request" });
-  if (!drive.checkViewport(viewport)) return reply(400, { error: "bad-viewport" });
-  const lock = extendDriverLock(session, who);
-  if (!lock) return reply(409, { driving: false, error: "not-driving" });
-  if (!drive.supported()) return reply(200, { ...lockBody(lock), fit: null });
-  const fitted = await startView(lock, viewport);
-  return reply(200, { ...lockBody(lock), fit: fitted });
+  return reply(200, lockBody(lock));
 }
 
 function renew({ session, who } = {}) {
@@ -476,8 +369,7 @@ function renew({ session, who } = {}) {
   current.expiresAt = iso(now + LOCK_TTL_MS);
   lockFile.writeLock(current);
   openInputSocket(current.session); // after a restart the socket comes back here
-  reviveView(current); // and the driver's view
-  return reply(200, current.fit ? { ...lockBody(current), fit: drive.active(current.session) ? current.fit : null } : lockBody(current));
+  return reply(200, lockBody(current));
 }
 
 // Hand the browser back: claim the lock (synchronously, so a release and the sweeper never both
@@ -491,13 +383,6 @@ async function handBack(expected, { reason = null } = {}) {
   let stopped = null;
   await runQueued(current.session, 0, async () => {
     closeInputSocket(current.session);
-    // The bot's tab goes back to its own size before the bot carries on.
-    try {
-      if (drive.active(current.session)) await drive.stop();
-      else if (current.bounds) await drive.restoreWindow(info, current.bounds);
-    } catch (e) {
-      console.error(`[browser] ending the driver's view failed: ${e.message}`);
-    }
     try {
       stopped = await teach.stopRecording(current.userId, { session: info });
     } catch (e) {
@@ -505,10 +390,9 @@ async function handBack(expected, { reason = null } = {}) {
     }
   });
   const line = handBackLine(current.name, reason);
-  const waited = botWasWaiting(current);
   if (stopped && !stopped.discarded) wakeChat(current, teach.teachPrompt(stopped, { handBack: line }), "Teach me");
-  else if (waited) wakeChat(current, line, "Browser");
-  console.log(`[browser] ${current.userId} handed the browser back${reason ? ` (${reason})` : ""}${waited || (stopped && !stopped.discarded) ? "" : "; the bot was not waiting for them, so it is not woken"}`);
+  else wakeChat(current, line, "Browser");
+  console.log(`[browser] ${current.userId} handed the browser back${reason ? ` (${reason})` : ""}`);
   return true;
 }
 
@@ -525,13 +409,10 @@ async function control(body = {}) {
   if (body.action === "take") return take(body);
   if (body.action === "renew") return renew(body);
   if (body.action === "release") return release(body);
-  if (body.action === "fit") return fitView(body);
   return reply(400, { error: "bad-action" });
 }
 
-// navigate: true tells the front door this bot has the address bar (POST /api/browser/navigate);
-// fit: true that a take can bring the driver's view (core/browser-drive.js) and input_text works;
-// start: true that it opens its browser on a start page when there is none (POST /api/browser/start).
+// navigate: true tells the front door this bot has the address bar (POST /api/browser/navigate).
 function status() {
   const lock = lockFile.liveLock(deps.now());
   return reply(200, {
@@ -539,50 +420,9 @@ function status() {
     driver: lock ? { name: lock.name, userId: lock.userId } : null,
     recording: teach.activeSummary(),
     navigate: true,
-    fit: drive.supported(),
-    start: true,
   });
 }
 
-// ---------------------------------------------------------------------------
-// Always on: POST /api/browser/start
-
-// The socket folder the bot's own agent-browser commands use (its agent runs without
-// XDG_RUNTIME_DIR): AGENT_BROWSER_SOCKET_DIR, else ~/.agent-browser.
-function agentSocketDir(env = process.env, home = os.homedir()) {
-  if (env.AGENT_BROWSER_SOCKET_DIR) return env.AGENT_BROWSER_SOCKET_DIR;
-  return home ? path.join(home, ".agent-browser") : null;
-}
-
-let starting = null;
-
-// { who: { userId } }. A browser already open is answered as it is (the newest session); otherwise
-// the bot's default session opens on the start page, as the bot's own `agent-browser open` would,
-// and two people opening the app at once start one browser. { session, started }.
-async function start({ who } = {}) {
-  if (!validWho(who)) return reply(400, { error: "bad-request" });
-  const open = deps.listSessions();
-  if (open.length) return reply(200, { session: open[0].name, started: false });
-  if (!starting) {
-    starting = (async () => {
-      const dir = agentSocketDir();
-      const run = await runAgentBrowser({ name: START_SESSION, dir }, ["open", START_PAGE], {
-        timeoutMs: deps.navigateTimeoutMs,
-        execFile: deps.execFile || undefined,
-      });
-      const listed = run.ok ? deps.listSessions().find((s) => s.name === START_SESSION) : null;
-      if (!listed) {
-        const why = run.timedOut ? `agent-browser took longer than ${Math.ceil(deps.navigateTimeoutMs / 1000)} s and was stopped` : run.ok ? "the browser did not come up" : "agent-browser failed";
-        console.error(`[browser] could not open the browser for ${who.userId}: ${why}`);
-        return reply(503, { error: "browser-unavailable" });
-      }
-      console.log(`[browser] opened the browser on the start page for ${who.userId}`);
-      return reply(200, { session: listed.name, started: true });
-    })().finally(() => { starting = null; });
-  }
-  return starting;
-}
-
 // ---------------------------------------------------------------------------
 // C3: input
 
@@ -596,41 +436,24 @@ async function input({ session, events, who } = {}) {
     messages.push(msg);
   }
   // Every accepted input extends the lock.
-  const lock = extendDriverLock(session, who);
-  if (!lock) return reply(409, { error: "not-driving" });
+  if (!extendDriverLock(session, who)) return reply(409, { error: "not-driving" });
   if (!messages.length) return reply(200, { ok: true, accepted: 0 });
-  if (lock.fit && !drive.active(session)) reviveView(lock);
   const entry = openInputSocket(session);
-  if (!entry && !drive.active(session)) return reply(404, { error: "not-running" });
+  if (!entry) return reply(404, { error: "not-running" });
   const job = runQueued(session, messages.length, async () => {
+    if (!(await socketReady(entry))) return reply(503, { error: "browser-unavailable", accepted: 0 });
     const recorder = teach.recorderFor(session, who.userId);
-    const record = async (msg, frame, info) => {
-      if (!recorder) return;
-      // Teach me counts typing from key presses: typed text is shown to it as keys.
-      for (const ev of msg.type === "input_text" ? textAsKeys(msg.text) : [msg]) {
+    let sent = 0;
+    for (const msg of messages) {
+      if (recorder) {
         try {
-          await recorder.onEvent(ev, { session: info, frame });
+          await recorder.onEvent(msg, { session: { name: entry.name, dir: entry.dir }, frame: entry.frame });
         } catch (e) {
           console.error(`[browser] recording a step failed: ${e.message}`);
         }
       }
-    };
-    // The driver's view: straight to Chrome, in order, without waiting for each answer.
-    if (drive.active(session)) {
-      const info = sessionInfo(session) || { name: session, dir: entry ? entry.dir : null };
-      for (const msg of messages) {
-        await record(msg, drive.lastFrame(), { name: info.name, dir: info.dir });
-        if (drive.dispatch([msg]) < 0) return reply(503, { error: "browser-unavailable" });
-      }
-      return reply(200, { ok: true, accepted: messages.length });
-    }
-    if (!entry || !(await socketReady(entry))) return reply(503, { error: "browser-unavailable", accepted: 0 });
-    let sent = 0;
-    for (const msg of messages) {
-      await record(msg, entry.frame, { name: entry.name, dir: entry.dir });
       if (!entry.open || entry.closed) return reply(503, { error: "browser-unavailable", accepted: sent });
-      // agent-browser's socket takes no text: typed text goes as key presses.
-      for (const ev of msg.type === "input_text" ? textAsKeys(msg.text) : [msg]) entry.ws.send(JSON.stringify(ev));
+      entry.ws.send(JSON.stringify(msg));
       sent += 1;
     }
     return reply(200, { ok: true, accepted: sent });
@@ -779,8 +602,6 @@ function _reset() {
   for (const name of [...sockets.keys()]) closeInputSocket(name);
   queues.clear();
   if (sweepTimer) { clearInterval(sweepTimer); sweepTimer = null; }
-  reviving = null;
-  drive._reset();
   deps = defaultDeps();
 }
 
@@ -788,20 +609,15 @@ module.exports = {
   LOCK_TTL_MS,
   MAX_EVENTS,
   NAVIGATE_TIMEOUT_MS,
-  START_PAGE,
-  START_SESSION,
   SWEEP_INTERVAL_MS,
-  agentSocketDir,
   checkEvent,
   chatOrigin,
   control,
-  fitView,
   handBackLine,
   input,
   navigate,
   release,
   renew,
-  start,
   startSweeper,
   status,
   sweepLock,

package/core/browser-lock.js

@@ -4,9 +4,7 @@
 // hook (core/tool-guard.js, C7), which runs as a separate process for every tool call and
 // re-reads it each time, like the tooling-mode switch (core/tooling-mode.js).
 //
-// { session, userId, name, chatId, since, expiresAt, fit?, bounds? }   (ISO times; atomic, 0600)
-// fit: the driver's view (core/browser-drive.js), bounds: the window's size before it, so a
-// restarted bot can bring the view back, and the hand back can put the window back.
+// { session, userId, name, chatId, since, expiresAt }   (ISO times; written atomically, 0600)
 //
 // An expired lock is no lock: it never blocks the bot, and the sweeper in
 // core/browser-control.js hands the browser back.
@@ -50,33 +48,4 @@ function removeLock() {
   try { fs.rmSync(driverFile(), { force: true }); } catch (_) { /* already gone */ }
 }
 
-// The bot was told to wait (core/tool-guard.js refused one of its agent-browser commands while
-// this lock was live), so the hand back must wake it. Keyed by the lock's `since`: a marker from
-// an earlier drive never counts. A separate file, because the tool guard runs in its own process
-// and the lock file is rewritten every second while someone drives.
-function waitingFile() {
-  return process.env.OC_BROWSER_WAITING_FILE || path.join(require("../config-dir"), "browser-waiting.json");
-}
-
-function markWaiting(lock) {
-  if (!lock || !lock.since) return;
-  try {
-    atomicWriteFileSync(waitingFile(), `${JSON.stringify({ since: lock.since, at: new Date().toISOString() })}\n`, { mode: 0o600 });
-  } catch (_) { /* best effort: the bot then just is not woken */ }
-}
-
-function waitedDuring(lock) {
-  if (!lock || !lock.since) return false;
-  try {
-    const mark = JSON.parse(fs.readFileSync(waitingFile(), "utf8"));
-    return !!mark && mark.since === lock.since;
-  } catch (_) {
-    return false;
-  }
-}
-
-function clearWaiting() {
-  try { fs.rmSync(waitingFile(), { force: true }); } catch (_) { /* already gone */ }
-}
-
-module.exports = { LOCK_TTL_MS, driverFile, readLock, lockExpiresAt, liveLock, writeLock, removeLock, markWaiting, waitedDuring, clearWaiting };
+module.exports = { LOCK_TTL_MS, driverFile, readLock, lockExpiresAt, liveLock, writeLock, removeLock };

package/core/browser-view.js

@@ -22,22 +22,11 @@
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
-const { EventEmitter } = require("events");
 const WebSocket = require("ws");
 
 const SESSION_NAME = /^[A-Za-z0-9._-]{1,64}$/;
 const DEFAULT_FPS = 5;
-const MAX_FPS = 30;
-
-// The phone and web view (core/browser-drive.js) publishes here while a person drives: "frame",
-// "fields" (the page's text fields) and "start" / "stop", each with the session's name. A viewer
-// of that session gets these instead of agent-browser's own frames, which follow neither the
-// driver's size nor the page's real size. `active` and `last` let a viewer that opens mid-drive
-// start with the picture at once.
-const driveFeed = new EventEmitter();
-driveFeed.setMaxListeners(200);
-driveFeed.active = null;
-driveFeed.last = null;
+const MAX_FPS = 10;
 const KEEPALIVE_MS = 25000;
 const ACTIVATE_TIMEOUT_MS = 1500;
 const TARGET_ID = /^[A-Za-z0-9]{8,64}$/; // static pages send no frames; comments keep proxies from closing the stream
@@ -224,77 +213,18 @@ function openStream(sessionName, { fps, sessions, connect = (url) => new WebSock
 
 // Server-sent events for one session: "frame" and "url" events, a final "end" event with the
 // reason, and ": ping" comments while the page is still. Every payload also carries its type,
-// for readers that only look at data lines. While a slow viewer's connection is backed up,
-// frames are not queued: only the newest waits, and goes out once the connection drains, so the
-// last picture of a scroll is never lost. While a person drives in the phone or web view, the
-// frames are the driver's (core/browser-drive.js), at most `fps` a second, with "fields" events
-// (the page's text fields) and "fit" events (the driver's view started, changed or ended).
-function serveStream(res, sessionName, { fps, sessions, connect, activate, keepaliveMs = KEEPALIVE_MS, feed = driveFeed } = {}) {
+// for readers that only look at data lines. Frames are skipped, never queued, while a slow
+// viewer's connection is backed up.
+function serveStream(res, sessionName, { fps, sessions, connect, activate, keepaliveMs = KEEPALIVE_MS } = {}) {
   res.writeHead(200, {
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache, no-store",
     "Connection": "keep-alive",
     "X-Accel-Buffering": "no",
   });
-  let closed = false;
   const write = (event, obj) => {
-    if (closed) return;
     try { res.write(`event: ${event}\ndata: ${JSON.stringify(obj)}\n\n`); } catch (_) { /* viewer gone */ }
   };
-  const interval = 1000 / clampFps(fps);
-  let lastSent = 0;
-  let pending = null;
-  let slot = null;
-  const flush = () => {
-    if (!pending || closed || res.writableNeedDrain) return;
-    const now = Date.now();
-    const due = lastSent + interval;
-    if (now < due) {
-      if (!slot) {
-        slot = setTimeout(() => { slot = null; flush(); }, due - now);
-        if (slot.unref) slot.unref();
-      }
-      return;
-    }
-    const msg = pending;
-    pending = null;
-    lastSent = now;
-    write("frame", msg);
-  };
-  const offerFrame = (msg) => {
-    pending = msg;
-    flush();
-  };
-  if (typeof res.on === "function") res.on("drain", flush);
-  let driving = feed.active === sessionName;
-  const onDriveFrame = (ev) => {
-    if (ev.session !== sessionName || !driving) return;
-    offerFrame({ type: "frame", seq: ev.frame.seq, data: ev.frame.data, metadata: ev.frame.metadata });
-  };
-  const onDriveFields = (ev) => {
-    if (ev.session !== sessionName || !driving) return;
-    write("fields", { type: "fields", fields: ev.fields, focused: ev.focused, editable: ev.editable });
-  };
-  const onDriveStart = (ev) => {
-    if (ev.session !== sessionName) return;
-    driving = true;
-    write("fit", { type: "fit", fit: ev.fit || null });
-  };
-  const onDriveStop = (ev) => {
-    if (ev.session !== sessionName) return;
-    driving = false;
-    write("fit", { type: "fit", fit: null });
-  };
-  feed.on("frame", onDriveFrame);
-  feed.on("fields", onDriveFields);
-  feed.on("start", onDriveStart);
-  feed.on("stop", onDriveStop);
-  const unsubscribe = () => {
-    feed.removeListener("frame", onDriveFrame);
-    feed.removeListener("fields", onDriveFields);
-    feed.removeListener("start", onDriveStart);
-    feed.removeListener("stop", onDriveStop);
-  };
   const heartbeat = setInterval(() => { try { res.write(": ping\n\n"); } catch (_) { /* viewer gone */ } }, keepaliveMs);
   const stream = openStream(sessionName, {
     fps,
@@ -302,30 +232,17 @@ function serveStream(res, sessionName, { fps, sessions, connect, activate, keepa
     connect,
     ...(activate ? { activate } : {}),
     onMessage: (msg) => {
-      if (msg.type === "frame") {
-        if (!driving) offerFrame(msg);
-        return;
-      }
+      if (msg.type === "frame" && res.writableNeedDrain) return;
       write(msg.type, msg);
     },
     onEnd: (reason) => {
       clearInterval(heartbeat);
-      unsubscribe();
       write("end", { type: "end", reason });
-      closed = true;
       try { res.end(); } catch (_) { /* viewer gone */ }
     },
   });
-  // A viewer that opens while someone drives starts with the driver's picture.
-  if (driving && feed.last && feed.last.session === sessionName) {
-    const f = feed.last.frame;
-    offerFrame({ type: "frame", seq: f.seq, data: f.data, metadata: f.metadata });
-  }
   res.on("close", () => {
-    closed = true;
     clearInterval(heartbeat);
-    if (slot) clearTimeout(slot);
-    unsubscribe();
     stream.close();
   });
 }
@@ -338,12 +255,10 @@ module.exports = {
   cdpEndpoint,
   clampFps,
   describeSessions,
-  driveFeed,
   listSessions,
   openStream,
   processAlive,
   safePageAddress,
   serveStream,
-  sessionTargetId,
   socketDirs,
 };