@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 204 lines 8.03 KB
Raw
1 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import { assert, describe, it } from "@effect/vitest";
4 import {
5 SecretProviderId,
6 SecretProviderKind,
7 type SecretReference,
8 type ServerSettings,
9 } from "@t3tools/contracts";
10 import * as Deferred from "effect/Deferred";
11 import * as Effect from "effect/Effect";
12 import * as Fiber from "effect/Fiber";
13 import * as Layer from "effect/Layer";
14 import * as Schema from "effect/Schema";
15
16 import { defineSecretProviderDriver } from "./driver.ts";
17 import * as SecretResolver from "./SecretResolver.ts";
18 import { defineSecretProvider } from "../shared/definition.ts";
19
20 const FAKE_KIND = SecretProviderKind.make("fake");
21 const FakeConfig = Schema.Struct({ account: Schema.String });
22
23 const personal = SecretProviderId.make("personal");
24 const work = SecretProviderId.make("work");
25 const fake = (account: string) => ({
26 kind: FAKE_KIND,
27 label: account,
28 config: { account },
29 });
30 const ref = (reference: string, provider = personal): SecretReference => ({ provider, reference });
31
32 function fakeDriver(
33 answer: (account: string, reference: string) => string | undefined,
34 wait: (references: ReadonlyArray<string>) => Effect.Effect<void> = () => Effect.void,
35 ) {
36 const reads: Array<{ readonly account: string; readonly references: ReadonlyArray<string> }> = [];
37 const driver = defineSecretProviderDriver({
38 kind: FAKE_KIND,
39 definition: defineSecretProvider({
40 kind: FAKE_KIND,
41 label: "Fake",
42 configSchema: FakeConfig,
43 isReference: (reference) => reference.startsWith("fake://"),
44 referencePlaceholder: "fake://item",
45 invalidReferenceMessage: "Use fake://item.",
46 }),
47 read: ({ account }, references) =>
48 wait(references).pipe(
49 Effect.andThen(
50 Effect.sync(() => {
51 reads.push({ account, references });
52 return references.map((reference) => answer(account, reference));
53 }),
54 ),
55 ),
56 });
57 return { driver, reads };
58 }
59
60 const resolverLayer = (
61 driver: ReturnType<typeof fakeDriver>["driver"],
62 secretProviders: () => ServerSettings["secretProviders"] = () => ({ [personal]: fake("a") }),
63 ) =>
64 SecretResolver.layer({
65 drivers: [driver],
66 secretProviders: Effect.sync(secretProviders),
67 }).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
68
69 describe("SecretResolver", () => {
70 it.effect("reads a reference once and holds it", () => {
71 const { driver, reads } = fakeDriver(() => "sk-live");
72 return Effect.gen(function* () {
73 const resolver = yield* SecretResolver.SecretResolver;
74 const token = ref("fake://openai");
75
76 assert.deepStrictEqual(yield* resolver.read([token]), ["sk-live"]);
77 assert.deepStrictEqual(yield* resolver.read([token]), ["sk-live"]);
78 assert.deepStrictEqual(reads, [{ account: "a", references: ["fake://openai"] }]);
79 }).pipe(Effect.provide(resolverLayer(driver)));
80 });
81
82 it.effect("holds a failed read until invalidated, then reads again", () => {
83 let locked = true;
84 const { driver, reads } = fakeDriver(() => (locked ? undefined : "sk-live"));
85 return Effect.gen(function* () {
86 const resolver = yield* SecretResolver.SecretResolver;
87 const token = ref("fake://openai");
88
89 assert.deepStrictEqual(yield* resolver.read([token]), [undefined]);
90 locked = false;
91 assert.deepStrictEqual(yield* resolver.read([token]), [undefined]);
92 assert.strictEqual(reads.length, 1);
93
94 yield* resolver.invalidate([token]);
95 assert.deepStrictEqual(yield* resolver.read([token]), ["sk-live"]);
96 assert.strictEqual(reads.length, 2);
97 }).pipe(Effect.provide(resolverLayer(driver)));
98 });
99
100 it.effect("answers a cached reference while another reference waits on its provider", () =>
101 Effect.gen(function* () {
102 const started = yield* Deferred.make<void>();
103 const unlock = yield* Deferred.make<void>();
104 const { driver } = fakeDriver(
105 () => "sk-live",
106 (references) =>
107 references.includes("fake://slow")
108 ? Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(unlock)))
109 : Effect.void,
110 );
111 yield* Effect.gen(function* () {
112 const resolver = yield* SecretResolver.SecretResolver;
113 yield* resolver.read([ref("fake://cached")]);
114 const slow = yield* Effect.forkChild(resolver.read([ref("fake://slow")]));
115 yield* Deferred.await(started);
116
117 assert.deepStrictEqual(yield* resolver.read([ref("fake://cached")]), ["sk-live"]);
118 yield* Deferred.succeed(unlock, undefined);
119 assert.deepStrictEqual(yield* Fiber.join(slow), ["sk-live"]);
120 }).pipe(Effect.provide(resolverLayer(driver)));
121 }),
122 );
123
124 it.effect("invalidates every reference when none are named", () => {
125 const { driver, reads } = fakeDriver(() => "sk-live");
126 return Effect.gen(function* () {
127 const resolver = yield* SecretResolver.SecretResolver;
128 const token = ref("fake://openai");
129
130 yield* resolver.read([token]);
131 yield* resolver.invalidate();
132 yield* resolver.read([token]);
133 assert.strictEqual(reads.length, 2);
134 }).pipe(Effect.provide(resolverLayer(driver)));
135 });
136
137 it.effect("reads each distinct reference of a provider in one call, in input order", () => {
138 const { driver, reads } = fakeDriver((_, reference) => reference.toUpperCase());
139 return Effect.gen(function* () {
140 const resolver = yield* SecretResolver.SecretResolver;
141
142 const values = yield* resolver.read([ref("fake://a"), ref("fake://b"), ref("fake://a")]);
143
144 assert.deepStrictEqual(values, ["FAKE://A", "FAKE://B", "FAKE://A"]);
145 assert.deepStrictEqual(reads, [{ account: "a", references: ["fake://a", "fake://b"] }]);
146 }).pipe(Effect.provide(resolverLayer(driver)));
147 });
148
149 it.effect("reads each provider separately", () => {
150 const { driver, reads } = fakeDriver((account, reference) => `${account}:${reference}`);
151 return Effect.gen(function* () {
152 const resolver = yield* SecretResolver.SecretResolver;
153
154 const values = yield* resolver.read([ref("fake://a"), ref("fake://a", work)]);
155
156 assert.deepStrictEqual(values, ["a:fake://a", "b:fake://a"]);
157 assert.strictEqual(reads.length, 2);
158 }).pipe(
159 Effect.provide(resolverLayer(driver, () => ({ [personal]: fake("a"), [work]: fake("b") }))),
160 );
161 });
162
163 it.effect("reads again when the provider's config changes", () => {
164 let account = "a";
165 const { driver, reads } = fakeDriver((account, reference) => `${account}:${reference}`);
166 return Effect.gen(function* () {
167 const resolver = yield* SecretResolver.SecretResolver;
168 const token = ref("fake://openai");
169
170 assert.deepStrictEqual(yield* resolver.read([token]), ["a:fake://openai"]);
171 account = "b";
172 assert.deepStrictEqual(yield* resolver.read([token]), ["b:fake://openai"]);
173 assert.deepStrictEqual(
174 reads.map((read) => read.account),
175 ["a", "b"],
176 );
177 }).pipe(Effect.provide(resolverLayer(driver, () => ({ [personal]: fake(account) }))));
178 });
179
180 it.effect("does not call a driver for what it cannot read, and reads it later", () => {
181 const { driver, reads } = fakeDriver(() => "sk-live");
182 const providers: ServerSettings["secretProviders"] = {
183 [personal]: fake("a"),
184 [SecretProviderId.make("vault")]: {
185 kind: SecretProviderKind.make("openbao"),
186 label: "Vault",
187 },
188 [SecretProviderId.make("broken")]: { kind: FAKE_KIND, label: "Broken", config: {} },
189 };
190 return Effect.gen(function* () {
191 const resolver = yield* SecretResolver.SecretResolver;
192
193 const values = yield* resolver.read([
194 ref("fake://openai", SecretProviderId.make("missing")),
195 ref("fake://openai", SecretProviderId.make("vault")),
196 ref("fake://openai", SecretProviderId.make("broken")),
197 ref("openai"),
198 ]);
199
200 assert.deepStrictEqual(values, [undefined, undefined, undefined, undefined]);
201 assert.strictEqual(reads.length, 0);
202 }).pipe(Effect.provide(resolverLayer(driver, () => providers)));
203 });
204 });