@proagentstore/cli 0.4.133 → 0.4.134

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

@@ -60,6 +60,16 @@ export const LOCAL_APPLY_RECONCILIATION_HANDOFF_FRAME_PATH = "/local-apply/recon
 export const LOCAL_APPLY_RECONCILIATION_HANDOFF_INPUT_PATH = "/local-apply/reconciliation/handoff/input";
 export const LOCAL_APPLY_RECONCILIATION_HANDOFF_RESUME_PATH = "/local-apply/reconciliation/handoff/resume";
 export const LOCAL_APPLY_RECONCILIATION_HANDOFF_END_PATH = "/local-apply/reconciliation/handoff/end";
+/**
+ * A sign-in to the job's site in this machine's application browser profile, AFTER a fill ended
+ * `blocked` on `login_required` (#1100). Not a run and not a run's handoff: there is no engine, no
+ * source, no artifact and no submit gate — only the profile's page at the job's site, for the owner
+ * to sign in, and the profile's sign-in ledger (#1094) to record that they did.
+ */
+export const LOCAL_APPLY_SIGN_IN_PATH = "/local-apply/sign-in";
+export const LOCAL_APPLY_SIGN_IN_FRAME_PATH = "/local-apply/sign-in/frame";
+export const LOCAL_APPLY_SIGN_IN_INPUT_PATH = "/local-apply/sign-in/input";
+export const LOCAL_APPLY_SIGN_IN_END_PATH = "/local-apply/sign-in/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"];

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

