@proagentstore/cli 0.4.133 → 0.4.135

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

@@ -94,6 +94,7 @@ export const INSPECT_PAGE = `() => {
 		unavailable: new RegExp(UNAVAILABLE_TEXT_SOURCE, "i").test(text) ? (new RegExp(EXPIRED_TEXT_SOURCE, "i").test(text) ? "expired" : "unavailable") : null,
 	};
 }`;
+const signInQuestion = (site) => `Sign in to ${site} on this machine's application browser, then retry. Nothing was submitted.`;
 const text = (t, isError = false) => ({ content: [{ type: "text", text: t }], ...(isError ? { isError: true } : {}) });
 const textOf = (r) => (r.content ?? []).map((c) => c.text ?? "").join("\n");
 const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -283,7 +284,9 @@ export class ApplyBridge {
         if (!v || typeof v.url !== "string")
             return null;
         const unavailable = v.unavailable === "expired" || v.unavailable === "unavailable" ? v.unavailable : null;
-        return { url: v.url, title: String(v.title ?? ""), captcha: !!v.captcha, login: !!v.login, duplicate: !!v.duplicate, antiBot: !!v.antiBot, confirmed: !!v.confirmed, unavailable };
+        // A sign-in page by its ADDRESS too (#1100): SEEK's `login.seek.com/login` has no password field, so an
+        // "Apply" that bounced there ran on to `awaiting_review` with nothing filled. Same rule as the submit path.
+        return { url: v.url, title: String(v.title ?? ""), captcha: !!v.captcha, login: looksLikeSignIn(v.url, !!v.login), duplicate: !!v.duplicate, antiBot: !!v.antiBot, confirmed: !!v.confirmed, unavailable };
     }
     blockerOf(s) {
         return s.captcha ? "captcha" : s.antiBot ? "anti_bot" : s.duplicate ? "duplicate_application" : s.login ? "login_required" : null;
@@ -314,15 +317,19 @@ export class ApplyBridge {
         const blocker = this.blockerOf(state);
         if (!blocker)
             return text(toolText);
+        return this.holdFor(blocker, state);
+    }
+    /** A page that needs a person: pause for the owner, and remember a sign-in they complete (#1094). */
+    async holdFor(blocker, state) {
+        const host = hostOf(state.url) ?? "";
         this.host.emit({ type: "browser.blocked", url: state.url, domain: host, detail: { reason: blocker } });
         const site = blocker === "login_required" && host ? siteKeyOf(host) : null;
         if (site)
             await this.host.sessions?.beginSignIn(site).catch(() => undefined);
-        const ok = await this.pauseFor({ reason: blocker, url: state.url, domain: host }, async () => {
+        const ok = await this.pauseFor({ reason: blocker, url: state.url, domain: host, ...(site ? { question: signInQuestion(site) } : {}) }, async () => {
             const after = await this.inspect();
             return !!after && this.blockerOf(after) === null;
         });
-        // A sign-in the owner completed here is remembered for this browser profile (#1094).
         if (ok && site)
             await this.recordSignIn(site);
         if (!ok)
@@ -533,6 +540,12 @@ export class ApplyBridge {
         if (!phase)
             return text("supervisor_checkpoint needs phase initial, post_navigation, before_submit or uncertain.", true);
         const state = await this.inspect();
+        // A sign-in reached after the last landing — a late redirect (#1100, run 804bed49): hold for the owner as
+        // on landing. Reported to the cloud as a blocker it was stopped, and ended `incomplete`.
+        if (state?.login && !this.blocked) {
+            const held = await this.holdFor("login_required", state);
+            return held.isError ? held : text("The owner signed in. Take a browser_snapshot to read the page, then call supervisor_checkpoint again.");
+        }
         const blockers = new Set();
         if (state?.captcha)
             blockers.add("captcha");
@@ -588,8 +601,16 @@ export class ApplyBridge {
         this.host.emit({ type: "job.unavailable", url, domain, detail: { reason, source: "page_notice" } });
         return text(`Recorded the runner-verified ${reason} listing notice. Stop now.`);
     }
-    review(summary) {
+    async review(summary) {
         this.summary = summary; // bounded where the result is built (runtime.ts `end`)
+        // Nothing entered, on a sign-in page (#1100; runs abb37433, 7fb1e4f5): the outcome is the owner's sign-in,
+        // not an empty form "awaiting review" — a card that is not `login_required` offers them no sign-in at all.
+        const state = !this.filled && !this.uploaded.size && !this.blocked ? await this.inspect() : null;
+        const host = state?.login ? hostOf(state.url) : null;
+        if (state && host) {
+            this.host.emit({ type: "browser.blocked", url: state.url, domain: host, detail: { reason: "login_required" } });
+            this.blocked = { reason: "login_required", questions: [signInQuestion(siteKeyOf(host))] };
+        }
         // #989: "ready for review" with nothing entered is not a review state.
         //
         // The live run ended `awaiting_review` with `filled: 0, uploaded: 0` seconds after the cloud
@@ -655,7 +676,7 @@ export class ApplyBridge {
                     ],
                 };
             }
-            this.review(oneClick ? "Stopped at a one-click apply control: it can send the application outright, and this run fills and waits for review." : "Stopped at the final submit: this run fills and waits for review.");
+            await this.review(oneClick ? "Stopped at a one-click apply control: it can send the application outright, and this run fills and waits for review." : "Stopped at the final submit: this run fills and waits for review.");
             return text(oneClick
                 ? 'That control ("' + String(forward.element ?? "") + '") can send the application in one click, and this run is fill-and-review: it was NOT pressed. Approve this application if you want it sent. Stop now.'
                 : "That control submits the application, and this run is fill-and-review: it was NOT pressed. The application waits for the owner's review. Stop now.");

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

@@ -37,29 +37,6 @@ 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";
-/**
- * A separate, browser-only receipt/history check for an already-ended uncertain attempt.  This is
- * deliberately not an application run: it receives no engine, sources, artifacts or submit gate.
- */
-export const LOCAL_APPLY_RECONCILIATION_RUN_PATH = "/local-apply/reconciliation/run";
-export const LOCAL_APPLY_RECONCILIATION_STATUS_PATH = "/local-apply/reconciliation/status";
-export const LOCAL_APPLY_RECONCILIATION_HANDOFF_PATH = "/local-apply/reconciliation/handoff";
-export const LOCAL_APPLY_RECONCILIATION_HANDOFF_STATUS_PATH = "/local-apply/reconciliation/handoff-status";
-export const LOCAL_APPLY_RECONCILIATION_HANDOFF_FRAME_PATH = "/local-apply/reconciliation/handoff/frame";
-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";
 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"];
@@ -166,7 +143,6 @@ 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-contract.js

@@ -0,0 +1,34 @@
+/**
+ * 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";
+/**
+ * A separate, browser-only receipt/history check for an already-ended uncertain attempt.  This is
+ * deliberately not an application run: it receives no engine, sources, artifacts or submit gate.
+ */
+export const LOCAL_APPLY_RECONCILIATION_RUN_PATH = "/local-apply/reconciliation/run";
+export const LOCAL_APPLY_RECONCILIATION_STATUS_PATH = "/local-apply/reconciliation/status";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_PATH = "/local-apply/reconciliation/handoff";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_STATUS_PATH = "/local-apply/reconciliation/handoff-status";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_FRAME_PATH = "/local-apply/reconciliation/handoff/frame";
+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_HANDOFF_TERMINAL_REASONS = ["unavailable", "profile_unavailable", "profile_mismatch", "page_lost", "expired", "run_ended", "runner_restarted"];

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.135",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",