@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 286 lines 10.7 KB
Raw
1 import type { ReplacedResourceState, ResourceState } from "alchemy/State/ResourceState";
2 import { encodeState } from "alchemy/State/StateEncoding";
3 import * as Effect from "effect/Effect";
4 import { pipe } from "effect/Function";
5 import * as Redacted from "effect/Redacted";
6 import * as Schedule from "effect/Schedule";
7 import * as Secret from "../SecretsStore/index.ts";
8 import { DurableObject } from "../Workers/DurableObject.ts";
9 import { DurableObjectState } from "../Workers/DurableObjectState.ts";
10 import { EncryptionKey } from "./Token.ts";
11
12 /**
13 * Secrets Store reads from a Worker or Durable Object fail transiently
14 * ("Secrets Worker: Failed to fetch secret"); retry briefly before failing
15 * the request.
16 */
17 export const retrySecretRead = <A, E, R>(read: Effect.Effect<A, E, R>) =>
18 read.pipe(
19 Effect.retry({
20 schedule: Schedule.max([Schedule.exponential("100 millis"), Schedule.recurs(3)]),
21 }),
22 );
23
24 export default class Store extends DurableObject<Store>()(
25 "Store",
26 Effect.gen(function* () {
27 // Outer (class-level) phase — resolve the binding factory once.
28 // The actual secret read happens inside each DO instance below,
29 // since `SecretClient.get()` needs the per-instance worker env.
30 const encryptionSecret = yield* Secret.ReadSecret(EncryptionKey);
31 const state = yield* DurableObjectState;
32 const storage = state.storage;
33
34 return Effect.gen(function* () {
35 const keyHex = yield* encryptionSecret
36 .get()
37 .pipe(retrySecretRead, Effect.map(Redacted.value));
38 const cryptoKey = yield* Effect.tryPromise(() =>
39 crypto.subtle.importKey("raw", Buffer.from(keyHex, "hex"), { name: "AES-CTR" }, false, [
40 "encrypt",
41 "decrypt",
42 ]),
43 );
44
45 const encryptValue = (value: unknown) =>
46 Effect.tryPromise(async () => {
47 const plaintext = new TextEncoder().encode(JSON.stringify(encodeState(value)));
48 const counter = crypto.getRandomValues(allocBytes(NONCE_BYTES));
49 const ct = new Uint8Array(
50 await crypto.subtle.encrypt(
51 { name: "AES-CTR", counter, length: 64 },
52 cryptoKey,
53 plaintext,
54 ),
55 );
56 // Frame as a single base64 string: nonce || ciphertext.
57 return Buffer.concat([counter, ct]).toString("base64");
58 }).pipe(Effect.orDie);
59
60 const decryptEntry = (entry: string) =>
61 Effect.tryPromise(async () => {
62 const framed = Buffer.from(entry, "base64");
63 const counter = framed.subarray(0, NONCE_BYTES);
64 const ciphertext = framed.subarray(NONCE_BYTES);
65 let pt;
66 try {
67 pt = await crypto.subtle.decrypt(
68 { name: "AES-CTR", counter, length: 64 },
69 cryptoKey,
70 ciphertext,
71 );
72 } catch (error) {
73 // We return undefined here because in 2.0.0-beta.45, we rotated encryption keys unnecessarily.
74 // So, we catch a decryption error here and return undefined instead.
75 // The engine should reconcile, hopefully, but users may lose some data
76 console.error("Error decrypting entry. Returning undefined instead.", error);
77 return undefined;
78 }
79 return JSON.parse(new TextDecoder().decode(pt)) as ResourceState;
80 }).pipe(Effect.orDie);
81
82 return {
83 // -- Root DO methods -----------------------------------------
84
85 /**
86 * (Root DO only) List every stack name ever registered.
87 */
88 listStacks: Effect.fn(function* () {
89 const entries = yield* storage.list<number>({
90 prefix: STACK_INDEX_PREFIX,
91 });
92 const stacks: string[] = [];
93 for (const key of entries.keys()) {
94 stacks.push(key.slice(STACK_INDEX_PREFIX.length));
95 }
96 return stacks;
97 }),
98
99 /**
100 * (Root DO only) Register a stack name. Idempotent — safe to
101 * call on every `set` to the corresponding stack DO.
102 */
103 registerStack: ({ stack }: { stack: string }) =>
104 storage.put(`${STACK_INDEX_PREFIX}${stack}`, 1),
105
106 /**
107 * (Root DO only) Remove a stack name from the global index.
108 */
109 unregisterStack: ({ stack }: { stack: string }) =>
110 storage.delete(`${STACK_INDEX_PREFIX}${stack}`),
111
112 // -- Stack DO methods ----------------------------------------
113
114 /** (Stack DO only) List stages with at least one resource. */
115 listStages: () =>
116 storage
117 .list<string>({
118 prefix: RESOURCE_PREFIX,
119 })
120 .pipe(
121 Effect.map((entries) => {
122 const stages = new Set<string>();
123 for (const key of entries.keys()) {
124 const parsed = parseResourceKey(key);
125 if (parsed) stages.add(parsed.stage);
126 }
127 return [...stages];
128 }),
129 ),
130
131 /** (Stack DO only) List every resource FQN in a stage. */
132 listResources: ({ stage }: { stage: string }) =>
133 storage
134 .list<string>({
135 prefix: stagePrefix(stage),
136 })
137 .pipe(
138 Effect.map((entries) => {
139 const fqns: string[] = [];
140 for (const key of entries.keys()) {
141 const parsed = parseResourceKey(key);
142 if (parsed) fqns.push(parsed.fqn);
143 }
144 return fqns;
145 }),
146 ),
147
148 /**
149 * (Stack DO only) Get a resource by (stage, fqn). Returns
150 * null if missing.
151 */
152 get: ({ stage, fqn }: { stage: string; fqn: string }) =>
153 storage
154 .get<string>(resourceKey(stage, fqn))
155 .pipe(
156 Effect.flatMap((entry) => (entry == null ? Effect.undefined : decryptEntry(entry))),
157 ),
158
159 /**
160 * (Stack DO only) Persist a resource. Returns the stored
161 * value unchanged.
162 */
163 set: ({ stage, fqn, value }: { stage: string; fqn: string; value: ResourceState }) =>
164 encryptValue(value).pipe(
165 Effect.flatMap((encrypted) =>
166 storage.put<string>(resourceKey(stage, fqn), encrypted).pipe(Effect.asVoid),
167 ),
168 Effect.map(() => value),
169 ),
170
171 /**
172 * (Stack DO only) Delete a resource. Idempotent.
173 *
174 * Exposed as `remove` (not `delete`) because Cloudflare's
175 * Durable Object RPC stub reserves `delete` and refuses to
176 * proxy the call, surfacing as "RPC receiver does not
177 * implement the method 'delete'".
178 */
179 remove: ({ stage, fqn }: { stage: string; fqn: string }) =>
180 storage.delete(resourceKey(stage, fqn)),
181
182 /**
183 * (Stack DO only) Delete every resource in this stack, or every
184 * resource in a single stage when specified.
185 */
186 deleteStack: ({ stage }: { stage?: string } = {}) =>
187 stage === undefined
188 ? storage.deleteAll()
189 : storage.list<string>({ prefix: stagePrefix(stage) }).pipe(
190 Effect.flatMap((entries) => {
191 const keys = [...entries.keys(), stackOutputKey(stage)];
192 return storage.delete(keys).pipe(Effect.asVoid);
193 }),
194 ),
195
196 /**
197 * (Stack DO only) Read the persisted stack output for `stage`.
198 * Returns `undefined` when the stage has not been deployed.
199 */
200 getOutput: ({ stage }: { stage: string }) =>
201 storage
202 .get<string>(stackOutputKey(stage))
203 .pipe(
204 Effect.flatMap((entry) => (entry == null ? Effect.undefined : decryptEntry(entry))),
205 ),
206
207 /**
208 * (Stack DO only) Persist the resolved stack output for
209 * `stage`. Returns the stored value unchanged.
210 */
211 setOutput: ({ stage, value }: { stage: string; value: any }) =>
212 encryptValue(value).pipe(
213 Effect.flatMap((encrypted) =>
214 storage.put<string>(stackOutputKey(stage), encrypted).pipe(Effect.asVoid),
215 ),
216 Effect.map(() => value),
217 ),
218
219 /**
220 * (Stack DO only) Return every resource in a stage whose
221 * `status === "replaced"`. Each entry is decrypted so the
222 * `status` field can be inspected.
223 */
224 getReplacedResources: ({ stage }: { stage: string }) =>
225 pipe(
226 storage.list<string>({ prefix: stagePrefix(stage) }),
227 Effect.map((entries) => [...entries.values()].filter((e): e is string => !!e)),
228 Effect.flatMap(Effect.forEach(decryptEntry, { concurrency: "unbounded" })),
229 Effect.map((decoded) =>
230 decoded.filter((d): d is ReplacedResourceState => d?.status === "replaced"),
231 ),
232 ),
233 };
234 }).pipe(Effect.orDie);
235 }).pipe(Effect.provide(Secret.ReadSecretBinding)),
236 ) {
237 /**
238 * Well-known DO name whose sole job is to track the set of stacks
239 * that have ever had resources written. `listStacks` queries it;
240 * every `set` asks it to register the stack (idempotent).
241 */
242 static readonly ROOT_DO_NAME = "__root__" as const;
243 }
244
245 /** NUL byte separator for composite keys. */
246 const SEP = "\x00";
247
248 /** Key prefix for resource entries in a stack DO. */
249 const RESOURCE_PREFIX = `r${SEP}`;
250
251 /** Key prefix for stack-output entries in a stack DO. */
252 const STACK_OUTPUT_PREFIX = `o${SEP}`;
253
254 /** Key prefix for stack-index entries in the root DO. */
255 const STACK_INDEX_PREFIX = "s:";
256
257 /** AES-CTR counter block length. */
258 const NONCE_BYTES = 16;
259
260 /** Build the resource key inside a *stack DO*. */
261 const resourceKey = (stage: string, fqn: string) => `${RESOURCE_PREFIX}${stage}${SEP}${fqn}`;
262
263 /** Prefix matching every resource key inside a specific stage. */
264 const stagePrefix = (stage: string) => `${RESOURCE_PREFIX}${stage}${SEP}`;
265
266 /** Build the stack-output key inside a *stack DO*. */
267 const stackOutputKey = (stage: string) => `${STACK_OUTPUT_PREFIX}${stage}`;
268
269 /**
270 * Parse a resource key back into its (stage, fqn) tuple. Returns
271 * undefined for keys that do not match the expected shape.
272 */
273 const parseResourceKey = (key: string): { stage: string; fqn: string } | undefined => {
274 if (!key.startsWith(RESOURCE_PREFIX)) return undefined;
275 const rest = key.slice(RESOURCE_PREFIX.length);
276 const sep = rest.indexOf(SEP);
277 if (sep < 0) return undefined;
278 return { stage: rest.slice(0, sep), fqn: rest.slice(sep + 1) };
279 };
280
281 /**
282 * Allocate a `Uint8Array` over a fresh `ArrayBuffer` (not shared) so
283 * the resulting buffer satisfies Web Crypto's `BufferSource` type
284 * constraint under strict DOM typings.
285 */
286 const allocBytes = (size: number): Uint8Array<ArrayBuffer> => new Uint8Array(new ArrayBuffer(size));