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

main
ts 321 lines 12 KB
Raw
1 import { gzipSync } from "node:zlib";
2 import * as Git from "@alchemy.run/git";
3 import * as GitHttp from "@alchemy.run/git/Http";
4 import { concatBytes } from "@alchemy.run/git/Protocol/ObjectCodec";
5 import { pktText, flushPkt } from "@alchemy.run/git/Protocol/Pkt";
6 import { describe, expect, it } from "@alchemy.run/test";
7 import * as Http from "alchemy/Http";
8 import { RuntimeContext } from "alchemy/RuntimeContext";
9 import * as Context from "effect/Context";
10 import * as Effect from "effect/Effect";
11 import * as HttpApi from "effect/http-api/HttpApi";
12 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
13 import * as HttpApiGroup from "effect/http-api/HttpApiGroup";
14 import * as HttpApiMiddleware from "effect/http-api/HttpApiMiddleware";
15 import * as HttpRouter from "effect/http/HttpRouter";
16 import * as HttpServerRequest from "effect/http/HttpServerRequest";
17 import * as HttpServerResponse from "effect/http/HttpServerResponse";
18 import * as Layer from "effect/Layer";
19 import * as Result from "effect/Result";
20 import * as Stream from "effect/Stream";
21 import { makeMemoryBlobStore } from "./harness/store.ts";
22
23 const oid = "a".repeat(40);
24 const zero = "0".repeat(40);
25 const meta: Git.RepoMetaData = {
26 repoId: "repo",
27 owner: "alice",
28 name: "demo",
29 defaultBranch: "main",
30 description: null,
31 readOnly: false,
32 public: false,
33 forkOf: null,
34 status: "ready",
35 createdAt: 0,
36 lastPush: null,
37 objects: { loose: 0, resident: 0, packed: 0, r2: 0, bytes: 0 },
38 };
39 const request = () =>
40 HttpServerRequest.fromWeb(
41 new Request("http://test/alice/demo.git/git-receive-pack", {
42 method: "POST",
43 body: Buffer.from(
44 concatBytes([pktText(`${zero} ${oid} refs/heads/main\0report-status atomic`), flushPkt]),
45 ),
46 }),
47 );
48
49 const fixture = Effect.gen(function* () {
50 const calls = {
51 begin: 0,
52 abort: 0,
53 commit: 0,
54 update: undefined as unknown,
55 merge: undefined as unknown,
56 };
57 const stub = {
58 getRepoMeta: () => Effect.succeed(meta),
59 beginPush: () =>
60 Effect.sync(() => {
61 calls.begin++;
62 return { _tag: "ok" as const, pushId: "push" };
63 }),
64 abortPush: () =>
65 Effect.sync(() => {
66 calls.abort++;
67 return true;
68 }),
69 validatePush: () => Effect.void,
70 readPreparedObject: () =>
71 Effect.succeed({ type: 1 as const, content: new TextEncoder().encode("commit") }),
72 commitPush: (input: Git.CommitPushInput) =>
73 Effect.sync(() => {
74 calls.commit++;
75 return { unpack: "ok", results: input.commands.map((c) => ({ ref: c.ref, ok: true })) };
76 }),
77 getRef: () => Effect.fail(new Git.RefNotFound({ ref: "refs/heads/main" })),
78 updateRef: (input: unknown) =>
79 Effect.sync(() => {
80 calls.update = input;
81 return { name: "refs/heads/main", oid };
82 }),
83 getPull: () =>
84 Effect.succeed({
85 baseRef: "refs/heads/main",
86 headRef: "refs/heads/feature",
87 baseOid: oid,
88 headOid: "b".repeat(40),
89 }),
90 mergePull: (input: unknown) =>
91 Effect.sync(() => {
92 calls.merge = input;
93 return {};
94 }),
95 };
96 const engineLayer = Git.EngineLive.pipe(
97 Layer.provide(
98 Layer.mergeAll(
99 Layer.succeed(Git.RepoStore, { getByName: () => stub as never }),
100 Layer.succeed(Git.RegistryStore, {
101 resolve: () => Effect.succeed({ repoId: "repo", deletedAt: null }),
102 } as never),
103 Git.HasherInline,
104 ),
105 ),
106 Layer.provide(Layer.succeed(Git.BlobStore, makeMemoryBlobStore())),
107 );
108 const engine = yield* Git.Engine.pipe(Effect.provide(engineLayer));
109 return { engine, engineLayer, calls };
110 });
111
112 describe("Git operations and native HTTP middleware", { tags: ["unit", "local"] }, () => {
113 it.effect("accepts raw pack streams without an HTTP request", () =>
114 Effect.scoped(
115 Effect.gen(function* () {
116 const { engine, calls } = yield* fixture;
117 const pack = new Uint8Array(
118 yield* Effect.promise(() =>
119 Bun.file(new URL("./fixtures/packs/empty.pack", import.meta.url)).arrayBuffer(),
120 ),
121 );
122 const input = yield* Git.Push.fromStream(
123 [{ ref: "refs/heads/main", oldOid: zero, newOid: oid }],
124 Stream.make(pack),
125 );
126 yield* Effect.scoped(
127 Effect.gen(function* () {
128 const prepared = yield* engine.preparePush(meta, input);
129 yield* engine.commitPush(prepared);
130 }),
131 );
132 expect(calls.commit).toBe(1);
133 const invalid = yield* Effect.result(
134 Git.Push.fromStream([{ ref: "bad ref", oldOid: zero, newOid: oid }], Stream.empty),
135 );
136 expect(Result.isFailure(invalid)).toBe(true);
137 const truncated = yield* Git.Push.fromStream(
138 [{ ref: "refs/heads/main", oldOid: zero, newOid: oid }],
139 Stream.make(new Uint8Array([0x50, 0x41, 0x43, 0x4b])),
140 );
141 const failure = yield* Effect.result(engine.preparePush(meta, truncated));
142 expect(failure).toMatchObject({
143 _tag: "Failure",
144 failure: { _tag: "StoreError", reason: "truncated pack header" },
145 });
146 expect(calls.commit).toBe(1);
147 }),
148 ).pipe(Effect.provide(RuntimeContext.phantom)),
149 );
150
151 it.effect("decodes gzip incrementally and recognizes Git's empty probe", () =>
152 Effect.scoped(
153 Effect.gen(function* () {
154 const compressed = HttpServerRequest.fromWeb(
155 new Request("http://test/push", {
156 method: "POST",
157 headers: { "content-encoding": "gzip" },
158 body: gzipSync(
159 Buffer.from(
160 concatBytes([pktText(`${zero} ${oid} refs/heads/main\0report-status`), flushPkt]),
161 ),
162 ),
163 }),
164 );
165 const decoded = yield* GitHttp.ReceivePack.decode(compressed);
166 expect(decoded._tag).toBe("Push");
167 const probe = yield* GitHttp.ReceivePack.decode(
168 HttpServerRequest.fromWeb(
169 new Request("http://test/push", { method: "POST", body: "0000" }),
170 ),
171 );
172 expect(probe._tag).toBe("Probe");
173 const malformed = yield* Effect.result(
174 GitHttp.ReceivePack.decode(
175 HttpServerRequest.fromWeb(
176 new Request("http://test/push", { method: "POST", body: "xxxx" }),
177 ),
178 ),
179 );
180 expect(Result.isFailure(malformed)).toBe(true);
181 }),
182 ),
183 );
184
185 it.effect("rejects before staging and encodes a Git report", () =>
186 Effect.gen(function* () {
187 const { calls } = yield* fixture;
188 const response = yield* Effect.scoped(
189 Effect.gen(function* () {
190 const push = yield* GitHttp.ReceivePack.decode(request());
191 if (push._tag !== "Push") return yield* Effect.die("expected push");
192 return GitHttp.ReceivePack.reject(push, "database branch is protected");
193 }),
194 );
195 const text = yield* Effect.promise(() => HttpServerResponse.toWeb(response).text());
196 expect(text).toContain("ng refs/heads/main database branch is protected");
197 expect(calls.begin).toBe(0);
198 }).pipe(Effect.provide(RuntimeContext.phantom)),
199 );
200
201 it.effect("stages, reads objects, aborts on exit, and rejects an escaped transaction", () =>
202 Effect.gen(function* () {
203 const { engine, calls } = yield* fixture;
204 const prepared = yield* Effect.scoped(
205 Effect.gen(function* () {
206 const push = yield* GitHttp.ReceivePack.decode(request());
207 if (push._tag !== "Push") return yield* Effect.die("expected push");
208 const prepared = yield* engine.preparePush(meta, push.input);
209 expect((yield* prepared.readObject(oid))?.type).toBe(1);
210 expect(calls.commit).toBe(0);
211 return prepared;
212 }),
213 );
214 expect(calls.abort).toBe(1);
215 expect(Result.isFailure(yield* Effect.result(engine.commitPush(prepared)))).toBe(true);
216 expect(Result.isFailure(yield* Effect.result(prepared.readObject(oid)))).toBe(true);
217 expect(calls.commit).toBe(0);
218 }).pipe(Effect.provide(RuntimeContext.phantom)),
219 );
220
221 it.effect("commits once, retains committed data, and rejects a second prepare", () =>
222 Effect.gen(function* () {
223 const { engine, calls } = yield* fixture;
224 yield* Effect.scoped(
225 Effect.gen(function* () {
226 const push = yield* GitHttp.ReceivePack.decode(request());
227 if (push._tag !== "Push") return yield* Effect.die("expected push");
228 const prepared = yield* engine.preparePush(meta, push.input);
229 expect(Result.isFailure(yield* Effect.result(engine.preparePush(meta, push.input)))).toBe(
230 true,
231 );
232 yield* engine.commitPush(prepared);
233 expect(Result.isFailure(yield* Effect.result(engine.commitPush(prepared)))).toBe(true);
234 }),
235 );
236 expect(calls.commit).toBe(1);
237 expect(calls.abort).toBe(0);
238 }).pipe(Effect.provide(RuntimeContext.phantom)),
239 );
240
241 it.effect("pins ref creation and both merge tips to the inspected state", () =>
242 Effect.scoped(
243 Effect.gen(function* () {
244 const { engine, calls } = yield* fixture;
245 const ref = yield* engine.prepareRefUpdate(meta, {
246 ref: "refs/heads/main",
247 newOid: oid,
248 expectedOid: null,
249 });
250 expect(ref.updates[0]?.oldOid).toBe(zero);
251 yield* ref.commit;
252 expect(calls.update).toEqual({ name: "refs/heads/main", newOid: oid, expectedOid: null });
253 expect(Result.isFailure(yield* Effect.result(ref.commit))).toBe(true);
254 const merge = yield* engine.prepareMerge(meta, { number: 1 });
255 yield* merge.commit;
256 expect(calls.merge).toMatchObject({
257 expectedBaseOid: oid,
258 expectedHeadOid: "b".repeat(40),
259 });
260 }),
261 ).pipe(Effect.provide(RuntimeContext.phantom)),
262 );
263
264 it.effect("raw API handlers retain middleware user and database dependencies", () =>
265 Effect.gen(function* () {
266 class User extends Context.Service<User, { id: string }>()("test/push/User") {}
267 class Database extends Context.Service<
268 Database,
269 { mayWrite: (user: string, ref: string) => Effect.Effect<boolean> }
270 >()("test/push/Database") {}
271 class Authentication extends HttpApiMiddleware.Service<Authentication, { provides: User }>()(
272 "test/push/Auth",
273 ) {}
274 class Api extends HttpApi.make("custom")
275 .add(HttpApiGroup.make("git").add(GitHttp.ReceivePack.endpoint))
276 .middleware(Authentication) {}
277 const seen: Array<string> = [];
278 const routes = HttpApiBuilder.layer(Api).pipe(
279 Layer.provide(
280 HttpApiBuilder.group(Api, "git", (h) =>
281 Effect.gen(function* () {
282 const db = yield* Database;
283 return h.handleRaw("receivePack", ({ request }) =>
284 Effect.scoped(
285 Effect.gen(function* () {
286 const user = yield* User;
287 const push = yield* GitHttp.ReceivePack.decode(request).pipe(Effect.orDie);
288 if (push._tag === "Probe") return GitHttp.ReceivePack.probeResponse();
289 yield* db.mayWrite(user.id, push.updates[0]!.ref);
290 return GitHttp.ReceivePack.reject(push, "denied by database");
291 }),
292 ),
293 );
294 }),
295 ),
296 ),
297 Layer.provide(
298 Layer.succeed(Authentication, (effect) =>
299 Effect.provideService(effect, User, { id: "alice" }),
300 ),
301 ),
302 Layer.provide(
303 Layer.succeed(Database, {
304 mayWrite: (user, ref) =>
305 Effect.sync(() => {
306 seen.push(`${user}:${ref}`);
307 return false;
308 }),
309 }),
310 ),
311 Layer.provide(Http.Platform),
312 );
313 const fetch = yield* HttpRouter.toHttpEffect(routes);
314 const response = yield* fetch.pipe(
315 Effect.provideService(HttpServerRequest.HttpServerRequest, request()),
316 );
317 expect(response.status).toBe(200);
318 expect(seen).toEqual(["alice:refs/heads/main"]);
319 }).pipe(Effect.provide(RuntimeContext.phantom)),
320 );
321 });