@proagentstore/cli 0.4.95 → 0.4.97

package/dist/browser-runner/local-apply/contract.js

@@ -35,6 +35,17 @@ export const LOCAL_APPLY_CANCEL_PATH = "/local-apply/cancel";
 export const LOCAL_APPLY_PREFLIGHT_PATH = "/local-apply/preflight";
 /** Delivers a cloud-persisted supervisory decision to one paused checkpoint. */
 export const LOCAL_APPLY_DIRECTIVE_PATH = "/local-apply/directive";
+/**
+ * A short-lived, owner-authorized view of the *existing* browser page for one local-apply run.
+ * The id is opaque and carries no browser/profile material.  It deliberately is not a task id:
+ * local-apply runs are not generic runner tasks.
+ */
+export const LOCAL_APPLY_HANDOFF_PATH = "/local-apply/handoff";
+export const LOCAL_APPLY_HANDOFF_STATUS_PATH = "/local-apply/handoff-status";
+export const LOCAL_APPLY_HANDOFF_FRAME_PATH = "/local-apply/handoff/frame";
+export const LOCAL_APPLY_HANDOFF_INPUT_PATH = "/local-apply/handoff/input";
+export const LOCAL_APPLY_HANDOFF_RESUME_PATH = "/local-apply/handoff/resume";
+export const LOCAL_APPLY_HANDOFF_END_PATH = "/local-apply/handoff/end";
 export const LOCAL_APPLY_ENGINES = ["claude", "codex"];
 export const LOCAL_APPLY_AUTH_MODES = ["machine", "subscription"];
 export const LOCAL_APPLY_MODES = ["fill_and_review", "auto_submit"];
