Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Resolve localhost preview URLs for remote environments (#4011)

Julius Marmingebde0a4c0dd2d
diff --git a/apps/web/src/browser/browserTargetResolver.test.ts b/apps/web/src/browser/browserTargetResolver.test.ts
index d3c7f6a8d..6f89d86df 100644
--- a/apps/web/src/browser/browserTargetResolver.test.ts
+++ b/apps/web/src/browser/browserTargetResolver.test.ts
@@ -25,6 +25,89 @@ describe("browser target resolver", () => {
});
});
+ it("maps localhost URL navigation onto a remote Tailscale IPv4 host", async () => {
+ readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://100.65.180.100:3773" });
+ const { resolveBrowserNavigationTarget } = await import("./browserTargetResolver");
+ expect(
+ resolveBrowserNavigationTarget(EnvironmentId.make("environment-1"), {
+ kind: "url",
+ url: "http://localhost:5173/dashboard?mode=test#results",
+ }),
+ ).toEqual({
+ requestedUrl: "http://localhost:5173/dashboard?mode=test#results",
+ resolvedUrl: "http://100.65.180.100:5173/dashboard?mode=test#results",
+ resolutionKind: "direct-private-network",
+ environmentId: "environment-1",
+ });
+ });
+
+ it("preserves URL credentials when mapping localhost onto a remote host", async () => {
+ readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://100.65.180.100:3773" });
+ const { resolveBrowserNavigationTarget } = await import("./browserTargetResolver");
+ expect(
+ resolveBrowserNavigationTarget(EnvironmentId.make("environment-1"), {
+ kind: "url",
+ url: "http://user:p%40ss@localhost:5173/dashboard",
+ }).resolvedUrl,
+ ).toBe("http://user:p%[email protected]:5173/dashboard");
+ });
+
+ it("maps credentialed localhost URLs onto private IPv6 hosts", async () => {
+ readPreparedConnection.mockReturnValue({
+ httpBaseUrl: "http://[fd7a:115c:a1e0::53]:3773",
+ });
+ const { resolveBrowserNavigationTarget } = await import("./browserTargetResolver");
+ expect(
+ resolveBrowserNavigationTarget(EnvironmentId.make("environment-1"), {
+ kind: "url",
+ url: "http://user:p%40ss@localhost:5173/dashboard?mode=test#results",
+ }).resolvedUrl,
+ ).toBe("http://user:p%40ss@[fd7a:115c:a1e0::53]:5173/dashboard?mode=test#results");
+ });
+
+ it("maps schemeless localhost navigation onto a remote environment host", async () => {
+ readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://192.168.1.25:3773" });
+ const { resolveBrowserNavigationTarget } = await import("./browserTargetResolver");
+ expect(
+ resolveBrowserNavigationTarget(EnvironmentId.make("environment-1"), {
+ kind: "url",
+ url: "localhost:3000/app",
+ }).resolvedUrl,
+ ).toBe("http://192.168.1.25:3000/app");
+ });
+
+ it("keeps localhost navigation local for a local environment", async () => {
+ readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://127.0.0.1:3773" });
+ const { resolveBrowserNavigationTarget } = await import("./browserTargetResolver");
+ expect(
+ resolveBrowserNavigationTarget(EnvironmentId.make("environment-1"), {
+ kind: "url",
+ url: "localhost:3000/app",
+ }),
+ ).toEqual({
+ requestedUrl: "localhost:3000/app",
+ resolvedUrl: "localhost:3000/app",
+ resolutionKind: "direct",
+ environmentId: "environment-1",
+ });
+ });
+
+ it("keeps localhost navigation local for the full IPv4 loopback range", async () => {
+ readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://127.0.0.2:3773" });
+ const { resolveBrowserNavigationTarget } = await import("./browserTargetResolver");
+ expect(
+ resolveBrowserNavigationTarget(EnvironmentId.make("environment-1"), {
+ kind: "url",
+ url: "http://localhost:3000/app",
+ }),
+ ).toEqual({
+ requestedUrl: "http://localhost:3000/app",
+ resolvedUrl: "http://localhost:3000/app",
+ resolutionKind: "direct",
+ environmentId: "environment-1",
+ });
+ });
+
it("refuses public relay hosts until the authenticated gateway exists", async () => {
readPreparedConnection.mockReturnValue({ httpBaseUrl: "https://relay.example.com" });
const { resolveBrowserNavigationTarget } = await import("./browserTargetResolver");
@@ -34,6 +117,12 @@ describe("browser target resolver", () => {
port: 5173,
}),
).toThrow(/authenticated preview gateway/);
+ expect(() =>
+ resolveBrowserNavigationTarget(EnvironmentId.make("environment-1"), {
+ kind: "url",
+ url: "http://localhost:5173",
+ }),
+ ).toThrow(/authenticated preview gateway/);
});
it("normalizes schemeless localhost server-picker values", async () => {
@@ -63,7 +152,9 @@ describe("browser target resolver", () => {
});
it("supports private IPv6 environment hosts", async () => {
- readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://[::1]:3773" });
+ readPreparedConnection.mockReturnValue({
+ httpBaseUrl: "http://[fd7a:115c:a1e0::53]:3773",
+ });
const { resolveBrowserNavigationTarget } = await import("./browserTargetResolver");
expect(
resolveBrowserNavigationTarget(EnvironmentId.make("environment-1"), {
@@ -71,7 +162,18 @@ describe("browser target resolver", () => {
port: 5173,
path: "/app?mode=test",
}).resolvedUrl,
- ).toBe("http://[::1]:5173/app?mode=test");
+ ).toBe("http://[fd7a:115c:a1e0::53]:5173/app?mode=test");
+ });
+
+ it("supports a local IPv6 environment host", async () => {
+ readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://[::1]:3773" });
+ const { resolveBrowserNavigationTarget } = await import("./browserTargetResolver");
+ expect(
+ resolveBrowserNavigationTarget(EnvironmentId.make("environment-1"), {
+ kind: "environment-port",
+ port: 5173,
+ }).resolvedUrl,
+ ).toBe("http://[::1]:5173/");
});
it("leaves malformed input for the normal navigation error path", async () => {
diff --git a/apps/web/src/browser/browserTargetResolver.ts b/apps/web/src/browser/browserTargetResolver.ts
index 9142cce1e..9b201dbdb 100644
--- a/apps/web/src/browser/browserTargetResolver.ts
+++ b/apps/web/src/browser/browserTargetResolver.ts
@@ -7,43 +7,60 @@ import { isLoopbackHost, normalizePreviewUrl } from "@t3tools/shared/preview";
import { readPreparedConnection } from "~/state/session";
+const normalizeHostname = (host: string): string => host.toLowerCase().replace(/^\[|\]$/g, "");
+
+const parseIpv4Address = (host: string): readonly number[] | null => {
+ const parts = normalizeHostname(host).split(".").map(Number);
+ return parts.length === 4 &&
+ parts.every((part) => Number.isInteger(part) && part >= 0 && part <= 255)
+ ? parts
+ : null;
+};
+
+const isLocalLoopbackHost = (host: string): boolean => {
+ const normalized = normalizeHostname(host);
+ if (normalized === "localhost" || normalized === "::1") return true;
+ return parseIpv4Address(normalized)?.[0] === 127;
+};
+
const isPrivateNetworkHost = (host: string): boolean => {
- const normalized = host.toLowerCase().replace(/^\[|\]$/g, "");
- if (normalized === "localhost" || normalized === "::1" || normalized.endsWith(".local")) {
+ const normalized = normalizeHostname(host);
+ if (isLocalLoopbackHost(normalized) || normalized.endsWith(".local")) {
return true;
}
if (normalized.endsWith(".ts.net")) return true;
- const parts = normalized.split(".").map(Number);
- if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part))) return false;
+ const parts = parseIpv4Address(normalized);
+ if (parts) {
+ return (
+ parts[0] === 10 ||
+ (parts[0] === 100 && parts[1]! >= 64 && parts[1]! <= 127) ||
+ (parts[0] === 172 && parts[1]! >= 16 && parts[1]! <= 31) ||
+ (parts[0] === 192 && parts[1] === 168) ||
+ (parts[0] === 169 && parts[1] === 254)
+ );
+ }
+ const firstIpv6Token = normalized.split(":", 1)[0] ?? "";
+ if (!normalized.includes(":") || !/^[\da-f]{1,4}$/u.test(firstIpv6Token)) return false;
+ const firstIpv6Hextet = Number.parseInt(firstIpv6Token, 16);
return (
- parts[0] === 10 ||
- (parts[0] === 172 && parts[1]! >= 16 && parts[1]! <= 31) ||
- (parts[0] === 192 && parts[1] === 168) ||
- parts[0] === 127 ||
- (parts[0] === 169 && parts[1] === 254)
+ Number.isInteger(firstIpv6Hextet) &&
+ ((firstIpv6Hextet & 0xfe00) === 0xfc00 || (firstIpv6Hextet & 0xffc0) === 0xfe80)
);
};
-const isLocalLoopbackHost = (host: string): boolean => {
- const normalized = host.toLowerCase().replace(/^\[|\]$/g, "");
- return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1";
+const readEnvironmentUrl = (environmentId: EnvironmentId): URL => {
+ const connection = readPreparedConnection(environmentId);
+ if (!connection) throw new Error(`Environment ${environmentId} is not connected.`);
+ return new URL(connection.httpBaseUrl);
};
-export function resolveBrowserNavigationTarget(
+const resolveEnvironmentPortTarget = (
environmentId: EnvironmentId,
- target: BrowserNavigationTarget,
-): PreviewUrlResolution {
- if (target.kind === "url") {
- return {
- requestedUrl: target.url,
- resolvedUrl: target.url,
- resolutionKind: "direct",
- environmentId,
- };
- }
- const connection = readPreparedConnection(environmentId);
- if (!connection) throw new Error(`Environment ${environmentId} is not connected.`);
- const environmentUrl = new URL(connection.httpBaseUrl);
+ target: Extract<BrowserNavigationTarget, { readonly kind: "environment-port" }>,
+ environmentUrl: URL,
+ requestedUrl?: string,
+ sourceUrl?: URL,
+): PreviewUrlResolution => {
if (!isPrivateNetworkHost(environmentUrl.hostname)) {
throw new Error(
"This environment port needs the planned authenticated preview gateway; its server address is not directly private-network reachable.",
@@ -51,40 +68,72 @@ export function resolveBrowserNavigationTarget(
}
const protocol = target.protocol ?? "http";
const path = target.path?.startsWith("/") ? target.path : `/${target.path ?? ""}`;
- const requestedUrl = `${protocol}://localhost:${target.port}${path}`;
const normalizedEnvironmentHost = environmentUrl.hostname.replace(/^\[|\]$/g, "");
const resolvedHost = normalizedEnvironmentHost.includes(":")
? `[${normalizedEnvironmentHost}]`
: normalizedEnvironmentHost;
- const resolved = new URL(path, `${protocol}://${resolvedHost}:${target.port}`);
+ const resolved = sourceUrl
+ ? new URL(sourceUrl)
+ : new URL(path, `${protocol}://${resolvedHost}:${target.port}`);
+ if (sourceUrl) {
+ resolved.hostname = resolvedHost;
+ resolved.port = String(target.port);
+ }
return {
- requestedUrl,
+ requestedUrl: requestedUrl ?? `${protocol}://localhost:${target.port}${path}`,
resolvedUrl: resolved.toString(),
- resolutionKind:
- normalizedEnvironmentHost === "localhost" || normalizedEnvironmentHost === "127.0.0.1"
- ? "direct"
- : "direct-private-network",
+ resolutionKind: isLocalLoopbackHost(normalizedEnvironmentHost)
+ ? "direct"
+ : "direct-private-network",
environmentId,
};
+};
+
+export function resolveBrowserNavigationTarget(
+ environmentId: EnvironmentId,
+ target: BrowserNavigationTarget,
+): PreviewUrlResolution {
+ if (target.kind === "url") {
+ let parsed: URL | null = null;
+ try {
+ parsed = new URL(normalizePreviewUrl(target.url));
+ } catch {
+ // Preserve the existing direct-navigation behavior so the preview host
+ // reports malformed URL errors through its normal navigation path.
+ }
+ if (parsed && isLoopbackHost(parsed.hostname)) {
+ const environmentUrl = readEnvironmentUrl(environmentId);
+ if (parsed.hostname === "0.0.0.0" || !isLocalLoopbackHost(environmentUrl.hostname)) {
+ return resolveEnvironmentPortTarget(
+ environmentId,
+ {
+ kind: "environment-port",
+ port: Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80)),
+ protocol: parsed.protocol === "https:" ? "https" : "http",
+ path: `${parsed.pathname}${parsed.search}${parsed.hash}`,
+ },
+ environmentUrl,
+ target.url,
+ parsed,
+ );
+ }
+ }
+ return {
+ requestedUrl: target.url,
+ resolvedUrl: target.url,
+ resolutionKind: "direct",
+ environmentId,
+ };
+ }
+ return resolveEnvironmentPortTarget(environmentId, target, readEnvironmentUrl(environmentId));
}
export function resolveDiscoveredServerUrl(environmentId: EnvironmentId, rawUrl: string): string {
try {
const normalizedUrl = normalizePreviewUrl(rawUrl);
- const parsed = new URL(normalizedUrl);
- if (!isLoopbackHost(parsed.hostname)) return normalizedUrl;
- const connection = readPreparedConnection(environmentId);
- if (!connection) throw new Error(`Environment ${environmentId} is not connected.`);
- const environmentUrl = new URL(connection.httpBaseUrl);
- if (parsed.hostname !== "0.0.0.0" && isLocalLoopbackHost(environmentUrl.hostname)) {
- return normalizedUrl;
- }
- const port = Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80));
return resolveBrowserNavigationTarget(environmentId, {
- kind: "environment-port",
- port,
- protocol: parsed.protocol === "https:" ? "https" : "http",
- path: `${parsed.pathname}${parsed.search}${parsed.hash}`,
+ kind: "url",
+ url: normalizedUrl,
}).resolvedUrl;
} catch {
return rawUrl;
diff --git a/apps/web/src/components/preview/PreviewAutomationHosts.tsx b/apps/web/src/components/preview/PreviewAutomationHosts.tsx
index d637611a7..06954b73f 100644
--- a/apps/web/src/components/preview/PreviewAutomationHosts.tsx
+++ b/apps/web/src/components/preview/PreviewAutomationHosts.tsx
@@ -343,6 +343,12 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId })
return await currentStatus(threadRef, tabId);
case "open": {
const input = request.input as PreviewAutomationOpenInput;
+ const resolvedInputUrl = input.url
+ ? resolveBrowserNavigationTarget(environmentId, {
+ kind: "url",
+ url: input.url,
+ }).resolvedUrl
+ : undefined;
let activeTabId = resolvePreviewAutomationOpenTab(
state,
request.tabId,
@@ -358,7 +364,7 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId })
environmentId,
input: {
threadId: request.threadId,
- ...(input.url ? { url: input.url } : {}),
+ ...(resolvedInputUrl ? { url: resolvedInputUrl } : {}),
},
});
if (result._tag === "Failure") {
@@ -381,12 +387,8 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId })
request.timeoutMs,
);
}
- if (reusedExistingTab && input.url && previewBridge) {
- const resolution = resolveBrowserNavigationTarget(environmentId, {
- kind: "url",
- url: input.url,
- });
- await previewBridge.navigate(activeTabId, resolution.resolvedUrl);
+ if (reusedExistingTab && resolvedInputUrl && previewBridge) {
+ await previewBridge.navigate(activeTabId, resolvedInputUrl);
await waitForNavigationReadiness(
threadRef,
request.requestId,