@superblocksteam/gateway 2.0.155-next.0

package/dist/capabilities/types.d.ts

@@ -0,0 +1,446 @@
+import type { BrowserDriverContract } from "../capture/browser-contract.js";
+import type { EventCursor } from "../events/cursor.js";
+import type { LostEventRange } from "../events/types.js";
+export type { CallerChannel, CallerRef } from "../resume/types.js";
+export type CallerKind = "mcp";
+/**
+ * The caller behind a capability invocation.
+ *
+ * Identity is optional because MCP hands over only the credential and lets the
+ * capability resolve it. Whoever resolves it, it is resolved exactly once —
+ * `/users/me` is the most expensive endpoint the Superblocks API exposes.
+ */
+export type Principal = {
+    apiKey: string;
+    email?: string;
+    organizationId?: string;
+    userId?: string;
+};
+/** A principal whose identity the Superblocks API has confirmed. */
+export type ResolvedPrincipal = Principal & {
+    organizationId: string;
+    userId: string;
+};
+export type ProgressEvent = {
+    message: string;
+    type: "progress" | "auth_required" | "completed" | "error";
+};
+export type AuthElicitation = {
+    authUrl: string;
+    browser?: BrowserDriverContract;
+    reason: "idp_step_up";
+    turnId: string;
+};
+/**
+ * A failed capability, and the application it was working on when it failed.
+ *
+ * `start_app` persists an application row before it ever reaches live edit, so
+ * a failure past that point leaves the caller owning a resource it was never
+ * handed. `applicationId` is that handle, and it is a field because the
+ * alternative callers actually resorted to — regex a UUID out of `message`, or
+ * else fall back to "the most recent app" — drives another caller's build in
+ * any session with more than one of them.
+ */
+export type CapabilityError = {
+    /** Absent only when the call failed before it had an application at all. */
+    applicationId?: string;
+    code: string;
+    kind: "error";
+    message: string;
+    /** Set when resending the prompt is what recovers this application. */
+    pendingAction?: PendingAppAction;
+};
+export type CapabilityResult<T> = {
+    kind: "ok";
+    value: T;
+} | {
+    kind: "auth_required";
+    elicitation: AuthElicitation;
+} | CapabilityError;
+export type GenerationStatus = "cancelled" | "completed"
+/**
+ * Clark took the prompt but pushes nothing the gateway can see, so its
+ * progress is only visible in the editor. The job itself keeps running.
+ */
+ | "detached"
+/**
+ * The turn never ran to an outcome because the live-edit session did not: it
+ * went away mid-flight, or it never opened at all. Distinct from `timeout`:
+ * the turn did not run out of time, the thing that was to run it was not
+ * there, and retrying is the right response.
+ */
+ | "live_edit_terminated"
+/** The job ended without writing a file or leaving a draft. */
+ | "no_changes" | "needs_decision" | "timeout";
+/**
+ * How far a `start_app` / `edit_app` call follows the turn it starts.
+ *
+ * - `turn`: block until Clark's job is done (HTTP).
+ * - `ack`: return as soon as Clark accepts the prompt and let the caller follow
+ *   the build through `check_app_progress`. The only way an MCP client that
+ *   sends no `progressToken` — Claude Desktop — can show anything mid-build.
+ */
+export type TurnWait = "ack" | "turn";
+/**
+ * Where a build stands.
+ *
+ * `unknown` means the gateway is not following a turn for this app: it finished
+ * and was already reported, or nothing was ever started here.
+ */
+export type BuildStatus = "building" | "cancelled"
+/**
+ * Clark is working but out of the gateway's sight — polling cannot report it,
+ * and only the editor can. Ends the poll loop instead of running it out.
+ */
+ | "detached"
+/**
+ * The live-edit session backing the turn died before it finished, or never
+ * opened. Nothing was built, and the caller should retry rather than keep
+ * polling.
+ */
+ | "live_edit_terminated" | "needs_decision"
+/** Clark's job ended having built nothing; there is no app to show. */
+ | "no_changes" | "ready" | "timeout" | "unknown";
+/**
+ * How a finished turn reads as a build status.
+ *
+ * Every member is spelled out and the default is unreachable on purpose. A
+ * `default: return "ready"` would answer "your app is fine" for any status
+ * added later, which is how a dead live edit came to be reported as `ready`
+ * in the first place; this way the compiler stops the next one.
+ */
+export declare function buildStatusOf(generationStatus: GenerationStatus): BuildStatus;
+export type StartAppInput = {
+    branch?: string;
+    idempotencyKey: string;
+    /** Defaults to PLAN (editor parity). Pass BUILD to skip planning. */
+    mode?: "BUILD" | "PLAN";
+    name?: string;
+    prompt: string;
+    wait?: TurnWait;
+};
+export type DecisionPayload = {
+    kind: "multi_choice";
+    messageId?: string;
+    options: string[];
+    question: string;
+} | {
+    kind: "plan";
+    messageId?: string;
+    plan: string;
+    title?: string;
+};
+export type StartAppResult = {
+    /** Clark's chat lines since the previous report, oldest first. */
+    activity?: string[];
+    applicationId: string;
+    /** Host-driver steer. Tokens never belong here. */
+    browser?: BrowserDriverContract;
+    /**
+     * Checkpoint the gateway committed for Clark's work. Absent when Clark left
+     * nothing to commit or the checkpoint did not land.
+     */
+    checkpointCommitId?: string;
+    /** Absent while the build is still running (`wait: "ack"`). */
+    reply?: string;
+    /** Present when status is needs_decision. */
+    decision?: DecisionPayload;
+    editUrl: string;
+    /** Absent while the build is still running (`wait: "ack"`). */
+    generationStatus?: GenerationStatus;
+    liveEditId?: string;
+    /** Mode this turn ran in, so the caller can say whether Clark is planning. */
+    mode?: "BUILD" | "PLAN";
+    name: string;
+    /** Mid-turn testApi / testIntegration outcomes when the turn finished. */
+    recentRuns?: RecentToolRun[];
+    status: BuildStatus;
+    /** Absent while the build is still running (`wait: "ack"`). */
+    viewStatus?: "ready" | "unknown";
+};
+export type CheckAppProgressInput = {
+    applicationId?: string;
+    /**
+     * Resume from an explicit position instead of the one stored for this
+     * caller. Only needed when a caller keeps its own place — an omitted cursor
+     * reads from wherever the gateway last left this caller.
+     */
+    cursor?: EventCursor;
+};
+/**
+ * Machine-readable pacing, so a caller polls on the gateway's terms rather
+ * than on a number the model invented.
+ *
+ * Every long-running result carries a poll interval whether or not the host
+ * supports progress notifications: a host that ignores progress still has to be
+ * told when to come back.
+ */
+export type PollPacing = {
+    /** Cursor to resume from. Stable JSON; hand it back verbatim. */
+    cursor?: EventCursor;
+    /** How long to wait before asking again. Zero once nothing is in flight. */
+    nextPollAfterMs: number;
+    /**
+     * What is left of the turn budget before the gateway gives up on it.
+     *
+     * Present only while this gateway is following the turn itself and can see
+     * its clock, which is the only case where the number means anything. It used
+     * to be sent unconditionally, so a poll of an app with no turn at all
+     * answered with the full budget next to a zero elapsed - a fresh,
+     * fully-funded turn, asserted about nothing (ENG-5808).
+     *
+     * Absent does not mean "nothing is running": a build read out of the
+     * persisted stream reports `building` without a budget, because the turn is
+     * running somewhere this process cannot time it.
+     * {@link PollPacing.nextPollAfterMs} and the status are what say whether to
+     * keep polling.
+     */
+    remainingTurnBudgetMs?: number;
+    /**
+     * Producers whose retained history had already passed the resumed cursor.
+     * Present only when something was actually lost.
+     */
+    staleStreams?: LostEventRange[];
+};
+/**
+ * A nonterminal warning that a build has gone quiet, raised well before the
+ * turn budget runs out so a caller can say something rather than sit on a
+ * silent poll loop until it times out.
+ */
+export type StallHint = {
+    /** How long the build has been running without saying anything new. */
+    quietMs: number;
+    reason: "long_quiet";
+};
+export type CheckAppProgressResult = PollPacing & {
+    /** Clark's chat lines since the previous poll, oldest first. */
+    activity: string[];
+    applicationId: string;
+    /** How long Clark has been on this turn, so a quiet poll still has news. */
+    elapsedSeconds: number;
+    /** See StartAppResult.checkpointCommitId. */
+    checkpointCommitId?: string;
+    /** Present once the turn has finished. */
+    reply?: string;
+    /** Present when status is needs_decision. */
+    decision?: DecisionPayload;
+    editUrl: string;
+    /** Present once the turn has finished. */
+    generationStatus?: GenerationStatus;
+    /** Recent mid-turn testApi / testIntegration outcomes, oldest first. */
+    recentRuns?: RecentToolRun[];
+    /** Emitted once per quiet spell, never in place of a terminal answer. */
+    stallHint?: StallHint;
+    status: BuildStatus;
+    /** Present once the turn has finished. */
+    viewStatus?: "ready" | "unknown";
+};
+/**
+ * One mid-turn testApi or testIntegration result surfaced to MCP clients.
+ * Output/error strings are truncated so tool results stay readable.
+ */
+export type RecentToolRun = {
+    kind: "test_api" | "test_integration";
+    name: string;
+    success: boolean;
+    summary: string;
+    at: string;
+};
+export type EditAppInput = {
+    applicationId?: string;
+    branch?: string;
+    idempotencyKey: string;
+    /** Defaults to PLAN. Approve forces BUILD with planContext.approved. */
+    mode?: "BUILD" | "PLAN";
+    /**
+     * Approve or refine a pending Clark plan. When omitted and a plan is pending,
+     * a normal prompt is treated as refine feedback. `approve` does not need a
+     * prompt — the pending plan is sent as the build prompt.
+     */
+    planAction?: "approve" | "refine";
+    /** Required unless `planAction` is `approve`. */
+    prompt?: string;
+    wait?: TurnWait;
+};
+export type EditAppResult = {
+    /** Clark's chat lines since the previous report, oldest first. */
+    activity?: string[];
+    applicationId: string;
+    /** Host-driver steer. Tokens never belong here. */
+    browser?: BrowserDriverContract;
+    /** See StartAppResult.checkpointCommitId. */
+    checkpointCommitId?: string;
+    /** Absent while the build is still running (`wait: "ack"`). */
+    reply?: string;
+    /** Present when status is needs_decision. */
+    decision?: DecisionPayload;
+    editUrl: string;
+    /** Absent while the build is still running (`wait: "ack"`). */
+    generationStatus?: GenerationStatus;
+    /**
+     * Mode this turn actually ran in. Follow-ups stay BUILD once a plan was
+     * approved, so the caller can see it does not need to re-send mode.
+     */
+    mode?: "BUILD" | "PLAN";
+    /** Mid-turn testApi / testIntegration outcomes when the turn finished. */
+    recentRuns?: RecentToolRun[];
+    status: BuildStatus;
+    /** Absent while the build is still running (`wait: "ack"`). */
+    viewStatus?: "ready" | "unknown";
+};
+export type PreviewAppInput = {
+    applicationId?: string;
+    branch?: string;
+    /**
+     * Capture a deployed-shell screenshot when the preview is ready. `get_app`
+     * sets this false when it will screenshot the live library instead.
+     */
+    includeScreenshot?: boolean;
+    /**
+     * Whether to wait for the build. See {@link GetAppInput.wait}; `false`
+     * starts or observes the build and returns `status: "building"` at once.
+     */
+    wait?: boolean;
+};
+export type PreviewAppResult = {
+    applicationId: string;
+    browser?: BrowserDriverContract;
+    /**
+     * True when preview URLs are returned but Gateway cannot screenshot because
+     * there is no Chromium and no host browser MCP.
+     */
+    needsBrowserDriver?: boolean;
+    /** Commit that was built and is being previewed. */
+    commitId: string;
+    /** Editor URL for the same app (MCP App Open editor button). */
+    editUrl: string;
+    /** Display name, so callers can say more than a UUID. Absent when unknown. */
+    name?: string;
+    previewUrl: string;
+    /**
+     * Direct viewer URL used for screenshots (may be http localhost even when
+     * `previewUrl` is an https gateway redirect).
+     */
+    viewerUrl?: string;
+    /**
+     * True when `previewUrl` is https and Claude Desktop can openLink it.
+     */
+    openableViaHttps?: boolean;
+    /**
+     * Base64 JPEG of the running preview when capture succeeds. Absent when
+     * capture was skipped (still building) or soft-failed.
+     */
+    screenshotBase64?: string;
+    /**
+     * `building` means the URL is right but SABS has not finished building it
+     * yet; previewing again resumes watching the same build.
+     */
+    status: "building" | "ready";
+};
+export type GetAppInput = {
+    applicationId?: string;
+    branch?: string;
+    /** When true, ensure a preview build exists and return preview URLs. */
+    ensurePreview?: boolean;
+    /**
+     * Whether to wait for the preview build.
+     *
+     * A boolean, and deliberately not the {@link TurnWait} the prompt
+     * capabilities take: this decides how long *this call* blocks on a build,
+     * while `wait: "ack"` decides how far a prompt follows the turn it starts.
+     * Conflating them would make `wait: "ack"` mean something here, where there
+     * is no turn to acknowledge.
+     *
+     * `false` starts or observes the build and returns straight away with
+     * `status: "building"` and pacing to poll on. `true` (the default) waits,
+     * but never past the host's tool-call ceiling — it returns `building` with
+     * the same pacing rather than holding the call open.
+     */
+    wait?: boolean;
+};
+/**
+ * What has to happen before this app has anything worth previewing. Present
+ * only when the gateway declined to build one, and paired with the status that
+ * says why.
+ */
+export type PendingAppAction = 
+/** Clark asked a multi_choice question; answer it with `edit_app`. */
+"answer_question"
+/** Clark proposed a plan; `edit_app` with `planAction: "approve"` builds it. */
+ | "approve_plan"
+/** The last turn ended without writing anything; `edit_app` starts it over. */
+ | "retry_build"
+/** A turn is in flight; follow it with `check_app_progress`. */
+ | "wait_for_build";
+export type GetAppResult = Partial<PollPacing> & {
+    applicationId: string;
+    browser?: BrowserDriverContract;
+    commitId?: string;
+    /** The question or plan Clark is waiting on, when status is needs_decision. */
+    decision?: DecisionPayload;
+    editUrl: string;
+    /** Display name, so callers can say more than a UUID. Absent when unknown. */
+    name?: string;
+    openableViaHttps?: boolean;
+    /** Set whenever no preview was built; says what unblocks one. */
+    pendingAction?: PendingAppAction;
+    needsBrowserDriver?: boolean;
+    previewUrl?: string;
+    publishUrl?: string;
+    screenshotBase64?: string;
+    /**
+     * `cancelled`, `live_edit_terminated`, `no_changes` and `timeout` mean the
+     * last turn left nothing to show, so no preview was built for it.
+     */
+    status: "building" | "cancelled" | "live_edit_terminated" | "needs_decision" | "no_changes" | "ready" | "timeout" | "unknown";
+    viewerUrl?: string;
+};
+export type PublishAppInput = {
+    applicationId?: string;
+    branch?: string;
+    commitId?: string;
+    idempotencyKey: string;
+    prompt: string;
+};
+export type PublishAppResult = {
+    applicationId: string;
+    commitId: string;
+    /** Present when the deploy response carried an id. */
+    deploymentId?: string;
+    publishUrl: string;
+    status: "deployed";
+};
+/**
+ * Gateway MCP/HTTP import rejects archives above this size. Larger ZIPs almost
+ * certainly include `node_modules` (or similar); those belong outside the
+ * export — deps are installed on or after import. Stricter than the browser
+ * migration UI (50 MB) on purpose.
+ */
+export declare const IMPORT_ZIP_MAX_BYTES = 1048576;
+/**
+ * Ceiling on an inline `zipBase64` payload, far below
+ * {@link IMPORT_ZIP_MAX_BYTES} because base64 is not a transport a model can
+ * afford: every 3 bytes of archive cost 4 characters it has to write out one
+ * token at a time, so even a 42 KB export runs to 57,000 characters and the
+ * tool call never gets sent. Real archives arrive by name — this size only
+ * carries test fixtures.
+ */
+export declare const IMPORT_ZIP_BASE64_MAX_CHARS = 8192;
+/** Third-party import source ids Clark uses for migration prompts and billing. */
+export type ImportAppSource = "chatgpt" | "claude" | "claude-design" | "lovable" | "replit" | "streamlit" | "v0" | "zip";
+export type ImportAppInput = {
+    branch?: string;
+    idempotencyKey: string;
+    /** Defaults to PLAN. */
+    mode?: "BUILD" | "PLAN";
+    name?: string;
+    /** Extra intent appended after the migration template (e.g. harden security). */
+    prompt?: string;
+    source?: ImportAppSource | string;
+    wait?: TurnWait;
+    /** Absolute path on the gateway host; mutually exclusive with zipBase64. */
+    zipBase64?: string;
+    zipPath?: string;
+};
+/** Same shape as {@link StartAppResult}: import creates an app then starts Clark. */
+export type ImportAppResult = StartAppResult;

