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

main
ts 145 lines 5.41 KB
Raw
1 import * as Context from "effect/Context";
2 import * as Effect from "effect/Effect";
3 import type * as Scope from "effect/Scope";
4 import { SERVICE_USER_WORKER } from "./internal/constants.ts";
5 import type * as Plugin from "./Plugin.ts";
6 import type { RuntimeError } from "./RuntimeError.shared.ts";
7 import { ConfigError } from "./RuntimeError.shared.ts";
8 import type { RuntimeWorker } from "./RuntimeWorker.ts";
9 import type * as WorkerdConfig from "./workerd/Config.ts";
10 import type * as Workerd from "./workerd/Workerd.ts";
11
12 export class PluginContext extends Context.Service<
13 PluginContext,
14 {
15 readonly worker: RuntimeWorker;
16 readonly plugins: ReadonlyMap<
17 string,
18 Plugin.Plugin<any> | Effect.Effect<Plugin.Plugin<any>, never, PluginContext>
19 >;
20 readonly get: <Self, Identifier extends Plugin.PluginIdentifier, Api>(
21 service: Plugin.PluginService<Self, Identifier, Api>,
22 ) => Effect.Effect<Plugin.Plugin<Api>, ConfigError>;
23 readonly start: (ports: Workerd.WorkerdPorts) => Effect.Effect<void, RuntimeError, Scope.Scope>;
24 readonly config: Effect.Effect<
25 {
26 entry: string | undefined;
27 sockets: Array<WorkerdConfig.Socket>;
28 services: Array<WorkerdConfig.Service>;
29 extensions: Array<WorkerdConfig.Extension>;
30 userWorker: Partial<WorkerdConfig.Worker>;
31 },
32 RuntimeError
33 >;
34 }
35 >()("cloudflare-runtime/PluginContext") {}
36
37 export type ConfigHook<A, E, R> = Effect.Effect<A, E | ConfigError, R | PluginContext>;
38 export type BindingHook<R = never> = ConfigHook<WorkerdConfig.Worker_Binding, never, R>;
39
40 export const make = (
41 worker: RuntimeWorker,
42 inheritedPlugins?: PluginMap,
43 ): Effect.Effect<PluginContext["Service"], RuntimeError> =>
44 Effect.gen(function* () {
45 const plugins = new Map<string, Plugin.Plugin<any>>();
46 const context = PluginContext.of({
47 worker,
48 plugins,
49 config: Effect.gen(function* () {
50 const configs = yield* Effect.forEach(
51 plugins.values(),
52 (plugin) =>
53 Effect.isEffect(plugin.defer)
54 ? plugin.defer.pipe(
55 Effect.map((config) => ({ ...plugin, ...config })),
56 Effect.provideService(PluginContext, context),
57 )
58 : Effect.succeed(plugin),
59 { concurrency: "unbounded" },
60 );
61 const services = configs.flatMap((config) => config.services ?? []);
62 const sockets = configs.flatMap((config) => config.sockets ?? []);
63 const extensions = configs.flatMap((config) => config.extensions ?? []);
64 const userWorker = Object.assign({}, ...configs.map((config) => config.userWorker ?? {}));
65 const middlewares = configs
66 .flatMap((config) => config.middlewares ?? [])
67 .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
68 return {
69 entry: middlewares[0]?.name,
70 sockets,
71 extensions,
72 userWorker,
73 services: [
74 ...services,
75 ...middlewares.map((middleware, index) => ({
76 name: middleware.name,
77 worker: {
78 ...middleware.worker,
79 bindings: [
80 ...(middleware.worker.bindings ?? []),
81 {
82 name: middleware.upstreamBindingName,
83 service: {
84 name:
85 index < middlewares.length - 1
86 ? middlewares[index + 1].name
87 : SERVICE_USER_WORKER,
88 },
89 },
90 ],
91 },
92 })),
93 ],
94 };
95 }),
96 start: Effect.fn(function* (ports) {
97 yield* Effect.forEach(plugins.values(), (plugin) => plugin.start?.(ports) ?? Effect.void);
98 }),
99 get: Effect.fn(function* (service) {
100 const plugin = plugins.get(service.key);
101 if (!plugin) {
102 return yield* ConfigError.make({
103 subtag: "PluginNotFound",
104 message: `Plugin "${service.key}" not found`,
105 hint: `The plugin "${service.key}" is not registered in the current context.`,
106 detail: {
107 name: service.key,
108 },
109 });
110 }
111 return plugin;
112 }),
113 });
114 const pluginMap: PluginMap = inheritedPlugins ?? new Map();
115 const pluginsFromContext = yield* pickPluginsFromContext();
116 for (const [key, builder] of pluginsFromContext.entries()) {
117 pluginMap.set(key, builder);
118 }
119 yield* Effect.forEach(pluginMap.entries(), ([key, builder]) =>
120 Effect.gen(function* () {
121 const plugin = Effect.isEffect(builder)
122 ? yield* builder.pipe(Effect.provideService(PluginContext, context))
123 : builder;
124 plugins.set(key, plugin);
125 }),
126 );
127 return context;
128 });
129
130 export type PluginMap = Map<Plugin.PluginIdentifier<string>, Plugin.PluginBuilder<any>>;
131
132 export const pickPluginsFromContext = <R = never>() =>
133 Effect.context<R>().pipe(
134 Effect.map((context): PluginMap => new Map(context.mapUnsafe.entries().filter(isPlugin))),
135 );
136
137 const isPlugin = <Identifier extends string>(
138 entry: [string, any],
139 ): entry is [Plugin.PluginIdentifier<Identifier>, Plugin.PluginBuilder<any>] =>
140 entry[0].startsWith("cloudflare-runtime/plugin/");
141
142 export const use = Effect.fn("PluginContext.use")(PluginContext.use.bind(PluginContext));
143 export const useSync = Effect.fn("PluginContext.useSync")(
144 PluginContext.useSync.bind(PluginContext),
145 );