@superblocksteam/gateway 2.0.177 → 2.0.178-next.0

package/dist/sabs/websocket-session-peer.js

@@ -1,11 +1,13 @@
 import { randomUUID } from "node:crypto";
 import { WebSocket } from "ws";
 import { AiMode as SharedAiMode, llmConfigFromFlags, } from "@superblocksteam/library-shared/types";
-import { createISocketClient, ISocket, SocketHeartbeat, } from "@superblocksteam/shared";
+import { createISocketClient, DEFAULT_NON_GIT_BRANCH, ISocket, SocketHeartbeat, } from "@superblocksteam/shared";
+import { HostedOrchestratorRefusedError, refusingOrchestratorClient, } from "../agents/hosted-boundary.js";
 import { canonicalizeOrchestratorBaseUrl, orchestratorUrlDependsOnProfile, pickOrchestratorBaseUrl, } from "../agents/resolve-orchestrator-url.js";
 import { gatewayDebug } from "../debug.js";
 import { resolveAppEditorProfileKey, } from "../integrations/profile-key.js";
 import { resolveProfileForApplication } from "../integrations/resolve-profile.js";
+import { internalIngress } from "../internal-ingress.js";
 import { HttpOrchestratorClient, } from "../orchestrator/client.js";
 import { recordCheckpointOutcome, recordIntegrationProfileResolution, } from "../telemetry/metrics.js";
 import { sanitizeAgentFacingText } from "./agent-facing-text.js";
@@ -17,6 +19,18 @@ import { appendRecentToolRun, buildRecentToolRun } from "./recent-tool-runs.js";
 import { PromptNotSentError, } from "./session-peer.js";
 import { DEFAULT_SETTLE_MS, TurnCollector } from "./turn-collector.js";
 const RELEASE_TURN_LOCK_METHOD = "editor.releaseTurnLock";
+/**
+ * The branch an edit-mode SDK API run fetches its code from. The server only
+ * lets the session's edit token read code on a named branch, so this always
+ * names one: the branch the server opened the live edit on, sent as the server
+ * named it, else the branch that was picked. The server's branch wins because
+ * connect can open a different branch than the one picked (for example main,
+ * when another user holds the picked branch), and the runs must test the code
+ * being edited.
+ */
+function sdkApiRunBranch(held) {
+    return held.liveEditBranch || held.branchName || DEFAULT_NON_GIT_BRANCH;
+}
 function editorStructureScopeKey(applicationId, branch) {
     return `${applicationId}\u0000${branch?.trim() ?? ""}`;
 }