package/dist/capabilities/types.js

@@ -0,0 +1,47 @@
+/**
+ * How a finished turn reads as a build status.
+ *
+ * Every member is spelled out and the default is unreachable on purpose. A
+ * `default: return "ready"` would answer "your app is fine" for any status
+ * added later, which is how a dead live edit came to be reported as `ready`
+ * in the first place; this way the compiler stops the next one.
+ */
+export function buildStatusOf(generationStatus) {
+    switch (generationStatus) {
+        case "cancelled":
+            return "cancelled";
+        case "completed":
+            return "ready";
+        case "detached":
+            return "detached";
+        case "live_edit_terminated":
+            return "live_edit_terminated";
+        case "needs_decision":
+            return "needs_decision";
+        case "no_changes":
+            return "no_changes";
+        case "timeout":
+            return "timeout";
+        default: {
+            const unhandled = generationStatus;
+            return unhandled;
+        }
+    }
+}
+/**
+ * Gateway MCP/HTTP import rejects archives above this size. Larger ZIPs almost
+ * certainly include `node_modules` (or similar); those belong outside the
+ * export — deps are installed on or after import. Stricter than the browser
+ * migration UI (50 MB) on purpose.
+ */
+export const IMPORT_ZIP_MAX_BYTES = 1_048_576;
+/**
+ * Ceiling on an inline `zipBase64` payload, far below
+ * {@link IMPORT_ZIP_MAX_BYTES} because base64 is not a transport a model can
+ * afford: every 3 bytes of archive cost 4 characters it has to write out one
+ * token at a time, so even a 42 KB export runs to 57,000 characters and the
+ * tool call never gets sent. Real archives arrive by name — this size only
+ * carries test fixtures.
+ */
+export const IMPORT_ZIP_BASE64_MAX_CHARS = 8_192;
+//# sourceMappingURL=types.js.map