@@ -0,0 +1,218 @@
+/**
+ * A post-run site sign-in in this machine's application browser profile (#1100).
+ *
+ * #1094 made the profile persistent and pauses a fill `login_required` before an uncertain press, so
+ * the owner signs in once through the fill's handoff. But that handoff exists only while the fill is
+ * paused. The reported run (9a7d9e85) paused at 11:32, nobody reached it before the run's 20-minute
+ * limit, and it ended `blocked` at 11:53; the owner asked to take over at 11:57 — when there was no
+ * paused fill, no retained page, and so nothing to stream. Every later fill would bounce off the same
+ * sign-in, because the only way to sign in had closed with the run.
+ *
+ * This opens the profile itself at the job's site, with no run: the owner signs in there, and `end`
+ * with `complete` records the sign-in in the profile's ledger (names and expiry only) so the next
+ * fill's session gate passes. It has no engine, no bridge, no source and no submit gate — the page is
+ * for a person, and nothing here fills or presses anything.
+ */
+import { join } from "node:path";
+import { RunnerInputError } from "../errors.js";
+import { siteKeyOf } from "./site-session.js";
+const SAFE_ID = /^[A-Za-z0-9_.:-]{1,300}$/;
+/** As long as the durable takeover it serves (`TAKEOVER_TTL_MS` in the Worker). */
+const TTL_MS = 60 * 60_000;
+export class LocalApplySignInRuntime {
+    deps;
+    sessions = new Map();
+    now;
+    schedule;
+    constructor(deps) {
+        this.deps = deps;
+        this.now = deps.now ?? (() => Date.now());
+        this.schedule = deps.schedule ?? ((task, delayMs) => {
+            const timer = setTimeout(task, delayMs);
+            return () => clearTimeout(timer);
+        });
+    }
+    /**
+     * Open the profile at the job's site, or read back the one already open under this id. Idempotent,
+     * so the cloud may call it whenever a frame finds no live page: a page the owner closed is reported
+     * closed, and a runner restart (nothing in memory) simply opens it again.
+     */
+    async open(raw) {
+        const request = parseRequest(raw);
+        const existing = this.sessions.get(request.signInId);
+        if (existing) {
+            if (existing.request.browserProfile !== request.browserProfile || existing.request.url !== request.url)
+                throw new RunnerInputError("The sign-in id is already bound to another profile or site", 409);
+            if (existing.state === "ready" && !(await this.pageLive(existing)))
+                await this.close(existing, "page_lost");
+            // A finished sign-in is an answer and is read back; one that closed without one (the owner
+            // closed the tab, the deadline passed) opens again — the cloud asks only under a live takeover.
+            if (existing.state === "ready" || existing.signedIn)
+                return this.view(existing);
+            this.sessions.delete(request.signInId);
+        }
+        for (const [id, s] of this.sessions)
+            if (s.state === "closed" && s.expiresAt <= this.now())
+                this.sessions.delete(id);
+        if ([...this.sessions.values()].some((s) => s.state === "ready" && s.request.browserProfile === request.browserProfile))
+            throw new RunnerInputError("Another sign-in is already open in this application browser; finish it first.", 409);
+        // The `default` profile's page is the runner's own browser page; never navigate it from under a run.
+        if (this.deps.busy())
+            throw new RunnerInputError("An application run is using this machine's application browser; sign in when it ends.", 409);
+        const site = siteKeyOf(new URL(request.url).hostname);
+        const takeover = this.deps.takeover;
+        let browser;
+        try {
+            if (!takeover)
+                throw new Error("no takeover");
+            browser = await this.deps.browserFor(request.browserProfile, join(this.deps.dataDir, "sign-in", request.signInId));
+        }
+        catch {
+            return this.closedView(request, site, "profile_unavailable");
+        }
+        const session = { request, site, browser, state: "ready", expiresAt: this.now() + TTL_MS };
+        this.sessions.set(request.signInId, session);
+        session.cancelDeadline = this.schedule(() => void this.close(session, "expired"), TTL_MS);
+        const page = this.page(session);
+        if (!page) {
+            await this.close(session, "profile_unavailable");
+            return this.view(session);
+        }
+        await browser.sessions?.beginSignIn(site).catch(() => undefined);
+        // A slow or redirecting site still leaves a page the owner can use; only a lost page is terminal.
+        await page.goto(request.url, { waitUntil: "domcontentloaded", timeout: 20_000 }).catch(() => undefined);
+        try {
+            await takeover.open({ handoffId: request.signInId }, page);
+        }
+        catch {
+            await this.close(session, "page_lost");
+        }
+        return this.view(session);
+    }
+    async frame(raw) {
+        const session = await this.live(raw);
+        try {
+            return await this.deps.takeover.frame(session.request.signInId);
+        }
+        catch {
+            await this.close(session, "page_lost");
+            throw new RunnerInputError("The sign-in page is no longer available", 409);
+        }
+    }
+    async input(raw) {
+        const o = raw && typeof raw === "object" ? raw : {};
+        const session = await this.live(o);
+        if (!o.input || typeof o.input !== "object")
+            throw new RunnerInputError("sign-in input is required");
+        try {
+            await this.deps.takeover.input(session.request.signInId, o.input);
+        }
+        catch {
+            await this.close(session, "page_lost");
+            throw new RunnerInputError("The sign-in page is no longer available", 409);
+        }
+    }
+    /** Close it. `complete: true` is the owner saying they signed in: the ledger records it first. */
+    async end(raw) {
+        const o = raw && typeof raw === "object" ? raw : {};
+        const session = this.require(o);
+        if (session.state === "ready" && o.complete === true) {
+            const recorded = await session.browser.sessions?.completeSignIn(session.site).catch(() => null);
+            if (recorded)
+                session.signedIn = recorded;
+        }
+        await this.close(session, session.signedIn ? undefined : "unavailable");
+        return this.view(session);
+    }
+    liveWork() {
+        return [...this.sessions.values()].filter((s) => s.state === "ready").map((s) => `sign-in:${s.request.signInId}`);
+    }
+    closeAll() {
+        for (const session of this.sessions.values())
+            void this.close(session, "runner_restarted");
+    }
+    async close(session, reason) {
+        if (session.state === "closed")
+            return;
+        // Terminal synchronously, so a deadline racing an `end` cannot tear down twice.
+        session.state = "closed";
+        session.terminalReason = reason;
+        session.cancelDeadline?.();
+        session.cancelDeadline = undefined;
+        await this.deps.takeover?.end(session.request.signInId).catch(() => undefined);
+        await session.browser.stop().catch(() => undefined);
+    }
+    async live(raw) {
+        const session = this.require(raw);
+        if (session.state === "ready" && session.expiresAt <= this.now())
+            await this.close(session, "expired");
+        if (session.state === "ready" && !(await this.pageLive(session)))
+            await this.close(session, "page_lost");
+        if (session.state !== "ready")
+            throw new RunnerInputError(`The sign-in is closed (${session.terminalReason ?? "finished"})`, 409);
+        return session;
+    }
+    async pageLive(session) {
+        return !!this.page(session) && (await this.deps.takeover?.state(session.request.signInId)) === "ready";
+    }
+    page(session) {
+        const page = session.browser.handoffPage?.();
+        return page && !page.isClosed() ? page : null;
+    }
+    require(raw) {
+        const id = raw?.signInId;
+        if (typeof id !== "string" || !SAFE_ID.test(id))
+            throw new RunnerInputError("signInId is required");
+        const session = this.sessions.get(id);
+        if (!session)
+            throw new RunnerInputError("Sign-in not found", 404);
+        return session;
+    }
+    view(session) {
+        return {
+            signInId: session.request.signInId,
+            browserProfile: session.request.browserProfile,
+            site: session.site,
+            state: session.state,
+            expiresAt: new Date(session.expiresAt).toISOString(),
+            ...(session.terminalReason ? { terminalReason: session.terminalReason } : {}),
+            ...(session.signedIn ? { signedIn: session.signedIn } : {}),
+        };
+    }
+    closedView(request, site, terminalReason) {
+        return { signInId: request.signInId, browserProfile: request.browserProfile, site, state: "closed", expiresAt: new Date(this.now()).toISOString(), terminalReason };
+    }
+}
+/** Separate from the fill's handoff and from reconciliation: this surface has no fill or submit operation. */
+export async function routeLocalApplySignIn(runtime, method, path, read) {
+    if (method !== "POST")
+        return undefined;
+    if (path === "/local-apply/sign-in")
+        return runtime.open(await read());
+    if (path === "/local-apply/sign-in/frame")
+        return runtime.frame(await read());
+    if (path === "/local-apply/sign-in/input") {
+        await runtime.input(await read());
+        return { ok: true };
+    }
+    if (path === "/local-apply/sign-in/end")
+        return runtime.end(await read());
+    return undefined;
+}
+function parseRequest(raw) {
+    const o = raw && typeof raw === "object" ? raw : {};
+    const signInId = typeof o.signInId === "string" ? o.signInId : "";
+    const browserProfile = o.browserProfile === "default" || o.browserProfile === "isolated" ? o.browserProfile : null;
+    const url = typeof o.url === "string" ? o.url : "";
+    let ok = false;
+    try {
+        const u = new URL(url);
+        ok = u.protocol === "https:" || u.protocol === "http:";
+    }
+    catch {
+        ok = false;
+    }
+    if (!SAFE_ID.test(signInId) || !browserProfile || !ok)
+        throw new RunnerInputError("sign-in needs an opaque signInId, a browserProfile and an http(s) url");
+    return { signInId, browserProfile, url };
+}

