From 9a0b2d26ac1180510d89c2c03edaadd89af535e9 Mon Sep 17 00:00:00 2001
From: Jack Singer <jacobsinger22@gmail.com>
Date: Wed, 22 Jul 2026 17:04:52 -0500
Subject: [PATCH 1/2] fix(client): route gateway same-origin for any deployment
 subdomain
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The gateway base was chosen by comparing the live host to the
build-time-baked VITE_BOOL_SLUG (location.host === `${slug}.${appHost}`).
Vite inlines VITE_* at build time, so when a project's slug/domain is
changed after the bundle is built, the baked slug goes stale: the app is
served at `<new-slug>.<appHost>`, the exact match fails, and the client
falls through to an absolute `${appOrigin}/served/<old-slug>` gateway URL.
That slug no longer exists, so every gateway call 404s — most visibly the
"Continue with Google" navigation, which opens a tab straight onto the
404.

The platform proxy resolves the gateway slug from the REQUEST host, not
the baked slug, so any `<label>.<appHost>` deployment subdomain is
reachable same-origin. Detect that shape (new isDeploymentSubdomain,
mirroring the proxy's deploymentSlugFromHost) instead of matching the
baked slug. Renamed apps now stay same-origin and keep working with no
rebuild. Preview sandboxes and custom domains are unchanged (still the
cross-origin baked-origin path).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/client.test.ts | 43 +++++++++++++++++++++++++++++++++++++++++++
 src/client.ts      | 39 ++++++++++++++++++++++++++++++++-------
 2 files changed, 75 insertions(+), 7 deletions(-)

diff --git a/src/client.test.ts b/src/client.test.ts
index 40498c8..ee5ada8 100644
--- a/src/client.test.ts
+++ b/src/client.test.ts
@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, test } from "bun:test";
 import {
   createBoolClient,
   getDefaultBoolClient,
+  isDeploymentSubdomain,
   BoolAiError,
   type BoolClientConfig,
 } from "./client";
@@ -72,6 +73,18 @@ describe("gateway routing", () => {
     expect(calls[0]!.url).toBe("/_bool/v1/db/rest/v1/todos?select=*");
   });
 
+  test("stays same-origin when the live subdomain differs from the baked slug (renamed app)", async () => {
+    // The bundle was built with slug "my-app" but the project was later renamed
+    // to "renamed-app". The proxy resolves the gateway slug from the host, so a
+    // relative path still reaches the right gateway. Comparing the live host to
+    // the baked slug (the old behavior) routed cross-origin to /served/my-app,
+    // which no longer exists → 404 (the "Continue with Google 404s" bug).
+    (globalThis as any).location = { host: "renamed-app.bool.test" };
+    const client = createBoolClient(CONFIG);
+    await client.db.from("todos").select("*");
+    expect(calls[0]!.url).toBe("/_bool/v1/db/rest/v1/todos?select=*");
+  });
+
   test("Storage calls go through the gateway too", async () => {
     const client = createBoolClient(CONFIG);
     await client.db.storage.from("uploads").list();
@@ -409,3 +422,33 @@ describe("default client registry", () => {
     expect(getDefaultBoolClient()).toBe(second);
   });
 });
+
+describe("isDeploymentSubdomain", () => {
+  test("any single-label subdomain of appHost qualifies — not just the baked slug", () => {
+    expect(isDeploymentSubdomain("my-app.bool.test", "bool.test")).toBe(true);
+    expect(isDeploymentSubdomain("renamed-app.bool.test", "bool.test")).toBe(true);
+    expect(isDeploymentSubdomain("a1b2c3.bool.test", "bool.test")).toBe(true);
+  });
+
+  test("ignores a :port so it holds in local dev", () => {
+    expect(isDeploymentSubdomain("my-app.bool.test:3010", "bool.test")).toBe(true);
+  });
+
+  test("the bare apex is not a deployment subdomain", () => {
+    expect(isDeploymentSubdomain("bool.test", "bool.test")).toBe(false);
+  });
+
+  test("multi-label hosts don't qualify (proxy only rewrites single-label)", () => {
+    expect(isDeploymentSubdomain("foo.bar.bool.test", "bool.test")).toBe(false);
+  });
+
+  test("a different registrable domain (custom domain / preview sandbox) is cross-origin", () => {
+    expect(isDeploymentSubdomain("my-app.example.com", "bool.test")).toBe(false);
+    expect(isDeploymentSubdomain("abc123.vercel.run", "bool.test")).toBe(false);
+  });
+
+  test("empty inputs are safe", () => {
+    expect(isDeploymentSubdomain("", "bool.test")).toBe(false);
+    expect(isDeploymentSubdomain("my-app.bool.test", "")).toBe(false);
+  });
+});
diff --git a/src/client.ts b/src/client.ts
index e56e603..a6e822b 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -30,6 +30,26 @@ const GATEWAY_API = "v1";
 // used, and the server never returns a token), so it's never exposed there.
 const EU_SESSION_KEY = "bool_eu_session_token";
 