package/dist/capabilities/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/capabilities/types.ts"],"names":[],"mappings":"AA0HA;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,gBAAkC;IAC9D,QAAQ,gBAAgB,EAAE,CAAC;QACzB,KAAK,WAAW;YACd,OAAO,WAAW,CAAC;QACrB,KAAK,WAAW;YACd,OAAO,OAAO,CAAC;QACjB,KAAK,UAAU;YACb,OAAO,UAAU,CAAC;QACpB,KAAK,sBAAsB;YACzB,OAAO,sBAAsB,CAAC;QAChC,KAAK,gBAAgB;YACnB,OAAO,gBAAgB,CAAC;QAC1B,KAAK,YAAY;YACf,OAAO,YAAY,CAAC;QACtB,KAAK,SAAS;YACZ,OAAO,SAAS,CAAC;QACnB,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,SAAS,GAAU,gBAAgB,CAAC;YAC1C,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;AACH,CAAC;AAyUD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,SAAS,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,KAAK,CAAC"}

package/dist/capture/browser-contract.d.ts

@@ -0,0 +1,36 @@
+import type { CaptureMode } from "./mode.js";
+export declare const HOST_BROWSER_TOOLS_UNKNOWN: "unknown";
+export declare const MUST_NOT_CLOSE_UNTIL = "the Superblocks task is done (status ready, or the user no longer needs the browser session)";
+export declare const NEEDS_BROWSER_DRIVER_CODE = "needs_browser_driver";
+export declare const NEEDS_BROWSER_DRIVER_MESSAGE = "No browser driver is available for live-canvas capture or IdP step-up. Add a host browser MCP (@playwright/mcp) and re-run gateway setup. Gateway Chromium cannot complete IdP. Config on disk can lie if a listed server fails to start.";
+/**
+ * Structured steer for host browser tools. Tokens never belong here.
+ *
+ * Until a loopback capture URL exists, live canvas is not a navigate target:
+ * `canvas.doNotOpen` is the edit URL (opening it mid-build steals the turn).
+ */
+export type BrowserDriverContract = {
+    captureMode: CaptureMode;
+    canvas: {
+        doNotOpen: string;
+    };
+    driver: {
+        isolated?: boolean;
+        mustNotCloseUntil: string;
+    };
+    hostBrowserTools: typeof HOST_BROWSER_TOOLS_UNKNOWN;
+    uiOrigin: {
+        navigate: string;
+    };
+};
+export declare function buildBrowserDriverContract(input: {
+    captureMode: CaptureMode;
+    editUrl: string;
+    isolated?: boolean;
+    uiOrigin: string;
+}): BrowserDriverContract;
+export declare function needsBrowserDriverError(): {
+    code: typeof NEEDS_BROWSER_DRIVER_CODE;
+    kind: "error";
+    message: string;
+};