@@ -84,23 +95,23 @@ export const LOCAL_APPLY_BLOCK_REASONS = [
  * dispatch, naming the update, rather than silently producing the older behaviour (`apply.ts`
  * `runnerContractProblem`).
  *
- * ── Why it moved to 0.4.90 (#953)
+ * ── Why it moved to 0.4.97 (#1013)
  *
- * #953 adds the read-only `/local-apply/preflight` route used before an email lead can enter
- * tailoring. That route lives in `packages/browser-runner`, which ships INSIDE the published CLI.
- * A machine below this floor cannot make the live/expired/unverifiable observation, so it must
- * not silently look equivalent to a current runner.
+ * #1013 adds the exact isolated-run browser handoff used when a sign-in or CAPTCHA blocks an
+ * application. That route lives in `packages/browser-runner`, which ships INSIDE the published
+ * CLI. A machine below this floor cannot retain the actual isolated page and must not silently
+ * substitute the shared/default browser page.
  *
  * A behaviour change in the runner is a CONTRACT change, because the cloud's decisions assume it.
- * So this floor moves with it: a machine that cannot observe a post-submit receipt is refused
- * with a sentence that says so, rather than reporting an unhelpful `submit_unconfirmed` state.
+ * So this floor moves with it: #1013's exact-page login/CAPTCHA handoff and post-submit receipt
+ * evidence are refused together rather than silently degrading to an unhelpful `submit_unconfirmed` state.
  *
  * Bump this when the runner's half of the contract changes again, together with the CLI version
  * that ships it — `policy.test.ts` pins the pair, so the floor cannot name a release that has not
  * been published. `cliAtLeast` treats an unreported version as capable, which is the convention
  * every MIN_CLI gate here follows.
  */
-export const LOCAL_APPLY_CONTRACT_MIN_CLI = "0.4.90";
+export const LOCAL_APPLY_CONTRACT_MIN_CLI = "0.4.97";
 export const LOCAL_APPLY_DIAGNOSTIC_CAUSES = ["bridge_unused", "engine_exited_nonzero", "timed_out", "no_engine_output", "submit_unconfirmed"];
 export const LOCAL_APPLY_CONFIRMATION_MARKERS = ["page_text", "url_receipt", "already_applied_notice"];
 export const LOCAL_APPLY_SIGNALS = [
@@ -140,6 +151,7 @@ export const LOCAL_APPLY_EVENT_TYPES = [
 export const LOCAL_APPLY_ENGINE_AUTHS = ["machine-login", "subscription", "api-key", "missing_login", "unknown"];
 export const LOCAL_APPLY_SUPERVISOR_DIRECTIVES = ["continue", "request_review", "stop"];
 export const LOCAL_APPLY_SUPERVISOR_PHASES = ["initial", "before_submit", "post_navigation", "uncertain"];
+export const LOCAL_APPLY_HANDOFF_TERMINAL_REASONS = ["unavailable", "profile_unavailable", "profile_mismatch", "page_lost", "expired", "run_ended", "runner_restarted"];
 export const LOCAL_APPLY_CAPS = { questions: 20, questionChars: 300, answers: 20, answerChars: 2000, summary: 2000 };
 const str = (v, max) => (typeof v === "string" && v.trim() ? v.trim().slice(0, max) : null);
 const oneOf = (list, v) => (list.includes(v) ? v : null);

package/dist/browser-runner/local-apply/handoff-routes.js

@@ -0,0 +1,21 @@
+/**
+ * The local-apply takeover surface is separate from generic task takeover: every request carries
+ * the exact run/application/profile binding that the runtime verifies before it reaches a page.
+ */
+export async function routeLocalApplyHandoff(runtime, method, path, read) {
+    if (method !== "POST")
+        return undefined;
+    if (path === "/local-apply/handoff")
+        return runtime.handoff(await read());
+    if (path === "/local-apply/handoff-status")
+        return runtime.handoffStatus(await read());
+    if (path === "/local-apply/handoff/frame")
+        return runtime.handoffFrame(await read());
+    if (path === "/local-apply/handoff/input") {
+        await runtime.handoffInput(await read());
+        return { ok: true };
+    }
+    if (path === "/local-apply/handoff/end" || path === "/local-apply/handoff/resume")
+        return runtime.endHandoff(await read());
+    return undefined;
+}

package/dist/browser-runner/local-apply/live-run-browser.js

@@ -0,0 +1,87 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { McpRuntime } from "../mcp-runtime.js";
+/** Bind application handoff to the run browser, not to the runner-wide active page. */
+export function createLocalApplyBrowserFactory(options) {
+    return async (profile, runDir) => {
+        if (profile === "isolated")
+            return createIsolatedApplyBrowser(runDir, options.headless);
+        const browser = await options.defaultBrowser(profile, runDir);
+        return { ...browser, handoffPage: options.sharedPage };
+    };
+}
+/**
+ * Start the disposable browser context for one application run and retain only its current live
+ * page for the bounded takeover adapter.  This deliberately does not seed, copy, or persist an
+ * owner profile: the profile remains the run's existing throwaway `runDir/profile` directory.
+ */
+export async function createIsolatedApplyBrowser(runDir, headless) {
+    const playwright = await import("playwright");
+    const profileDir = join(runDir, "profile");
+    let context;
+    let mcp;
+    let activePage = null;
+    let stopped = false;
+    try {
+        context = await playwright.chromium.launchPersistentContext(profileDir, {
+            headless,
+            acceptDownloads: true,
+            viewport: null,
+            args: [
+                "--disable-blink-features=AutomationControlled",
+                "--start-maximized",
+                "--window-size=1512,982",
+                "--remote-debugging-port=0",
+                "--use-fake-ui-for-media-stream",
+                "--use-fake-device-for-media-stream",
+            ],
+        });
+        await context.addInitScript(() => {
+            Object.defineProperty(navigator, "webdriver", { get: () => undefined });
+        }).catch(() => undefined);
+        const track = (page) => {
+            activePage = page;
+            // Never fall back to another tab after the exact page closes: that would hand a
+            // person a different site/page. A lost page is terminal for this handoff.
+            page.once("close", () => {
+                if (activePage === page)
+                    activePage = null;
+            });
+        };
+        context.on("page", track);
+        const initial = context.pages().at(-1) ?? await context.newPage();
+        track(initial);
+        mcp = new McpRuntime();
+        await mcp.start({ cdpEndpoint: await cdpEndpoint(profileDir) });
+        return {
+            tools: mcp,
+            handoffPage: () => activePage && !activePage.isClosed() ? activePage : null,
+            stop: async () => {
+                if (stopped)
+                    return;
+                stopped = true;
+                activePage = null;
+                await mcp.stop().catch(() => undefined);
+                await context.close().catch(() => undefined);
+            },
+        };
+    }
+    catch (error) {
+        await mcp?.stop().catch(() => undefined);
+        await context?.close().catch(() => undefined);
+        throw error;
+    }
+}
+async function cdpEndpoint(profileDir) {
+    const portFile = join(profileDir, "DevToolsActivePort");
+    for (let i = 0; i < 50; i++) {
+        if (existsSync(portFile)) {
+            const text = await import("node:fs/promises").then(({ readFile }) => readFile(portFile, "utf8"));
+            const port = text.split("\n", 1)[0]?.trim();
+            if (port)
+                return `http://127.0.0.1:${port}`;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error("could not read the local application browser CDP port");
+}

package/dist/browser-runner/local-apply/runtime-handoff.js

@@ -0,0 +1,120 @@
+import { RunnerInputError } from "../errors.js";
+const SAFE_ID = /^[A-Za-z0-9_.:-]{1,300}$/;
+const HANDOFF_TTL_MS = 10 * 60 * 1000;
+/** Exact-page lifecycle only. It deliberately has no access to a bridge, browser credentials, or run output. */
+export class LocalApplyHandoffRuntime {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async handoff(raw) {
+        const request = this.parse(raw);
+        const run = this.host.get(request.runId);
+        this.assertBinding(run, request);
+        if (run.state === "ended")
+            return this.closed(run, request.handoffId, "run_ended");
+        if (run.handoff)
+            throw new RunnerInputError("A handoff already exists for this application run", 409);
+        if (!this.host.takeover)
+            return this.closed(run, request.handoffId, "unavailable");
+        const page = run.browser?.handoffPage?.();
+        if (!page || page.isClosed())
+            return this.closed(run, request.handoffId, "page_lost");
+        try {
+            await this.host.takeover.open(request, page);
+        }
+        catch {
+            return this.closed(run, request.handoffId, "profile_unavailable");
+        }
+        run.handoff = { handoffId: request.handoffId, expiresAt: this.host.now() + (this.host.handoffTtlMs ?? HANDOFF_TTL_MS), state: "ready" };
+        return this.status(request);
+    }
+    async status(raw) {
+        const request = this.parse(raw);
+        const run = this.host.get(request.runId);
+        this.assertBinding(run, request);
+        if (run.state === "ended")
+            return this.closed(run, request.handoffId, "run_ended");
+        const handoff = run.handoff;
+        if (!handoff || handoff.handoffId !== request.handoffId)
+            return this.closed(run, request.handoffId, "unavailable");
+        if (handoff.state === "closed")
+            return this.response(run, handoff);
+        if (handoff.expiresAt <= this.host.now())
+            await this.close(run, "expired");
+        else if (!this.host.takeover || (await this.host.takeover.state(handoff.handoffId)) !== "ready")
+            await this.close(run, "page_lost");
+        return this.response(run, run.handoff);
+    }
+    async frame(raw) {
+        const { run, handoff } = await this.live(raw);
+        try {
+            return await this.host.takeover.frame(handoff.handoffId);
+        }
+        catch {
+            await this.close(run, "page_lost");
+            throw new RunnerInputError("The handoff page is no longer available", 409);
+        }
+    }
+    async input(raw) {
+        const o = raw && typeof raw === "object" ? raw : {};
+        const { run, handoff } = await this.live(o);
+        if (!o.input || typeof o.input !== "object")
+            throw new RunnerInputError("handoff input is required");
+        try {
+            await this.host.takeover.input(handoff.handoffId, o.input);
+        }
+        catch {
+            await this.close(run, "page_lost");
+            throw new RunnerInputError("The handoff page is no longer available", 409);
+        }
+    }
+    async end(raw) {
+        const request = this.parse(raw);
+        const run = this.host.get(request.runId);
+        this.assertBinding(run, request);
+        if (!run.handoff || run.handoff.handoffId !== request.handoffId)
+            return this.closed(run, request.handoffId, "unavailable");
+        await this.close(run, "unavailable");
+        return this.response(run, run.handoff);
+    }
+    parse(raw) {
+        const o = raw && typeof raw === "object" ? raw : {};
+        const handoffId = typeof o.handoffId === "string" ? o.handoffId : "";
+        const runId = typeof o.runId === "string" ? o.runId : "";
+        const applicationId = typeof o.applicationId === "string" ? o.applicationId : "";
+        const browserProfile = o.browserProfile === "default" || o.browserProfile === "isolated" ? o.browserProfile : null;
+        if (!SAFE_ID.test(handoffId) || !SAFE_ID.test(runId) || !SAFE_ID.test(applicationId) || !browserProfile)
+            throw new RunnerInputError("handoff needs opaque handoffId, runId, applicationId, and browserProfile");
+        return { handoffId, runId, applicationId, browserProfile };
+    }
+    assertBinding(run, request) {
+        if (run.envelope.applicationId !== request.applicationId || run.envelope.browserProfile !== request.browserProfile)
+            throw new RunnerInputError("The handoff does not match this application run", 403);
+    }
+    response(run, handoff) {
+        return { handoffId: handoff.handoffId, runId: run.envelope.runId, applicationId: run.envelope.applicationId, browserProfile: run.envelope.browserProfile, state: handoff.state, expiresAt: new Date(handoff.expiresAt).toISOString(), ...(handoff.terminalReason ? { terminalReason: handoff.terminalReason } : {}) };
+    }
+    closed(run, handoffId, terminalReason) {
+        const handoff = { handoffId, expiresAt: this.host.now(), state: "closed", terminalReason };
+        if (run.handoff?.handoffId === handoffId)
+            run.handoff = handoff;
+        return this.response(run, handoff);
+    }
+    async close(run, reason) {
+        const handoff = run.handoff;
+        if (!handoff || handoff.state === "closed")
+            return;
+        handoff.state = "closed";
+        handoff.terminalReason = reason;
+        if (this.host.takeover)
+            await this.host.takeover.end(handoff.handoffId).catch(() => undefined);
+    }
+    async live(raw) {
+        const status = await this.status(raw);
+        if (status.state !== "ready")
+            throw new RunnerInputError(`The handoff is closed (${status.terminalReason ?? "unavailable"})`, 409);
+        const run = this.host.get(status.runId);
+        return { run, handoff: run.handoff };
+    }
+}

package/dist/browser-runner/local-apply/runtime.js

@@ -37,6 +37,7 @@ import { ApplyBridge } from "./bridge.js";
 import { confirmationSignals } from "./confirmation.js";
 import { LOCAL_APPLY_AUTH_MODES, LOCAL_APPLY_CAPS, LOCAL_APPLY_ENGINES, LOCAL_APPLY_MODES, LOCAL_APPLY_TASK_TYPE, parseLocalApplyResult, } from "./contract.js";
 import { applyPrompt, buildApplyEngineSpec, observedApplyAuth } from "./engine.js";
+import { LocalApplyHandoffRuntime } from "./runtime-handoff.js";
 const MAX_EVENTS = 1000;
 const OUTPUT_LINES = 400;
 const SOURCE_BYTES = 256 * 1024;
@@ -169,6 +170,7 @@ function bridgeUnusedHelp(engine, d) {
 export class LocalApplyRuntime {
     deps;
     runs = new Map();
+    handoffs;
     /** Application fills that a restart would lose (#896) — their state is in this process. */
     liveWork() {
         return [...this.runs.values()].filter((r) => r.state !== "ended").map((r) => `an application fill (${r.envelope.applicationId.slice(0, 8)})`);
@@ -183,6 +185,7 @@ export class LocalApplyRuntime {
         this.now = deps.now ?? Date.now;
         this.spawn = deps.spawn ?? nodeSpawn;
         this.retentionMs = deps.retentionMs ?? 24 * 60 * 60 * 1000;
+        this.handoffs = new LocalApplyHandoffRuntime({ get: (runId) => this.get(runId), now: this.now, takeover: deps.takeover, handoffTtlMs: deps.handoffTtlMs });
         this.hydrateTerminalJournals();
     }
     /**
@@ -650,6 +653,12 @@ export class LocalApplyRuntime {
             ...(run.result ? { result: run.result } : {}),
         };
     }
+    /** A takeover only views the exact live page; it never authorizes the paused bridge. */
+    async handoff(raw) { return this.handoffs.handoff(raw); }
+    async handoffStatus(raw) { return this.handoffs.status(raw); }
+    async handoffFrame(raw) { return this.handoffs.frame(raw); }
+    async handoffInput(raw) { return this.handoffs.input(raw); }
+    async endHandoff(raw) { return this.handoffs.end(raw); }
     /** Does this token belong to this run? The bridge forwarder's only credential. */
     authorizeBridge(runId, token) {
         const run = this.runs.get(runId);
@@ -689,6 +698,10 @@ export class LocalApplyRuntime {
     end(run, r) {
         if (run.state === "ended")
             return;
+        // A terminal application outcome never means that a handoff succeeded.  Tear down only the
+        // live view and retain the explicit closed state for a caller that polls before restart.
+        if (run.handoff?.state === "ready")
+            void this.handoffs.close(run, "run_ended");
         if (run.state === "paused")
             this.release(run, "stopped");
         if (run.timer)

package/dist/browser-runner/local-apply/takeover-adapter.js

@@ -0,0 +1,26 @@
+import { RunnerInputError } from "../errors.js";
+const prefix = "local-apply:";
+export function isLocalApplyTakeover(id) { return id.startsWith(prefix); }
+/** Attach the bounded local-apply view to the runner's existing live-page takeover machinery. */
+export function createLocalApplyTakeoverAdapter(deps) {
+    const key = (handoffId) => `${prefix}${handoffId}`;
+    return {
+        async open(request, page) {
+            const id = key(request.handoffId);
+            if (deps.get(id))
+                throw new RunnerInputError("A local application handoff already exists", 409);
+            // Do not create or substitute a page here. The runtime supplied the page retained by
+            // this exact run/profile; a destroyed page must remain a lost handoff, never look ready.
+            if (!page || page.isClosed())
+                throw new RunnerInputError("The local application page is no longer available", 409);
+            deps.set(id, page);
+        },
+        async state(handoffId) {
+            const session = deps.get(key(handoffId));
+            return session && !session.page.isClosed() ? "ready" : "page_lost";
+        },
+        frame: (handoffId) => deps.frame(key(handoffId)),
+        input: (handoffId, input) => deps.input(key(handoffId), input),
+        end: (handoffId) => deps.end(key(handoffId)),
+    };
+}

package/dist/browser-runner/runner.js

@@ -18,6 +18,8 @@ import { LocalArtifactRuntime } from "./local-artifact/runtime.js";
 import { LOCAL_ARTIFACT_TASK_TYPE } from "./local-artifact/contract.js";
 import { LocalApplyRuntime } from "./local-apply/runtime.js";
 import { LOCAL_APPLY_TASK_TYPE } from "./local-apply/contract.js";
+import { createLocalApplyBrowserFactory } from "./local-apply/live-run-browser.js";
+import { createLocalApplyTakeoverAdapter, isLocalApplyTakeover } from "./local-apply/takeover-adapter.js";
 import { WORKFLOW_DRIVEN_TASKS } from "./task-types.js";
 /** True for a plain object. */
 function isRecord(value) {
@@ -103,9 +105,15 @@ export class LocalRunner {
             await mcp.start({ userDataDir: join(runDir, "profile"), headless: config.headless });
             return { tools: mcp, stop: () => mcp.stop() };
         };
+        const applyBrowserFor = createLocalApplyBrowserFactory({ headless: config.headless, defaultBrowser: browserFor, sharedPage: () => this.activePage });
         this.localBrowser = new LocalBrowserRuntime({ dataDir: config.dataDir, selfUrl: () => this.selfUrl, browserFor });
         this.localArtifact = new LocalArtifactRuntime({ dataDir: config.dataDir });
-        this.localApply = new LocalApplyRuntime({ dataDir: config.dataDir, selfUrl: () => this.selfUrl, browserFor });
+        this.localApply = new LocalApplyRuntime({
+            dataDir: config.dataDir,
+            selfUrl: () => this.selfUrl,
+            browserFor: applyBrowserFor,
+            takeover: createLocalApplyTakeoverAdapter({ get: (id) => this.takeovers.get(id), set: (id, page) => this.takeovers.set(id, { page, reason: "local_apply", humanDone: false }), frame: (id) => this.takeoverFrame(id), input: (id, input) => this.takeoverInput(id, input), end: (id) => this.endTakeover(id) }),
+        });
         // Tasks paused/running on a previous process are orphaned now — their
         // pages and takeover sessions are gone. Fail them so the board is clean.
         const expired = this.store.expireInFlightTasks();
@@ -365,7 +373,7 @@ export class LocalRunner {
     }
     /** Active human-takeover task ids (for status/discovery). */
     listTakeovers() {
-        return [...this.takeovers.keys()];
+        return [...this.takeovers.keys()].filter((id) => !isLocalApplyTakeover(id));
     }
     requireTakeover(taskId) {
         const session = this.takeovers.get(taskId);

package/dist/browser-runner/server.js

@@ -4,6 +4,7 @@ import { LocalRunner, RunnerInputError } from "./runner.js";
 import { probeGitSshIdentity } from "./coding/repo.js";
 import { checkEngine } from "./coding/engine-check.js";
 import { listGithubOrgs, listGithubRepos, searchGithubRepos, getGithubRepoDetail, getGithubCredentialScope } from "./coding/github-browse.js";
+import { routeLocalApplyHandoff } from "./local-apply/handoff-routes.js";
 export function createRunnerServer(runner) {
     return createServer(async (req, res) => {
         try {
@@ -226,7 +227,6 @@ async function route(runner, req, res) {
         return json(res, 200, runner.localArtifact.cancel(await readJson(req)));
     }
     // Local application execution (#957) — run, status, resume, cancel; PULL like research.
-    // The email-lead preflight is read-only and precedes Tailor material generation (#953).
     if (req.method === "POST" && path === "/local-apply/preflight") {
         return json(res, 200, await runner.localApply.preflight(await readJson(req)));
     }
@@ -236,6 +236,9 @@ async function route(runner, req, res) {
     if (req.method === "POST" && path === "/local-apply/status") {
         return json(res, 200, runner.localApply.status(await readJson(req)));
     }
+    const handoff = await routeLocalApplyHandoff(runner.localApply, req.method, path, () => readJson(req));
+    if (handoff)
+        return json(res, 200, handoff);
     if (req.method === "POST" && path === "/local-apply/resume") {
         return json(res, 200, runner.localApply.resume(await readJson(req)));
     }

package/dist/index.js

@@ -1875,8 +1875,7 @@ var RelayMutationAdmission = class {
   }
 };
 
-// src/commands/runner/relay.ts
-var MEMBERSHIP_SYNC_PATH = "/pags/membership/sync";
+// src/commands/runner/runner-work-observation.ts
 function observedRunnerWork(observation) {
   const sessions = observation.sessions;
   const work = observation.work;
@@ -1900,6 +1899,9 @@ function observedRunnerWork(observation) {
     ...Array.from({ length: localRuns }, (_v, i) => localDetail[i] || `local-run-${i + 1}`)
   ];
 }
+
+// src/commands/runner/relay.ts
+var MEMBERSHIP_SYNC_PATH = "/pags/membership/sync";
 var CLI_CONTROL_PATHS = /* @__PURE__ */ new Set([MEMBERSHIP_SYNC_PATH, RUNNER_UPDATE_PATH]);
 async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force = false, watchInstances = false) {
   const apiBase = pagsApiBase(opts.apiBase).replace(/^http/, "ws");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-	"version": "0.4.95",
+	"version": "0.4.97",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",