@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 276 lines 10.8 KB
Raw
1 import * as iam from "@distilled.cloud/aws/iam";
2 import { isResolved } from "alchemy/Diff";
3 import * as Provider from "alchemy/Provider";
4 import { Resource } from "alchemy/Resource";
5 import { toWireDays } from "alchemy/Util/Duration";
6 import * as Data from "effect/Data";
7 import type * as Duration from "effect/Duration";
8 import * as Effect from "effect/Effect";
9 import * as Redacted from "effect/Redacted";
10 import * as Stream from "effect/Stream";
11 import type { Providers } from "../Providers.ts";
12 import { toRedactedString } from "./common.ts";
13
14 export class ServiceSpecificCredentialUnexpectedResponse extends Data.TaggedError(
15 "ServiceSpecificCredentialUnexpectedResponse",
16 )<{
17 readonly message: string;
18 readonly cause?: unknown;
19 }> {}
20
21 export interface ServiceSpecificCredentialProps {
22 /**
23 * User that owns the service-specific credential.
24 */
25 userName: string;
26 /**
27 * AWS service name that will consume the credential.
28 */
29 serviceName: string;
30 /**
31 * Optional credential validity duration, e.g. `"30 days"` or
32 * `Duration.days(30)`. Sent to IAM as whole days (a bare number is
33 * milliseconds). Changing it replaces the credential.
34 */
35 credentialAge?: Duration.Input;
36 /**
37 * Desired credential status.
38 * @default "Active"
39 */
40 status?: iam.StatusType;
41 }
42
43 export interface ServiceSpecificCredential extends Resource<
44 "AWS.IAM.ServiceSpecificCredential",
45 ServiceSpecificCredentialProps,
46 {
47 /** The IAM user the credential belongs to. */
48 userName: string;
49 /** The AWS service the credential is scoped to (e.g. `codecommit.amazonaws.com`). */
50 serviceName: string;
51 /** The unique ID of the credential. */
52 serviceSpecificCredentialId: string;
53 /** Whether the credential is `Active` or `Inactive`. */
54 status: iam.StatusType;
55 /** When the credential was created. */
56 createDate: Date | undefined;
57 /** When the credential expires, if an age was configured. */
58 expirationDate: Date | undefined;
59 /** The generated service-specific user name. */
60 serviceUserName: string | undefined;
61 /** The generated credential alias, if the service issues one. */
62 serviceCredentialAlias: string | undefined;
63 /** The generated password. AWS only returns it at creation; later reads preserve the originally stored redacted value. */
64 servicePassword: Redacted.Redacted<string> | undefined;
65 /** The generated secret. AWS only returns it at creation; later reads preserve the originally stored redacted value. */
66 serviceCredentialSecret: Redacted.Redacted<string> | undefined;
67 },
68 never,
69 Providers
70 > {}
71
72 /**
73 * A service-specific IAM credential.
74 *
75 * `ServiceSpecificCredential` creates service-bound credentials such as
76 * CodeCommit HTTPS passwords for an IAM user. AWS only returns the secret
77 * fields during creation, so subsequent reads preserve the originally stored
78 * redacted values.
79 * ### Managing Service Credentials
80 * **Example:** Create a CodeCommit Credential
81 * ```typescript
82 * const user = yield* User("CodeCommitUser", {
83 * userName: "codecommit-user",
84 * });
85 *
86 * const credential = yield* ServiceSpecificCredential("CodeCommitCredential", {
87 * userName: user.userName,
88 * serviceName: "codecommit.amazonaws.com",
89 * });
90 * ```
91 *
92 * @resource
93 */
94 export const ServiceSpecificCredential = Resource<ServiceSpecificCredential>(
95 "AWS.IAM.ServiceSpecificCredential",
96 );
97
98 export const ServiceSpecificCredentialProvider = () =>
99 Provider.succeed(ServiceSpecificCredential, {
100 stables: ["serviceSpecificCredentialId"],
101 list: Effect.fn(function* () {
102 // Service-specific credentials are owned per IAM user and IAM is a
103 // global service, so enumerate every user in the account
104 // (`listUsers`) and fan out `listServiceSpecificCredentials` per user
105 // (bounded concurrency). Omit `ServiceName` to capture credentials
106 // across all services. The credential secret is only returned at
107 // creation, so list cannot recover it — match `read` and leave the
108 // redacted secret fields undefined.
109 const users = yield* iam.listUsers.pages({}).pipe(
110 Stream.runCollect,
111 Effect.map((chunk) => Array.from(chunk).flatMap((page) => page.Users)),
112 );
113 const perUser = yield* Effect.forEach(
114 users,
115 (user) =>
116 iam.listServiceSpecificCredentials({ UserName: user.UserName }).pipe(
117 Effect.map((response) =>
118 (response.ServiceSpecificCredentials ?? []).map((metadata) => ({
119 userName: metadata.UserName,
120 serviceName: metadata.ServiceName,
121 serviceSpecificCredentialId: metadata.ServiceSpecificCredentialId,
122 status: metadata.Status,
123 createDate: metadata.CreateDate,
124 expirationDate: metadata.ExpirationDate,
125 serviceUserName: metadata.ServiceUserName,
126 serviceCredentialAlias: metadata.ServiceCredentialAlias,
127 servicePassword: undefined,
128 serviceCredentialSecret: undefined,
129 })),
130 ),
131 // The user may be deleted between enumeration and per-user list.
132 Effect.catchTag("NoSuchEntityException", () => Effect.succeed([])),
133 ),
134 { concurrency: 10 },
135 );
136 return perUser.flat();
137 }),
138 diff: Effect.fn(function* ({ olds, news }) {
139 if (!isResolved(news)) return;
140 if (
141 olds.userName !== news.userName ||
142 olds.serviceName !== news.serviceName ||
143 toWireDays(olds.credentialAge) !== toWireDays(news.credentialAge)
144 ) {
145 return { action: "replace" } as const;
146 }
147 }),
148 read: Effect.fn(function* ({ output }) {
149 if (!output) {
150 return undefined;
151 }
152 const listed = yield* iam.listServiceSpecificCredentials({
153 UserName: output.userName,
154 ServiceName: output.serviceName,
155 });
156 const metadata = listed.ServiceSpecificCredentials?.find(
157 (entry) => entry.ServiceSpecificCredentialId === output.serviceSpecificCredentialId,
158 );
159 if (!metadata?.ServiceSpecificCredentialId) {
160 return undefined;
161 }
162 return {
163 userName: metadata.UserName,
164 serviceName: metadata.ServiceName,
165 serviceSpecificCredentialId: metadata.ServiceSpecificCredentialId,
166 status: metadata.Status,
167 createDate: metadata.CreateDate,
168 expirationDate: metadata.ExpirationDate,
169 serviceUserName: metadata.ServiceUserName,
170 serviceCredentialAlias: metadata.ServiceCredentialAlias,
171 servicePassword: output.servicePassword,
172 serviceCredentialSecret: output.serviceCredentialSecret,
173 };
174 }),
175 reconcile: Effect.fn(function* ({ news, output, session }) {
176 // Observe — credential ids are AWS-generated; we can only locate
177 // the existing record via the prior output. The credential's
178 // identity (userName, serviceName, age) is immutable (`diff`
179 // triggers replacement on change), so a missing credential always
180 // requires recreation.
181 const observed = output
182 ? yield* iam
183 .listServiceSpecificCredentials({
184 UserName: output.userName,
185 ServiceName: output.serviceName,
186 })
187 .pipe(
188 Effect.map((r) =>
189 r.ServiceSpecificCredentials?.find(
190 (entry) =>
191 entry.ServiceSpecificCredentialId === output.serviceSpecificCredentialId,
192 ),
193 ),
194 Effect.catchTag("NoSuchEntityException", () => Effect.undefined),
195 )
196 : undefined;
197
198 // Ensure — create when missing. The secret fields are only
199 // returned on first creation, so adoption preserves the prior
200 // redacted values.
201 let credentialId =
202 observed?.ServiceSpecificCredentialId ?? output?.serviceSpecificCredentialId;
203 let userName = observed?.UserName ?? output?.userName ?? news.userName;
204 let serviceName = observed?.ServiceName ?? output?.serviceName ?? news.serviceName;
205 let createDate = observed?.CreateDate ?? output?.createDate;
206 let expirationDate = observed?.ExpirationDate ?? output?.expirationDate;
207 let serviceUserName = observed?.ServiceUserName ?? output?.serviceUserName;
208 let serviceCredentialAlias =
209 observed?.ServiceCredentialAlias ?? output?.serviceCredentialAlias;
210 let servicePassword = output?.servicePassword;
211 let serviceCredentialSecret = output?.serviceCredentialSecret;
212 let observedStatus = observed?.Status ?? output?.status;
213
214 if (!observed) {
215 const created = yield* iam.createServiceSpecificCredential({
216 UserName: news.userName,
217 ServiceName: news.serviceName,
218 CredentialAgeDays: toWireDays(news.credentialAge),
219 });
220 const credential = created.ServiceSpecificCredential;
221 if (!credential?.ServiceSpecificCredentialId) {
222 return yield* new ServiceSpecificCredentialUnexpectedResponse({
223 message: `createServiceSpecificCredential returned no credential id`,
224 });
225 }
226 credentialId = credential.ServiceSpecificCredentialId;
227 userName = credential.UserName;
228 serviceName = credential.ServiceName;
229 createDate = credential.CreateDate;
230 expirationDate = credential.ExpirationDate;
231 serviceUserName = credential.ServiceUserName;
232 serviceCredentialAlias = credential.ServiceCredentialAlias;
233 servicePassword = toRedactedString(credential.ServicePassword);
234 serviceCredentialSecret = toRedactedString(credential.ServiceCredentialSecret);
235 observedStatus = credential.Status;
236 }
237
238 if (!credentialId) {
239 return yield* new ServiceSpecificCredentialUnexpectedResponse({
240 message: `ServiceSpecificCredential for user '${news.userName}' has no id`,
241 });
242 }
243
244 // Sync — apply the desired status when it differs from observed.
245 const desiredStatus = news.status ?? observedStatus ?? "Active";
246 if (desiredStatus !== observedStatus) {
247 yield* iam.updateServiceSpecificCredential({
248 UserName: userName,
249 ServiceSpecificCredentialId: credentialId,
250 Status: desiredStatus,
251 });
252 }
253
254 yield* session.note(credentialId);
255 return {
256 userName,
257 serviceName,
258 serviceSpecificCredentialId: credentialId,
259 status: desiredStatus,
260 createDate,
261 expirationDate,
262 serviceUserName,
263 serviceCredentialAlias,
264 servicePassword,
265 serviceCredentialSecret,
266 };
267 }),
268 delete: Effect.fn(function* ({ output }) {
269 yield* iam
270 .deleteServiceSpecificCredential({
271 UserName: output.userName,
272 ServiceSpecificCredentialId: output.serviceSpecificCredentialId,
273 })
274 .pipe(Effect.catchTag("NoSuchEntityException", () => Effect.void));
275 }),
276 });