humanish 0.26.0 → 0.28.0

package/dist/cua-actor-lab.js

@@ -31,8 +31,9 @@ import { CHROMIUM_EVIDENCE_HYGIENE_FLAGS, chromiumEvidenceProfilePreferencesJson
 import { DEFAULT_OPENAI_CU_MODEL } from "./openai-responses-cu.js";
 import { createDesktopSandbox, loadE2BDesktopModule } from "./e2b-desktop-launch.js";
 import { probeUrl, readDetachedLog, runDetachedStep, startDetachedProcess } from "./e2b-detached.js";
-import { DEFAULT_SANDBOX_CATCH_PORT, collectCommsThread, deployCommsCatch } from "./comms-sandbox-catch.js";
+import { DEFAULT_SANDBOX_CATCH_PORT, collectCommsThread, deployCommsCatch, refreshInboxSurface, writeInboxSurface } from "./comms-sandbox-catch.js";
 import { FakeInbox } from "./comms-fake-inbox.js";
+import { buildOriginMap } from "./comms-inbox.js";
 import { DEFAULT_DEVICE_PRESET, isDevicePresetName, resolveDevicePreset } from "./device-presets.js";
 import { cuaLaneValidationReason, isHttpUrl, isLoopbackUrl, MAX_CUA_LANES, subjectStateInvalidReason } from "./lab-config.js";
 import { mapWithConcurrency } from "./concurrency.js";
@@ -110,6 +111,25 @@ export function composeLaneInstructions(args) {
         }
     };
 }
