@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, 06:00 UTC

main
ts 185 lines 7.16 KB
Raw
1 import * as Lambda from "@alchemy.run/aws/Lambda";
2 import * as SSM from "@alchemy.run/aws/SSM";
3 import * as Duration from "effect/Duration";
4 import * as Effect from "effect/Effect";
5 import { HttpServerRequest } from "effect/http/HttpServerRequest";
6 import * as HttpServerResponse from "effect/http/HttpServerResponse";
7 import * as Layer from "effect/Layer";
8 import * as Redacted from "effect/Redacted";
9 import * as Schedule from "effect/Schedule";
10 import * as Stream from "effect/Stream";
11 import path from "pathe";
12
13 const main = path.resolve(import.meta.dirname, "handler.ts");
14
15 const plain = (value: string | Redacted.Redacted<string> | undefined): string | undefined =>
16 value === undefined ? undefined : typeof value === "string" ? value : Redacted.value(value);
17
18 export class SSMTestFunction extends Lambda.Function<Lambda.Function>()("SSMTestFunction") {}
19
20 export default SSMTestFunction.make(
21 {
22 main,
23 functionUrl: true,
24 timeout: Duration.seconds(30),
25 },
26 Effect.gen(function* () {
27 const stringParameter = yield* SSM.Parameter("TestStringParameter", {
28 value: "plain-config-value",
29 tags: { Environment: "test" },
30 });
31 const secureParameter = yield* SSM.Parameter("TestSecureParameter", {
32 type: "SecureString",
33 value: Redacted.make("bound-secret-value"),
34 });
35 // A parameter the write-plane bindings mutate at runtime (put, label,
36 // unlabel, history). Runtime writes drift the value; the next deploy
37 // converges it back to "v1".
38 const mutableParameter = yield* SSM.Parameter("TestMutableParameter", {
39 value: "v1",
40 });
41 // A hierarchical subtree for GetParametersByPath: the root parameter is
42 // the bound subtree marker, the child lives under the root's name.
43 const pathRoot = yield* SSM.Parameter("TestPathRoot", {
44 name: "/alchemy-test/ssm-bindings/root",
45 value: "root-value",
46 });
47 yield* SSM.Parameter("TestPathChild", {
48 name: "/alchemy-test/ssm-bindings/root/child",
49 value: "child-value",
50 });
51
52 // Event source: subscribe the host to Parameter Store change events. The
53 // deploy proves the EventBridge rule + invoke permission wiring.
54 yield* SSM.consumeParameterEvents(
55 {
56 kinds: ["change"],
57 names: ["/alchemy-test/ssm-bindings/root", "/alchemy-test/ssm-bindings/root/child"],
58 },
59 (events) =>
60 Stream.runForEach(events, (event) =>
61 Effect.log(`parameter ${event.detail.operation}: ${event.detail.name}`),
62 ),
63 );
64
65 const getStringParameter = yield* SSM.GetParameter(stringParameter);
66 const getSecureParameter = yield* SSM.GetParameter(secureParameter);
67 const getParameters = yield* SSM.GetParameters(stringParameter, secureParameter);
68 const putParameter = yield* SSM.PutParameter(mutableParameter);
69 const getHistory = yield* SSM.GetParameterHistory(mutableParameter);
70 const labelVersion = yield* SSM.LabelParameterVersion(mutableParameter);
71 const unlabelVersion = yield* SSM.UnlabelParameterVersion(mutableParameter);
72 const getByPath = yield* SSM.GetParametersByPath(pathRoot);
73
74 return {
75 fetch: Effect.gen(function* () {
76 const request = yield* HttpServerRequest;
77 const url = new URL(request.originalUrl);
78 const pathname = url.pathname;
79
80 if (request.method === "GET" && pathname === "/get-string") {
81 const result = yield* getStringParameter();
82 return yield* HttpServerResponse.json({
83 name: result.Parameter?.Name,
84 type: result.Parameter?.Type,
85 value: plain(result.Parameter?.Value),
86 });
87 }
88
89 if (request.method === "GET" && pathname === "/get-secure") {
90 const result = yield* getSecureParameter({ WithDecryption: true });
91 return yield* HttpServerResponse.json({
92 name: result.Parameter?.Name,
93 type: result.Parameter?.Type,
94 value: plain(result.Parameter?.Value),
95 });
96 }
97
98 if (request.method === "GET" && pathname === "/get-many") {
99 const result = yield* getParameters({ WithDecryption: true });
100 return yield* HttpServerResponse.json({
101 parameters: (result.Parameters ?? []).map((parameter) => ({
102 name: parameter.Name,
103 type: parameter.Type,
104 value: plain(parameter.Value),
105 })),
106 invalidParameters: result.InvalidParameters ?? [],
107 });
108 }
109
110 // Write a new version of the mutable parameter, then read it back.
111 if (request.method === "POST" && pathname === "/put") {
112 const put = yield* putParameter({
113 Value: "v2-runtime",
114 Overwrite: true,
115 });
116 const history = yield* getHistory();
117 return yield* HttpServerResponse.json({
118 version: put.Version,
119 latest: plain(history.Parameters?.at(-1)?.Value),
120 });
121 }
122
123 // The mutable parameter's full change history.
124 if (request.method === "GET" && pathname === "/history") {
125 const result = yield* getHistory();
126 return yield* HttpServerResponse.json({
127 count: (result.Parameters ?? []).length,
128 values: (result.Parameters ?? []).map((version) => plain(version.Value)),
129 });
130 }
131
132 // Label the latest version, then unlabel the same version. The label
133 // attach is eventually consistent, so retry the unlabel until the
134 // label is visible (RemovedLabels non-empty), bounded at 8 attempts.
135 if (request.method === "POST" && pathname === "/label-cycle") {
136 const labeled = yield* labelVersion({ Labels: ["current"] });
137 const unlabeled = yield* unlabelVersion({
138 ParameterVersion: labeled.ParameterVersion!,
139 Labels: ["current"],
140 }).pipe(
141 Effect.repeat({
142 until: (result): boolean => (result.RemovedLabels ?? []).length > 0,
143 schedule: Schedule.spaced("1 second"),
144 times: 8,
145 }),
146 );
147 return yield* HttpServerResponse.json({
148 labeledVersion: labeled.ParameterVersion,
149 invalidLabels: labeled.InvalidLabels ?? [],
150 removedLabels: unlabeled.RemovedLabels ?? [],
151 });
152 }
153
154 // Read the subtree under the bound path-root parameter's name.
155 if (request.method === "GET" && pathname === "/by-path") {
156 const result = yield* getByPath({ Recursive: true });
157 return yield* HttpServerResponse.json({
158 parameters: (result.Parameters ?? []).map((parameter) => ({
159 name: parameter.Name,
160 value: plain(parameter.Value),
161 })),
162 });
163 }
164
165 return yield* HttpServerResponse.json(
166 { error: "Not found", method: request.method, pathname },
167 { status: 404 },
168 );
169 }).pipe(Effect.orDie),
170 };
171 }).pipe(
172 Effect.provide(
173 Layer.mergeAll(
174 Lambda.EventSource,
175 SSM.GetParameterHttp,
176 SSM.GetParametersHttp,
177 SSM.GetParameterHistoryHttp,
178 SSM.GetParametersByPathHttp,
179 SSM.PutParameterHttp,
180 SSM.LabelParameterVersionHttp,
181 SSM.UnlabelParameterVersionHttp,
182 ),
183 ),
184 ),
185 );