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

main
ts 248 lines 7.56 KB
Raw
1 import { describe, expect, it } from "@alchemy.run/test";
2 import * as Effect from "effect/Effect";
3 import * as Layer from "effect/Layer";
4 import * as Stream from "effect/Stream";
5 import { AlchemyContext } from "@/AlchemyContext.ts";
6 import * as Artifacts from "@/Artifacts.ts";
7 import * as RpcProvider from "@/Local/RpcProvider.ts";
8 import type { ProviderService } from "@/Provider.ts";
9 import { Resource } from "@/Resource.ts";
10 import { ResourceContext } from "@/ResourceContext.ts";
11 import { Stack, type StackSpec } from "@/Stack.ts";
12 import { Stage } from "@/Stage.ts";
13
14 interface TestResource extends Resource<
15 "Local.RpcProvider.Test",
16 {},
17 { ok: boolean; artifact: string }
18 > {}
19 const TestResource = Resource<TestResource>("Local.RpcProvider.Test");
20
21 type StackShape = Omit<StackSpec, "output">;
22
23 interface Capture {
24 stack?: StackShape;
25 stage?: string;
26 resource?: ResourceContext["Service"];
27 artifact?: string;
28 }
29
30 const defaultStack: StackShape = {
31 name: "default-stack",
32 stage: "default-stage",
33 resources: {},
34 bindings: {},
35 actions: {},
36 };
37
38 describe("Local.RpcProvider.effect", { tags: ["unit", "local"] }, () => {
39 it.effect("provides default Stack, Stage, and ResourceContext to lifecycle effects", () =>
40 Effect.gen(function* () {
41 const [capture, result] = yield* useProvider((provider) =>
42 provider.reconcile({
43 id: "r",
44 fqn: "r",
45 instanceId: "inst-from-arg",
46 news: {},
47 olds: undefined,
48 output: undefined,
49 session: undefined as any,
50 bindings: [],
51 }),
52 );
53 expect(result).toMatchObject({ ok: true });
54 expect(capture.stack).toBe(defaultStack);
55 expect(capture.stage).toBe(defaultStack.stage);
56 expect(capture.resource).toEqual({
57 logicalId: "r",
58 fqn: "r",
59 instanceId: "inst-from-arg",
60 type: "Local.RpcProvider.Test",
61 });
62 }),
63 );
64
65 it.effect("does not override Stack, Stage, or ResourceContext when already provided", () =>
66 Effect.gen(function* () {
67 const overrideStack: StackShape = {
68 name: "override-stack",
69 stage: "ignored-stage-on-stack",
70 resources: {},
71 bindings: {},
72 actions: {},
73 };
74 const overrideResource: ResourceContext["Service"] = {
75 logicalId: "override",
76 fqn: "Override/override",
77 instanceId: "override-instance-id",
78 type: "Override.Type",
79 };
80 const [capture] = yield* useProvider((provider) =>
81 provider
82 .reconcile({
83 id: "r",
84 fqn: "r",
85 instanceId: "inst-from-arg",
86 news: {},
87 olds: undefined,
88 output: undefined,
89 session: undefined as any,
90 bindings: [],
91 })
92 .pipe(
93 Effect.provide([
94 Layer.succeed(Stack, overrideStack),
95 Layer.succeed(Stage, "override-stage"),
96 Layer.succeed(ResourceContext, overrideResource),
97 ]),
98 ),
99 );
100 expect(capture.stack).toBe(overrideStack);
101 expect(capture.stage).toBe("override-stage");
102 expect(capture.resource).toBe(overrideResource);
103 }),
104 );
105
106 it.effect("provides defaults to Stream-returning lifecycle methods", () =>
107 Effect.gen(function* () {
108 const [capture, items] = yield* useProvider((provider) =>
109 provider.tail!({
110 id: "r",
111 fqn: "r",
112 instanceId: "inst-from-arg",
113 props: {},
114 output: { ok: true, artifact: "artifact" },
115 }).pipe(Stream.runCollect),
116 );
117 expect(items.length).toBe(1);
118 expect(capture.stack).toBe(defaultStack);
119 expect(capture.stage).toBe(defaultStack.stage);
120 expect(capture.resource).toEqual({
121 logicalId: "r",
122 fqn: "r",
123 instanceId: "inst-from-arg",
124 type: "Local.RpcProvider.Test",
125 });
126 }),
127 );
128
129 it.effect("omits ResourceContext fallback when input has no instanceId", () =>
130 Effect.gen(function* () {
131 const [capture, exit] = yield* useProvider((provider) =>
132 provider
133 .reconcile({
134 id: "r",
135 fqn: "r",
136 news: {},
137 olds: undefined,
138 output: undefined,
139 session: undefined!,
140 instanceId: undefined!,
141 bindings: [],
142 })
143 .pipe(Effect.exit),
144 );
145 expect(exit._tag).toBe("Failure");
146 expect(capture.stack).toBe(defaultStack);
147 expect(capture.stage).toBe(defaultStack.stage);
148 expect(capture.resource).toBeUndefined();
149 }),
150 );
151
152 it.effect("caches artifacts", () =>
153 Effect.gen(function* () {
154 const [capture, result] = yield* useProvider((provider) =>
155 provider.diff!({
156 id: "r",
157 fqn: "r",
158 news: {},
159 olds: undefined,
160 output: undefined,
161 oldBindings: [],
162 newBindings: [],
163 instanceId: "inst-from-arg",
164 }).pipe(
165 Effect.andThen(
166 Effect.all({
167 sameInstanceId: provider.reconcile({
168 id: "r",
169 fqn: "r",
170 instanceId: "inst-from-arg",
171 news: {},
172 olds: undefined,
173 output: undefined,
174 session: undefined as any,
175 bindings: [],
176 }),
177 differentInstanceId: provider.reconcile({
178 id: "r",
179 fqn: "r",
180 instanceId: "inst-from-arg-2",
181 news: {},
182 olds: undefined,
183 output: undefined,
184 session: undefined as any,
185 bindings: [],
186 }),
187 }),
188 ),
189 ),
190 );
191 expect(capture.artifact).toBeDefined();
192 expect(result.sameInstanceId.artifact).toBeDefined();
193 expect(result.differentInstanceId.artifact).toBeDefined();
194 expect(capture.artifact).toBe(result.sameInstanceId.artifact);
195 expect(capture.artifact).not.toBe(result.differentInstanceId.artifact);
196 }),
197 );
198 });
199
200 const artifact = Effect.sync(() => crypto.randomUUID()).pipe(Artifacts.cached("artifact"));
201
202 const TestResourceProvider = (capture: Capture) =>
203 RpcProvider.effect(
204 TestResource,
205 "ignored://entry",
206 Effect.succeed({
207 diff: Effect.fn(function* () {
208 capture.artifact = yield* artifact;
209 }),
210 reconcile: Effect.fn(function* (_input: any) {
211 capture.stack = yield* Stack;
212 capture.stage = yield* Stage;
213 capture.resource = yield* ResourceContext;
214 return { ok: true, artifact: yield* artifact };
215 }),
216 tail: (_input: any) =>
217 Stream.fromEffect(
218 Effect.gen(function* () {
219 capture.stack = yield* Stack;
220 capture.stage = yield* Stage;
221 capture.resource = yield* ResourceContext;
222 return { timestamp: new Date(0), message: "ok" };
223 }),
224 ),
225 delete: Effect.fn(function* () {}),
226 }),
227 );
228
229 const useProvider = <A, E, R>(
230 callback: (provider: ProviderService<TestResource>) => Effect.Effect<A, E, R>,
231 ) => {
232 const capture: Capture = {};
233 return TestResource.Provider.pipe(
234 Effect.flatMap(callback),
235 Effect.map((result) => [capture, result] as const),
236 Effect.provide(
237 Layer.provide(
238 TestResourceProvider(capture),
239 Layer.mergeAll(
240 Layer.succeed(Stack, defaultStack),
241 Layer.succeed(Stage, defaultStack.stage),
242 Layer.sync(Artifacts.ArtifactStore, Artifacts.createArtifactStore),
243 Layer.succeed(AlchemyContext, { dotAlchemy: "/tmp/.alchemy", dev: false, adopt: false }),
244 ),
245 ),
246 ),
247 );
248 };