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.

fix(server): isolate remote web session cookies (#208)

Leob6b2b5ded752
diff --git a/apps/server/src/auth/EnvironmentAuth.test.ts b/apps/server/src/auth/EnvironmentAuth.test.ts
index 1e0901c53..c70412d49 100644
--- a/apps/server/src/auth/EnvironmentAuth.test.ts
+++ b/apps/server/src/auth/EnvironmentAuth.test.ts
@@ -5,6 +5,7 @@ import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as ServerConfig from "../config.ts";
+import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import { SqlitePersistenceMemory } from "../persistence/Layers/Sqlite.ts";
import * as PairingGrantStore from "./PairingGrantStore.ts";
import * as EnvironmentAuth from "./EnvironmentAuth.ts";
@@ -34,6 +35,7 @@ const makeEnvironmentAuthLayer = (overrides?: Partial<ServerConfig.ServerConfig[
EnvironmentAuth.layer.pipe(
Layer.provide(SqlitePersistenceMemory),
Layer.provide(ServerSecretStore.layer),
+ Layer.provide(ServerEnvironment.identityLayer),
Layer.provide(makeServerConfigLayer(overrides)),
);
@@ -108,6 +110,20 @@ it.layer(NodeServices.layer)("EnvironmentAuth.layer", (it) => {
}).pipe(Effect.provide(makeEnvironmentAuthLayer())),
);
+ it.effect("prefers a bearer token over a stale legacy cookie", () =>
+ Effect.gen(function* () {
+ const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
+ const sessions = yield* SessionStore.SessionStore;
+ const bearer = yield* serverAuth.issueSession();
+ const verified = yield* serverAuth.authenticateHttpRequest({
+ cookies: { [sessions.legacyCookieName ?? "t3_session"]: "stale" },
+ headers: { authorization: `Bearer ${bearer.token}` },
+ } as never);
+
+ expect(verified.sessionId).toBe(bearer.sessionId);
+ }).pipe(Effect.provide(makeEnvironmentAuthLayer({ mode: "web", host: "192.168.1.50" }))),
+ );
+
it.effect("does not exchange ordinary pairing grants for administrative access tokens", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
diff --git a/apps/server/src/auth/EnvironmentAuth.ts b/apps/server/src/auth/EnvironmentAuth.ts
index 86efea2a7..1816f41d9 100644
--- a/apps/server/src/auth/EnvironmentAuth.ts
+++ b/apps/server/src/auth/EnvironmentAuth.ts
@@ -27,6 +27,7 @@ import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import * as EnvironmentAuthPolicy from "./EnvironmentAuthPolicy.ts";
import * as PairingGrantStore from "./PairingGrantStore.ts";
import * as ServerSecretStore from "./ServerSecretStore.ts";
@@ -427,6 +428,29 @@ function parseBearerToken(request: HttpServerRequest.HttpServerRequest): string
return token.length > 0 ? token : null;
}
+export function selectRequestCredential(
+ request: HttpServerRequest.HttpServerRequest,
+ cookieName: string,
+ legacyCookieName: string | undefined,
+) {
+ const cookieToken = request.cookies[cookieName];
+ if (cookieToken !== undefined) {
+ return { token: cookieToken, source: "cookie" } as const;
+ }
+
+ const bearerToken = parseBearerToken(request);
+ if (bearerToken !== null) {
+ return { token: bearerToken, source: "bearer" } as const;
+ }
+
+ const legacyToken = legacyCookieName ? request.cookies[legacyCookieName] : undefined;
+ if (legacyToken !== undefined) {
+ return { token: legacyToken, source: "legacy-cookie" } as const;
+ }
+
+ return undefined;
+}
+
export const make = Effect.gen(function* () {
const policy = yield* EnvironmentAuthPolicy.EnvironmentAuthPolicy;
const bootstrapCredentials = yield* PairingGrantStore.PairingGrantStore;
@@ -462,13 +486,15 @@ export const make = Effect.gen(function* () {
const authenticateRequest = (
request: HttpServerRequest.HttpServerRequest,
): Effect.Effect<AuthenticatedSession, ServerAuthCredentialError | ServerAuthInternalError> => {
- const cookieToken = request.cookies[sessions.cookieName];
- const bearerToken = parseBearerToken(request);
- const credential = cookieToken ?? bearerToken;
- if (!credential) {
+ const credential = selectRequestCredential(
+ request,
+ sessions.cookieName,
+ sessions.legacyCookieName,
+ );
+ if (!credential?.token) {
return Effect.fail(new ServerAuthMissingCredentialError({}));
}
- return authenticateToken(credential);
+ return authenticateToken(credential.token);
};
const getSessionState: EnvironmentAuth["Service"]["getSessionState"] = (request) =>
@@ -826,4 +852,7 @@ export const layer = Layer.effect(EnvironmentAuth, make).pipe(
export const storageLayer = Layer.mergeAll(ServerSecretStore.layer, SqlitePersistenceLayer);
-export const runtimeLayer = layer.pipe(Layer.provideMerge(storageLayer));
+export const runtimeLayer = layer.pipe(
+ Layer.provideMerge(storageLayer),
+ Layer.provideMerge(ServerEnvironment.identityLayer),
+);
diff --git a/apps/server/src/auth/EnvironmentAuthAdmin.test.ts b/apps/server/src/auth/EnvironmentAuthAdmin.test.ts
index 9248714fd..c3e75c882 100644
--- a/apps/server/src/auth/EnvironmentAuthAdmin.test.ts
+++ b/apps/server/src/auth/EnvironmentAuthAdmin.test.ts
@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as ServerConfig from "../config.ts";
+import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import { SqlitePersistenceMemory } from "../persistence/Layers/Sqlite.ts";
import * as EnvironmentAuth from "./EnvironmentAuth.ts";
import * as ServerSecretStore from "./ServerSecretStore.ts";
@@ -35,6 +36,7 @@ const makeEnvironmentAuthLayer = (
EnvironmentAuth.layer.pipe(
Layer.provideMerge(ServerSecretStore.layer),
Layer.provideMerge(SqlitePersistenceMemory),
+ Layer.provide(ServerEnvironment.identityLayer),
Layer.provide(makeServerConfigLayer(overrides)),
);
diff --git a/apps/server/src/auth/EnvironmentAuthPolicy.test.ts b/apps/server/src/auth/EnvironmentAuthPolicy.test.ts
index 8e4c21710..982ff397d 100644
--- a/apps/server/src/auth/EnvironmentAuthPolicy.test.ts
+++ b/apps/server/src/auth/EnvironmentAuthPolicy.test.ts
@@ -4,12 +4,14 @@ import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as ServerConfig from "../config.ts";
+import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import * as EnvironmentAuthPolicy from "./EnvironmentAuthPolicy.ts";
const makeEnvironmentAuthPolicyLayer = (
overrides?: Partial<ServerConfig.ServerConfig["Service"]>,
) =>
EnvironmentAuthPolicy.layer.pipe(
+ Layer.provide(ServerEnvironment.identityLayer),
Layer.provide(
Layer.effect(
ServerConfig.ServerConfig,
@@ -107,7 +109,7 @@ it.layer(NodeServices.layer)("EnvironmentAuthPolicy.layer", (it) => {
expect(descriptor.policy).toBe("remote-reachable");
expect(descriptor.bootstrapMethods).toEqual(["one-time-token"]);
- expect(descriptor.sessionCookieName).toBe("t3_session");
+ expect(descriptor.sessionCookieName).toMatch(/^t3_session_[a-f0-9]{12}$/);
}).pipe(
Effect.provide(
makeEnvironmentAuthPolicyLayer({
@@ -143,7 +145,7 @@ it.layer(NodeServices.layer)("EnvironmentAuthPolicy.layer", (it) => {
const descriptor = yield* policy.getDescriptor();
expect(descriptor.policy).toBe("remote-reachable");
- expect(descriptor.sessionCookieName).toBe("t3_session");
+ expect(descriptor.sessionCookieName).toMatch(/^t3_session_[a-f0-9]{12}$/);
}).pipe(
Effect.provide(
makeEnvironmentAuthPolicyLayer({
diff --git a/apps/server/src/auth/EnvironmentAuthPolicy.ts b/apps/server/src/auth/EnvironmentAuthPolicy.ts
index 49ddee9f3..28637cec1 100644
--- a/apps/server/src/auth/EnvironmentAuthPolicy.ts
+++ b/apps/server/src/auth/EnvironmentAuthPolicy.ts
@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as ServerConfig from "../config.ts";
+import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import { isRemoteReachableHost, resolveSessionCookieName } from "./utils.ts";
export class EnvironmentAuthPolicy extends Context.Service<
@@ -15,6 +16,7 @@ export class EnvironmentAuthPolicy extends Context.Service<
export const make = Effect.gen(function* () {
const config = yield* ServerConfig.ServerConfig;
+ const serverEnvironment = yield* ServerEnvironment.ServerEnvironmentIdentity;
const isRemoteReachable = isRemoteReachableHost(config.host);
const policy =
@@ -42,6 +44,7 @@ export const make = Effect.gen(function* () {
port: config.port,
host: config.host,
instanceKey: config.stateDir,
+ environmentId: yield* serverEnvironment.getEnvironmentId,
development: config.devUrl !== undefined,
}),
};
diff --git a/apps/server/src/auth/SessionStore.test.ts b/apps/server/src/auth/SessionStore.test.ts
index 08057600a..21e5ce685 100644
--- a/apps/server/src/auth/SessionStore.test.ts
+++ b/apps/server/src/auth/SessionStore.test.ts
@@ -1,4 +1,5 @@
import * as NodeServices from "@effect/platform-node/NodeServices";
+import { EnvironmentId } from "@t3tools/contracts";
import { expect, it } from "@effect/vitest";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
@@ -7,15 +8,14 @@ import * as TestClock from "effect/testing/TestClock";
import * as SqlClient from "effect/unstable/sql/SqlClient";
import * as ServerConfig from "../config.ts";
+import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import { PersistenceSqlError } from "../persistence/Errors.ts";
import { SqlitePersistenceMemory } from "../persistence/Layers/Sqlite.ts";
import * as AuthSessions from "../persistence/AuthSessions.ts";
import * as SessionStore from "./SessionStore.ts";
import * as ServerSecretStore from "./ServerSecretStore.ts";
-const makeServerConfigLayer = (
- overrides?: Partial<Pick<ServerConfig.ServerConfig["Service"], "desktopBootstrapToken">>,
-) =>
+const makeServerConfigLayer = (overrides?: Partial<ServerConfig.ServerConfig["Service"]>) =>
Layer.effect(
ServerConfig.ServerConfig,
Effect.gen(function* () {
@@ -27,12 +27,19 @@ const makeServerConfigLayer = (
}),
).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-auth-session-test-" })));
+const makeServerEnvironmentLayer = (environmentId: EnvironmentId) =>
+ Layer.succeed(ServerEnvironment.ServerEnvironmentIdentity, {
+ getEnvironmentId: Effect.succeed(environmentId),
+ });
+
const makeSessionStoreLayer = (
- overrides?: Partial<Pick<ServerConfig.ServerConfig["Service"], "desktopBootstrapToken">>,
+ overrides?: Partial<ServerConfig.ServerConfig["Service"]>,
+ environmentId = EnvironmentId.make("test-environment"),
) =>
SessionStore.layer.pipe(
Layer.provide(SqlitePersistenceMemory),
Layer.provide(ServerSecretStore.layer),
+ Layer.provide(makeServerEnvironmentLayer(environmentId)),
Layer.provide(makeServerConfigLayer(overrides)),
);
@@ -58,10 +65,32 @@ const failingSessionLookupCredentialLayer = Layer.effect(
Layer.provide(failingSessionLookupRepositoryLayer),
Layer.provide(ServerSecretStore.layer),
Layer.provide(SqlitePersistenceMemory),
+ Layer.provide(makeServerEnvironmentLayer(EnvironmentId.make("test-environment"))),
Layer.provide(makeServerConfigLayer()),
);
it.layer(NodeServices.layer)("SessionStore.layer", (it) => {
+ it.effect("keys remote cookies by environment identity instead of state directory", () =>
+ Effect.gen(function* () {
+ const cookieName = (stateDir: string, environmentId: EnvironmentId) =>
+ Effect.gen(function* () {
+ const sessions = yield* SessionStore.SessionStore;
+ return sessions.cookieName;
+ }).pipe(
+ Effect.provide(
+ makeSessionStoreLayer({ mode: "web", host: "192.168.1.50", stateDir }, environmentId),
+ ),
+ );
+
+ const original = yield* cookieName("/srv/t3-one", EnvironmentId.make("environment-one"));
+ const moved = yield* cookieName("/srv/t3-moved", EnvironmentId.make("environment-one"));
+ const other = yield* cookieName("/srv/t3-one", EnvironmentId.make("environment-two"));
+
+ expect(moved).toBe(original);
+ expect(other).not.toBe(original);
+ }),
+ );
+
it.effect("issues and verifies signed browser session tokens", () =>
Effect.gen(function* () {
const sessions = yield* SessionStore.SessionStore;
diff --git a/apps/server/src/auth/SessionStore.ts b/apps/server/src/auth/SessionStore.ts
index f2049397a..73cb8ab40 100644
--- a/apps/server/src/auth/SessionStore.ts
+++ b/apps/server/src/auth/SessionStore.ts
@@ -21,11 +21,13 @@ import * as Stream from "effect/Stream";
import * as Option from "effect/Option";
import * as ServerConfig from "../config.ts";
+import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import * as AuthSessions from "../persistence/AuthSessions.ts";
import * as ServerSecretStore from "./ServerSecretStore.ts";
import {
base64UrlDecodeUtf8,
base64UrlEncode,
+ resolveLegacySessionCookieName,
resolveSessionCookieName,
signPayload,
timingSafeEqualBase64Url,
@@ -358,6 +360,7 @@ export class SessionStore extends Context.Service<
SessionStore,
{
readonly cookieName: string;
+ readonly legacyCookieName: string | undefined;
readonly issue: (input?: {
readonly ttl?: Duration.Duration;
readonly subject?: string;
@@ -466,18 +469,22 @@ function toAuthClientSession(input: Omit<AuthClientSession, "current">): AuthCli
export const make = Effect.gen(function* () {
const crypto = yield* Crypto.Crypto;
const serverConfig = yield* ServerConfig.ServerConfig;
+ const serverEnvironment = yield* ServerEnvironment.ServerEnvironmentIdentity;
const secretStore = yield* ServerSecretStore.ServerSecretStore;
const authSessions = yield* AuthSessions.AuthSessionRepository;
const signingSecret = yield* secretStore.getOrCreateRandom(SIGNING_SECRET_NAME, 32);
const connectedSessionsRef = yield* Ref.make(new Map<string, number>());
const changesPubSub = yield* PubSub.unbounded<SessionCredentialChange>();
- const cookieName = resolveSessionCookieName({
+ const cookieInput = {
mode: serverConfig.mode,
port: serverConfig.port,
host: serverConfig.host,
instanceKey: serverConfig.stateDir,
+ environmentId: yield* serverEnvironment.getEnvironmentId,
development: serverConfig.devUrl !== undefined,
- });
+ } as const;
+ const cookieName = resolveSessionCookieName(cookieInput);
+ const legacyCookieName = resolveLegacySessionCookieName(cookieInput);
const emitUpsert = (clientSession: AuthClientSession) =>
PubSub.publish(changesPubSub, {
@@ -923,6 +930,7 @@ export const make = Effect.gen(function* () {
return SessionStore.of({
cookieName,
+ legacyCookieName,
issue,
verify,
issueWebSocketToken,
diff --git a/apps/server/src/auth/http.ts b/apps/server/src/auth/http.ts
index 0065dbef2..e1ada0167 100644
--- a/apps/server/src/auth/http.ts
+++ b/apps/server/src/auth/http.ts
@@ -126,6 +126,23 @@ export function failEnvironmentNotFound(reason: EnvironmentResourceNotFoundReaso
);
}
+const appendSessionCookie = (cookieName: string, token: string, expiresAt: DateTime.DateTime) =>
+ Effect.fromResult(
+ Cookies.set(Cookies.empty, cookieName, token, {
+ expires: DateTime.toDate(expiresAt),
+ httpOnly: true,
+ path: "/",
+ sameSite: "lax",
+ }),
+ ).pipe(
+ Effect.catch(() => failEnvironmentInternal("browser_session_cookie_failed")),
+ Effect.flatMap((cookies) =>
+ HttpEffect.appendPreResponseHandler((_request, response) =>
+ Effect.succeed(HttpServerResponse.mergeCookies(response, cookies)),
+ ),
+ ),
+ );
+
export function failEnvironmentInternal(reason: EnvironmentInternalErrorReason, error?: unknown) {
return Effect.gen(function* () {
const traceId = yield* currentEnvironmentTraceId;
@@ -189,7 +206,22 @@ export const authHttpApiLayer = HttpApiBuilder.group(
function* (args) {
yield* annotateEnvironmentRequest(args.endpoint.name);
const request = yield* HttpServerRequest.HttpServerRequest;
- return yield* serverAuth.getSessionState(request);
+ const result = yield* serverAuth.getSessionState(request);
+ const credential = EnvironmentAuth.selectRequestCredential(
+ request,
+ sessions.cookieName,
+ sessions.legacyCookieName,
+ );
+ if (
+ credential?.source === "legacy-cookie" &&
+ result.authenticated &&
+ result.sessionMethod === "browser-session-cookie" &&
+ result.expiresAt
+ ) {
+ yield* appendSessionCookie(sessions.cookieName, credential.token, result.expiresAt);
+ yield* appendCredentialResponseHeaders;
+ }
+ return result;
},
Effect.catchIf(EnvironmentAuth.isServerAuthInternalError, (error) =>
failEnvironmentInternal("internal_error", error),
@@ -206,17 +238,10 @@ export const authHttpApiLayer = HttpApiBuilder.group(
args.payload.credential,
deriveAuthClientMetadata({ request }),
);
- const sessionCookies = yield* Effect.fromResult(
- Cookies.set(Cookies.empty, sessions.cookieName, result.sessionToken, {
- expires: DateTime.toDate(result.response.expiresAt),
- httpOnly: true,
- path: "/",
- sameSite: "lax",
- }),
- ).pipe(Effect.catch(() => failEnvironmentInternal("browser_session_cookie_failed")));
-
- yield* HttpEffect.appendPreResponseHandler((_request, response) =>
- Effect.succeed(HttpServerResponse.mergeCookies(response, sessionCookies)),
+ yield* appendSessionCookie(
+ sessions.cookieName,
+ result.sessionToken,
+ result.response.expiresAt,
);
yield* appendCredentialResponseHeaders;
return result.response;
diff --git a/apps/server/src/auth/utils.test.ts b/apps/server/src/auth/utils.test.ts
index 34c0ee376..4ff338706 100644
--- a/apps/server/src/auth/utils.test.ts
+++ b/apps/server/src/auth/utils.test.ts
@@ -3,6 +3,7 @@ import { describe, expect, it } from "vite-plus/test";
import {
deriveAuthClientMetadata,
isRemoteReachableHost,
+ resolveLegacySessionCookieName,
resolveSessionCookieName,
} from "./utils.ts";
@@ -64,6 +65,7 @@ describe("session cookie isolation", () => {
port: 5775,
host: "127.0.0.1",
instanceKey: "/tmp/t3-agent-one",
+ environmentId: "environment-one",
development: true,
});
const second = resolveSessionCookieName({
@@ -71,6 +73,7 @@ describe("session cookie isolation", () => {
port: 5775,
host: "127.0.0.1",
instanceKey: "/tmp/t3-agent-two",
+ environmentId: "environment-two",
development: true,
});
@@ -79,25 +82,48 @@ describe("session cookie isolation", () => {
expect(first).not.toBe(second);
});
- it("keeps the hosted web cookie stable across server instances", () => {
- expect(
- resolveSessionCookieName({
- mode: "web",
- port: 8080,
- host: "0.0.0.0",
- instanceKey: "/srv/release-a",
- development: false,
- }),
- ).toBe("t3_session");
- expect(
- resolveSessionCookieName({
- mode: "web",
- port: 9090,
- host: "app.example.com",
- instanceKey: "/srv/release-b",
- development: false,
- }),
- ).toBe("t3_session");
+ it("isolates remote web servers by server state", () => {
+ const first = resolveSessionCookieName({
+ mode: "web",
+ port: 3773,
+ host: "192.168.1.50",
+ instanceKey: "/srv/t3-one",
+ environmentId: "environment-one",
+ development: false,
+ });
+ const second = resolveSessionCookieName({
+ mode: "web",
+ port: 5775,
+ host: "192.168.1.50",
+ instanceKey: "/srv/t3-two",
+ environmentId: "environment-two",
+ development: false,
+ });
+
+ expect(first).toMatch(/^t3_session_[a-f0-9]{12}$/);
+ expect(second).toMatch(/^t3_session_[a-f0-9]{12}$/);
+ expect(first).not.toBe(second);
+ });
+
+ it("keeps a remote web server cookie stable across port changes", () => {
+ const first = resolveSessionCookieName({
+ mode: "web",
+ port: 8080,
+ host: "0.0.0.0",
+ instanceKey: "/srv/t3",
+ environmentId: "environment-one",
+ development: false,
+ });
+ const second = resolveSessionCookieName({
+ mode: "web",
+ port: 9090,
+ host: "app.example.com",
+ instanceKey: "/srv/t3",
+ environmentId: "environment-one",
+ development: false,
+ });
+
+ expect(first).toBe(second);
});
it("retains desktop port scoping", () => {
@@ -107,6 +133,7 @@ describe("session cookie isolation", () => {
port: 3773,
host: "127.0.0.1",
instanceKey: "/tmp/desktop",
+ environmentId: "environment-one",
development: true,
}),
).toBe("t3_session_3773");
@@ -119,11 +146,29 @@ describe("session cookie isolation", () => {
port: 5775,
host: "0.0.0.0",
instanceKey: "/tmp/t3-wildcard-dev",
+ environmentId: "environment-one",
development: true,
}),
).toMatch(/^t3_session_5775_[a-f0-9]{12}$/);
});
+ it("exposes the legacy remote web cookie name for migration", () => {
+ expect(
+ resolveLegacySessionCookieName({
+ mode: "web",
+ host: "192.168.1.50",
+ development: false,
+ }),
+ ).toBe("t3_session");
+ expect(
+ resolveLegacySessionCookieName({
+ mode: "desktop",
+ host: "127.0.0.1",
+ development: true,
+ }),
+ ).toBeUndefined();
+ });
+
it("classifies loopback aliases separately from remotely reachable hosts", () => {
expect(isRemoteReachableHost(undefined)).toBe(false);
expect(isRemoteReachableHost("localhost")).toBe(false);
diff --git a/apps/server/src/auth/utils.ts b/apps/server/src/auth/utils.ts
index 32a6799b0..30d59d654 100644
--- a/apps/server/src/auth/utils.ts
+++ b/apps/server/src/auth/utils.ts
@@ -16,40 +16,53 @@ const SESSION_COOKIE_NAME = "t3_session";
* clobbers the first's session and both sides see "Invalid session token
* signature" until someone clears cookies by hand.
*
- * Two populations qualify, for the same reason but from different causes:
+ * Remote web servers use their persisted environment identity and omit the
+ * port, so the name survives state-directory moves and public port changes.
*
- * - **Dev servers** (`devUrl` set), which run several at a time across worktrees.
- * - **Desktop**, which scans upward from 3773 for a free port and binds
+ * Desktop scans upward from 3773 for a free port and binds
* 127.0.0.1, so a second instance lands on a different port and the same host.
- *
- * Hosted deployments keep the stable production name: their public port can
- * change between releases, and scoping it would log every user out.
*/
export function resolveSessionCookieName(input: {
readonly mode: "web" | "desktop";
readonly port: number;
readonly host: string | undefined;
readonly instanceKey: string;
+ readonly environmentId: string;
readonly development: boolean;
}): string {
if (input.mode === "desktop") {
return `${SESSION_COOKIE_NAME}_${input.port}`;
}
+ const instanceHash = NodeCrypto.createHash("sha256")
+ .update(
+ !input.development && isRemoteReachableHost(input.host)
+ ? input.environmentId
+ : input.instanceKey,
+ )
+ .digest("hex")
+ .slice(0, 12);
+
if (!input.development && isRemoteReachableHost(input.host)) {
- return SESSION_COOKIE_NAME;
+ return `${SESSION_COOKIE_NAME}_${instanceHash}`;
}
// Cookies are scoped by host, not port. Loopback development servers need an
// instance-specific name or parallel agents overwrite each other's session,
// and a server that later reuses the port receives a token signed elsewhere.
- const instanceHash = NodeCrypto.createHash("sha256")
- .update(input.instanceKey)
- .digest("hex")
- .slice(0, 12);
return `${SESSION_COOKIE_NAME}_${input.port}_${instanceHash}`;
}
+export function resolveLegacySessionCookieName(input: {
+ readonly mode: "web" | "desktop";
+ readonly host: string | undefined;
+ readonly development: boolean;
+}): string | undefined {
+ return input.mode === "web" && !input.development && isRemoteReachableHost(input.host)
+ ? SESSION_COOKIE_NAME
+ : undefined;
+}
+
export function isRemoteReachableHost(host: string | undefined): boolean {
if (host === "0.0.0.0" || host === "::" || host === "[::]") {
return true;
diff --git a/apps/server/src/bin.test.ts b/apps/server/src/bin.test.ts
index 994c37f56..b629f6b31 100644
--- a/apps/server/src/bin.test.ts
+++ b/apps/server/src/bin.test.ts
@@ -41,6 +41,7 @@ import * as WorkspacePaths from "./workspace/WorkspacePaths.ts";
import * as ServerSecretStore from "./auth/ServerSecretStore.ts";
import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";
import { environmentAuthenticatedAuthLayer } from "./auth/http.ts";
+import * as ServerEnvironment from "./environment/ServerEnvironment.ts";
const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer);
class ProjectCliHttpApi extends HttpApi.make("environment").add(EnvironmentOrchestrationHttpApi) {}
@@ -125,6 +126,7 @@ const withLiveProjectCliServer = <A, E, R>(baseDir: string, run: () => Effect.Ef
EnvironmentAuth.layer.pipe(
Layer.provideMerge(SqlitePersistenceLayerLive),
Layer.provide(ServerSecretStore.layer),
+ Layer.provide(ServerEnvironment.identityLayer),
),
),
Layer.provideMerge(makeProjectPersistenceLayer(config)),
diff --git a/apps/server/src/environment/ServerEnvironment.test.ts b/apps/server/src/environment/ServerEnvironment.test.ts
index aa0f3cbbf..5542ce896 100644
--- a/apps/server/src/environment/ServerEnvironment.test.ts
+++ b/apps/server/src/environment/ServerEnvironment.test.ts
@@ -1,5 +1,7 @@
import * as NodeServices from "@effect/platform-node/NodeServices";
import { expect, it } from "@effect/vitest";
+import * as Crypto from "effect/Crypto";
+import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
@@ -50,6 +52,77 @@ const makeServerConfig = Effect.fn(function* (baseDir: string) {
});
it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
+ it.effect.each([
+ { name: "missing", content: undefined },
+ { name: "empty", content: "" },
+ { name: "whitespace-only", content: " \t\n" },
+ ])("concurrent initializers recover a $name environment id file", ({ content }) =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const crypto = yield* Crypto.Crypto;
+ const baseDir = yield* fileSystem.makeTempDirectoryScoped({
+ prefix: "t3-server-environment-concurrent-test-",
+ });
+ const serverConfig = yield* makeServerConfig(baseDir);
+ yield* fileSystem.makeDirectory(serverConfig.stateDir, { recursive: true });
+ if (content !== undefined) {
+ yield* fileSystem.writeFileString(serverConfig.environmentIdPath, content);
+ }
+ const bothGenerated = yield* Deferred.make<void>();
+ const bothReadEmpty = yield* Deferred.make<void>();
+ const firstInitialized = yield* Deferred.make<void>();
+ let remaining = 2;
+ let emptyReads = 0;
+ const readIdentity = Effect.gen(function* () {
+ const identity = yield* ServerEnvironment.ServerEnvironmentIdentity;
+ return yield* identity.getEnvironmentId;
+ }).pipe(
+ Effect.tap(() => Deferred.succeed(firstInitialized, undefined)),
+ Effect.provide(Layer.fresh(ServerEnvironment.identityLayer)),
+ Effect.provideService(ServerConfig.ServerConfig, serverConfig),
+ Effect.provideService(FileSystem.FileSystem, {
+ ...fileSystem,
+ readFileString: (path) =>
+ fileSystem.readFileString(path).pipe(
+ Effect.tap(
+ Effect.fn(function* (value) {
+ if (path !== serverConfig.environmentIdPath || remaining > 0 || value.trim()) {
+ return;
+ }
+ // Both observe the empty file, but one repairs it after the other has finished.
+ if (++emptyReads === 2) {
+ yield* Deferred.succeed(bothReadEmpty, undefined);
+ yield* Deferred.await(firstInitialized);
+ } else {
+ yield* Deferred.await(bothReadEmpty);
+ }
+ }),
+ ),
+ ),
+ }),
+ Effect.provideService(Crypto.Crypto, {
+ ...crypto,
+ randomUUIDv4: Effect.gen(function* () {
+ const id = yield* crypto.randomUUIDv4;
+ if (--remaining === 0) {
+ yield* Deferred.succeed(bothGenerated, undefined);
+ }
+ yield* Deferred.await(bothGenerated);
+ return id;
+ }),
+ }),
+ );
+
+ const [first, second] = yield* Effect.all([readIdentity, readIdentity], {
+ concurrency: "unbounded",
+ });
+ const persisted = yield* fileSystem.readFileString(serverConfig.environmentIdPath);
+
+ expect(first).toBe(second);
+ expect(persisted.trim()).toBe(first);
+ }),
+ );
+
it.effect("persists the environment id across service restarts", () =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
@@ -85,6 +158,7 @@ it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
});
const serverConfig = yield* makeServerConfig(baseDir);
const environmentIdPath = serverConfig.environmentIdPath;
+ const tempPath = `${environmentIdPath}.tmp`;
const methodByOperation = {
check: "exists",
read: "readFileString",
@@ -104,6 +178,7 @@ it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
exists: () =>
operation === "check" ? Effect.fail(cause) : Effect.succeed(operation === "read"),
readFileString: () => Effect.fail(cause),
+ makeTempFileScoped: () => Effect.succeed(tempPath),
writeFileString: (path) => {
writeAttempts.push(path);
return Effect.fail(cause);
@@ -132,7 +207,7 @@ it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
expect(error.message).toBe(
`Server environment ID ${operation} failed at '${environmentIdPath}'.`,
);
- expect(writeAttempts).toEqual(operation === "write" ? [environmentIdPath] : []);
+ expect(writeAttempts).toEqual(operation === "write" ? [tempPath] : []);
}
}),
);
diff --git a/apps/server/src/environment/ServerEnvironment.ts b/apps/server/src/environment/ServerEnvironment.ts
index 4de2b31ac..2911c303e 100644
--- a/apps/server/src/environment/ServerEnvironment.ts
+++ b/apps/server/src/environment/ServerEnvironment.ts
@@ -18,12 +18,15 @@ import { resolveServerEnvironmentLabel } from "./ServerEnvironmentLabel.ts";
export class ServerEnvironmentIdPersistenceError extends Schema.TaggedErrorClass<ServerEnvironmentIdPersistenceError>()(
"ServerEnvironmentIdPersistenceError",
{
- operation: Schema.Literals(["check", "read", "write"]),
+ operation: Schema.Literals(["check", "read", "write", "initialize"]),
environmentIdPath: Schema.String,
- cause: Schema.Defect(),
+ cause: Schema.optional(Schema.Defect()),
},
) {
override get message(): string {
+ if (this.operation === "initialize") {
+ return `Server environment ID file is missing or empty after initialization at '${this.environmentIdPath}'.`;
+ }
return `Server environment ID ${this.operation} failed at '${this.environmentIdPath}'.`;
}
}
@@ -36,6 +39,13 @@ export class ServerEnvironment extends Context.Service<
}
>()("akeru-bot/environment/ServerEnvironment") {}
+export class ServerEnvironmentIdentity extends Context.Service<
+ ServerEnvironmentIdentity,
+ {
+ readonly getEnvironmentId: Effect.Effect<EnvironmentId>;
+ }
+>()("akeru-bot/environment/ServerEnvironment/ServerEnvironmentIdentity") {}
+
function platformOs(platform: NodeJS.Platform): ExecutionEnvironmentDescriptor["platform"]["os"] {
switch (platform) {
case "darwin":
@@ -62,13 +72,10 @@ function platformArch(
}
}
-export const make = Effect.gen(function* () {
+const makeIdentity = Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
- const path = yield* Path.Path;
const serverConfig = yield* ServerConfig.ServerConfig;
const crypto = yield* Crypto.Crypto;
- const hostPlatform = yield* HostProcessPlatform;
- const hostArchitecture = yield* HostProcessArchitecture;
const readPersistedEnvironmentId = Effect.gen(function* () {
const exists = yield* fileSystem.exists(serverConfig.environmentIdPath).pipe(
@@ -100,17 +107,42 @@ export const make = Effect.gen(function* () {
return raw.length > 0 ? raw : null;
});
- const persistEnvironmentId = (value: string) =>
- fileSystem.writeFileString(serverConfig.environmentIdPath, `${value}\n`).pipe(
- Effect.mapError(
- (cause) =>
- new ServerEnvironmentIdPersistenceError({
- operation: "write",
- environmentIdPath: serverConfig.environmentIdPath,
- cause,
- }),
- ),
- );
+ const persistEnvironmentId = Effect.fn("ServerEnvironmentIdentity.persistEnvironmentId")(
+ function* (value: string, mode: "create" | "recover") {
+ const destinationPath =
+ mode === "recover"
+ ? `${serverConfig.environmentIdPath}.recovery`
+ : serverConfig.environmentIdPath;
+ const tempPath = yield* fileSystem.makeTempFileScoped({
+ directory: serverConfig.stateDir,
+ prefix: ".environment-id-",
+ });
+ yield* fileSystem.writeFileString(tempPath, `${value}\n`);
+ // Publish the completed file without replacing an ID created by another process.
+ yield* fileSystem
+ .link(tempPath, destinationPath)
+ .pipe(
+ Effect.catch((cause) =>
+ cause.reason._tag === "AlreadyExists" ? Effect.void : Effect.fail(cause),
+ ),
+ );
+ if (mode === "recover") {
+ // Keep the recovery ID so delayed initializers also publish the same winner.
+ yield* fileSystem.remove(tempPath);
+ yield* fileSystem.copyFile(destinationPath, tempPath);
+ yield* fileSystem.rename(tempPath, serverConfig.environmentIdPath);
+ }
+ },
+ Effect.scoped,
+ Effect.mapError(
+ (cause) =>
+ new ServerEnvironmentIdPersistenceError({
+ operation: "write",
+ environmentIdPath: serverConfig.environmentIdPath,
+ cause,
+ }),
+ ),
+ );
const environmentIdRaw = yield* Effect.gen(function* () {
const persisted = yield* readPersistedEnvironmentId;
@@ -119,11 +151,34 @@ export const make = Effect.gen(function* () {
}
const generated = yield* crypto.randomUUIDv4;
- yield* persistEnvironmentId(generated);
- return generated;
+ yield* persistEnvironmentId(generated, "create");
+ let winner = yield* readPersistedEnvironmentId;
+ if (winner === null) {
+ yield* persistEnvironmentId(generated, "recover");
+ winner = yield* readPersistedEnvironmentId;
+ }
+ if (winner === null) {
+ return yield* new ServerEnvironmentIdPersistenceError({
+ operation: "initialize",
+ environmentIdPath: serverConfig.environmentIdPath,
+ });
+ }
+ return winner;
});
const environmentId = EnvironmentId.make(environmentIdRaw);
+ return ServerEnvironmentIdentity.of({
+ getEnvironmentId: Effect.succeed(environmentId),
+ });
+});
+
+export const make = Effect.gen(function* () {
+ const path = yield* Path.Path;
+ const serverConfig = yield* ServerConfig.ServerConfig;
+ const identity = yield* ServerEnvironmentIdentity;
+ const hostPlatform = yield* HostProcessPlatform;
+ const hostArchitecture = yield* HostProcessArchitecture;
+ const environmentId = yield* identity.getEnvironmentId;
const cwdBaseName = path.basename(serverConfig.cwd).trim();
const label = yield* resolveServerEnvironmentLabel({ cwdBaseName });
const launcher = yield* resolveServiceLauncherMode();
@@ -163,9 +218,14 @@ export const make = Effect.gen(function* () {
});
});
+export const identityLayer = Layer.effect(ServerEnvironmentIdentity, makeIdentity);
+
/**
* ServerEnvironment is acquired from persisted filesystem and host-process
* state. It intentionally has no fallback Layer.succeed value: callers must
* provide the external platform services and a ServerConfig.
*/
-export const layer = Layer.effect(ServerEnvironment, make).pipe(Layer.provide(ProcessRunner.layer));
+export const layer = Layer.effect(ServerEnvironment, make).pipe(
+ Layer.provideMerge(identityLayer),
+ Layer.provide(ProcessRunner.layer),
+);
diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.ts
index 7e2daec42..4cc4eebf2 100644
--- a/apps/server/src/server.test.ts
+++ b/apps/server/src/server.test.ts
@@ -345,6 +345,11 @@ const makeAuthTestLayer = () =>
EnvironmentAuth.layer.pipe(
Layer.provide(SqlitePersistenceMemory),
Layer.provide(ServerSecretStore.layer),
+ Layer.provide(
+ Layer.mock(ServerEnvironment.ServerEnvironmentIdentity)({
+ getEnvironmentId: Effect.succeed(testEnvironmentDescriptor.environmentId),
+ }),
+ ),
);
const makeBrowserOtlpPayload = (spanName: string) =>
@@ -1588,6 +1593,48 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
+ it.effect("migrates a valid legacy remote-web session cookie", () =>
+ Effect.gen(function* () {
+ yield* buildAppUnderTest({ config: { mode: "web", host: "192.168.1.50" } });
+
+ const { cookie } = yield* bootstrapBrowserSession();
+ const currentCookie = cookie?.split(";")[0] ?? "";
+ const legacyCookie = currentCookie.replace(/^t3_session_[^=]+=/, "t3_session=");
+ const sessionUrl = yield* getHttpServerUrl("/api/auth/session");
+ const response = yield* fetchEffect(sessionUrl, {
+ headers: { cookie: legacyCookie },
+ });
+ const body = yield* responseJsonEffect<{ readonly authenticated: boolean }>(response);
+
+ assert.equal(body.authenticated, true);
+ assert.equal(response.headers["set-cookie"], cookie);
+ assert.equal(response.headers["cache-control"], "no-store");
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect.each(["cookie", "bearer"])(
+ "does not migrate a stale legacy cookie when %s auth succeeds",
+ (source) =>
+ Effect.gen(function* () {
+ yield* buildAppUnderTest({ config: { mode: "web", host: "192.168.1.50" } });
+
+ const { cookie } = yield* bootstrapBrowserSession();
+ const sessionCookie = cookie?.split(";")[0] ?? "";
+ const sessionToken = extractSessionTokenFromSetCookie(cookie ?? "");
+ const sessionUrl = yield* getHttpServerUrl("/api/auth/session");
+ const response = yield* fetchEffect(sessionUrl, {
+ headers:
+ source === "cookie"
+ ? { cookie: `${sessionCookie}; t3_session=stale` }
+ : { authorization: `Bearer ${sessionToken}`, cookie: "t3_session=stale" },
+ });
+ const body = yield* responseJsonEffect<{ readonly authenticated: boolean }>(response);
+
+ assert.equal(body.authenticated, true);
+ assert.isUndefined(response.headers["set-cookie"]);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
it.effect("exchanges a bootstrap grant for a scoped bearer access token", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index 06935733b..24c0c4284 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -364,8 +364,11 @@ const ProjectFaviconResolverLayerLive = ProjectFaviconResolver.layer.pipe(
Layer.provide(T3ProjectFileLoader.layer),
);
+const ServerEnvironmentLayerLive = ServerEnvironment.layer;
+
const AuthLayerLive = EnvironmentAuth.layer.pipe(
Layer.provideMerge(PersistenceLayerLive),
+ Layer.provide(ServerEnvironmentLayerLive),
Layer.provide(ServerSecretStore.layer),
);
@@ -412,7 +415,7 @@ const RuntimeCoreDependenciesLive = ReactorLayerLive.pipe(
Layer.provideMerge(WorkspaceLayerLive),
Layer.provideMerge(ProjectFaviconResolverLayerLive),
Layer.provideMerge(RepositoryIdentityResolver.layer),
- Layer.provideMerge(ServerEnvironment.layer),
+ Layer.provideMerge(ServerEnvironmentLayerLive),
Layer.provideMerge(AuthLayerLive),
Layer.provideMerge(
Layer.mergeAll(
diff --git a/docs/internals/remote.md b/docs/internals/remote.md
index 8161449bf..75a2f5ff8 100644
--- a/docs/internals/remote.md
+++ b/docs/internals/remote.md
@@ -55,7 +55,11 @@ a directly reachable server after normal pairing.
## Environment identity
Each server stores a stable `environmentId` in its state directory. Clients use that identifier to
-reject endpoints that point at a different server than the saved target.
+reject endpoints that point at a different server than the saved target. Remote production web
+cookies use that same identity, so two `akeru serve` instances on one hostname keep separate
+sessions. Initialization publishes a complete ID atomically. Empty or whitespace-only ID files are
+repaired using a retained `<stateDir>/environment-id.recovery` file so concurrent and delayed
+repairs choose the same ID. Existing nonempty ID files remain authoritative.
Repository identity may group related clones in the interface. It never changes routing. A project
always belongs to one environment.