@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 155 lines 5.24 KB
Raw
1 import { CredentialsStoreLive } from "alchemy/Auth/Credentials";
2 import { ProfileStoreLive } from "alchemy/Auth/Profile";
3 import * as Command from "alchemy/Command";
4 import * as Provider from "alchemy/Provider";
5 import { Random, RandomProvider } from "alchemy/Random";
6 import {
7 Server as WebsiteServer,
8 ServerProvider as WebsiteServerProvider,
9 } from "alchemy/Website/Server";
10 import * as FetchHttpClient from "effect/http/FetchHttpClient";
11 import * as Layer from "effect/Layer";
12 import { App, AppProvider } from "./App.ts";
13 import { FlyAuth } from "./AuthProvider.ts";
14 import { Bucket, BucketProvider } from "./Bucket.ts";
15 import { Certificate, CertificateProvider } from "./Certificate.ts";
16 import { CheckpointHttp } from "./CheckpointHttp.ts";
17 import { ConnectPostgresHttp } from "./ConnectPostgresHttp.ts";
18 import * as Credentials from "./Credentials.ts";
19 import { DecryptHttp } from "./DecryptHttp.ts";
20 import { DeleteObjectHttp } from "./DeleteObjectHttp.ts";
21 import { EncryptHttp } from "./EncryptHttp.ts";
22 import { fromCredentials } from "./Environment.ts";
23 import { ExecHttp } from "./ExecHttp.ts";
24 import { GetObjectHttp } from "./GetObjectHttp.ts";
25 import { GetSecretHttp } from "./GetSecretHttp.ts";
26 import { HeadObjectHttp } from "./HeadObjectHttp.ts";
27 import { IpAssignment, IpAssignmentProvider } from "./IpAssignment.ts";
28 import { ListObjectsV2Http } from "./ListObjectsV2Http.ts";
29 import { ListSecretsHttp } from "./ListSecretsHttp.ts";
30 import { Machine, MachineProvider } from "./Machine.ts";
31 import { MountVolumeLive } from "./MountVolume.ts";
32 import { Postgres, PostgresProvider } from "./Postgres.ts";
33 import { PutObjectHttp } from "./PutObjectHttp.ts";
34 import { ReadRedisHttp } from "./ReadRedisHttp.ts";
35 import { ReadWriteRedisHttp } from "./ReadWriteRedisHttp.ts";
36 import { Redis, RedisProvider } from "./Redis.ts";
37 import { Secret, SecretProvider } from "./Secret.ts";
38 import { SecretKey, SecretKeyProvider } from "./SecretKey.ts";
39 import { Service, ServiceProvider } from "./Service.ts";
40 import { SignHttp } from "./SignHttp.ts";
41 import { Sprite, SpriteProvider } from "./Sprite.ts";
42 import { VerifyHttp } from "./VerifyHttp.ts";
43 import { VolumeSnapshot, VolumeSnapshotProvider } from "./VolumeSnapshot.ts";
44 import { AssetDeployment, AssetDeploymentProvider } from "./Website/AssetDeployment.ts";
45 import { WriteCertificatesHttp } from "./WriteCertificatesHttp.ts";
46 import { WriteRedisHttp } from "./WriteRedisHttp.ts";
47 import { WriteSecretHttp } from "./WriteSecretHttp.ts";
48
49 export class Providers extends Provider.ProviderCollection<Providers>()("Fly") {}
50
51 export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
52
53 /**
54 * Build a layer that registers Fly resource providers, the Fly
55 * `AuthProvider`, the resolved `Credentials`, and an `HttpClient`. Include
56 * this from your stack alongside other cloud `providers()` layers.
57 *
58 * Resource providers are inserted into {@link Provider.collection} as they
59 * land. The collection starts empty so App / Machine / Service agents can
60 * make a single minimal insertion.
61 *
62 * @example
63 * ```typescript
64 * import * as Alchemy from "alchemy";
65 * import * as Fly from "@alchemy.run/fly";
66 * import * as Effect from "effect/Effect";
67 *
68 * export default Alchemy.Stack(
69 * "MyStack",
70 * {
71 * providers: Fly.providers(),
72 * state: Alchemy.localState(),
73 * },
74 * Effect.gen(function* () {
75 * return {};
76 * }),
77 * );
78 * ```
79 */
80 export const providers = () =>
81 Layer.effect(
82 Providers,
83 Provider.collection([
84 App,
85 AssetDeployment,
86 Bucket,
87 Certificate,
88 IpAssignment,
89 Machine,
90 Postgres,
91 Random,
92 Redis,
93 Secret,
94 SecretKey,
95 Service,
96 Sprite,
97 VolumeSnapshot,
98 WebsiteServer,
99 ]),
100 ).pipe(
101 Layer.provide(
102 Layer.mergeAll(
103 AppProvider(),
104 AssetDeploymentProvider(),
105 BucketProvider(),
106 CertificateProvider(),
107 IpAssignmentProvider(),
108 MachineProvider(),
109 PostgresProvider(),
110 RandomProvider(),
111 RedisProvider(),
112 SecretProvider(),
113 SecretKeyProvider(),
114 ServiceProvider(),
115 SpriteProvider(),
116 VolumeSnapshotProvider(),
117 WebsiteServerProvider(),
118 ),
119 ),
120 // The binding layers are mutually independent — they all draw on the
121 // Credentials/HttpClient layers below. Merge them into one group so
122 // `.pipe` stays under its 20-argument overload ceiling.
123 Layer.provideMerge(
124 Layer.mergeAll(
125 MountVolumeLive,
126 ConnectPostgresHttp,
127 PutObjectHttp,
128 GetObjectHttp,
129 DeleteObjectHttp,
130 HeadObjectHttp,
131 ListObjectsV2Http,
132 ReadRedisHttp,
133 WriteRedisHttp,
134 ReadWriteRedisHttp,
135 CheckpointHttp,
136 ExecHttp,
137 GetSecretHttp,
138 ListSecretsHttp,
139 WriteSecretHttp,
140 WriteCertificatesHttp,
141 EncryptHttp,
142 DecryptHttp,
143 SignHttp,
144 VerifyHttp,
145 ),
146 ),
147 Layer.provideMerge(fromCredentials()),
148 Layer.provideMerge(Credentials.fromAuthProvider()),
149 Layer.provideMerge(FlyAuth),
150 Layer.provideMerge(ProfileStoreLive),
151 Layer.provideMerge(CredentialsStoreLive),
152 Layer.provideMerge(FetchHttpClient.layer),
153 Layer.provideMerge(Command.providers()),
154 Layer.orDie,
155 );