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

main
ts 262 lines 9.15 KB
Raw
1 import { spawn } from "node:child_process";
2 import { createServer, type Server } from "node:http";
3 import * as Effect from "effect/Effect";
4 import * as Schema from "effect/Schema";
5
6 export interface OtlpCollector {
7 readonly server: Server;
8 /** Base URL (`http://127.0.0.1:<port>`); append the OTLP signal path. */
9 readonly url: string;
10 /** Responses fully written to the client. */
11 readonly completedRequests: { value: number };
12 /**
13 * Received `POST /v1/*` export batches, including exports whose client
14 * disconnected. Any other request is answered 404 and not recorded.
15 */
16 readonly requests: Array<{
17 body: string;
18 receivedAt: number;
19 responseStartedAt?: number;
20 closedAt?: number;
21 completed: boolean;
22 aborted: boolean;
23 }>;
24 /** Re-arm the response gate for subsequent matching batches. */
25 readonly holdResponses: () => void;
26 /** Acknowledge held batches and leave the gate open until re-armed. */
27 readonly releaseResponses: () => void;
28 }
29
30 /** OTLP/HTTP exports are `POST`s to a signal path (`/v1/traces`, `/v1/logs`, …). */
31 const isOtlpExport = (method: string | undefined, url: string | undefined) =>
32 method === "POST" && url?.startsWith("/v1/") === true;
33
34 /**
35 * Starts a local OTLP endpoint that records exports and completed responses.
36 * Matching `holdResponse` batches wait for explicit release, so tests can
37 * assert response/export ordering without timer races. Only OTLP exports
38 * (`POST /v1/*`) are recorded: dev tools that probe local ports (a terminal
39 * app sending `GET /` to every listener it sees) get a 404 instead of
40 * landing in `requests`. The Node server is a test adapter only.
41 */
42 export const startOtlpCollector = (
43 options: {
44 holdResponse?: (body: string) => boolean;
45 } = {},
46 ) =>
47 Effect.acquireRelease(
48 Effect.callback<OtlpCollector, Error>((resume) => {
49 const completedRequests = { value: 0 };
50 const requests: OtlpCollector["requests"] = [];
51 const pending = new Set<() => void>();
52 let held = true;
53 const holdResponses = () => {
54 held = true;
55 };
56 const releaseResponses = () => {
57 held = false;
58 for (const send of pending) send();
59 pending.clear();
60 };
61 const server = createServer((request, response) => {
62 if (!isOtlpExport(request.method, request.url)) {
63 request.resume();
64 response.writeHead(404).end();
65 return;
66 }
67 let body = "";
68 request.setEncoding("utf8");
69 request.on("data", (chunk: string) => {
70 body += chunk;
71 });
72 request.once("end", () => {
73 const batch: OtlpCollector["requests"][number] = {
74 body,
75 receivedAt: Date.now(),
76 completed: false,
77 aborted: false,
78 };
79 requests.push(batch);
80 const send = () => {
81 batch.responseStartedAt = Date.now();
82 response.writeHead(200, { "content-type": "application/json" });
83 response.end('{"partialSuccess":{}}');
84 };
85 response.once("finish", () => {
86 batch.completed = true;
87 completedRequests.value += 1;
88 });
89 response.once("close", () => {
90 batch.closedAt = Date.now();
91 batch.aborted = !batch.completed;
92 pending.delete(send);
93 });
94 if (held && options.holdResponse?.(body)) {
95 pending.add(send);
96 } else {
97 send();
98 }
99 });
100 });
101 const onError = (error: Error) => resume(Effect.fail(error));
102 server.once("error", onError);
103 server.listen(0, "127.0.0.1", () => {
104 server.off("error", onError);
105 const address = server.address();
106 if (address === null || typeof address === "string") {
107 resume(Effect.fail(new Error("OTLP test collector address unavailable")));
108 return;
109 }
110 resume(
111 Effect.succeed({
112 server,
113 completedRequests,
114 requests,
115 holdResponses,
116 releaseResponses,
117 url: `http://127.0.0.1:${address.port}`,
118 }),
119 );
120 });
121 return Effect.sync(() => server.close());
122 }),
123 ({ server, releaseResponses }) =>
124 Effect.callback<void, Error>((resume) => {
125 releaseResponses();
126 server.close((error) => resume(error === undefined ? Effect.void : Effect.fail(error)));
127 }).pipe(Effect.orDie),
128 );
129
130 /** One line the delayed collector child writes to stdout. */
131 const CollectorEvent = Schema.fromJsonString(
132 Schema.Union([
133 Schema.Struct({ type: Schema.Literal("ready"), port: Schema.Number }),
134 Schema.Struct({
135 type: Schema.Literal("received"),
136 id: Schema.Number,
137 body: Schema.String,
138 at: Schema.Number,
139 }),
140 Schema.Struct({
141 type: Schema.Literals(["responding", "finished"]),
142 id: Schema.Number,
143 at: Schema.Number,
144 }),
145 Schema.Struct({
146 type: Schema.Literal("closed"),
147 id: Schema.Number,
148 at: Schema.Number,
149 aborted: Schema.Boolean,
150 }),
151 ]),
152 );
153 const decodeCollectorEvent = Schema.decodeUnknownExit(CollectorEvent);
154
155 /** Node's native HTTP close events expose cancellations that Bun's adapter omits. */
156 export const startDelayedOtlpCollector = () =>
157 Effect.acquireRelease(
158 Effect.callback<
159 Pick<OtlpCollector, "url" | "requests" | "completedRequests"> & {
160 stop: () => void;
161 },
162 Error
163 >((resume) => {
164 const requests: OtlpCollector["requests"] = [];
165 const completedRequests = { value: 0 };
166 const child = spawn(
167 "node",
168 [
169 "-e",
170 `
171 const { createServer } = require("node:http");
172 const emit = (event) => process.stdout.write(JSON.stringify(event) + "\\n");
173 let nextId = 0;
174 const server = createServer((request, response) => {
175 // Record OTLP exports only; dev tools probe local listeners with GET /.
176 if (request.method !== "POST" || !request.url?.startsWith("/v1/")) {
177 request.resume();
178 response.writeHead(404).end();
179 return;
180 }
181 let body = "";
182 request.setEncoding("utf8");
183 request.on("data", (chunk) => { body += chunk; });
184 request.once("end", () => {
185 const id = nextId++;
186 let completed = false;
187 emit({ type: "received", id, body, at: Date.now() });
188 const send = () => {
189 emit({ type: "responding", id, at: Date.now() });
190 response.writeHead(200, { "content-type": "application/json" });
191 response.end('{"partialSuccess":{}}');
192 };
193 const delayed = body.includes('"name":"otel-event-flush.rpc"');
194 const timer = delayed ? setTimeout(send, 4000) : undefined;
195 response.once("finish", () => {
196 completed = true;
197 emit({ type: "finished", id, at: Date.now() });
198 });
199 response.once("close", () => {
200 clearTimeout(timer);
201 emit({ type: "closed", id, at: Date.now(), aborted: !completed });
202 });
203 if (!delayed) send();
204 });
205 });
206 server.listen(0, "127.0.0.1", () => emit({ type: "ready", port: server.address().port }));
207 `,
208 ],
209 { stdio: ["ignore", "pipe", "pipe"] },
210 );
211 const stop = () => {
212 child.kill();
213 };
214 child.once("error", (error) => resume(Effect.fail(error)));
215 child.stderr.on("data", (data) => console.error(String(data)));
216 let pending = "";
217 child.stdout.on("data", (data) => {
218 pending += String(data);
219 let newline: number;
220 while ((newline = pending.indexOf("\n")) !== -1) {
221 const line = pending.slice(0, newline);
222 pending = pending.slice(newline + 1);
223 const decoded = decodeCollectorEvent(line);
224 if (decoded._tag === "Failure") {
225 console.error(`Undecodable OTLP collector event: ${line}`);
226 resume(Effect.fail(new Error(`Undecodable OTLP collector event: ${line}`)));
227 continue;
228 }
229 const message = decoded.value;
230 if (message.type === "ready") {
231 resume(
232 Effect.succeed({
233 url: `http://127.0.0.1:${message.port}`,
234 requests,
235 completedRequests,
236 stop,
237 }),
238 );
239 } else if (message.type === "received") {
240 requests[message.id] = {
241 body: message.body,
242 receivedAt: message.at,
243 completed: false,
244 aborted: false,
245 };
246 } else {
247 const batch = requests[message.id]!;
248 if (message.type === "responding") batch.responseStartedAt = message.at;
249 else if (message.type === "finished") {
250 batch.completed = true;
251 completedRequests.value += 1;
252 } else if (message.type === "closed") {
253 batch.closedAt = message.at;
254 batch.aborted = message.aborted;
255 }
256 }
257 }
258 });
259 return Effect.sync(stop);
260 }).pipe(Effect.timeout("5 seconds")),
261 ({ stop }) => Effect.sync(stop),
262 );