+/** True when `host` is a single-label deployment subdomain of `appHost` (e.g.
+ * "acme.bool.so" under "bool.so") — the exact shape the platform proxy rewrites
+ * to /served/<label>/… keyed on the request host. Mirrors `deploymentSlugFromHost`
+ * in the platform proxy: the label must be a valid slug (lowercase letters,
+ * digits, dashes) with no further dots, so multi-label hosts and the bare apex
+ * don't qualify. The port is ignored so it holds in local dev too.
+ *
+ * Deliberately does NOT compare the label to the baked `VITE_BOOL_SLUG`: the
+ * proxy resolves the slug from the live host, so any deployment subdomain is
+ * same-origin. Tying it to the baked slug is what made a renamed app route its
+ * gateway calls to the old slug cross-origin and 404. */
+export function isDeploymentSubdomain(host: string, appHost: string): boolean {
+  if (!host || !appHost) return false;
+  const h = host.split(":")[0]!; // drop any :port
+  const suffix = "." + appHost;
+  if (!h.endsWith(suffix)) return false;
+  const label = h.slice(0, -suffix.length);
+  return /^[a-z0-9-]+$/.test(label);
+}
+
 /** Everything the client needs to reach its Bool. Injected by Bool at boot
  * (the app's `src/lib/supabase.ts` passes these from `import.meta.env`). */
 export type BoolClientConfig = {
@@ -218,17 +238,22 @@ export function createBoolClient(config: BoolClientConfig): BoolClient {
   }
 
   // Where the gateway lives, decided at runtime by where the app is running:
-  //  - Deployed at <slug>.<host>: the gateway is same-origin (the platform
-  //    proxy rewrites /_bool → /served/<slug>/_bool), so use a relative path —
-  //    no CORS.
-  //  - Preview (sandbox) or a custom domain: reach the slug gateway
-  //    cross-origin.
+  //  - Deployed on a <label>.<appHost> subdomain: the gateway is same-origin
+  //    (the platform proxy rewrites /_bool → /served/<slug>/_bool keyed on the
+  //    REQUEST host, not the baked slug), so use a relative path — no CORS. This
+  //    matches on the subdomain SHAPE, not on the baked slug: a project whose
+  //    slug/domain changed after this bundle was built serves a stale
+  //    VITE_BOOL_SLUG, but the host is always current, so relative URLs keep
+  //    hitting the right gateway. (Comparing to the baked slug was the bug: a
+  //    renamed app fell through to a cross-origin URL for the OLD slug and 404'd
+  //    — most visibly on the "Continue with Google" tab.)
+  //  - Preview (sandbox *.vercel.run) or a custom domain: reach the slug gateway
+  //    cross-origin at the baked appOrigin.
   function boolGatewayBase(): string {
     if (
       appHost &&
-      slug &&
       typeof location !== "undefined" &&
-      location.host === slug + "." + appHost
+      isDeploymentSubdomain(location.host, appHost)
     ) {
       return "";
     }

From 7aaedcedc9586b7144e4c0a4f76b21e217d5fc68 Mon Sep 17 00:00:00 2001
From: Jack Singer <jacobsinger22@gmail.com>
Date: Wed, 22 Jul 2026 17:07:18 -0500
Subject: [PATCH 2/2] chore(release): 0.2.0-next.17

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index c1604a4..7d0aea1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "bool-sdk",
-  "version": "0.2.0-next.16",
+  "version": "0.2.0-next.17",
   "description": "Client SDK for apps built on Bool — gateway data access, end-user auth, the AI battery, the React auth layer, and the local-dev CLI (link, types, deploy).",
   "type": "module",
   "main": "./dist/index.js",