@@ -590,7 +604,9 @@ function decisionFields(decision) {
     return decision ? { decision } : {};
 }
 async function attempt(url, timeoutMs, onSocketError) {
-    const socket = new WebSocket(url, GATEWAY_PROTOCOL);
+    const socket = new WebSocket(url, GATEWAY_PROTOCOL, {
+        createConnection: internalIngress.createConnection(url),
+    });
     return await new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
             socket.terminate();
@@ -777,7 +793,7 @@ export class WebSocketSessionPeer {
     editorStructureByScope = new Map();
     /** Facts about an application that outlive any one turn. */
     appState;
-    constructor(options = {}) {
+    constructor(options) {
         this.options = options;
         this.appState =
             options.appState ??
@@ -959,6 +975,10 @@ export class WebSocketSessionPeer {
                 : {}),
         };
     }
+    anyTurnRunning() {
+        return (this.appState.hasPendingStart() ||
+            [...this.turns.values()].some((turn) => !turn.finished));
+    }
     clearPendingPlan(applicationId) {
         this.appState.clearPending(applicationId);
     }
@@ -1009,6 +1029,7 @@ export class WebSocketSessionPeer {
             held.organizationId = input.organizationId;
         }
         held.sessionToken = input.sessionToken;
+        held.liveEditBranch = input.liveEditBranch;
         try {
             await this.synchronizeChatState(held, input.sessionToken);
             await this.resolveHeldProfileKey(held);
@@ -1257,6 +1278,7 @@ export class WebSocketSessionPeer {
                     held.organizationId = input.organizationId;
                 }
                 held.sessionToken = input.sessionToken;
+                held.liveEditBranch = input.liveEditBranch;
                 await beforePromptDeadline(this.resolveHeldProfileKey(held), deadline, input.signal);
                 await beforePromptDeadline(this.resolveHeldOrchestrator(held), deadline, input.signal);
             }
@@ -1452,6 +1474,7 @@ export class WebSocketSessionPeer {
                         mode: input.mode === "BUILD" ? SharedAiMode.BUILD : SharedAiMode.PLAN,
                     }),
                 prompt: input.prompt,
+                mcpClientName: input.mcpClientName,
                 promptContext: {
                     attachments: input.attachments ?? [],
                     entities: [],
@@ -2452,6 +2475,7 @@ export class WebSocketSessionPeer {
     carryOver(fresh, previous) {
         fresh.apiKey = previous.apiKey;
         fresh.branchName = previous.branchName;
+        fresh.liveEditBranch = previous.liveEditBranch;
         fresh.isFactsEnabled = previous.isFactsEnabled;
         fresh.llmConfig = previous.llmConfig;
         fresh.orchestrator = previous.orchestrator;
@@ -2619,7 +2643,20 @@ export class WebSocketSessionPeer {
                 ? normalizeCheckpointWarning(result?.warning)
                 : undefined;
             const captureCheckpointScreenshot = this.options.captureCheckpointScreenshot;
-            if (commitId && captureCheckpointScreenshot) {
+            const previewBlocked = commitId !== undefined &&
+                captureCheckpointScreenshot !== undefined &&
+                this.hostedPreviewBlocked(input.held);
+            if (previewBlocked) {
+                // The preview picks the org's agents itself, so loading it here would
+                // run the app's on-load APIs against the customer's agent from our
+                // control plane.
+                console.warn("gateway checkpoint screenshot skipped", {
+                    applicationId: input.held.applicationId,
+                    commitId,
+                    reason: "hosted_customer_agent",
+                });
+            }
+            if (commitId && captureCheckpointScreenshot && !previewBlocked) {
                 const screenshotTask = (async () => {
                     const budgetMs = this.options.checkpointScreenshotTimeoutMs ??
                         DEFAULT_CHECKPOINT_SCREENSHOT_TIMEOUT_MS;
@@ -3666,7 +3703,7 @@ export class WebSocketSessionPeer {
         return {
             apiKey: held.apiKey,
             applicationId: held.applicationId,
-            branchName: held.branchName,
+            branchName: sdkApiRunBranch(held),
             organizationId: held.organizationId,
             orchestrator: held.orchestrator,
             profileKey: held.profileKey,
@@ -3696,6 +3733,16 @@ export class WebSocketSessionPeer {
         }
         return this.buildHeldBrowserContext(held);
     }
+    /**
+     * Whether the hosted Platform MCP must keep this session's app out of any
+     * browser it runs. A hosted session has an agent URL only when the org's
+     * agent is one Superblocks runs, so a session without one (refused, or not
+     * discovered) fails closed. The CLI runs on the person's own machine and is
+     * never blocked here.
+     */
+    hostedPreviewBlocked(held) {
+        return this.options.hosted && !held.orchestratorUrl;
+    }
     /**
      * Library iframe bootstrap from a held session. Used for Gateway's own
      * live-canvas screenshot even when Clark's in-sandbox Playwright is off.
@@ -3719,12 +3766,18 @@ export class WebSocketSessionPeer {
             });
             return undefined;
         }
-        const apiKey = this.options.getAccessToken
-            ? await this.options.getAccessToken()
-            : held.apiKey;
+        // Hosted, both of these are the /mcp tools token, which the server refuses
+        // when the orchestrator forwards it. Leaving the key out makes the preview
+        // send the session token instead, which may read this app's code.
+        const apiKey = this.options.hosted
+            ? undefined
+            : this.options.getAccessToken
+                ? await this.options.getAccessToken()
+                : held.apiKey;
         return buildBrowserContext({
             ...(apiKey ? { apiKey } : {}),
             applicationId: held.applicationId,
+            branchName: sdkApiRunBranch(held),
             liveEditUrl: held.liveEdit.url,
             orchestratorUrl: held.orchestratorUrl,
             organizationId: held.organizationId,
@@ -3896,14 +3949,35 @@ export class WebSocketSessionPeer {
                 });
                 return;
             }
-            const orchestratorUrl = pickOrchestratorBaseUrl({
-                agentType: inventory.agentType,
-                agents: inventory.agents,
-                controlPlaneUrl: inventory.controlPlaneUrl,
-                profileKey,
-            });
+            let orchestratorUrl;
+            try {
+                orchestratorUrl = pickOrchestratorBaseUrl({
+                    agentType: inventory.agentType,
+                    agents: inventory.agents,
+                    controlPlaneUrl: inventory.controlPlaneUrl,
+                    hosted: this.options.hosted,
+                    profileKey,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof HostedOrchestratorRefusedError)) {
+                    throw error;
+                }
+                // The turn still runs, so Clark can build and hear why its API runs
+                // fail. No agent URL is kept, so none reaches the sandbox browser.
+                held.orchestrator = refusingOrchestratorClient(error);
+                delete held.orchestratorUrl;
+                held.orchestratorAgentType = inventory.agentType;
+                delete held.orchestratorStale;
+                console.warn("gateway refused orchestrator for hosted session", {
+                    applicationId: held.applicationId,
+                    organizationId: held.organizationId,
+                    reason: error.reason,
+                });
+                return;
+            }
             held.orchestratorUrl = orchestratorUrl;
-            held.orchestrator = new HttpOrchestratorClient(orchestratorUrl, undefined, this.options.getAccessToken);
+            held.orchestrator = new HttpOrchestratorClient(orchestratorUrl, this.options.hosted, undefined, this.options.getAccessToken);
             held.orchestratorAgentType = inventory.agentType;
             delete held.orchestratorStale;
             console.error("gateway resolved orchestrator url", {