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

main
ts 171 lines 6.45 KB
Raw
1 import * as Lambda from "@alchemy.run/aws/Lambda";
2 import * as Route53Resolver from "@alchemy.run/aws/Route53Resolver";
3 import * as EC2 from "@distilled.cloud/aws/ec2";
4 import * as Duration from "effect/Duration";
5 import * as Effect from "effect/Effect";
6 import { HttpServerRequest } from "effect/http/HttpServerRequest";
7 import * as HttpServerResponse from "effect/http/HttpServerResponse";
8 import * as Layer from "effect/Layer";
9 import path from "pathe";
10 import { getDefaultVpc } from "../DefaultVpc.ts";
11
12 const main = path.resolve(import.meta.dirname, "handler.ts");
13
14 export class Route53ResolverBindingsFunction extends Lambda.Function<Lambda.Function>()(
15 "Route53ResolverBindingsFunction",
16 ) {}
17
18 /**
19 * Resolve two default-for-AZ subnets plus the default security group from
20 * the account's default VPC — the network the resolver endpoint's interfaces
21 * land in. Runtime-guarded: the Lambda runtime re-executes this props effect
22 * on cold start with no ec2:Describe* permission, so return empty values
23 * there (network config is deploy-time only).
24 */
25 const resolveNetwork = Effect.gen(function* () {
26 if (globalThis.__ALCHEMY_RUNTIME__) {
27 return { subnetIds: [] as string[], securityGroupIds: [] as string[] };
28 }
29 const vpc = yield* getDefaultVpc;
30 const subnets = yield* EC2.describeSubnets({
31 Filters: [
32 { Name: "vpc-id", Values: [vpc.vpcId] },
33 { Name: "default-for-az", Values: ["true"] },
34 ],
35 });
36 const subnetIds = (subnets.Subnets ?? [])
37 .map((s) => s.SubnetId)
38 .filter((id): id is string => id !== undefined)
39 .sort()
40 .slice(0, 2);
41 const groups = yield* EC2.describeSecurityGroups({
42 Filters: [
43 { Name: "vpc-id", Values: [vpc.vpcId] },
44 { Name: "group-name", Values: ["default"] },
45 ],
46 });
47 const securityGroupId = groups.SecurityGroups?.[0]?.GroupId;
48 return {
49 subnetIds,
50 securityGroupIds: securityGroupId ? [securityGroupId] : [],
51 };
52 }).pipe(
53 // Deploy-time lookup only; a failure here is a fixture defect, not a typed
54 // error the Function impl contract can carry.
55 Effect.orDie,
56 );
57
58 /**
59 * Binding fixture: an OUTBOUND resolver endpoint in the default VPC, a
60 * FORWARD rule through it, and a Lambda bound to all five Route 53 Resolver
61 * runtime bindings, one HTTP route per behavior.
62 */
63 export default Route53ResolverBindingsFunction.make(
64 {
65 main,
66 functionUrl: true,
67 timeout: Duration.seconds(120),
68 },
69 Effect.gen(function* () {
70 const net = yield* resolveNetwork;
71 const endpoint = yield* Route53Resolver.ResolverEndpoint("BindingsEndpoint", {
72 direction: "OUTBOUND",
73 securityGroupIds: net.securityGroupIds,
74 ipAddresses: net.subnetIds.map((subnetId) => ({ subnetId })),
75 });
76 const rule = yield* Route53Resolver.ResolverRule("BindingsRule", {
77 domainName: "bindings.alchemy-r53r-test.internal",
78 resolverEndpointId: endpoint.resolverEndpointId,
79 targetIps: [{ ip: "10.100.0.10" }],
80 });
81
82 const bound = {
83 getResolverEndpoint: yield* Route53Resolver.GetResolverEndpoint(endpoint),
84 listResolverEndpointIpAddresses:
85 yield* Route53Resolver.ListResolverEndpointIpAddresses(endpoint),
86 getResolverRule: yield* Route53Resolver.GetResolverRule(rule),
87 updateResolverRule: yield* Route53Resolver.UpdateResolverRule(rule),
88 listResolverRuleAssociations: yield* Route53Resolver.ListResolverRuleAssociations(rule),
89 };
90
91 return {
92 fetch: Effect.gen(function* () {
93 const request = yield* HttpServerRequest;
94 const url = new URL(request.originalUrl);
95 const pathname = url.pathname;
96
97 if (request.method === "GET" && pathname === "/bindings") {
98 return yield* HttpServerResponse.json({
99 bound: Object.keys(bound),
100 });
101 }
102
103 // Endpoint-scoped read — the endpoint ID is injected.
104 if (request.method === "GET" && pathname === "/endpoint") {
105 const response = yield* bound.getResolverEndpoint();
106 return yield* HttpServerResponse.json({
107 status: response.ResolverEndpoint?.Status ?? "",
108 direction: response.ResolverEndpoint?.Direction ?? "",
109 ipAddressCount: response.ResolverEndpoint?.IpAddressCount ?? 0,
110 });
111 }
112
113 // Endpoint IP discovery — the endpoint ID is injected.
114 if (request.method === "GET" && pathname === "/endpoint/ips") {
115 const response = yield* bound.listResolverEndpointIpAddresses();
116 return yield* HttpServerResponse.json({
117 ips: (response.IpAddresses ?? []).map((ip) => ({
118 ip: ip.Ip ?? "",
119 status: ip.Status ?? "",
120 })),
121 });
122 }
123
124 // Rule-scoped read — the rule ID is injected.
125 if (request.method === "GET" && pathname === "/rule") {
126 const response = yield* bound.getResolverRule();
127 return yield* HttpServerResponse.json({
128 domainName: response.ResolverRule?.DomainName ?? "",
129 ruleType: response.ResolverRule?.RuleType ?? "",
130 targetIps: (response.ResolverRule?.TargetIps ?? []).map((t) => t.Ip ?? ""),
131 });
132 }
133
134 // Runtime failover: swap the rule's target IP.
135 if (request.method === "POST" && pathname === "/rule/target") {
136 const ip = url.searchParams.get("ip") ?? "";
137 const response = yield* bound.updateResolverRule({
138 Config: { TargetIps: [{ Ip: ip, Port: 53 }] },
139 });
140 return yield* HttpServerResponse.json({
141 status: response.ResolverRule?.Status ?? "",
142 targetIps: (response.ResolverRule?.TargetIps ?? []).map((t) => t.Ip ?? ""),
143 });
144 }
145
146 // Which VPCs is the rule live in? (filtered to the bound rule)
147 if (request.method === "GET" && pathname === "/rule/associations") {
148 const response = yield* bound.listResolverRuleAssociations();
149 return yield* HttpServerResponse.json({
150 count: (response.ResolverRuleAssociations ?? []).length,
151 });
152 }
153
154 return yield* HttpServerResponse.json(
155 { error: "Not found", method: request.method, pathname },
156 { status: 404 },
157 );
158 }).pipe(Effect.orDie),
159 };
160 }).pipe(
161 Effect.provide(
162 Layer.mergeAll(
163 Route53Resolver.GetResolverEndpointHttp,
164 Route53Resolver.ListResolverEndpointIpAddressesHttp,
165 Route53Resolver.GetResolverRuleHttp,
166 Route53Resolver.UpdateResolverRuleHttp,
167 Route53Resolver.ListResolverRuleAssociationsHttp,
168 ),
169 ),
170 ),
171 );