@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 683 lines 29.4 KB
Raw
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 });