+/** Runtime-inject the persona inbox instruction into a lane's prompt (#297 slice B). The inbox URL is a
+ *  runtime loopback/getHost address (not secret), so — mirroring the lobby-code runtime injection — this
+ *  augments only the instructions the model receives; the authored prompt + its digest are unchanged.
+ *  Returns a new spec (never mutates). Shared by the CUA + concurrent shared-world routes. */
+export function withInboxMission(spec, inboxUrl) {
+    return {
+        ...spec,
+        instructions: `${spec.instructions}\n\nEmail inbox: when the app tells you it has emailed you (a verification link, confirmation code, or magic link), open ${inboxUrl} in the browser to read that email and follow its link or enter its code. All email the app sends you arrives there.`
+    };
+}
+/** True when a lane has a declared comms recipient WITH an address, so the drain can actually match the
+ *  mail the persona will be told to read. Gates the inbox instruction to lanes that can receive mail —
+ *  a lane told to check an inbox it can never receive into would just stall. */
+export function laneHasInboxRecipient(commsEmail, laneId) {
+    return (commsEmail.recipients ?? []).some((recipient) => recipient.lane === laneId && recipient.address !== undefined);
+}
+/** Mid-run inbox-surface render cadence (ms). Coarse enough that the per-tick `cat` + file writes stay
+ *  cheap; fine enough that a verification email is visible seconds after the app sends it. */
+const INBOX_SURFACE_CADENCE_MS = 2500;
 /**
  * The narrowest browser WINDOW Chrome/Chromium will render on the E2B desktop. Chrome refuses to
  * make its window narrower than this (~500 CSS px observed: a 414-wide X screen produced a 500-wide
@@ -1002,6 +1022,26 @@ export async function runCuaLane(spec, deps) {
     const commsEnv = commsEmail && commsPort !== undefined
         ? { [commsEmail.injectEnv]: `http://127.0.0.1:${commsPort}` }
         : {};
+    // Persona inbox SURFACE (#297 slice B): the loopback URL the persona opens to read captured mail; the
+    // origin-rewrite map (identity on this same-sandbox route, but covers localhost/0.0.0.0 alias skew + an
+    // operator-declared linkOrigin); and a disposable background loop that renders the surface DURING the
+    // session so the inbox is live when the persona checks. The surface uses its OWN FakeInbox + cursor,
+    // independent of the teardown evidence drain (two readers of the append-only NDJSON — no double-count).
+    const commsInboxUrl = commsEmail && commsPort !== undefined ? `http://127.0.0.1:${commsPort}/inbox` : undefined;
+    const commsOriginMap = commsEmail
+        ? buildOriginMap({
+            ...(config.subject.serve?.url === undefined ? {} : { internalServeUrl: config.subject.serve.url }),
+            reachableBaseUrl: targetUrl,
+            ...(commsEmail.linkOrigin === undefined ? {} : { linkOrigin: commsEmail.linkOrigin })
+        })
+        : [];
+    let surfaceChannel;
+    const surfaceInboxes = [];
+    let surfaceCursor = 0;
+    let surfaceDisposed = false;
+    let releaseSurface = () => { };
+    const surfaceDispose = new Promise((resolve) => { releaseSurface = resolve; });
+    let surfaceLoop;
     const warnings = [];
     const screenshots = [];
     const writeScreenshot = makeLaneWriteScreenshot(deps.artifactRoot, spec, screenshots);
@@ -1091,6 +1131,51 @@ export async function runCuaLane(spec, deps) {
             if (!deployedComms.ready) {
                 throw new Error(`comms email catch did not become ready on 127.0.0.1:${commsPort} in the subject sandbox`);
             }
+            // Stand up the live inbox surface: provision the declared-recipient inboxes on a dedicated surface
+            // channel, then start a background loop that drains-and-renders on a cadence so the persona sees new
+            // mail mid-session. Disposed at the TOP of the finally, before the teardown evidence drain.
+            surfaceChannel = new FakeInbox();
+            for (const recipient of commsEmail.recipients ?? []) {
+                if (recipient.address !== undefined)
+                    surfaceInboxes.push(await surfaceChannel.provisionAddress(recipient.lane, recipient.address));
+            }
+            // Write the EMPTY inbox once up front so the persona's /inbox always resolves to the "No messages
+            // yet." page — never a bare 404 — the instant it navigates there, even before any mail arrives OR if
+            // the app sends to an address no declared recipient matches (the loop only re-renders on new mail).
+            await writeInboxSurface(desktop, deployedComms.surfaceDir, [], { originMap: commsOriginMap, requestTimeoutMs: deps.requestTimeoutMs });
+            const deployedRef = deployedComms;
+            const surfaceChannelRef = surfaceChannel;
+            surfaceLoop = (async () => {
+                // Render-first (so even a short session gets a populated inbox), then refresh on a cadence. The
+                // cadence uses a REAL timer, NOT the injected instant clock: this loop is unbounded, so an instant
+                // sleep would busy-spin and starve the session's own timers. The wait is interruptible by
+                // surfaceDispose (and the timer cleared) so teardown never blocks for a full cadence.
+                for (;;) {
+                    try {
+                        const refreshed = await refreshInboxSurface({
+                            desktop,
+                            deployed: deployedRef,
+                            channel: surfaceChannelRef,
+                            inboxes: surfaceInboxes,
+                            cursor: surfaceCursor,
+                            originMap: commsOriginMap,
+                            requestTimeoutMs: deps.requestTimeoutMs
+                        });
+                        surfaceCursor = refreshed.cursor;
+                    }
+                    catch {
+                        // Never throw into the render loop; the teardown drain + by-id teardown must still run.
+                    }
+                    if (surfaceDisposed)
+                        break;
+                    await new Promise((resolve) => {
+                        const timer = setTimeout(resolve, INBOX_SURFACE_CADENCE_MS);
+                        void surfaceDispose.then(() => { clearTimeout(timer); resolve(); });
+                    });
+                    if (surfaceDisposed)
+                        break;
+                }
+            })();
         }
         // Per-lane geometry assertion (fail-closed) — the device claim is verified in-sandbox.
         const screenGeometry = await inspectDesktopScreenGeometry({
@@ -1210,7 +1295,11 @@ export async function runCuaLane(spec, deps) {
             const capModelId = config.actors[0]?.model ?? DEFAULT_OPENAI_CU_MODEL;
             const maxUsd = config.execution?.caps?.maxUsd;
             const sessionOptions = {
-                instructions: spec.instructions,
+                // Tell the persona where its inbox is — but only when comms is live AND this lane has a declared
+                // recipient it can actually receive mail into (else it would stall on an inbox that stays empty).
+                instructions: commsEmail && commsInboxUrl && deployedComms?.ready && laneHasInboxRecipient(commsEmail, spec.laneId)
+                    ? withInboxMission(spec, commsInboxUrl).instructions
+                    : spec.instructions,
                 persona: spec.persona,
                 timeoutMs: deps.timeoutMs,
                 openai: {
@@ -1252,6 +1341,13 @@ export async function runCuaLane(spec, deps) {
         sessionError = redactText(deps.scrubKnownValues(toErrorMessage(error)));
     }
     finally {
+        // Stop the mid-run inbox-surface loop FIRST — before the teardown evidence drain below — so the two
+        // `cat`s never overlap and the final surface state is deterministic. A surface failure can never
+        // block teardown (the loop body is fully try/caught and this await is on its already-caught promise).
+        surfaceDisposed = true;
+        releaseSurface();
+        if (surfaceLoop)
+            await surfaceLoop.catch(() => undefined);
         if (!provisioned) {
             signal(false);
         }