package/dist/capture/browser-contract.js

@@ -0,0 +1,24 @@
+export const HOST_BROWSER_TOOLS_UNKNOWN = "unknown";
+export const MUST_NOT_CLOSE_UNTIL = "the Superblocks task is done (status ready, or the user no longer needs the browser session)";
+export const NEEDS_BROWSER_DRIVER_CODE = "needs_browser_driver";
+export const NEEDS_BROWSER_DRIVER_MESSAGE = "No browser driver is available for live-canvas capture or IdP step-up. Add a host browser MCP (@playwright/mcp) and re-run gateway setup. Gateway Chromium cannot complete IdP. Config on disk can lie if a listed server fails to start.";
+export function buildBrowserDriverContract(input) {
+    return {
+        captureMode: input.captureMode,
+        canvas: { doNotOpen: input.editUrl },
+        driver: {
+            ...(input.isolated ? { isolated: true } : {}),
+            mustNotCloseUntil: MUST_NOT_CLOSE_UNTIL,
+        },
+        hostBrowserTools: HOST_BROWSER_TOOLS_UNKNOWN,
+        uiOrigin: { navigate: input.uiOrigin },
+    };
+}
+export function needsBrowserDriverError() {
+    return {
+        code: NEEDS_BROWSER_DRIVER_CODE,
+        kind: "error",
+        message: NEEDS_BROWSER_DRIVER_MESSAGE,
+    };
+}
+//# sourceMappingURL=browser-contract.js.map

