offsite 0.0.31 → 0.0.33

package/apps/server/dist/main.mjs

@@ -24,6 +24,7 @@ import { integer, snakeCase, text } from "drizzle-orm/sqlite-core";
 import { promisify } from "node:util";
 import webPush from "web-push";
 import { createProxyServer } from "http-proxy-3";
+import { OUTGOING_PASSES } from "http-proxy-3/dist/lib/http-proxy/passes/web-outgoing.js";
 import { spawn as spawn$1 } from "@lydell/node-pty";
 //#region ../core/src/media.ts
 const mediaTypes = /* @__PURE__ */ new Map([
@@ -890,6 +891,7 @@ function accountSchema(provider) {
 		id: z.string(),
 		provider: z.literal(provider),
 		name: z.string(),
+		color: z.string().regex(/^#[0-9a-f]{6}$/i, "must be a hex color like #3b82f6").nullable().default(null),
 		configDir: platformDirs,
 		enabled: z.boolean().default(true),
 		hiddenModels: z.record(z.string(), z.boolean()).default({})
@@ -3458,6 +3460,14 @@ function openCodeRuns() {
 }
 //#endregion
 //#region src/services/accounts.ts
+const accountColors = [
+	"#3b82f6",
+	"#16a34a",
+	"#f97316",
+	"#a855f7",
+	"#ec4899",
+	"#0d9488"
+];
 const providerNames = {
 	claude: "Claude",
 	codex: "Codex",
@@ -3468,13 +3478,11 @@ function providerName(provider) {
 }
 function storedAccounts() {
 	const config = readConfig();
-	return [...config.claudeAccounts.map((item) => ({
-		...item,
-		configDir: item.configDir[platform()]
-	})), ...config.codexAccounts.map((item) => ({
+	return [...config.claudeAccounts, ...config.codexAccounts].map((item, index) => ({
 		...item,
+		color: item.color ?? accountColors[index % accountColors.length],
 		configDir: item.configDir[platform()]
-	}))];
+	}));
 }
 function assertEnabled(provider, accountId) {
 	if (!readConfig().enabledProviders[provider]) throw new Error(`${providerName(provider)} is disabled in Settings`);
@@ -3576,6 +3584,8 @@ function providerCapabilities(provider, accountId, cwd) {
 }
 function addAccount(provider, name, configDir) {
 	const account = validAccount(name, configDir);
+	const stored = storedAccounts();
+	const color = accountColors.find((item) => stored.every((other) => other.color !== item)) ?? accountColors[stored.length % accountColors.length];
 	const config = readConfig();
 	const key = `${provider}Accounts`;
 	saveConfig({
@@ -3584,6 +3594,7 @@ function addAccount(provider, name, configDir) {
 			id: randomUUID(),
 			provider,
 			name: account.name,
+			color,
 			configDir: { [platform()]: account.configDir },
 			enabled: true,
 			hiddenModels: {}
@@ -3601,6 +3612,7 @@ async function updateAccount(update) {
 		[key]: config[key].map((item) => item.id === update.id ? {
 			...item,
 			name: account.name,
+			color: update.color,
 			configDir: {
 				...item.configDir,
 				[platform()]: account.configDir
@@ -3795,6 +3807,7 @@ function claudeMode(value) {
 	return mode;
 }
 function claudeOptions(accountId, cwd) {
+	if (!statSync(cwd, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`Project folder ${cwd} does not exist`);
 	const configDir = storedAccount("claude", accountId).configDir ?? claudeBaseDir();
 	const env = {
 		...process.env,
@@ -5093,6 +5106,46 @@ function resolveProjectFile(cwd, file) {
 //#endregion
 //#region src/services/proxy.ts
 const proxies = /* @__PURE__ */ new Map();
+const pageScriptPath = "/__offsite/browser.js";
+function pageScript(origin) {
+	return `(() => {
+  if (window.parent === window || window.navigation === undefined) {
+    return
+  }
+  const post = (message) =>
+    window.parent.postMessage({ offsite: 'browser', ...message }, '*')
+  const report = () =>
+    post({
+      event: 'location',
+      url: ${JSON.stringify(origin)} + location.pathname + location.search + location.hash,
+      proxied: location.href,
+      back: navigation.canGoBack,
+      forward: navigation.canGoForward,
+    })
+  addEventListener('pageshow', report)
+  navigation.addEventListener('currententrychange', report)
+  navigation.addEventListener('navigate', (event) => {
+    if (!event.destination.sameDocument && event.downloadRequest === null) {
+      post({ event: 'navigate' })
+    }
+  })
+  addEventListener('message', (event) => {
+    if (event.source !== window.parent || event.data?.offsite !== 'browser') {
+      return
+    }
+    if (event.data.command === 'back') {
+      navigation.back()
+    }
+    if (event.data.command === 'forward') {
+      navigation.forward()
+    }
+    if (event.data.command === 'reload') {
+      location.reload()
+    }
+  })
+})()
+`;
+}
 function proxyPort(origin) {
 	const target = new URL(origin);
 	if (target.protocol !== "http:" && target.protocol !== "https:") throw new Error(`${origin} is not an http or https address`);
@@ -5104,21 +5157,43 @@ function proxyPort(origin) {
 	return started;
 }
 function startProxy(target) {
-	const proxy = createProxyServer({
-		target: target.origin,
+	const options = {
+		target,
 		changeOrigin: true,
 		ws: true,
 		secure: false,
 		autoRewrite: true,
 		protocolRewrite: "http",
-		cookieDomainRewrite: ""
+		cookieDomainRewrite: "",
+		selfHandleResponse: true
+	};
+	const proxy = createProxyServer(options);
+	proxy.on("proxyReq", (outgoing, request) => {
+		rewriteOrigin(target, outgoing, request);
+		if (request.headers.accept?.startsWith("text/html") === true) outgoing.removeHeader("accept-encoding");
 	});
-	proxy.on("proxyReq", (outgoing, request) => rewriteOrigin(target, outgoing, request));
 	proxy.on("proxyReqWs", (outgoing, request) => rewriteOrigin(target, outgoing, request));
-	proxy.on("proxyRes", (incoming) => {
+	proxy.on("proxyRes", async (incoming, request, response) => {
+		try {
+			await rewriteRedirect(target, incoming, request);
+		} catch (error) {
+			response.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+			response.end(`Could not follow the redirect from ${target.origin}: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
 		delete incoming.headers["x-frame-options"];
 		delete incoming.headers["content-security-policy"];
 		if (incoming.headers["set-cookie"] !== void 0) incoming.headers["set-cookie"] = incoming.headers["set-cookie"].map((cookie) => cookie.replace(/;\s*secure/i, "").replace(/;\s*samesite=none/i, ""));
+		const page = request.method === "GET" && request.headers.accept?.startsWith("text/html") === true && incoming.statusCode !== 204 && incoming.statusCode !== 304 && /^text\/html/i.test(incoming.headers["content-type"] ?? "") && incoming.headers["content-encoding"] === void 0;
+		if (page) delete incoming.headers["content-length"];
+		for (const pass of Object.values(OUTGOING_PASSES)) pass(request, response, incoming, options);
+		if (!page) {
+			incoming.pipe(response);
+			return;
+		}
+		const chunks = [];
+		incoming.on("data", (chunk) => chunks.push(chunk));
+		incoming.on("end", () => response.end(Buffer.from(Buffer.concat(chunks).toString("latin1").replace(/^(\xEF\xBB\xBF)?\s*(<!doctype[^>]*>)?/i, `$&<script src="${pageScriptPath}"><\/script>`), "latin1")));
 	});
 	proxy.on("error", (error, _request, response) => {
 		if (!(response instanceof http.ServerResponse)) {
@@ -5128,7 +5203,14 @@ function startProxy(target) {
 		if (!response.headersSent) response.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
 		response.end(`Could not reach ${target.origin}: ${error.message}`);
 	});
-	const server = http.createServer((request, response) => proxy.web(request, response));
+	const server = http.createServer((request, response) => {
+		if (request.url === pageScriptPath) {
+			response.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
+			response.end(pageScript(target.origin));
+			return;
+		}
+		proxy.web(request, response);
+	});
 	server.on("upgrade", (request, socket, head) => proxy.ws(request, socket, head));
 	return new Promise((resolve, reject) => {
 		server.once("error", reject);
@@ -5142,6 +5224,16 @@ function startProxy(target) {
 		});
 	});
 }
+async function rewriteRedirect(target, incoming, request) {
+	const location = incoming.headers.location;
+	if (location === void 0 || !/^30[1278]$/.test(String(incoming.statusCode))) return;
+	const next = new URL(location, target);
+	if (next.origin === target.origin || next.protocol !== "http:" && next.protocol !== "https:") return;
+	if (request.headers.host === void 0) throw new Error("the redirected request has no host");
+	const proxied = new URL(`http://${request.headers.host}`);
+	proxied.port = String(await proxyPort(next.origin));
+	incoming.headers.location = `${proxied.origin}${next.pathname}${next.search}${next.hash}`;
+}
 function rewriteOrigin(target, outgoing, request) {
 	if (request.headers.origin !== void 0) outgoing.setHeader("origin", target.origin);
 	if (request.headers.referer !== void 0) outgoing.setHeader("referer", request.headers.referer.replace(`http://${request.headers.host}`, target.origin));