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.tsindex 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.tsindex 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): stringreturn 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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">): AuthCliexport 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.EfEnvironmentAuth.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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.mdindex 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 identityEach 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 projectalways belongs to one environment.