humanish 0.140.0 → 0.141.0

package/dist/guest/external-links.d.ts

@@ -0,0 +1,14 @@
+import type { CuaExecutor } from "../actors/computer-use/loop.js";
+/** Where the image keeps the stand-ins. */
+export declare const GUEST_EXTERNAL_LINK_BIN = "/opt/humanish/control/bin";
+/**
+ * Write the browser profile's Preferences before the first launch, so the initial app's origin
+ * opens tel:, sms: and the other app schemes without Chromium's prompt. No initial URL, no file.
+ */
+export declare function prepareGuestBrowserProfile(profileDir: string, initialUrl: string | undefined): Promise<void>;
+/**
+ * The executor with each observation carrying the links appended to `log` since the previous
+ * observation, at most EXTERNAL_HANDOFF_LIMITS.perObservation. A line still being written waits
+ * for the next observation. Every other property of the executor is kept.
+ */
+export declare function withExternalHandoffs(executor: CuaExecutor, log: string): CuaExecutor;

package/dist/guest/external-links.js

@@ -0,0 +1,48 @@
+// Links the guest browser hands to another app (mailto:, tel:, sms:). The guest has no email,
+// phone or messaging app. The image's stand-ins for xdg-open and xdg-email, first on the guest's
+// search path, append each such link to a log in the runtime directory, and every observation the
+// executor returns carries the links appended since the previous one.
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { EXTERNAL_HANDOFF_LIMITS, externalHandoffOf, } from "../actors/computer-use/external-handoff.js";
+import { externalAppPreferences } from "../evidence/browser-hygiene.js";
+/** Where the image keeps the stand-ins. */
+export const GUEST_EXTERNAL_LINK_BIN = "/opt/humanish/control/bin";
+/**
+ * Write the browser profile's Preferences before the first launch, so the initial app's origin
+ * opens tel:, sms: and the other app schemes without Chromium's prompt. No initial URL, no file.
+ */
+export async function prepareGuestBrowserProfile(profileDir, initialUrl) {
+    const preferences = externalAppPreferences(initialUrl);
+    if (preferences === undefined)
+        return;
+    await mkdir(`${profileDir}/Default`, { recursive: true, mode: 0o700 });
+    await writeFile(`${profileDir}/Default/Preferences`, JSON.stringify(preferences), {
+        mode: 0o600,
+        flag: "wx",
+    });
+}
+/**
+ * The executor with each observation carrying the links appended to `log` since the previous
+ * observation, at most EXTERNAL_HANDOFF_LIMITS.perObservation. A line still being written waits
+ * for the next observation. Every other property of the executor is kept.
+ */
+export function withExternalHandoffs(executor, log) {
+    let consumed = 0;
+    return {
+        ...executor,
+        observe: async () => {
+            const observation = await executor.observe();
+            const text = await readFile(log, "utf8").catch(() => "");
+            const lines = text
+                .split("\n")
+                .slice(0, -1)
+                .slice(consumed, consumed + EXTERNAL_HANDOFF_LIMITS.perObservation);
+            consumed += lines.length;
+            const externalHandoffs = lines.flatMap((line) => {
+                const handoff = externalHandoffOf(line);
+                return handoff === undefined ? [] : [handoff];
+            });
+            return externalHandoffs.length === 0 ? observation : { ...observation, externalHandoffs };
+        },
+    };
+}

package/dist/guest/runtime-desktop.js

@@ -14,6 +14,7 @@ import { GUEST_BOOTSTRAP_LIMITS, validateGuestInitialUrl } from "./bootstrap.js"
 import { startDesktopMedia, } from "./desktop-media.js";
 import { startDesktopRecorder } from "../evidence/desktop-recorder.js";
 import { createGuestProcesses, setupFailed } from "./runtime-processes.js";