package/dist/browser-runner/runner.js

@@ -19,6 +19,7 @@ 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 { LocalApplyReconciliationRuntime } from "./local-apply/reconciliation-runtime.js";
+import { LocalApplySignInRuntime } from "./local-apply/sign-in-runtime.js";
 import { LOCAL_APPLY_TASK_TYPE } from "./local-apply/contract.js";
 import { createRunnerBrowserFactories } from "./local-apply/live-run-browser.js";
 import { createLocalApplyTakeoverAdapter, isLocalApplyTakeover } from "./local-apply/takeover-adapter.js";
@@ -95,6 +96,8 @@ export class LocalRunner {
     localApply;
     /** Browser-only, no-bridge reconciliation for an ended uncertain apply attempt. */
     localApplyReconciliation;
+    /** A site sign-in in the application profile after a fill ended blocked on it (#1100): no run, no bridge. */
+    localApplySignIn;
     /** The Website Builder's local author (#841): the signed-in CLI drafting through the PAGS broker. */
     siteBuilder;
     /** This runner's own local URL, once the server listens — the bridge forwarder calls back to it. */
@@ -118,6 +121,12 @@ export class LocalRunner {
             takeover: localApplyTakeover,
         });
         this.localApplyReconciliation = new LocalApplyReconciliationRuntime({ dataDir: config.dataDir, browserFor: applyBrowserFor, takeover: localApplyTakeover });