package/dist/capture/browser-contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-contract.js","sourceRoot":"","sources":["../../src/capture/browser-contract.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,0BAA0B,GAAG,SAAkB,CAAC;AAE7D,MAAM,CAAC,MAAM,oBAAoB,GAC/B,8FAA8F,CAAC;AAEjG,MAAM,CAAC,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAEhE,MAAM,CAAC,MAAM,4BAA4B,GACvC,2OAA2O,CAAC;AAmB9O,MAAM,UAAU,0BAA0B,CAAC,KAK1C;IACC,OAAO;QACL,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,MAAM,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,OAAO,EAAE;QACpC,MAAM,EAAE;YACN,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC7C,iBAAiB,EAAE,oBAAoB;SACxC;QACD,gBAAgB,EAAE,0BAA0B;QAC5C,QAAQ,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE;KACvC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,uBAAuB;IAKrC,OAAO;QACL,IAAI,EAAE,yBAAyB;QAC/B,IAAI,EAAE,OAAO;QACb,OAAO,EAAE,4BAA4B;KACtC,CAAC;AACJ,CAAC"}

package/dist/capture/browser-instructions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Numbered MUSTs for host browser drivers. Appended to MCP server
+ * instructions so a model that already has Playwright MCP (or agent-browser)
+ * does not open the edit URL mid-build or paste tokens into evaluate.
+ *
+ * Detecting that this turn actually has those tools is ENG-5858's sibling
+ * concern; these lines only steer when the tools exist.
+ */
+export declare const BROWSER_DRIVER_INSTRUCTIONS = "Browser capture (MUST):\n1. Prefer host browser tools (Playwright MCP, chrome-devtools, agent-browser) over opening Superblocks URLs yourself. Honor the structured \"browser\" field on start_app / get_app / idp_step_up; do not paraphrase it into a different URL.\n2. NEVER open canvas.doNotOpen (the edit URL) while status is \"building\". That tab steals the live-edit turn and the gateway goes \"detached\".\n3. NEVER paste tokens, JWTs, or API keys into browser evaluate or fill. Tokens are not in tool JSON; do not invent them.\n4. Playwright MCP MUST NOT use --isolated for Superblocks IdP. Cookies must survive the session.\n5. MUST NOT call browser_close until the Superblocks task is done (see driver.mustNotCloseUntil).\n6. agent-browser MUST always pass --profile and a stable --session for the same Superblocks origin.\n7. Claude-in-Chrome is not a mid-turn canvas. Do not use it to screenshot the live Vite app while a Gateway turn is held.";

