@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 104 lines 3.68 KB
Raw
1 import { encodeFqn } from "alchemy/FQN";
2 import { localState } from "alchemy/State/LocalState";
3 import * as Deferred from "effect/Deferred";
4 import * as Effect from "effect/Effect";
5 import * as FileSystem from "effect/FileSystem";
6 import * as Layer from "effect/Layer";
7 import * as Path from "effect/Path";
8 import * as PlatformError from "effect/PlatformError";
9 import * as Schema from "effect/Schema";
10
11 /** Only nonsecret row identity and lifecycle fields leave the filesystem barrier. */
12 export const ResourceRow = Schema.Struct({
13 resourceType: Schema.String,
14 fqn: Schema.String,
15 instanceId: Schema.String,
16 status: Schema.String,
17 attr: Schema.optional(
18 Schema.Struct({
19 appName: Schema.String,
20 machineId: Schema.String,
21 machineIds: Schema.Array(Schema.String),
22 rolloutPending: Schema.optional(Schema.Boolean),
23 }),
24 ),
25 });
26
27 type ResourceRow = typeof ResourceRow.Type;
28
29 /** Delay one final resource-row rename; all filesystem operations remain real. */
30 export const delayedResourceWrite = (target: { stack: string; stage: string; fqn: string }) =>
31 Effect.gen(function* () {
32 const fs = yield* FileSystem.FileSystem;
33 const path = yield* Path.Path;
34 const held = yield* Deferred.make<ResourceRow>();
35 const released = yield* Deferred.make<void>();
36 const written = yield* Deferred.make<ResourceRow>();
37 const suffix = path.join(
38 ".alchemy",
39 "state",
40 target.stack,
41 target.stage,
42 `${encodeFqn(target.fqn)}.json`,
43 );
44 let intercepted = false;
45 const forwarded: FileSystem.FileSystem = {
46 ...fs,
47 rename: (from, to) =>
48 Effect.gen(function* () {
49 if (
50 !intercepted &&
51 to.endsWith(`${path.sep}${suffix}`) &&
52 from.startsWith(`${to}.`) &&
53 from.endsWith(".tmp")
54 ) {
55 const row = yield* fs.readFileString(from).pipe(
56 Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(ResourceRow))),
57 Effect.catchTag("SchemaError", () =>
58 Effect.fail(
59 PlatformError.badArgument({
60 module: "FileSystem",
61 method: "rename",
62 description: "Invalid delayed resource-row identity",
63 }),
64 ),
65 ),
66 );
67 if (
68 row.resourceType === "Fly.Machine" &&
69 row.fqn === target.fqn &&
70 row.status === "updated" &&
71 row.attr !== undefined
72 ) {
73 yield* Effect.sync(() => {
74 intercepted = true;
75 });
76 yield* Deferred.succeed(held, row);
77 yield* Deferred.await(released).pipe(
78 Effect.timeout("600 seconds"),
79 Effect.catchTag("TimeoutError", () =>
80 Effect.fail(
81 PlatformError.systemError({
82 _tag: "TimedOut",
83 module: "FileSystem",
84 method: "rename",
85 description: "Delayed resource-row release exceeded 600 seconds",
86 }),
87 ),
88 ),
89 );
90 yield* fs.rename(from, to);
91 yield* Deferred.succeed(written, row);
92 return;
93 }
94 }
95 yield* fs.rename(from, to);
96 }),
97 };
98 return {
99 state: localState().pipe(Layer.provide(Layer.succeed(FileSystem.FileSystem, forwarded))),
100 wait: Deferred.await(held).pipe(Effect.timeout("600 seconds")),
101 release: Deferred.succeed(released, undefined).pipe(Effect.asVoid),
102 written: Deferred.await(written).pipe(Effect.timeout("600 seconds")),
103 };
104 });