@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 318 lines 12.6 KB
Raw
1 import * as AccessAnalyzer from "@alchemy.run/aws/AccessAnalyzer";
2 import * as Lambda from "@alchemy.run/aws/Lambda";
3 import * as Effect from "effect/Effect";
4 import { HttpServerRequest } from "effect/http/HttpServerRequest";
5 import * as HttpServerResponse from "effect/http/HttpServerResponse";
6 import * as Layer from "effect/Layer";
7 import * as Stream from "effect/Stream";
8 import path from "pathe";
9
10 const main = path.resolve(import.meta.dirname, "handler.ts");
11
12 // The fixture analyzer is ACCOUNT_UNUSED_ACCESS (not ACCOUNT) on purpose:
13 // AWS allows only ONE external-access account analyzer per Region, and
14 // Analyzer.test.ts exercises that singleton's lifecycle. Using the
15 // unused-access type keeps the two suites quota-independent.
16 export const FIXTURE_ANALYZER_NAME = "alchemy-test-bindings-unused-access";
17 export const FIXTURE_RULE_NAME = "alchemy-test-bindings-rule";
18
19 // Deterministic sample policies (checked-in constants, never generated at
20 // test time).
21 const IDENTITY_POLICY = JSON.stringify({
22 Version: "2012-10-17",
23 Statement: [
24 {
25 Effect: "Allow",
26 Action: ["s3:GetObject"],
27 Resource: "arn:aws:s3:::alchemy-test-bucket/*",
28 },
29 ],
30 });
31
32 // Superset of IDENTITY_POLICY — used as the "existing" policy so the new
33 // policy (IDENTITY_POLICY) grants no new access.
34 const WIDER_IDENTITY_POLICY = JSON.stringify({
35 Version: "2012-10-17",
36 Statement: [
37 {
38 Effect: "Allow",
39 Action: ["s3:GetObject", "s3:PutObject"],
40 Resource: "arn:aws:s3:::alchemy-test-bucket/*",
41 },
42 ],
43 });
44
45 // Non-public bucket policy: access limited to a single account principal.
46 const PRIVATE_BUCKET_POLICY = JSON.stringify({
47 Version: "2012-10-17",
48 Statement: [
49 {
50 Effect: "Allow",
51 Principal: { AWS: "arn:aws:iam::111111111111:root" },
52 Action: "s3:GetObject",
53 Resource: "arn:aws:s3:::alchemy-test-bucket/*",
54 },
55 ],
56 });
57
58 export class AccessAnalyzerTestFunction extends Lambda.Function<Lambda.Function>()(
59 "AccessAnalyzerTestFunction",
60 ) {}
61
62 export default AccessAnalyzerTestFunction.make(
63 {
64 main,
65 functionUrl: true,
66 },
67 Effect.gen(function* () {
68 const analyzer = yield* AccessAnalyzer.Analyzer("BindingsAnalyzer", {
69 analyzerName: FIXTURE_ANALYZER_NAME,
70 type: "ACCOUNT_UNUSED_ACCESS",
71 });
72 yield* AccessAnalyzer.ArchiveRule("BindingsArchiveRule", {
73 analyzerName: analyzer.analyzerName,
74 ruleName: FIXTURE_RULE_NAME,
75 filter: { findingType: { eq: ["UnusedIAMRole"] } },
76 });
77
78 // --- analyzer-scoped bindings ---
79 const listFindingsV2 = yield* AccessAnalyzer.ListFindingsV2(analyzer);
80 const getFindingsStatistics = yield* AccessAnalyzer.GetFindingsStatistics(analyzer);
81 const applyArchiveRule = yield* AccessAnalyzer.ApplyArchiveRule(analyzer);
82 // Bound (compile + IAM coverage) but not routed: these need live
83 // findings, access previews, or an external-access analyzer to drive
84 // deterministically.
85 const listFindingsV1 = yield* AccessAnalyzer.ListFindings(analyzer);
86 const getFindingV2 = yield* AccessAnalyzer.GetFindingV2(analyzer);
87 const getFindingV1 = yield* AccessAnalyzer.GetFinding(analyzer);
88 const updateFindings = yield* AccessAnalyzer.UpdateFindings(analyzer);
89 const startResourceScan = yield* AccessAnalyzer.StartResourceScan(analyzer);
90 const getAnalyzedResource = yield* AccessAnalyzer.GetAnalyzedResource(analyzer);
91 const listAnalyzedResources = yield* AccessAnalyzer.ListAnalyzedResources(analyzer);
92 const createAccessPreview = yield* AccessAnalyzer.CreateAccessPreview(analyzer);
93 const getAccessPreview = yield* AccessAnalyzer.GetAccessPreview(analyzer);
94 const listAccessPreviews = yield* AccessAnalyzer.ListAccessPreviews(analyzer);
95 const listAccessPreviewFindings = yield* AccessAnalyzer.ListAccessPreviewFindings(analyzer);
96 const generateFindingRecommendation =
97 yield* AccessAnalyzer.GenerateFindingRecommendation(analyzer);
98 const getFindingRecommendation = yield* AccessAnalyzer.GetFindingRecommendation(analyzer);
99
100 // --- account-level bindings ---
101 const validatePolicy = yield* AccessAnalyzer.ValidatePolicy();
102 const checkAccessNotGranted = yield* AccessAnalyzer.CheckAccessNotGranted();
103 const checkNoNewAccess = yield* AccessAnalyzer.CheckNoNewAccess();
104 const checkNoPublicAccess = yield* AccessAnalyzer.CheckNoPublicAccess();
105 const startPolicyGeneration = yield* AccessAnalyzer.StartPolicyGeneration();
106 const getGeneratedPolicy = yield* AccessAnalyzer.GetGeneratedPolicy();
107 const listPolicyGenerations = yield* AccessAnalyzer.ListPolicyGenerations();
108 const cancelPolicyGeneration = yield* AccessAnalyzer.CancelPolicyGeneration();
109
110 // --- event source ---
111 // Deploy-time: creates the EventBridge rule (default bus) targeting this
112 // Function. Runtime firing needs a real finding, so the test only
113 // verifies the subscription deploys cleanly.
114 yield* AccessAnalyzer.consumeFindings({ kind: "all" }, (events) =>
115 Stream.runForEach(events, (event) =>
116 Effect.log(`access-analyzer finding event: ${event.detail.id}`),
117 ),
118 );
119
120 const bound = {
121 listFindingsV2,
122 listFindingsV1,
123 getFindingV2,
124 getFindingV1,
125 getFindingsStatistics,
126 updateFindings,
127 applyArchiveRule,
128 startResourceScan,
129 getAnalyzedResource,
130 listAnalyzedResources,
131 createAccessPreview,
132 getAccessPreview,
133 listAccessPreviews,
134 listAccessPreviewFindings,
135 generateFindingRecommendation,
136 getFindingRecommendation,
137 validatePolicy,
138 checkAccessNotGranted,
139 checkNoNewAccess,
140 checkNoPublicAccess,
141 startPolicyGeneration,
142 getGeneratedPolicy,
143 listPolicyGenerations,
144 cancelPolicyGeneration,
145 };
146
147 return {
148 fetch: Effect.gen(function* () {
149 const request = yield* HttpServerRequest;
150 const url = new URL(request.originalUrl);
151 const pathname = url.pathname;
152
153 if (request.method === "GET" && pathname === "/bindings") {
154 return yield* HttpServerResponse.json({
155 bound: Object.keys(bound),
156 });
157 }
158
159 if (request.method === "GET" && pathname === "/list-findings") {
160 const result = yield* listFindingsV2({ maxResults: 25 });
161 return yield* HttpServerResponse.json({
162 count: result.findings.length,
163 nextToken: result.nextToken ?? null,
164 });
165 }
166
167 if (request.method === "GET" && pathname === "/list-analyzed-resources") {
168 const result = yield* listAnalyzedResources({ maxResults: 25 });
169 return yield* HttpServerResponse.json({
170 count: result.analyzedResources.length,
171 });
172 }
173
174 if (request.method === "GET" && pathname === "/get-finding-not-found") {
175 // Exercises analyzerArn injection + the typed not-found error path.
176 const result = yield* getFindingV2({
177 id: "00000000-0000-0000-0000-000000000000",
178 }).pipe(
179 Effect.map(() => ({ found: true })),
180 Effect.catchTag("ResourceNotFoundException", () => Effect.succeed({ found: false })),
181 );
182 return yield* HttpServerResponse.json(result);
183 }
184
185 if (request.method === "GET" && pathname === "/findings-statistics") {
186 const result = yield* getFindingsStatistics();
187 return yield* HttpServerResponse.json({
188 statistics: result.findingsStatistics ?? [],
189 });
190 }
191
192 if (request.method === "POST" && pathname === "/apply-archive-rule") {
193 yield* applyArchiveRule({ ruleName: FIXTURE_RULE_NAME });
194 return yield* HttpServerResponse.json({ applied: true });
195 }
196
197 if (request.method === "POST" && pathname === "/validate-policy") {
198 const result = yield* validatePolicy({
199 policyDocument: IDENTITY_POLICY,
200 policyType: "IDENTITY_POLICY",
201 });
202 return yield* HttpServerResponse.json({
203 findingTypes: result.findings.map((f) => f.findingType),
204 });
205 }
206
207 if (request.method === "POST" && pathname === "/check-no-new-access") {
208 const result = yield* checkNoNewAccess({
209 existingPolicyDocument: WIDER_IDENTITY_POLICY,
210 newPolicyDocument: IDENTITY_POLICY,
211 policyType: "IDENTITY_POLICY",
212 });
213 return yield* HttpServerResponse.json({ result: result.result });
214 }
215
216 if (request.method === "POST" && pathname === "/check-access-not-granted") {
217 const result = yield* checkAccessNotGranted({
218 policyDocument: IDENTITY_POLICY,
219 policyType: "IDENTITY_POLICY",
220 access: [{ actions: ["s3:DeleteBucket"] }],
221 });
222 return yield* HttpServerResponse.json({ result: result.result });
223 }
224
225 if (request.method === "POST" && pathname === "/check-no-public-access") {
226 const result = yield* checkNoPublicAccess({
227 policyDocument: PRIVATE_BUCKET_POLICY,
228 resourceType: "AWS::S3::Bucket",
229 });
230 return yield* HttpServerResponse.json({ result: result.result });
231 }
232
233 if (request.method === "GET" && pathname === "/list-policy-generations") {
234 const result = yield* listPolicyGenerations();
235 return yield* HttpServerResponse.json({
236 count: result.policyGenerations.length,
237 });
238 }
239
240 if (request.method === "POST" && pathname === "/policy-generation") {
241 // The live API rejects StartPolicyGeneration without
242 // `cloudTrailDetails` ("Missing cloudTrailDetails"); a real
243 // generation needs a CloudTrail trail + an access role Access
244 // Analyzer can assume — external infra out of scope for a binding
245 // test. Drive all three bindings through their typed
246 // ValidationException paths instead: an IAM gap would surface
247 // AccessDeniedException, so a ValidationException proves the grant
248 // and the typed error union end-to-end.
249 const body = (yield* request.json) as unknown as {
250 principalArn: string;
251 };
252 const startTag = yield* startPolicyGeneration({
253 policyGenerationDetails: { principalArn: body.principalArn },
254 }).pipe(
255 // If AWS ever accepts trail-less generation again, cancel the
256 // job so nothing dangles.
257 Effect.flatMap(({ jobId }) =>
258 cancelPolicyGeneration({ jobId }).pipe(
259 Effect.catchTag("ValidationException", () => Effect.void),
260 Effect.as("Started"),
261 ),
262 ),
263 Effect.catchTag("ValidationException", (e) => Effect.succeed(e._tag)),
264 );
265 const bogusJob = { jobId: "00000000-0000-0000-0000-000000000000" };
266 const getTag = yield* getGeneratedPolicy(bogusJob).pipe(
267 Effect.map(() => "Found"),
268 Effect.catchTag("ValidationException", (e) => Effect.succeed(e._tag)),
269 );
270 const cancelTag = yield* cancelPolicyGeneration(bogusJob).pipe(
271 Effect.map(() => "Canceled"),
272 Effect.catchTag("ValidationException", (e) => Effect.succeed(e._tag)),
273 );
274 return yield* HttpServerResponse.json({
275 startTag,
276 getTag,
277 cancelTag,
278 });
279 }
280
281 return yield* HttpServerResponse.json(
282 { error: "Not found", method: request.method, pathname },
283 { status: 404 },
284 );
285 }).pipe(Effect.orDie),
286 };
287 }).pipe(
288 Effect.provide(
289 Layer.mergeAll(
290 Lambda.EventSource,
291 AccessAnalyzer.ListFindingsV2Http,
292 AccessAnalyzer.ListFindingsHttp,
293 AccessAnalyzer.GetFindingV2Http,
294 AccessAnalyzer.GetFindingHttp,
295 AccessAnalyzer.GetFindingsStatisticsHttp,
296 AccessAnalyzer.UpdateFindingsHttp,
297 AccessAnalyzer.ApplyArchiveRuleHttp,
298 AccessAnalyzer.StartResourceScanHttp,
299 AccessAnalyzer.GetAnalyzedResourceHttp,
300 AccessAnalyzer.ListAnalyzedResourcesHttp,
301 AccessAnalyzer.CreateAccessPreviewHttp,
302 AccessAnalyzer.GetAccessPreviewHttp,
303 AccessAnalyzer.ListAccessPreviewsHttp,
304 AccessAnalyzer.ListAccessPreviewFindingsHttp,
305 AccessAnalyzer.GenerateFindingRecommendationHttp,
306 AccessAnalyzer.GetFindingRecommendationHttp,
307 AccessAnalyzer.ValidatePolicyHttp,
308 AccessAnalyzer.CheckAccessNotGrantedHttp,
309 AccessAnalyzer.CheckNoNewAccessHttp,
310 AccessAnalyzer.CheckNoPublicAccessHttp,
311 AccessAnalyzer.StartPolicyGenerationHttp,
312 AccessAnalyzer.GetGeneratedPolicyHttp,
313 AccessAnalyzer.ListPolicyGenerationsHttp,
314 AccessAnalyzer.CancelPolicyGenerationHttp,
315 ),
316 ),
317 ),
318 );