package/dist/capture/browser-instructions.js

@@ -0,0 +1,17 @@
+/**
+ * Numbered MUSTs for host browser drivers. Appended to MCP server
+ * instructions so a model that already has Playwright MCP (or agent-browser)
+ * does not open the edit URL mid-build or paste tokens into evaluate.
+ *
+ * Detecting that this turn actually has those tools is ENG-5858's sibling
+ * concern; these lines only steer when the tools exist.
+ */
+export const BROWSER_DRIVER_INSTRUCTIONS = `Browser capture (MUST):
+1. Prefer host browser tools (Playwright MCP, chrome-devtools, agent-browser) over opening Superblocks URLs yourself. Honor the structured "browser" field on start_app / get_app / idp_step_up; do not paraphrase it into a different URL.
+2. NEVER open canvas.doNotOpen (the edit URL) while status is "building". That tab steals the live-edit turn and the gateway goes "detached".
+3. NEVER paste tokens, JWTs, or API keys into browser evaluate or fill. Tokens are not in tool JSON; do not invent them.
+4. Playwright MCP MUST NOT use --isolated for Superblocks IdP. Cookies must survive the session.
+5. MUST NOT call browser_close until the Superblocks task is done (see driver.mustNotCloseUntil).
+6. agent-browser MUST always pass --profile and a stable --session for the same Superblocks origin.
+7. Claude-in-Chrome is not a mid-turn canvas. Do not use it to screenshot the live Vite app while a Gateway turn is held.`;
+//# sourceMappingURL=browser-instructions.js.map

