@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 211 lines 9.08 KB
Raw
1 import { SqliteClient } from "@effect/sql-sqlite-node"
2 import { assert, describe, it } from "@effect/vitest"
3 import { Effect, Layer, Redacted } from "effect"
4 import * as RegressionTest from "effect-test/eventlog/EventLogServerUnencryptedRegressionTest"
5 import * as SqlEventLogServerUnencryptedStorageTest from "effect-test/eventlog/SqlEventLogServerUnencryptedStorageTest"
6 import * as EventJournal from "effect/eventlog/EventJournal"
7 import * as EventLog from "effect/eventlog/EventLog"
8 import * as EventLogEncryption from "effect/eventlog/EventLogEncryption"
9 import * as EventLogMessage from "effect/eventlog/EventLogMessage"
10 import * as EventLogServerUnencrypted from "effect/eventlog/EventLogServerUnencrypted"
11 import * as EventLogSessionAuth from "effect/eventlog/EventLogSessionAuth"
12 import { makeGetIdentityRootSecretMaterial } from "effect/eventlog/internal/identityRootSecretDerivation"
13 import * as SqlEventLogServerUnencrypted from "effect/eventlog/SqlEventLogServerUnencrypted"
14 import { Reactivity } from "effect/reactivity"
15 import * as RpcTest from "effect/rpc/RpcTest"
16 import * as SqlClient from "effect/sql/SqlClient"
17 import * as Statement from "effect/sql/Statement"
18
19 SqlEventLogServerUnencryptedStorageTest.suite(
20 "sql-sqlite-node",
21 SqliteClient.layer({
22 filename: ":memory:"
23 })
24 )
25
26 RegressionTest.suite(
27 "SQLite",
28 SqlEventLogServerUnencrypted.layerStorage().pipe(
29 Layer.provide(SqliteClient.layer({ filename: ":memory:" })),
30 Layer.provide(Reactivity.layer)
31 )
32 )
33
34 const getIdentityRootSecretMaterial = makeGetIdentityRootSecretMaterial(globalThis.crypto)
35 const storeId = EventLogMessage.StoreId.make("store-a")
36
37 const makeEntry = (value: number) =>
38 new EventJournal.Entry({
39 id: EventJournal.makeEntryIdUnsafe(),
40 event: "UserCreated",
41 primaryKey: `user-${value}`,
42 payload: new Uint8Array([value])
43 }, { disableChecks: true })
44
45 const makeAuthenticateRequest = Effect.fnUntraced(function*(options: {
46 readonly identity: EventLog.Identity["Service"]
47 readonly challenge: Uint8Array
48 readonly remoteId: EventJournal.RemoteId
49 }) {
50 const rootSecretMaterial = yield* getIdentityRootSecretMaterial(options.identity)
51 const signature = yield* EventLogSessionAuth.signSessionAuthPayload({
52 remoteId: options.remoteId,
53 challenge: options.challenge,
54 publicKey: options.identity.publicKey,
55 signingPublicKey: rootSecretMaterial.signingPublicKey,
56 signingPrivateKey: Redacted.value(rootSecretMaterial.signingPrivateKey)
57 })
58 return new EventLogMessage.Authenticate({
59 publicKey: options.identity.publicKey,
60 signingPublicKey: rootSecretMaterial.signingPublicKey,
61 signature,
62 algorithm: "Ed25519"
63 })
64 })
65
66 describe("SqlEventLogServerUnencrypted (sql-sqlite-node)", () => {
67 it.effect("forbids writing entries for another identity", () =>
68 Effect.gen(function*() {
69 const sql = yield* SqliteClient.make({ filename: ":memory:" })
70 const storage = yield* SqlEventLogServerUnencrypted.makeStorage().pipe(
71 Effect.provideService(SqlClient.SqlClient, sql),
72 Effect.orDie
73 )
74 const rpcClient = yield* RpcTest.makeClient(EventLogMessage.EventLogRemoteRpcs).pipe(
75 Effect.provide(
76 EventLogServerUnencrypted.layerRpcHandlers.pipe(
77 Layer.provideMerge(EventLog.layerRegistry),
78 Layer.provide(Layer.succeed(EventLogServerUnencrypted.Storage, storage)),
79 Layer.provide(Layer.succeed(EventLogServerUnencrypted.StoreMapping, {
80 resolve: ({ storeId }) => Effect.succeed(storeId),
81 hasStore: () => Effect.succeed(true)
82 })),
83 Layer.provide(Layer.succeed(EventLogServerUnencrypted.EventLogServerAuthorization, {
84 authorizeWrite: () => Effect.void,
85 authorizeRead: () => Effect.void,
86 authorizeIdentity: () => Effect.void
87 }))
88 )
89 )
90 )
91 const identityA = yield* EventLog.makeIdentity
92 const identityB = yield* EventLog.makeIdentity
93 const hello = yield* rpcClient["EventLog.Hello"]()
94 yield* rpcClient["EventLog.Authenticate"](
95 yield* makeAuthenticateRequest({
96 identity: identityA,
97 challenge: hello.challenge,
98 remoteId: hello.remoteId
99 })
100 )
101 const data = yield* new EventLogMessage.WriteEntriesUnencrypted({
102 publicKey: identityB.publicKey,
103 storeId,
104 entries: [makeEntry(1)]
105 }).encoded
106
107 const error = yield* rpcClient["EventLog.WriteSingle"]({ data }).pipe(Effect.flip)
108
109 assert.instanceOf(error, EventLogMessage.EventLogProtocolError)
110 assert.strictEqual(error.code, "Forbidden")
111 const written = yield* storage.write(storeId, [makeEntry(2)])
112 assert.deepStrictEqual(written.map((entry) => entry.remoteSequence), [1])
113 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle])))
114
115 it.effect("rejects session-auth rebinding for an existing publicKey", () =>
116 Effect.gen(function*() {
117 const sql = yield* SqliteClient.make({ filename: ":memory:" })
118 const storage = yield* SqlEventLogServerUnencrypted.makeStorage().pipe(
119 Effect.provideService(SqlClient.SqlClient, sql),
120 Effect.orDie
121 )
122
123 const rpcClient = yield* RpcTest.makeClient(EventLogMessage.EventLogRemoteRpcs).pipe(
124 Effect.provide(
125 EventLogServerUnencrypted.layerRpcHandlers.pipe(
126 Layer.provideMerge(EventLog.layerRegistry),
127 Layer.provide(Layer.succeed(EventLogServerUnencrypted.Storage, storage)),
128 Layer.provide(Layer.succeed(EventLogServerUnencrypted.StoreMapping, {
129 resolve: ({ storeId }) => Effect.succeed(storeId),
130 hasStore: () => Effect.succeed(true)
131 })),
132 Layer.provide(Layer.succeed(EventLogServerUnencrypted.EventLogServerAuthorization, {
133 authorizeWrite: () => Effect.void,
134 authorizeRead: () => Effect.void,
135 authorizeIdentity: () => Effect.void
136 }))
137 )
138 )
139 )
140
141 const firstIdentity = yield* EventLog.makeIdentity
142 const secondIdentitySeed = yield* EventLog.makeIdentity
143 const secondIdentity: EventLog.Identity["Service"] = {
144 publicKey: firstIdentity.publicKey,
145 privateKey: secondIdentitySeed.privateKey
146 }
147
148 const firstMaterial = yield* getIdentityRootSecretMaterial(firstIdentity)
149 const secondMaterial = yield* getIdentityRootSecretMaterial(secondIdentity)
150 const sameSigningPublicKey =
151 firstMaterial.signingPublicKey.byteLength === secondMaterial.signingPublicKey.byteLength &&
152 firstMaterial.signingPublicKey.every((byte, index) => byte === secondMaterial.signingPublicKey[index])
153 assert.strictEqual(sameSigningPublicKey, false)
154
155 const firstHello = yield* rpcClient["EventLog.Hello"]()
156 yield* rpcClient["EventLog.Authenticate"](
157 yield* makeAuthenticateRequest({
158 identity: firstIdentity,
159 challenge: firstHello.challenge,
160 remoteId: firstHello.remoteId
161 })
162 )
163
164 const secondHello = yield* rpcClient["EventLog.Hello"]()
165 const error = yield* rpcClient["EventLog.Authenticate"](
166 yield* makeAuthenticateRequest({
167 identity: secondIdentity,
168 challenge: secondHello.challenge,
169 remoteId: secondHello.remoteId
170 })
171 ).pipe(Effect.flip)
172
173 assert.instanceOf(error, EventLogMessage.EventLogProtocolError)
174 assert.strictEqual(error.code, "Forbidden")
175 assert.strictEqual(error.message, "Session auth signature verification failed")
176 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle])))
177
178 it.effect("reads batch history through id and primary key lookups", () => {
179 const statements: Array<readonly [string, ReadonlyArray<unknown>]> = []
180 return Effect.gen(function*() {
181 const sql = yield* SqlClient.SqlClient
182 const { write } = yield* RegressionTest.makeClient("plan")
183 yield* write([yield* RegressionTest.makeEntry(2_000, "a"), yield* RegressionTest.makeEntry(3_000, "b")])
184 statements.length = 0
185 yield* write([yield* RegressionTest.makeEntry(1_000, "a")])
186
187 const reads = statements.filter(([text]) => /^\s*SELECT\b/i.test(text) && text.includes(`"effect_events"`))
188 assert.isNotEmpty(reads)
189 for (const [text, params] of reads) {
190 const plan = yield* sql.unsafe<{ readonly detail: string }>(`EXPLAIN QUERY PLAN ${text}`, params)
191 for (const { detail } of plan.filter(({ detail }) => detail.includes("effect_events"))) {
192 // A range on entry_id alone reads every entry after the batch.
193 assert.match(detail, /^SEARCH effect_events USING (COVERING )?INDEX \S+ \(.*\b(entry_id|primary_key)=\?/)
194 }
195 }
196 }).pipe(
197 Effect.provide(
198 SqlEventLogServerUnencrypted.layerStorage().pipe(
199 Layer.provideMerge(SqliteClient.layer({ filename: ":memory:" })),
200 Layer.provide(Reactivity.layer)
201 )
202 ),
203 Effect.provide(EventLogEncryption.layerSubtle),
204 Effect.provideService(Statement.CurrentTransformer, (statement) =>
205 Effect.sync(() => {
206 statements.push(statement.compile())
207 return statement
208 }))
209 )
210 })
211 })