+        this.localApplySignIn = new LocalApplySignInRuntime({
+            dataDir: config.dataDir,
+            browserFor: applyBrowserFor,
+            takeover: localApplyTakeover,
+            busy: () => this.localApply.liveWork().length + this.localApplyReconciliation.liveWork().length + this.localBrowser.liveWork().length > 0,
+        });
         this.siteBuilder = new SiteBuilderRuntime({ dataDir: config.dataDir, selfUrl: () => this.selfUrl, onEvent: (id, type, message, data) => this.addTaskEvent(this.requireTask(id), type, message, data) });
         // Tasks paused/running on a previous process are orphaned now — their
         // pages and takeover sessions are gone. Fail them so the board is clean.
@@ -136,7 +145,7 @@ export class LocalRunner {
      */
     liveWork() {
         const coding = this.coding.liveWork();
-        const local = [...this.localBrowser.liveWork(), ...this.localArtifact.liveWork(), ...this.localApply.liveWork(), ...this.localApplyReconciliation.liveWork(), ...this.siteBuilder.liveWork()];
+        const local = [...this.localBrowser.liveWork(), ...this.localArtifact.liveWork(), ...this.localApply.liveWork(), ...this.localApplyReconciliation.liveWork(), ...this.localApplySignIn.liveWork(), ...this.siteBuilder.liveWork()];
         return { codingTurns: coding.length, localRuns: local.length, detail: [...coding, ...local].slice(0, 10) };
     }
     capabilities() {
@@ -320,6 +329,7 @@ export class LocalRunner {
         this.localArtifact.closeAll();
         this.localApply.closeAll();
         this.localApplyReconciliation.closeAll();
+        this.localApplySignIn.closeAll();
         try {
             this.coding.closeAll();
         }

package/dist/browser-runner/server.js

@@ -8,6 +8,7 @@ import { listGithubOrgs, listGithubRepos, searchGithubRepos, getGithubRepoDetail
 import { routeLocalApplyHandoff } from "./local-apply/handoff-routes.js";
 import { runNativePreflight } from "./native/preflight.js";
 import { routeLocalApplyReconciliation } from "./local-apply/reconciliation-routes.js";
+import { routeLocalApplySignIn } from "./local-apply/sign-in-runtime.js";
 export function createRunnerServer(runner) {
     return createServer(async (req, res) => {
         try {
@@ -273,6 +274,9 @@ async function route(runner, req, res) {
     const reconciliation = await routeLocalApplyReconciliation(runner.localApplyReconciliation, req.method, path, () => readJson(req));
     if (reconciliation !== undefined)
         return json(res, 200, reconciliation);
+    const signIn = await routeLocalApplySignIn(runner.localApplySignIn, req.method, path, () => readJson(req));
+    if (signIn !== undefined)
+        return json(res, 200, signIn);
     if (req.method === "POST" && path === "/local-apply/resume") {
         return json(res, 200, runner.localApply.resume(await readJson(req)));
     }

package/package.json

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