+import { GUEST_EXTERNAL_LINK_BIN, prepareGuestBrowserProfile, withExternalHandoffs, } from "./external-links.js";
 /** The guest image's fixed layout. Tests derive guest paths from it rather than spelling them. */
 export const GUEST_RUNTIME_PATHS = Object.freeze({
     root: "/opt/humanish/control",
@@ -21,7 +22,8 @@ export const GUEST_RUNTIME_PATHS = Object.freeze({
     home: "/home/humanish",
 });
 const GUEST_RUNTIME_ENV = Object.freeze({
-    PATH: "/usr/bin:/bin",
+    // The stand-ins come first, so the browser hands a mailto: or tel: link to them.
+    PATH: `${GUEST_EXTERNAL_LINK_BIN}:/usr/bin:/bin`,
     HOME: "/home/humanish",
     USER: "humanish",
     LOGNAME: "humanish",
@@ -390,6 +392,7 @@ export async function createGuestRuntimeDesktop(options) {
         progress("layout");
         check();
         await verifyGuestLayout(check);
+        await prepareGuestBrowserProfile(`${GUEST_RUNTIME_PATHS.home}/browser`, options.initialUrl);
         progress("xauthority");
         await authorizeDisplay(processes, check);
         progress("display");
@@ -434,7 +437,7 @@ export async function createGuestRuntimeDesktop(options) {
             await openGuestFixture(browser.page, check);
         }
         return {
-            executor: state.media?.wrap(executor) ?? executor,
+            executor: withExternalHandoffs(state.media?.wrap(executor) ?? executor, `${GUEST_RUNTIME_ENV.XDG_RUNTIME_DIR}/humanish-links.log`),
             close,
             ...(options.recording === undefined
                 ? {}

package/dist/observer/data.d.ts

@@ -23,6 +23,10 @@ export interface ObserverData {
         state: "running" | "finished" | "interrupted" | "unknown";
         observedAt: string;
         source: "local-run-status";
+        /** Present while the run's own process analyzes it after the run ended: when it started. */
+        analysis?: {
+            startedAt: string;
+        };
     };
     run: {
         runId: string;

package/dist/observer/run-routes.js

@@ -15,7 +15,7 @@ import { displayedTraces, loadStreamTraces, } from "../run/stream-trace.js";
 import { isNodeError, isRecord } from "../run/type-guards.js";
 import { MAX_NOTE_FILE_BYTES, readRunNotes, RUN_NOTES_DIR, } from "../run/note-files.js";
 import { analysisCostOf, runCost, runCostLabel } from "../run/run-cost.js";
-import { RUN_STATUS_FILE, RUN_STATUS_STALE_MS, isRunStatusRecord, } from "../run/status.js";
+import { RUN_STATUS_FILE, RUN_STATUS_STALE_MS, runAnalysisPhase, isRunStatusRecord, } from "../run/status.js";
 import { renderObserverHtml } from "./artifact.js";
 import { parseFeedCursors } from "./feed-cursors.js";
 import { observerFeedBody } from "./page-data.js";
@@ -98,7 +98,9 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
     const derivedRoot = cleanedRelativePath.split("/")[0];
     const derivedLeaf = path.posix.basename(cleanedRelativePath);
     // Local-only files (raw sandbox ids, the recording pid) are read in process, never served.
-    if (derivedRoot === ".analysis-lock" ||
+    if (
+    // `.analysis-lock-stale-*` is a lock whose dead owner's next writer moved it aside.
+    derivedRoot?.startsWith(".analysis-lock") === true ||
         derivedLeaf.startsWith(".humanish-write-") ||
         isAnalysisRecordPath(cleanedRelativePath) ||
         isLocalOnlyRunFile(cleanedRelativePath)) {
@@ -330,9 +332,16 @@ function withLocalRunStatus(record, input, outcome) {
             state = "running";
         }
     }
+    // The run's own process analyzes it after the run ended; the bundle outcome does not say so.
+    const analysis = timestampsValid ? runAnalysisPhase(record, now) : undefined;
     return {
         ...data,
-        runtime: { state, observedAt: new Date(now).toISOString(), source: "local-run-status" },
+        runtime: {
+            state,
+            observedAt: new Date(now).toISOString(),
+            source: "local-run-status",
+            ...(analysis?.state === "running" ? { analysis: { startedAt: analysis.startedAt } } : {}),
+        },
     };
 }
 /** internal: exported for the stream lifecycle tests. */