The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 2 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 3 | import { EnvironmentId } from "@t3tools/contracts"; |
| 4 | import { expect, it } from "@effect/vitest"; |
| 5 | import * as DateTime from "effect/DateTime"; |
| 6 | import * as Duration from "effect/Duration"; |
| 7 | import * as Effect from "effect/Effect"; |
| 8 | import * as Fiber from "effect/Fiber"; |
| 9 | import * as Deferred from "effect/Deferred"; |
| 10 | import * as FileSystem from "effect/FileSystem"; |
| 11 | import * as Layer from "effect/Layer"; |
| 12 | import * as Option from "effect/Option"; |
| 13 | import * as Redacted from "effect/Redacted"; |
| 14 | import * as TestClock from "effect/testing/TestClock"; |
| 15 | import * as SqlClient from "effect/sql/SqlClient"; |
| 16 | |
| 17 | import * as ServerConfig from "../config.ts"; |
| 18 | import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; |
| 19 | |
| 20 | import * as SqlitePersistence from "../persistence/Sqlite.ts"; |
| 21 | import * as SessionStore from "./SessionStore.ts"; |
| 22 | import * as ServerSecretStore from "./ServerSecretStore.ts"; |
| 23 | import { base64UrlDecodeUtf8, base64UrlEncode } from "./utils.ts"; |
| 24 | import * as PayloadSigner from "./PayloadSigner.ts"; |
| 25 | |
| 26 | const layerServerConfig = (overrides?: Partial<ServerConfig.ServerConfig["Service"]>) => |
| 27 | Layer.effect( |
| 28 | ServerConfig.ServerConfig, |
| 29 | Effect.gen(function* () { |
| 30 | const config = yield* ServerConfig.ServerConfig; |
| 31 | return { |
| 32 | ...config, |
| 33 | ...overrides, |
| 34 | } satisfies ServerConfig.ServerConfig["Service"]; |
| 35 | }), |
| 36 | ).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-auth-session-test-" }))); |
| 37 | |
| 38 | const layerServerEnvironment = (environmentId: EnvironmentId) => |
| 39 | Layer.succeed(ServerEnvironment.ServerEnvironmentIdentity, { |
| 40 | getEnvironmentId: Effect.succeed(environmentId), |
| 41 | }); |
| 42 | |
| 43 | const layerSessionStore = ( |
| 44 | overrides?: Partial<ServerConfig.ServerConfig["Service"]>, |
| 45 | environmentId = EnvironmentId.make("test-environment"), |
| 46 | ) => |
| 47 | SessionStore.layer.pipe( |
| 48 | Layer.provide(SqlitePersistence.layerMemory), |
| 49 | Layer.provide(ServerSecretStore.layer), |
| 50 | Layer.provide(layerServerEnvironment(environmentId)), |
| 51 | Layer.provide(layerServerConfig(overrides)), |
| 52 | ); |
| 53 | |
| 54 | const relaySessionInput = { |
| 55 | subject: "managed-relay-bootstrap", |
| 56 | method: "dpop-access-token", |
| 57 | proofKeyThumbprint: "relay-proof-key", |
| 58 | ttl: Duration.hours(1), |
| 59 | client: { label: "Relay desktop", deviceType: "desktop" }, |
| 60 | } as const; |
| 61 | |
| 62 | const makeDiskSessionStoreLayer = Effect.fn("makeDiskSessionStoreLayer")(function* ( |
| 63 | baseDir: string, |
| 64 | token?: string, |
| 65 | ) { |
| 66 | const devUrl = new URL("http://127.0.0.1:5173"); |
| 67 | const paths = yield* ServerConfig.deriveServerPaths(baseDir, devUrl, { |
| 68 | baseDirIsExplicit: true, |
| 69 | }); |
| 70 | yield* ServerConfig.ensureServerDirectories(paths); |
| 71 | const layerPersistence = SqlitePersistence.layerFromPath(paths.dbPath); |
| 72 | return SessionStore.layer.pipe( |
| 73 | Layer.provide(layerPersistence), |
| 74 | Layer.provide(ServerSecretStore.layer), |
| 75 | Layer.provide(layerServerEnvironment(EnvironmentId.make(baseDir))), |
| 76 | Layer.provide( |
| 77 | layerServerConfig({ |
| 78 | ...paths, |
| 79 | baseDir, |
| 80 | mode: "web", |
| 81 | devUrl, |
| 82 | ...(token === undefined ? {} : { devAuthToken: Redacted.make(token) }), |
| 83 | }), |
| 84 | ), |
| 85 | ); |
| 86 | }); |
| 87 | |
| 88 | it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("SessionStore.layer", (it) => { |
| 89 | it.effect.each(["revoke", "revokeAllExcept", "replace"] as const)( |
| 90 | "invalidates every connection for a session on %s and leaves other sessions active", |
| 91 | (operation) => |
| 92 | Effect.gen(function* () { |
| 93 | const sessions = yield* SessionStore.SessionStore; |
| 94 | const owner = yield* sessions.issue({ subject: "owner" }); |
| 95 | const client = yield* sessions.issue(relaySessionInput); |
| 96 | const ownerInvalidated = yield* Deferred.make<void>(); |
| 97 | yield* sessions |
| 98 | .awaitInvalidation(owner.sessionId) |
| 99 | .pipe( |
| 100 | Effect.andThen(Deferred.succeed(ownerInvalidated, undefined)), |
| 101 | Effect.forkScoped({ startImmediately: true }), |
| 102 | ); |
| 103 | const first = yield* sessions |
| 104 | .awaitInvalidation(client.sessionId, relaySessionInput.proofKeyThumbprint) |
| 105 | .pipe(Effect.forkScoped({ startImmediately: true })); |
| 106 | const second = yield* sessions |
| 107 | .awaitInvalidation(client.sessionId, relaySessionInput.proofKeyThumbprint) |
| 108 | .pipe(Effect.forkScoped({ startImmediately: true })); |
| 109 | if (operation === "revoke") yield* sessions.revoke(client.sessionId); |
| 110 | else if (operation === "revokeAllExcept") yield* sessions.revokeAllExcept(owner.sessionId); |
| 111 | else yield* sessions.issue({ ...relaySessionInput, replaceSessionId: client.sessionId }); |
| 112 | yield* Fiber.join(first); |
| 113 | yield* Fiber.join(second); |
| 114 | expect(yield* Deferred.isDone(ownerInvalidated)).toBe(false); |
| 115 | yield* sessions.awaitInvalidation(client.sessionId); |
| 116 | }).pipe(Effect.scoped, Effect.provide(Layer.merge(layerSessionStore(), TestClock.layer()))), |
| 117 | ); |
| 118 | |
| 119 | it.effect("expires a connected session at its credential deadline", () => |
| 120 | Effect.gen(function* () { |
| 121 | const sessions = yield* SessionStore.SessionStore; |
| 122 | const client = yield* sessions.issue(relaySessionInput); |
| 123 | yield* sessions.markConnected(client.sessionId); |
| 124 | const invalidated = yield* Deferred.make<void>(); |
| 125 | const watcher = yield* sessions |
| 126 | .awaitInvalidation(client.sessionId, relaySessionInput.proofKeyThumbprint) |
| 127 | .pipe( |
| 128 | Effect.andThen(Deferred.succeed(invalidated, undefined)), |
| 129 | Effect.forkScoped({ startImmediately: true }), |
| 130 | ); |
| 131 | yield* TestClock.adjust(Duration.minutes(59)); |
| 132 | expect(yield* Deferred.isDone(invalidated)).toBe(false); |
| 133 | yield* TestClock.adjust(Duration.minutes(1)); |
| 134 | yield* Fiber.join(watcher); |
| 135 | yield* sessions.awaitInvalidation(client.sessionId); |
| 136 | }).pipe(Effect.scoped, Effect.provide(Layer.merge(layerSessionStore(), TestClock.layer()))), |
| 137 | ); |
| 138 | |
| 139 | it.effect.each([ |
| 140 | { name: "a renewal for the same key", renewal: {}, closesAtMinute: 119 }, |
| 141 | { |
| 142 | name: "a renewal for the same key, on a media ticket", |
| 143 | renewal: {}, |
| 144 | closesAtMinute: 119, |
| 145 | ticket: "media", |
| 146 | }, |
| 147 | { |
| 148 | name: "a renewal for another key", |
| 149 | renewal: { proofKeyThumbprint: "other-proof-key" }, |
| 150 | closesAtMinute: 60, |
| 151 | }, |
| 152 | { |
| 153 | name: "a renewal with fewer scopes", |
| 154 | renewal: { scopes: ["orchestration:read"] as const }, |
| 155 | closesAtMinute: 60, |
| 156 | }, |
| 157 | { |
| 158 | name: "a renewal, until the original is revoked", |
| 159 | renewal: {}, |
| 160 | closesAtMinute: 90, |
| 161 | revoke: "original", |
| 162 | }, |
| 163 | { |
| 164 | name: "a renewal, until the renewal is revoked", |
| 165 | renewal: {}, |
| 166 | closesAtMinute: 90, |
| 167 | revoke: "renewal", |
| 168 | }, |
| 169 | ] as const)("closes a DPoP socket at minute $closesAtMinute after $name", (testCase) => |
| 170 | Effect.gen(function* () { |
| 171 | const sessions = yield* SessionStore.SessionStore; |
| 172 | const client = yield* sessions.issue(relaySessionInput); |
| 173 | const invalidated = yield* Deferred.make<void>(); |
| 174 | // Media tickets carry no proof key, so their routes wait without one. |
| 175 | const watched = |
| 176 | "ticket" in testCase |
| 177 | ? yield* sessions.verifyWebSocketToken( |
| 178 | (yield* sessions.issueWebSocketToken(client.sessionId, { audience: "media" })).token, |
| 179 | ) |
| 180 | : { |
| 181 | sessionId: client.sessionId, |
| 182 | proofKeyThumbprint: relaySessionInput.proofKeyThumbprint, |
| 183 | }; |
| 184 | const watcher = yield* sessions |
| 185 | .awaitInvalidation(watched.sessionId, watched.proofKeyThumbprint) |
| 186 | .pipe( |
| 187 | Effect.andThen(Deferred.succeed(invalidated, undefined)), |
| 188 | Effect.forkScoped({ startImmediately: true }), |
| 189 | ); |
| 190 | yield* TestClock.adjust(Duration.minutes(59)); |
| 191 | const renewal = yield* sessions.issue({ ...relaySessionInput, ...testCase.renewal }); |
| 192 | yield* TestClock.adjust(Duration.millis((testCase.closesAtMinute - 59) * 60_000 - 1)); |
| 193 | expect(yield* Deferred.isDone(invalidated)).toBe(false); |
| 194 | yield* TestClock.adjust(Duration.millis(1)); |
| 195 | if ("revoke" in testCase) { |
| 196 | yield* sessions.revoke( |
| 197 | testCase.revoke === "original" ? client.sessionId : renewal.sessionId, |
| 198 | ); |
| 199 | } |
| 200 | yield* Fiber.join(watcher); |
| 201 | }).pipe(Effect.scoped, Effect.provide(Layer.merge(layerSessionStore(), TestClock.layer()))), |
| 202 | ); |
| 203 | |
| 204 | it.effect("keeps a socket on a session renewed in place until its moved deadline", () => |
| 205 | Effect.gen(function* () { |
| 206 | const sessions = yield* SessionStore.SessionStore; |
| 207 | const renewable = { ttl: Duration.hours(1), renewalWindow: Duration.hours(2) }; |
| 208 | const client = yield* sessions.issue({ ...relaySessionInput, ...renewable }); |
| 209 | const invalidated = yield* Deferred.make<void>(); |
| 210 | const watcher = yield* sessions |
| 211 | .awaitInvalidation(client.sessionId, relaySessionInput.proofKeyThumbprint) |
| 212 | .pipe( |
| 213 | Effect.andThen(Deferred.succeed(invalidated, undefined)), |
| 214 | Effect.forkScoped({ startImmediately: true }), |
| 215 | ); |
| 216 | yield* TestClock.adjust(Duration.minutes(90)); |
| 217 | yield* sessions.renew(client.token, { |
| 218 | proofKeyThumbprint: relaySessionInput.proofKeyThumbprint, |
| 219 | consumeProof: Effect.void, |
| 220 | ...renewable, |
| 221 | }); |
| 222 | yield* TestClock.adjust(Duration.millis(120 * 60_000 - 1)); |
| 223 | expect(yield* Deferred.isDone(invalidated)).toBe(false); |
| 224 | yield* TestClock.adjust(Duration.millis(1)); |
| 225 | yield* Fiber.join(watcher); |
| 226 | }).pipe(Effect.scoped, Effect.provide(Layer.merge(layerSessionStore(), TestClock.layer()))), |
| 227 | ); |
| 228 | |
| 229 | it.effect("closes a DPoP socket when an earlier renewal in its chain is revoked", () => |
| 230 | Effect.gen(function* () { |
| 231 | const sessions = yield* SessionStore.SessionStore; |
| 232 | const client = yield* sessions.issue(relaySessionInput); |
| 233 | const invalidated = yield* Deferred.make<void>(); |
| 234 | const watcher = yield* sessions |
| 235 | .awaitInvalidation(client.sessionId, relaySessionInput.proofKeyThumbprint) |
| 236 | .pipe( |
| 237 | Effect.andThen(Deferred.succeed(invalidated, undefined)), |
| 238 | Effect.forkScoped({ startImmediately: true }), |
| 239 | ); |
| 240 | yield* TestClock.adjust(Duration.minutes(59)); |
| 241 | const first = yield* sessions.issue(relaySessionInput); |
| 242 | yield* TestClock.adjust(Duration.minutes(59)); |
| 243 | yield* sessions.issue(relaySessionInput); |
| 244 | // Past the first renewal's expiry, so the socket now follows the second. |
| 245 | yield* TestClock.adjust(Duration.minutes(2)); |
| 246 | expect(yield* Deferred.isDone(invalidated)).toBe(false); |
| 247 | yield* sessions.revoke(first.sessionId); |
| 248 | yield* Fiber.join(watcher); |
| 249 | }).pipe(Effect.scoped, Effect.provide(Layer.merge(layerSessionStore(), TestClock.layer()))), |
| 250 | ); |
| 251 | |
| 252 | it.effect("keeps a renewed DPoP socket when another socket on its expired session closes", () => |
| 253 | Effect.gen(function* () { |
| 254 | const sessions = yield* SessionStore.SessionStore; |
| 255 | const client = yield* sessions.issue(relaySessionInput); |
| 256 | yield* sessions.markConnected(client.sessionId); |
| 257 | const invalidated = yield* Deferred.make<void>(); |
| 258 | const watcher = yield* sessions |
| 259 | .awaitInvalidation(client.sessionId, relaySessionInput.proofKeyThumbprint) |
| 260 | .pipe( |
| 261 | Effect.andThen(Deferred.succeed(invalidated, undefined)), |
| 262 | Effect.forkScoped({ startImmediately: true }), |
| 263 | ); |
| 264 | yield* TestClock.adjust(Duration.minutes(59)); |
| 265 | yield* sessions.issue(relaySessionInput); |
| 266 | yield* TestClock.adjust(Duration.minutes(2)); |
| 267 | // An expired session that loses its last socket is reported as removed, not revoked. |
| 268 | yield* sessions.markDisconnected(client.sessionId); |
| 269 | yield* TestClock.adjust(Duration.millis(58 * 60_000 - 1)); |
| 270 | expect(yield* Deferred.isDone(invalidated)).toBe(false); |
| 271 | yield* TestClock.adjust(Duration.millis(1)); |
| 272 | yield* Fiber.join(watcher); |
| 273 | }).pipe(Effect.scoped, Effect.provide(Layer.merge(layerSessionStore(), TestClock.layer()))), |
| 274 | ); |
| 275 | |
| 276 | it.effect("keys remote cookies by environment identity instead of state directory", () => |
| 277 | Effect.gen(function* () { |
| 278 | const cookieName = (stateDir: string, environmentId: EnvironmentId) => |
| 279 | Effect.gen(function* () { |
| 280 | const sessions = yield* SessionStore.SessionStore; |
| 281 | return sessions.cookieName; |
| 282 | }).pipe( |
| 283 | Effect.provide( |
| 284 | layerSessionStore({ mode: "web", host: "192.168.1.50", stateDir }, environmentId), |
| 285 | ), |
| 286 | ); |
| 287 | |
| 288 | const original = yield* cookieName("/srv/t3-one", EnvironmentId.make("environment-one")); |
| 289 | const moved = yield* cookieName("/srv/t3-moved", EnvironmentId.make("environment-one")); |
| 290 | const other = yield* cookieName("/srv/t3-one", EnvironmentId.make("environment-two")); |
| 291 | |
| 292 | expect(moved).toBe(original); |
| 293 | expect(other).not.toBe(original); |
| 294 | }), |
| 295 | ); |
| 296 | |
| 297 | it.effect("keeps reusable dev auth local across disk-backed stores and restarts", () => |
| 298 | Effect.gen(function* () { |
| 299 | const fs = yield* FileSystem.FileSystem; |
| 300 | const token = "reusable-dev-auth-token-that-is-long-enough"; |
| 301 | const baseA = yield* fs.makeTempDirectoryScoped({ prefix: "t3-dev-auth-a-" }); |
| 302 | const baseB = yield* fs.makeTempDirectoryScoped({ prefix: "t3-dev-auth-b-" }); |
| 303 | const layerA = yield* makeDiskSessionStoreLayer(baseA, token); |
| 304 | const fromA = yield* Effect.gen(function* () { |
| 305 | const sessions = yield* SessionStore.SessionStore; |
| 306 | const dev = yield* sessions.verify(token); |
| 307 | const local = yield* sessions.issue({ subject: "environment-a" }); |
| 308 | const ticket = yield* sessions.issueWebSocketToken(local.sessionId); |
| 309 | yield* sessions.revoke(dev.sessionId); |
| 310 | return { dev, local, ticket }; |
| 311 | }).pipe(Effect.provide(layerA), Effect.scoped); |
| 312 | |
| 313 | const layerB = yield* makeDiskSessionStoreLayer(baseB, token); |
| 314 | yield* Effect.gen(function* () { |
| 315 | const sessions = yield* SessionStore.SessionStore; |
| 316 | const dev = yield* sessions.verify(token); |
| 317 | expect(dev.sessionId).toBe(fromA.dev.sessionId); |
| 318 | expect((yield* Effect.flip(sessions.verify(fromA.local.token)))._tag).toBe( |
| 319 | "InvalidSessionTokenSignatureError", |
| 320 | ); |
| 321 | expect((yield* Effect.flip(sessions.verifyWebSocketToken(fromA.ticket.token)))._tag).toBe( |
| 322 | "InvalidWebSocketTokenSignatureError", |
| 323 | ); |
| 324 | }).pipe(Effect.provide(layerB), Effect.scoped); |
| 325 | |
| 326 | const layerReopenedB = yield* makeDiskSessionStoreLayer(baseB, token); |
| 327 | yield* Effect.gen(function* () { |
| 328 | const sessions = yield* SessionStore.SessionStore; |
| 329 | const dev = yield* sessions.verify(token); |
| 330 | expect(dev.sessionId).toBe(fromA.dev.sessionId); |
| 331 | const ticket = yield* sessions.issueWebSocketToken(dev.sessionId); |
| 332 | expect((yield* sessions.verifyWebSocketToken(ticket.token)).sessionId).toBe(dev.sessionId); |
| 333 | }).pipe(Effect.provide(layerReopenedB), Effect.scoped); |
| 334 | |
| 335 | const layerReopenedA = yield* makeDiskSessionStoreLayer(baseA, token); |
| 336 | yield* Effect.gen(function* () { |
| 337 | const sessions = yield* SessionStore.SessionStore; |
| 338 | expect((yield* Effect.flip(sessions.verify(token)))._tag).toBe("SessionTokenRevokedError"); |
| 339 | }).pipe(Effect.provide(layerReopenedA), Effect.scoped); |
| 340 | }), |
| 341 | ); |
| 342 | |
| 343 | it.effect("invalidates old dev credentials and tickets after rotation or removal", () => |
| 344 | Effect.gen(function* () { |
| 345 | const fs = yield* FileSystem.FileSystem; |
| 346 | const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-dev-auth-rotation-" }); |
| 347 | const oldToken = "old-reusable-dev-auth-token-that-is-long-enough"; |
| 348 | const newToken = "new-reusable-dev-auth-token-that-is-long-enough"; |
| 349 | const layerInitial = yield* makeDiskSessionStoreLayer(baseDir, oldToken); |
| 350 | const old = yield* Effect.gen(function* () { |
| 351 | const sessions = yield* SessionStore.SessionStore; |
| 352 | const dev = yield* sessions.verify(oldToken); |
| 353 | const ticket = yield* sessions.issueWebSocketToken(dev.sessionId); |
| 354 | return { dev, ticket }; |
| 355 | }).pipe(Effect.provide(layerInitial), Effect.scoped); |
| 356 | |
| 357 | const layerRotated = yield* makeDiskSessionStoreLayer(baseDir, newToken); |
| 358 | const rotated = yield* Effect.gen(function* () { |
| 359 | const sessions = yield* SessionStore.SessionStore; |
| 360 | expect((yield* Effect.flip(sessions.verify(oldToken)))._tag).toBe( |
| 361 | "MalformedSessionTokenError", |
| 362 | ); |
| 363 | expect((yield* Effect.flip(sessions.verifyWebSocketToken(old.ticket.token)))._tag).toBe( |
| 364 | "UnknownWebSocketSessionError", |
| 365 | ); |
| 366 | expect( |
| 367 | (yield* sessions.listActive()).some((row) => row.sessionId === old.dev.sessionId), |
| 368 | ).toBe(true); |
| 369 | const dev = yield* sessions.verify(newToken); |
| 370 | const ticket = yield* sessions.issueWebSocketToken(dev.sessionId); |
| 371 | return { dev, ticket }; |
| 372 | }).pipe(Effect.provide(layerRotated), Effect.scoped); |
| 373 | |
| 374 | const layerRemoved = yield* makeDiskSessionStoreLayer(baseDir); |
| 375 | yield* Effect.gen(function* () { |
| 376 | const sessions = yield* SessionStore.SessionStore; |
| 377 | expect((yield* Effect.flip(sessions.verify(newToken)))._tag).toBe( |
| 378 | "MalformedSessionTokenError", |
| 379 | ); |
| 380 | expect((yield* Effect.flip(sessions.verifyWebSocketToken(rotated.ticket.token)))._tag).toBe( |
| 381 | "UnknownWebSocketSessionError", |
| 382 | ); |
| 383 | expect( |
| 384 | (yield* sessions.listActive()).some((row) => row.sessionId === rotated.dev.sessionId), |
| 385 | ).toBe(true); |
| 386 | }).pipe(Effect.provide(layerRemoved), Effect.scoped); |
| 387 | }), |
| 388 | ); |
| 389 | |
| 390 | it.effect("carries a runtime-mode ceiling only on sessions issued with one", () => |
| 391 | Effect.gen(function* () { |
| 392 | const sessions = yield* SessionStore.SessionStore; |
| 393 | const capped = yield* sessions.issue({ |
| 394 | subject: "mcp-client", |
| 395 | method: "bearer-access-token", |
| 396 | runtimeModeCeiling: "auto", |
| 397 | }); |
| 398 | const uncapped = yield* sessions.issue({ method: "bearer-access-token" }); |
| 399 | |
| 400 | expect((yield* sessions.verify(capped.token)).runtimeModeCeiling).toBe("auto"); |
| 401 | expect((yield* sessions.verify(uncapped.token)).runtimeModeCeiling).toBeUndefined(); |
| 402 | }).pipe(Effect.provide(layerSessionStore())), |
| 403 | ); |
| 404 | it.effect("takes scopes from the session record", () => |
| 405 | Effect.gen(function* () { |
| 406 | const sessions = yield* SessionStore.SessionStore; |
| 407 | const secrets = yield* ServerSecretStore.ServerSecretStore; |
| 408 | const legacyScopes = ["orchestration:read", "terminal:operate", "review:write"] as const; |
| 409 | const issued = yield* sessions.issue({ subject: "one-time-token", scopes: legacyScopes }); |
| 410 | const [encodedPayload] = issued.token.split("."); |
| 411 | const currentClaims = base64UrlDecodeUtf8(encodedPayload!); |
| 412 | expect(currentClaims).toContain('"v":1'); |
| 413 | const signer = yield* PayloadSigner.fromSecret( |
| 414 | yield* secrets.getOrCreateRandom("server-signing-key", 32), |
| 415 | ); |
| 416 | const resign = (claims: string) => { |
| 417 | const payload = base64UrlEncode(claims); |
| 418 | return signer.sign(payload).pipe(Effect.map((signature) => `${payload}.${signature}`)); |
| 419 | }; |
| 420 | const legacyToken = yield* resign(currentClaims.replace('"v":1', '"v":2')); |
| 421 | const editedToken = yield* resign( |
| 422 | currentClaims.replace(/"scopes":\[[^\]]*\]/, '"scopes":["access:write"]'), |
| 423 | ); |
| 424 | |
| 425 | expect((yield* sessions.verify(issued.token)).scopes).toEqual(legacyScopes); |
| 426 | expect((yield* sessions.verify(legacyToken)).scopes).toEqual(legacyScopes); |
| 427 | expect((yield* sessions.verify(editedToken)).scopes).toEqual(legacyScopes); |
| 428 | }).pipe( |
| 429 | Effect.provide( |
| 430 | SessionStore.layer.pipe( |
| 431 | Layer.provideMerge(ServerSecretStore.layer), |
| 432 | Layer.provide(SqlitePersistence.layerMemory), |
| 433 | Layer.provide(layerServerEnvironment(EnvironmentId.make("test-environment"))), |
| 434 | Layer.provide(layerServerConfig()), |
| 435 | ), |
| 436 | ), |
| 437 | ), |
| 438 | ); |
| 439 | |
| 440 | it.effect("atomically replaces active sessions with the same subject and method", () => |
| 441 | Effect.gen(function* () { |
| 442 | const sessions = yield* SessionStore.SessionStore; |
| 443 | const browser = yield* sessions.issue({ |
| 444 | subject: "desktop-bootstrap", |
| 445 | method: "browser-session-cookie", |
| 446 | }); |
| 447 | const [firstBearer, secondBearer] = yield* Effect.all( |
| 448 | [ |
| 449 | sessions.issue({ |
| 450 | subject: "desktop-bootstrap", |
| 451 | method: "bearer-access-token", |
| 452 | replaceActiveForSubjectAndMethod: true, |
| 453 | }), |
| 454 | sessions.issue({ |
| 455 | subject: "desktop-bootstrap", |
| 456 | method: "bearer-access-token", |
| 457 | replaceActiveForSubjectAndMethod: true, |
| 458 | }), |
| 459 | ], |
| 460 | { concurrency: "unbounded" }, |
| 461 | ); |
| 462 | |
| 463 | const active = yield* sessions.listActive(); |
| 464 | const bearerVerification = yield* Effect.all([ |
| 465 | sessions.verify(firstBearer.token).pipe(Effect.option), |
| 466 | sessions.verify(secondBearer.token).pipe(Effect.option), |
| 467 | ]); |
| 468 | |
| 469 | expect(active).toHaveLength(2); |
| 470 | expect(active.find((entry) => entry.sessionId === browser.sessionId)).toBeDefined(); |
| 471 | expect( |
| 472 | active.filter( |
| 473 | (entry) => |
| 474 | entry.subject === "desktop-bootstrap" && entry.method === "bearer-access-token", |
| 475 | ), |
| 476 | ).toHaveLength(1); |
| 477 | expect(bearerVerification.filter(Option.isSome)).toHaveLength(1); |
| 478 | }).pipe(Effect.provide(layerSessionStore())), |
| 479 | ); |
| 480 | |
| 481 | it.effect("keeps the previous desktop session valid when replacement fails", () => |
| 482 | Effect.gen(function* () { |
| 483 | const sessions = yield* SessionStore.SessionStore; |
| 484 | const sql = yield* SqlClient.SqlClient; |
| 485 | const previous = yield* sessions.issue({ |
| 486 | subject: "desktop-bootstrap", |
| 487 | method: "bearer-access-token", |
| 488 | }); |
| 489 | yield* sql` |
| 490 | CREATE TRIGGER reject_auth_session_insert BEFORE INSERT ON auth_sessions |
| 491 | BEGIN |
| 492 | SELECT RAISE(ABORT, 'simulated insert failure'); |
| 493 | END |
| 494 | `; |
| 495 | |
| 496 | const error = yield* sessions |
| 497 | .issue({ |
| 498 | subject: "desktop-bootstrap", |
| 499 | method: "bearer-access-token", |
| 500 | replaceActiveForSubjectAndMethod: true, |
| 501 | }) |
| 502 | .pipe(Effect.flip); |
| 503 | |
| 504 | expect(error._tag).toBe("SessionCredentialIssueError"); |
| 505 | expect((yield* sessions.verify(previous.token)).sessionId).toBe(previous.sessionId); |
| 506 | expect((yield* sessions.listActive()).map((session) => session.sessionId)).toEqual([ |
| 507 | previous.sessionId, |
| 508 | ]); |
| 509 | }).pipe(Effect.provide(Layer.mergeAll(layerSessionStore(), SqlitePersistence.layerMemory))), |
| 510 | ); |
| 511 | |
| 512 | it.effect.each(["insert", "revoke"] as const)( |
| 513 | "keeps existing browser sessions valid when replacement cannot %s", |
| 514 | (operation) => |
| 515 | Effect.gen(function* () { |
| 516 | const sessions = yield* SessionStore.SessionStore; |
| 517 | const sql = yield* SqlClient.SqlClient; |
| 518 | const previous = yield* sessions.issue({ subject: "one-time-token" }); |
| 519 | const unrelated = yield* sessions.issue({ subject: "one-time-token" }); |
| 520 | if (operation === "insert") { |
| 521 | yield* sql` |
| 522 | CREATE TRIGGER reject_auth_session_insert BEFORE INSERT ON auth_sessions |
| 523 | BEGIN |
| 524 | SELECT RAISE(ABORT, 'simulated insert failure'); |
| 525 | END |
| 526 | `; |
| 527 | } else { |
| 528 | yield* sql` |
| 529 | CREATE TRIGGER reject_auth_session_revocation BEFORE UPDATE OF revoked_at ON auth_sessions |
| 530 | BEGIN |
| 531 | SELECT RAISE(ABORT, 'simulated revocation failure'); |
| 532 | END |
| 533 | `; |
| 534 | } |
| 535 | |
| 536 | const error = yield* sessions |
| 537 | .issue({ |
| 538 | subject: "replacement-pairing", |
| 539 | scopes: ["orchestration:read"], |
| 540 | replaceSessionId: previous.sessionId, |
| 541 | }) |
| 542 | .pipe(Effect.flip); |
| 543 | |
| 544 | expect(error._tag).toBe("SessionCredentialIssueError"); |
| 545 | expect((yield* sessions.verify(previous.token)).sessionId).toBe(previous.sessionId); |
| 546 | expect((yield* sessions.verify(unrelated.token)).sessionId).toBe(unrelated.sessionId); |
| 547 | expect((yield* sessions.listActive()).map((session) => session.sessionId).sort()).toEqual( |
| 548 | [previous.sessionId, unrelated.sessionId].sort(), |
| 549 | ); |
| 550 | }).pipe(Effect.provide(Layer.mergeAll(layerSessionStore(), SqlitePersistence.layerMemory))), |
| 551 | ); |
| 552 | |
| 553 | it.effect("rejects websocket tokens once the parent session has expired", () => |
| 554 | Effect.gen(function* () { |
| 555 | const sessions = yield* SessionStore.SessionStore; |
| 556 | const issued = yield* sessions.issue({ |
| 557 | method: "bearer-access-token", |
| 558 | subject: "short-lived", |
| 559 | ttl: Duration.seconds(1), |
| 560 | }); |
| 561 | const websocket = yield* sessions.issueWebSocketToken(issued.sessionId); |
| 562 | |
| 563 | yield* TestClock.adjust(Duration.seconds(2)); |
| 564 | |
| 565 | const error = yield* Effect.flip(sessions.verifyWebSocketToken(websocket.token)); |
| 566 | expect(error._tag).toBe("WebSocketSessionExpiredError"); |
| 567 | if (error._tag === "WebSocketSessionExpiredError") { |
| 568 | expect(error.sessionId).toBe(issued.sessionId); |
| 569 | expect(error.expiresAt.epochMilliseconds).toBe(issued.expiresAt.epochMilliseconds); |
| 570 | expect(error.observedAt.epochMilliseconds).toBeGreaterThan( |
| 571 | error.expiresAt.epochMilliseconds, |
| 572 | ); |
| 573 | } |
| 574 | }).pipe(Effect.provide(Layer.merge(layerSessionStore(), TestClock.layer()))), |
| 575 | ); |
| 576 | |
| 577 | it.effect("extends a session once per step and refuses one that has ended", () => |
| 578 | Effect.gen(function* () { |
| 579 | const sessions = yield* SessionStore.SessionStore; |
| 580 | const step = Duration.days(1); |
| 581 | const issued = yield* sessions.issue({ subject: "owner" }); |
| 582 | const idle = yield* sessions.issue({ subject: "owner" }); |
| 583 | const millis = (expiresAt: Option.Option<DateTime.Utc>) => |
| 584 | Option.getOrNull(Option.map(expiresAt, (value) => value.epochMilliseconds)); |
| 585 | const stored = sessions |
| 586 | .listActive() |
| 587 | .pipe( |
| 588 | Effect.map( |
| 589 | (active) => |
| 590 | active.find((entry) => entry.sessionId === issued.sessionId)?.expiresAt |
| 591 | .epochMilliseconds, |
| 592 | ), |
| 593 | ); |
| 594 | |
| 595 | // Less than a step short: the row keeps its expiry. |
| 596 | const near = DateTime.toUtc(DateTime.add(issued.expiresAt, { hours: 12 })); |
| 597 | expect(millis(yield* sessions.extend(issued.sessionId, near, step))).toBe( |
| 598 | issued.expiresAt.epochMilliseconds, |
| 599 | ); |
| 600 | expect(yield* stored).toBe(issued.expiresAt.epochMilliseconds); |
| 601 | |
| 602 | const renewed = DateTime.toUtc(DateTime.add(issued.expiresAt, { days: 20 })); |
| 603 | expect(millis(yield* sessions.extend(issued.sessionId, renewed, step))).toBe( |
| 604 | renewed.epochMilliseconds, |
| 605 | ); |
| 606 | // A second use that read the old expiry finds the row renewed and takes its deadline. |
| 607 | const overlapping = DateTime.add(renewed, { minutes: 1 }); |
| 608 | expect(millis(yield* sessions.extend(issued.sessionId, overlapping, step))).toBe( |
| 609 | renewed.epochMilliseconds, |
| 610 | ); |
| 611 | expect(yield* stored).toBe(renewed.epochMilliseconds); |
| 612 | |
| 613 | yield* sessions.revoke(issued.sessionId); |
| 614 | expect(millis(yield* sessions.extend(issued.sessionId, overlapping, step))).toBeNull(); |
| 615 | |
| 616 | yield* TestClock.setTime(idle.expiresAt.epochMilliseconds); |
| 617 | const afterExpiry = DateTime.toUtc(DateTime.add(idle.expiresAt, { days: 30 })); |
| 618 | expect(millis(yield* sessions.extend(idle.sessionId, afterExpiry, step))).toBeNull(); |
| 619 | }).pipe(Effect.provide(Layer.merge(layerSessionStore(), TestClock.layer()))), |
| 620 | ); |
| 621 | |
| 622 | it.effect("lists active sessions, tracks connectivity, and revokes other sessions", () => |
| 623 | Effect.gen(function* () { |
| 624 | const sessions = yield* SessionStore.SessionStore; |
| 625 | const administrative = yield* sessions.issue({ |
| 626 | subject: "desktop-bootstrap", |
| 627 | scopes: ["orchestration:read", "access:write"], |
| 628 | client: { |
| 629 | label: "Desktop app", |
| 630 | deviceType: "desktop", |
| 631 | os: "macOS", |
| 632 | browser: "Electron", |
| 633 | }, |
| 634 | }); |
| 635 | const client = yield* sessions.issue({ |
| 636 | subject: "one-time-token", |
| 637 | scopes: ["orchestration:read"], |
| 638 | client: { |
| 639 | label: "Julius iPhone", |
| 640 | deviceType: "mobile", |
| 641 | os: "iOS", |
| 642 | browser: "Safari", |
| 643 | ipAddress: "192.168.1.88", |
| 644 | }, |
| 645 | }); |
| 646 | const clientWebSocket = yield* sessions.issueWebSocketToken(client.sessionId); |
| 647 | |
| 648 | yield* sessions.markConnected(client.sessionId); |
| 649 | const beforeRevoke = yield* sessions.listActive(); |
| 650 | const revokedCount = yield* sessions.revokeAllExcept(administrative.sessionId); |
| 651 | const afterRevoke = yield* sessions.listActive(); |
| 652 | const revokedClient = yield* Effect.flip(sessions.verify(client.token)); |
| 653 | const revokedClientWebSocket = yield* Effect.flip( |
| 654 | sessions.verifyWebSocketToken(clientWebSocket.token), |
| 655 | ); |
| 656 | |
| 657 | expect(beforeRevoke).toHaveLength(2); |
| 658 | expect(beforeRevoke.find((entry) => entry.sessionId === client.sessionId)?.connected).toBe( |
| 659 | true, |
| 660 | ); |
| 661 | expect(beforeRevoke.find((entry) => entry.sessionId === client.sessionId)?.client.label).toBe( |
| 662 | "Julius iPhone", |
| 663 | ); |
| 664 | expect( |
| 665 | beforeRevoke.find((entry) => entry.sessionId === administrative.sessionId)?.client |
| 666 | .deviceType, |
| 667 | ).toBe("desktop"); |
| 668 | expect(revokedCount).toBe(1); |
| 669 | expect(afterRevoke).toHaveLength(1); |
| 670 | expect(afterRevoke[0]?.sessionId).toBe(administrative.sessionId); |
| 671 | expect(revokedClient._tag).toBe("SessionTokenRevokedError"); |
| 672 | if (revokedClient._tag === "SessionTokenRevokedError") { |
| 673 | expect(revokedClient.sessionId).toBe(client.sessionId); |
| 674 | expect(revokedClient.revokedAt.epochMilliseconds).toBeGreaterThanOrEqual(0); |
| 675 | } |
| 676 | expect(revokedClientWebSocket._tag).toBe("WebSocketSessionRevokedError"); |
| 677 | if (revokedClientWebSocket._tag === "WebSocketSessionRevokedError") { |
| 678 | expect(revokedClientWebSocket.sessionId).toBe(client.sessionId); |
| 679 | expect(revokedClientWebSocket.revokedAt.epochMilliseconds).toBeGreaterThanOrEqual(0); |
| 680 | } |
| 681 | }).pipe(Effect.provide(layerSessionStore())), |
| 682 | ); |
| 683 | }); |