@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 356 lines 13.5 KB
Raw
1 import * as iotfleetwise from "@distilled.cloud/aws/iotfleetwise";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { isResolved } from "alchemy/Diff";
4 import { createPhysicalName } from "alchemy/PhysicalName";
5 import * as Provider from "alchemy/Provider";
6 import { Resource } from "alchemy/Resource";
7 import { createInternalTags, hasAlchemyTags } from "alchemy/Tags";
8 import * as Data from "effect/Data";
9 import * as Effect from "effect/Effect";
10 import * as Stream from "effect/Stream";
11 import type { Providers } from "../Providers.ts";
12 import {
13 inFleetWiseRegion,
14 readFleetWiseTags,
15 retryObservation,
16 retryWhileConflict,
17 stableEquals,
18 syncFleetWiseTags,
19 toFleetWiseTagList,
20 } from "./internal.ts";
21
22 export class DecoderManifestUnexpectedResponse extends Data.TaggedError(
23 "DecoderManifestUnexpectedResponse",
24 )<{
25 readonly message: string;
26 readonly cause?: unknown;
27 }> {}
28
29 export interface DecoderManifestProps {
30 /**
31 * Name of the decoder manifest. Must be 1-100 characters of
32 * `[a-zA-Z0-9:_-]`. If omitted, a deterministic physical name is
33 * generated. Changing the name replaces the manifest.
34 */
35 decoderManifestName?: string;
36 /**
37 * ARN of the {@link ModelManifest} the decoder manifest decodes signals
38 * for. Changing the model manifest replaces the decoder manifest.
39 */
40 modelManifestArn: string;
41 /**
42 * Human-readable description of the decoder manifest.
43 */
44 description?: string;
45 /**
46 * Network interfaces (CAN, OBD, vehicle middleware or custom decoding)
47 * the signal decoders reference, keyed by `interfaceId`. Updated in
48 * place via add/update/remove deltas (only while the manifest is in
49 * `DRAFT` status).
50 */
51 networkInterfaces?: iotfleetwise.NetworkInterface[];
52 /**
53 * Decoding rules mapping model-manifest signals onto network-interface
54 * messages, keyed by `fullyQualifiedName`. Updated in place via
55 * add/update/remove deltas (only while the manifest is in `DRAFT`
56 * status).
57 */
58 signalDecoders?: iotfleetwise.SignalDecoder[];
59 /**
60 * Use `"CUSTOM_DECODING"` to default any unmapped model-manifest signal
61 * to a custom decoding signal.
62 */
63 defaultForUnmappedSignals?: iotfleetwise.DefaultForUnmappedSignalsType;
64 /**
65 * Status of the manifest. Vehicles can only be created from an `ACTIVE`
66 * manifest; decoder/interface changes require `DRAFT`.
67 * @default "DRAFT"
68 */
69 status?: "ACTIVE" | "DRAFT";
70 /**
71 * User-defined tags for the decoder manifest.
72 */
73 tags?: Record<string, string>;
74 }
75
76 export interface DecoderManifest extends Resource<
77 "AWS.IoTFleetWise.DecoderManifest",
78 DecoderManifestProps,
79 {
80 /** The name of the decoder manifest. */
81 decoderManifestName: string;
82 /** The ARN of the decoder manifest. */
83 decoderManifestArn: string;
84 /** The current status of the manifest (`ACTIVE`, `DRAFT`, ...). */
85 status: string;
86 /** The model manifest the decoders map to. */
87 modelManifestArn: string | undefined;
88 },
89 never,
90 Providers
91 > {}
92
93 /**
94 * An AWS IoT FleetWise decoder manifest — the decoding rules (network
95 * interfaces + signal decoders) that turn raw bus data from a vehicle
96 * modeled by a {@link ModelManifest} into standardized signals.
97 *
98 * A manifest is created in `DRAFT` status; set `status: "ACTIVE"` to make
99 * it usable by vehicles. AWS IoT FleetWise is allowlist-gated and offered
100 * in `us-east-1`/`eu-central-1` only.
101 * ### Creating a Decoder Manifest
102 * **Example:** OBD Decoder for a Speed Signal
103 * ```typescript
104 * const decoder = yield* DecoderManifest("SedanDecoder", {
105 * modelManifestArn: model.modelManifestArn,
106 * networkInterfaces: [
107 * {
108 * interfaceId: "obd0",
109 * type: "OBD_INTERFACE",
110 * obdInterface: { name: "obd", requestMessageId: 2015 },
111 * },
112 * ],
113 * signalDecoders: [
114 * {
115 * fullyQualifiedName: "Vehicle.Speed",
116 * type: "OBD_SIGNAL",
117 * interfaceId: "obd0",
118 * obdSignal: {
119 * pidResponseLength: 1,
120 * serviceMode: 1,
121 * pid: 13,
122 * scaling: 1,
123 * offset: 0,
124 * startByte: 0,
125 * byteLength: 1,
126 * },
127 * },
128 * ],
129 * status: "ACTIVE",
130 * });
131 * ```
132 *
133 * @resource
134 */
135 export const DecoderManifest = Resource<DecoderManifest>("AWS.IoTFleetWise.DecoderManifest");
136
137 export const DecoderManifestProvider = () =>
138 Provider.effect(
139 DecoderManifest,
140 Effect.gen(function* () {
141 const toName = (id: string, props: { decoderManifestName?: string }) =>
142 props.decoderManifestName
143 ? Effect.succeed(props.decoderManifestName)
144 : createPhysicalName({ id, maxLength: 100 });
145
146 const readManifest = Effect.fn(function* (name: string) {
147 return yield* iotfleetwise.getDecoderManifest({ name }).pipe(
148 inFleetWiseRegion,
149 Effect.catchTag("ResourceNotFoundException", () => Effect.undefined),
150 );
151 });
152
153 const observeAfterWrite = Effect.fn(function* (name: string) {
154 return yield* readManifest(name).pipe(
155 Effect.flatMap((manifest) =>
156 manifest === undefined
157 ? Effect.fail(
158 new DecoderManifestUnexpectedResponse({
159 message: `Decoder manifest '${name}' not found`,
160 }),
161 )
162 : Effect.succeed(manifest),
163 ),
164 retryObservation,
165 );
166 });
167
168 const readInterfaces = Effect.fn(function* (name: string) {
169 return yield* iotfleetwise.listDecoderManifestNetworkInterfaces.items({ name }).pipe(
170 Stream.runCollect,
171 Effect.map((chunk) => Array.from(chunk)),
172 inFleetWiseRegion,
173 );
174 });
175
176 const readDecoders = Effect.fn(function* (name: string) {
177 return yield* iotfleetwise.listDecoderManifestSignals.items({ name }).pipe(
178 Stream.runCollect,
179 Effect.map((chunk) => Array.from(chunk)),
180 inFleetWiseRegion,
181 );
182 });
183
184 const toAttrs = (manifest: iotfleetwise.GetDecoderManifestResponse) => ({
185 decoderManifestName: manifest.name,
186 decoderManifestArn: manifest.arn,
187 status: manifest.status ?? "DRAFT",
188 modelManifestArn: manifest.modelManifestArn,
189 });
190
191 return {
192 stables: ["decoderManifestName", "decoderManifestArn"],
193
194 diff: Effect.fn(function* ({ id, olds, news }) {
195 if (!isResolved(news)) return undefined;
196 if ((yield* toName(id, olds)) !== (yield* toName(id, news))) {
197 return { action: "replace" } as const;
198 }
199 // The update API cannot change the model manifest.
200 if (news.modelManifestArn !== olds.modelManifestArn) {
201 return { action: "replace" } as const;
202 }
203 }),
204
205 read: Effect.fn(function* ({ id, olds, output }) {
206 const name = output?.decoderManifestName ?? (yield* toName(id, olds ?? {}));
207 const found = yield* readManifest(name);
208 if (found === undefined) return undefined;
209 const attrs = toAttrs(found);
210 const tags = yield* readFleetWiseTags(found.arn);
211 return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
212 }),
213
214 reconcile: Effect.fn(function* ({ id, news, output, session }) {
215 const name = output?.decoderManifestName ?? (yield* toName(id, news));
216 const internalTags = yield* createInternalTags(id);
217 const desiredTags = { ...internalTags, ...news.tags };
218 const desiredStatus = news.status ?? "DRAFT";
219 const desiredInterfaces = news.networkInterfaces ?? [];
220 const desiredDecoders = news.signalDecoders ?? [];
221
222 // 1. Observe — cloud state is authoritative.
223 let observed = yield* readManifest(name);
224
225 // 2. Ensure — create if missing; tolerate the AlreadyExists race.
226 if (observed === undefined) {
227 yield* iotfleetwise
228 .createDecoderManifest({
229 name,
230 modelManifestArn: news.modelManifestArn,
231 description: news.description,
232 networkInterfaces: desiredInterfaces.length > 0 ? desiredInterfaces : undefined,
233 signalDecoders: desiredDecoders.length > 0 ? desiredDecoders : undefined,
234 defaultForUnmappedSignals: news.defaultForUnmappedSignals,
235 tags: toFleetWiseTagList(desiredTags),
236 })
237 .pipe(
238 inFleetWiseRegion,
239 Effect.catchTag("ConflictException", () => Effect.void),
240 );
241 observed = yield* observeAfterWrite(name);
242 }
243
244 // 3. Sync interfaces + decoders + description — diff OBSERVED
245 // lists against desired, keyed by interfaceId /
246 // fullyQualifiedName. Structural changes require DRAFT status,
247 // so they run before any DRAFT -> ACTIVE transition.
248 const observedInterfaces = yield* readInterfaces(name);
249 const observedDecoders = yield* readDecoders(name);
250 const observedInterfaceById = new Map(observedInterfaces.map((i) => [i.interfaceId, i]));
251 const desiredInterfaceById = new Map(desiredInterfaces.map((i) => [i.interfaceId, i]));
252 const observedDecoderByFqn = new Map(
253 observedDecoders.map((d) => [d.fullyQualifiedName, d]),
254 );
255 const desiredDecoderByFqn = new Map(
256 desiredDecoders.map((d) => [d.fullyQualifiedName, d]),
257 );
258
259 const interfacesToAdd = desiredInterfaces.filter(
260 (i) => !observedInterfaceById.has(i.interfaceId),
261 );
262 const interfacesToUpdate = desiredInterfaces.filter((i) => {
263 const current = observedInterfaceById.get(i.interfaceId);
264 return current !== undefined && !stableEquals(current, i);
265 });
266 const interfacesToRemove = observedInterfaces
267 .map((i) => i.interfaceId)
268 .filter((id_) => !desiredInterfaceById.has(id_));
269 const decodersToAdd = desiredDecoders.filter(
270 (d) => !observedDecoderByFqn.has(d.fullyQualifiedName),
271 );
272 const decodersToUpdate = desiredDecoders.filter((d) => {
273 const current = observedDecoderByFqn.get(d.fullyQualifiedName);
274 return current !== undefined && !stableEquals(current, d);
275 });
276 const decodersToRemove = observedDecoders
277 .map((d) => d.fullyQualifiedName)
278 .filter((fqn) => !desiredDecoderByFqn.has(fqn));
279 const descriptionChanged =
280 news.description !== undefined && news.description !== observed.description;
281
282 if (
283 interfacesToAdd.length > 0 ||
284 interfacesToUpdate.length > 0 ||
285 interfacesToRemove.length > 0 ||
286 decodersToAdd.length > 0 ||
287 decodersToUpdate.length > 0 ||
288 decodersToRemove.length > 0 ||
289 descriptionChanged
290 ) {
291 yield* iotfleetwise
292 .updateDecoderManifest({
293 name,
294 description: descriptionChanged ? news.description : undefined,
295 networkInterfacesToAdd: interfacesToAdd.length > 0 ? interfacesToAdd : undefined,
296 networkInterfacesToUpdate:
297 interfacesToUpdate.length > 0 ? interfacesToUpdate : undefined,
298 networkInterfacesToRemove:
299 interfacesToRemove.length > 0 ? interfacesToRemove : undefined,
300 signalDecodersToAdd: decodersToAdd.length > 0 ? decodersToAdd : undefined,
301 signalDecodersToUpdate: decodersToUpdate.length > 0 ? decodersToUpdate : undefined,
302 signalDecodersToRemove: decodersToRemove.length > 0 ? decodersToRemove : undefined,
303 defaultForUnmappedSignals: news.defaultForUnmappedSignals,
304 })
305 .pipe(inFleetWiseRegion);
306 observed = yield* observeAfterWrite(name);
307 }
308
309 // 3b. Sync status (e.g. activate a draft).
310 if ((observed.status ?? "DRAFT") !== desiredStatus) {
311 yield* iotfleetwise
312 .updateDecoderManifest({ name, status: desiredStatus })
313 .pipe(inFleetWiseRegion);
314 observed = yield* observeAfterWrite(name);
315 }
316
317 // 3c. Sync tags against OBSERVED cloud tags.
318 yield* syncFleetWiseTags(observed.arn, desiredTags);
319
320 yield* session.note(name);
321 return toAttrs(observed);
322 }),
323
324 delete: Effect.fn(function* ({ output }) {
325 // Idempotent: deleting a missing manifest succeeds. Vehicles
326 // still detaching surface as ConflictException — retry through
327 // the window (bounded).
328 yield* iotfleetwise.deleteDecoderManifest({ name: output.decoderManifestName }).pipe(
329 inFleetWiseRegion,
330 retryWhileConflict,
331 Effect.catchTag("ConflictException", () => Effect.void),
332 );
333 }),
334
335 list: () =>
336 iotfleetwise.listDecoderManifests.items({}).pipe(
337 Stream.runCollect,
338 Effect.map((chunk) =>
339 Array.from(chunk).flatMap((summary) =>
340 summary.name !== undefined && summary.arn !== undefined
341 ? [
342 {
343 decoderManifestName: summary.name,
344 decoderManifestArn: summary.arn,
345 status: summary.status ?? "DRAFT",
346 modelManifestArn: summary.modelManifestArn,
347 },
348 ]
349 : [],
350 ),
351 ),
352 inFleetWiseRegion,
353 ),
354 };
355 }),
356 );