package/dist/capture/browser-instructions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-instructions.js","sourceRoot":"","sources":["../../src/capture/browser-instructions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG;;;;;;;0HAO+E,CAAC"}

package/dist/capture/capture-library-probe.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Stderr probe for live-library capture when canvas execute is unhealthy.
+ * Used to tell CORS / 401 / pending-abort apart from Clark testApi. Do not
+ * log tokens. Success (v3/execute POST 200) stays quiet. CORS preflight is
+ * not execute.
+ */
+export type CaptureParentEvent = {
+    type: string;
+};
+export type CaptureExecuteProbe = {
+    failure?: string;
+    method: string;
+    path: string;
+    pending?: boolean;
+    status?: number;
+};
+export type CaptureProbeInput = {
+    agentUrl?: string;
+    consoleText: string[];
+    execute: CaptureExecuteProbe[];
+    pageErrors: string[];
+    parentEvents: CaptureParentEvent[];
+    paintInnerText: string;
+    paintKind: string;
+};
+export type CaptureProbeSummary = {
+    agentHost?: string;
+    console: string[];
+    execute: CaptureExecuteProbe[];
+    pageErrors: string[];
+    paint: {
+        innerText: string;
+        kind: string;
+    };
+    parent: string[];
+    unanswered: string[];
+};
+export declare function isLibraryExecuteUrl(url: string): boolean;
+export declare function redactCaptureUrl(url: string): string;
+export declare function redactCaptureSecrets(text: string): string;
+export declare function executeStillInFlight(execute: CaptureExecuteProbe[]): boolean;
+export declare function shouldKeepCaptureConsole(text: string): boolean;
+export declare function summarizeCaptureProbe(input: CaptureProbeInput): CaptureProbeSummary;
+export type CaptureProbeCollector = {
+    consoleText: string[];
+    execute: CaptureExecuteProbe[];
+    pageErrors: string[];
+};
+type ProbePage = {
+    on: (event: string, handler: (arg: unknown) => void) => void;
+};
+export declare function attachLibraryCaptureProbe(page: ProbePage, collector: CaptureProbeCollector): void;
+export declare function shouldLogCaptureProbe(summary: CaptureProbeSummary): boolean;
+export declare function logCaptureProbe(summary: CaptureProbeSummary): void;
+export {};