Unified · Split
| @@ -1,4 +1,4 @@ | ||
| 1 | 1 | #!/usr/bin/env bash |
| 2 | 2 | set -euo pipefail |
| 3 | 3 | SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" |
| 4 | −exec bun "$SCRIPT_DIR/../src/main.ts" "$@" | |
| 4 | +exec bun "$SCRIPT_DIR/../src/cli/main.ts" "$@" | |
| @@ -9,7 +9,7 @@ · 8 unmodified lines | ||
| 9 | 9 | "typecheck": "bunx tsc --noEmit -p tsconfig.json", |
| 10 | 10 | "test": "vitest run", |
| 11 | 11 | "test:watch": "vitest", |
| 12 | − "start": "bun src/main.ts" | |
| 12 | + "start": "bun src/cli/main.ts" | |
| 13 | 13 | }, |
| 14 | 14 | "dependencies": { |
| 15 | 15 | "@effect/cli": "catalog:", |
| @@ -17,6 +17,7 @@ · 1 unmodified line | ||
| 17 | 17 | "@effect/platform-node": "catalog:", |
| 18 | 18 | "@executor-v3/codemode-core": "workspace:*", |
| 19 | 19 | "@executor-v3/codemode-mcp": "workspace:*", |
| 20 | + "@executor-v3/codemode-openapi": "workspace:*", | |
| 20 | 21 | "@executor-v3/control-plane": "workspace:*", |
| 21 | 22 | "@executor-v3/runtime-local-inproc": "workspace:*", |
| 22 | 23 | "effect": "catalog:" |
| @@ -0,0 +1,200 @@ | ||
| 1 | +import { | |
| 2 | + type ControlPlaneClient, | |
| 3 | + WorkspaceIdSchema, | |
| 4 | +} from "@executor-v3/control-plane"; | |
| 5 | +import * as Effect from "effect/Effect"; | |
| 6 | + | |
| 7 | +export type SeedDemoMcpSourceInput = { | |
| 8 | + client: ControlPlaneClient; | |
| 9 | + workspaceId: string; | |
| 10 | + endpoint: string; | |
| 11 | + name: string; | |
| 12 | + namespace: string; | |
| 13 | +}; | |
| 14 | + | |
| 15 | +export type SeedDemoMcpSourceResult = | |
| 16 | + | { | |
| 17 | + action: "noop"; | |
| 18 | + sourceId: string; | |
| 19 | + workspaceId: string; | |
| 20 | + endpoint: string; | |
| 21 | + } | |
| 22 | + | { | |
| 23 | + action: "updated" | "created"; | |
| 24 | + sourceId: string; | |
| 25 | + workspaceId: string; | |
| 26 | + endpoint: string; | |
| 27 | + }; | |
| 28 | + | |
| 29 | +export type SeedGithubOpenApiSourceInput = { | |
| 30 | + client: ControlPlaneClient; | |
| 31 | + workspaceId: string; | |
| 32 | + endpoint: string; | |
| 33 | + specUrl: string; | |
| 34 | + name: string; | |
| 35 | + namespace: string; | |
| 36 | + credentialEnvVar?: string; | |
| 37 | +}; | |
| 38 | + | |
| 39 | +export const seedDemoMcpSourceInWorkspace = ( | |
| 40 | + input: SeedDemoMcpSourceInput, | |
| 41 | +): Effect.Effect<SeedDemoMcpSourceResult, unknown, never> => | |
| 42 | + Effect.gen(function* () { | |
| 43 | + const workspaceId = WorkspaceIdSchema.make(input.workspaceId); | |
| 44 | + | |
| 45 | + const existing = yield* input.client.sources.list({ | |
| 46 | + path: { | |
| 47 | + workspaceId, | |
| 48 | + }, | |
| 49 | + }); | |
| 50 | + | |
| 51 | + const existingByName = existing.find( | |
| 52 | + (source) => source.kind === "mcp" && source.name === input.name, | |
| 53 | + ); | |
| 54 | + | |
| 55 | + if ( | |
| 56 | + existingByName !== undefined | |
| 57 | + && existingByName.endpoint === input.endpoint | |
| 58 | + && existingByName.configJson | |
| 59 | + === JSON.stringify({ | |
| 60 | + namespace: input.namespace, | |
| 61 | + transport: "streamable-http", | |
| 62 | + }) | |
| 63 | + ) { | |
| 64 | + return { | |
| 65 | + action: "noop", | |
| 66 | + sourceId: existingByName.id, | |
| 67 | + workspaceId: input.workspaceId, | |
| 68 | + endpoint: existingByName.endpoint, | |
| 69 | + }; | |
| 70 | + } | |
| 71 | + | |
| 72 | + if (existingByName !== undefined) { | |
| 73 | + const updated = yield* input.client.sources.update({ | |
| 74 | + path: { | |
| 75 | + workspaceId, | |
| 76 | + sourceId: existingByName.id, | |
| 77 | + }, | |
| 78 | + payload: { | |
| 79 | + endpoint: input.endpoint, | |
| 80 | + status: "connected", | |
| 81 | + enabled: true, | |
| 82 | + configJson: JSON.stringify({ | |
| 83 | + namespace: input.namespace, | |
| 84 | + transport: "streamable-http", | |
| 85 | + }), | |
| 86 | + }, | |
| 87 | + }); | |
| 88 | + | |
| 89 | + return { | |
| 90 | + action: "updated", | |
| 91 | + sourceId: updated.id, | |
| 92 | + workspaceId: input.workspaceId, | |
| 93 | + endpoint: updated.endpoint, | |
| 94 | + }; | |
| 95 | + } | |
| 96 | + | |
| 97 | + const created = yield* input.client.sources.create({ | |
| 98 | + path: { | |
| 99 | + workspaceId, | |
| 100 | + }, | |
| 101 | + payload: { | |
| 102 | + name: input.name, | |
| 103 | + kind: "mcp", | |
| 104 | + endpoint: input.endpoint, | |
| 105 | + status: "connected", | |
| 106 | + enabled: true, | |
| 107 | + configJson: JSON.stringify({ | |
| 108 | + namespace: input.namespace, | |
| 109 | + transport: "streamable-http", | |
| 110 | + }), | |
| 111 | + }, | |
| 112 | + }); | |
| 113 | + | |
| 114 | + return { | |
| 115 | + action: "created", | |
| 116 | + sourceId: created.id, | |
| 117 | + workspaceId: input.workspaceId, | |
| 118 | + endpoint: created.endpoint, | |
| 119 | + }; | |
| 120 | + }); | |
| 121 | + | |
| 122 | +export const seedGithubOpenApiSourceInWorkspace = ( | |
| 123 | + input: SeedGithubOpenApiSourceInput, | |
| 124 | +): Effect.Effect<SeedDemoMcpSourceResult, unknown, never> => | |
| 125 | + Effect.gen(function* () { | |
| 126 | + const workspaceId = WorkspaceIdSchema.make(input.workspaceId); | |
| 127 | + const configJson = JSON.stringify({ | |
| 128 | + namespace: input.namespace, | |
| 129 | + specUrl: input.specUrl, | |
| 130 | + credentialEnvVar: input.credentialEnvVar ?? "GITHUB_TOKEN", | |
| 131 | + credentialHeader: "Authorization", | |
| 132 | + credentialPrefix: "Bearer ", | |
| 133 | + }); | |
| 134 | + | |
| 135 | + const existing = yield* input.client.sources.list({ | |
| 136 | + path: { | |
| 137 | + workspaceId, | |
| 138 | + }, | |
| 139 | + }); | |
| 140 | + | |
| 141 | + const existingByName = existing.find( | |
| 142 | + (source) => source.kind === "openapi" && source.name === input.name, | |
| 143 | + ); | |
| 144 | + | |
| 145 | + if ( | |
| 146 | + existingByName !== undefined | |
| 147 | + && existingByName.endpoint === input.endpoint | |
| 148 | + && existingByName.configJson === configJson | |
| 149 | + ) { | |
| 150 | + return { | |
| 151 | + action: "noop", | |
| 152 | + sourceId: existingByName.id, | |
| 153 | + workspaceId: input.workspaceId, | |
| 154 | + endpoint: existingByName.endpoint, | |
| 155 | + }; | |
| 156 | + } | |
| 157 | + | |
| 158 | + if (existingByName !== undefined) { | |
| 159 | + const updated = yield* input.client.sources.update({ | |
| 160 | + path: { | |
| 161 | + workspaceId, | |
| 162 | + sourceId: existingByName.id, | |
| 163 | + }, | |
| 164 | + payload: { | |
| 165 | + endpoint: input.endpoint, | |
| 166 | + status: "connected", | |
| 167 | + enabled: true, | |
| 168 | + configJson, | |
| 169 | + }, | |
| 170 | + }); | |
| 171 | + | |
| 172 | + return { | |
| 173 | + action: "updated", | |
| 174 | + sourceId: updated.id, | |
| 175 | + workspaceId: input.workspaceId, | |
| 176 | + endpoint: updated.endpoint, | |
| 177 | + }; | |
| 178 | + } | |
| 179 | + | |
| 180 | + const created = yield* input.client.sources.create({ | |
| 181 | + path: { | |
| 182 | + workspaceId, | |
| 183 | + }, | |
| 184 | + payload: { | |
| 185 | + name: input.name, | |
| 186 | + kind: "openapi", | |
| 187 | + endpoint: input.endpoint, | |
| 188 | + status: "connected", | |
| 189 | + enabled: true, | |
| 190 | + configJson, | |
| 191 | + }, | |
| 192 | + }); | |
| 193 | + | |
| 194 | + return { | |
| 195 | + action: "created", | |
| 196 | + sourceId: created.id, | |
| 197 | + workspaceId: input.workspaceId, | |
| 198 | + endpoint: created.endpoint, | |
| 199 | + }; | |
| 200 | + }); | |
| @@ -25,9 +25,12 @@ import { · 24 unmodified lines | ||
| 25 | 25 | DEFAULT_SERVER_PORT, |
| 26 | 26 | SERVER_POLL_INTERVAL_MS, |
| 27 | 27 | SERVER_START_TIMEOUT_MS, |
| 28 | −} from "./config"; | |
| 29 | −import { seedDemoMcpSourceInWorkspace } from "./dev"; | |
| 30 | −import { runLocalExecutorServer } from "./server"; | |
| 28 | +} from "../server/config"; | |
| 29 | +import { | |
| 30 | + seedDemoMcpSourceInWorkspace, | |
| 31 | + seedGithubOpenApiSourceInWorkspace, | |
| 32 | +} from "./dev"; | |
| 33 | +import { runLocalExecutorServer } from "../server"; | |
| 31 | 34 | |
| 32 | 35 | const toError = (cause: unknown): Error => |
| 33 | 36 | cause instanceof Error ? cause : new Error(String(cause)); |
| @@ -52,9 +55,23 @@ const promptLine = (prompt: string): Effect.Effect<string, Error, never> => · 18 unmodified lines | ||
| 52 | 55 | catch: toError, |
| 53 | 56 | }); |
| 54 | 57 | |
| 58 | +const readStdin = (): Effect.Effect<string, Error, never> => | |
| 59 | + Effect.tryPromise({ | |
| 60 | + try: async () => { | |
| 61 | + let contents = ""; | |
| 62 | + process.stdin.setEncoding("utf8"); | |
| 63 | + for await (const chunk of process.stdin) { | |
| 64 | + contents += chunk; | |
| 65 | + } | |
| 66 | + return contents; | |
| 67 | + }, | |
| 68 | + catch: toError, | |
| 69 | + }); | |
| 70 | + | |
| 55 | 71 | const readCode = (input: { |
| 56 | 72 | code?: string; |
| 57 | 73 | file?: string; |
| 74 | + stdin?: boolean; | |
| 58 | 75 | }): Effect.Effect<string, Error, never> => |
| 59 | 76 | Effect.gen(function* () { |
| 60 | 77 | if (input.code && input.code.trim().length > 0) { |
| @@ -71,7 +88,15 @@ const readCode = (input: { · 10 unmodified lines | ||
| 71 | 88 | } |
| 72 | 89 | } |
| 73 | 90 | |
| 74 | − return yield* Effect.fail(new Error("Provide --code or --file.")); | |
| 91 | + const shouldReadStdin = input.stdin === true || !process.stdin.isTTY; | |
| 92 | + if (shouldReadStdin) { | |
| 93 | + const contents = yield* readStdin(); | |
| 94 | + if (contents.trim().length > 0) { | |
| 95 | + return contents; | |
| 96 | + } | |
| 97 | + } | |
| 98 | + | |
| 99 | + return yield* Effect.fail(new Error("Provide --code, --file, or pipe code over stdin.")); | |
| 75 | 100 | }); |
| 76 | 101 | |
| 77 | 102 | const getBootstrapClient = (baseUrl: string = DEFAULT_SERVER_BASE_URL) => |
| @@ -248,6 +273,32 @@ const seedDemoMcpSource = (input: { · 170 unmodified lines | ||
| 248 | 273 | }); |
| 249 | 274 | }); |
| 250 | 275 | |
| 276 | +const seedGithubOpenApiSource = (input: { | |
| 277 | + baseUrl: string; | |
| 278 | + endpoint: string; | |
| 279 | + specUrl: string; | |
| 280 | + name: string; | |
| 281 | + namespace: string; | |
| 282 | + credentialEnvVar?: string; | |
| 283 | +}) => | |
| 284 | + Effect.gen(function* () { | |
| 285 | + yield* ensureServer(input.baseUrl); | |
| 286 | + const { installation, client } = yield* getLocalAuthedClient(input.baseUrl); | |
| 287 | + const result = yield* seedGithubOpenApiSourceInWorkspace({ | |
| 288 | + client, | |
| 289 | + workspaceId: installation.workspaceId, | |
| 290 | + endpoint: input.endpoint, | |
| 291 | + specUrl: input.specUrl, | |
| 292 | + name: input.name, | |
| 293 | + namespace: input.namespace, | |
| 294 | + credentialEnvVar: input.credentialEnvVar, | |
| 295 | + }); | |
| 296 | + | |
| 297 | + yield* Effect.sync(() => { | |
| 298 | + console.log(JSON.stringify(result)); | |
| 299 | + }); | |
| 300 | + }); | |
| 301 | + | |
| 251 | 302 | const driveExecution = (input: { |
| 252 | 303 | client: ControlPlaneClient; |
| 253 | 304 | workspaceId: ExecutionEnvelope["execution"]["workspaceId"]; |
| @@ -310,13 +361,15 @@ const runCommand = Command.make( · 56 unmodified lines | ||
| 310 | 361 | { |
| 311 | 362 | code: Options.text("code").pipe(Options.optional), |
| 312 | 363 | file: Options.text("file").pipe(Options.optional), |
| 364 | + stdin: Options.boolean("stdin").pipe(Options.withDefault(false)), | |
| 313 | 365 | baseUrl: Options.text("base-url").pipe(Options.withDefault(DEFAULT_SERVER_BASE_URL)), |
| 314 | 366 | }, |
| 315 | − ({ code, file, baseUrl }) => | |
| 367 | + ({ code, file, stdin, baseUrl }) => | |
| 316 | 368 | Effect.gen(function* () { |
| 317 | 369 | const resolvedCode = yield* readCode({ |
| 318 | 370 | code: Option.getOrUndefined(code), |
| 319 | 371 | file: Option.getOrUndefined(file), |
| 372 | + stdin, | |
| 320 | 373 | }); |
| 321 | 374 | |
| 322 | 375 | yield* ensureServer(baseUrl); |
| @@ -393,8 +446,41 @@ const devSeedMcpDemoCommand = Command.make( · 70 unmodified lines | ||
| 393 | 446 | ), |
| 394 | 447 | ); |
| 395 | 448 | |
| 449 | +const devSeedGithubCommand = Command.make( | |
| 450 | + "seed-github", | |
| 451 | + { | |
| 452 | + baseUrl: Options.text("base-url").pipe(Options.withDefault(DEFAULT_SERVER_BASE_URL)), | |
| 453 | + endpoint: Options.text("endpoint").pipe( | |
| 454 | + Options.withDefault("https://api.github.com"), | |
| 455 | + ), | |
| 456 | + specUrl: Options.text("spec-url").pipe( | |
| 457 | + Options.withDefault( | |
| 458 | + "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json", | |
| 459 | + ), | |
| 460 | + ), | |
| 461 | + name: Options.text("name").pipe(Options.withDefault("GitHub")), | |
| 462 | + namespace: Options.text("namespace").pipe(Options.withDefault("github")), | |
| 463 | + credentialEnvVar: Options.text("credential-env-var").pipe( | |
| 464 | + Options.withDefault("GITHUB_TOKEN"), | |
| 465 | + ), | |
| 466 | + }, | |
| 467 | + ({ baseUrl, endpoint, specUrl, name, namespace, credentialEnvVar }) => | |
| 468 | + seedGithubOpenApiSource({ | |
| 469 | + baseUrl, | |
| 470 | + endpoint, | |
| 471 | + specUrl, | |
| 472 | + name, | |
| 473 | + namespace, | |
| 474 | + credentialEnvVar, | |
| 475 | + }), | |
| 476 | +).pipe( | |
| 477 | + Command.withDescription( | |
| 478 | + "Seed a GitHub OpenAPI source into the default workspace", | |
| 479 | + ), | |
| 480 | +); | |
| 481 | + | |
| 396 | 482 | const devCommand = Command.make("dev").pipe( |
| 397 | − Command.withSubcommands([devSeedMcpDemoCommand] as any), | |
| 483 | + Command.withSubcommands([devSeedMcpDemoCommand, devSeedGithubCommand] as any), | |
| 398 | 484 | Command.withDescription("Development helpers"), |
| 399 | 485 | ); |
| 400 | 486 | |
| @@ -1,182 +0,0 @@ | ||
| 1 | −import { | |
| 2 | − type Source, | |
| 3 | − type SqlControlPlaneRuntime, | |
| 4 | − type ResolveExecutionEnvironment, | |
| 5 | −} from "@executor-v3/control-plane"; | |
| 6 | −import { | |
| 7 | − createToolCatalogFromTools, | |
| 8 | − createSystemToolMap, | |
| 9 | − makeToolInvokerFromTools, | |
| 10 | − mergeToolMaps, | |
| 11 | −} from "@executor-v3/codemode-core"; | |
| 12 | −import { createSdkMcpConnector, discoverMcpToolsFromConnector } from "@executor-v3/codemode-mcp"; | |
| 13 | −import { makeInProcessExecutor } from "@executor-v3/runtime-local-inproc"; | |
| 14 | −import * as Effect from "effect/Effect"; | |
| 15 | −import * as Schema from "effect/Schema"; | |
| 16 | − | |
| 17 | −const McpSourceConfigSchema = Schema.Struct({ | |
| 18 | − namespace: Schema.optional(Schema.String), | |
| 19 | − transport: Schema.optional(Schema.Literal("auto", "streamable-http", "sse")), | |
| 20 | − queryParams: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })), | |
| 21 | − headers: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })), | |
| 22 | −}).pipe(Schema.partialWith({ exact: true })); | |
| 23 | − | |
| 24 | −const decodeMcpSourceConfig = Schema.decodeUnknown(McpSourceConfigSchema); | |
| 25 | − | |
| 26 | −const namespaceFromSourceName = (name: string): string => { | |
| 27 | − const normalized = name | |
| 28 | − .trim() | |
| 29 | − .toLowerCase() | |
| 30 | − .replace(/[^a-z0-9]+/g, ".") | |
| 31 | − .replace(/^\.+|\.+$/g, ""); | |
| 32 | − | |
| 33 | − return normalized.length > 0 ? normalized : "source"; | |
| 34 | −}; | |
| 35 | − | |
| 36 | −const loadWorkspaceMcpTools = (input: { | |
| 37 | − runtime: SqlControlPlaneRuntime; | |
| 38 | − workspaceId: Parameters<SqlControlPlaneRuntime["persistence"]["rows"]["sources"]["listByWorkspaceId"]>[0]; | |
| 39 | −}): Effect.Effect< | |
| 40 | − { | |
| 41 | − tools: ReturnType<typeof mergeToolMaps>; | |
| 42 | − catalog: ReturnType<typeof createToolCatalogFromTools>; | |
| 43 | − }, | |
| 44 | − Error, | |
| 45 | − never | |
| 46 | −> => | |
| 47 | − Effect.gen(function* () { | |
| 48 | − const sources: ReadonlyArray<Source> = yield* input.runtime.persistence.rows.sources | |
| 49 | − .listByWorkspaceId(input.workspaceId) | |
| 50 | − .pipe( | |
| 51 | − Effect.mapError((cause) => | |
| 52 | − cause instanceof Error ? cause : new Error(String(cause)), | |
| 53 | − ), | |
| 54 | − ); | |
| 55 | − | |
| 56 | − const enabledMcpSources = sources.filter( | |
| 57 | − (source) => source.enabled && source.kind === "mcp", | |
| 58 | − ); | |
| 59 | − | |
| 60 | − const discovered = yield* Effect.forEach( | |
| 61 | − enabledMcpSources, | |
| 62 | − (source: Source) => | |
| 63 | − Effect.gen(function* () { | |
| 64 | − const rawConfig = yield* Effect.try({ | |
| 65 | − try: () => (source.configJson.length > 0 ? JSON.parse(source.configJson) : {}), | |
| 66 | − catch: (cause) => | |
| 67 | − new Error( | |
| 68 | − `Invalid JSON config for source ${source.id}: ${ | |
| 69 | − cause instanceof Error ? cause.message : String(cause) | |
| 70 | − }`, | |
| 71 | − ), | |
| 72 | − }); | |
| 73 | − | |
| 74 | − const config = yield* decodeMcpSourceConfig(rawConfig).pipe( | |
| 75 | − Effect.mapError( | |
| 76 | − (cause) => | |
| 77 | − new Error( | |
| 78 | − `Invalid MCP source config for ${source.id}: ${ | |
| 79 | − cause instanceof Error ? cause.message : String(cause) | |
| 80 | − }`, | |
| 81 | − ), | |
| 82 | − ), | |
| 83 | − ); | |
| 84 | − | |
| 85 | − const connector = yield* Effect.try({ | |
| 86 | − try: () => | |
| 87 | − createSdkMcpConnector({ | |
| 88 | − endpoint: source.endpoint, | |
| 89 | − transport: config.transport, | |
| 90 | − queryParams: config.queryParams, | |
| 91 | − headers: config.headers, | |
| 92 | − }), | |
| 93 | − catch: (cause) => | |
| 94 | − new Error( | |
| 95 | − `Failed creating MCP connector for ${source.id}: ${ | |
| 96 | − cause instanceof Error ? cause.message : String(cause) | |
| 97 | − }`, | |
| 98 | − ), | |
| 99 | − }); | |
| 100 | − | |
| 101 | − return yield* discoverMcpToolsFromConnector({ | |
| 102 | − connect: connector, | |
| 103 | − namespace: config.namespace ?? namespaceFromSourceName(source.name), | |
| 104 | − sourceKey: source.id, | |
| 105 | − }).pipe( | |
| 106 | − Effect.mapError( | |
| 107 | − (cause) => | |
| 108 | − new Error( | |
| 109 | − `Failed discovering MCP tools for ${source.id}: ${ | |
| 110 | − cause instanceof Error ? cause.message : String(cause) | |
| 111 | − }`, | |
| 112 | − ), | |
| 113 | − ), | |
| 114 | − ); | |
| 115 | − }), | |
| 116 | − { concurrency: "unbounded" }, | |
| 117 | − ); | |
| 118 | − | |
| 119 | − const sourceTools = yield* Effect.try({ | |
| 120 | − try: () => | |
| 121 | − mergeToolMaps(discovered.map((item) => item.tools), { | |
| 122 | − conflictMode: "throw", | |
| 123 | − }), | |
| 124 | − catch: (cause) => | |
| 125 | − new Error( | |
| 126 | − `Failed merging discovered MCP tools: ${ | |
| 127 | − cause instanceof Error ? cause.message : String(cause) | |
| 128 | − }`, | |
| 129 | − ), | |
| 130 | − }); | |
| 131 | − const catalog = yield* Effect.try({ | |
| 132 | − try: () => createToolCatalogFromTools({ tools: sourceTools }), | |
| 133 | − catch: (cause) => | |
| 134 | − new Error( | |
| 135 | − `Failed creating tool catalog from MCP tools: ${ | |
| 136 | − cause instanceof Error ? cause.message : String(cause) | |
| 137 | − }`, | |
| 138 | − ), | |
| 139 | − }); | |
| 140 | − const allTools = yield* Effect.try({ | |
| 141 | − try: () => | |
| 142 | − mergeToolMaps([sourceTools, createSystemToolMap({ catalog })]), | |
| 143 | − catch: (cause) => | |
| 144 | − new Error( | |
| 145 | − `Failed creating MCP execution tool map: ${ | |
| 146 | − cause instanceof Error ? cause.message : String(cause) | |
| 147 | − }`, | |
| 148 | − ), | |
| 149 | − }); | |
| 150 | − | |
| 151 | − return { | |
| 152 | − tools: allTools, | |
| 153 | − catalog, | |
| 154 | − }; | |
| 155 | − }); | |
| 156 | − | |
| 157 | −export const makeControlPlaneExecutionResolver = ( | |
| 158 | − getRuntime: () => SqlControlPlaneRuntime | null, | |
| 159 | −): ResolveExecutionEnvironment => | |
| 160 | − (input) => | |
| 161 | − Effect.gen(function* () { | |
| 162 | − const runtime = getRuntime(); | |
| 163 | − if (runtime === null) { | |
| 164 | − return yield* Effect.fail( | |
| 165 | − new Error("Control-plane runtime is not ready"), | |
| 166 | − ); | |
| 167 | − } | |
| 168 | − | |
| 169 | − const loaded = yield* loadWorkspaceMcpTools({ | |
| 170 | − runtime, | |
| 171 | − workspaceId: input.workspaceId, | |
| 172 | − }); | |
| 173 | − | |
| 174 | − return { | |
| 175 | − executor: makeInProcessExecutor(), | |
| 176 | − toolInvoker: makeToolInvokerFromTools({ | |
| 177 | − tools: loaded.tools, | |
| 178 | − onElicitation: input.onElicitation, | |
| 179 | − }), | |
| 180 | − catalog: loaded.catalog, | |
| 181 | − }; | |
| 182 | − }); | |
| @@ -1,105 +0,0 @@ | ||
| 1 | −import type { ControlPlaneClient } from "@executor-v3/control-plane"; | |
| 2 | −import * as Effect from "effect/Effect"; | |
| 3 | − | |
| 4 | −export type SeedDemoMcpSourceInput = { | |
| 5 | − client: ControlPlaneClient; | |
| 6 | − workspaceId: string; | |
| 7 | − endpoint: string; | |
| 8 | − name: string; | |
| 9 | − namespace: string; | |
| 10 | −}; | |
| 11 | − | |
| 12 | −export type SeedDemoMcpSourceResult = | |
| 13 | − | { | |
| 14 | − action: "noop"; | |
| 15 | − sourceId: string; | |
| 16 | − workspaceId: string; | |
| 17 | − endpoint: string; | |
| 18 | − } | |
| 19 | − | { | |
| 20 | − action: "updated" | "created"; | |
| 21 | − sourceId: string; | |
| 22 | − workspaceId: string; | |
| 23 | − endpoint: string; | |
| 24 | − }; | |
| 25 | − | |
| 26 | −export const seedDemoMcpSourceInWorkspace = ( | |
| 27 | − input: SeedDemoMcpSourceInput, | |
| 28 | −): Effect.Effect<SeedDemoMcpSourceResult, unknown, never> => | |
| 29 | − Effect.gen(function* () { | |
| 30 | − const existing = yield* input.client.sources.list({ | |
| 31 | − path: { | |
| 32 | − workspaceId: input.workspaceId as never, | |
| 33 | − }, | |
| 34 | − }); | |
| 35 | − | |
| 36 | − const existingByName = existing.find( | |
| 37 | − (source) => source.kind === "mcp" && source.name === input.name, | |
| 38 | − ); | |
| 39 | − | |
| 40 | − if ( | |
| 41 | − existingByName !== undefined | |
| 42 | − && existingByName.endpoint === input.endpoint | |
| 43 | − && existingByName.configJson | |
| 44 | − === JSON.stringify({ | |
| 45 | − namespace: input.namespace, | |
| 46 | − transport: "streamable-http", | |
| 47 | − }) | |
| 48 | − ) { | |
| 49 | − return { | |
| 50 | − action: "noop", | |
| 51 | − sourceId: existingByName.id, | |
| 52 | − workspaceId: input.workspaceId, | |
| 53 | − endpoint: existingByName.endpoint, | |
| 54 | − }; | |
| 55 | − } | |
| 56 | − | |
| 57 | − if (existingByName !== undefined) { | |
| 58 | − const updated = yield* input.client.sources.update({ | |
| 59 | − path: { | |
| 60 | − workspaceId: input.workspaceId as never, | |
| 61 | − sourceId: existingByName.id, | |
| 62 | − }, | |
| 63 | − payload: { | |
| 64 | − endpoint: input.endpoint, | |
| 65 | − status: "connected", | |
| 66 | − enabled: true, | |
| 67 | − configJson: JSON.stringify({ | |
| 68 | − namespace: input.namespace, | |
| 69 | − transport: "streamable-http", | |
| 70 | − }), | |
| 71 | − }, | |
| 72 | − }); | |
| 73 | − | |
| 74 | − return { | |
| 75 | − action: "updated", | |
| 76 | − sourceId: updated.id, | |
| 77 | − workspaceId: input.workspaceId, | |
| 78 | − endpoint: updated.endpoint, | |
| 79 | − }; | |
| 80 | − } | |
| 81 | − | |
| 82 | − const created = yield* input.client.sources.create({ | |
| 83 | − path: { | |
| 84 | − workspaceId: input.workspaceId as never, | |
| 85 | − }, | |
| 86 | − payload: { | |
| 87 | − name: input.name, | |
| 88 | − kind: "mcp", | |
| 89 | − endpoint: input.endpoint, | |
| 90 | − status: "connected", | |
| 91 | − enabled: true, | |
| 92 | − configJson: JSON.stringify({ | |
| 93 | − namespace: input.namespace, | |
| 94 | − transport: "streamable-http", | |
| 95 | − }), | |
| 96 | − }, | |
| 97 | − }); | |
| 98 | − | |
| 99 | − return { | |
| 100 | − action: "created", | |
| 101 | − sourceId: created.id, | |
| 102 | − workspaceId: input.workspaceId, | |
| 103 | − endpoint: created.endpoint, | |
| 104 | − }; | |
| 105 | − }); | |
| @@ -1,2 +0,0 @@ | ||
| 1 | −export * from "./config"; | |
| 2 | −export * from "./server"; | |
File renamed without changes.
| @@ -0,0 +1,281 @@ | ||
| 1 | +import { | |
| 2 | + type Source, | |
| 3 | + type SqlControlPlaneRuntime, | |
| 4 | + type ResolveExecutionEnvironment, | |
| 5 | +} from "@executor-v3/control-plane"; | |
| 6 | +import { | |
| 7 | + type ToolMap, | |
| 8 | + createToolCatalogFromTools, | |
| 9 | + createSystemToolMap, | |
| 10 | + makeToolInvokerFromTools, | |
| 11 | + mergeToolMaps, | |
| 12 | +} from "@executor-v3/codemode-core"; | |
| 13 | +import { createSdkMcpConnector, discoverMcpToolsFromConnector } from "@executor-v3/codemode-mcp"; | |
| 14 | +import { | |
| 15 | + createOpenApiToolsFromSpec, | |
| 16 | + fetchOpenApiDocument, | |
| 17 | +} from "@executor-v3/codemode-openapi"; | |
| 18 | +import { makeInProcessExecutor } from "@executor-v3/runtime-local-inproc"; | |
| 19 | +import * as Effect from "effect/Effect"; | |
| 20 | +import * as Schema from "effect/Schema"; | |
| 21 | + | |
| 22 | +const McpSourceConfigSchema = Schema.Struct({ | |
| 23 | + namespace: Schema.optional(Schema.String), | |
| 24 | + transport: Schema.optional(Schema.Literal("auto", "streamable-http", "sse")), | |
| 25 | + queryParams: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })), | |
| 26 | + headers: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })), | |
| 27 | +}).pipe(Schema.partialWith({ exact: true })); | |
| 28 | + | |
| 29 | +const decodeMcpSourceConfig = Schema.decodeUnknown(McpSourceConfigSchema); | |
| 30 | + | |
| 31 | +const OpenApiSourceConfigSchema = Schema.Struct({ | |
| 32 | + namespace: Schema.optional(Schema.String), | |
| 33 | + specUrl: Schema.optional(Schema.String), | |
| 34 | + credentialEnvVar: Schema.optional(Schema.String), | |
| 35 | + credentialHeader: Schema.optional(Schema.String), | |
| 36 | + credentialPrefix: Schema.optional(Schema.String), | |
| 37 | + defaultHeaders: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })), | |
| 38 | +}).pipe(Schema.partialWith({ exact: true })); | |
| 39 | + | |
| 40 | +const decodeOpenApiSourceConfig = Schema.decodeUnknown(OpenApiSourceConfigSchema); | |
| 41 | + | |
| 42 | +const namespaceFromSourceName = (name: string): string => { | |
| 43 | + const normalized = name | |
| 44 | + .trim() | |
| 45 | + .toLowerCase() | |
| 46 | + .replace(/[^a-z0-9]+/g, ".") | |
| 47 | + .replace(/^\.+|\.+$/g, ""); | |
| 48 | + | |
| 49 | + return normalized.length > 0 ? normalized : "source"; | |
| 50 | +}; | |
| 51 | + | |
| 52 | +const loadWorkspaceSourceTools = (input: { | |
| 53 | + runtime: SqlControlPlaneRuntime; | |
| 54 | + workspaceId: Parameters<SqlControlPlaneRuntime["persistence"]["rows"]["sources"]["listByWorkspaceId"]>[0]; | |
| 55 | +}): Effect.Effect< | |
| 56 | + { | |
| 57 | + tools: ToolMap; | |
| 58 | + catalog: ReturnType<typeof createToolCatalogFromTools>; | |
| 59 | + }, | |
| 60 | + Error, | |
| 61 | + never | |
| 62 | +> => | |
| 63 | + Effect.gen(function* () { | |
| 64 | + const sources: ReadonlyArray<Source> = yield* input.runtime.persistence.rows.sources | |
| 65 | + .listByWorkspaceId(input.workspaceId) | |
| 66 | + .pipe( | |
| 67 | + Effect.mapError((cause) => | |
| 68 | + cause instanceof Error ? cause : new Error(String(cause)), | |
| 69 | + ), | |
| 70 | + ); | |
| 71 | + | |
| 72 | + const enabledSources = sources.filter((source) => source.enabled); | |
| 73 | + | |
| 74 | + const discoveredToolMaps = yield* Effect.forEach( | |
| 75 | + enabledSources, | |
| 76 | + (source: Source) => | |
| 77 | + Effect.gen(function* () { | |
| 78 | + if (source.kind === "mcp") { | |
| 79 | + const rawConfig = yield* Effect.try({ | |
| 80 | + try: () => (source.configJson.length > 0 ? JSON.parse(source.configJson) : {}), | |
| 81 | + catch: (cause) => | |
| 82 | + new Error( | |
| 83 | + `Invalid JSON config for source ${source.id}: ${ | |
| 84 | + cause instanceof Error ? cause.message : String(cause) | |
| 85 | + }`, | |
| 86 | + ), | |
| 87 | + }); | |
| 88 | + | |
| 89 | + const config = yield* decodeMcpSourceConfig(rawConfig).pipe( | |
| 90 | + Effect.mapError( | |
| 91 | + (cause) => | |
| 92 | + new Error( | |
| 93 | + `Invalid MCP source config for ${source.id}: ${ | |
| 94 | + cause instanceof Error ? cause.message : String(cause) | |
| 95 | + }`, | |
| 96 | + ), | |
| 97 | + ), | |
| 98 | + ); | |
| 99 | + | |
| 100 | + const connector = yield* Effect.try({ | |
| 101 | + try: () => | |
| 102 | + createSdkMcpConnector({ | |
| 103 | + endpoint: source.endpoint, | |
| 104 | + transport: config.transport, | |
| 105 | + queryParams: config.queryParams, | |
| 106 | + headers: config.headers, | |
| 107 | + }), | |
| 108 | + catch: (cause) => | |
| 109 | + new Error( | |
| 110 | + `Failed creating MCP connector for ${source.id}: ${ | |
| 111 | + cause instanceof Error ? cause.message : String(cause) | |
| 112 | + }`, | |
| 113 | + ), | |
| 114 | + }); | |
| 115 | + | |
| 116 | + const discovered = yield* discoverMcpToolsFromConnector({ | |
| 117 | + connect: connector, | |
| 118 | + namespace: config.namespace ?? namespaceFromSourceName(source.name), | |
| 119 | + sourceKey: source.id, | |
| 120 | + }).pipe( | |
| 121 | + Effect.mapError( | |
| 122 | + (cause) => | |
| 123 | + new Error( | |
| 124 | + `Failed discovering MCP tools for ${source.id}: ${ | |
| 125 | + cause instanceof Error ? cause.message : String(cause) | |
| 126 | + }`, | |
| 127 | + ), | |
| 128 | + ), | |
| 129 | + ); | |
| 130 | + | |
| 131 | + return discovered.tools; | |
| 132 | + } | |
| 133 | + | |
| 134 | + if (source.kind === "openapi") { | |
| 135 | + const rawConfig = yield* Effect.try({ | |
| 136 | + try: () => (source.configJson.length > 0 ? JSON.parse(source.configJson) : {}), | |
| 137 | + catch: (cause) => | |
| 138 | + new Error( | |
| 139 | + `Invalid JSON config for source ${source.id}: ${ | |
| 140 | + cause instanceof Error ? cause.message : String(cause) | |
| 141 | + }`, | |
| 142 | + ), | |
| 143 | + }); | |
| 144 | + | |
| 145 | + const config = yield* decodeOpenApiSourceConfig(rawConfig).pipe( | |
| 146 | + Effect.mapError( | |
| 147 | + (cause) => | |
| 148 | + new Error( | |
| 149 | + `Invalid OpenAPI source config for ${source.id}: ${ | |
| 150 | + cause instanceof Error ? cause.message : String(cause) | |
| 151 | + }`, | |
| 152 | + ), | |
| 153 | + ), | |
| 154 | + ); | |
| 155 | + | |
| 156 | + const specUrl = config.specUrl?.trim(); | |
| 157 | + if (!specUrl) { | |
| 158 | + return yield* Effect.fail( | |
| 159 | + new Error(`Missing OpenAPI specUrl for source ${source.id}`), | |
| 160 | + ); | |
| 161 | + } | |
| 162 | + | |
| 163 | + const openApiDocument = yield* Effect.tryPromise({ | |
| 164 | + try: () => fetchOpenApiDocument(specUrl), | |
| 165 | + catch: (cause) => | |
| 166 | + new Error( | |
| 167 | + `Failed fetching OpenAPI spec for ${source.id}: ${ | |
| 168 | + cause instanceof Error ? cause.message : String(cause) | |
| 169 | + }`, | |
| 170 | + ), | |
| 171 | + }); | |
| 172 | + | |
| 173 | + const defaultHeaders = config.defaultHeaders ?? {}; | |
| 174 | + const credentialHeader = config.credentialHeader?.trim() || "Authorization"; | |
| 175 | + const credentialPrefix = config.credentialPrefix ?? "Bearer "; | |
| 176 | + const credentialEnvVar = config.credentialEnvVar?.trim(); | |
| 177 | + const credentialValue = credentialEnvVar | |
| 178 | + ? process.env[credentialEnvVar]?.trim() | |
| 179 | + : undefined; | |
| 180 | + const credentialHeaders = | |
| 181 | + credentialEnvVar && credentialValue | |
| 182 | + ? { | |
| 183 | + [credentialHeader]: `${credentialPrefix}${credentialValue}`, | |
| 184 | + } | |
| 185 | + : {}; | |
| 186 | + | |
| 187 | + const extracted = yield* createOpenApiToolsFromSpec({ | |
| 188 | + sourceName: source.name, | |
| 189 | + openApiSpec: openApiDocument, | |
| 190 | + baseUrl: source.endpoint, | |
| 191 | + namespace: config.namespace ?? namespaceFromSourceName(source.name), | |
| 192 | + sourceKey: source.id, | |
| 193 | + defaultHeaders, | |
| 194 | + credentialHeaders, | |
| 195 | + }).pipe( | |
| 196 | + Effect.mapError( | |
| 197 | + (cause) => | |
| 198 | + new Error( | |
| 199 | + `Failed loading OpenAPI tools for ${source.id}: ${ | |
| 200 | + cause instanceof Error ? cause.message : String(cause) | |
| 201 | + }`, | |
| 202 | + ), | |
| 203 | + ), | |
| 204 | + ); | |
| 205 | + | |
| 206 | + return extracted.tools; | |
| 207 | + } | |
| 208 | + | |
| 209 | + return {}; | |
| 210 | + }), | |
| 211 | + { concurrency: "unbounded" }, | |
| 212 | + ); | |
| 213 | + | |
| 214 | + const sourceTools = yield* Effect.try({ | |
| 215 | + try: () => | |
| 216 | + mergeToolMaps(discoveredToolMaps, { | |
| 217 | + conflictMode: "throw", | |
| 218 | + }), | |
| 219 | + catch: (cause) => | |
| 220 | + new Error( | |
| 221 | + `Failed merging discovered source tools: ${ | |
| 222 | + cause instanceof Error ? cause.message : String(cause) | |
| 223 | + }`, | |
| 224 | + ), | |
| 225 | + }); | |
| 226 | + const catalog = yield* Effect.try({ | |
| 227 | + try: () => createToolCatalogFromTools({ tools: sourceTools }), | |
| 228 | + catch: (cause) => | |
| 229 | + new Error( | |
| 230 | + `Failed creating tool catalog from source tools: ${ | |
| 231 | + cause instanceof Error ? cause.message : String(cause) | |
| 232 | + }`, | |
| 233 | + ), | |
| 234 | + }); | |
| 235 | + const allTools = yield* Effect.try({ | |
| 236 | + try: () => | |
| 237 | + mergeToolMaps([sourceTools, createSystemToolMap({ catalog })]), | |
| 238 | + catch: (cause) => | |
| 239 | + new Error( | |
| 240 | + `Failed creating source execution tool map: ${ | |
| 241 | + cause instanceof Error ? cause.message : String(cause) | |
| 242 | + }`, | |
| 243 | + ), | |
| 244 | + }); | |
| 245 | + | |
| 246 | + return { | |
| 247 | + tools: allTools, | |
| 248 | + catalog, | |
| 249 | + }; | |
| 250 | + }).pipe( | |
| 251 | + Effect.mapError((cause) => | |
| 252 | + cause instanceof Error ? cause : new Error(String(cause)), | |
| 253 | + ), | |
| 254 | + ); | |
| 255 | + | |
| 256 | +export const makeControlPlaneExecutionResolver = ( | |
| 257 | + getRuntime: () => SqlControlPlaneRuntime | null, | |
| 258 | +): ResolveExecutionEnvironment => | |
| 259 | + (input) => | |
| 260 | + Effect.gen(function* () { | |
| 261 | + const runtime = getRuntime(); | |
| 262 | + if (runtime === null) { | |
| 263 | + return yield* Effect.fail( | |
| 264 | + new Error("Control-plane runtime is not ready"), | |
| 265 | + ); | |
| 266 | + } | |
| 267 | + | |
| 268 | + const loaded = yield* loadWorkspaceSourceTools({ | |
| 269 | + runtime, | |
| 270 | + workspaceId: input.workspaceId, | |
| 271 | + }); | |
| 272 | + | |
| 273 | + return { | |
| 274 | + executor: makeInProcessExecutor(), | |
| 275 | + toolInvoker: makeToolInvokerFromTools({ | |
| 276 | + tools: loaded.tools, | |
| 277 | + onElicitation: input.onElicitation, | |
| 278 | + }), | |
| 279 | + catalog: loaded.catalog, | |
| 280 | + }; | |
| 281 | + }); | |
File renamed without changes.
| @@ -1,3 +1,12 @@ | ||
| 1 | +import { createServer, type IncomingMessage, type ServerResponse } from "node:http"; | |
| 2 | + | |
| 3 | +import { | |
| 4 | + HttpApi, | |
| 5 | + HttpApiEndpoint, | |
| 6 | + HttpApiGroup, | |
| 7 | + HttpApiSchema, | |
| 8 | + OpenApi, | |
| 9 | +} from "@effect/platform"; | |
| 1 | 10 | import { describe, expect, it } from "@effect/vitest"; |
| 2 | 11 | import * as Effect from "effect/Effect"; |
| 3 | 12 | import * as Schema from "effect/Schema"; |
| @@ -11,8 +20,11 @@ import { · 7 unmodified lines | ||
| 11 | 20 | } from "@executor-v3/control-plane"; |
| 12 | 21 | import { makeInProcessExecutor } from "@executor-v3/runtime-local-inproc"; |
| 13 | 22 | |
| 14 | −import { seedDemoMcpSourceInWorkspace } from "./dev"; | |
| 15 | −import { makeLocalExecutorServer } from "./server"; | |
| 23 | +import { | |
| 24 | + seedDemoMcpSourceInWorkspace, | |
| 25 | + seedGithubOpenApiSourceInWorkspace, | |
| 26 | +} from "../cli/dev"; | |
| 27 | +import { makeLocalExecutorServer } from "."; | |
| 16 | 28 | |
| 17 | 29 | const executionResolver: ResolveExecutionEnvironment = () => |
| 18 | 30 | Effect.succeed({ |
| @@ -39,6 +51,77 @@ const makeServer = makeLocalExecutorServer({ · 20 unmodified lines | ||
| 39 | 51 | executionResolver, |
| 40 | 52 | }); |
| 41 | 53 | |
| 54 | +const ownerParam = HttpApiSchema.param("owner", Schema.String); | |
| 55 | +const repoParam = HttpApiSchema.param("repo", Schema.String); | |
| 56 | + | |
| 57 | +class ExecutorDemoReposApi extends HttpApiGroup.make("repos") | |
| 58 | + .add( | |
| 59 | + HttpApiEndpoint.get("getRepo")`/repos/${ownerParam}/${repoParam}` | |
| 60 | + .addSuccess( | |
| 61 | + Schema.Struct({ | |
| 62 | + full_name: Schema.String, | |
| 63 | + private: Schema.Boolean, | |
| 64 | + }), | |
| 65 | + ), | |
| 66 | + ) | |
| 67 | +{} | |
| 68 | + | |
| 69 | +class ExecutorDemoApi extends HttpApi.make("executorDemo").add(ExecutorDemoReposApi) {} | |
| 70 | + | |
| 71 | +const executorDemoOpenApiSpec = OpenApi.fromApi(ExecutorDemoApi); | |
| 72 | + | |
| 73 | +const startOpenApiDemoServer = async () => { | |
| 74 | + const seenAuthHeaders: Array<string | null> = []; | |
| 75 | + | |
| 76 | + const handler = (req: IncomingMessage, res: ServerResponse) => { | |
| 77 | + if (req.url === "/openapi.json") { | |
| 78 | + res.statusCode = 200; | |
| 79 | + res.setHeader("content-type", "application/json"); | |
| 80 | + res.end(JSON.stringify(executorDemoOpenApiSpec)); | |
| 81 | + return; | |
| 82 | + } | |
| 83 | + | |
| 84 | + const match = req.url?.match(/^\/repos\/([^/]+)\/([^/]+)$/); | |
| 85 | + if (req.method === "GET" && match) { | |
| 86 | + seenAuthHeaders.push( | |
| 87 | + typeof req.headers.authorization === "string" ? req.headers.authorization : null, | |
| 88 | + ); | |
| 89 | + res.statusCode = 200; | |
| 90 | + res.setHeader("content-type", "application/json"); | |
| 91 | + res.end( | |
| 92 | + JSON.stringify({ | |
| 93 | + full_name: `${decodeURIComponent(match[1] ?? "")}/${decodeURIComponent(match[2] ?? "")}`, | |
| 94 | + private: false, | |
| 95 | + }), | |
| 96 | + ); | |
| 97 | + return; | |
| 98 | + } | |
| 99 | + | |
| 100 | + res.statusCode = 404; | |
| 101 | + res.end("not found"); | |
| 102 | + }; | |
| 103 | + | |
| 104 | + const server = createServer(handler); | |
| 105 | + await new Promise<void>((resolve, reject) => { | |
| 106 | + server.once("error", reject); | |
| 107 | + server.listen(0, "127.0.0.1", () => resolve()); | |
| 108 | + }); | |
| 109 | + const address = server.address(); | |
| 110 | + if (!address || typeof address === "string") { | |
| 111 | + throw new Error("Failed to bind OpenAPI demo server"); | |
| 112 | + } | |
| 113 | + | |
| 114 | + return { | |
| 115 | + baseUrl: `http://127.0.0.1:${address.port}`, | |
| 116 | + specUrl: `http://127.0.0.1:${address.port}/openapi.json`, | |
| 117 | + seenAuthHeaders, | |
| 118 | + close: () => | |
| 119 | + new Promise<void>((resolve, reject) => { | |
| 120 | + server.close((error) => (error ? reject(error) : resolve())); | |
| 121 | + }), | |
| 122 | + }; | |
| 123 | +}; | |
| 124 | + | |
| 42 | 125 | describe("local-executor-server", () => { |
| 43 | 126 | it.scoped("serves the control-plane API and executes code", () => |
| 44 | 127 | Effect.gen(function* () { |
| @@ -268,6 +351,65 @@ describe("local-executor-server", () => { · 223 unmodified lines | ||
| 268 | 351 | }), |
| 269 | 352 | ); |
| 270 | 353 | |
| 354 | + it.scoped("loads OpenAPI sources from control-plane state and calls them", () => | |
| 355 | + Effect.gen(function* () { | |
| 356 | + const openApiServer = yield* Effect.acquireRelease( | |
| 357 | + Effect.promise(() => startOpenApiDemoServer()), | |
| 358 | + (server) => Effect.promise(() => server.close()).pipe(Effect.orDie), | |
| 359 | + ); | |
| 360 | + | |
| 361 | + const previousGithubToken = process.env.GITHUB_TOKEN; | |
| 362 | + process.env.GITHUB_TOKEN = "ghp_test_executor"; | |
| 363 | + | |
| 364 | + const server = yield* makeLocalExecutorServer({ | |
| 365 | + port: 0, | |
| 366 | + localDataDir: ":memory:", | |
| 367 | + }); | |
| 368 | + | |
| 369 | + const bootstrapClient = yield* makeControlPlaneClient({ | |
| 370 | + baseUrl: server.baseUrl, | |
| 371 | + }); | |
| 372 | + const installation = yield* bootstrapClient.local.installation({}); | |
| 373 | + const client = yield* makeControlPlaneClient({ | |
| 374 | + baseUrl: server.baseUrl, | |
| 375 | + accountId: installation.accountId, | |
| 376 | + }); | |
| 377 | + | |
| 378 | + yield* seedGithubOpenApiSourceInWorkspace({ | |
| 379 | + client, | |
| 380 | + workspaceId: installation.workspaceId, | |
| 381 | + endpoint: openApiServer.baseUrl, | |
| 382 | + specUrl: openApiServer.specUrl, | |
| 383 | + name: "GitHub", | |
| 384 | + namespace: "github", | |
| 385 | + }); | |
| 386 | + | |
| 387 | + const execution = yield* client.executions.create({ | |
| 388 | + path: { | |
| 389 | + workspaceId: installation.workspaceId, | |
| 390 | + }, | |
| 391 | + payload: { | |
| 392 | + code: 'return await tools.github.repos.getRepo({ owner: "vercel", repo: "ai" });', | |
| 393 | + }, | |
| 394 | + }).pipe( | |
| 395 | + Effect.ensuring( | |
| 396 | + Effect.sync(() => { | |
| 397 | + if (previousGithubToken === undefined) { | |
| 398 | + delete process.env.GITHUB_TOKEN; | |
| 399 | + } else { | |
| 400 | + process.env.GITHUB_TOKEN = previousGithubToken; | |
| 401 | + } | |
| 402 | + }), | |
| 403 | + ), | |
| 404 | + ); | |
| 405 | + | |
| 406 | + expect(execution.execution.status).toBe("completed"); | |
| 407 | + expect(execution.pendingInteraction).toBeNull(); | |
| 408 | + expect(execution.execution.resultJson).toContain("\"full_name\":\"vercel/ai\""); | |
| 409 | + expect(openApiServer.seenAuthHeaders).toEqual(["Bearer ghp_test_executor"]); | |
| 410 | + }), | |
| 411 | + ); | |
| 412 | + | |
| 271 | 413 | it.scoped("returns a typed storage error when a configured MCP endpoint is invalid", () => |
| 272 | 414 | Effect.gen(function* () { |
| 273 | 415 | const server = yield* makeLocalExecutorServer({ |
| @@ -19,6 +19,7 @@ · 18 unmodified lines | ||
| 19 | 19 | "@effect/platform-node": "catalog:", |
| 20 | 20 | "@executor-v3/codemode-core": "workspace:*", |
| 21 | 21 | "@executor-v3/codemode-mcp": "workspace:*", |
| 22 | + "@executor-v3/codemode-openapi": "workspace:*", | |
| 22 | 23 | "@executor-v3/control-plane": "workspace:*", |
| 23 | 24 | "@executor-v3/runtime-local-inproc": "workspace:*", |
| 24 | 25 | "effect": "catalog:", |
| @@ -388,4 +388,53 @@ describe("openapi-tools", () => { · 387 unmodified lines | ||
| 388 | 388 | expect(server.requests[0]?.query).toContain("include=all"); |
| 389 | 389 | }), |
| 390 | 390 | ); |
| 391 | + | |
| 392 | + it.scoped("falls back to path-template args when extracted path parameters are missing", () => | |
| 393 | + Effect.gen(function* () { | |
| 394 | + const server = yield* makeTestServer; | |
| 395 | + | |
| 396 | + const extracted = yield* createOpenApiToolsFromSpec({ | |
| 397 | + sourceName: "generated", | |
| 398 | + openApiSpec: generatedOpenApiSpec, | |
| 399 | + baseUrl: server.baseUrl, | |
| 400 | + namespace: "source.generated", | |
| 401 | + }); | |
| 402 | + | |
| 403 | + const manifestWithoutPathParameters = { | |
| 404 | + ...extracted.manifest, | |
| 405 | + tools: extracted.manifest.tools.map((tool) => | |
| 406 | + tool.toolId === "repos/getRepo" | |
| 407 | + ? { | |
| 408 | + ...tool, | |
| 409 | + invocation: { | |
| 410 | + ...tool.invocation, | |
| 411 | + parameters: [], | |
| 412 | + }, | |
| 413 | + } | |
| 414 | + : tool), | |
| 415 | + }; | |
| 416 | + | |
| 417 | + const tools = createOpenApiToolsFromManifest({ | |
| 418 | + manifest: manifestWithoutPathParameters, | |
| 419 | + baseUrl: server.baseUrl, | |
| 420 | + namespace: "source.generated", | |
| 421 | + }); | |
| 422 | + | |
| 423 | + const getRepo = resolveToolExecutor(tools, "source.generated.repos.getRepo"); | |
| 424 | + const result = yield* Effect.promise(() => | |
| 425 | + getRepo({ owner: "octocat", repo: "hello-world" }), | |
| 426 | + ); | |
| 427 | + | |
| 428 | + expect(result).toEqual({ | |
| 429 | + status: 200, | |
| 430 | + headers: expect.any(Object), | |
| 431 | + body: { | |
| 432 | + full_name: "octocat/hello-world", | |
| 433 | + include: null, | |
| 434 | + }, | |
| 435 | + }); | |
| 436 | + expect(server.requests).toHaveLength(1); | |
| 437 | + expect(server.requests[0]?.path).toBe("/repos/octocat/hello-world"); | |
| 438 | + }), | |
| 439 | + ); | |
| 391 | 440 | }); |
| @@ -129,8 +129,28 @@ const replacePathTemplate = ( · 128 unmodified lines | ||
| 129 | 129 | .map((match) => match[1]) |
| 130 | 130 | .filter((value): value is string => typeof value === "string" && value.length > 0); |
| 131 | 131 | |
| 132 | − if (unresolvedPathParameters.length > 0) { | |
| 133 | − const names = [...new Set(unresolvedPathParameters)].sort().join(", "); | |
| 132 | + for (const parameterName of unresolvedPathParameters) { | |
| 133 | + const parameterValue = args[parameterName] | |
| 134 | + ?? (isRecord(args.path) ? args.path[parameterName] : undefined) | |
| 135 | + ?? (isRecord(args.pathParams) ? args.pathParams[parameterName] : undefined) | |
| 136 | + ?? (isRecord(args.params) ? args.params[parameterName] : undefined); | |
| 137 | + | |
| 138 | + if (parameterValue === undefined || parameterValue === null) { | |
| 139 | + continue; | |
| 140 | + } | |
| 141 | + | |
| 142 | + resolvedPath = resolvedPath.replaceAll( | |
| 143 | + `{${parameterName}}`, | |
| 144 | + encodeURIComponent(String(parameterValue)), | |
| 145 | + ); | |
| 146 | + } | |
| 147 | + | |
| 148 | + const stillUnresolvedPathParameters = [...resolvedPath.matchAll(/\{([^{}]+)\}/g)] | |
| 149 | + .map((match) => match[1]) | |
| 150 | + .filter((value): value is string => typeof value === "string" && value.length > 0); | |
| 151 | + | |
| 152 | + if (stillUnresolvedPathParameters.length > 0) { | |
| 153 | + const names = [...new Set(stillUnresolvedPathParameters)].sort().join(", "); | |
| 134 | 154 | throw new OpenApiToolInvocationError({ |
| 135 | 155 | operation: "resolve_path", |
| 136 | 156 | message: `Unresolved path parameters after substitution: ${names}`, |