@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 206 lines 7.97 KB
Raw
1 import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import { assert, it } from "@effect/vitest";
4 import { DEFAULT_SIGNAL_EXPORT } from "@t3tools/shared/observability";
5 import * as OtelEnvironment from "@t3tools/shared/otelEnvironment";
6 import * as Effect from "effect/Effect";
7 import * as Layer from "effect/Layer";
8 import * as Tracer from "effect/Tracer";
9 import * as NetAddress from "effect/net/NetAddress";
10 import {
11 FetchHttpClient,
12 HttpClient,
13 HttpClientError,
14 HttpClientResponse,
15 HttpServer,
16 HttpServerRequest,
17 HttpServerResponse,
18 } from "effect/http";
19 import { describe } from "vite-plus/test";
20
21 import * as ServerConfig from "../config.ts";
22 import * as OtlpEndpointCheck from "./OtlpEndpointCheck.ts";
23
24 interface PostedRequest {
25 readonly url: string;
26 readonly headers: Readonly<Record<string, string>>;
27 readonly body: string;
28 readonly signal: AbortSignal;
29 }
30
31 const checkWith = (
32 status: number | null,
33 overrides: Partial<ServerConfig.ServerConfig["Service"]> = {},
34 httpClientLayer?: Layer.Layer<HttpClient.HttpClient>,
35 ) => {
36 const requests: Array<PostedRequest> = [];
37 const httpClient = HttpClient.make((request, _url, signal) => {
38 requests.push({
39 url: request.url,
40 headers: request.headers,
41 body: request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : "",
42 signal,
43 });
44 return status === null
45 ? Effect.fail(
46 new HttpClientError.HttpClientError({
47 reason: new HttpClientError.TransportError({ request }),
48 }),
49 )
50 : Effect.succeed(HttpClientResponse.fromWeb(request, new Response(null, { status })));
51 });
52 const configLayer = Layer.effect(
53 ServerConfig.ServerConfig,
54 Effect.gen(function* () {
55 const config = yield* ServerConfig.ServerConfig;
56 return ServerConfig.make({ ...config, ...overrides });
57 }),
58 ).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-otlp-check-" })));
59 const layer = OtlpEndpointCheck.layer.pipe(
60 Layer.provide(httpClientLayer ?? Layer.succeed(HttpClient.HttpClient, httpClient)),
61 Layer.provide(configLayer),
62 Layer.provide(NodeServices.layer),
63 );
64 return { requests, layer };
65 };
66
67 const check = (input: Parameters<OtlpEndpointCheck.OtlpEndpointCheck["Service"]["check"]>[0]) =>
68 Effect.gen(function* () {
69 const service = yield* OtlpEndpointCheck.OtlpEndpointCheck;
70 return yield* service.check(input);
71 });
72
73 describe("OtlpEndpointCheck", () => {
74 it.effect("keeps T3 credentials paired with each running signal endpoint", () => {
75 const signalExport = { ...DEFAULT_SIGNAL_EXPORT, headers: { "x-api-key": "secret" } };
76 const { requests, layer } = checkWith(200, {
77 otlpTracesUrl: "https://collector.example.com/v1/traces",
78 otlpMetricsUrl: "https://collector.example.com/v1/metrics",
79 otlpLogsUrl: "https://collector.example.com/v1/logs",
80 otlpTracesExport: signalExport,
81 otlpMetricsExport: signalExport,
82 otlpLogsExport: signalExport,
83 otelEnvironment: OtelEnvironment.none,
84 });
85 return Effect.gen(function* () {
86 for (const signal of ["traces", "metrics", "logs"] as const) {
87 const runningUrl = `https://collector.example.com/v1/${signal}`;
88 yield* check({ signal, url: runningUrl });
89 yield* check({ signal, url: "https://elsewhere.example.com/collect" });
90 yield* check({ signal, url: `${runningUrl}/other` });
91 yield* check({ signal, url: `${runningUrl}?tenant=other` });
92 }
93
94 assert.lengthOf(requests, 12);
95 requests.forEach((request, index) => {
96 if (index % 4 === 0) assert.strictEqual(request.headers["x-api-key"], "secret");
97 else assert.isUndefined(request.headers["x-api-key"]);
98 });
99 }).pipe(Effect.provide(layer));
100 });
101
102 it.effect("does not send export credentials when the signal has no running endpoint", () => {
103 const { requests, layer } = checkWith(200, {
104 otlpLogsUrl: undefined,
105 otlpLogsExport: { ...DEFAULT_SIGNAL_EXPORT, headers: { authorization: "Bearer t3" } },
106 otelEnvironment: OtelEnvironment.none,
107 });
108 return Effect.gen(function* () {
109 const result = yield* check({ signal: "logs", url: "https://new.example.com/v1/logs" });
110
111 assert.strictEqual(result._tag, "Accepted");
112 assert.lengthOf(requests, 1);
113 assert.isUndefined(requests[0]?.headers.authorization);
114 }).pipe(Effect.provide(layer));
115 });
116
117 it.effect("keeps endpoint URLs and credentials out of traces", () => {
118 const url = "https://collector.example.com/v1/logs?api_key=query-secret";
119 const { requests, layer } = checkWith(200, {
120 otlpLogsUrl: url,
121 otlpLogsExport: {
122 ...DEFAULT_SIGNAL_EXPORT,
123 headers: { "x-honeycomb-team": "header-secret" },
124 },
125 otelEnvironment: OtelEnvironment.none,
126 });
127 const recorded: Array<unknown> = [];
128 const tracer = Tracer.make({
129 span: (options) => {
130 const span = new Tracer.NativeSpan(options);
131 const end = span.end.bind(span);
132 span.end = (endTime, exit) => {
133 end(endTime, exit);
134 recorded.push({ name: span.name, attributes: Object.fromEntries(span.attributes) });
135 };
136 return span;
137 },
138 });
139 return Effect.gen(function* () {
140 yield* check({ signal: "logs", url }).pipe(Effect.withTracer(tracer));
141
142 assert.strictEqual(requests[0]?.headers["x-honeycomb-team"], "header-secret");
143 assert.notInclude(JSON.stringify(recorded), "secret");
144 }).pipe(Effect.provide(layer));
145 });
146
147 it.effect("does not forward credentials through a receiver redirect", () =>
148 Effect.scoped(
149 Effect.gen(function* () {
150 const requests: Array<{ url: string; apiKey: string | undefined }> = [];
151 const server = yield* HttpServer.HttpServer;
152 yield* server.serve(
153 Effect.gen(function* () {
154 const request = yield* HttpServerRequest.HttpServerRequest;
155 yield* request.text;
156 requests.push({ url: request.url, apiKey: request.headers["x-api-key"] });
157 return request.url === "/v1/traces"
158 ? HttpServerResponse.redirect("/other", { status: 307 })
159 : HttpServerResponse.empty({ status: 200 });
160 }),
161 );
162 if (!NetAddress.isInetAddress(server.address)) {
163 return yield* Effect.die(new Error("Expected a TCP address"));
164 }
165 const url = `http://127.0.0.1:${server.address.port}/v1/traces`;
166 const { layer } = checkWith(
167 200,
168 {
169 otlpTracesUrl: url,
170 otlpTracesExport: { ...DEFAULT_SIGNAL_EXPORT, headers: { "x-api-key": "secret" } },
171 },
172 FetchHttpClient.layer,
173 );
174 const result = yield* check({ signal: "traces", url }).pipe(Effect.provide(layer));
175
176 assert.deepStrictEqual(result, { _tag: "Rejected", status: 307 });
177 assert.deepStrictEqual(requests, [{ url: "/v1/traces", apiKey: "secret" }]);
178 }),
179 ).pipe(Effect.provide(NodeHttpServer.layerTest)),
180 );
181
182 it.effect("keeps OTEL endpoint credentials off other endpoints", () => {
183 const otelUrl = "https://otel.example.com/v1/traces";
184 const otelExport = { ...DEFAULT_SIGNAL_EXPORT, headers: { "x-api-key": "secret" } };
185 const { requests, layer } = checkWith(200, {
186 otlpTracesUrl: otelUrl,
187 otlpTracesExport: otelExport,
188 otelEnvironment: {
189 ...OtelEnvironment.none,
190 traces: OtelEnvironment.OtelSignal.Export({
191 url: otelUrl,
192 variable: "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
193 protocol: otelExport.protocol,
194 headers: otelExport.headers,
195 }),
196 },
197 });
198 return Effect.gen(function* () {
199 yield* check({ signal: "traces", url: otelUrl });
200 yield* check({ signal: "traces", url: "https://elsewhere.example.com/v1/traces" });
201
202 assert.strictEqual(requests[0]?.headers["x-api-key"], "secret");
203 assert.isUndefined(requests[1]?.headers["x-api-key"]);
204 }).pipe(Effect.provide(layer));
205 });
206 });