@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, 04:45 UTC

main
ts 92 lines 2.96 KB
Raw
1 import {
2 importRelayPrivateKey,
3 importRelayPublicKey,
4 RelayJwtError,
5 signRelayJwt,
6 verifyRelayJwt,
7 } from "@t3tools/shared/relayJwt";
8 import * as Context from "effect/Context";
9 import * as Signature from "effect/crypto/Signature";
10 import type * as Duration from "effect/Duration";
11 import * as Effect from "effect/Effect";
12 import * as Layer from "effect/Layer";
13 import * as Redacted from "effect/Redacted";
14 import type * as Schema from "effect/Schema";
15
16 import * as RelayConfiguration from "../Config.ts";
17
18 /** Signs and verifies relay-issued tokens with the cloud mint key pair. */
19 export class CloudMintSigner extends Context.Service<
20 CloudMintSigner,
21 {
22 readonly sign: (input: {
23 readonly typ: string;
24 readonly payload: Readonly<Record<string, unknown>>;
25 }) => Effect.Effect<string, RelayJwtError>;
26 readonly verify: <A>(
27 schema: Schema.ConstraintDecoder<A>,
28 input: {
29 readonly token: string;
30 readonly typ: string;
31 readonly issuer: string;
32 readonly audience: string;
33 readonly maxTokenAge?: Duration.Input;
34 },
35 ) => Effect.Effect<A, RelayJwtError>;
36 }
37 >()("t3code-relay/auth/CloudMintSigner") {}
38
39 // Parsed on first use and kept; a failed parse is retried so a bad key fails requests, not boot.
40 const cacheSuccess = <A, E>(load: Effect.Effect<A, E>) => {
41 let value: A | undefined;
42 return Effect.suspend(() =>
43 value !== undefined
44 ? Effect.succeed(value)
45 : Effect.tap(load, (loaded) =>
46 Effect.sync(() => {
47 value = loaded;
48 }),
49 ),
50 );
51 };
52
53 export const layer = Layer.effect(
54 CloudMintSigner,
55 Effect.gen(function* () {
56 const config = yield* RelayConfiguration.RelayConfiguration;
57 const signature = yield* Signature.Signature;
58 const privateKey = cacheSuccess(
59 importRelayPrivateKey(Redacted.value(config.cloudMintPrivateKey)),
60 );
61 const publicKey = cacheSuccess(importRelayPublicKey(config.cloudMintPublicKey));
62
63 return CloudMintSigner.of({
64 sign: Effect.fn("CloudMintSigner.sign")(function* (input) {
65 const key = yield* privateKey.pipe(
66 Effect.mapError(
67 (cause) => new RelayJwtError({ operation: "sign", typ: input.typ, cause }),
68 ),
69 );
70 return yield* signRelayJwt({ ...input, privateKey: key }).pipe(
71 Effect.provideService(Signature.Signature, signature),
72 );
73 }),
74 verify: Effect.fn("CloudMintSigner.verify")(function* (schema, input) {
75 return yield* publicKey.pipe(
76 Effect.mapError(
77 (cause) =>
78 new RelayJwtError({
79 operation: "verify",
80 typ: input.typ,
81 issuer: input.issuer,
82 audience: input.audience,
83 cause,
84 }),
85 ),
86 Effect.flatMap((key) => verifyRelayJwt(schema, { ...input, publicKey: key })),
87 Effect.provideService(Signature.Signature, signature),
88 );
89 }),
90 });
91 }),
92 );