Showing the changes to apps (216 of 1206 files). Show all
Unified · Split
| @@ -0,0 +1 @@ | |||
| 1 | .vercel | ||
| @@ -0,0 +1,461 @@ | |||
| 1 | import { describe, expect, it } from "@effect/vitest"; | ||
| 2 | import * as Effect from "effect/Effect"; | ||
| 3 | import { parse as parseYaml } from "yaml"; | ||
| 4 | |||
| 5 | import { extractOpenApiManifest } from "./parse-openapi"; | ||
| 6 | |||
| 7 | const cloudflareSpecUrl = "https://raw.githubusercontent.com/cloudflare/api-schemas/main/openapi.yaml"; | ||
| 8 | const vercelSpecUrl = "https://openapi.vercel.sh/"; | ||
| 9 | const httpMethods = ["get", "put", "post", "delete", "patch", "head", "options", "trace"] as const; | ||
| 10 | |||
| 11 | const isRecord = (value: unknown): value is Record<string, unknown> => | ||
| 12 | typeof value === "object" && value !== null && !Array.isArray(value); | ||
| 13 | |||
| 14 | const parseSpecDocument = (input: string): unknown => { | ||
| 15 | const trimmed = input.trim(); | ||
| 16 | if (trimmed.length === 0) { | ||
| 17 | throw new Error("Spec document is empty"); | ||
| 18 | } | ||
| 19 | |||
| 20 | try { | ||
| 21 | return JSON.parse(trimmed); | ||
| 22 | } catch { | ||
| 23 | return parseYaml(trimmed); | ||
| 24 | } | ||
| 25 | }; | ||
| 26 | |||
| 27 | const loadSpec = async (url: string): Promise<unknown> => { | ||
| 28 | const response = await fetch(url); | ||
| 29 | if (!response.ok) { | ||
| 30 | throw new Error(`Failed to fetch spec ${url}: ${response.status} ${response.statusText}`); | ||
| 31 | } | ||
| 32 | |||
| 33 | return parseSpecDocument(await response.text()); | ||
| 34 | }; | ||
| 35 | |||
| 36 | const collectRefKeys = (value: unknown, refs: Set<string>): void => { | ||
| 37 | if (Array.isArray(value)) { | ||
| 38 | for (const item of value) { | ||
| 39 | collectRefKeys(item, refs); | ||
| 40 | } | ||
| 41 | return; | ||
| 42 | } | ||
| 43 | |||
| 44 | if (!isRecord(value)) { | ||
| 45 | return; | ||
| 46 | } | ||
| 47 | |||
| 48 | const refValue = value.$ref; | ||
| 49 | if (typeof refValue === "string" && refValue.startsWith("#/")) { | ||
| 50 | refs.add(refValue); | ||
| 51 | } | ||
| 52 | |||
| 53 | for (const nested of Object.values(value)) { | ||
| 54 | collectRefKeys(nested, refs); | ||
| 55 | } | ||
| 56 | }; | ||
| 57 | |||
| 58 | const unescapeJsonPointer = (value: string): string => | ||
| 59 | value.replace(/~1/g, "/").replace(/~0/g, "~"); | ||
| 60 | |||
| 61 | const getByJsonPointer = (root: unknown, pointer: string): unknown => { | ||
| 62 | if (!pointer.startsWith("#/")) { | ||
| 63 | return null; | ||
| 64 | } | ||
| 65 | |||
| 66 | const segments = pointer | ||
| 67 | .slice(2) | ||
| 68 | .split("/") | ||
| 69 | .map((segment) => unescapeJsonPointer(segment)); | ||
| 70 | |||
| 71 | let current: unknown = root; | ||
| 72 | for (const segment of segments) { | ||
| 73 | if (Array.isArray(current)) { | ||
| 74 | const index = Number(segment); | ||
| 75 | if (!Number.isInteger(index) || index < 0 || index >= current.length) { | ||
| 76 | return null; | ||
| 77 | } | ||
| 78 | current = current[index]; | ||
| 79 | continue; | ||
| 80 | } | ||
| 81 | |||
| 82 | if (!isRecord(current) || !(segment in current)) { | ||
| 83 | return null; | ||
| 84 | } | ||
| 85 | |||
| 86 | current = current[segment]; | ||
| 87 | } | ||
| 88 | |||
| 89 | return current; | ||
| 90 | }; | ||
| 91 | |||
| 92 | const resolveLocalRef = (root: unknown, value: unknown, depth = 0): unknown => { | ||
| 93 | if (depth > 8 || !isRecord(value) || typeof value.$ref !== "string") { | ||
| 94 | return value; | ||
| 95 | } | ||
| 96 | |||
| 97 | const resolved = getByJsonPointer(root, value.$ref); | ||
| 98 | if (resolved === null) { | ||
| 99 | return value; | ||
| 100 | } | ||
| 101 | |||
| 102 | return resolveLocalRef(root, resolved, depth + 1); | ||
| 103 | }; | ||
| 104 | |||
| 105 | const extractSchemaFromContent = (content: unknown): unknown | null => { | ||
| 106 | if (!isRecord(content)) { | ||
| 107 | return null; | ||
| 108 | } | ||
| 109 | |||
| 110 | const jsonMedia = | ||
| 111 | (content["application/json"] as Record<string, unknown> | undefined) | ||
| 112 | ?? (content["application/*+json"] as Record<string, unknown> | undefined); | ||
| 113 | |||
| 114 | if (jsonMedia && isRecord(jsonMedia.schema)) { | ||
| 115 | return jsonMedia.schema; | ||
| 116 | } | ||
| 117 | |||
| 118 | for (const mediaType of Object.values(content)) { | ||
| 119 | if (isRecord(mediaType) && isRecord(mediaType.schema)) { | ||
| 120 | return mediaType.schema; | ||
| 121 | } | ||
| 122 | } | ||
| 123 | |||
| 124 | return null; | ||
| 125 | }; | ||
| 126 | |||
| 127 | const extractParameterSchema = (root: unknown, value: unknown): unknown => { | ||
| 128 | const parameter = resolveLocalRef(root, value); | ||
| 129 | if (!isRecord(parameter)) { | ||
| 130 | return null; | ||
| 131 | } | ||
| 132 | |||
| 133 | if (isRecord(parameter.schema)) { | ||
| 134 | return parameter.schema; | ||
| 135 | } | ||
| 136 | |||
| 137 | return extractSchemaFromContent(parameter.content); | ||
| 138 | }; | ||
| 139 | |||
| 140 | const extractRequestBodySchema = (root: unknown, operation: Record<string, unknown>): unknown => { | ||
| 141 | const requestBody = resolveLocalRef(root, operation.requestBody); | ||
| 142 | if (!isRecord(requestBody)) { | ||
| 143 | return null; | ||
| 144 | } | ||
| 145 | |||
| 146 | return extractSchemaFromContent(requestBody.content); | ||
| 147 | }; | ||
| 148 | |||
| 149 | const extractResponseSchema = (root: unknown, operation: Record<string, unknown>): unknown => { | ||
| 150 | const responses = resolveLocalRef(root, operation.responses); | ||
| 151 | if (!isRecord(responses)) { | ||
| 152 | return null; | ||
| 153 | } | ||
| 154 | |||
| 155 | const preferred = Object.keys(responses) | ||
| 156 | .filter((key) => /^2\d\d$/.test(key)) | ||
| 157 | .sort(); | ||
| 158 | if ("default" in responses) { | ||
| 159 | preferred.push("default"); | ||
| 160 | } | ||
| 161 | |||
| 162 | for (const key of preferred) { | ||
| 163 | const response = resolveLocalRef(root, responses[key]); | ||
| 164 | if (!isRecord(response)) { | ||
| 165 | continue; | ||
| 166 | } | ||
| 167 | |||
| 168 | const schema = extractSchemaFromContent(response.content); | ||
| 169 | if (schema !== null) { | ||
| 170 | return schema; | ||
| 171 | } | ||
| 172 | } | ||
| 173 | |||
| 174 | return null; | ||
| 175 | }; | ||
| 176 | |||
| 177 | const hasMeaningfulSchemaShape = (value: unknown): boolean => { | ||
| 178 | if (!isRecord(value)) { | ||
| 179 | return false; | ||
| 180 | } | ||
| 181 | |||
| 182 | if (typeof value.$ref === "string") { | ||
| 183 | return true; | ||
| 184 | } | ||
| 185 | |||
| 186 | if (typeof value.type === "string") { | ||
| 187 | return true; | ||
| 188 | } | ||
| 189 | |||
| 190 | if (Array.isArray(value.enum) && value.enum.length > 0) { | ||
| 191 | return true; | ||
| 192 | } | ||
| 193 | |||
| 194 | if (isRecord(value.properties) && Object.keys(value.properties).length > 0) { | ||
| 195 | return true; | ||
| 196 | } | ||
| 197 | |||
| 198 | if (value.items !== undefined && value.items !== null) { | ||
| 199 | return true; | ||
| 200 | } | ||
| 201 | |||
| 202 | if (Array.isArray(value.oneOf) || Array.isArray(value.anyOf) || Array.isArray(value.allOf)) { | ||
| 203 | return true; | ||
| 204 | } | ||
| 205 | |||
| 206 | if (value.additionalProperties !== undefined) { | ||
| 207 | return true; | ||
| 208 | } | ||
| 209 | |||
| 210 | return false; | ||
| 211 | }; | ||
| 212 | |||
| 213 | const isUnknownLikeSchema = (value: unknown): boolean => !hasMeaningfulSchemaShape(value); | ||
| 214 | |||
| 215 | type OperationExpectation = { | ||
| 216 | parameterSchemas: Record<string, unknown>; | ||
| 217 | requestBodySchema: unknown; | ||
| 218 | responseSchema: unknown; | ||
| 219 | }; | ||
| 220 | |||
| 221 | const operationSignature = (method: string, path: string): string => | ||
| 222 | `${method.toLowerCase()} ${path}`; | ||
| 223 | |||
| 224 | const buildOperationExpectations = (spec: unknown): Map<string, OperationExpectation> => { | ||
| 225 | if (!isRecord(spec) || !isRecord(spec.paths)) { | ||
| 226 | throw new Error("Spec missing paths object"); | ||
| 227 | } | ||
| 228 | |||
| 229 | const expectations = new Map<string, OperationExpectation>(); | ||
| 230 | |||
| 231 | for (const [path, pathItemValue] of Object.entries(spec.paths)) { | ||
| 232 | if (!isRecord(pathItemValue)) { | ||
| 233 | continue; | ||
| 234 | } | ||
| 235 | |||
| 236 | const pathLevelParameters = Array.isArray(pathItemValue.parameters) | ||
| 237 | ? pathItemValue.parameters | ||
| 238 | : []; | ||
| 239 | |||
| 240 | for (const method of httpMethods) { | ||
| 241 | const operationValue = pathItemValue[method]; | ||
| 242 | if (!isRecord(operationValue)) { | ||
| 243 | continue; | ||
| 244 | } | ||
| 245 | |||
| 246 | const parameterSchemas: Record<string, unknown> = {}; | ||
| 247 | const operationLevelParameters = Array.isArray(operationValue.parameters) | ||
| 248 | ? operationValue.parameters | ||
| 249 | : []; | ||
| 250 | |||
| 251 | const parameters = [...pathLevelParameters, ...operationLevelParameters]; | ||
| 252 | for (const parameter of parameters) { | ||
| 253 | const resolved = resolveLocalRef(spec, parameter); | ||
| 254 | if (!isRecord(resolved)) { | ||
| 255 | continue; | ||
| 256 | } | ||
| 257 | |||
| 258 | const name = typeof resolved.name === "string" ? resolved.name.trim() : ""; | ||
| 259 | const location = typeof resolved.in === "string" ? resolved.in.trim().toLowerCase() : ""; | ||
| 260 | if ( | ||
| 261 | name.length === 0 | ||
| 262 | || ( | ||
| 263 | location !== "path" | ||
| 264 | && location !== "query" | ||
| 265 | && location !== "header" | ||
| 266 | && location !== "cookie" | ||
| 267 | ) | ||
| 268 | ) { | ||
| 269 | continue; | ||
| 270 | } | ||
| 271 | |||
| 272 | const schema = extractParameterSchema(spec, resolved); | ||
| 273 | if (schema !== null) { | ||
| 274 | parameterSchemas[name] = schema; | ||
| 275 | } | ||
| 276 | } | ||
| 277 | |||
| 278 | expectations.set(operationSignature(method, path), { | ||
| 279 | parameterSchemas, | ||
| 280 | requestBodySchema: extractRequestBodySchema(spec, operationValue), | ||
| 281 | responseSchema: extractResponseSchema(spec, operationValue), | ||
| 282 | }); | ||
| 283 | } | ||
| 284 | } | ||
| 285 | |||
| 286 | return expectations; | ||
| 287 | }; | ||
| 288 | |||
| 289 | const assertManifestFidelityForSpec = ( | ||
| 290 | specName: string, | ||
| 291 | spec: unknown, | ||
| 292 | ): void => { | ||
| 293 | const manifest = extractOpenApiManifest(specName, spec); | ||
| 294 | const expectations = buildOperationExpectations(spec); | ||
| 295 | |||
| 296 | for (const tool of manifest.tools) { | ||
| 297 | const signature = operationSignature(tool.method, tool.path); | ||
| 298 | const expectation = expectations.get(signature); | ||
| 299 | expect(expectation, `Missing operation expectation for ${signature}`).toBeDefined(); | ||
| 300 | |||
| 301 | const inputSchema = tool.typing?.inputSchemaJson | ||
| 302 | ? JSON.parse(tool.typing.inputSchemaJson) | ||
| 303 | : null; | ||
| 304 | const outputSchema = tool.typing?.outputSchemaJson | ||
| 305 | ? JSON.parse(tool.typing.outputSchemaJson) | ||
| 306 | : null; | ||
| 307 | |||
| 308 | if (expectation) { | ||
| 309 | const expectedParamSchemas = Object.entries(expectation.parameterSchemas); | ||
| 310 | const hasStructuredParams = expectedParamSchemas.some(([, schema]) => hasMeaningfulSchemaShape(schema)); | ||
| 311 | const hasStructuredBody = hasMeaningfulSchemaShape(expectation.requestBodySchema); | ||
| 312 | const hasStructuredOutput = hasMeaningfulSchemaShape(expectation.responseSchema); | ||
| 313 | |||
| 314 | if (hasStructuredParams || hasStructuredBody) { | ||
| 315 | expect(tool.typing?.inputSchemaJson, `Missing input schema for ${signature}`).toBeDefined(); | ||
| 316 | expect(isRecord(inputSchema)).toBe(true); | ||
| 317 | expect(isRecord(inputSchema?.properties)).toBe(true); | ||
| 318 | } | ||
| 319 | |||
| 320 | if (hasStructuredParams && isRecord(inputSchema) && isRecord(inputSchema.properties)) { | ||
| 321 | for (const [paramName, sourceSchema] of expectedParamSchemas) { | ||
| 322 | if (!hasMeaningfulSchemaShape(sourceSchema)) { | ||
| 323 | continue; | ||
| 324 | } | ||
| 325 | |||
| 326 | expect( | ||
| 327 | inputSchema.properties[paramName], | ||
| 328 | `Missing input property '${paramName}' for ${signature}`, | ||
| 329 | ).toBeDefined(); | ||
| 330 | expect( | ||
| 331 | isUnknownLikeSchema(inputSchema.properties[paramName]), | ||
| 332 | `Unknown-like input schema for '${paramName}' in ${signature}`, | ||
| 333 | ).toBe(false); | ||
| 334 | } | ||
| 335 | } | ||
| 336 | |||
| 337 | if (hasStructuredBody && isRecord(inputSchema) && isRecord(inputSchema.properties)) { | ||
| 338 | expect(inputSchema.properties.body, `Missing body schema for ${signature}`).toBeDefined(); | ||
| 339 | expect( | ||
| 340 | isUnknownLikeSchema(inputSchema.properties.body), | ||
| 341 | `Unknown-like body schema for ${signature}`, | ||
| 342 | ).toBe(false); | ||
| 343 | } | ||
| 344 | |||
| 345 | if (hasStructuredOutput) { | ||
| 346 | expect(tool.typing?.outputSchemaJson, `Missing output schema for ${signature}`).toBeDefined(); | ||
| 347 | expect( | ||
| 348 | isUnknownLikeSchema(outputSchema), | ||
| 349 | `Unknown-like output schema for ${signature}`, | ||
| 350 | ).toBe(false); | ||
| 351 | } | ||
| 352 | } | ||
| 353 | |||
| 354 | const refs = new Set<string>(); | ||
| 355 | if (inputSchema) { | ||
| 356 | collectRefKeys(inputSchema, refs); | ||
| 357 | } | ||
| 358 | if (outputSchema) { | ||
| 359 | collectRefKeys(outputSchema, refs); | ||
| 360 | } | ||
| 361 | |||
| 362 | for (const refKey of refs) { | ||
| 363 | const resolvedRef = manifest.refHintTable[refKey]; | ||
| 364 | expect(resolvedRef, `Missing refHintTable entry ${refKey} for ${signature}`).toBeDefined(); | ||
| 365 | expect(() => JSON.parse(resolvedRef!)).not.toThrow(); | ||
| 366 | } | ||
| 367 | } | ||
| 368 | }; | ||
| 369 | |||
| 370 | describe("parse-openapi extractor fidelity against real specs", () => { | ||
| 371 | it.effect("Cloudflare path params and output refs are preserved", () => | ||
| 372 | Effect.gen(function* () { | ||
| 373 | const cloudflareSpec = yield* Effect.tryPromise(() => loadSpec(cloudflareSpecUrl)); | ||
| 374 | const manifest = extractOpenApiManifest("cloudflare", cloudflareSpec); | ||
| 375 | |||
| 376 | expect(manifest.tools.length).toBeGreaterThan(2000); | ||
| 377 | |||
| 378 | const accessDeleteTool = manifest.tools.find( | ||
| 379 | (tool) => | ||
| 380 | tool.method === "delete" | ||
| 381 | && tool.path === "/accounts/{account_id}/access/apps/{app_id}", | ||
| 382 | ); | ||
| 383 | expect(accessDeleteTool).toBeDefined(); | ||
| 384 | expect(accessDeleteTool?.typing?.inputSchemaJson).toBeDefined(); | ||
| 385 | |||
| 386 | const inputSchema = JSON.parse(accessDeleteTool!.typing!.inputSchemaJson!); | ||
| 387 | expect(inputSchema.type).toBe("object"); | ||
| 388 | expect(Array.isArray(inputSchema.required)).toBe(true); | ||
| 389 | expect(inputSchema.required).toContain("account_id"); | ||
| 390 | expect(inputSchema.required).toContain("app_id"); | ||
| 391 | expect(isRecord(inputSchema.properties)).toBe(true); | ||
| 392 | expect(isRecord(inputSchema.properties.account_id)).toBe(true); | ||
| 393 | expect(isRecord(inputSchema.properties.app_id)).toBe(true); | ||
| 394 | |||
| 395 | const ipDetailsTool = manifest.tools.find( | ||
| 396 | (tool) => | ||
| 397 | tool.name.toLowerCase().includes("jd cloud ip details") | ||
| 398 | || (tool.method === "get" && tool.path === "/ips"), | ||
| 399 | ); | ||
| 400 | expect(ipDetailsTool).toBeDefined(); | ||
| 401 | expect(ipDetailsTool?.typing?.outputSchemaJson).toBeDefined(); | ||
| 402 | |||
| 403 | const outputSchema = JSON.parse(ipDetailsTool!.typing!.outputSchemaJson!); | ||
| 404 | const outputRefs = new Set<string>(); | ||
| 405 | collectRefKeys(outputSchema, outputRefs); | ||
| 406 | expect(outputRefs.size).toBeGreaterThan(0); | ||
| 407 | |||
| 408 | for (const refKey of outputRefs) { | ||
| 409 | const schemaJson = manifest.refHintTable[refKey]; | ||
| 410 | expect(schemaJson).toBeDefined(); | ||
| 411 | expect(() => JSON.parse(schemaJson)).not.toThrow(); | ||
| 412 | } | ||
| 413 | }), | ||
| 414 | 30_000, | ||
| 415 | ); | ||
| 416 | |||
| 417 | it.effect("Vercel extract keeps typed invocation + schema coverage", () => | ||
| 418 | Effect.gen(function* () { | ||
| 419 | const vercelSpec = yield* Effect.tryPromise(() => loadSpec(vercelSpecUrl)); | ||
| 420 | const manifest = extractOpenApiManifest("vercel", vercelSpec); | ||
| 421 | |||
| 422 | expect(manifest.tools.length).toBeGreaterThan(100); | ||
| 423 | |||
| 424 | const toolWithPathParams = manifest.tools.find( | ||
| 425 | (tool) => tool.invocation.parameters.some((parameter) => parameter.location === "path"), | ||
| 426 | ); | ||
| 427 | expect(toolWithPathParams).toBeDefined(); | ||
| 428 | expect(toolWithPathParams?.typing?.inputSchemaJson).toBeDefined(); | ||
| 429 | |||
| 430 | const inputSchema = JSON.parse(toolWithPathParams!.typing!.inputSchemaJson!); | ||
| 431 | expect(isRecord(inputSchema)).toBe(true); | ||
| 432 | expect(inputSchema.type).toBe("object"); | ||
| 433 | expect(isRecord(inputSchema.properties)).toBe(true); | ||
| 434 | |||
| 435 | for (const pathParameter of toolWithPathParams!.invocation.parameters.filter( | ||
| 436 | (parameter) => parameter.location === "path", | ||
| 437 | )) { | ||
| 438 | expect(Array.isArray(inputSchema.required)).toBe(true); | ||
| 439 | expect(inputSchema.required).toContain(pathParameter.name); | ||
| 440 | expect(inputSchema.properties[pathParameter.name]).toBeDefined(); | ||
| 441 | } | ||
| 442 | }), | ||
| 443 | 30_000, | ||
| 444 | ); | ||
| 445 | |||
| 446 | it.effect("Cloudflare has no unknown-like schemas for structured operations", () => | ||
| 447 | Effect.gen(function* () { | ||
| 448 | const cloudflareSpec = yield* Effect.tryPromise(() => loadSpec(cloudflareSpecUrl)); | ||
| 449 | assertManifestFidelityForSpec("cloudflare", cloudflareSpec); | ||
| 450 | }), | ||
| 451 | 60_000, | ||
| 452 | ); | ||
| 453 | |||
| 454 | it.effect("Vercel has no unknown-like schemas for structured operations", () => | ||
| 455 | Effect.gen(function* () { | ||
| 456 | const vercelSpec = yield* Effect.tryPromise(() => loadSpec(vercelSpecUrl)); | ||
| 457 | assertManifestFidelityForSpec("vercel", vercelSpec); | ||
| 458 | }), | ||
| 459 | 60_000, | ||
| 460 | ); | ||
| 461 | }); | ||
| @@ -0,0 +1,806 @@ | |||
| 1 | import { createHash } from "node:crypto"; | ||
| 2 | |||
| 3 | import { ConvexHttpClient } from "convex/browser"; | ||
| 4 | import { parse as parseYaml } from "yaml"; | ||
| 5 | |||
| 6 | const maxBodyBytes = 256 * 1024; | ||
| 7 | const httpMethods = ["get", "put", "post", "delete", "patch", "head", "options", "trace"] as const; | ||
| 8 | |||
| 9 | type HttpMethod = typeof httpMethods[number]; | ||
| 10 | type OpenApiParameterLocation = "path" | "query" | "header" | "cookie"; | ||
| 11 | |||
| 12 | type ExtractedTool = { | ||
| 13 | toolId: string; | ||
| 14 | name: string; | ||
| 15 | description: string | null; | ||
| 16 | method: HttpMethod; | ||
| 17 | path: string; | ||
| 18 | invocation: { | ||
| 19 | method: HttpMethod; | ||
| 20 | pathTemplate: string; | ||
| 21 | parameters: Array<{ | ||
| 22 | name: string; | ||
| 23 | location: OpenApiParameterLocation; | ||
| 24 | required: boolean; | ||
| 25 | }>; | ||
| 26 | requestBody: { | ||
| 27 | required: boolean; | ||
| 28 | contentTypes: Array<string>; | ||
| 29 | } | null; | ||
| 30 | }; | ||
| 31 | operationHash: string; | ||
| 32 | typing?: { | ||
| 33 | inputSchemaJson?: string; | ||
| 34 | outputSchemaJson?: string; | ||
| 35 | refHintKeys?: Array<string>; | ||
| 36 | }; | ||
| 37 | }; | ||
| 38 | |||
| 39 | type OpenApiManifest = { | ||
| 40 | sourceHash: string; | ||
| 41 | tools: Array<ExtractedTool>; | ||
| 42 | refHintTable: Record<string, string>; | ||
| 43 | }; | ||
| 44 | |||
| 45 | const parseJsonDocument = (input: string): unknown => JSON.parse(input); | ||
| 46 | const parseYamlDocument = (input: string): unknown => parseYaml(input); | ||
| 47 | |||
| 48 | const isRecord = (value: unknown): value is Record<string, unknown> => | ||
| 49 | typeof value === "object" && value !== null && !Array.isArray(value); | ||
| 50 | |||
| 51 | const stableStringify = (value: unknown): string => { | ||
| 52 | if (Array.isArray(value)) { | ||
| 53 | return `[${value.map((entry) => stableStringify(entry)).join(",")}]`; | ||
| 54 | } | ||
| 55 | |||
| 56 | if (isRecord(value)) { | ||
| 57 | const keys = Object.keys(value).sort(); | ||
| 58 | return `{${keys | ||
| 59 | .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`) | ||
| 60 | .join(",")}}`; | ||
| 61 | } | ||
| 62 | |||
| 63 | return JSON.stringify(value); | ||
| 64 | }; | ||
| 65 | |||
| 66 | const hashUnknown = (value: unknown): string => | ||
| 67 | createHash("sha256").update(stableStringify(value)).digest("hex").slice(0, 16); | ||
| 68 | |||
| 69 | const normalizeText = (value: unknown): string | null => { | ||
| 70 | if (typeof value !== "string") { | ||
| 71 | return null; | ||
| 72 | } | ||
| 73 | |||
| 74 | const trimmed = value.trim(); | ||
| 75 | return trimmed.length > 0 ? trimmed : null; | ||
| 76 | }; | ||
| 77 | |||
| 78 | const normalizeSegment = (value: string): string => | ||
| 79 | value | ||
| 80 | .toLowerCase() | ||
| 81 | .replace(/[^a-z0-9]+/g, "_") | ||
| 82 | .replace(/^_+|_+$/g, ""); | ||
| 83 | |||
| 84 | const normalizeToolId = (value: string): string => | ||
| 85 | value | ||
| 86 | .toLowerCase() | ||
| 87 | .replace(/[^a-z0-9]+/g, ".") | ||
| 88 | .replace(/\.+/g, ".") | ||
| 89 | .replace(/^\.|\.$/g, ""); | ||
| 90 | |||
| 91 | const escapeJsonPointer = (value: string): string => | ||
| 92 | value.replace(/~/g, "~0").replace(/\//g, "~1"); | ||
| 93 | |||
| 94 | const unescapeJsonPointer = (value: string): string => | ||
| 95 | value.replace(/~1/g, "/").replace(/~0/g, "~"); | ||
| 96 | |||
| 97 | const getByJsonPointer = (root: unknown, pointer: string): unknown => { | ||
| 98 | if (!pointer.startsWith("#/")) { | ||
| 99 | return null; | ||
| 100 | } | ||
| 101 | |||
| 102 | const segments = pointer | ||
| 103 | .slice(2) | ||
| 104 | .split("/") | ||
| 105 | .map((segment) => unescapeJsonPointer(segment)); | ||
| 106 | |||
| 107 | let current: unknown = root; | ||
| 108 | for (const segment of segments) { | ||
| 109 | if (Array.isArray(current)) { | ||
| 110 | const index = Number(segment); | ||
| 111 | if (!Number.isInteger(index) || index < 0 || index >= current.length) { | ||
| 112 | return null; | ||
| 113 | } | ||
| 114 | current = current[index]; | ||
| 115 | continue; | ||
| 116 | } | ||
| 117 | |||
| 118 | if (!isRecord(current) || !(segment in current)) { | ||
| 119 | return null; | ||
| 120 | } | ||
| 121 | |||
| 122 | current = current[segment]; | ||
| 123 | } | ||
| 124 | |||
| 125 | return current; | ||
| 126 | }; | ||
| 127 | |||
| 128 | const resolveLocalRef = (root: unknown, value: unknown, depth = 0): unknown => { | ||
| 129 | if (depth > 8 || !isRecord(value) || typeof value.$ref !== "string") { | ||
| 130 | return value; | ||
| 131 | } | ||
| 132 | |||
| 133 | const resolved = getByJsonPointer(root, value.$ref); | ||
| 134 | if (resolved === null) { | ||
| 135 | return value; | ||
| 136 | } | ||
| 137 | |||
| 138 | return resolveLocalRef(root, resolved, depth + 1); | ||
| 139 | }; | ||
| 140 | |||
| 141 | const collectLocalRefKeys = (value: unknown, target: Set<string>): void => { | ||
| 142 | if (Array.isArray(value)) { | ||
| 143 | for (const entry of value) { | ||
| 144 | collectLocalRefKeys(entry, target); | ||
| 145 | } | ||
| 146 | return; | ||
| 147 | } | ||
| 148 | |||
| 149 | if (!isRecord(value)) { | ||
| 150 | return; | ||
| 151 | } | ||
| 152 | |||
| 153 | for (const [key, entry] of Object.entries(value)) { | ||
| 154 | if (key === "$ref" && typeof entry === "string" && entry.startsWith("#/")) { | ||
| 155 | target.add(entry); | ||
| 156 | continue; | ||
| 157 | } | ||
| 158 | |||
| 159 | collectLocalRefKeys(entry, target); | ||
| 160 | } | ||
| 161 | }; | ||
| 162 | |||
| 163 | const extractParameterSchema = ( | ||
| 164 | root: unknown, | ||
| 165 | parameter: Record<string, unknown>, | ||
| 166 | ): unknown => { | ||
| 167 | const resolved = resolveLocalRef(root, parameter); | ||
| 168 | if (!isRecord(resolved)) { | ||
| 169 | return {}; | ||
| 170 | } | ||
| 171 | |||
| 172 | if (isRecord(resolved.schema)) { | ||
| 173 | return resolved.schema; | ||
| 174 | } | ||
| 175 | |||
| 176 | const content = resolved.content; | ||
| 177 | if (isRecord(content)) { | ||
| 178 | const jsonMedia = | ||
| 179 | (content["application/json"] as Record<string, unknown> | undefined) | ||
| 180 | ?? (content["application/*+json"] as Record<string, unknown> | undefined); | ||
| 181 | |||
| 182 | if (jsonMedia && isRecord(jsonMedia.schema)) { | ||
| 183 | return jsonMedia.schema; | ||
| 184 | } | ||
| 185 | |||
| 186 | for (const mediaType of Object.values(content)) { | ||
| 187 | if (isRecord(mediaType) && isRecord(mediaType.schema)) { | ||
| 188 | return mediaType.schema; | ||
| 189 | } | ||
| 190 | } | ||
| 191 | } | ||
| 192 | |||
| 193 | return {}; | ||
| 194 | }; | ||
| 195 | |||
| 196 | const extractRequestBody = ( | ||
| 197 | root: unknown, | ||
| 198 | operation: Record<string, unknown>, | ||
| 199 | ): { | ||
| 200 | required: boolean; | ||
| 201 | contentTypes: Array<string>; | ||
| 202 | schema: unknown; | ||
| 203 | } | null => { | ||
| 204 | const requestBodyValue = resolveLocalRef(root, operation.requestBody); | ||
| 205 | if (!isRecord(requestBodyValue)) { | ||
| 206 | return null; | ||
| 207 | } | ||
| 208 | |||
| 209 | const content = requestBodyValue.content; | ||
| 210 | if (!isRecord(content)) { | ||
| 211 | return { | ||
| 212 | required: requestBodyValue.required === true, | ||
| 213 | contentTypes: [], | ||
| 214 | schema: {}, | ||
| 215 | }; | ||
| 216 | } | ||
| 217 | |||
| 218 | const contentTypes = Object.keys(content).filter((entry) => entry.trim().length > 0); | ||
| 219 | const jsonMedia = | ||
| 220 | (content["application/json"] as Record<string, unknown> | undefined) | ||
| 221 | ?? (content["application/*+json"] as Record<string, unknown> | undefined); | ||
| 222 | let schema: unknown = {}; | ||
| 223 | |||
| 224 | if (jsonMedia && isRecord(jsonMedia.schema)) { | ||
| 225 | schema = jsonMedia.schema; | ||
| 226 | } else { | ||
| 227 | for (const mediaType of Object.values(content)) { | ||
| 228 | if (isRecord(mediaType) && isRecord(mediaType.schema)) { | ||
| 229 | schema = mediaType.schema; | ||
| 230 | break; | ||
| 231 | } | ||
| 232 | } | ||
| 233 | } | ||
| 234 | |||
| 235 | return { | ||
| 236 | required: requestBodyValue.required === true, | ||
| 237 | contentTypes, | ||
| 238 | schema, | ||
| 239 | }; | ||
| 240 | }; | ||
| 241 | |||
| 242 | const extractResponseSchema = ( | ||
| 243 | root: unknown, | ||
| 244 | operation: Record<string, unknown>, | ||
| 245 | ): unknown | null => { | ||
| 246 | const responsesValue = resolveLocalRef(root, operation.responses); | ||
| 247 | if (!isRecord(responsesValue)) { | ||
| 248 | return null; | ||
| 249 | } | ||
| 250 | |||
| 251 | const preferredKeys = Object.keys(responsesValue) | ||
| 252 | .filter((key) => /^2\d\d$/.test(key)) | ||
| 253 | .sort(); | ||
| 254 | if ("default" in responsesValue) { | ||
| 255 | preferredKeys.push("default"); | ||
| 256 | } | ||
| 257 | |||
| 258 | for (const key of preferredKeys) { | ||
| 259 | const candidate = resolveLocalRef(root, responsesValue[key]); | ||
| 260 | if (!isRecord(candidate) || !isRecord(candidate.content)) { | ||
| 261 | continue; | ||
| 262 | } | ||
| 263 | |||
| 264 | const content = candidate.content; | ||
| 265 | const jsonMedia = | ||
| 266 | (content["application/json"] as Record<string, unknown> | undefined) | ||
| 267 | ?? (content["application/*+json"] as Record<string, unknown> | undefined); | ||
| 268 | |||
| 269 | if (jsonMedia && isRecord(jsonMedia.schema)) { | ||
| 270 | return jsonMedia.schema; | ||
| 271 | } | ||
| 272 | |||
| 273 | for (const mediaType of Object.values(content)) { | ||
| 274 | if (isRecord(mediaType) && isRecord(mediaType.schema)) { | ||
| 275 | return mediaType.schema; | ||
| 276 | } | ||
| 277 | } | ||
| 278 | } | ||
| 279 | |||
| 280 | return null; | ||
| 281 | }; | ||
| 282 | |||
| 283 | const buildInputSchema = ( | ||
| 284 | root: unknown, | ||
| 285 | parameters: Array<Record<string, unknown>>, | ||
| 286 | requestBody: { | ||
| 287 | required: boolean; | ||
| 288 | schema: unknown; | ||
| 289 | } | null, | ||
| 290 | ): { schemaJson: string; refHintKeys: Array<string> } | null => { | ||
| 291 | const properties: Record<string, unknown> = {}; | ||
| 292 | const required = new Set<string>(); | ||
| 293 | const refKeys = new Set<string>(); | ||
| 294 | |||
| 295 | for (const parameter of parameters) { | ||
| 296 | const resolved = resolveLocalRef(root, parameter); | ||
| 297 | if (!isRecord(resolved)) { | ||
| 298 | continue; | ||
| 299 | } | ||
| 300 | |||
| 301 | const location = normalizeText(resolved.in)?.toLowerCase(); | ||
| 302 | if ( | ||
| 303 | location !== "path" | ||
| 304 | && location !== "query" | ||
| 305 | && location !== "header" | ||
| 306 | && location !== "cookie" | ||
| 307 | ) { | ||
| 308 | continue; | ||
| 309 | } | ||
| 310 | |||
| 311 | const name = normalizeText(resolved.name); | ||
| 312 | if (!name) { | ||
| 313 | continue; | ||
| 314 | } | ||
| 315 | |||
| 316 | const schema = extractParameterSchema(root, resolved); | ||
| 317 | properties[name] = schema; | ||
| 318 | collectLocalRefKeys(schema, refKeys); | ||
| 319 | |||
| 320 | const isRequired = resolved.required === true || location === "path"; | ||
| 321 | if (isRequired) { | ||
| 322 | required.add(name); | ||
| 323 | } | ||
| 324 | } | ||
| 325 | |||
| 326 | if (requestBody) { | ||
| 327 | properties.body = requestBody.schema; | ||
| 328 | collectLocalRefKeys(requestBody.schema, refKeys); | ||
| 329 | if (requestBody.required) { | ||
| 330 | required.add("body"); | ||
| 331 | } | ||
| 332 | } | ||
| 333 | |||
| 334 | if (Object.keys(properties).length === 0) { | ||
| 335 | return null; | ||
| 336 | } | ||
| 337 | |||
| 338 | return { | ||
| 339 | schemaJson: JSON.stringify({ | ||
| 340 | type: "object", | ||
| 341 | properties, | ||
| 342 | ...(required.size > 0 ? { required: Array.from(required).sort() } : {}), | ||
| 343 | }), | ||
| 344 | refHintKeys: Array.from(refKeys).sort(), | ||
| 345 | }; | ||
| 346 | }; | ||
| 347 | |||
| 348 | const buildToolId = ( | ||
| 349 | method: HttpMethod, | ||
| 350 | path: string, | ||
| 351 | operation: Record<string, unknown>, | ||
| 352 | ): string => { | ||
| 353 | const operationId = normalizeText(operation.operationId); | ||
| 354 | if (operationId) { | ||
| 355 | const normalized = normalizeToolId(operationId); | ||
| 356 | if (normalized.length > 0) { | ||
| 357 | return normalized; | ||
| 358 | } | ||
| 359 | } | ||
| 360 | |||
| 361 | const rawSegments = path | ||
| 362 | .split("/") | ||
| 363 | .map((segment) => segment.trim()) | ||
| 364 | .filter((segment) => segment.length > 0) | ||
| 365 | .map((segment) => { | ||
| 366 | if (segment.startsWith("{") && segment.endsWith("}")) { | ||
| 367 | return segment.slice(1, -1); | ||
| 368 | } | ||
| 369 | return segment; | ||
| 370 | }) | ||
| 371 | .map((segment) => normalizeSegment(segment)) | ||
| 372 | .filter((segment) => segment.length > 0); | ||
| 373 | |||
| 374 | const segments = rawSegments.length > 0 ? rawSegments.slice(0, 6) : ["operation"]; | ||
| 375 | return normalizeToolId(`${segments.join(".")}.${method}`); | ||
| 376 | }; | ||
| 377 | |||
| 378 | const dedupeToolIds = (tools: Array<ExtractedTool>): Array<ExtractedTool> => { | ||
| 379 | const counts = new Map<string, number>(); | ||
| 380 | |||
| 381 | return tools.map((tool) => { | ||
| 382 | const count = (counts.get(tool.toolId) ?? 0) + 1; | ||
| 383 | counts.set(tool.toolId, count); | ||
| 384 | |||
| 385 | if (count === 1) { | ||
| 386 | return tool; | ||
| 387 | } | ||
| 388 | |||
| 389 | return { | ||
| 390 | ...tool, | ||
| 391 | toolId: `${tool.toolId}_${count}`, | ||
| 392 | }; | ||
| 393 | }); | ||
| 394 | }; | ||
| 395 | |||
| 396 | const buildRefHintTable = ( | ||
| 397 | root: unknown, | ||
| 398 | initialRefs: ReadonlyArray<string>, | ||
| 399 | ): Record<string, string> => { | ||
| 400 | const table: Record<string, string> = {}; | ||
| 401 | const queue = [...initialRefs]; | ||
| 402 | const visited = new Set<string>(); | ||
| 403 | |||
| 404 | while (queue.length > 0) { | ||
| 405 | const ref = queue.shift(); | ||
| 406 | if (!ref || visited.has(ref)) { | ||
| 407 | continue; | ||
| 408 | } | ||
| 409 | visited.add(ref); | ||
| 410 | |||
| 411 | const resolved = getByJsonPointer(root, ref); | ||
| 412 | if (resolved === null) { | ||
| 413 | continue; | ||
| 414 | } | ||
| 415 | |||
| 416 | table[ref] = JSON.stringify(resolved); | ||
| 417 | |||
| 418 | const nestedRefs = new Set<string>(); | ||
| 419 | collectLocalRefKeys(resolved, nestedRefs); | ||
| 420 | for (const nestedRef of nestedRefs) { | ||
| 421 | if (!visited.has(nestedRef)) { | ||
| 422 | queue.push(nestedRef); | ||
| 423 | } | ||
| 424 | } | ||
| 425 | } | ||
| 426 | |||
| 427 | return table; | ||
| 428 | }; | ||
| 429 | |||
| 430 | export const extractOpenApiManifest = ( | ||
| 431 | _sourceName: string, | ||
| 432 | openApiSpec: unknown, | ||
| 433 | ): OpenApiManifest => { | ||
| 434 | if (!isRecord(openApiSpec)) { | ||
| 435 | throw new Error("OpenAPI document must be an object"); | ||
| 436 | } | ||
| 437 | |||
| 438 | const paths = openApiSpec.paths; | ||
| 439 | if (!isRecord(paths)) { | ||
| 440 | throw new Error("OpenAPI document is missing paths"); | ||
| 441 | } | ||
| 442 | |||
| 443 | const tools: Array<ExtractedTool> = []; | ||
| 444 | const globalRefKeys = new Set<string>(); | ||
| 445 | |||
| 446 | for (const [path, pathItemValue] of Object.entries(paths)) { | ||
| 447 | if (!isRecord(pathItemValue)) { | ||
| 448 | continue; | ||
| 449 | } | ||
| 450 | |||
| 451 | const sharedParameters = Array.isArray(pathItemValue.parameters) | ||
| 452 | ? pathItemValue.parameters.filter((entry): entry is Record<string, unknown> => isRecord(entry)) | ||
| 453 | : []; | ||
| 454 | |||
| 455 | for (const method of httpMethods) { | ||
| 456 | const operationValue = pathItemValue[method]; | ||
| 457 | if (!isRecord(operationValue)) { | ||
| 458 | continue; | ||
| 459 | } | ||
| 460 | |||
| 461 | const operationParameters = Array.isArray(operationValue.parameters) | ||
| 462 | ? operationValue.parameters.filter((entry): entry is Record<string, unknown> => isRecord(entry)) | ||
| 463 | : []; | ||
| 464 | const parameters = [...sharedParameters, ...operationParameters]; | ||
| 465 | const requestBody = extractRequestBody(openApiSpec, operationValue); | ||
| 466 | |||
| 467 | const invocation = { | ||
| 468 | method, | ||
| 469 | pathTemplate: path, | ||
| 470 | parameters: parameters | ||
| 471 | .map((parameter) => resolveLocalRef(openApiSpec, parameter)) | ||
| 472 | .filter((parameter): parameter is Record<string, unknown> => isRecord(parameter)) | ||
| 473 | .map((parameter) => ({ | ||
| 474 | name: normalizeText(parameter.name) ?? "", | ||
| 475 | location: | ||
| 476 | (normalizeText(parameter.in)?.toLowerCase() as OpenApiParameterLocation | undefined) | ||
| 477 | ?? "query", | ||
| 478 | required: | ||
| 479 | parameter.required === true | ||
| 480 | || normalizeText(parameter.in)?.toLowerCase() === "path", | ||
| 481 | })) | ||
| 482 | .filter((parameter) => | ||
| 483 | parameter.name.length > 0 | ||
| 484 | && ( | ||
| 485 | parameter.location === "path" | ||
| 486 | || parameter.location === "query" | ||
| 487 | || parameter.location === "header" | ||
| 488 | || parameter.location === "cookie" | ||
| 489 | )) | ||
| 490 | .sort((left, right) => | ||
| 491 | left.location === right.location | ||
| 492 | ? left.name.localeCompare(right.name) | ||
| 493 | : left.location.localeCompare(right.location)), | ||
| 494 | requestBody: requestBody | ||
| 495 | ? { | ||
| 496 | required: requestBody.required, | ||
| 497 | contentTypes: requestBody.contentTypes, | ||
| 498 | } | ||
| 499 | : null, | ||
| 500 | }; | ||
| 501 | |||
| 502 | const inputTyping = buildInputSchema(openApiSpec, parameters, requestBody); | ||
| 503 | const outputSchema = extractResponseSchema(openApiSpec, operationValue); | ||
| 504 | const outputSchemaJson = outputSchema === null ? null : JSON.stringify(outputSchema); | ||
| 505 | if (outputSchema !== null) { | ||
| 506 | collectLocalRefKeys(outputSchema, globalRefKeys); | ||
| 507 | } | ||
| 508 | |||
| 509 | if (inputTyping) { | ||
| 510 | for (const refKey of inputTyping.refHintKeys) { | ||
| 511 | globalRefKeys.add(refKey); | ||
| 512 | } | ||
| 513 | } | ||
| 514 | |||
| 515 | const name = | ||
| 516 | normalizeText(operationValue.summary) | ||
| 517 | ?? normalizeText(operationValue.operationId) | ||
| 518 | ?? `${method.toUpperCase()} ${path}`; | ||
| 519 | const description = | ||
| 520 | normalizeText(operationValue.description) | ||
| 521 | ?? normalizeText(operationValue.summary) | ||
| 522 | ?? null; | ||
| 523 | const toolId = buildToolId(method, path, operationValue); | ||
| 524 | |||
| 525 | tools.push({ | ||
| 526 | toolId, | ||
| 527 | name, | ||
| 528 | description, | ||
| 529 | method, | ||
| 530 | path, | ||
| 531 | invocation, | ||
| 532 | operationHash: hashUnknown({ | ||
| 533 | method, | ||
| 534 | path, | ||
| 535 | invocation, | ||
| 536 | inputSchemaJson: inputTyping?.schemaJson ?? null, | ||
| 537 | outputSchemaJson, | ||
| 538 | }), | ||
| 539 | typing: { | ||
| 540 | ...(inputTyping ? { inputSchemaJson: inputTyping.schemaJson } : {}), | ||
| 541 | ...(outputSchemaJson ? { outputSchemaJson } : {}), | ||
| 542 | ...(inputTyping && inputTyping.refHintKeys.length > 0 | ||
| 543 | ? { refHintKeys: inputTyping.refHintKeys } | ||
| 544 | : {}), | ||
| 545 | }, | ||
| 546 | }); | ||
| 547 | } | ||
| 548 | } | ||
| 549 | |||
| 550 | const deduped = dedupeToolIds(tools); | ||
| 551 | const refHintTable = buildRefHintTable(openApiSpec, Array.from(globalRefKeys)); | ||
| 552 | |||
| 553 | return { | ||
| 554 | sourceHash: hashUnknown({ | ||
| 555 | tools: deduped.map((tool) => ({ | ||
| 556 | toolId: tool.toolId, | ||
| 557 | operationHash: tool.operationHash, | ||
| 558 | })), | ||
| 559 | refKeys: Object.keys(refHintTable).sort(), | ||
| 560 | }), | ||
| 561 | tools: deduped, | ||
| 562 | refHintTable, | ||
| 563 | }; | ||
| 564 | }; | ||
| 565 | |||
| 566 | const parseOpenApiDocument = (input: string): unknown => { | ||
| 567 | const text = input.trim(); | ||
| 568 | if (text.length === 0) { | ||
| 569 | throw new Error("OpenAPI document is empty"); | ||
| 570 | } | ||
| 571 | |||
| 572 | try { | ||
| 573 | return parseJsonDocument(text); | ||
| 574 | } catch { | ||
| 575 | try { | ||
| 576 | return parseYamlDocument(text); | ||
| 577 | } catch (cause) { | ||
| 578 | throw new Error( | ||
| 579 | `Unable to parse OpenAPI document as JSON or YAML: ${ | ||
| 580 | cause instanceof Error ? cause.message : String(cause) | ||
| 581 | }`, | ||
| 582 | ); | ||
| 583 | } | ||
| 584 | } | ||
| 585 | }; | ||
| 586 | |||
| 587 | const readRawBody = async (request: AsyncIterable<unknown>): Promise<string> => { | ||
| 588 | const chunks: Array<Buffer> = []; | ||
| 589 | let bytes = 0; | ||
| 590 | |||
| 591 | for await (const chunk of request) { | ||
| 592 | const buffer = Buffer.isBuffer(chunk) | ||
| 593 | ? chunk | ||
| 594 | : typeof chunk === "string" | ||
| 595 | ? Buffer.from(chunk) | ||
| 596 | : chunk instanceof Uint8Array | ||
| 597 | ? Buffer.from(chunk) | ||
| 598 | : Buffer.from(String(chunk)); | ||
| 599 | bytes += buffer.length; | ||
| 600 | if (bytes > maxBodyBytes) { | ||
| 601 | throw new Error("Request body too large"); | ||
| 602 | } | ||
| 603 | chunks.push(buffer); | ||
| 604 | } | ||
| 605 | |||
| 606 | return Buffer.concat(chunks).toString("utf8"); | ||
| 607 | }; | ||
| 608 | |||
| 609 | const json = ( | ||
| 610 | response: any, | ||
| 611 | status: number, | ||
| 612 | payload: Record<string, unknown>, | ||
| 613 | ): void => { | ||
| 614 | response.status(status).setHeader("content-type", "application/json; charset=utf-8"); | ||
| 615 | response.send(JSON.stringify(payload)); | ||
| 616 | }; | ||
| 617 | |||
| 618 | const normalizeNamespacePart = (value: string): string => { | ||
| 619 | const normalized = value | ||
| 620 | .trim() | ||
| 621 | .toLowerCase() | ||
| 622 | .replace(/[^a-z0-9]+/g, "_") | ||
| 623 | .replace(/^_+|_+$/g, ""); | ||
| 624 | |||
| 625 | return normalized.length > 0 ? normalized : "source"; | ||
| 626 | }; | ||
| 627 | |||
| 628 | const sourceNamespace = (sourceName: string, sourceId: string): string => { | ||
| 629 | const sourceIdSuffix = sourceId.slice(-6).toLowerCase(); | ||
| 630 | return `${normalizeNamespacePart(sourceName)}_${sourceIdSuffix}`; | ||
| 631 | }; | ||
| 632 | |||
| 633 | const parseSourceEnabled = (value: unknown): boolean => | ||
| 634 | typeof value === "boolean" ? value : true; | ||
| 635 | |||
| 636 | const toIngestPayload = async ( | ||
| 637 | openApiSpec: unknown, | ||
| 638 | input: { | ||
| 639 | convexUrl: string; | ||
| 640 | ingestToken: string; | ||
| 641 | workspaceId: string; | ||
| 642 | sourceId: string; | ||
| 643 | sourceName: string; | ||
| 644 | sourceEndpoint: string; | ||
| 645 | sourceEnabled: boolean; | ||
| 646 | }, | ||
| 647 | ): Promise<{ | ||
| 648 | artifactId: string; | ||
| 649 | sourceHash: string; | ||
| 650 | toolCount: number; | ||
| 651 | namespace: string; | ||
| 652 | }> => { | ||
| 653 | const manifest = extractOpenApiManifest(input.sourceName, openApiSpec); | ||
| 654 | |||
| 655 | const refs = Object.entries(manifest.refHintTable ?? {}).map(([refKey, schemaJson]) => ({ | ||
| 656 | refKey, | ||
| 657 | schemaJson, | ||
| 658 | })); | ||
| 659 | |||
| 660 | const tools = manifest.tools.map((tool) => ({ | ||
| 661 | toolId: tool.toolId, | ||
| 662 | name: tool.name, | ||
| 663 | description: tool.description, | ||
| 664 | method: tool.method, | ||
| 665 | path: tool.path, | ||
| 666 | operationHash: tool.operationHash, | ||
| 667 | invocationJson: JSON.stringify(tool.invocation), | ||
| 668 | inputSchemaJson: tool.typing?.inputSchemaJson ?? null, | ||
| 669 | outputSchemaJson: tool.typing?.outputSchemaJson ?? null, | ||
| 670 | })); | ||
| 671 | |||
| 672 | const convex = new ConvexHttpClient(input.convexUrl); | ||
| 673 | const result = await (convex as any).action("control_plane/tool_registry:ingestOpenApiManifest", { | ||
| 674 | token: input.ingestToken, | ||
| 675 | workspaceId: input.workspaceId, | ||
| 676 | sourceId: input.sourceId, | ||
| 677 | sourceName: input.sourceName, | ||
| 678 | sourceEndpoint: input.sourceEndpoint, | ||
| 679 | sourceEnabled: input.sourceEnabled, | ||
| 680 | sourceHash: manifest.sourceHash, | ||
| 681 | toolCount: manifest.tools.length, | ||
| 682 | refs, | ||
| 683 | tools, | ||
| 684 | }) as { | ||
| 685 | artifactId: string; | ||
| 686 | }; | ||
| 687 | |||
| 688 | return { | ||
| 689 | artifactId: result.artifactId, | ||
| 690 | sourceHash: manifest.sourceHash, | ||
| 691 | toolCount: manifest.tools.length, | ||
| 692 | namespace: sourceNamespace(input.sourceName, input.sourceId), | ||
| 693 | }; | ||
| 694 | }; | ||
| 695 | |||
| 696 | const parseEndpoint = async (request: any, response: any) => { | ||
| 697 | if (request.method !== "POST") { | ||
| 698 | response.setHeader("allow", "POST"); | ||
| 699 | json(response, 405, { error: "Method not allowed" }); | ||
| 700 | return; | ||
| 701 | } | ||
| 702 | |||
| 703 | try { | ||
| 704 | const expectedToken = process.env.OPENAPI_PARSE_API_TOKEN?.trim(); | ||
| 705 | const provided = | ||
| 706 | typeof request.headers["x-openapi-parse-token"] === "string" | ||
| 707 | ? request.headers["x-openapi-parse-token"].trim() | ||
| 708 | : ""; | ||
| 709 | if (expectedToken && expectedToken.length > 0 && provided !== expectedToken) { | ||
| 710 | json(response, 401, { error: "Unauthorized" }); | ||
| 711 | return; | ||
| 712 | } | ||
| 713 | |||
| 714 | const rawBody = await readRawBody(request); | ||
| 715 | const payload = JSON.parse(rawBody) as Record<string, unknown>; | ||
| 716 | const specUrl = typeof payload.specUrl === "string" ? payload.specUrl.trim() : ""; | ||
| 717 | |||
| 718 | if (specUrl.length === 0) { | ||
| 719 | json(response, 400, { error: "specUrl is required" }); | ||
| 720 | return; | ||
| 721 | } | ||
| 722 | |||
| 723 | const parsedUrl = new URL(specUrl); | ||
| 724 | const protocol = parsedUrl.protocol.toLowerCase(); | ||
| 725 | if (protocol !== "https:" && protocol !== "http:") { | ||
| 726 | json(response, 400, { error: "specUrl must use http:// or https://" }); | ||
| 727 | return; | ||
| 728 | } | ||
| 729 | |||
| 730 | const upstream = await fetch(specUrl); | ||
| 731 | if (!upstream.ok) { | ||
| 732 | json(response, 502, { | ||
| 733 | error: "Failed fetching OpenAPI document", | ||
| 734 | status: upstream.status, | ||
| 735 | statusText: upstream.statusText, | ||
| 736 | }); | ||
| 737 | return; | ||
| 738 | } | ||
| 739 | |||
| 740 | const bodyText = await upstream.text(); | ||
| 741 | const openApiSpec = parseOpenApiDocument(bodyText); | ||
| 742 | |||
| 743 | const workspaceId = typeof payload.workspaceId === "string" ? payload.workspaceId.trim() : ""; | ||
| 744 | const sourceId = typeof payload.sourceId === "string" ? payload.sourceId.trim() : ""; | ||
| 745 | const sourceName = typeof payload.sourceName === "string" ? payload.sourceName.trim() : ""; | ||
| 746 | |||
| 747 | const convexUrl = | ||
| 748 | process.env.CONVEX_URL?.trim() | ||
| 749 | || process.env.NEXT_PUBLIC_CONVEX_URL?.trim() | ||
| 750 | || ""; | ||
| 751 | const ingestToken = | ||
| 752 | process.env.OPENAPI_INGEST_SERVICE_TOKEN?.trim() | ||
| 753 | || process.env.OPENAPI_PARSE_API_TOKEN?.trim() | ||
| 754 | || ""; | ||
| 755 | |||
| 756 | const shouldIngest = | ||
| 757 | workspaceId.length > 0 | ||
| 758 | && sourceId.length > 0 | ||
| 759 | && sourceName.length > 0 | ||
| 760 | && convexUrl.length > 0; | ||
| 761 | |||
| 762 | if (shouldIngest) { | ||
| 763 | const ingested = await toIngestPayload(openApiSpec, { | ||
| 764 | convexUrl, | ||
| 765 | ingestToken, | ||
| 766 | workspaceId, | ||
| 767 | sourceId, | ||
| 768 | sourceName, | ||
| 769 | sourceEndpoint: specUrl, | ||
| 770 | sourceEnabled: parseSourceEnabled(payload.sourceEnabled), | ||
| 771 | }); | ||
| 772 | |||
| 773 | json(response, 200, { | ||
| 774 | ok: true, | ||
| 775 | mode: "ingested", | ||
| 776 | specUrl, | ||
| 777 | artifactId: ingested.artifactId, | ||
| 778 | sourceHash: ingested.sourceHash, | ||
| 779 | toolCount: ingested.toolCount, | ||
| 780 | namespace: ingested.namespace, | ||
| 781 | artifactBatchCount: 0, | ||
| 782 | }); | ||
| 783 | return; | ||
| 784 | } | ||
| 785 | |||
| 786 | json(response, 200, { | ||
| 787 | ok: true, | ||
| 788 | mode: "parsed", | ||
| 789 | specUrl, | ||
| 790 | openApiSpec, | ||
| 791 | }); | ||
| 792 | } catch (cause) { | ||
| 793 | json(response, 500, { | ||
| 794 | ok: false, | ||
| 795 | error: cause instanceof Error ? cause.message : String(cause), | ||
| 796 | }); | ||
| 797 | } | ||
| 798 | }; | ||
| 799 | |||
| 800 | export const config = { | ||
| 801 | api: { | ||
| 802 | bodyParser: false, | ||
| 803 | }, | ||
| 804 | }; | ||
| 805 | |||
| 806 | export default parseEndpoint; | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../convex/bin/main.js | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../typescript/bin/tsc | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../typescript/bin/tsserver | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../vitest/vitest.mjs | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../yaml/bin.mjs | ||
| @@ -0,0 +1 @@ | |||
| 1 | {"version":"3.2.4","results":[[":api/parse-openapi.fidelity.test.ts",{"duration":15450.162534,"failed":false}]]} | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@effect+vitest@0.27.0+745106daec5afff3/node_modules/@effect/vitest | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@types+node@20.19.33/node_modules/@types/node | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/convex@1.32.0+b1ab299f0a400331/node_modules/convex | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/effect@3.19.19/node_modules/effect | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/typescript@5.9.3/node_modules/typescript | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/vitest@3.2.4+dddfa60a3fc73abb/node_modules/vitest | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/yaml@2.8.2/node_modules/yaml | ||
| @@ -0,0 +1,19 @@ | |||
| 1 | { | ||
| 2 | "name": "@executor-v2/app-api", | ||
| 3 | "private": true, | ||
| 4 | "type": "module", | ||
| 5 | "scripts": { | ||
| 6 | "dev:disabled": "bunx vercel dev --listen 8788" | ||
| 7 | }, | ||
| 8 | "dependencies": { | ||
| 9 | "convex": "^1.32.0", | ||
| 10 | "yaml": "^2.8.1" | ||
| 11 | }, | ||
| 12 | "devDependencies": { | ||
| 13 | "@effect/vitest": "^0.27.0", | ||
| 14 | "@types/node": "^20.19.9", | ||
| 15 | "effect": "^3.19.8", | ||
| 16 | "typescript": "^5.9.3", | ||
| 17 | "vitest": "^3.2.4" | ||
| 18 | } | ||
| 19 | } | ||
| @@ -0,0 +1,9 @@ | |||
| 1 | { | ||
| 2 | "$schema": "https://openapi.vercel.sh/vercel.json", | ||
| 3 | "rewrites": [ | ||
| 4 | { | ||
| 5 | "source": "/parse-openapi", | ||
| 6 | "destination": "/api/parse-openapi" | ||
| 7 | } | ||
| 8 | ] | ||
| 9 | } | ||
| @@ -0,0 +1,3 @@ | |||
| 1 | # app-cli | ||
| 2 | |||
| 3 | CLI app scaffold for Executor v2. | ||
| @@ -0,0 +1,8 @@ | |||
| 1 | { | ||
| 2 | "name": "@executor-v2/app-cli", | ||
| 3 | "private": true, | ||
| 4 | "type": "module", | ||
| 5 | "scripts": { | ||
| 6 | "typecheck": "bunx tsc --noEmit -p tsconfig.json" | ||
| 7 | } | ||
| 8 | } | ||
| @@ -0,0 +1 @@ | |||
| 1 | export {}; | ||
| @@ -0,0 +1,4 @@ | |||
| 1 | { | ||
| 2 | "extends": "../../tsconfig.json", | ||
| 3 | "include": ["src"] | ||
| 4 | } | ||
| @@ -0,0 +1,2 @@ | |||
| 1 | |||
| 2 | .env.local | ||
| @@ -0,0 +1,11 @@ | |||
| 1 | # app-convex | ||
| 2 | |||
| 3 | Convex remote server app scaffold for Executor v2. | ||
| 4 | |||
| 5 | Current scaffold includes: | ||
| 6 | Convex schema wiring lives directly in `convex/schema.ts` | ||
| 7 | MCP HTTP endpoint at `GET/POST/DELETE /v1/mcp` via `convex/http.ts` and `convex/mcp.ts` | ||
| 8 | runtime callback endpoint at `POST /v1/runtime/tool-call` | ||
| 9 | control-plane source endpoints at `GET/POST /v1/workspaces/:workspaceId/sources` | ||
| 10 | control-plane source removal endpoint at `DELETE /v1/workspaces/:workspaceId/sources/:sourceId` | ||
| 11 | generated OpenAPI spec endpoint at `GET /v1/openapi.json` | ||
| @@ -0,0 +1,90 @@ | |||
| 1 | # Welcome to your Convex functions directory! | ||
| 2 | |||
| 3 | Write your Convex functions here. | ||
| 4 | See https://docs.convex.dev/functions for more. | ||
| 5 | |||
| 6 | A query function that takes two arguments looks like: | ||
| 7 | |||
| 8 | ```ts | ||
| 9 | // convex/myFunctions.ts | ||
| 10 | import { query } from "./_generated/server"; | ||
| 11 | import { v } from "convex/values"; | ||
| 12 | |||
| 13 | export const myQueryFunction = query({ | ||
| 14 | // Validators for arguments. | ||
| 15 | args: { | ||
| 16 | first: v.number(), | ||
| 17 | second: v.string(), | ||
| 18 | }, | ||
| 19 | |||
| 20 | // Function implementation. | ||
| 21 | handler: async (ctx, args) => { | ||
| 22 | // Read the database as many times as you need here. | ||
| 23 | // See https://docs.convex.dev/database/reading-data. | ||
| 24 | const documents = await ctx.db.query("tablename").collect(); | ||
| 25 | |||
| 26 | // Arguments passed from the client are properties of the args object. | ||
| 27 | console.log(args.first, args.second); | ||
| 28 | |||
| 29 | // Write arbitrary JavaScript here: filter, aggregate, build derived data, | ||
| 30 | // remove non-public properties, or create new objects. | ||
| 31 | return documents; | ||
| 32 | }, | ||
| 33 | }); | ||
| 34 | ``` | ||
| 35 | |||
| 36 | Using this query function in a React component looks like: | ||
| 37 | |||
| 38 | ```ts | ||
| 39 | const data = useQuery(api.myFunctions.myQueryFunction, { | ||
| 40 | first: 10, | ||
| 41 | second: "hello", | ||
| 42 | }); | ||
| 43 | ``` | ||
| 44 | |||
| 45 | A mutation function looks like: | ||
| 46 | |||
| 47 | ```ts | ||
| 48 | // convex/myFunctions.ts | ||
| 49 | import { mutation } from "./_generated/server"; | ||
| 50 | import { v } from "convex/values"; | ||
| 51 | |||
| 52 | export const myMutationFunction = mutation({ | ||
| 53 | // Validators for arguments. | ||
| 54 | args: { | ||
| 55 | first: v.string(), | ||
| 56 | second: v.string(), | ||
| 57 | }, | ||
| 58 | |||
| 59 | // Function implementation. | ||
| 60 | handler: async (ctx, args) => { | ||
| 61 | // Insert or modify documents in the database here. | ||
| 62 | // Mutations can also read from the database like queries. | ||
| 63 | // See https://docs.convex.dev/database/writing-data. | ||
| 64 | const message = { body: args.first, author: args.second }; | ||
| 65 | const id = await ctx.db.insert("messages", message); | ||
| 66 | |||
| 67 | // Optionally, return a value from your mutation. | ||
| 68 | return await ctx.db.get("messages", id); | ||
| 69 | }, | ||
| 70 | }); | ||
| 71 | ``` | ||
| 72 | |||
| 73 | Using this mutation function in a React component looks like: | ||
| 74 | |||
| 75 | ```ts | ||
| 76 | const mutation = useMutation(api.myFunctions.myMutationFunction); | ||
| 77 | function handleButtonPress() { | ||
| 78 | // fire and forget, the most common way to use mutations | ||
| 79 | mutation({ first: "Hello!", second: "me" }); | ||
| 80 | // OR | ||
| 81 | // use the result once the mutation has completed | ||
| 82 | mutation({ first: "Hello!", second: "me" }).then((result) => | ||
| 83 | console.log(result), | ||
| 84 | ); | ||
| 85 | } | ||
| 86 | ``` | ||
| 87 | |||
| 88 | Use the Convex CLI to push your functions to a deployment. See everything | ||
| 89 | the Convex CLI can do by running `npx convex -h` in your project root | ||
| 90 | directory. To learn more, launch the docs with `npx convex docs`. | ||
| @@ -0,0 +1,558 @@ | |||
| 1 | /* eslint-disable */ | ||
| 2 | /** | ||
| 3 | * Generated `api` utility. | ||
| 4 | * | ||
| 5 | * THIS CODE IS AUTOMATICALLY GENERATED. | ||
| 6 | * | ||
| 7 | * To regenerate, run `npx convex dev`. | ||
| 8 | * @module | ||
| 9 | */ | ||
| 10 | |||
| 11 | import type * as controlPlane from "../controlPlane.js"; | ||
| 12 | import type * as control_plane_actor from "../control_plane/actor.js"; | ||
| 13 | import type * as control_plane_approvals from "../control_plane/approvals.js"; | ||
| 14 | import type * as control_plane_credentials from "../control_plane/credentials.js"; | ||
| 15 | import type * as control_plane_errors from "../control_plane/errors.js"; | ||
| 16 | import type * as control_plane_http from "../control_plane/http.js"; | ||
| 17 | import type * as control_plane_openapi_ingest from "../control_plane/openapi_ingest.js"; | ||
| 18 | import type * as control_plane_organizations from "../control_plane/organizations.js"; | ||
| 19 | import type * as control_plane_policies from "../control_plane/policies.js"; | ||
| 20 | import type * as control_plane_service from "../control_plane/service.js"; | ||
| 21 | import type * as control_plane_sources from "../control_plane/sources.js"; | ||
| 22 | import type * as control_plane_storage from "../control_plane/storage.js"; | ||
| 23 | import type * as control_plane_tool_registry from "../control_plane/tool_registry.js"; | ||
| 24 | import type * as control_plane_tools from "../control_plane/tools.js"; | ||
| 25 | import type * as control_plane_workspaces from "../control_plane/workspaces.js"; | ||
| 26 | import type * as credential_crypto from "../credential_crypto.js"; | ||
| 27 | import type * as credential_resolver from "../credential_resolver.js"; | ||
| 28 | import type * as executor from "../executor.js"; | ||
| 29 | import type * as http from "../http.js"; | ||
| 30 | import type * as mcp from "../mcp.js"; | ||
| 31 | import type * as mcp_auth from "../mcp_auth.js"; | ||
| 32 | import type * as run_executor from "../run_executor.js"; | ||
| 33 | import type * as runtimeCallbacks from "../runtimeCallbacks.js"; | ||
| 34 | import type * as runtime_adapter from "../runtime_adapter.js"; | ||
| 35 | import type * as runtime_execution_port from "../runtime_execution_port.js"; | ||
| 36 | import type * as source_tool_registry from "../source_tool_registry.js"; | ||
| 37 | import type * as task_runs from "../task_runs.js"; | ||
| 38 | import type * as workflow from "../workflow.js"; | ||
| 39 | |||
| 40 | import type { | ||
| 41 | ApiFromModules, | ||
| 42 | FilterApi, | ||
| 43 | FunctionReference, | ||
| 44 | } from "convex/server"; | ||
| 45 | |||
| 46 | declare const fullApi: ApiFromModules<{ | ||
| 47 | controlPlane: typeof controlPlane; | ||
| 48 | "control_plane/actor": typeof control_plane_actor; | ||
| 49 | "control_plane/approvals": typeof control_plane_approvals; | ||
| 50 | "control_plane/credentials": typeof control_plane_credentials; | ||
| 51 | "control_plane/errors": typeof control_plane_errors; | ||
| 52 | "control_plane/http": typeof control_plane_http; | ||
| 53 | "control_plane/openapi_ingest": typeof control_plane_openapi_ingest; | ||
| 54 | "control_plane/organizations": typeof control_plane_organizations; | ||
| 55 | "control_plane/policies": typeof control_plane_policies; | ||
| 56 | "control_plane/service": typeof control_plane_service; | ||
| 57 | "control_plane/sources": typeof control_plane_sources; | ||
| 58 | "control_plane/storage": typeof control_plane_storage; | ||
| 59 | "control_plane/tool_registry": typeof control_plane_tool_registry; | ||
| 60 | "control_plane/tools": typeof control_plane_tools; | ||
| 61 | "control_plane/workspaces": typeof control_plane_workspaces; | ||
| 62 | credential_crypto: typeof credential_crypto; | ||
| 63 | credential_resolver: typeof credential_resolver; | ||
| 64 | executor: typeof executor; | ||
| 65 | http: typeof http; | ||
| 66 | mcp: typeof mcp; | ||
| 67 | mcp_auth: typeof mcp_auth; | ||
| 68 | run_executor: typeof run_executor; | ||
| 69 | runtimeCallbacks: typeof runtimeCallbacks; | ||
| 70 | runtime_adapter: typeof runtime_adapter; | ||
| 71 | runtime_execution_port: typeof runtime_execution_port; | ||
| 72 | source_tool_registry: typeof source_tool_registry; | ||
| 73 | task_runs: typeof task_runs; | ||
| 74 | workflow: typeof workflow; | ||
| 75 | }>; | ||
| 76 | |||
| 77 | /** | ||
| 78 | * A utility for referencing Convex functions in your app's public API. | ||
| 79 | * | ||
| 80 | * Usage: | ||
| 81 | * ```js | ||
| 82 | * const myFunctionReference = api.myModule.myFunction; | ||
| 83 | * ``` | ||
| 84 | */ | ||
| 85 | export declare const api: FilterApi< | ||
| 86 | typeof fullApi, | ||
| 87 | FunctionReference<any, "public"> | ||
| 88 | >; | ||
| 89 | |||
| 90 | /** | ||
| 91 | * A utility for referencing Convex functions in your app's internal API. | ||
| 92 | * | ||
| 93 | * Usage: | ||
| 94 | * ```js | ||
| 95 | * const myFunctionReference = internal.myModule.myFunction; | ||
| 96 | * ``` | ||
| 97 | */ | ||
| 98 | export declare const internal: FilterApi< | ||
| 99 | typeof fullApi, | ||
| 100 | FunctionReference<any, "internal"> | ||
| 101 | >; | ||
| 102 | |||
| 103 | export declare const components: { | ||
| 104 | workflow: { | ||
| 105 | event: { | ||
| 106 | create: FunctionReference< | ||
| 107 | "mutation", | ||
| 108 | "internal", | ||
| 109 | { name: string; workflowId: string }, | ||
| 110 | string | ||
| 111 | >; | ||
| 112 | send: FunctionReference< | ||
| 113 | "mutation", | ||
| 114 | "internal", | ||
| 115 | { | ||
| 116 | eventId?: string; | ||
| 117 | name?: string; | ||
| 118 | result: | ||
| 119 | | { kind: "success"; returnValue: any } | ||
| 120 | | { error: string; kind: "failed" } | ||
| 121 | | { kind: "canceled" }; | ||
| 122 | workflowId?: string; | ||
| 123 | workpoolOptions?: { | ||
| 124 | defaultRetryBehavior?: { | ||
| 125 | base: number; | ||
| 126 | initialBackoffMs: number; | ||
| 127 | maxAttempts: number; | ||
| 128 | }; | ||
| 129 | logLevel?: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR"; | ||
| 130 | maxParallelism?: number; | ||
| 131 | retryActionsByDefault?: boolean; | ||
| 132 | }; | ||
| 133 | }, | ||
| 134 | string | ||
| 135 | >; | ||
| 136 | }; | ||
| 137 | journal: { | ||
| 138 | load: FunctionReference< | ||
| 139 | "query", | ||
| 140 | "internal", | ||
| 141 | { shortCircuit?: boolean; workflowId: string }, | ||
| 142 | { | ||
| 143 | blocked?: boolean; | ||
| 144 | journalEntries: Array<{ | ||
| 145 | _creationTime: number; | ||
| 146 | _id: string; | ||
| 147 | step: | ||
| 148 | | { | ||
| 149 | args: any; | ||
| 150 | argsSize: number; | ||
| 151 | completedAt?: number; | ||
| 152 | functionType: "query" | "mutation" | "action"; | ||
| 153 | handle: string; | ||
| 154 | inProgress: boolean; | ||
| 155 | kind?: "function"; | ||
| 156 | name: string; | ||
| 157 | runResult?: | ||
| 158 | | { kind: "success"; returnValue: any } | ||
| 159 | | { error: string; kind: "failed" } | ||
| 160 | | { kind: "canceled" }; | ||
| 161 | startedAt: number; | ||
| 162 | workId?: string; | ||
| 163 | } | ||
| 164 | | { | ||
| 165 | args: any; | ||
| 166 | argsSize: number; | ||
| 167 | completedAt?: number; | ||
| 168 | handle: string; | ||
| 169 | inProgress: boolean; | ||
| 170 | kind: "workflow"; | ||
| 171 | name: string; | ||
| 172 | runResult?: | ||
| 173 | | { kind: "success"; returnValue: any } | ||
| 174 | | { error: string; kind: "failed" } | ||
| 175 | | { kind: "canceled" }; | ||
| 176 | startedAt: number; | ||
| 177 | workflowId?: string; | ||
| 178 | } | ||
| 179 | | { | ||
| 180 | args: { eventId?: string }; | ||
| 181 | argsSize: number; | ||
| 182 | completedAt?: number; | ||
| 183 | eventId?: string; | ||
| 184 | inProgress: boolean; | ||
| 185 | kind: "event"; | ||
| 186 | name: string; | ||
| 187 | runResult?: | ||
| 188 | | { kind: "success"; returnValue: any } | ||
| 189 | | { error: string; kind: "failed" } | ||
| 190 | | { kind: "canceled" }; | ||
| 191 | startedAt: number; | ||
| 192 | }; | ||
| 193 | stepNumber: number; | ||
| 194 | workflowId: string; | ||
| 195 | }>; | ||
| 196 | logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR"; | ||
| 197 | ok: boolean; | ||
| 198 | workflow: { | ||
| 199 | _creationTime: number; | ||
| 200 | _id: string; | ||
| 201 | args: any; | ||
| 202 | generationNumber: number; | ||
| 203 | logLevel?: any; | ||
| 204 | name?: string; | ||
| 205 | onComplete?: { context?: any; fnHandle: string }; | ||
| 206 | runResult?: | ||
| 207 | | { kind: "success"; returnValue: any } | ||
| 208 | | { error: string; kind: "failed" } | ||
| 209 | | { kind: "canceled" }; | ||
| 210 | startedAt?: any; | ||
| 211 | state?: any; | ||
| 212 | workflowHandle: string; | ||
| 213 | }; | ||
| 214 | } | ||
| 215 | >; | ||
| 216 | startSteps: FunctionReference< | ||
| 217 | "mutation", | ||
| 218 | "internal", | ||
| 219 | { | ||
| 220 | generationNumber: number; | ||
| 221 | steps: Array<{ | ||
| 222 | retry?: | ||
| 223 | | boolean | ||
| 224 | | { base: number; initialBackoffMs: number; maxAttempts: number }; | ||
| 225 | schedulerOptions?: { runAt?: number } | { runAfter?: number }; | ||
| 226 | step: | ||
| 227 | | { | ||
| 228 | args: any; | ||
| 229 | argsSize: number; | ||
| 230 | completedAt?: number; | ||
| 231 | functionType: "query" | "mutation" | "action"; | ||
| 232 | handle: string; | ||
| 233 | inProgress: boolean; | ||
| 234 | kind?: "function"; | ||
| 235 | name: string; | ||
| 236 | runResult?: | ||
| 237 | | { kind: "success"; returnValue: any } | ||
| 238 | | { error: string; kind: "failed" } | ||
| 239 | | { kind: "canceled" }; | ||
| 240 | startedAt: number; | ||
| 241 | workId?: string; | ||
| 242 | } | ||
| 243 | | { | ||
| 244 | args: any; | ||
| 245 | argsSize: number; | ||
| 246 | completedAt?: number; | ||
| 247 | handle: string; | ||
| 248 | inProgress: boolean; | ||
| 249 | kind: "workflow"; | ||
| 250 | name: string; | ||
| 251 | runResult?: | ||
| 252 | | { kind: "success"; returnValue: any } | ||
| 253 | | { error: string; kind: "failed" } | ||
| 254 | | { kind: "canceled" }; | ||
| 255 | startedAt: number; | ||
| 256 | workflowId?: string; | ||
| 257 | } | ||
| 258 | | { | ||
| 259 | args: { eventId?: string }; | ||
| 260 | argsSize: number; | ||
| 261 | completedAt?: number; | ||
| 262 | eventId?: string; | ||
| 263 | inProgress: boolean; | ||
| 264 | kind: "event"; | ||
| 265 | name: string; | ||
| 266 | runResult?: | ||
| 267 | | { kind: "success"; returnValue: any } | ||
| 268 | | { error: string; kind: "failed" } | ||
| 269 | | { kind: "canceled" }; | ||
| 270 | startedAt: number; | ||
| 271 | }; | ||
| 272 | }>; | ||
| 273 | workflowId: string; | ||
| 274 | workpoolOptions?: { | ||
| 275 | defaultRetryBehavior?: { | ||
| 276 | base: number; | ||
| 277 | initialBackoffMs: number; | ||
| 278 | maxAttempts: number; | ||
| 279 | }; | ||
| 280 | logLevel?: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR"; | ||
| 281 | maxParallelism?: number; | ||
| 282 | retryActionsByDefault?: boolean; | ||
| 283 | }; | ||
| 284 | }, | ||
| 285 | Array<{ | ||
| 286 | _creationTime: number; | ||
| 287 | _id: string; | ||
| 288 | step: | ||
| 289 | | { | ||
| 290 | args: any; | ||
| 291 | argsSize: number; | ||
| 292 | completedAt?: number; | ||
| 293 | functionType: "query" | "mutation" | "action"; | ||
| 294 | handle: string; | ||
| 295 | inProgress: boolean; | ||
| 296 | kind?: "function"; | ||
| 297 | name: string; | ||
| 298 | runResult?: | ||
| 299 | | { kind: "success"; returnValue: any } | ||
| 300 | | { error: string; kind: "failed" } | ||
| 301 | | { kind: "canceled" }; | ||
| 302 | startedAt: number; | ||
| 303 | workId?: string; | ||
| 304 | } | ||
| 305 | | { | ||
| 306 | args: any; | ||
| 307 | argsSize: number; | ||
| 308 | completedAt?: number; | ||
| 309 | handle: string; | ||
| 310 | inProgress: boolean; | ||
| 311 | kind: "workflow"; | ||
| 312 | name: string; | ||
| 313 | runResult?: | ||
| 314 | | { kind: "success"; returnValue: any } | ||
| 315 | | { error: string; kind: "failed" } | ||
| 316 | | { kind: "canceled" }; | ||
| 317 | startedAt: number; | ||
| 318 | workflowId?: string; | ||
| 319 | } | ||
| 320 | | { | ||
| 321 | args: { eventId?: string }; | ||
| 322 | argsSize: number; | ||
| 323 | completedAt?: number; | ||
| 324 | eventId?: string; | ||
| 325 | inProgress: boolean; | ||
| 326 | kind: "event"; | ||
| 327 | name: string; | ||
| 328 | runResult?: | ||
| 329 | | { kind: "success"; returnValue: any } | ||
| 330 | | { error: string; kind: "failed" } | ||
| 331 | | { kind: "canceled" }; | ||
| 332 | startedAt: number; | ||
| 333 | }; | ||
| 334 | stepNumber: number; | ||
| 335 | workflowId: string; | ||
| 336 | }> | ||
| 337 | >; | ||
| 338 | }; | ||
| 339 | workflow: { | ||
| 340 | cancel: FunctionReference< | ||
| 341 | "mutation", | ||
| 342 | "internal", | ||
| 343 | { workflowId: string }, | ||
| 344 | null | ||
| 345 | >; | ||
| 346 | cleanup: FunctionReference< | ||
| 347 | "mutation", | ||
| 348 | "internal", | ||
| 349 | { workflowId: string }, | ||
| 350 | boolean | ||
| 351 | >; | ||
| 352 | complete: FunctionReference< | ||
| 353 | "mutation", | ||
| 354 | "internal", | ||
| 355 | { | ||
| 356 | generationNumber: number; | ||
| 357 | runResult: | ||
| 358 | | { kind: "success"; returnValue: any } | ||
| 359 | | { error: string; kind: "failed" } | ||
| 360 | | { kind: "canceled" }; | ||
| 361 | workflowId: string; | ||
| 362 | }, | ||
| 363 | null | ||
| 364 | >; | ||
| 365 | create: FunctionReference< | ||
| 366 | "mutation", | ||
| 367 | "internal", | ||
| 368 | { | ||
| 369 | maxParallelism?: number; | ||
| 370 | onComplete?: { context?: any; fnHandle: string }; | ||
| 371 | startAsync?: boolean; | ||
| 372 | workflowArgs: any; | ||
| 373 | workflowHandle: string; | ||
| 374 | workflowName: string; | ||
| 375 | }, | ||
| 376 | string | ||
| 377 | >; | ||
| 378 | getStatus: FunctionReference< | ||
| 379 | "query", | ||
| 380 | "internal", | ||
| 381 | { workflowId: string }, | ||
| 382 | { | ||
| 383 | inProgress: Array<{ | ||
| 384 | _creationTime: number; | ||
| 385 | _id: string; | ||
| 386 | step: | ||
| 387 | | { | ||
| 388 | args: any; | ||
| 389 | argsSize: number; | ||
| 390 | completedAt?: number; | ||
| 391 | functionType: "query" | "mutation" | "action"; | ||
| 392 | handle: string; | ||
| 393 | inProgress: boolean; | ||
| 394 | kind?: "function"; | ||
| 395 | name: string; | ||
| 396 | runResult?: | ||
| 397 | | { kind: "success"; returnValue: any } | ||
| 398 | | { error: string; kind: "failed" } | ||
| 399 | | { kind: "canceled" }; | ||
| 400 | startedAt: number; | ||
| 401 | workId?: string; | ||
| 402 | } | ||
| 403 | | { | ||
| 404 | args: any; | ||
| 405 | argsSize: number; | ||
| 406 | completedAt?: number; | ||
| 407 | handle: string; | ||
| 408 | inProgress: boolean; | ||
| 409 | kind: "workflow"; | ||
| 410 | name: string; | ||
| 411 | runResult?: | ||
| 412 | | { kind: "success"; returnValue: any } | ||
| 413 | | { error: string; kind: "failed" } | ||
| 414 | | { kind: "canceled" }; | ||
| 415 | startedAt: number; | ||
| 416 | workflowId?: string; | ||
| 417 | } | ||
| 418 | | { | ||
| 419 | args: { eventId?: string }; | ||
| 420 | argsSize: number; | ||
| 421 | completedAt?: number; | ||
| 422 | eventId?: string; | ||
| 423 | inProgress: boolean; | ||
| 424 | kind: "event"; | ||
| 425 | name: string; | ||
| 426 | runResult?: | ||
| 427 | | { kind: "success"; returnValue: any } | ||
| 428 | | { error: string; kind: "failed" } | ||
| 429 | | { kind: "canceled" }; | ||
| 430 | startedAt: number; | ||
| 431 | }; | ||
| 432 | stepNumber: number; | ||
| 433 | workflowId: string; | ||
| 434 | }>; | ||
| 435 | logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR"; | ||
| 436 | workflow: { | ||
| 437 | _creationTime: number; | ||
| 438 | _id: string; | ||
| 439 | args: any; | ||
| 440 | generationNumber: number; | ||
| 441 | logLevel?: any; | ||
| 442 | name?: string; | ||
| 443 | onComplete?: { context?: any; fnHandle: string }; | ||
| 444 | runResult?: | ||
| 445 | | { kind: "success"; returnValue: any } | ||
| 446 | | { error: string; kind: "failed" } | ||
| 447 | | { kind: "canceled" }; | ||
| 448 | startedAt?: any; | ||
| 449 | state?: any; | ||
| 450 | workflowHandle: string; | ||
| 451 | }; | ||
| 452 | } | ||
| 453 | >; | ||
| 454 | list: FunctionReference< | ||
| 455 | "query", | ||
| 456 | "internal", | ||
| 457 | { | ||
| 458 | order: "asc" | "desc"; | ||
| 459 | paginationOpts: { | ||
| 460 | cursor: string | null; | ||
| 461 | endCursor?: string | null; | ||
| 462 | id?: number; | ||
| 463 | maximumBytesRead?: number; | ||
| 464 | maximumRowsRead?: number; | ||
| 465 | numItems: number; | ||
| 466 | }; | ||
| 467 | }, | ||
| 468 | { | ||
| 469 | continueCursor: string; | ||
| 470 | isDone: boolean; | ||
| 471 | page: Array<{ | ||
| 472 | args: any; | ||
| 473 | context?: any; | ||
| 474 | name?: string; | ||
| 475 | runResult?: | ||
| 476 | | { kind: "success"; returnValue: any } | ||
| 477 | | { error: string; kind: "failed" } | ||
| 478 | | { kind: "canceled" }; | ||
| 479 | workflowId: string; | ||
| 480 | }>; | ||
| 481 | pageStatus?: "SplitRecommended" | "SplitRequired" | null; | ||
| 482 | splitCursor?: string | null; | ||
| 483 | } | ||
| 484 | >; | ||
| 485 | listByName: FunctionReference< | ||
| 486 | "query", | ||
| 487 | "internal", | ||
| 488 | { | ||
| 489 | name: string; | ||
| 490 | order: "asc" | "desc"; | ||
| 491 | paginationOpts: { | ||
| 492 | cursor: string | null; | ||
| 493 | endCursor?: string | null; | ||
| 494 | id?: number; | ||
| 495 | maximumBytesRead?: number; | ||
| 496 | maximumRowsRead?: number; | ||
| 497 | numItems: number; | ||
| 498 | }; | ||
| 499 | }, | ||
| 500 | { | ||
| 501 | continueCursor: string; | ||
| 502 | isDone: boolean; | ||
| 503 | page: Array<{ | ||
| 504 | args: any; | ||
| 505 | context?: any; | ||
| 506 | name?: string; | ||
| 507 | runResult?: | ||
| 508 | | { kind: "success"; returnValue: any } | ||
| 509 | | { error: string; kind: "failed" } | ||
| 510 | | { kind: "canceled" }; | ||
| 511 | workflowId: string; | ||
| 512 | }>; | ||
| 513 | pageStatus?: "SplitRecommended" | "SplitRequired" | null; | ||
| 514 | splitCursor?: string | null; | ||
| 515 | } | ||
| 516 | >; | ||
| 517 | listSteps: FunctionReference< | ||
| 518 | "query", | ||
| 519 | "internal", | ||
| 520 | { | ||
| 521 | order: "asc" | "desc"; | ||
| 522 | paginationOpts: { | ||
| 523 | cursor: string | null; | ||
| 524 | endCursor?: string | null; | ||
| 525 | id?: number; | ||
| 526 | maximumBytesRead?: number; | ||
| 527 | maximumRowsRead?: number; | ||
| 528 | numItems: number; | ||
| 529 | }; | ||
| 530 | workflowId: string; | ||
| 531 | }, | ||
| 532 | { | ||
| 533 | continueCursor: string; | ||
| 534 | isDone: boolean; | ||
| 535 | page: Array<{ | ||
| 536 | args: any; | ||
| 537 | completedAt?: number; | ||
| 538 | eventId?: string; | ||
| 539 | kind: "function" | "workflow" | "event"; | ||
| 540 | name: string; | ||
| 541 | nestedWorkflowId?: string; | ||
| 542 | runResult?: | ||
| 543 | | { kind: "success"; returnValue: any } | ||
| 544 | | { error: string; kind: "failed" } | ||
| 545 | | { kind: "canceled" }; | ||
| 546 | startedAt: number; | ||
| 547 | stepId: string; | ||
| 548 | stepNumber: number; | ||
| 549 | workId?: string; | ||
| 550 | workflowId: string; | ||
| 551 | }>; | ||
| 552 | pageStatus?: "SplitRecommended" | "SplitRequired" | null; | ||
| 553 | splitCursor?: string | null; | ||
| 554 | } | ||
| 555 | >; | ||
| 556 | }; | ||
| 557 | }; | ||
| 558 | }; | ||
| @@ -0,0 +1,23 @@ | |||
| 1 | /* eslint-disable */ | ||
| 2 | /** | ||
| 3 | * Generated `api` utility. | ||
| 4 | * | ||
| 5 | * THIS CODE IS AUTOMATICALLY GENERATED. | ||
| 6 | * | ||
| 7 | * To regenerate, run `npx convex dev`. | ||
| 8 | * @module | ||
| 9 | */ | ||
| 10 | |||
| 11 | import { anyApi, componentsGeneric } from "convex/server"; | ||
| 12 | |||
| 13 | /** | ||
| 14 | * A utility for referencing Convex functions in your app's API. | ||
| 15 | * | ||
| 16 | * Usage: | ||
| 17 | * ```js | ||
| 18 | * const myFunctionReference = api.myModule.myFunction; | ||
| 19 | * ``` | ||
| 20 | */ | ||
| 21 | export const api = anyApi; | ||
| 22 | export const internal = anyApi; | ||
| 23 | export const components = componentsGeneric(); | ||
| @@ -0,0 +1,60 @@ | |||
| 1 | /* eslint-disable */ | ||
| 2 | /** | ||
| 3 | * Generated data model types. | ||
| 4 | * | ||
| 5 | * THIS CODE IS AUTOMATICALLY GENERATED. | ||
| 6 | * | ||
| 7 | * To regenerate, run `npx convex dev`. | ||
| 8 | * @module | ||
| 9 | */ | ||
| 10 | |||
| 11 | import type { | ||
| 12 | DataModelFromSchemaDefinition, | ||
| 13 | DocumentByName, | ||
| 14 | TableNamesInDataModel, | ||
| 15 | SystemTableNames, | ||
| 16 | } from "convex/server"; | ||
| 17 | import type { GenericId } from "convex/values"; | ||
| 18 | import schema from "../schema.js"; | ||
| 19 | |||
| 20 | /** | ||
| 21 | * The names of all of your Convex tables. | ||
| 22 | */ | ||
| 23 | export type TableNames = TableNamesInDataModel<DataModel>; | ||
| 24 | |||
| 25 | /** | ||
| 26 | * The type of a document stored in Convex. | ||
| 27 | * | ||
| 28 | * @typeParam TableName - A string literal type of the table name (like "users"). | ||
| 29 | */ | ||
| 30 | export type Doc<TableName extends TableNames> = DocumentByName< | ||
| 31 | DataModel, | ||
| 32 | TableName | ||
| 33 | >; | ||
| 34 | |||
| 35 | /** | ||
| 36 | * An identifier for a document in Convex. | ||
| 37 | * | ||
| 38 | * Convex documents are uniquely identified by their `Id`, which is accessible | ||
| 39 | * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids). | ||
| 40 | * | ||
| 41 | * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions. | ||
| 42 | * | ||
| 43 | * IDs are just strings at runtime, but this type can be used to distinguish them from other | ||
| 44 | * strings when type checking. | ||
| 45 | * | ||
| 46 | * @typeParam TableName - A string literal type of the table name (like "users"). | ||
| 47 | */ | ||
| 48 | export type Id<TableName extends TableNames | SystemTableNames> = | ||
| 49 | GenericId<TableName>; | ||
| 50 | |||
| 51 | /** | ||
| 52 | * A type describing your Convex data model. | ||
| 53 | * | ||
| 54 | * This type includes information about what tables you have, the type of | ||
| 55 | * documents stored in those tables, and the indexes defined on them. | ||
| 56 | * | ||
| 57 | * This type is used to parameterize methods like `queryGeneric` and | ||
| 58 | * `mutationGeneric` to make them type-safe. | ||
| 59 | */ | ||
| 60 | export type DataModel = DataModelFromSchemaDefinition<typeof schema>; | ||
| @@ -0,0 +1,143 @@ | |||
| 1 | /* eslint-disable */ | ||
| 2 | /** | ||
| 3 | * Generated utilities for implementing server-side Convex query and mutation functions. | ||
| 4 | * | ||
| 5 | * THIS CODE IS AUTOMATICALLY GENERATED. | ||
| 6 | * | ||
| 7 | * To regenerate, run `npx convex dev`. | ||
| 8 | * @module | ||
| 9 | */ | ||
| 10 | |||
| 11 | import { | ||
| 12 | ActionBuilder, | ||
| 13 | HttpActionBuilder, | ||
| 14 | MutationBuilder, | ||
| 15 | QueryBuilder, | ||
| 16 | GenericActionCtx, | ||
| 17 | GenericMutationCtx, | ||
| 18 | GenericQueryCtx, | ||
| 19 | GenericDatabaseReader, | ||
| 20 | GenericDatabaseWriter, | ||
| 21 | } from "convex/server"; | ||
| 22 | import type { DataModel } from "./dataModel.js"; | ||
| 23 | |||
| 24 | /** | ||
| 25 | * Define a query in this Convex app's public API. | ||
| 26 | * | ||
| 27 | * This function will be allowed to read your Convex database and will be accessible from the client. | ||
| 28 | * | ||
| 29 | * @param func - The query function. It receives a {@link QueryCtx} as its first argument. | ||
| 30 | * @returns The wrapped query. Include this as an `export` to name it and make it accessible. | ||
| 31 | */ | ||
| 32 | export declare const query: QueryBuilder<DataModel, "public">; | ||
| 33 | |||
| 34 | /** | ||
| 35 | * Define a query that is only accessible from other Convex functions (but not from the client). | ||
| 36 | * | ||
| 37 | * This function will be allowed to read from your Convex database. It will not be accessible from the client. | ||
| 38 | * | ||
| 39 | * @param func - The query function. It receives a {@link QueryCtx} as its first argument. | ||
| 40 | * @returns The wrapped query. Include this as an `export` to name it and make it accessible. | ||
| 41 | */ | ||
| 42 | export declare const internalQuery: QueryBuilder<DataModel, "internal">; | ||
| 43 | |||
| 44 | /** | ||
| 45 | * Define a mutation in this Convex app's public API. | ||
| 46 | * | ||
| 47 | * This function will be allowed to modify your Convex database and will be accessible from the client. | ||
| 48 | * | ||
| 49 | * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument. | ||
| 50 | * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible. | ||
| 51 | */ | ||
| 52 | export declare const mutation: MutationBuilder<DataModel, "public">; | ||
| 53 | |||
| 54 | /** | ||
| 55 | * Define a mutation that is only accessible from other Convex functions (but not from the client). | ||
| 56 | * | ||
| 57 | * This function will be allowed to modify your Convex database. It will not be accessible from the client. | ||
| 58 | * | ||
| 59 | * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument. | ||
| 60 | * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible. | ||
| 61 | */ | ||
| 62 | export declare const internalMutation: MutationBuilder<DataModel, "internal">; | ||
| 63 | |||
| 64 | /** | ||
| 65 | * Define an action in this Convex app's public API. | ||
| 66 | * | ||
| 67 | * An action is a function which can execute any JavaScript code, including non-deterministic | ||
| 68 | * code and code with side-effects, like calling third-party services. | ||
| 69 | * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive. | ||
| 70 | * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}. | ||
| 71 | * | ||
| 72 | * @param func - The action. It receives an {@link ActionCtx} as its first argument. | ||
| 73 | * @returns The wrapped action. Include this as an `export` to name it and make it accessible. | ||
| 74 | */ | ||
| 75 | export declare const action: ActionBuilder<DataModel, "public">; | ||
| 76 | |||
| 77 | /** | ||
| 78 | * Define an action that is only accessible from other Convex functions (but not from the client). | ||
| 79 | * | ||
| 80 | * @param func - The function. It receives an {@link ActionCtx} as its first argument. | ||
| 81 | * @returns The wrapped function. Include this as an `export` to name it and make it accessible. | ||
| 82 | */ | ||
| 83 | export declare const internalAction: ActionBuilder<DataModel, "internal">; | ||
| 84 | |||
| 85 | /** | ||
| 86 | * Define an HTTP action. | ||
| 87 | * | ||
| 88 | * The wrapped function will be used to respond to HTTP requests received | ||
| 89 | * by a Convex deployment if the requests matches the path and method where | ||
| 90 | * this action is routed. Be sure to route your httpAction in `convex/http.js`. | ||
| 91 | * | ||
| 92 | * @param func - The function. It receives an {@link ActionCtx} as its first argument | ||
| 93 | * and a Fetch API `Request` object as its second. | ||
| 94 | * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up. | ||
| 95 | */ | ||
| 96 | export declare const httpAction: HttpActionBuilder; | ||
| 97 | |||
| 98 | /** | ||
| 99 | * A set of services for use within Convex query functions. | ||
| 100 | * | ||
| 101 | * The query context is passed as the first argument to any Convex query | ||
| 102 | * function run on the server. | ||
| 103 | * | ||
| 104 | * This differs from the {@link MutationCtx} because all of the services are | ||
| 105 | * read-only. | ||
| 106 | */ | ||
| 107 | export type QueryCtx = GenericQueryCtx<DataModel>; | ||
| 108 | |||
| 109 | /** | ||
| 110 | * A set of services for use within Convex mutation functions. | ||
| 111 | * | ||
| 112 | * The mutation context is passed as the first argument to any Convex mutation | ||
| 113 | * function run on the server. | ||
| 114 | */ | ||
| 115 | export type MutationCtx = GenericMutationCtx<DataModel>; | ||
| 116 | |||
| 117 | /** | ||
| 118 | * A set of services for use within Convex action functions. | ||
| 119 | * | ||
| 120 | * The action context is passed as the first argument to any Convex action | ||
| 121 | * function run on the server. | ||
| 122 | */ | ||
| 123 | export type ActionCtx = GenericActionCtx<DataModel>; | ||
| 124 | |||
| 125 | /** | ||
| 126 | * An interface to read from the database within Convex query functions. | ||
| 127 | * | ||
| 128 | * The two entry points are {@link DatabaseReader.get}, which fetches a single | ||
| 129 | * document by its {@link Id}, or {@link DatabaseReader.query}, which starts | ||
| 130 | * building a query. | ||
| 131 | */ | ||
| 132 | export type DatabaseReader = GenericDatabaseReader<DataModel>; | ||
| 133 | |||
| 134 | /** | ||
| 135 | * An interface to read from and write to the database within Convex mutation | ||
| 136 | * functions. | ||
| 137 | * | ||
| 138 | * Convex guarantees that all writes within a single mutation are | ||
| 139 | * executed atomically, so you never have to worry about partial writes leaving | ||
| 140 | * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control) | ||
| 141 | * for the guarantees Convex provides your functions. | ||
| 142 | */ | ||
| 143 | export type DatabaseWriter = GenericDatabaseWriter<DataModel>; | ||
| @@ -0,0 +1,93 @@ | |||
| 1 | /* eslint-disable */ | ||
| 2 | /** | ||
| 3 | * Generated utilities for implementing server-side Convex query and mutation functions. | ||
| 4 | * | ||
| 5 | * THIS CODE IS AUTOMATICALLY GENERATED. | ||
| 6 | * | ||
| 7 | * To regenerate, run `npx convex dev`. | ||
| 8 | * @module | ||
| 9 | */ | ||
| 10 | |||
| 11 | import { | ||
| 12 | actionGeneric, | ||
| 13 | httpActionGeneric, | ||
| 14 | queryGeneric, | ||
| 15 | mutationGeneric, | ||
| 16 | internalActionGeneric, | ||
| 17 | internalMutationGeneric, | ||
| 18 | internalQueryGeneric, | ||
| 19 | } from "convex/server"; | ||
| 20 | |||
| 21 | /** | ||
| 22 | * Define a query in this Convex app's public API. | ||
| 23 | * | ||
| 24 | * This function will be allowed to read your Convex database and will be accessible from the client. | ||
| 25 | * | ||
| 26 | * @param func - The query function. It receives a {@link QueryCtx} as its first argument. | ||
| 27 | * @returns The wrapped query. Include this as an `export` to name it and make it accessible. | ||
| 28 | */ | ||
| 29 | export const query = queryGeneric; | ||
| 30 | |||
| 31 | /** | ||
| 32 | * Define a query that is only accessible from other Convex functions (but not from the client). | ||
| 33 | * | ||
| 34 | * This function will be allowed to read from your Convex database. It will not be accessible from the client. | ||
| 35 | * | ||
| 36 | * @param func - The query function. It receives a {@link QueryCtx} as its first argument. | ||
| 37 | * @returns The wrapped query. Include this as an `export` to name it and make it accessible. | ||
| 38 | */ | ||
| 39 | export const internalQuery = internalQueryGeneric; | ||
| 40 | |||
| 41 | /** | ||
| 42 | * Define a mutation in this Convex app's public API. | ||
| 43 | * | ||
| 44 | * This function will be allowed to modify your Convex database and will be accessible from the client. | ||
| 45 | * | ||
| 46 | * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument. | ||
| 47 | * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible. | ||
| 48 | */ | ||
| 49 | export const mutation = mutationGeneric; | ||
| 50 | |||
| 51 | /** | ||
| 52 | * Define a mutation that is only accessible from other Convex functions (but not from the client). | ||
| 53 | * | ||
| 54 | * This function will be allowed to modify your Convex database. It will not be accessible from the client. | ||
| 55 | * | ||
| 56 | * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument. | ||
| 57 | * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible. | ||
| 58 | */ | ||
| 59 | export const internalMutation = internalMutationGeneric; | ||
| 60 | |||
| 61 | /** | ||
| 62 | * Define an action in this Convex app's public API. | ||
| 63 | * | ||
| 64 | * An action is a function which can execute any JavaScript code, including non-deterministic | ||
| 65 | * code and code with side-effects, like calling third-party services. | ||
| 66 | * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive. | ||
| 67 | * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}. | ||
| 68 | * | ||
| 69 | * @param func - The action. It receives an {@link ActionCtx} as its first argument. | ||
| 70 | * @returns The wrapped action. Include this as an `export` to name it and make it accessible. | ||
| 71 | */ | ||
| 72 | export const action = actionGeneric; | ||
| 73 | |||
| 74 | /** | ||
| 75 | * Define an action that is only accessible from other Convex functions (but not from the client). | ||
| 76 | * | ||
| 77 | * @param func - The function. It receives an {@link ActionCtx} as its first argument. | ||
| 78 | * @returns The wrapped function. Include this as an `export` to name it and make it accessible. | ||
| 79 | */ | ||
| 80 | export const internalAction = internalActionGeneric; | ||
| 81 | |||
| 82 | /** | ||
| 83 | * Define an HTTP action. | ||
| 84 | * | ||
| 85 | * The wrapped function will be used to respond to HTTP requests received | ||
| 86 | * by a Convex deployment if the requests matches the path and method where | ||
| 87 | * this action is routed. Be sure to route your httpAction in `convex/http.js`. | ||
| 88 | * | ||
| 89 | * @param func - The function. It receives an {@link ActionCtx} as its first argument | ||
| 90 | * and a Fetch API `Request` object as its second. | ||
| 91 | * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up. | ||
| 92 | */ | ||
| 93 | export const httpAction = httpActionGeneric; | ||
| @@ -0,0 +1,72 @@ | |||
| 1 | import { | ||
| 2 | listApprovals as listApprovalsImpl, | ||
| 3 | resolveApproval as resolveApprovalImpl, | ||
| 4 | } from "./control_plane/approvals"; | ||
| 5 | import { | ||
| 6 | listCredentialBindings as listCredentialBindingsImpl, | ||
| 7 | removeCredentialBinding as removeCredentialBindingImpl, | ||
| 8 | upsertCredentialBinding as upsertCredentialBindingImpl, | ||
| 9 | } from "./control_plane/credentials"; | ||
| 10 | import { controlPlaneHttpHandler as controlPlaneHttpHandlerImpl } from "./control_plane/http"; | ||
| 11 | import { | ||
| 12 | listOrganizations as listOrganizationsImpl, | ||
| 13 | upsertOrganization as upsertOrganizationImpl, | ||
| 14 | } from "./control_plane/organizations"; | ||
| 15 | import { | ||
| 16 | listPolicies as listPoliciesImpl, | ||
| 17 | removePolicy as removePolicyImpl, | ||
| 18 | upsertPolicy as upsertPolicyImpl, | ||
| 19 | } from "./control_plane/policies"; | ||
| 20 | import { | ||
| 21 | listSources as listSourcesImpl, | ||
| 22 | removeSource as removeSourceImpl, | ||
| 23 | upsertSource as upsertSourceImpl, | ||
| 24 | } from "./control_plane/sources"; | ||
| 25 | import { | ||
| 26 | closeStorageInstance as closeStorageInstanceImpl, | ||
| 27 | listStorageDirectory as listStorageDirectoryImpl, | ||
| 28 | listStorageInstances as listStorageInstancesImpl, | ||
| 29 | listStorageKv as listStorageKvImpl, | ||
| 30 | openStorageInstance as openStorageInstanceImpl, | ||
| 31 | queryStorageSql as queryStorageSqlImpl, | ||
| 32 | readStorageFile as readStorageFileImpl, | ||
| 33 | removeStorageInstance as removeStorageInstanceImpl, | ||
| 34 | } from "./control_plane/storage"; | ||
| 35 | import { | ||
| 36 | getToolDetail as getToolDetailImpl, | ||
| 37 | listSourceTools as listSourceToolsImpl, | ||
| 38 | listWorkspaceTools as listWorkspaceToolsImpl, | ||
| 39 | } from "./control_plane/tools"; | ||
| 40 | import { | ||
| 41 | listWorkspaces as listWorkspacesImpl, | ||
| 42 | upsertWorkspace as upsertWorkspaceImpl, | ||
| 43 | } from "./control_plane/workspaces"; | ||
| 44 | |||
| 45 | export const listSources = listSourcesImpl; | ||
| 46 | export const upsertSource = upsertSourceImpl; | ||
| 47 | export const removeSource = removeSourceImpl; | ||
| 48 | export const listCredentialBindings = listCredentialBindingsImpl; | ||
| 49 | export const upsertCredentialBinding = upsertCredentialBindingImpl; | ||
| 50 | export const removeCredentialBinding = removeCredentialBindingImpl; | ||
| 51 | export const listPolicies = listPoliciesImpl; | ||
| 52 | export const upsertPolicy = upsertPolicyImpl; | ||
| 53 | export const removePolicy = removePolicyImpl; | ||
| 54 | export const listOrganizations = listOrganizationsImpl; | ||
| 55 | export const upsertOrganization = upsertOrganizationImpl; | ||
| 56 | export const listWorkspaces = listWorkspacesImpl; | ||
| 57 | export const upsertWorkspace = upsertWorkspaceImpl; | ||
| 58 | export const listWorkspaceTools = listWorkspaceToolsImpl; | ||
| 59 | export const listSourceTools = listSourceToolsImpl; | ||
| 60 | export const getToolDetail = getToolDetailImpl; | ||
| 61 | export const listStorageInstances = listStorageInstancesImpl; | ||
| 62 | export const openStorageInstance = openStorageInstanceImpl; | ||
| 63 | export const closeStorageInstance = closeStorageInstanceImpl; | ||
| 64 | export const removeStorageInstance = removeStorageInstanceImpl; | ||
| 65 | export const listStorageDirectory = listStorageDirectoryImpl; | ||
| 66 | export const readStorageFile = readStorageFileImpl; | ||
| 67 | export const listStorageKv = listStorageKvImpl; | ||
| 68 | export const queryStorageSql = queryStorageSqlImpl; | ||
| 69 | export const listApprovals = listApprovalsImpl; | ||
| 70 | export const resolveApproval = resolveApprovalImpl; | ||
| 71 | |||
| 72 | export const controlPlaneHttpHandler = controlPlaneHttpHandlerImpl; | ||
| @@ -0,0 +1,307 @@ | |||
| 1 | import { | ||
| 2 | ControlPlaneActorResolverLive, | ||
| 3 | deriveWorkspaceMembershipsForPrincipal, | ||
| 4 | requirePrincipalFromHeaders, | ||
| 5 | } from "@executor-v2/management-api"; | ||
| 6 | import { ActorUnauthenticatedError, makeActor } from "@executor-v2/domain"; | ||
| 7 | import { | ||
| 8 | OrganizationMembershipSchema, | ||
| 9 | WorkspaceSchema, | ||
| 10 | type OrganizationMembership, | ||
| 11 | type Workspace, | ||
| 12 | } from "@executor-v2/schema"; | ||
| 13 | import { v } from "convex/values"; | ||
| 14 | import * as Effect from "effect/Effect"; | ||
| 15 | import * as Schema from "effect/Schema"; | ||
| 16 | |||
| 17 | import { internal } from "../_generated/api"; | ||
| 18 | import { | ||
| 19 | internalMutation, | ||
| 20 | internalQuery, | ||
| 21 | type ActionCtx, | ||
| 22 | } from "../_generated/server"; | ||
| 23 | |||
| 24 | const decodeWorkspace = Schema.decodeUnknownSync(WorkspaceSchema); | ||
| 25 | const decodeOrganizationMembership = Schema.decodeUnknownSync( | ||
| 26 | OrganizationMembershipSchema, | ||
| 27 | ); | ||
| 28 | |||
| 29 | const stripConvexSystemFields = ( | ||
| 30 | value: Record<string, unknown>, | ||
| 31 | ): Record<string, unknown> => { | ||
| 32 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 33 | return rest; | ||
| 34 | }; | ||
| 35 | |||
| 36 | const toOrganizationSlug = (accountId: string): string => { | ||
| 37 | const slug = accountId | ||
| 38 | .trim() | ||
| 39 | .toLowerCase() | ||
| 40 | .replace(/[^a-z0-9]+/g, "-") | ||
| 41 | .replace(/^-+/, "") | ||
| 42 | .replace(/-+$/, ""); | ||
| 43 | |||
| 44 | return slug.length > 0 ? `acct-${slug}` : `acct-${crypto.randomUUID().slice(0, 8)}`; | ||
| 45 | }; | ||
| 46 | |||
| 47 | export const getWorkspaceForActor = internalQuery({ | ||
| 48 | args: { | ||
| 49 | workspaceId: v.string(), | ||
| 50 | }, | ||
| 51 | handler: async (ctx, args): Promise<Workspace | null> => { | ||
| 52 | const row = await ctx.db | ||
| 53 | .query("workspaces") | ||
| 54 | .withIndex("by_domainId", (q) => q.eq("id", args.workspaceId)) | ||
| 55 | .first(); | ||
| 56 | |||
| 57 | if (row === null) { | ||
| 58 | return null; | ||
| 59 | } | ||
| 60 | |||
| 61 | return decodeWorkspace( | ||
| 62 | stripConvexSystemFields(row as unknown as Record<string, unknown>), | ||
| 63 | ); | ||
| 64 | }, | ||
| 65 | }); | ||
| 66 | |||
| 67 | export const listOrganizationMembershipsForActor = internalQuery({ | ||
| 68 | args: { | ||
| 69 | accountId: v.string(), | ||
| 70 | }, | ||
| 71 | handler: async (ctx, args): Promise<ReadonlyArray<OrganizationMembership>> => { | ||
| 72 | const rows = await ctx.db | ||
| 73 | .query("organizationMemberships") | ||
| 74 | .withIndex("by_accountId", (q) => q.eq("accountId", args.accountId)) | ||
| 75 | .collect(); | ||
| 76 | |||
| 77 | return rows.map((row) => | ||
| 78 | decodeOrganizationMembership( | ||
| 79 | stripConvexSystemFields(row as unknown as Record<string, unknown>), | ||
| 80 | ), | ||
| 81 | ); | ||
| 82 | }, | ||
| 83 | }); | ||
| 84 | |||
| 85 | export const listWorkspacesForActor = internalQuery({ | ||
| 86 | args: { | ||
| 87 | accountId: v.string(), | ||
| 88 | organizationIds: v.array(v.string()), | ||
| 89 | }, | ||
| 90 | handler: async (ctx, args): Promise<ReadonlyArray<Workspace>> => { | ||
| 91 | const ownRows = await ctx.db | ||
| 92 | .query("workspaces") | ||
| 93 | .withIndex("by_createdByAccountId", (q) => q.eq("createdByAccountId", args.accountId)) | ||
| 94 | .collect(); | ||
| 95 | |||
| 96 | const organizationRows = await Promise.all( | ||
| 97 | args.organizationIds.map((organizationId) => | ||
| 98 | ctx.db | ||
| 99 | .query("workspaces") | ||
| 100 | .withIndex("by_organizationId", (q) => q.eq("organizationId", organizationId)) | ||
| 101 | .collect(), | ||
| 102 | ), | ||
| 103 | ); | ||
| 104 | |||
| 105 | const workspaces = [...ownRows, ...organizationRows.flat()].map((row) => | ||
| 106 | decodeWorkspace(stripConvexSystemFields(row as unknown as Record<string, unknown>)), | ||
| 107 | ); | ||
| 108 | |||
| 109 | return Array.from(new Map(workspaces.map((workspace) => [workspace.id, workspace])).values()); | ||
| 110 | }, | ||
| 111 | }); | ||
| 112 | |||
| 113 | export const ensureWorkspaceForActor = internalMutation({ | ||
| 114 | args: { | ||
| 115 | workspaceId: v.string(), | ||
| 116 | accountId: v.string(), | ||
| 117 | }, | ||
| 118 | handler: async (ctx, args): Promise<Workspace> => { | ||
| 119 | const now = Date.now(); | ||
| 120 | |||
| 121 | const ensureOrganizationMembership = async (organizationId: string) => { | ||
| 122 | const existingOrganization = await ctx.db | ||
| 123 | .query("organizations") | ||
| 124 | .withIndex("by_domainId", (q) => q.eq("id", organizationId)) | ||
| 125 | .first(); | ||
| 126 | |||
| 127 | if (existingOrganization === null) { | ||
| 128 | await ctx.db.insert("organizations", { | ||
| 129 | id: organizationId, | ||
| 130 | slug: toOrganizationSlug(args.accountId), | ||
| 131 | name: `${args.accountId} Organization`, | ||
| 132 | status: "active", | ||
| 133 | createdByAccountId: args.accountId, | ||
| 134 | createdAt: now, | ||
| 135 | updatedAt: now, | ||
| 136 | }); | ||
| 137 | } | ||
| 138 | |||
| 139 | const existingMembership = await ctx.db | ||
| 140 | .query("organizationMemberships") | ||
| 141 | .withIndex("by_organizationId_accountId", (q) => | ||
| 142 | q.eq("organizationId", organizationId).eq("accountId", args.accountId) | ||
| 143 | ) | ||
| 144 | .first(); | ||
| 145 | |||
| 146 | if (existingMembership !== null) { | ||
| 147 | return; | ||
| 148 | } | ||
| 149 | |||
| 150 | await ctx.db.insert("organizationMemberships", { | ||
| 151 | id: `org_member_${crypto.randomUUID()}`, | ||
| 152 | organizationId, | ||
| 153 | accountId: args.accountId, | ||
| 154 | role: "owner", | ||
| 155 | status: "active", | ||
| 156 | billable: false, | ||
| 157 | invitedByAccountId: null, | ||
| 158 | joinedAt: now, | ||
| 159 | createdAt: now, | ||
| 160 | updatedAt: now, | ||
| 161 | }); | ||
| 162 | }; | ||
| 163 | |||
| 164 | const existing = await ctx.db | ||
| 165 | .query("workspaces") | ||
| 166 | .withIndex("by_domainId", (q) => q.eq("id", args.workspaceId)) | ||
| 167 | .first(); | ||
| 168 | |||
| 169 | if (existing !== null) { | ||
| 170 | const existingWorkspace = decodeWorkspace( | ||
| 171 | stripConvexSystemFields(existing as unknown as Record<string, unknown>), | ||
| 172 | ); | ||
| 173 | |||
| 174 | await ensureOrganizationMembership(existingWorkspace.organizationId); | ||
| 175 | |||
| 176 | if (existingWorkspace.createdByAccountId !== null) { | ||
| 177 | return existingWorkspace; | ||
| 178 | } | ||
| 179 | |||
| 180 | await ctx.db.patch(existing._id, { | ||
| 181 | createdByAccountId: args.accountId, | ||
| 182 | updatedAt: now, | ||
| 183 | }); | ||
| 184 | |||
| 185 | return decodeWorkspace({ | ||
| 186 | ...existingWorkspace, | ||
| 187 | createdByAccountId: args.accountId, | ||
| 188 | updatedAt: now, | ||
| 189 | }); | ||
| 190 | } | ||
| 191 | |||
| 192 | const organizationId = `org_${args.accountId}`; | ||
| 193 | await ensureOrganizationMembership(organizationId); | ||
| 194 | |||
| 195 | await ctx.db.insert("workspaces", { | ||
| 196 | id: args.workspaceId, | ||
| 197 | organizationId, | ||
| 198 | name: args.workspaceId, | ||
| 199 | createdByAccountId: args.accountId, | ||
| 200 | createdAt: now, | ||
| 201 | updatedAt: now, | ||
| 202 | }); | ||
| 203 | |||
| 204 | return decodeWorkspace({ | ||
| 205 | id: args.workspaceId, | ||
| 206 | organizationId, | ||
| 207 | name: args.workspaceId, | ||
| 208 | createdByAccountId: args.accountId, | ||
| 209 | createdAt: now, | ||
| 210 | updatedAt: now, | ||
| 211 | }); | ||
| 212 | }, | ||
| 213 | }); | ||
| 214 | |||
| 215 | const runQueryEffect = <A>( | ||
| 216 | operation: string, | ||
| 217 | run: () => Promise<A>, | ||
| 218 | ): Effect.Effect<A, ActorUnauthenticatedError> => | ||
| 219 | Effect.tryPromise({ | ||
| 220 | try: run, | ||
| 221 | catch: (cause) => | ||
| 222 | new ActorUnauthenticatedError({ | ||
| 223 | message: `Failed resolving actor (${operation}): ${String(cause)}`, | ||
| 224 | }), | ||
| 225 | }); | ||
| 226 | |||
| 227 | export const ConvexControlPlaneActorLive = (ctx: ActionCtx) => | ||
| 228 | ControlPlaneActorResolverLive({ | ||
| 229 | resolveActor: (input) => | ||
| 230 | Effect.gen(function* () { | ||
| 231 | const principal = yield* requirePrincipalFromHeaders(input.headers); | ||
| 232 | |||
| 233 | const organizationMemberships = yield* runQueryEffect( | ||
| 234 | "organizationMembership.list", | ||
| 235 | () => | ||
| 236 | ctx.runQuery(internal.control_plane.actor.listOrganizationMembershipsForActor, { | ||
| 237 | accountId: principal.accountId, | ||
| 238 | }), | ||
| 239 | ); | ||
| 240 | |||
| 241 | const organizationIds = organizationMemberships.map( | ||
| 242 | (membership) => membership.organizationId, | ||
| 243 | ); | ||
| 244 | |||
| 245 | const workspaces = yield* runQueryEffect("workspace.list", () => | ||
| 246 | ctx.runQuery(internal.control_plane.actor.listWorkspacesForActor, { | ||
| 247 | accountId: principal.accountId, | ||
| 248 | organizationIds, | ||
| 249 | }), | ||
| 250 | ); | ||
| 251 | |||
| 252 | const workspaceMemberships = workspaces.flatMap((workspace) => | ||
| 253 | deriveWorkspaceMembershipsForPrincipal({ | ||
| 254 | principalAccountId: principal.accountId, | ||
| 255 | workspaceId: workspace.id, | ||
| 256 | workspace, | ||
| 257 | organizationMemberships, | ||
| 258 | }), | ||
| 259 | ); | ||
| 260 | |||
| 261 | return yield* makeActor({ | ||
| 262 | principal, | ||
| 263 | workspaceMemberships, | ||
| 264 | organizationMemberships, | ||
| 265 | }); | ||
| 266 | }), | ||
| 267 | resolveWorkspaceActor: (input) => | ||
| 268 | Effect.gen(function* () { | ||
| 269 | const principal = yield* requirePrincipalFromHeaders(input.headers); | ||
| 270 | |||
| 271 | let workspace = yield* runQueryEffect("workspace.read", () => | ||
| 272 | ctx.runQuery(internal.control_plane.actor.getWorkspaceForActor, { | ||
| 273 | workspaceId: input.workspaceId, | ||
| 274 | }), | ||
| 275 | ); | ||
| 276 | |||
| 277 | if (workspace === null || workspace.createdByAccountId === null) { | ||
| 278 | workspace = yield* runQueryEffect("workspace.ensure", () => | ||
| 279 | ctx.runMutation(internal.control_plane.actor.ensureWorkspaceForActor, { | ||
| 280 | workspaceId: input.workspaceId, | ||
| 281 | accountId: principal.accountId, | ||
| 282 | }), | ||
| 283 | ); | ||
| 284 | } | ||
| 285 | |||
| 286 | const organizationMemberships = yield* runQueryEffect( | ||
| 287 | "organizationMembership.list", | ||
| 288 | () => | ||
| 289 | ctx.runQuery(internal.control_plane.actor.listOrganizationMembershipsForActor, { | ||
| 290 | accountId: principal.accountId, | ||
| 291 | }), | ||
| 292 | ); | ||
| 293 | |||
| 294 | const workspaceMemberships = deriveWorkspaceMembershipsForPrincipal({ | ||
| 295 | principalAccountId: principal.accountId, | ||
| 296 | workspaceId: input.workspaceId, | ||
| 297 | workspace, | ||
| 298 | organizationMemberships, | ||
| 299 | }); | ||
| 300 | |||
| 301 | return yield* makeActor({ | ||
| 302 | principal, | ||
| 303 | workspaceMemberships, | ||
| 304 | organizationMemberships, | ||
| 305 | }); | ||
| 306 | }), | ||
| 307 | }); | ||
| @@ -0,0 +1,95 @@ | |||
| 1 | import { | ||
| 2 | type ResolveApprovalPayload, | ||
| 3 | } from "@executor-v2/management-api"; | ||
| 4 | import { | ||
| 5 | ApprovalSchema, | ||
| 6 | type Approval, | ||
| 7 | } from "@executor-v2/schema"; | ||
| 8 | import { v } from "convex/values"; | ||
| 9 | import * as Schema from "effect/Schema"; | ||
| 10 | |||
| 11 | import { mutation, query } from "../_generated/server"; | ||
| 12 | |||
| 13 | const decodeApproval = Schema.decodeUnknownSync(ApprovalSchema); | ||
| 14 | |||
| 15 | const stripConvexSystemFields = ( | ||
| 16 | value: Record<string, unknown>, | ||
| 17 | ): Record<string, unknown> => { | ||
| 18 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 19 | return rest; | ||
| 20 | }; | ||
| 21 | |||
| 22 | const approvalStatusValidator = v.union( | ||
| 23 | v.literal("approved"), | ||
| 24 | v.literal("denied"), | ||
| 25 | ); | ||
| 26 | |||
| 27 | const sortApprovals = (approvals: ReadonlyArray<Approval>): Array<Approval> => | ||
| 28 | [...approvals].sort((left, right) => right.requestedAt - left.requestedAt); | ||
| 29 | |||
| 30 | export const listApprovals = query({ | ||
| 31 | args: { | ||
| 32 | workspaceId: v.string(), | ||
| 33 | }, | ||
| 34 | handler: async (ctx, args): Promise<Array<Approval>> => { | ||
| 35 | const rows = await ctx.db | ||
| 36 | .query("approvals") | ||
| 37 | .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId)) | ||
| 38 | .collect(); | ||
| 39 | |||
| 40 | return sortApprovals( | ||
| 41 | rows.map((row) => | ||
| 42 | decodeApproval( | ||
| 43 | stripConvexSystemFields(row as unknown as Record<string, unknown>), | ||
| 44 | ), | ||
| 45 | ), | ||
| 46 | ); | ||
| 47 | }, | ||
| 48 | }); | ||
| 49 | |||
| 50 | export const resolveApproval = mutation({ | ||
| 51 | args: { | ||
| 52 | workspaceId: v.string(), | ||
| 53 | approvalId: v.string(), | ||
| 54 | payload: v.object({ | ||
| 55 | status: approvalStatusValidator, | ||
| 56 | reason: v.optional(v.union(v.string(), v.null())), | ||
| 57 | }), | ||
| 58 | }, | ||
| 59 | handler: async (ctx, args): Promise<Approval> => { | ||
| 60 | const row = await ctx.db | ||
| 61 | .query("approvals") | ||
| 62 | .withIndex("by_domainId", (q) => q.eq("id", args.approvalId)) | ||
| 63 | .unique(); | ||
| 64 | |||
| 65 | if (!row || row.workspaceId !== args.workspaceId) { | ||
| 66 | throw new Error(`Approval not found: ${args.approvalId}`); | ||
| 67 | } | ||
| 68 | |||
| 69 | const approval = decodeApproval( | ||
| 70 | stripConvexSystemFields(row as unknown as Record<string, unknown>), | ||
| 71 | ); | ||
| 72 | |||
| 73 | if (approval.status !== "pending") { | ||
| 74 | throw new Error(`Approval is not pending: ${args.approvalId}`); | ||
| 75 | } | ||
| 76 | |||
| 77 | const payload = args.payload as ResolveApprovalPayload; | ||
| 78 | const updatedAt = Date.now(); | ||
| 79 | |||
| 80 | const resolvedApproval: Approval = { | ||
| 81 | ...approval, | ||
| 82 | status: payload.status, | ||
| 83 | reason: payload.reason ?? approval.reason ?? null, | ||
| 84 | resolvedAt: updatedAt, | ||
| 85 | }; | ||
| 86 | |||
| 87 | await ctx.db.patch(row._id, { | ||
| 88 | status: resolvedApproval.status, | ||
| 89 | reason: resolvedApproval.reason, | ||
| 90 | resolvedAt: resolvedApproval.resolvedAt, | ||
| 91 | }); | ||
| 92 | |||
| 93 | return resolvedApproval; | ||
| 94 | }, | ||
| 95 | }); | ||
| @@ -0,0 +1,564 @@ | |||
| 1 | import { | ||
| 2 | buildCredentialHeaders, | ||
| 3 | selectOAuthAccessToken, | ||
| 4 | } from "@executor-v2/engine"; | ||
| 5 | import { type UpsertCredentialBindingPayload } from "@executor-v2/management-api"; | ||
| 6 | import { | ||
| 7 | OAuthTokenSchema, | ||
| 8 | SourceCredentialBindingSchema, | ||
| 9 | type OAuthToken, | ||
| 10 | type SourceCredentialBinding, | ||
| 11 | } from "@executor-v2/schema"; | ||
| 12 | import { v } from "convex/values"; | ||
| 13 | import * as Schema from "effect/Schema"; | ||
| 14 | |||
| 15 | import { internal } from "../_generated/api"; | ||
| 16 | import { decryptSecretValue, encryptSecretValue } from "../credential_crypto"; | ||
| 17 | import { | ||
| 18 | action, | ||
| 19 | internalAction, | ||
| 20 | internalMutation, | ||
| 21 | internalQuery, | ||
| 22 | mutation, | ||
| 23 | query, | ||
| 24 | type MutationCtx, | ||
| 25 | type QueryCtx, | ||
| 26 | } from "../_generated/server"; | ||
| 27 | |||
| 28 | const runtimeInternal = internal as any; | ||
| 29 | |||
| 30 | const decodeSourceCredentialBinding = Schema.decodeUnknownSync( | ||
| 31 | SourceCredentialBindingSchema, | ||
| 32 | ); | ||
| 33 | const decodeOAuthToken = Schema.decodeUnknownSync(OAuthTokenSchema); | ||
| 34 | |||
| 35 | const stripConvexSystemFields = ( | ||
| 36 | value: Record<string, unknown>, | ||
| 37 | ): Record<string, unknown> => { | ||
| 38 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 39 | return rest; | ||
| 40 | }; | ||
| 41 | |||
| 42 | const toSourceCredentialBinding = ( | ||
| 43 | document: Record<string, unknown>, | ||
| 44 | ): SourceCredentialBinding => | ||
| 45 | decodeSourceCredentialBinding(stripConvexSystemFields(document)); | ||
| 46 | |||
| 47 | const credentialProviderValidator = v.union( | ||
| 48 | v.literal("api_key"), | ||
| 49 | v.literal("bearer"), | ||
| 50 | v.literal("oauth2"), | ||
| 51 | v.literal("custom"), | ||
| 52 | ); | ||
| 53 | |||
| 54 | const credentialSecretProviderValidator = v.literal("local"); | ||
| 55 | |||
| 56 | const credentialScopeTypeValidator = v.union( | ||
| 57 | v.literal("workspace"), | ||
| 58 | v.literal("organization"), | ||
| 59 | v.literal("account"), | ||
| 60 | ); | ||
| 61 | |||
| 62 | const sourceCredentialBindingPayloadValidator = v.object({ | ||
| 63 | id: v.optional(v.string()), | ||
| 64 | credentialId: v.string(), | ||
| 65 | scopeType: credentialScopeTypeValidator, | ||
| 66 | sourceKey: v.string(), | ||
| 67 | provider: credentialProviderValidator, | ||
| 68 | secretProvider: v.optional(credentialSecretProviderValidator), | ||
| 69 | secretRef: v.string(), | ||
| 70 | accountId: v.optional(v.union(v.string(), v.null())), | ||
| 71 | additionalHeadersJson: v.optional(v.union(v.string(), v.null())), | ||
| 72 | boundAuthFingerprint: v.optional(v.union(v.string(), v.null())), | ||
| 73 | }); | ||
| 74 | |||
| 75 | const sortSourceCredentialBindings = ( | ||
| 76 | bindings: ReadonlyArray<SourceCredentialBinding>, | ||
| 77 | ): Array<SourceCredentialBinding> => | ||
| 78 | [...bindings].sort((left, right) => { | ||
| 79 | const leftKey = `${left.sourceKey}:${left.provider}`.toLowerCase(); | ||
| 80 | const rightKey = `${right.sourceKey}:${right.provider}`.toLowerCase(); | ||
| 81 | |||
| 82 | if (leftKey === rightKey) { | ||
| 83 | return left.id.localeCompare(right.id); | ||
| 84 | } | ||
| 85 | |||
| 86 | return leftKey.localeCompare(rightKey); | ||
| 87 | }); | ||
| 88 | |||
| 89 | const resolveWorkspaceOrganizationId = async ( | ||
| 90 | ctx: QueryCtx | MutationCtx, | ||
| 91 | workspaceId: string, | ||
| 92 | ): Promise<string> => { | ||
| 93 | const workspace = await ctx.db | ||
| 94 | .query("workspaces") | ||
| 95 | .withIndex("by_domainId", (q) => q.eq("id", workspaceId)) | ||
| 96 | .unique(); | ||
| 97 | |||
| 98 | if (!workspace) { | ||
| 99 | throw new Error(`Workspace not found: ${workspaceId}`); | ||
| 100 | } | ||
| 101 | |||
| 102 | return workspace.organizationId; | ||
| 103 | }; | ||
| 104 | |||
| 105 | const canAccessSourceCredentialBinding = ( | ||
| 106 | binding: SourceCredentialBinding, | ||
| 107 | input: { | ||
| 108 | workspaceId: string; | ||
| 109 | organizationId: string; | ||
| 110 | }, | ||
| 111 | ): boolean => | ||
| 112 | binding.workspaceId === input.workspaceId | ||
| 113 | || (binding.workspaceId === null && binding.organizationId === input.organizationId); | ||
| 114 | |||
| 115 | const toOAuthToken = (document: Record<string, unknown>): OAuthToken => | ||
| 116 | decodeOAuthToken(stripConvexSystemFields(document)); | ||
| 117 | |||
| 118 | const sourceSlug = (value: string): string => | ||
| 119 | value | ||
| 120 | .toLowerCase() | ||
| 121 | .replaceAll(/[^a-z0-9]+/g, "_") | ||
| 122 | .replaceAll(/^_+|_+$/g, ""); | ||
| 123 | |||
| 124 | const parseHostname = (endpoint: string): string | null => { | ||
| 125 | try { | ||
| 126 | const hostname = new URL(endpoint).hostname.trim().toLowerCase(); | ||
| 127 | return hostname.length > 0 ? hostname : null; | ||
| 128 | } catch { | ||
| 129 | return null; | ||
| 130 | } | ||
| 131 | }; | ||
| 132 | |||
| 133 | const sourceKeyCandidatesForIngest = (input: { | ||
| 134 | sourceId: string; | ||
| 135 | sourceName: string; | ||
| 136 | sourceEndpoint: string; | ||
| 137 | }): Array<string> => { | ||
| 138 | const values = new Set<string>(); | ||
| 139 | |||
| 140 | const addCandidate = (value: string | null): void => { | ||
| 141 | if (!value) { | ||
| 142 | return; | ||
| 143 | } | ||
| 144 | |||
| 145 | const trimmed = value.trim(); | ||
| 146 | if (trimmed.length > 0) { | ||
| 147 | values.add(trimmed); | ||
| 148 | } | ||
| 149 | }; | ||
| 150 | |||
| 151 | addCandidate(`source:${input.sourceId}`); | ||
| 152 | addCandidate(input.sourceId); | ||
| 153 | addCandidate(input.sourceName.toLowerCase()); | ||
| 154 | addCandidate(sourceSlug(input.sourceName)); | ||
| 155 | |||
| 156 | const hostname = parseHostname(input.sourceEndpoint); | ||
| 157 | addCandidate(hostname); | ||
| 158 | if (hostname) { | ||
| 159 | const hostnameWithoutApi = hostname.replace(/^api\./, ""); | ||
| 160 | addCandidate(hostnameWithoutApi); | ||
| 161 | const firstLabel = hostnameWithoutApi.split(".")[0] ?? null; | ||
| 162 | addCandidate(firstLabel); | ||
| 163 | } | ||
| 164 | |||
| 165 | return [...values]; | ||
| 166 | }; | ||
| 167 | |||
| 168 | const bindingScopeScore = ( | ||
| 169 | binding: SourceCredentialBinding, | ||
| 170 | input: { | ||
| 171 | workspaceId: string; | ||
| 172 | organizationId: string; | ||
| 173 | }, | ||
| 174 | ): number => { | ||
| 175 | if (binding.scopeType === "workspace") { | ||
| 176 | return binding.workspaceId === input.workspaceId ? 20 : -1; | ||
| 177 | } | ||
| 178 | |||
| 179 | if (binding.scopeType === "organization") { | ||
| 180 | return binding.organizationId === input.organizationId ? 10 : -1; | ||
| 181 | } | ||
| 182 | |||
| 183 | return -1; | ||
| 184 | }; | ||
| 185 | |||
| 186 | const selectBestIngestBinding = ( | ||
| 187 | candidates: ReadonlyArray<{ | ||
| 188 | binding: SourceCredentialBinding; | ||
| 189 | sourceKeyRank: number; | ||
| 190 | }>, | ||
| 191 | input: { | ||
| 192 | workspaceId: string; | ||
| 193 | organizationId: string; | ||
| 194 | }, | ||
| 195 | ): SourceCredentialBinding | null => { | ||
| 196 | const ranked = candidates | ||
| 197 | .map((candidate) => ({ | ||
| 198 | binding: candidate.binding, | ||
| 199 | scopeScore: bindingScopeScore(candidate.binding, input), | ||
| 200 | sourceKeyRank: candidate.sourceKeyRank, | ||
| 201 | })) | ||
| 202 | .filter((candidate) => candidate.scopeScore >= 0) | ||
| 203 | .sort((left, right) => { | ||
| 204 | if (left.scopeScore !== right.scopeScore) { | ||
| 205 | return right.scopeScore - left.scopeScore; | ||
| 206 | } | ||
| 207 | |||
| 208 | if (left.sourceKeyRank !== right.sourceKeyRank) { | ||
| 209 | return right.sourceKeyRank - left.sourceKeyRank; | ||
| 210 | } | ||
| 211 | |||
| 212 | if (left.binding.updatedAt !== right.binding.updatedAt) { | ||
| 213 | return right.binding.updatedAt - left.binding.updatedAt; | ||
| 214 | } | ||
| 215 | |||
| 216 | return right.binding.createdAt - left.binding.createdAt; | ||
| 217 | }); | ||
| 218 | |||
| 219 | return ranked[0]?.binding ?? null; | ||
| 220 | }; | ||
| 221 | |||
| 222 | const requireLocalSecretProvider = ( | ||
| 223 | secretProvider: SourceCredentialBinding["secretProvider"], | ||
| 224 | ): "local" => { | ||
| 225 | if (secretProvider !== "local") { | ||
| 226 | throw new Error("Convex credentials require secretProvider 'local'"); | ||
| 227 | } | ||
| 228 | |||
| 229 | return "local"; | ||
| 230 | }; | ||
| 231 | |||
| 232 | const defaultSecretProvider = (): "local" => "local"; | ||
| 233 | |||
| 234 | const resolveSecretRefForHeaders = async ( | ||
| 235 | binding: SourceCredentialBinding, | ||
| 236 | ): Promise<string> => { | ||
| 237 | requireLocalSecretProvider(binding.secretProvider); | ||
| 238 | return await decryptSecretValue(binding.secretRef); | ||
| 239 | }; | ||
| 240 | |||
| 241 | const resolveIngestSelection = async ( | ||
| 242 | ctx: QueryCtx, | ||
| 243 | args: { | ||
| 244 | workspaceId: string; | ||
| 245 | sourceId: string; | ||
| 246 | sourceName: string; | ||
| 247 | sourceEndpoint: string; | ||
| 248 | }, | ||
| 249 | ): Promise<{ | ||
| 250 | binding: SourceCredentialBinding | null; | ||
| 251 | oauthAccessToken: string | null; | ||
| 252 | }> => { | ||
| 253 | const organizationId = await resolveWorkspaceOrganizationId(ctx, args.workspaceId); | ||
| 254 | const sourceKeys = sourceKeyCandidatesForIngest({ | ||
| 255 | sourceId: args.sourceId, | ||
| 256 | sourceName: args.sourceName, | ||
| 257 | sourceEndpoint: args.sourceEndpoint, | ||
| 258 | }); | ||
| 259 | |||
| 260 | const candidateRows = await Promise.all( | ||
| 261 | sourceKeys.map((sourceKey) => | ||
| 262 | ctx.db | ||
| 263 | .query("sourceCredentialBindings") | ||
| 264 | .withIndex("by_sourceKey", (q) => q.eq("sourceKey", sourceKey)) | ||
| 265 | .collect() | ||
| 266 | .then((rows) => | ||
| 267 | rows.map((row) => ({ | ||
| 268 | binding: toSourceCredentialBinding(row as unknown as Record<string, unknown>), | ||
| 269 | sourceKey, | ||
| 270 | })), | ||
| 271 | ), | ||
| 272 | ), | ||
| 273 | ); | ||
| 274 | |||
| 275 | const flattened = candidateRows.flat(); | ||
| 276 | const dedupedById = new Map<string, { binding: SourceCredentialBinding; sourceKey: string }>(); | ||
| 277 | for (const candidate of flattened) { | ||
| 278 | if (!dedupedById.has(candidate.binding.id)) { | ||
| 279 | dedupedById.set(candidate.binding.id, candidate); | ||
| 280 | } | ||
| 281 | } | ||
| 282 | |||
| 283 | const sourceKeyRankByKey = new Map<string, number>(); | ||
| 284 | sourceKeys.forEach((sourceKey, index) => { | ||
| 285 | sourceKeyRankByKey.set(sourceKey, sourceKeys.length - index); | ||
| 286 | }); | ||
| 287 | |||
| 288 | const binding = selectBestIngestBinding( | ||
| 289 | [...dedupedById.values()].map((candidate) => ({ | ||
| 290 | binding: candidate.binding, | ||
| 291 | sourceKeyRank: sourceKeyRankByKey.get(candidate.sourceKey) ?? 0, | ||
| 292 | })), | ||
| 293 | { | ||
| 294 | workspaceId: args.workspaceId, | ||
| 295 | organizationId, | ||
| 296 | }, | ||
| 297 | ); | ||
| 298 | |||
| 299 | if (!binding || !canAccessSourceCredentialBinding(binding, { workspaceId: args.workspaceId, organizationId })) { | ||
| 300 | return { | ||
| 301 | binding: null, | ||
| 302 | oauthAccessToken: null, | ||
| 303 | }; | ||
| 304 | } | ||
| 305 | |||
| 306 | const oauthTokens = binding.provider === "oauth2" | ||
| 307 | ? (await ctx.db | ||
| 308 | .query("oauthTokens") | ||
| 309 | .withIndex("by_sourceId", (q) => q.eq("sourceId", args.sourceId)) | ||
| 310 | .collect()).map((row) => toOAuthToken(row as unknown as Record<string, unknown>)) | ||
| 311 | : []; | ||
| 312 | |||
| 313 | const oauthAccessToken = binding.provider === "oauth2" | ||
| 314 | ? selectOAuthAccessToken(oauthTokens, { | ||
| 315 | workspaceId: args.workspaceId, | ||
| 316 | organizationId, | ||
| 317 | accountId: null, | ||
| 318 | sourceKey: binding.sourceKey, | ||
| 319 | }, args.sourceId) | ||
| 320 | : null; | ||
| 321 | |||
| 322 | return { | ||
| 323 | binding, | ||
| 324 | oauthAccessToken, | ||
| 325 | }; | ||
| 326 | }; | ||
| 327 | |||
| 328 | const withDecryptedSecret = async ( | ||
| 329 | binding: SourceCredentialBinding, | ||
| 330 | ): Promise<SourceCredentialBinding> => { | ||
| 331 | const secretRef = await resolveSecretRefForHeaders(binding); | ||
| 332 | return { | ||
| 333 | ...binding, | ||
| 334 | secretProvider: "local", | ||
| 335 | secretRef, | ||
| 336 | }; | ||
| 337 | }; | ||
| 338 | |||
| 339 | export const resolveSourceCredentialSelectionForIngest = internalQuery({ | ||
| 340 | args: { | ||
| 341 | workspaceId: v.string(), | ||
| 342 | sourceId: v.string(), | ||
| 343 | sourceName: v.string(), | ||
| 344 | sourceEndpoint: v.string(), | ||
| 345 | }, | ||
| 346 | handler: async (ctx, args) => resolveIngestSelection(ctx, args), | ||
| 347 | }); | ||
| 348 | |||
| 349 | export const resolveSourceCredentialHeadersForIngest = internalAction({ | ||
| 350 | args: { | ||
| 351 | workspaceId: v.string(), | ||
| 352 | sourceId: v.string(), | ||
| 353 | sourceName: v.string(), | ||
| 354 | sourceEndpoint: v.string(), | ||
| 355 | }, | ||
| 356 | handler: async (ctx, args): Promise<{ | ||
| 357 | headers: Record<string, string>; | ||
| 358 | }> => { | ||
| 359 | const selected = await ctx.runQuery( | ||
| 360 | runtimeInternal.control_plane.credentials.resolveSourceCredentialSelectionForIngest, | ||
| 361 | args, | ||
| 362 | ) as { | ||
| 363 | binding: SourceCredentialBinding | null; | ||
| 364 | oauthAccessToken: string | null; | ||
| 365 | }; | ||
| 366 | |||
| 367 | if (!selected.binding) { | ||
| 368 | return { | ||
| 369 | headers: {}, | ||
| 370 | }; | ||
| 371 | } | ||
| 372 | |||
| 373 | const decrypted = await withDecryptedSecret(selected.binding); | ||
| 374 | |||
| 375 | const headers = buildCredentialHeaders(decrypted, { | ||
| 376 | oauthAccessToken: selected.oauthAccessToken, | ||
| 377 | }); | ||
| 378 | |||
| 379 | return { headers }; | ||
| 380 | }, | ||
| 381 | }); | ||
| 382 | |||
| 383 | export const listCredentialBindings = query({ | ||
| 384 | args: { | ||
| 385 | workspaceId: v.string(), | ||
| 386 | }, | ||
| 387 | handler: async (ctx, args): Promise<Array<SourceCredentialBinding>> => { | ||
| 388 | const organizationId = await resolveWorkspaceOrganizationId(ctx, args.workspaceId); | ||
| 389 | |||
| 390 | const workspaceRows = await ctx.db | ||
| 391 | .query("sourceCredentialBindings") | ||
| 392 | .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId)) | ||
| 393 | .collect(); | ||
| 394 | |||
| 395 | const organizationRows = await ctx.db | ||
| 396 | .query("sourceCredentialBindings") | ||
| 397 | .withIndex("by_organizationId", (q) => q.eq("organizationId", organizationId)) | ||
| 398 | .collect(); | ||
| 399 | |||
| 400 | const bindings = [...workspaceRows, ...organizationRows] | ||
| 401 | .map((row) => | ||
| 402 | toSourceCredentialBinding(row as unknown as Record<string, unknown>), | ||
| 403 | ) | ||
| 404 | .filter((binding) => | ||
| 405 | canAccessSourceCredentialBinding(binding, { | ||
| 406 | workspaceId: args.workspaceId, | ||
| 407 | organizationId, | ||
| 408 | }) | ||
| 409 | ); | ||
| 410 | |||
| 411 | const uniqueBindings = Array.from( | ||
| 412 | new Map(bindings.map((binding) => [binding.id, binding])).values(), | ||
| 413 | ); | ||
| 414 | |||
| 415 | const decryptedBindings = await Promise.all( | ||
| 416 | uniqueBindings.map((binding) => withDecryptedSecret(binding)), | ||
| 417 | ); | ||
| 418 | |||
| 419 | return sortSourceCredentialBindings(decryptedBindings); | ||
| 420 | }, | ||
| 421 | }); | ||
| 422 | |||
| 423 | export const upsertCredentialBindingRecord = internalMutation({ | ||
| 424 | args: { | ||
| 425 | workspaceId: v.string(), | ||
| 426 | payload: sourceCredentialBindingPayloadValidator, | ||
| 427 | }, | ||
| 428 | handler: async (ctx, args): Promise<SourceCredentialBinding> => { | ||
| 429 | const payload = args.payload as UpsertCredentialBindingPayload; | ||
| 430 | |||
| 431 | if (payload.scopeType === "account" && payload.accountId === null) { | ||
| 432 | throw new Error("Account scope credentials require accountId"); | ||
| 433 | } | ||
| 434 | |||
| 435 | const organizationId = await resolveWorkspaceOrganizationId(ctx, args.workspaceId); | ||
| 436 | const now = Date.now(); | ||
| 437 | const bindingId = payload.id ?? `credential_binding_${crypto.randomUUID()}`; | ||
| 438 | |||
| 439 | const existing = await ctx.db | ||
| 440 | .query("sourceCredentialBindings") | ||
| 441 | .withIndex("by_domainId", (q) => q.eq("id", bindingId)) | ||
| 442 | .unique(); | ||
| 443 | |||
| 444 | const existingBinding = existing | ||
| 445 | ? toSourceCredentialBinding(existing as unknown as Record<string, unknown>) | ||
| 446 | : null; | ||
| 447 | |||
| 448 | if ( | ||
| 449 | existingBinding !== null | ||
| 450 | && !canAccessSourceCredentialBinding(existingBinding, { | ||
| 451 | workspaceId: args.workspaceId, | ||
| 452 | organizationId, | ||
| 453 | }) | ||
| 454 | ) { | ||
| 455 | throw new Error(`Credential binding not found: ${bindingId}`); | ||
| 456 | } | ||
| 457 | |||
| 458 | const secretProvider = requireLocalSecretProvider( | ||
| 459 | payload.secretProvider | ||
| 460 | ?? existingBinding?.secretProvider | ||
| 461 | ?? defaultSecretProvider(), | ||
| 462 | ); | ||
| 463 | |||
| 464 | const nextBinding = decodeSourceCredentialBinding({ | ||
| 465 | id: bindingId, | ||
| 466 | credentialId: payload.credentialId, | ||
| 467 | organizationId, | ||
| 468 | workspaceId: payload.scopeType === "workspace" ? args.workspaceId : null, | ||
| 469 | accountId: payload.scopeType === "account" ? (payload.accountId ?? null) : null, | ||
| 470 | scopeType: payload.scopeType, | ||
| 471 | sourceKey: payload.sourceKey, | ||
| 472 | provider: payload.provider, | ||
| 473 | secretProvider, | ||
| 474 | secretRef: payload.secretRef, | ||
| 475 | additionalHeadersJson: payload.additionalHeadersJson ?? null, | ||
| 476 | boundAuthFingerprint: payload.boundAuthFingerprint ?? null, | ||
| 477 | createdAt: existingBinding?.createdAt ?? now, | ||
| 478 | updatedAt: now, | ||
| 479 | }); | ||
| 480 | |||
| 481 | if (existing) { | ||
| 482 | await ctx.db.patch(existing._id, nextBinding); | ||
| 483 | } else { | ||
| 484 | await ctx.db.insert("sourceCredentialBindings", nextBinding); | ||
| 485 | } | ||
| 486 | |||
| 487 | return nextBinding; | ||
| 488 | }, | ||
| 489 | }); | ||
| 490 | |||
| 491 | export const upsertCredentialBinding = action({ | ||
| 492 | args: { | ||
| 493 | workspaceId: v.string(), | ||
| 494 | payload: sourceCredentialBindingPayloadValidator, | ||
| 495 | }, | ||
| 496 | handler: async (ctx, args): Promise<SourceCredentialBinding> => { | ||
| 497 | const payload = args.payload as UpsertCredentialBindingPayload; | ||
| 498 | const requestedSecretRef = payload.secretRef.trim(); | ||
| 499 | if (requestedSecretRef.length === 0) { | ||
| 500 | throw new Error("Credential secret is required"); | ||
| 501 | } | ||
| 502 | |||
| 503 | const encryptedSecretRef = await encryptSecretValue(requestedSecretRef); | ||
| 504 | |||
| 505 | const written = await ctx.runMutation( | ||
| 506 | runtimeInternal.control_plane.credentials.upsertCredentialBindingRecord, | ||
| 507 | { | ||
| 508 | workspaceId: args.workspaceId, | ||
| 509 | payload: { | ||
| 510 | ...payload, | ||
| 511 | secretProvider: "local", | ||
| 512 | secretRef: encryptedSecretRef, | ||
| 513 | }, | ||
| 514 | }, | ||
| 515 | ) as SourceCredentialBinding; | ||
| 516 | |||
| 517 | return { | ||
| 518 | ...written, | ||
| 519 | secretProvider: "local", | ||
| 520 | secretRef: requestedSecretRef, | ||
| 521 | }; | ||
| 522 | }, | ||
| 523 | }); | ||
| 524 | |||
| 525 | export const removeCredentialBinding = mutation({ | ||
| 526 | args: { | ||
| 527 | workspaceId: v.string(), | ||
| 528 | credentialBindingId: v.string(), | ||
| 529 | }, | ||
| 530 | handler: async ( | ||
| 531 | ctx, | ||
| 532 | args, | ||
| 533 | ): Promise<{ | ||
| 534 | removed: boolean; | ||
| 535 | }> => { | ||
| 536 | const organizationId = await resolveWorkspaceOrganizationId(ctx, args.workspaceId); | ||
| 537 | |||
| 538 | const existing = await ctx.db | ||
| 539 | .query("sourceCredentialBindings") | ||
| 540 | .withIndex("by_domainId", (q) => q.eq("id", args.credentialBindingId)) | ||
| 541 | .unique(); | ||
| 542 | |||
| 543 | if (!existing) { | ||
| 544 | return { removed: false }; | ||
| 545 | } | ||
| 546 | |||
| 547 | const existingBinding = toSourceCredentialBinding( | ||
| 548 | existing as unknown as Record<string, unknown>, | ||
| 549 | ); | ||
| 550 | |||
| 551 | if ( | ||
| 552 | !canAccessSourceCredentialBinding(existingBinding, { | ||
| 553 | workspaceId: args.workspaceId, | ||
| 554 | organizationId, | ||
| 555 | }) | ||
| 556 | ) { | ||
| 557 | return { removed: false }; | ||
| 558 | } | ||
| 559 | |||
| 560 | await ctx.db.delete(existing._id); | ||
| 561 | |||
| 562 | return { removed: true }; | ||
| 563 | }, | ||
| 564 | }); | ||
| @@ -0,0 +1,82 @@ | |||
| 1 | import { SourceStoreError } from "@executor-v2/persistence-ports"; | ||
| 2 | |||
| 3 | type ControlPlaneErrorCode = | ||
| 4 | | "bad_request" | ||
| 5 | | "unauthorized" | ||
| 6 | | "forbidden" | ||
| 7 | | "not_found" | ||
| 8 | | "method_not_allowed" | ||
| 9 | | "internal"; | ||
| 10 | |||
| 11 | type ControlPlaneErrorResponse = { | ||
| 12 | ok: false; | ||
| 13 | error: { | ||
| 14 | code: ControlPlaneErrorCode; | ||
| 15 | message: string; | ||
| 16 | details: string | null; | ||
| 17 | }; | ||
| 18 | }; | ||
| 19 | |||
| 20 | const renderCause = (cause: unknown): string => String(cause); | ||
| 21 | |||
| 22 | export const toSourceStoreError = ( | ||
| 23 | operation: string, | ||
| 24 | cause: unknown, | ||
| 25 | ): SourceStoreError => | ||
| 26 | new SourceStoreError({ | ||
| 27 | operation, | ||
| 28 | backend: "convex", | ||
| 29 | location: "control-plane", | ||
| 30 | message: "Convex control plane call failed", | ||
| 31 | reason: null, | ||
| 32 | details: renderCause(cause), | ||
| 33 | }); | ||
| 34 | |||
| 35 | const toErrorCode = (status: number): ControlPlaneErrorCode => { | ||
| 36 | switch (status) { | ||
| 37 | case 400: | ||
| 38 | return "bad_request"; | ||
| 39 | case 401: | ||
| 40 | return "unauthorized"; | ||
| 41 | case 403: | ||
| 42 | return "forbidden"; | ||
| 43 | case 404: | ||
| 44 | return "not_found"; | ||
| 45 | case 405: | ||
| 46 | return "method_not_allowed"; | ||
| 47 | default: | ||
| 48 | return "internal"; | ||
| 49 | } | ||
| 50 | }; | ||
| 51 | |||
| 52 | export const controlPlaneErrorResponse = ( | ||
| 53 | status: number, | ||
| 54 | message: string, | ||
| 55 | details: string | null, | ||
| 56 | ): Response => | ||
| 57 | Response.json( | ||
| 58 | { | ||
| 59 | ok: false, | ||
| 60 | error: { | ||
| 61 | code: toErrorCode(status), | ||
| 62 | message, | ||
| 63 | details, | ||
| 64 | }, | ||
| 65 | } satisfies ControlPlaneErrorResponse, | ||
| 66 | { status }, | ||
| 67 | ); | ||
| 68 | |||
| 69 | const isJsonResponse = (response: Response): boolean => | ||
| 70 | response.headers.get("content-type")?.toLowerCase().includes("application/json") ?? false; | ||
| 71 | |||
| 72 | export const normalizeControlPlaneErrorResponse = (response: Response): Response => { | ||
| 73 | if (response.ok || isJsonResponse(response)) { | ||
| 74 | return response; | ||
| 75 | } | ||
| 76 | |||
| 77 | return controlPlaneErrorResponse( | ||
| 78 | response.status, | ||
| 79 | "Control plane request failed", | ||
| 80 | response.statusText || null, | ||
| 81 | ); | ||
| 82 | }; | ||
| @@ -0,0 +1,67 @@ | |||
| 1 | import { | ||
| 2 | ControlPlaneService, | ||
| 3 | controlPlaneOpenApiSpec, | ||
| 4 | makeControlPlaneWebHandler, | ||
| 5 | } from "@executor-v2/management-api"; | ||
| 6 | import * as Effect from "effect/Effect"; | ||
| 7 | import * as Layer from "effect/Layer"; | ||
| 8 | |||
| 9 | import { httpAction, type ActionCtx } from "../_generated/server"; | ||
| 10 | import { ConvexControlPlaneActorLive } from "./actor"; | ||
| 11 | import { | ||
| 12 | controlPlaneErrorResponse, | ||
| 13 | normalizeControlPlaneErrorResponse, | ||
| 14 | toSourceStoreError, | ||
| 15 | } from "./errors"; | ||
| 16 | import { makeConvexControlPlaneService } from "./service"; | ||
| 17 | |||
| 18 | const isOpenApiRequest = (request: Request): boolean => | ||
| 19 | new URL(request.url).pathname === "/v1/openapi.json"; | ||
| 20 | |||
| 21 | const handleControlPlaneRequest = ( | ||
| 22 | ctx: ActionCtx, | ||
| 23 | request: Request, | ||
| 24 | ): Effect.Effect<Response, never> => | ||
| 25 | Effect.scoped( | ||
| 26 | Effect.gen(function* () { | ||
| 27 | if (isOpenApiRequest(request)) { | ||
| 28 | return Response.json(controlPlaneOpenApiSpec, { status: 200 }); | ||
| 29 | } | ||
| 30 | |||
| 31 | const webHandler = makeControlPlaneWebHandler( | ||
| 32 | Layer.succeed(ControlPlaneService, makeConvexControlPlaneService(ctx)), | ||
| 33 | ConvexControlPlaneActorLive(ctx), | ||
| 34 | ); | ||
| 35 | |||
| 36 | yield* Effect.addFinalizer(() => | ||
| 37 | Effect.tryPromise({ | ||
| 38 | try: () => webHandler.dispose(), | ||
| 39 | catch: (cause) => toSourceStoreError("controlPlane.dispose", cause), | ||
| 40 | }).pipe( | ||
| 41 | Effect.asVoid, | ||
| 42 | Effect.catchAll(() => Effect.void), | ||
| 43 | ), | ||
| 44 | ); | ||
| 45 | |||
| 46 | const response = yield* Effect.tryPromise({ | ||
| 47 | try: () => webHandler.handler(request), | ||
| 48 | catch: (cause) => toSourceStoreError("controlPlane.http", cause), | ||
| 49 | }); | ||
| 50 | |||
| 51 | return normalizeControlPlaneErrorResponse(response); | ||
| 52 | }), | ||
| 53 | ).pipe( | ||
| 54 | Effect.catchAll((error) => | ||
| 55 | Effect.succeed( | ||
| 56 | controlPlaneErrorResponse( | ||
| 57 | 500, | ||
| 58 | "Control plane request failed", | ||
| 59 | error.details, | ||
| 60 | ), | ||
| 61 | ), | ||
| 62 | ), | ||
| 63 | ); | ||
| 64 | |||
| 65 | export const controlPlaneHttpHandler = httpAction((ctx, request) => | ||
| 66 | Effect.runPromise(handleControlPlaneRequest(ctx, request)), | ||
| 67 | ); | ||
| @@ -0,0 +1,1437 @@ | |||
| 1 | "use node"; | ||
| 2 | |||
| 3 | import { createHash } from "node:crypto"; | ||
| 4 | |||
| 5 | import { type Source } from "@executor-v2/schema"; | ||
| 6 | import { Client } from "@modelcontextprotocol/sdk/client/index.js"; | ||
| 7 | import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"; | ||
| 8 | import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"; | ||
| 9 | import { v } from "convex/values"; | ||
| 10 | import * as Effect from "effect/Effect"; | ||
| 11 | import * as Schema from "effect/Schema"; | ||
| 12 | |||
| 13 | import { internal } from "../_generated/api"; | ||
| 14 | import { internalAction } from "../_generated/server"; | ||
| 15 | |||
| 16 | const runtimeInternal = internal as any; | ||
| 17 | |||
| 18 | const graphqlExtractorVersion = "graphql_v1"; | ||
| 19 | const mcpExtractorVersion = "mcp_v1"; | ||
| 20 | const writeBatchSize = 500; | ||
| 21 | |||
| 22 | const graphqlSchemaRootsQuery = `query SchemaRoots { | ||
| 23 | __schema { | ||
| 24 | queryType { name } | ||
| 25 | mutationType { name } | ||
| 26 | } | ||
| 27 | }`; | ||
| 28 | |||
| 29 | const graphqlRootFieldsQuery = `query RootFields($name: String!) { | ||
| 30 | __type(name: $name) { | ||
| 31 | name | ||
| 32 | fields { | ||
| 33 | name | ||
| 34 | description | ||
| 35 | args { | ||
| 36 | name | ||
| 37 | description | ||
| 38 | defaultValue | ||
| 39 | type { | ||
| 40 | kind | ||
| 41 | name | ||
| 42 | ofType { | ||
| 43 | kind | ||
| 44 | name | ||
| 45 | ofType { | ||
| 46 | kind | ||
| 47 | name | ||
| 48 | } | ||
| 49 | } | ||
| 50 | } | ||
| 51 | } | ||
| 52 | } | ||
| 53 | } | ||
| 54 | }`; | ||
| 55 | |||
| 56 | type GraphqlIngestTool = { | ||
| 57 | toolId: string; | ||
| 58 | name: string; | ||
| 59 | description: string | null; | ||
| 60 | operationType: string; | ||
| 61 | fieldName: string; | ||
| 62 | operationHash: string; | ||
| 63 | invocationJson: string; | ||
| 64 | }; | ||
| 65 | |||
| 66 | type McpIngestTool = { | ||
| 67 | toolId: string; | ||
| 68 | name: string; | ||
| 69 | description: string | null; | ||
| 70 | toolName: string; | ||
| 71 | operationHash: string; | ||
| 72 | invocationJson: string; | ||
| 73 | }; | ||
| 74 | |||
| 75 | type McpTransport = "sse" | "streamable-http"; | ||
| 76 | |||
| 77 | type McpConnection = { | ||
| 78 | client: Client; | ||
| 79 | close: () => Promise<void>; | ||
| 80 | transport: McpTransport; | ||
| 81 | }; | ||
| 82 | |||
| 83 | const SourceIngestStatusSchema = Schema.Union( | ||
| 84 | Schema.Literal("error"), | ||
| 85 | Schema.Literal("auth_required"), | ||
| 86 | ); | ||
| 87 | |||
| 88 | type SourceIngestStatus = typeof SourceIngestStatusSchema.Type; | ||
| 89 | |||
| 90 | class SourceIngestError extends Schema.TaggedError<SourceIngestError>()( | ||
| 91 | "SourceIngestError", | ||
| 92 | { | ||
| 93 | status: SourceIngestStatusSchema, | ||
| 94 | message: Schema.String, | ||
| 95 | }, | ||
| 96 | ) {} | ||
| 97 | |||
| 98 | type SourceIngestPrepared = { | ||
| 99 | protocol: "openapi" | "graphql" | "mcp"; | ||
| 100 | artifactId: string; | ||
| 101 | sourceHash: string; | ||
| 102 | toolCount: number; | ||
| 103 | namespace: string; | ||
| 104 | refHintTableJson: string | null; | ||
| 105 | artifactBatchCount: number; | ||
| 106 | }; | ||
| 107 | |||
| 108 | const isUnknownRecord = (value: unknown): value is Record<string, unknown> => | ||
| 109 | typeof value === "object" && value !== null && !Array.isArray(value); | ||
| 110 | |||
| 111 | const normalizeString = (value: unknown): string | null => { | ||
| 112 | if (typeof value !== "string") { | ||
| 113 | return null; | ||
| 114 | } | ||
| 115 | |||
| 116 | const trimmed = value.trim(); | ||
| 117 | return trimmed.length > 0 ? trimmed : null; | ||
| 118 | }; | ||
| 119 | |||
| 120 | const stableStringify = (value: unknown): string => { | ||
| 121 | if (Array.isArray(value)) { | ||
| 122 | return `[${value.map((entry) => stableStringify(entry)).join(",")}]`; | ||
| 123 | } | ||
| 124 | |||
| 125 | if (isUnknownRecord(value)) { | ||
| 126 | const keys = Object.keys(value).sort(); | ||
| 127 | return `{${keys | ||
| 128 | .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`) | ||
| 129 | .join(",")}}`; | ||
| 130 | } | ||
| 131 | |||
| 132 | return JSON.stringify(value); | ||
| 133 | }; | ||
| 134 | |||
| 135 | const hashUnknown = (value: unknown): string => | ||
| 136 | createHash("sha256").update(stableStringify(value)).digest("hex").slice(0, 16); | ||
| 137 | |||
| 138 | const sourceSlug = (name: string): string => { | ||
| 139 | const slug = name | ||
| 140 | .toLowerCase() | ||
| 141 | .replaceAll(/[^a-z0-9]+/g, "_") | ||
| 142 | .replaceAll(/^_+|_+$/g, ""); | ||
| 143 | |||
| 144 | return slug.length > 0 ? slug : "graphql"; | ||
| 145 | }; | ||
| 146 | |||
| 147 | const toolSegment = (value: string): string => { | ||
| 148 | const segment = value | ||
| 149 | .toLowerCase() | ||
| 150 | .replaceAll(/[^a-z0-9]+/g, "_") | ||
| 151 | .replaceAll(/^_+|_+$/g, ""); | ||
| 152 | |||
| 153 | return segment.length > 0 ? segment : "field"; | ||
| 154 | }; | ||
| 155 | |||
| 156 | const normalizeNamespacePart = (value: string): string => { | ||
| 157 | const normalized = value | ||
| 158 | .trim() | ||
| 159 | .toLowerCase() | ||
| 160 | .replace(/[^a-z0-9]+/g, "_") | ||
| 161 | .replace(/^_+|_+$/g, ""); | ||
| 162 | |||
| 163 | return normalized.length > 0 ? normalized : "source"; | ||
| 164 | }; | ||
| 165 | |||
| 166 | const sourceNamespace = (source: Source): string => { | ||
| 167 | const sourceIdSuffix = source.id.slice(-6).toLowerCase(); | ||
| 168 | return `${normalizeNamespacePart(source.name)}_${sourceIdSuffix}`; | ||
| 169 | }; | ||
| 170 | |||
| 171 | const sourceToolPath = (source: Source, toolId: string): string => | ||
| 172 | `${sourceNamespace(source)}.${toolId}`; | ||
| 173 | |||
| 174 | const normalizedSearchText = (...parts: ReadonlyArray<string | null | undefined>): string => | ||
| 175 | parts | ||
| 176 | .map((part) => (typeof part === "string" ? part.trim().toLowerCase() : "")) | ||
| 177 | .filter((part) => part.length > 0) | ||
| 178 | .join(" "); | ||
| 179 | |||
| 180 | const metadataSearchTerms = (metadataJson: string | null | undefined): ReadonlyArray<string> => { | ||
| 181 | if (!metadataJson) { | ||
| 182 | return []; | ||
| 183 | } | ||
| 184 | |||
| 185 | const parsed = parseJsonObject(metadataJson); | ||
| 186 | const keys = ["method", "path", "operationType", "fieldName", "toolName"] as const; | ||
| 187 | const terms: Array<string> = []; | ||
| 188 | |||
| 189 | for (const key of keys) { | ||
| 190 | const value = parsed[key]; | ||
| 191 | if (typeof value === "string" && value.trim().length > 0) { | ||
| 192 | terms.push(value); | ||
| 193 | } | ||
| 194 | } | ||
| 195 | |||
| 196 | return terms; | ||
| 197 | }; | ||
| 198 | |||
| 199 | const toWorkspaceToolMethod = (protocol: string, metadataJson: string | null | undefined): string => { | ||
| 200 | if (protocol !== "openapi") { | ||
| 201 | return "post"; | ||
| 202 | } | ||
| 203 | |||
| 204 | const parsed = metadataJson ? parseJsonObject(metadataJson) : {}; | ||
| 205 | const method = typeof parsed.method === "string" ? parsed.method.trim().toLowerCase() : ""; | ||
| 206 | |||
| 207 | if ( | ||
| 208 | method === "get" || | ||
| 209 | method === "post" || | ||
| 210 | method === "put" || | ||
| 211 | method === "patch" || | ||
| 212 | method === "delete" || | ||
| 213 | method === "head" || | ||
| 214 | method === "options" || | ||
| 215 | method === "trace" | ||
| 216 | ) { | ||
| 217 | return method; | ||
| 218 | } | ||
| 219 | |||
| 220 | return "get"; | ||
| 221 | }; | ||
| 222 | |||
| 223 | const parseJsonObject = (value: string): Record<string, unknown> => { | ||
| 224 | try { | ||
| 225 | const parsed = JSON.parse(value) as unknown; | ||
| 226 | return isUnknownRecord(parsed) ? parsed : {}; | ||
| 227 | } catch { | ||
| 228 | return {}; | ||
| 229 | } | ||
| 230 | }; | ||
| 231 | |||
| 232 | const safeJsonStringify = (value: unknown): string | null => { | ||
| 233 | try { | ||
| 234 | return JSON.stringify(value); | ||
| 235 | } catch { | ||
| 236 | return null; | ||
| 237 | } | ||
| 238 | }; | ||
| 239 | |||
| 240 | const chunkArray = <A>(values: ReadonlyArray<A>, size: number): Array<Array<A>> => { | ||
| 241 | const chunkSize = Math.max(1, Math.floor(size)); | ||
| 242 | const chunks: Array<Array<A>> = []; | ||
| 243 | |||
| 244 | for (let index = 0; index < values.length; index += chunkSize) { | ||
| 245 | chunks.push(values.slice(index, index + chunkSize)); | ||
| 246 | } | ||
| 247 | |||
| 248 | return chunks; | ||
| 249 | }; | ||
| 250 | |||
| 251 | const extractMcpSchemas = ( | ||
| 252 | invocationJson: string, | ||
| 253 | ): { inputSchemaJson: string | null; outputSchemaJson: string | null } => { | ||
| 254 | const parsed = parseJsonObject(invocationJson); | ||
| 255 | return { | ||
| 256 | inputSchemaJson: safeJsonStringify(parsed.inputSchema) ?? null, | ||
| 257 | outputSchemaJson: safeJsonStringify(parsed.outputSchema) ?? null, | ||
| 258 | }; | ||
| 259 | }; | ||
| 260 | |||
| 261 | const typeRefToLabel = (typeRef: unknown): string => { | ||
| 262 | if (!isUnknownRecord(typeRef)) { | ||
| 263 | return "Unknown"; | ||
| 264 | } | ||
| 265 | |||
| 266 | const kind = normalizeString(typeRef.kind); | ||
| 267 | const name = normalizeString(typeRef.name); | ||
| 268 | const ofType = typeRef.ofType; | ||
| 269 | |||
| 270 | if (kind === "NON_NULL") { | ||
| 271 | return `${typeRefToLabel(ofType)}!`; | ||
| 272 | } | ||
| 273 | |||
| 274 | if (kind === "LIST") { | ||
| 275 | return `[${typeRefToLabel(ofType)}]`; | ||
| 276 | } | ||
| 277 | |||
| 278 | if (name) { | ||
| 279 | return name; | ||
| 280 | } | ||
| 281 | |||
| 282 | return kind ?? "Unknown"; | ||
| 283 | }; | ||
| 284 | |||
| 285 | const isRequiredType = (typeRef: unknown): boolean => | ||
| 286 | isUnknownRecord(typeRef) && normalizeString(typeRef.kind) === "NON_NULL"; | ||
| 287 | |||
| 288 | const parseSourceConfig = (configJson: string): Record<string, unknown> => { | ||
| 289 | try { | ||
| 290 | const parsed = JSON.parse(configJson) as unknown; | ||
| 291 | return isUnknownRecord(parsed) ? parsed : {}; | ||
| 292 | } catch { | ||
| 293 | return {}; | ||
| 294 | } | ||
| 295 | }; | ||
| 296 | |||
| 297 | const collectAuthHeadersFromSourceConfig = (config: Record<string, unknown>): Record<string, string> => { | ||
| 298 | const headers: Record<string, string> = {}; | ||
| 299 | |||
| 300 | const auth = config.auth; | ||
| 301 | if (!isUnknownRecord(auth)) { | ||
| 302 | return headers; | ||
| 303 | } | ||
| 304 | |||
| 305 | const authType = normalizeString(auth.type)?.toLowerCase(); | ||
| 306 | |||
| 307 | if (authType === "bearer") { | ||
| 308 | const token = normalizeString(auth.token) ?? normalizeString(auth.value); | ||
| 309 | if (token) { | ||
| 310 | headers.Authorization = `Bearer ${token}`; | ||
| 311 | } | ||
| 312 | } | ||
| 313 | |||
| 314 | if (authType === "apikey" || authType === "api_key") { | ||
| 315 | const value = normalizeString(auth.value) ?? normalizeString(auth.token); | ||
| 316 | if (value) { | ||
| 317 | const headerName = normalizeString(auth.header) ?? "Authorization"; | ||
| 318 | headers[headerName] = value; | ||
| 319 | } | ||
| 320 | } | ||
| 321 | |||
| 322 | if (authType === "basic") { | ||
| 323 | const username = normalizeString(auth.username); | ||
| 324 | const password = normalizeString(auth.password); | ||
| 325 | if (username && password) { | ||
| 326 | headers.Authorization = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`; | ||
| 327 | } | ||
| 328 | } | ||
| 329 | |||
| 330 | return headers; | ||
| 331 | }; | ||
| 332 | |||
| 333 | const collectConfiguredHeadersFromSourceConfig = (config: Record<string, unknown>): Record<string, string> => { | ||
| 334 | const headers: Record<string, string> = {}; | ||
| 335 | const configuredHeaders = config.headers; | ||
| 336 | |||
| 337 | if (!isUnknownRecord(configuredHeaders)) { | ||
| 338 | return headers; | ||
| 339 | } | ||
| 340 | |||
| 341 | for (const [headerKey, headerValue] of Object.entries(configuredHeaders)) { | ||
| 342 | const key = normalizeString(headerKey); | ||
| 343 | const value = normalizeString(headerValue); | ||
| 344 | if (key && value) { | ||
| 345 | headers[key] = value; | ||
| 346 | } | ||
| 347 | } | ||
| 348 | |||
| 349 | return headers; | ||
| 350 | }; | ||
| 351 | |||
| 352 | const collectGraphqlHeadersFromSourceConfig = (source: Source): Record<string, string> => { | ||
| 353 | const config = parseSourceConfig(source.configJson); | ||
| 354 | return { | ||
| 355 | "content-type": "application/json", | ||
| 356 | ...collectConfiguredHeadersFromSourceConfig(config), | ||
| 357 | ...collectAuthHeadersFromSourceConfig(config), | ||
| 358 | }; | ||
| 359 | }; | ||
| 360 | |||
| 361 | const collectMcpHeadersFromSourceConfig = (source: Source): Record<string, string> => { | ||
| 362 | const config = parseSourceConfig(source.configJson); | ||
| 363 | return { | ||
| 364 | ...collectConfiguredHeadersFromSourceConfig(config), | ||
| 365 | ...collectAuthHeadersFromSourceConfig(config), | ||
| 366 | }; | ||
| 367 | }; | ||
| 368 | |||
| 369 | const mergeHeaders = (...sets: ReadonlyArray<Record<string, string>>): Record<string, string> => { | ||
| 370 | const merged: Record<string, string> = {}; | ||
| 371 | const keyByLower = new Map<string, string>(); | ||
| 372 | |||
| 373 | for (const headers of sets) { | ||
| 374 | for (const [rawKey, rawValue] of Object.entries(headers)) { | ||
| 375 | const key = rawKey.trim(); | ||
| 376 | const value = rawValue.trim(); | ||
| 377 | if (key.length === 0 || value.length === 0) { | ||
| 378 | continue; | ||
| 379 | } | ||
| 380 | |||
| 381 | const normalizedKey = key.toLowerCase(); | ||
| 382 | const existingKey = keyByLower.get(normalizedKey); | ||
| 383 | if (existingKey && existingKey !== key) { | ||
| 384 | delete merged[existingKey]; | ||
| 385 | } | ||
| 386 | |||
| 387 | keyByLower.set(normalizedKey, key); | ||
| 388 | merged[key] = value; | ||
| 389 | } | ||
| 390 | } | ||
| 391 | |||
| 392 | return merged; | ||
| 393 | }; | ||
| 394 | |||
| 395 | const graphqlAuthErrorCodes = new Set(["unauthenticated", "forbidden", "unauthorized"]); | ||
| 396 | |||
| 397 | const payloadHasGraphqlAuthError = (payload: unknown): boolean => { | ||
| 398 | if (!isUnknownRecord(payload) || !Array.isArray(payload.errors)) { | ||
| 399 | return false; | ||
| 400 | } | ||
| 401 | |||
| 402 | return payload.errors.some((entry) => { | ||
| 403 | if (!isUnknownRecord(entry)) { | ||
| 404 | return false; | ||
| 405 | } | ||
| 406 | |||
| 407 | const message = normalizeString(entry.message)?.toLowerCase(); | ||
| 408 | if (message && (message.includes("unauthor") || message.includes("forbidden") || message.includes("auth"))) { | ||
| 409 | return true; | ||
| 410 | } | ||
| 411 | |||
| 412 | if (!isUnknownRecord(entry.extensions)) { | ||
| 413 | return false; | ||
| 414 | } | ||
| 415 | |||
| 416 | const code = normalizeString(entry.extensions.code)?.toLowerCase(); | ||
| 417 | return code ? graphqlAuthErrorCodes.has(code) : false; | ||
| 418 | }); | ||
| 419 | }; | ||
| 420 | |||
| 421 | const looksLikeAuthErrorMessage = (value: string): boolean => { | ||
| 422 | const message = value.toLowerCase(); | ||
| 423 | return message.includes("unauthor") || message.includes("forbidden") || message.includes("auth required"); | ||
| 424 | }; | ||
| 425 | |||
| 426 | const sourceIngestStatusFromCause = (cause: unknown): SourceIngestStatus => { | ||
| 427 | if (cause instanceof SourceIngestError) { | ||
| 428 | return cause.status; | ||
| 429 | } | ||
| 430 | |||
| 431 | const message = formatError(cause); | ||
| 432 | return looksLikeAuthErrorMessage(message) ? "auth_required" : "error"; | ||
| 433 | }; | ||
| 434 | |||
| 435 | const extractGraphqlErrorMessage = (payload: unknown, status: number): string => { | ||
| 436 | if (isUnknownRecord(payload) && Array.isArray(payload.errors) && payload.errors.length > 0) { | ||
| 437 | const firstError = payload.errors[0]; | ||
| 438 | if (isUnknownRecord(firstError)) { | ||
| 439 | const message = normalizeString(firstError.message); | ||
| 440 | if (message) { | ||
| 441 | return message; | ||
| 442 | } | ||
| 443 | } | ||
| 444 | } | ||
| 445 | |||
| 446 | return `GraphQL schema request failed (${status})`; | ||
| 447 | }; | ||
| 448 | |||
| 449 | const fetchGraphqlPayload = ( | ||
| 450 | source: Source, | ||
| 451 | headers: Record<string, string>, | ||
| 452 | body: Record<string, unknown>, | ||
| 453 | ): Effect.Effect<Record<string, unknown>, SourceIngestError> => | ||
| 454 | Effect.gen(function* () { | ||
| 455 | const response = yield* Effect.tryPromise({ | ||
| 456 | try: () => | ||
| 457 | fetch(source.endpoint, { | ||
| 458 | method: "POST", | ||
| 459 | headers, | ||
| 460 | body: JSON.stringify(body), | ||
| 461 | cache: "no-store", | ||
| 462 | }), | ||
| 463 | catch: (cause) => | ||
| 464 | SourceIngestError.make({ | ||
| 465 | status: "error", | ||
| 466 | message: `GraphQL schema request failed: ${formatError(cause)}`, | ||
| 467 | }), | ||
| 468 | }); | ||
| 469 | |||
| 470 | const payload = yield* Effect.tryPromise({ | ||
| 471 | try: () => response.json().catch(() => null), | ||
| 472 | catch: (cause) => | ||
| 473 | SourceIngestError.make({ | ||
| 474 | status: "error", | ||
| 475 | message: `GraphQL schema response parse failed: ${formatError(cause)}`, | ||
| 476 | }), | ||
| 477 | }); | ||
| 478 | |||
| 479 | if (!response.ok) { | ||
| 480 | const message = extractGraphqlErrorMessage(payload, response.status); | ||
| 481 | const authRequired = | ||
| 482 | response.status === 401 || response.status === 403 || payloadHasGraphqlAuthError(payload); | ||
| 483 | |||
| 484 | return yield* SourceIngestError.make({ | ||
| 485 | status: authRequired ? "auth_required" : "error", | ||
| 486 | message, | ||
| 487 | }); | ||
| 488 | } | ||
| 489 | |||
| 490 | if (!isUnknownRecord(payload)) { | ||
| 491 | return yield* SourceIngestError.make({ | ||
| 492 | status: "error", | ||
| 493 | message: "GraphQL response is not an object", | ||
| 494 | }); | ||
| 495 | } | ||
| 496 | |||
| 497 | return payload; | ||
| 498 | }); | ||
| 499 | |||
| 500 | const loadGraphqlSchemaRoots = ( | ||
| 501 | source: Source, | ||
| 502 | headers: Record<string, string>, | ||
| 503 | ): Effect.Effect< | ||
| 504 | { | ||
| 505 | queryTypeName: string | null; | ||
| 506 | mutationTypeName: string | null; | ||
| 507 | }, | ||
| 508 | SourceIngestError | ||
| 509 | > => | ||
| 510 | Effect.gen(function* () { | ||
| 511 | const payload = yield* fetchGraphqlPayload(source, headers, { | ||
| 512 | query: graphqlSchemaRootsQuery, | ||
| 513 | }); | ||
| 514 | |||
| 515 | const data = payload.data; | ||
| 516 | const schema = isUnknownRecord(data) && isUnknownRecord(data.__schema) | ||
| 517 | ? data.__schema | ||
| 518 | : null; | ||
| 519 | |||
| 520 | if (!schema) { | ||
| 521 | return yield* SourceIngestError.make({ | ||
| 522 | status: "error", | ||
| 523 | message: "GraphQL schema roots payload is missing __schema", | ||
| 524 | }); | ||
| 525 | } | ||
| 526 | |||
| 527 | return { | ||
| 528 | queryTypeName: isUnknownRecord(schema.queryType) ? normalizeString(schema.queryType.name) : null, | ||
| 529 | mutationTypeName: isUnknownRecord(schema.mutationType) | ||
| 530 | ? normalizeString(schema.mutationType.name) | ||
| 531 | : null, | ||
| 532 | }; | ||
| 533 | }); | ||
| 534 | |||
| 535 | const loadGraphqlRootFields = ( | ||
| 536 | source: Source, | ||
| 537 | headers: Record<string, string>, | ||
| 538 | rootTypeName: string | null, | ||
| 539 | ): Effect.Effect<Array<Record<string, unknown>>, SourceIngestError> => | ||
| 540 | Effect.gen(function* () { | ||
| 541 | if (!rootTypeName) { | ||
| 542 | return []; | ||
| 543 | } | ||
| 544 | |||
| 545 | const payload = yield* fetchGraphqlPayload(source, headers, { | ||
| 546 | query: graphqlRootFieldsQuery, | ||
| 547 | variables: { | ||
| 548 | name: rootTypeName, | ||
| 549 | }, | ||
| 550 | }); | ||
| 551 | |||
| 552 | const data = payload.data; | ||
| 553 | const rootType = isUnknownRecord(data) && isUnknownRecord(data.__type) | ||
| 554 | ? data.__type | ||
| 555 | : null; | ||
| 556 | |||
| 557 | if (!rootType) { | ||
| 558 | return []; | ||
| 559 | } | ||
| 560 | |||
| 561 | const fields = rootType.fields; | ||
| 562 | if (!Array.isArray(fields)) { | ||
| 563 | return []; | ||
| 564 | } | ||
| 565 | |||
| 566 | return fields.filter((field): field is Record<string, unknown> => isUnknownRecord(field)); | ||
| 567 | }); | ||
| 568 | |||
| 569 | const ensureUniqueToolIds = (tools: Array<GraphqlIngestTool>): Array<GraphqlIngestTool> => { | ||
| 570 | const counts = new Map<string, number>(); | ||
| 571 | |||
| 572 | return tools.map((tool) => { | ||
| 573 | const count = (counts.get(tool.toolId) ?? 0) + 1; | ||
| 574 | counts.set(tool.toolId, count); | ||
| 575 | |||
| 576 | if (count === 1) { | ||
| 577 | return tool; | ||
| 578 | } | ||
| 579 | |||
| 580 | return { | ||
| 581 | ...tool, | ||
| 582 | toolId: `${tool.toolId}_${count}`, | ||
| 583 | }; | ||
| 584 | }); | ||
| 585 | }; | ||
| 586 | |||
| 587 | const extractGraphqlTools = ( | ||
| 588 | source: Source, | ||
| 589 | roots: { | ||
| 590 | queryTypeName: string | null; | ||
| 591 | mutationTypeName: string | null; | ||
| 592 | }, | ||
| 593 | queryFields: ReadonlyArray<Record<string, unknown>>, | ||
| 594 | mutationFields: ReadonlyArray<Record<string, unknown>>, | ||
| 595 | ): { | ||
| 596 | schemaHash: string; | ||
| 597 | tools: Array<GraphqlIngestTool>; | ||
| 598 | } => { | ||
| 599 | const slug = sourceSlug(source.name); | ||
| 600 | |||
| 601 | const rawInvocation = { | ||
| 602 | kind: "graphql_raw", | ||
| 603 | endpoint: source.endpoint, | ||
| 604 | }; | ||
| 605 | |||
| 606 | const tools: Array<GraphqlIngestTool> = [ | ||
| 607 | { | ||
| 608 | toolId: `${slug}.graphql`, | ||
| 609 | name: `${source.name} GraphQL`, | ||
| 610 | description: `Run raw GraphQL queries against ${source.name}.`, | ||
| 611 | operationType: "raw", | ||
| 612 | fieldName: "graphql", | ||
| 613 | operationHash: hashUnknown(rawInvocation), | ||
| 614 | invocationJson: JSON.stringify(rawInvocation), | ||
| 615 | }, | ||
| 616 | ]; | ||
| 617 | |||
| 618 | const fieldSignatures: Array<unknown> = []; | ||
| 619 | |||
| 620 | const addOperationTools = ( | ||
| 621 | operationType: "query" | "mutation", | ||
| 622 | fields: ReadonlyArray<Record<string, unknown>>, | ||
| 623 | ): void => { | ||
| 624 | for (const field of fields) { | ||
| 625 | const fieldName = normalizeString(field.name); | ||
| 626 | if (!fieldName) { | ||
| 627 | continue; | ||
| 628 | } | ||
| 629 | |||
| 630 | const args = Array.isArray(field.args) | ||
| 631 | ? field.args | ||
| 632 | .filter((arg): arg is Record<string, unknown> => isUnknownRecord(arg)) | ||
| 633 | .map((arg) => ({ | ||
| 634 | name: normalizeString(arg.name) ?? "arg", | ||
| 635 | description: normalizeString(arg.description), | ||
| 636 | required: isRequiredType(arg.type), | ||
| 637 | type: typeRefToLabel(arg.type), | ||
| 638 | defaultValue: normalizeString(arg.defaultValue), | ||
| 639 | })) | ||
| 640 | : []; | ||
| 641 | |||
| 642 | const invocation = { | ||
| 643 | kind: "graphql_field", | ||
| 644 | endpoint: source.endpoint, | ||
| 645 | operationType, | ||
| 646 | fieldName, | ||
| 647 | args, | ||
| 648 | }; | ||
| 649 | |||
| 650 | tools.push({ | ||
| 651 | toolId: `${slug}.${operationType}.${toolSegment(fieldName)}`, | ||
| 652 | name: fieldName, | ||
| 653 | description: normalizeString(field.description), | ||
| 654 | operationType, | ||
| 655 | fieldName, | ||
| 656 | operationHash: hashUnknown(invocation), | ||
| 657 | invocationJson: JSON.stringify(invocation), | ||
| 658 | }); | ||
| 659 | |||
| 660 | fieldSignatures.push({ | ||
| 661 | operationType, | ||
| 662 | fieldName, | ||
| 663 | args: args.map((arg) => ({ | ||
| 664 | name: arg.name, | ||
| 665 | required: arg.required, | ||
| 666 | type: arg.type, | ||
| 667 | })), | ||
| 668 | }); | ||
| 669 | } | ||
| 670 | }; | ||
| 671 | |||
| 672 | addOperationTools("query", queryFields); | ||
| 673 | addOperationTools("mutation", mutationFields); | ||
| 674 | |||
| 675 | return { | ||
| 676 | schemaHash: hashUnknown({ | ||
| 677 | queryTypeName: roots.queryTypeName, | ||
| 678 | mutationTypeName: roots.mutationTypeName, | ||
| 679 | fieldSignatures, | ||
| 680 | }), | ||
| 681 | tools: ensureUniqueToolIds(tools), | ||
| 682 | }; | ||
| 683 | }; | ||
| 684 | |||
| 685 | const parseMcpTransportPreference = (source: Source): McpTransport | null => { | ||
| 686 | const config = parseSourceConfig(source.configJson); | ||
| 687 | const transport = normalizeString(config.transport)?.toLowerCase(); | ||
| 688 | |||
| 689 | if (transport === "sse") { | ||
| 690 | return "sse"; | ||
| 691 | } | ||
| 692 | |||
| 693 | if (transport === "streamable-http" || transport === "streamable_http") { | ||
| 694 | return "streamable-http"; | ||
| 695 | } | ||
| 696 | |||
| 697 | return null; | ||
| 698 | }; | ||
| 699 | |||
| 700 | const parseMcpQueryParams = (source: Source): Record<string, string> => { | ||
| 701 | const config = parseSourceConfig(source.configJson); | ||
| 702 | const queryParams = config.queryParams; | ||
| 703 | |||
| 704 | if (!isUnknownRecord(queryParams)) { | ||
| 705 | return {}; | ||
| 706 | } | ||
| 707 | |||
| 708 | const normalized: Record<string, string> = {}; | ||
| 709 | for (const [rawKey, rawValue] of Object.entries(queryParams)) { | ||
| 710 | const key = normalizeString(rawKey); | ||
| 711 | const value = normalizeString(rawValue); | ||
| 712 | if (key && value) { | ||
| 713 | normalized[key] = value; | ||
| 714 | } | ||
| 715 | } | ||
| 716 | |||
| 717 | return normalized; | ||
| 718 | }; | ||
| 719 | |||
| 720 | const withMcpHeaders = ( | ||
| 721 | input: RequestInfo | URL, | ||
| 722 | init: RequestInit | undefined, | ||
| 723 | headers: Record<string, string>, | ||
| 724 | ): Promise<Response> => { | ||
| 725 | const mergedHeaders = new Headers(init?.headers ?? {}); | ||
| 726 | for (const [key, value] of Object.entries(headers)) { | ||
| 727 | mergedHeaders.set(key, value); | ||
| 728 | } | ||
| 729 | |||
| 730 | return fetch(input, { | ||
| 731 | ...init, | ||
| 732 | headers: mergedHeaders, | ||
| 733 | }); | ||
| 734 | }; | ||
| 735 | |||
| 736 | const connectMcp = ( | ||
| 737 | source: Source, | ||
| 738 | headers: Record<string, string>, | ||
| 739 | ): Effect.Effect<McpConnection, SourceIngestError> => | ||
| 740 | Effect.gen(function* () { | ||
| 741 | const endpoint = yield* Effect.try({ | ||
| 742 | try: () => new URL(source.endpoint), | ||
| 743 | catch: () => | ||
| 744 | SourceIngestError.make({ | ||
| 745 | status: "error", | ||
| 746 | message: `Invalid MCP endpoint URL: ${source.endpoint}`, | ||
| 747 | }), | ||
| 748 | }); | ||
| 749 | |||
| 750 | const queryParams = parseMcpQueryParams(source); | ||
| 751 | for (const [key, value] of Object.entries(queryParams)) { | ||
| 752 | endpoint.searchParams.set(key, value); | ||
| 753 | } | ||
| 754 | |||
| 755 | const connectWithTransport = ( | ||
| 756 | transport: McpTransport, | ||
| 757 | ): Effect.Effect<McpConnection, SourceIngestError> => | ||
| 758 | Effect.tryPromise({ | ||
| 759 | try: async () => { | ||
| 760 | const client = new Client( | ||
| 761 | { | ||
| 762 | name: "executor-v2-control-plane", | ||
| 763 | version: "0.1.0", | ||
| 764 | }, | ||
| 765 | { capabilities: {} }, | ||
| 766 | ); | ||
| 767 | |||
| 768 | if (transport === "streamable-http") { | ||
| 769 | await client.connect(new StreamableHTTPClientTransport(endpoint, { | ||
| 770 | requestInit: { headers }, | ||
| 771 | })); | ||
| 772 | } else { | ||
| 773 | await client.connect(new SSEClientTransport(endpoint, { | ||
| 774 | requestInit: { headers }, | ||
| 775 | eventSourceInit: { | ||
| 776 | fetch: (input, init) => withMcpHeaders(input, init, headers), | ||
| 777 | }, | ||
| 778 | })); | ||
| 779 | } | ||
| 780 | |||
| 781 | return { | ||
| 782 | client, | ||
| 783 | close: () => client.close(), | ||
| 784 | transport, | ||
| 785 | }; | ||
| 786 | }, | ||
| 787 | catch: (cause) => | ||
| 788 | SourceIngestError.make({ | ||
| 789 | status: sourceIngestStatusFromCause(cause), | ||
| 790 | message: `Failed to connect to MCP source: ${formatError(cause)}`, | ||
| 791 | }), | ||
| 792 | }); | ||
| 793 | |||
| 794 | const preferred = parseMcpTransportPreference(source); | ||
| 795 | if (preferred === "streamable-http") { | ||
| 796 | return yield* connectWithTransport("streamable-http"); | ||
| 797 | } | ||
| 798 | |||
| 799 | if (preferred === "sse") { | ||
| 800 | return yield* connectWithTransport("sse"); | ||
| 801 | } | ||
| 802 | |||
| 803 | const streamableAttempt = yield* connectWithTransport("streamable-http").pipe(Effect.either); | ||
| 804 | if (streamableAttempt._tag === "Right") { | ||
| 805 | return streamableAttempt.right; | ||
| 806 | } | ||
| 807 | |||
| 808 | return yield* connectWithTransport("sse"); | ||
| 809 | }); | ||
| 810 | |||
| 811 | const normalizeJsonSchema = (value: unknown): Record<string, unknown> => { | ||
| 812 | if (value === true) { | ||
| 813 | return {}; | ||
| 814 | } | ||
| 815 | |||
| 816 | if (value === false) { | ||
| 817 | return { not: {} }; | ||
| 818 | } | ||
| 819 | |||
| 820 | return isUnknownRecord(value) ? value : {}; | ||
| 821 | }; | ||
| 822 | |||
| 823 | const extractMcpListedToolRows = (value: unknown): Array<Record<string, unknown>> => { | ||
| 824 | if (!isUnknownRecord(value) || !Array.isArray(value.tools)) { | ||
| 825 | return []; | ||
| 826 | } | ||
| 827 | |||
| 828 | return value.tools.filter((tool): tool is Record<string, unknown> => isUnknownRecord(tool)); | ||
| 829 | }; | ||
| 830 | |||
| 831 | const ensureUniqueMcpToolIds = (tools: Array<McpIngestTool>): Array<McpIngestTool> => { | ||
| 832 | const counts = new Map<string, number>(); | ||
| 833 | |||
| 834 | return tools.map((tool) => { | ||
| 835 | const count = (counts.get(tool.toolId) ?? 0) + 1; | ||
| 836 | counts.set(tool.toolId, count); | ||
| 837 | |||
| 838 | if (count === 1) { | ||
| 839 | return tool; | ||
| 840 | } | ||
| 841 | |||
| 842 | return { | ||
| 843 | ...tool, | ||
| 844 | toolId: `${tool.toolId}_${count}`, | ||
| 845 | }; | ||
| 846 | }); | ||
| 847 | }; | ||
| 848 | |||
| 849 | const extractMcpTools = ( | ||
| 850 | source: Source, | ||
| 851 | transport: McpTransport, | ||
| 852 | listedTools: ReadonlyArray<Record<string, unknown>>, | ||
| 853 | ): { | ||
| 854 | sourceHash: string; | ||
| 855 | tools: Array<McpIngestTool>; | ||
| 856 | } => { | ||
| 857 | const slug = sourceSlug(source.name); | ||
| 858 | const queryParams = parseMcpQueryParams(source); | ||
| 859 | |||
| 860 | const tools: Array<McpIngestTool> = []; | ||
| 861 | const toolSignatures: Array<unknown> = []; | ||
| 862 | |||
| 863 | for (const tool of listedTools) { | ||
| 864 | const toolName = normalizeString(tool.name); | ||
| 865 | if (!toolName) { | ||
| 866 | continue; | ||
| 867 | } | ||
| 868 | |||
| 869 | const inputSchema = normalizeJsonSchema(tool.inputSchema); | ||
| 870 | const outputSchema = normalizeJsonSchema(tool.outputSchema); | ||
| 871 | const invocation = { | ||
| 872 | kind: "mcp_tool", | ||
| 873 | endpoint: source.endpoint, | ||
| 874 | transport, | ||
| 875 | queryParams, | ||
| 876 | toolName, | ||
| 877 | }; | ||
| 878 | |||
| 879 | tools.push({ | ||
| 880 | toolId: `${slug}.mcp.${toolSegment(toolName)}`, | ||
| 881 | name: toolName, | ||
| 882 | description: normalizeString(tool.description), | ||
| 883 | toolName, | ||
| 884 | operationHash: hashUnknown({ invocation, inputSchema, outputSchema }), | ||
| 885 | invocationJson: JSON.stringify({ | ||
| 886 | ...invocation, | ||
| 887 | inputSchema, | ||
| 888 | outputSchema, | ||
| 889 | }), | ||
| 890 | }); | ||
| 891 | |||
| 892 | toolSignatures.push({ toolName, inputSchema, outputSchema }); | ||
| 893 | } | ||
| 894 | |||
| 895 | return { | ||
| 896 | sourceHash: hashUnknown({ | ||
| 897 | endpoint: source.endpoint, | ||
| 898 | transport, | ||
| 899 | queryParams, | ||
| 900 | toolSignatures, | ||
| 901 | }), | ||
| 902 | tools: ensureUniqueMcpToolIds(tools), | ||
| 903 | }; | ||
| 904 | }; | ||
| 905 | |||
| 906 | const formatError = (cause: unknown): string => | ||
| 907 | cause instanceof Error ? cause.message : String(cause); | ||
| 908 | |||
| 909 | const trySourceIngestPromise = <A>( | ||
| 910 | promise: () => Promise<A>, | ||
| 911 | message: string, | ||
| 912 | ): Effect.Effect<A, SourceIngestError> => | ||
| 913 | Effect.tryPromise({ | ||
| 914 | try: promise, | ||
| 915 | catch: (cause) => | ||
| 916 | SourceIngestError.make({ | ||
| 917 | status: "error", | ||
| 918 | message: `${message}: ${formatError(cause)}`, | ||
| 919 | }), | ||
| 920 | }); | ||
| 921 | |||
| 922 | const openApiParserUrl = process.env.OPENAPI_PARSE_API_URL?.trim() ?? ""; | ||
| 923 | const openApiParserToken = process.env.OPENAPI_PARSE_API_TOKEN?.trim() ?? ""; | ||
| 924 | |||
| 925 | type OpenApiParserIngestedPayload = { | ||
| 926 | ok?: boolean; | ||
| 927 | mode?: string; | ||
| 928 | artifactId?: string; | ||
| 929 | sourceHash?: string; | ||
| 930 | toolCount?: number; | ||
| 931 | namespace?: string; | ||
| 932 | refHintTableJson?: string | null; | ||
| 933 | artifactBatchCount?: number; | ||
| 934 | error?: string; | ||
| 935 | }; | ||
| 936 | |||
| 937 | const fetchOpenApiDocumentForIngest = async ( | ||
| 938 | source: Source, | ||
| 939 | ): Promise<{ | ||
| 940 | artifactId: string; | ||
| 941 | sourceHash: string; | ||
| 942 | toolCount: number; | ||
| 943 | namespace: string; | ||
| 944 | refHintTableJson: string | null; | ||
| 945 | artifactBatchCount: number; | ||
| 946 | }> => { | ||
| 947 | if (openApiParserUrl.length === 0) { | ||
| 948 | throw new Error("OPENAPI_PARSE_API_URL is required for OpenAPI ingestion"); | ||
| 949 | } | ||
| 950 | |||
| 951 | const response = await fetch(openApiParserUrl, { | ||
| 952 | method: "POST", | ||
| 953 | headers: { | ||
| 954 | "content-type": "application/json", | ||
| 955 | ...(openApiParserToken.length > 0 | ||
| 956 | ? { "x-openapi-parse-token": openApiParserToken } | ||
| 957 | : {}), | ||
| 958 | }, | ||
| 959 | body: JSON.stringify({ | ||
| 960 | specUrl: source.endpoint, | ||
| 961 | workspaceId: source.workspaceId, | ||
| 962 | sourceId: source.id, | ||
| 963 | sourceName: source.name, | ||
| 964 | sourceEnabled: source.enabled, | ||
| 965 | }), | ||
| 966 | }); | ||
| 967 | |||
| 968 | if (!response.ok) { | ||
| 969 | const details = await response.text().catch(() => ""); | ||
| 970 | throw new Error( | ||
| 971 | `Parser endpoint failed (${response.status}): ${ | ||
| 972 | details.trim().length > 0 ? details.trim() : response.statusText | ||
| 973 | }`, | ||
| 974 | ); | ||
| 975 | } | ||
| 976 | |||
| 977 | const payload = (await response.json()) as OpenApiParserIngestedPayload; | ||
| 978 | |||
| 979 | if (payload.ok !== true) { | ||
| 980 | throw new Error( | ||
| 981 | payload.error && payload.error.trim().length > 0 | ||
| 982 | ? payload.error | ||
| 983 | : "Parser endpoint returned an invalid payload", | ||
| 984 | ); | ||
| 985 | } | ||
| 986 | |||
| 987 | if (payload.mode !== "ingested") { | ||
| 988 | throw new Error("Parser endpoint must return mode='ingested' for OpenAPI ingestion"); | ||
| 989 | } | ||
| 990 | |||
| 991 | const artifactId = normalizeString(payload.artifactId); | ||
| 992 | const sourceHash = normalizeString(payload.sourceHash); | ||
| 993 | const namespace = normalizeString(payload.namespace); | ||
| 994 | const toolCount = Number.isFinite(payload.toolCount) | ||
| 995 | ? Math.max(0, Math.floor(payload.toolCount ?? 0)) | ||
| 996 | : null; | ||
| 997 | const artifactBatchCount = Number.isFinite(payload.artifactBatchCount) | ||
| 998 | ? Math.max(0, Math.floor(payload.artifactBatchCount ?? 0)) | ||
| 999 | : 0; | ||
| 1000 | |||
| 1001 | if (!artifactId || !sourceHash || !namespace || toolCount === null) { | ||
| 1002 | throw new Error("Parser endpoint returned an invalid ingested payload"); | ||
| 1003 | } | ||
| 1004 | |||
| 1005 | return { | ||
| 1006 | artifactId, | ||
| 1007 | sourceHash, | ||
| 1008 | toolCount, | ||
| 1009 | namespace, | ||
| 1010 | refHintTableJson: | ||
| 1011 | typeof payload.refHintTableJson === "string" ? payload.refHintTableJson : null, | ||
| 1012 | artifactBatchCount, | ||
| 1013 | }; | ||
| 1014 | }; | ||
| 1015 | |||
| 1016 | type IngestOptions = { | ||
| 1017 | rebuildIndex: boolean; | ||
| 1018 | stageArtifactWrites: boolean; | ||
| 1019 | }; | ||
| 1020 | |||
| 1021 | const ingestOpenApiSource = ( | ||
| 1022 | ctx: any, | ||
| 1023 | source: Source, | ||
| 1024 | ): Effect.Effect<SourceIngestPrepared, SourceIngestError> => | ||
| 1025 | Effect.gen(function* () { | ||
| 1026 | const ingested = yield* trySourceIngestPromise( | ||
| 1027 | () => fetchOpenApiDocumentForIngest(source), | ||
| 1028 | "Failed to fetch OpenAPI document", | ||
| 1029 | ); | ||
| 1030 | |||
| 1031 | return { | ||
| 1032 | protocol: "openapi", | ||
| 1033 | artifactId: ingested.artifactId, | ||
| 1034 | sourceHash: ingested.sourceHash, | ||
| 1035 | toolCount: ingested.toolCount, | ||
| 1036 | namespace: ingested.namespace, | ||
| 1037 | refHintTableJson: ingested.refHintTableJson, | ||
| 1038 | artifactBatchCount: ingested.artifactBatchCount, | ||
| 1039 | }; | ||
| 1040 | }); | ||
| 1041 | |||
| 1042 | const ingestGraphqlSource = ( | ||
| 1043 | ctx: any, | ||
| 1044 | source: Source, | ||
| 1045 | options: IngestOptions, | ||
| 1046 | ): Effect.Effect<SourceIngestPrepared, SourceIngestError> => | ||
| 1047 | Effect.gen(function* () { | ||
| 1048 | const credentialHeadersResult = yield* trySourceIngestPromise<{ | ||
| 1049 | headers: Record<string, string>; | ||
| 1050 | }>( | ||
| 1051 | () => | ||
| 1052 | ctx.runAction(runtimeInternal.control_plane.credentials.resolveSourceCredentialHeadersForIngest, { | ||
| 1053 | workspaceId: source.workspaceId, | ||
| 1054 | sourceId: source.id, | ||
| 1055 | sourceName: source.name, | ||
| 1056 | sourceEndpoint: source.endpoint, | ||
| 1057 | }), | ||
| 1058 | "Failed to resolve source credentials for GraphQL ingest", | ||
| 1059 | ); | ||
| 1060 | |||
| 1061 | const headers = mergeHeaders( | ||
| 1062 | collectGraphqlHeadersFromSourceConfig(source), | ||
| 1063 | credentialHeadersResult.headers, | ||
| 1064 | ); | ||
| 1065 | |||
| 1066 | const roots = yield* loadGraphqlSchemaRoots(source, headers); | ||
| 1067 | const queryFields = yield* loadGraphqlRootFields(source, headers, roots.queryTypeName); | ||
| 1068 | const mutationFields = yield* loadGraphqlRootFields(source, headers, roots.mutationTypeName); | ||
| 1069 | const extracted = extractGraphqlTools(source, roots, queryFields, mutationFields); | ||
| 1070 | |||
| 1071 | const artifactMeta = yield* trySourceIngestPromise<{ | ||
| 1072 | artifactId: string; | ||
| 1073 | created: boolean; | ||
| 1074 | }>( | ||
| 1075 | () => | ||
| 1076 | ctx.runMutation(runtimeInternal.control_plane.tool_registry.upsertArtifactMeta, { | ||
| 1077 | protocol: "graphql", | ||
| 1078 | contentHash: extracted.schemaHash, | ||
| 1079 | extractorVersion: graphqlExtractorVersion, | ||
| 1080 | toolCount: extracted.tools.length, | ||
| 1081 | }), | ||
| 1082 | "Failed to upsert GraphQL artifact metadata", | ||
| 1083 | ); | ||
| 1084 | |||
| 1085 | if (artifactMeta.created) { | ||
| 1086 | const artifactRows = extracted.tools.map((tool) => ({ | ||
| 1087 | toolId: tool.toolId, | ||
| 1088 | name: tool.name, | ||
| 1089 | description: tool.description, | ||
| 1090 | canonicalPath: `${tool.operationType}.${tool.fieldName}`, | ||
| 1091 | operationHash: tool.operationHash, | ||
| 1092 | invocationJson: tool.invocationJson, | ||
| 1093 | metadataJson: safeJsonStringify({ | ||
| 1094 | operationType: tool.operationType, | ||
| 1095 | fieldName: tool.fieldName, | ||
| 1096 | }), | ||
| 1097 | })); | ||
| 1098 | |||
| 1099 | if (options.stageArtifactWrites) { | ||
| 1100 | const serializedBatches = chunkArray(artifactRows, stagedArtifactBatchSize).map((batch) => | ||
| 1101 | JSON.stringify(batch), | ||
| 1102 | ); | ||
| 1103 | |||
| 1104 | yield* trySourceIngestPromise( | ||
| 1105 | () => | ||
| 1106 | ctx.runMutation( | ||
| 1107 | runtimeInternal.control_plane.tool_registry.replaceSourceIngestArtifactBatches, | ||
| 1108 | { | ||
| 1109 | workspaceId: source.workspaceId, | ||
| 1110 | sourceId: source.id, | ||
| 1111 | artifactId: artifactMeta.artifactId, | ||
| 1112 | protocol: "graphql", | ||
| 1113 | batches: serializedBatches, | ||
| 1114 | }, | ||
| 1115 | ), | ||
| 1116 | "Failed to stage GraphQL artifact tool batches", | ||
| 1117 | ); | ||
| 1118 | } else { | ||
| 1119 | for (let index = 0; index < artifactRows.length; index += writeBatchSize) { | ||
| 1120 | const batch = artifactRows.slice(index, index + writeBatchSize); | ||
| 1121 | yield* trySourceIngestPromise( | ||
| 1122 | () => | ||
| 1123 | ctx.runMutation(runtimeInternal.control_plane.tool_registry.putArtifactToolsBatch, { | ||
| 1124 | artifactId: artifactMeta.artifactId, | ||
| 1125 | protocol: "graphql", | ||
| 1126 | insertOnly: true, | ||
| 1127 | tools: batch, | ||
| 1128 | }), | ||
| 1129 | "Failed to write GraphQL artifact tools", | ||
| 1130 | ); | ||
| 1131 | } | ||
| 1132 | } | ||
| 1133 | } | ||
| 1134 | |||
| 1135 | yield* trySourceIngestPromise( | ||
| 1136 | () => | ||
| 1137 | ctx.runMutation(runtimeInternal.control_plane.tool_registry.bindSourceToArtifact, { | ||
| 1138 | workspaceId: source.workspaceId, | ||
| 1139 | sourceId: source.id, | ||
| 1140 | artifactId: artifactMeta.artifactId, | ||
| 1141 | }), | ||
| 1142 | "Failed to bind source to GraphQL artifact", | ||
| 1143 | ); | ||
| 1144 | |||
| 1145 | const namespace = sourceNamespace(source); | ||
| 1146 | const indexRows = extracted.tools.map((tool) => ({ | ||
| 1147 | toolId: tool.toolId, | ||
| 1148 | protocol: "graphql", | ||
| 1149 | method: "post", | ||
| 1150 | path: sourceToolPath(source, tool.toolId), | ||
| 1151 | operationPath: null, | ||
| 1152 | name: tool.name, | ||
| 1153 | description: tool.description, | ||
| 1154 | searchText: normalizedSearchText( | ||
| 1155 | source.name, | ||
| 1156 | source.endpoint, | ||
| 1157 | namespace, | ||
| 1158 | tool.toolId, | ||
| 1159 | tool.name, | ||
| 1160 | tool.description, | ||
| 1161 | tool.operationType, | ||
| 1162 | tool.fieldName, | ||
| 1163 | ), | ||
| 1164 | operationHash: tool.operationHash, | ||
| 1165 | approvalMode: "auto", | ||
| 1166 | status: source.enabled ? "active" : "disabled", | ||
| 1167 | })); | ||
| 1168 | |||
| 1169 | if (options.rebuildIndex) { | ||
| 1170 | yield* trySourceIngestPromise( | ||
| 1171 | () => | ||
| 1172 | ctx.runMutation(runtimeInternal.control_plane.tool_registry.replaceWorkspaceSourceToolIndex, { | ||
| 1173 | workspaceId: source.workspaceId, | ||
| 1174 | sourceId: source.id, | ||
| 1175 | sourceName: source.name, | ||
| 1176 | sourceKind: source.kind, | ||
| 1177 | artifactId: artifactMeta.artifactId, | ||
| 1178 | namespace, | ||
| 1179 | refHintTableJson: null, | ||
| 1180 | rows: indexRows, | ||
| 1181 | }), | ||
| 1182 | "Failed to rebuild workspace tool index for GraphQL source", | ||
| 1183 | ); | ||
| 1184 | } | ||
| 1185 | |||
| 1186 | return { | ||
| 1187 | protocol: "graphql", | ||
| 1188 | artifactId: artifactMeta.artifactId, | ||
| 1189 | sourceHash: extracted.schemaHash, | ||
| 1190 | toolCount: extracted.tools.length, | ||
| 1191 | namespace, | ||
| 1192 | refHintTableJson: null, | ||
| 1193 | artifactBatchCount: artifactMeta.created && options.stageArtifactWrites | ||
| 1194 | ? Math.ceil(extracted.tools.length / stagedArtifactBatchSize) | ||
| 1195 | : 0, | ||
| 1196 | }; | ||
| 1197 | }); | ||
| 1198 | |||
| 1199 | const ingestMcpSource = ( | ||
| 1200 | ctx: any, | ||
| 1201 | source: Source, | ||
| 1202 | options: IngestOptions, | ||
| 1203 | ): Effect.Effect<SourceIngestPrepared, SourceIngestError> => | ||
| 1204 | Effect.gen(function* () { | ||
| 1205 | const credentialHeadersResult = yield* trySourceIngestPromise<{ | ||
| 1206 | headers: Record<string, string>; | ||
| 1207 | }>( | ||
| 1208 | () => | ||
| 1209 | ctx.runAction(runtimeInternal.control_plane.credentials.resolveSourceCredentialHeadersForIngest, { | ||
| 1210 | workspaceId: source.workspaceId, | ||
| 1211 | sourceId: source.id, | ||
| 1212 | sourceName: source.name, | ||
| 1213 | sourceEndpoint: source.endpoint, | ||
| 1214 | }), | ||
| 1215 | "Failed to resolve source credentials for MCP ingest", | ||
| 1216 | ); | ||
| 1217 | |||
| 1218 | const headers = mergeHeaders( | ||
| 1219 | collectMcpHeadersFromSourceConfig(source), | ||
| 1220 | credentialHeadersResult.headers, | ||
| 1221 | ); | ||
| 1222 | |||
| 1223 | const connection = yield* connectMcp(source, headers); | ||
| 1224 | |||
| 1225 | const listedResult = yield* Effect.tryPromise({ | ||
| 1226 | try: () => connection.client.listTools(), | ||
| 1227 | catch: (cause) => | ||
| 1228 | SourceIngestError.make({ | ||
| 1229 | status: sourceIngestStatusFromCause(cause), | ||
| 1230 | message: `Failed to list MCP tools: ${formatError(cause)}`, | ||
| 1231 | }), | ||
| 1232 | }).pipe( | ||
| 1233 | Effect.ensuring( | ||
| 1234 | Effect.promise(() => connection.close().catch(() => undefined)), | ||
| 1235 | ), | ||
| 1236 | ); | ||
| 1237 | |||
| 1238 | const listedTools = extractMcpListedToolRows(listedResult); | ||
| 1239 | const extracted = extractMcpTools(source, connection.transport, listedTools); | ||
| 1240 | |||
| 1241 | const artifactMeta = yield* trySourceIngestPromise<{ | ||
| 1242 | artifactId: string; | ||
| 1243 | created: boolean; | ||
| 1244 | }>( | ||
| 1245 | () => | ||
| 1246 | ctx.runMutation(runtimeInternal.control_plane.tool_registry.upsertArtifactMeta, { | ||
| 1247 | protocol: "mcp", | ||
| 1248 | contentHash: extracted.sourceHash, | ||
| 1249 | extractorVersion: mcpExtractorVersion, | ||
| 1250 | toolCount: extracted.tools.length, | ||
| 1251 | }), | ||
| 1252 | "Failed to upsert MCP artifact metadata", | ||
| 1253 | ); | ||
| 1254 | |||
| 1255 | if (artifactMeta.created) { | ||
| 1256 | const artifactRows = extracted.tools.map((tool) => { | ||
| 1257 | const schemas = extractMcpSchemas(tool.invocationJson); | ||
| 1258 | return { | ||
| 1259 | toolId: tool.toolId, | ||
| 1260 | name: tool.name, | ||
| 1261 | description: tool.description, | ||
| 1262 | canonicalPath: tool.toolName, | ||
| 1263 | operationHash: tool.operationHash, | ||
| 1264 | invocationJson: tool.invocationJson, | ||
| 1265 | inputSchemaJson: schemas.inputSchemaJson, | ||
| 1266 | outputSchemaJson: schemas.outputSchemaJson, | ||
| 1267 | metadataJson: safeJsonStringify({ | ||
| 1268 | toolName: tool.toolName, | ||
| 1269 | }), | ||
| 1270 | }; | ||
| 1271 | }); | ||
| 1272 | |||
| 1273 | if (options.stageArtifactWrites) { | ||
| 1274 | const serializedBatches = chunkArray(artifactRows, stagedArtifactBatchSize).map((batch) => | ||
| 1275 | JSON.stringify(batch), | ||
| 1276 | ); | ||
| 1277 | |||
| 1278 | yield* trySourceIngestPromise( | ||
| 1279 | () => | ||
| 1280 | ctx.runMutation( | ||
| 1281 | runtimeInternal.control_plane.tool_registry.replaceSourceIngestArtifactBatches, | ||
| 1282 | { | ||
| 1283 | workspaceId: source.workspaceId, | ||
| 1284 | sourceId: source.id, | ||
| 1285 | artifactId: artifactMeta.artifactId, | ||
| 1286 | protocol: "mcp", | ||
| 1287 | batches: serializedBatches, | ||
| 1288 | }, | ||
| 1289 | ), | ||
| 1290 | "Failed to stage MCP artifact tool batches", | ||
| 1291 | ); | ||
| 1292 | } else { | ||
| 1293 | for (let index = 0; index < artifactRows.length; index += writeBatchSize) { | ||
| 1294 | const batch = artifactRows.slice(index, index + writeBatchSize); | ||
| 1295 | yield* trySourceIngestPromise( | ||
| 1296 | () => | ||
| 1297 | ctx.runMutation(runtimeInternal.control_plane.tool_registry.putArtifactToolsBatch, { | ||
| 1298 | artifactId: artifactMeta.artifactId, | ||
| 1299 | protocol: "mcp", | ||
| 1300 | insertOnly: true, | ||
| 1301 | tools: batch, | ||
| 1302 | }), | ||
| 1303 | "Failed to write MCP artifact tools", | ||
| 1304 | ); | ||
| 1305 | } | ||
| 1306 | } | ||
| 1307 | } | ||
| 1308 | |||
| 1309 | yield* trySourceIngestPromise( | ||
| 1310 | () => | ||
| 1311 | ctx.runMutation(runtimeInternal.control_plane.tool_registry.bindSourceToArtifact, { | ||
| 1312 | workspaceId: source.workspaceId, | ||
| 1313 | sourceId: source.id, | ||
| 1314 | artifactId: artifactMeta.artifactId, | ||
| 1315 | }), | ||
| 1316 | "Failed to bind source to MCP artifact", | ||
| 1317 | ); | ||
| 1318 | |||
| 1319 | const namespace = sourceNamespace(source); | ||
| 1320 | const indexRows = extracted.tools.map((tool) => { | ||
| 1321 | return { | ||
| 1322 | toolId: tool.toolId, | ||
| 1323 | protocol: "mcp", | ||
| 1324 | method: "post", | ||
| 1325 | path: sourceToolPath(source, tool.toolId), | ||
| 1326 | operationPath: null, | ||
| 1327 | name: tool.name, | ||
| 1328 | description: tool.description, | ||
| 1329 | searchText: normalizedSearchText( | ||
| 1330 | source.name, | ||
| 1331 | source.endpoint, | ||
| 1332 | namespace, | ||
| 1333 | tool.toolId, | ||
| 1334 | tool.name, | ||
| 1335 | tool.description, | ||
| 1336 | tool.toolName, | ||
| 1337 | ), | ||
| 1338 | operationHash: tool.operationHash, | ||
| 1339 | approvalMode: "auto", | ||
| 1340 | status: source.enabled ? "active" : "disabled", | ||
| 1341 | }; | ||
| 1342 | }); | ||
| 1343 | |||
| 1344 | if (options.rebuildIndex) { | ||
| 1345 | yield* trySourceIngestPromise( | ||
| 1346 | () => | ||
| 1347 | ctx.runMutation(runtimeInternal.control_plane.tool_registry.replaceWorkspaceSourceToolIndex, { | ||
| 1348 | workspaceId: source.workspaceId, | ||
| 1349 | sourceId: source.id, | ||
| 1350 | sourceName: source.name, | ||
| 1351 | sourceKind: source.kind, | ||
| 1352 | artifactId: artifactMeta.artifactId, | ||
| 1353 | namespace, | ||
| 1354 | refHintTableJson: null, | ||
| 1355 | rows: indexRows, | ||
| 1356 | }), | ||
| 1357 | "Failed to rebuild workspace tool index for MCP source", | ||
| 1358 | ); | ||
| 1359 | } | ||
| 1360 | |||
| 1361 | return { | ||
| 1362 | protocol: "mcp", | ||
| 1363 | artifactId: artifactMeta.artifactId, | ||
| 1364 | sourceHash: extracted.sourceHash, | ||
| 1365 | toolCount: extracted.tools.length, | ||
| 1366 | namespace, | ||
| 1367 | refHintTableJson: null, | ||
| 1368 | artifactBatchCount: artifactMeta.created && options.stageArtifactWrites | ||
| 1369 | ? Math.ceil(extracted.tools.length / stagedArtifactBatchSize) | ||
| 1370 | : 0, | ||
| 1371 | }; | ||
| 1372 | }); | ||
| 1373 | |||
| 1374 | export const ingestSourceArtifact = internalAction({ | ||
| 1375 | args: { | ||
| 1376 | workspaceId: v.string(), | ||
| 1377 | sourceId: v.string(), | ||
| 1378 | }, | ||
| 1379 | handler: async (ctx, args): Promise<void> => { | ||
| 1380 | const source = await ctx.runQuery(runtimeInternal.control_plane.sources.getSourceForIngest, { | ||
| 1381 | sourceId: args.sourceId, | ||
| 1382 | }); | ||
| 1383 | |||
| 1384 | if (!source || source.workspaceId !== args.workspaceId) { | ||
| 1385 | return; | ||
| 1386 | } | ||
| 1387 | |||
| 1388 | await ctx.runMutation(runtimeInternal.control_plane.sources.setSourceIngestState, { | ||
| 1389 | sourceId: source.id, | ||
| 1390 | status: "probing", | ||
| 1391 | lastError: null, | ||
| 1392 | }); | ||
| 1393 | |||
| 1394 | const ingestEffect = source.kind === "openapi" | ||
| 1395 | ? ingestOpenApiSource(ctx, source) | ||
| 1396 | : source.kind === "graphql" | ||
| 1397 | ? ingestGraphqlSource(ctx, source, { | ||
| 1398 | rebuildIndex: true, | ||
| 1399 | stageArtifactWrites: false, | ||
| 1400 | }) | ||
| 1401 | : source.kind === "mcp" | ||
| 1402 | ? ingestMcpSource(ctx, source, { | ||
| 1403 | rebuildIndex: true, | ||
| 1404 | stageArtifactWrites: false, | ||
| 1405 | }) | ||
| 1406 | : Effect.fail( | ||
| 1407 | SourceIngestError.make({ | ||
| 1408 | status: "error", | ||
| 1409 | message: `Source ingest for kind '${source.kind}' is not implemented yet`, | ||
| 1410 | }), | ||
| 1411 | ); | ||
| 1412 | |||
| 1413 | const result = await Effect.runPromise( | ||
| 1414 | ingestEffect.pipe( | ||
| 1415 | Effect.match({ | ||
| 1416 | onFailure: (error) => ({ | ||
| 1417 | status: error.status, | ||
| 1418 | sourceHash: null as string | null, | ||
| 1419 | lastError: error.message, | ||
| 1420 | }), | ||
| 1421 | onSuccess: (prepared) => ({ | ||
| 1422 | status: "connected" as const, | ||
| 1423 | sourceHash: prepared.sourceHash, | ||
| 1424 | lastError: null as string | null, | ||
| 1425 | }), | ||
| 1426 | }), | ||
| 1427 | ), | ||
| 1428 | ); | ||
| 1429 | |||
| 1430 | await ctx.runMutation(runtimeInternal.control_plane.sources.setSourceIngestState, { | ||
| 1431 | sourceId: source.id, | ||
| 1432 | status: result.status, | ||
| 1433 | sourceHash: result.sourceHash, | ||
| 1434 | lastError: result.lastError, | ||
| 1435 | }); | ||
| 1436 | }, | ||
| 1437 | }); | ||
| @@ -0,0 +1,124 @@ | |||
| 1 | import { type UpsertOrganizationPayload } from "@executor-v2/management-api"; | ||
| 2 | import { | ||
| 3 | OrganizationSchema, | ||
| 4 | type Organization, | ||
| 5 | type OrganizationMembership, | ||
| 6 | } from "@executor-v2/schema"; | ||
| 7 | import { v } from "convex/values"; | ||
| 8 | import * as Schema from "effect/Schema"; | ||
| 9 | |||
| 10 | import { mutation, query } from "../_generated/server"; | ||
| 11 | |||
| 12 | const decodeOrganization = Schema.decodeUnknownSync(OrganizationSchema); | ||
| 13 | |||
| 14 | const stripConvexSystemFields = ( | ||
| 15 | value: Record<string, unknown>, | ||
| 16 | ): Record<string, unknown> => { | ||
| 17 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 18 | return rest; | ||
| 19 | }; | ||
| 20 | |||
| 21 | const toOrganization = (document: Record<string, unknown>): Organization => | ||
| 22 | decodeOrganization(stripConvexSystemFields(document)); | ||
| 23 | |||
| 24 | const organizationStatusValidator = v.union( | ||
| 25 | v.literal("active"), | ||
| 26 | v.literal("suspended"), | ||
| 27 | v.literal("archived"), | ||
| 28 | ); | ||
| 29 | |||
| 30 | const sortOrganizations = ( | ||
| 31 | organizations: ReadonlyArray<Organization>, | ||
| 32 | ): Array<Organization> => | ||
| 33 | [...organizations].sort((left, right) => { | ||
| 34 | const leftName = left.name.toLowerCase(); | ||
| 35 | const rightName = right.name.toLowerCase(); | ||
| 36 | |||
| 37 | if (leftName === rightName) { | ||
| 38 | return left.id.localeCompare(right.id); | ||
| 39 | } | ||
| 40 | |||
| 41 | return leftName.localeCompare(rightName); | ||
| 42 | }); | ||
| 43 | |||
| 44 | export const listOrganizations = query({ | ||
| 45 | args: {}, | ||
| 46 | handler: async (ctx): Promise<Array<Organization>> => { | ||
| 47 | const rows = await ctx.db.query("organizations").collect(); | ||
| 48 | |||
| 49 | return sortOrganizations( | ||
| 50 | rows.map((row) => toOrganization(row as unknown as Record<string, unknown>)), | ||
| 51 | ); | ||
| 52 | }, | ||
| 53 | }); | ||
| 54 | |||
| 55 | export const upsertOrganization = mutation({ | ||
| 56 | args: { | ||
| 57 | payload: v.object({ | ||
| 58 | id: v.optional(v.string()), | ||
| 59 | slug: v.string(), | ||
| 60 | name: v.string(), | ||
| 61 | status: v.optional(organizationStatusValidator), | ||
| 62 | createdByAccountId: v.optional(v.union(v.string(), v.null())), | ||
| 63 | }), | ||
| 64 | }, | ||
| 65 | handler: async (ctx, args): Promise<Organization> => { | ||
| 66 | const payload = args.payload as UpsertOrganizationPayload; | ||
| 67 | const now = Date.now(); | ||
| 68 | const organizationId = payload.id ?? `org_${crypto.randomUUID()}`; | ||
| 69 | |||
| 70 | const existing = await ctx.db | ||
| 71 | .query("organizations") | ||
| 72 | .withIndex("by_domainId", (q) => q.eq("id", organizationId)) | ||
| 73 | .unique(); | ||
| 74 | |||
| 75 | const nextOrganization = decodeOrganization({ | ||
| 76 | id: organizationId, | ||
| 77 | slug: payload.slug, | ||
| 78 | name: payload.name, | ||
| 79 | status: payload.status ?? existing?.status ?? "active", | ||
| 80 | createdByAccountId: | ||
| 81 | existing?.createdByAccountId | ||
| 82 | ?? payload.createdByAccountId | ||
| 83 | ?? null, | ||
| 84 | createdAt: existing?.createdAt ?? now, | ||
| 85 | updatedAt: now, | ||
| 86 | }); | ||
| 87 | |||
| 88 | if (existing) { | ||
| 89 | await ctx.db.patch(existing._id, nextOrganization); | ||
| 90 | } else { | ||
| 91 | await ctx.db.insert("organizations", nextOrganization); | ||
| 92 | |||
| 93 | if (nextOrganization.createdByAccountId !== null) { | ||
| 94 | const existingMembership = await ctx.db | ||
| 95 | .query("organizationMemberships") | ||
| 96 | .withIndex("by_organizationId_accountId", (q) => | ||
| 97 | q | ||
| 98 | .eq("organizationId", nextOrganization.id) | ||
| 99 | .eq("accountId", nextOrganization.createdByAccountId as string) | ||
| 100 | ) | ||
| 101 | .first(); | ||
| 102 | |||
| 103 | if (!existingMembership) { | ||
| 104 | const membership: OrganizationMembership = { | ||
| 105 | id: `org_member_${crypto.randomUUID()}` as OrganizationMembership["id"], | ||
| 106 | organizationId: nextOrganization.id, | ||
| 107 | accountId: nextOrganization.createdByAccountId, | ||
| 108 | role: "owner", | ||
| 109 | status: "active", | ||
| 110 | billable: false, | ||
| 111 | invitedByAccountId: null, | ||
| 112 | joinedAt: now, | ||
| 113 | createdAt: now, | ||
| 114 | updatedAt: now, | ||
| 115 | }; | ||
| 116 | |||
| 117 | await ctx.db.insert("organizationMemberships", membership); | ||
| 118 | } | ||
| 119 | } | ||
| 120 | } | ||
| 121 | |||
| 122 | return nextOrganization; | ||
| 123 | }, | ||
| 124 | }); | ||
| @@ -0,0 +1,120 @@ | |||
| 1 | import { type UpsertPolicyPayload } from "@executor-v2/management-api"; | ||
| 2 | import { PolicySchema, type Policy } from "@executor-v2/schema"; | ||
| 3 | import { v } from "convex/values"; | ||
| 4 | import * as Schema from "effect/Schema"; | ||
| 5 | |||
| 6 | import { mutation, query } from "../_generated/server"; | ||
| 7 | |||
| 8 | const decodePolicy = Schema.decodeUnknownSync(PolicySchema); | ||
| 9 | |||
| 10 | const stripConvexSystemFields = ( | ||
| 11 | value: Record<string, unknown>, | ||
| 12 | ): Record<string, unknown> => { | ||
| 13 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 14 | return rest; | ||
| 15 | }; | ||
| 16 | |||
| 17 | const toPolicy = (document: Record<string, unknown>): Policy => | ||
| 18 | decodePolicy(stripConvexSystemFields(document)); | ||
| 19 | |||
| 20 | const policyDecisionValidator = v.union( | ||
| 21 | v.literal("allow"), | ||
| 22 | v.literal("require_approval"), | ||
| 23 | v.literal("deny"), | ||
| 24 | ); | ||
| 25 | |||
| 26 | const sortPolicies = (policies: ReadonlyArray<Policy>): Array<Policy> => | ||
| 27 | [...policies].sort((left, right) => { | ||
| 28 | const leftPattern = left.toolPathPattern.toLowerCase(); | ||
| 29 | const rightPattern = right.toolPathPattern.toLowerCase(); | ||
| 30 | |||
| 31 | if (leftPattern === rightPattern) { | ||
| 32 | return left.id.localeCompare(right.id); | ||
| 33 | } | ||
| 34 | |||
| 35 | return leftPattern.localeCompare(rightPattern); | ||
| 36 | }); | ||
| 37 | |||
| 38 | export const listPolicies = query({ | ||
| 39 | args: { | ||
| 40 | workspaceId: v.string(), | ||
| 41 | }, | ||
| 42 | handler: async (ctx, args): Promise<Array<Policy>> => { | ||
| 43 | const rows = await ctx.db | ||
| 44 | .query("policies") | ||
| 45 | .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId)) | ||
| 46 | .collect(); | ||
| 47 | |||
| 48 | return sortPolicies( | ||
| 49 | rows.map((row) => toPolicy(row as unknown as Record<string, unknown>)), | ||
| 50 | ); | ||
| 51 | }, | ||
| 52 | }); | ||
| 53 | |||
| 54 | export const upsertPolicy = mutation({ | ||
| 55 | args: { | ||
| 56 | workspaceId: v.string(), | ||
| 57 | payload: v.object({ | ||
| 58 | id: v.optional(v.string()), | ||
| 59 | toolPathPattern: v.string(), | ||
| 60 | decision: policyDecisionValidator, | ||
| 61 | }), | ||
| 62 | }, | ||
| 63 | handler: async (ctx, args): Promise<Policy> => { | ||
| 64 | const payload = args.payload as UpsertPolicyPayload; | ||
| 65 | const now = Date.now(); | ||
| 66 | const policyId = payload.id ?? `pol_${crypto.randomUUID()}`; | ||
| 67 | |||
| 68 | const existing = await ctx.db | ||
| 69 | .query("policies") | ||
| 70 | .withIndex("by_domainId", (q) => q.eq("id", policyId)) | ||
| 71 | .unique(); | ||
| 72 | |||
| 73 | if (existing && existing.workspaceId !== args.workspaceId) { | ||
| 74 | throw new Error(`Policy not found: ${policyId}`); | ||
| 75 | } | ||
| 76 | |||
| 77 | const nextPolicy = decodePolicy({ | ||
| 78 | id: policyId, | ||
| 79 | workspaceId: args.workspaceId, | ||
| 80 | toolPathPattern: payload.toolPathPattern, | ||
| 81 | decision: payload.decision, | ||
| 82 | createdAt: existing?.createdAt ?? now, | ||
| 83 | updatedAt: now, | ||
| 84 | }); | ||
| 85 | |||
| 86 | if (existing) { | ||
| 87 | await ctx.db.patch(existing._id, nextPolicy); | ||
| 88 | } else { | ||
| 89 | await ctx.db.insert("policies", nextPolicy); | ||
| 90 | } | ||
| 91 | |||
| 92 | return nextPolicy; | ||
| 93 | }, | ||
| 94 | }); | ||
| 95 | |||
| 96 | export const removePolicy = mutation({ | ||
| 97 | args: { | ||
| 98 | workspaceId: v.string(), | ||
| 99 | policyId: v.string(), | ||
| 100 | }, | ||
| 101 | handler: async ( | ||
| 102 | ctx, | ||
| 103 | args, | ||
| 104 | ): Promise<{ | ||
| 105 | removed: boolean; | ||
| 106 | }> => { | ||
| 107 | const existing = await ctx.db | ||
| 108 | .query("policies") | ||
| 109 | .withIndex("by_domainId", (q) => q.eq("id", args.policyId)) | ||
| 110 | .unique(); | ||
| 111 | |||
| 112 | if (!existing || existing.workspaceId !== args.workspaceId) { | ||
| 113 | return { removed: false }; | ||
| 114 | } | ||
| 115 | |||
| 116 | await ctx.db.delete(existing._id); | ||
| 117 | |||
| 118 | return { removed: true }; | ||
| 119 | }, | ||
| 120 | }); | ||
| @@ -0,0 +1,247 @@ | |||
| 1 | import { | ||
| 2 | ControlPlaneService, | ||
| 3 | type ControlPlaneServiceShape, | ||
| 4 | } from "@executor-v2/management-api"; | ||
| 5 | import * as Effect from "effect/Effect"; | ||
| 6 | |||
| 7 | import { api } from "../_generated/api"; | ||
| 8 | import type { ActionCtx } from "../_generated/server"; | ||
| 9 | import { toSourceStoreError } from "./errors"; | ||
| 10 | |||
| 11 | export const makeConvexControlPlaneService = ( | ||
| 12 | ctx: ActionCtx, | ||
| 13 | ): ControlPlaneServiceShape => | ||
| 14 | ControlPlaneService.of({ | ||
| 15 | listSources: (workspaceId) => | ||
| 16 | Effect.tryPromise({ | ||
| 17 | try: () => | ||
| 18 | ctx.runQuery(api.controlPlane.listSources, { | ||
| 19 | workspaceId, | ||
| 20 | }), | ||
| 21 | catch: (cause) => toSourceStoreError("controlPlane.listSources", cause), | ||
| 22 | }), | ||
| 23 | upsertSource: (input) => | ||
| 24 | Effect.tryPromise({ | ||
| 25 | try: () => | ||
| 26 | ctx.runAction(api.controlPlane.upsertSource, { | ||
| 27 | workspaceId: input.workspaceId, | ||
| 28 | payload: input.payload, | ||
| 29 | }), | ||
| 30 | catch: (cause) => toSourceStoreError("controlPlane.upsertSource", cause), | ||
| 31 | }), | ||
| 32 | removeSource: (input) => | ||
| 33 | Effect.tryPromise({ | ||
| 34 | try: () => | ||
| 35 | ctx.runMutation(api.controlPlane.removeSource, { | ||
| 36 | workspaceId: input.workspaceId, | ||
| 37 | sourceId: input.sourceId, | ||
| 38 | }), | ||
| 39 | catch: (cause) => toSourceStoreError("controlPlane.removeSource", cause), | ||
| 40 | }), | ||
| 41 | listCredentialBindings: (workspaceId) => | ||
| 42 | Effect.tryPromise({ | ||
| 43 | try: () => | ||
| 44 | ctx.runQuery(api.controlPlane.listCredentialBindings, { | ||
| 45 | workspaceId, | ||
| 46 | }), | ||
| 47 | catch: (cause) => | ||
| 48 | toSourceStoreError("controlPlane.listCredentialBindings", cause), | ||
| 49 | }), | ||
| 50 | upsertCredentialBinding: (input) => | ||
| 51 | Effect.tryPromise({ | ||
| 52 | try: () => | ||
| 53 | ctx.runAction(api.controlPlane.upsertCredentialBinding, { | ||
| 54 | workspaceId: input.workspaceId, | ||
| 55 | payload: input.payload, | ||
| 56 | }), | ||
| 57 | catch: (cause) => | ||
| 58 | toSourceStoreError("controlPlane.upsertCredentialBinding", cause), | ||
| 59 | }), | ||
| 60 | removeCredentialBinding: (input) => | ||
| 61 | Effect.tryPromise({ | ||
| 62 | try: () => | ||
| 63 | ctx.runMutation(api.controlPlane.removeCredentialBinding, { | ||
| 64 | workspaceId: input.workspaceId, | ||
| 65 | credentialBindingId: input.credentialBindingId, | ||
| 66 | }), | ||
| 67 | catch: (cause) => | ||
| 68 | toSourceStoreError("controlPlane.removeCredentialBinding", cause), | ||
| 69 | }), | ||
| 70 | listPolicies: (workspaceId) => | ||
| 71 | Effect.tryPromise({ | ||
| 72 | try: () => | ||
| 73 | ctx.runQuery(api.controlPlane.listPolicies, { | ||
| 74 | workspaceId, | ||
| 75 | }), | ||
| 76 | catch: (cause) => toSourceStoreError("controlPlane.listPolicies", cause), | ||
| 77 | }), | ||
| 78 | upsertPolicy: (input) => | ||
| 79 | Effect.tryPromise({ | ||
| 80 | try: () => | ||
| 81 | ctx.runMutation(api.controlPlane.upsertPolicy, { | ||
| 82 | workspaceId: input.workspaceId, | ||
| 83 | payload: input.payload, | ||
| 84 | }), | ||
| 85 | catch: (cause) => toSourceStoreError("controlPlane.upsertPolicy", cause), | ||
| 86 | }), | ||
| 87 | removePolicy: (input) => | ||
| 88 | Effect.tryPromise({ | ||
| 89 | try: () => | ||
| 90 | ctx.runMutation(api.controlPlane.removePolicy, { | ||
| 91 | workspaceId: input.workspaceId, | ||
| 92 | policyId: input.policyId, | ||
| 93 | }), | ||
| 94 | catch: (cause) => toSourceStoreError("controlPlane.removePolicy", cause), | ||
| 95 | }), | ||
| 96 | listOrganizations: () => | ||
| 97 | Effect.tryPromise({ | ||
| 98 | try: () => ctx.runQuery(api.controlPlane.listOrganizations, {}), | ||
| 99 | catch: (cause) => toSourceStoreError("controlPlane.listOrganizations", cause), | ||
| 100 | }), | ||
| 101 | upsertOrganization: (input) => | ||
| 102 | Effect.tryPromise({ | ||
| 103 | try: () => | ||
| 104 | ctx.runMutation(api.controlPlane.upsertOrganization, { | ||
| 105 | payload: input.payload, | ||
| 106 | }), | ||
| 107 | catch: (cause) => toSourceStoreError("controlPlane.upsertOrganization", cause), | ||
| 108 | }), | ||
| 109 | listWorkspaces: () => | ||
| 110 | Effect.tryPromise({ | ||
| 111 | try: () => ctx.runQuery(api.controlPlane.listWorkspaces, {}), | ||
| 112 | catch: (cause) => toSourceStoreError("controlPlane.listWorkspaces", cause), | ||
| 113 | }), | ||
| 114 | upsertWorkspace: (input) => | ||
| 115 | Effect.tryPromise({ | ||
| 116 | try: () => | ||
| 117 | ctx.runMutation(api.controlPlane.upsertWorkspace, { | ||
| 118 | payload: input.payload, | ||
| 119 | }), | ||
| 120 | catch: (cause) => toSourceStoreError("controlPlane.upsertWorkspace", cause), | ||
| 121 | }), | ||
| 122 | listWorkspaceTools: (workspaceId) => | ||
| 123 | Effect.tryPromise({ | ||
| 124 | try: () => | ||
| 125 | ctx.runQuery(api.controlPlane.listWorkspaceTools, { | ||
| 126 | workspaceId, | ||
| 127 | }), | ||
| 128 | catch: (cause) => toSourceStoreError("controlPlane.listWorkspaceTools", cause), | ||
| 129 | }), | ||
| 130 | listSourceTools: (input) => | ||
| 131 | Effect.tryPromise({ | ||
| 132 | try: () => | ||
| 133 | ctx.runQuery(api.controlPlane.listSourceTools, { | ||
| 134 | workspaceId: input.workspaceId, | ||
| 135 | sourceId: input.sourceId, | ||
| 136 | }), | ||
| 137 | catch: (cause) => toSourceStoreError("controlPlane.listSourceTools", cause), | ||
| 138 | }), | ||
| 139 | getToolDetail: (input) => | ||
| 140 | Effect.tryPromise({ | ||
| 141 | try: () => | ||
| 142 | ctx.runQuery(api.controlPlane.getToolDetail, { | ||
| 143 | workspaceId: input.workspaceId, | ||
| 144 | sourceId: input.sourceId, | ||
| 145 | operationHash: input.operationHash, | ||
| 146 | }), | ||
| 147 | catch: (cause) => toSourceStoreError("controlPlane.getToolDetail", cause), | ||
| 148 | }), | ||
| 149 | listStorageInstances: (workspaceId) => | ||
| 150 | Effect.tryPromise({ | ||
| 151 | try: () => | ||
| 152 | ctx.runQuery(api.controlPlane.listStorageInstances, { | ||
| 153 | workspaceId, | ||
| 154 | }), | ||
| 155 | catch: (cause) => | ||
| 156 | toSourceStoreError("controlPlane.listStorageInstances", cause), | ||
| 157 | }), | ||
| 158 | openStorageInstance: (input) => | ||
| 159 | Effect.tryPromise({ | ||
| 160 | try: () => | ||
| 161 | ctx.runMutation(api.controlPlane.openStorageInstance, { | ||
| 162 | workspaceId: input.workspaceId, | ||
| 163 | payload: input.payload, | ||
| 164 | }), | ||
| 165 | catch: (cause) => | ||
| 166 | toSourceStoreError("controlPlane.openStorageInstance", cause), | ||
| 167 | }), | ||
| 168 | closeStorageInstance: (input) => | ||
| 169 | Effect.tryPromise({ | ||
| 170 | try: () => | ||
| 171 | ctx.runMutation(api.controlPlane.closeStorageInstance, { | ||
| 172 | workspaceId: input.workspaceId, | ||
| 173 | storageInstanceId: input.storageInstanceId, | ||
| 174 | }), | ||
| 175 | catch: (cause) => | ||
| 176 | toSourceStoreError("controlPlane.closeStorageInstance", cause), | ||
| 177 | }), | ||
| 178 | removeStorageInstance: (input) => | ||
| 179 | Effect.tryPromise({ | ||
| 180 | try: () => | ||
| 181 | ctx.runMutation(api.controlPlane.removeStorageInstance, { | ||
| 182 | workspaceId: input.workspaceId, | ||
| 183 | storageInstanceId: input.storageInstanceId, | ||
| 184 | }), | ||
| 185 | catch: (cause) => | ||
| 186 | toSourceStoreError("controlPlane.removeStorageInstance", cause), | ||
| 187 | }), | ||
| 188 | listStorageDirectory: (input) => | ||
| 189 | Effect.tryPromise({ | ||
| 190 | try: () => | ||
| 191 | ctx.runQuery(api.controlPlane.listStorageDirectory, { | ||
| 192 | workspaceId: input.workspaceId, | ||
| 193 | storageInstanceId: input.storageInstanceId, | ||
| 194 | payload: input.payload, | ||
| 195 | }), | ||
| 196 | catch: (cause) => | ||
| 197 | toSourceStoreError("controlPlane.listStorageDirectory", cause), | ||
| 198 | }), | ||
| 199 | readStorageFile: (input) => | ||
| 200 | Effect.tryPromise({ | ||
| 201 | try: () => | ||
| 202 | ctx.runQuery(api.controlPlane.readStorageFile, { | ||
| 203 | workspaceId: input.workspaceId, | ||
| 204 | storageInstanceId: input.storageInstanceId, | ||
| 205 | payload: input.payload, | ||
| 206 | }), | ||
| 207 | catch: (cause) => toSourceStoreError("controlPlane.readStorageFile", cause), | ||
| 208 | }), | ||
| 209 | listStorageKv: (input) => | ||
| 210 | Effect.tryPromise({ | ||
| 211 | try: () => | ||
| 212 | ctx.runQuery(api.controlPlane.listStorageKv, { | ||
| 213 | workspaceId: input.workspaceId, | ||
| 214 | storageInstanceId: input.storageInstanceId, | ||
| 215 | payload: input.payload, | ||
| 216 | }), | ||
| 217 | catch: (cause) => toSourceStoreError("controlPlane.listStorageKv", cause), | ||
| 218 | }), | ||
| 219 | queryStorageSql: (input) => | ||
| 220 | Effect.tryPromise({ | ||
| 221 | try: () => | ||
| 222 | ctx.runMutation(api.controlPlane.queryStorageSql, { | ||
| 223 | workspaceId: input.workspaceId, | ||
| 224 | storageInstanceId: input.storageInstanceId, | ||
| 225 | payload: input.payload, | ||
| 226 | }), | ||
| 227 | catch: (cause) => toSourceStoreError("controlPlane.queryStorageSql", cause), | ||
| 228 | }), | ||
| 229 | listApprovals: (workspaceId) => | ||
| 230 | Effect.tryPromise({ | ||
| 231 | try: () => | ||
| 232 | ctx.runQuery(api.controlPlane.listApprovals, { | ||
| 233 | workspaceId, | ||
| 234 | }), | ||
| 235 | catch: (cause) => toSourceStoreError("controlPlane.listApprovals", cause), | ||
| 236 | }), | ||
| 237 | resolveApproval: (input) => | ||
| 238 | Effect.tryPromise({ | ||
| 239 | try: () => | ||
| 240 | ctx.runMutation(api.controlPlane.resolveApproval, { | ||
| 241 | workspaceId: input.workspaceId, | ||
| 242 | approvalId: input.approvalId, | ||
| 243 | payload: input.payload, | ||
| 244 | }), | ||
| 245 | catch: (cause) => toSourceStoreError("controlPlane.resolveApproval", cause), | ||
| 246 | }), | ||
| 247 | }); | ||
| @@ -0,0 +1,239 @@ | |||
| 1 | import { type UpsertSourcePayload } from "@executor-v2/management-api"; | ||
| 2 | import { SourceSchema, type Source } from "@executor-v2/schema"; | ||
| 3 | import { v } from "convex/values"; | ||
| 4 | import * as Schema from "effect/Schema"; | ||
| 5 | |||
| 6 | import { internal } from "../_generated/api"; | ||
| 7 | import { action, internalQuery, internalMutation, mutation, query } from "../_generated/server"; | ||
| 8 | |||
| 9 | const runtimeInternal = internal as any; | ||
| 10 | |||
| 11 | const decodeSource = Schema.decodeUnknownSync(SourceSchema); | ||
| 12 | |||
| 13 | const sourceStoreKey = (source: Source): string => `${source.workspaceId}:${source.id}`; | ||
| 14 | |||
| 15 | const sortSources = (sources: ReadonlyArray<Source>): Array<Source> => | ||
| 16 | [...sources].sort((left, right) => { | ||
| 17 | const leftName = left.name.toLowerCase(); | ||
| 18 | const rightName = right.name.toLowerCase(); | ||
| 19 | |||
| 20 | if (leftName === rightName) { | ||
| 21 | return sourceStoreKey(left).localeCompare(sourceStoreKey(right)); | ||
| 22 | } | ||
| 23 | |||
| 24 | return leftName.localeCompare(rightName); | ||
| 25 | }); | ||
| 26 | |||
| 27 | const toSource = (document: Record<string, unknown>): Source => { | ||
| 28 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...source } = document; | ||
| 29 | return decodeSource(source); | ||
| 30 | }; | ||
| 31 | |||
| 32 | const sourceKindValidator = v.union( | ||
| 33 | v.literal("mcp"), | ||
| 34 | v.literal("openapi"), | ||
| 35 | v.literal("graphql"), | ||
| 36 | v.literal("internal"), | ||
| 37 | ); | ||
| 38 | |||
| 39 | const sourceStatusValidator = v.union( | ||
| 40 | v.literal("draft"), | ||
| 41 | v.literal("probing"), | ||
| 42 | v.literal("auth_required"), | ||
| 43 | v.literal("connected"), | ||
| 44 | v.literal("error"), | ||
| 45 | ); | ||
| 46 | |||
| 47 | export const listSources = query({ | ||
| 48 | args: { | ||
| 49 | workspaceId: v.string(), | ||
| 50 | }, | ||
| 51 | handler: async (ctx, args): Promise<Array<Source>> => { | ||
| 52 | const documents = await ctx.db | ||
| 53 | .query("sources") | ||
| 54 | .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId)) | ||
| 55 | .collect(); | ||
| 56 | |||
| 57 | return sortSources( | ||
| 58 | documents.map((document) => | ||
| 59 | toSource(document as unknown as Record<string, unknown>), | ||
| 60 | ), | ||
| 61 | ); | ||
| 62 | }, | ||
| 63 | }); | ||
| 64 | |||
| 65 | export const upsertSourceRecord = internalMutation({ | ||
| 66 | args: { | ||
| 67 | workspaceId: v.string(), | ||
| 68 | payload: v.object({ | ||
| 69 | id: v.optional(v.string()), | ||
| 70 | name: v.string(), | ||
| 71 | kind: sourceKindValidator, | ||
| 72 | endpoint: v.string(), | ||
| 73 | status: v.optional(sourceStatusValidator), | ||
| 74 | enabled: v.optional(v.boolean()), | ||
| 75 | configJson: v.optional(v.string()), | ||
| 76 | sourceHash: v.optional(v.union(v.string(), v.null())), | ||
| 77 | lastError: v.optional(v.union(v.string(), v.null())), | ||
| 78 | }), | ||
| 79 | }, | ||
| 80 | handler: async (ctx, args): Promise<Source> => { | ||
| 81 | const now = Date.now(); | ||
| 82 | const sourceId = args.payload.id ?? `src_${crypto.randomUUID()}`; | ||
| 83 | |||
| 84 | const existing = await ctx.db | ||
| 85 | .query("sources") | ||
| 86 | .withIndex("by_domainId", (q) => q.eq("id", sourceId)) | ||
| 87 | .unique(); | ||
| 88 | |||
| 89 | const existingInWorkspace = | ||
| 90 | existing && existing.workspaceId === args.workspaceId ? existing : null; | ||
| 91 | |||
| 92 | const payload = args.payload as UpsertSourcePayload; | ||
| 93 | |||
| 94 | const source = decodeSource({ | ||
| 95 | id: sourceId, | ||
| 96 | workspaceId: args.workspaceId, | ||
| 97 | name: payload.name, | ||
| 98 | kind: payload.kind, | ||
| 99 | endpoint: payload.endpoint, | ||
| 100 | status: payload.status ?? "draft", | ||
| 101 | enabled: payload.enabled ?? true, | ||
| 102 | configJson: payload.configJson ?? "{}", | ||
| 103 | sourceHash: payload.sourceHash ?? null, | ||
| 104 | lastError: payload.lastError ?? null, | ||
| 105 | createdAt: existingInWorkspace?.createdAt ?? now, | ||
| 106 | updatedAt: now, | ||
| 107 | }); | ||
| 108 | |||
| 109 | if (existingInWorkspace) { | ||
| 110 | await ctx.db.patch(existingInWorkspace._id, source); | ||
| 111 | } else { | ||
| 112 | await ctx.db.insert("sources", source); | ||
| 113 | } | ||
| 114 | |||
| 115 | return source; | ||
| 116 | }, | ||
| 117 | }); | ||
| 118 | |||
| 119 | export const upsertSource = action({ | ||
| 120 | args: { | ||
| 121 | workspaceId: v.string(), | ||
| 122 | payload: v.object({ | ||
| 123 | id: v.optional(v.string()), | ||
| 124 | name: v.string(), | ||
| 125 | kind: sourceKindValidator, | ||
| 126 | endpoint: v.string(), | ||
| 127 | status: v.optional(sourceStatusValidator), | ||
| 128 | enabled: v.optional(v.boolean()), | ||
| 129 | configJson: v.optional(v.string()), | ||
| 130 | sourceHash: v.optional(v.union(v.string(), v.null())), | ||
| 131 | lastError: v.optional(v.union(v.string(), v.null())), | ||
| 132 | }), | ||
| 133 | }, | ||
| 134 | handler: async (ctx, args): Promise<Source> => { | ||
| 135 | const shouldIngest = args.payload.status !== "draft"; | ||
| 136 | const source = await ctx.runMutation(runtimeInternal.control_plane.sources.upsertSourceRecord, { | ||
| 137 | workspaceId: args.workspaceId, | ||
| 138 | payload: { | ||
| 139 | ...args.payload, | ||
| 140 | status: args.payload.status ?? (shouldIngest ? "probing" : "draft"), | ||
| 141 | }, | ||
| 142 | }); | ||
| 143 | |||
| 144 | if (shouldIngest && source.kind !== "internal") { | ||
| 145 | if (source.kind === "openapi") { | ||
| 146 | await ctx.runAction(runtimeInternal.control_plane.openapi_ingest.ingestSourceArtifact, { | ||
| 147 | workspaceId: source.workspaceId, | ||
| 148 | sourceId: source.id, | ||
| 149 | }); | ||
| 150 | } else { | ||
| 151 | await ctx.scheduler.runAfter( | ||
| 152 | 0, | ||
| 153 | runtimeInternal.control_plane.openapi_ingest.ingestSourceArtifact, | ||
| 154 | { | ||
| 155 | workspaceId: source.workspaceId, | ||
| 156 | sourceId: source.id, | ||
| 157 | }, | ||
| 158 | ); | ||
| 159 | } | ||
| 160 | } | ||
| 161 | |||
| 162 | return source; | ||
| 163 | }, | ||
| 164 | }); | ||
| 165 | |||
| 166 | export const getSourceForIngest = internalQuery({ | ||
| 167 | args: { | ||
| 168 | sourceId: v.string(), | ||
| 169 | }, | ||
| 170 | handler: async (ctx, args): Promise<Source | null> => { | ||
| 171 | const sourceRow = await ctx.db | ||
| 172 | .query("sources") | ||
| 173 | .withIndex("by_domainId", (q) => q.eq("id", args.sourceId)) | ||
| 174 | .unique(); | ||
| 175 | |||
| 176 | if (!sourceRow) { | ||
| 177 | return null; | ||
| 178 | } | ||
| 179 | |||
| 180 | return toSource(sourceRow as unknown as Record<string, unknown>); | ||
| 181 | }, | ||
| 182 | }); | ||
| 183 | |||
| 184 | export const setSourceIngestState = internalMutation({ | ||
| 185 | args: { | ||
| 186 | sourceId: v.string(), | ||
| 187 | status: sourceStatusValidator, | ||
| 188 | sourceHash: v.optional(v.union(v.string(), v.null())), | ||
| 189 | lastError: v.optional(v.union(v.string(), v.null())), | ||
| 190 | }, | ||
| 191 | handler: async (ctx, args): Promise<void> => { | ||
| 192 | const sourceRow = await ctx.db | ||
| 193 | .query("sources") | ||
| 194 | .withIndex("by_domainId", (q) => q.eq("id", args.sourceId)) | ||
| 195 | .unique(); | ||
| 196 | |||
| 197 | if (!sourceRow) { | ||
| 198 | return; | ||
| 199 | } | ||
| 200 | |||
| 201 | await ctx.db.patch(sourceRow._id, { | ||
| 202 | status: args.status, | ||
| 203 | sourceHash: args.sourceHash !== undefined ? args.sourceHash : sourceRow.sourceHash, | ||
| 204 | lastError: args.lastError !== undefined ? args.lastError : sourceRow.lastError, | ||
| 205 | updatedAt: Date.now(), | ||
| 206 | }); | ||
| 207 | }, | ||
| 208 | }); | ||
| 209 | |||
| 210 | export const removeSource = mutation({ | ||
| 211 | args: { | ||
| 212 | workspaceId: v.string(), | ||
| 213 | sourceId: v.string(), | ||
| 214 | }, | ||
| 215 | handler: async ( | ||
| 216 | ctx, | ||
| 217 | args, | ||
| 218 | ): Promise<{ | ||
| 219 | removed: boolean; | ||
| 220 | }> => { | ||
| 221 | const existing = await ctx.db | ||
| 222 | .query("sources") | ||
| 223 | .withIndex("by_domainId", (q) => q.eq("id", args.sourceId)) | ||
| 224 | .unique(); | ||
| 225 | |||
| 226 | if (!existing || existing.workspaceId !== args.workspaceId) { | ||
| 227 | return { removed: false }; | ||
| 228 | } | ||
| 229 | |||
| 230 | await ctx.runMutation(runtimeInternal.control_plane.tool_registry.removeSourceBindingsAndIndex, { | ||
| 231 | workspaceId: args.workspaceId, | ||
| 232 | sourceId: args.sourceId, | ||
| 233 | }); | ||
| 234 | |||
| 235 | await ctx.db.delete(existing._id); | ||
| 236 | |||
| 237 | return { removed: true }; | ||
| 238 | }, | ||
| 239 | }); | ||
| @@ -0,0 +1,1069 @@ | |||
| 1 | import { | ||
| 2 | type ListStorageDirectoryResult, | ||
| 3 | type ListStorageKvResult, | ||
| 4 | type OpenStorageInstancePayload, | ||
| 5 | type QueryStorageSqlResult, | ||
| 6 | type ReadStorageFileResult, | ||
| 7 | } from "@executor-v2/management-api"; | ||
| 8 | import { StorageInstanceSchema, type StorageInstance } from "@executor-v2/schema"; | ||
| 9 | import { v } from "convex/values"; | ||
| 10 | import * as Schema from "effect/Schema"; | ||
| 11 | |||
| 12 | import { | ||
| 13 | internalMutation, | ||
| 14 | mutation, | ||
| 15 | query, | ||
| 16 | type MutationCtx, | ||
| 17 | type QueryCtx, | ||
| 18 | } from "../_generated/server"; | ||
| 19 | |||
| 20 | const decodeStorageInstance = Schema.decodeUnknownSync(StorageInstanceSchema); | ||
| 21 | |||
| 22 | const StorageFileEntrySchema = Schema.Struct({ | ||
| 23 | id: Schema.String, | ||
| 24 | storageInstanceId: Schema.String, | ||
| 25 | path: Schema.String, | ||
| 26 | contentBase64: Schema.String, | ||
| 27 | sizeBytes: Schema.Number, | ||
| 28 | updatedAt: Schema.Number, | ||
| 29 | }); | ||
| 30 | |||
| 31 | type StorageFileEntry = typeof StorageFileEntrySchema.Type; | ||
| 32 | const decodeStorageFileEntry = Schema.decodeUnknownSync(StorageFileEntrySchema); | ||
| 33 | |||
| 34 | const StorageKvEntrySchema = Schema.Struct({ | ||
| 35 | id: Schema.String, | ||
| 36 | storageInstanceId: Schema.String, | ||
| 37 | key: Schema.String, | ||
| 38 | valueJson: Schema.String, | ||
| 39 | updatedAt: Schema.Number, | ||
| 40 | }); | ||
| 41 | |||
| 42 | type StorageKvEntry = typeof StorageKvEntrySchema.Type; | ||
| 43 | const decodeStorageKvEntry = Schema.decodeUnknownSync(StorageKvEntrySchema); | ||
| 44 | |||
| 45 | const StorageSqlKvEntrySchema = Schema.Struct({ | ||
| 46 | id: Schema.String, | ||
| 47 | storageInstanceId: Schema.String, | ||
| 48 | key: Schema.String, | ||
| 49 | value: Schema.String, | ||
| 50 | updatedAt: Schema.Number, | ||
| 51 | }); | ||
| 52 | |||
| 53 | type StorageSqlKvEntry = typeof StorageSqlKvEntrySchema.Type; | ||
| 54 | const decodeStorageSqlKvEntry = Schema.decodeUnknownSync(StorageSqlKvEntrySchema); | ||
| 55 | |||
| 56 | const DEFAULT_KV_LIMIT = 100; | ||
| 57 | const MAX_KV_LIMIT = 1000; | ||
| 58 | const DEFAULT_SQL_MAX_ROWS = 200; | ||
| 59 | const MAX_SQL_MAX_ROWS = 5000; | ||
| 60 | |||
| 61 | const stripConvexSystemFields = ( | ||
| 62 | value: Record<string, unknown>, | ||
| 63 | ): Record<string, unknown> => { | ||
| 64 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 65 | return rest; | ||
| 66 | }; | ||
| 67 | |||
| 68 | const toStorageInstance = (document: Record<string, unknown>): StorageInstance => | ||
| 69 | decodeStorageInstance(stripConvexSystemFields(document)); | ||
| 70 | |||
| 71 | const toStorageFileEntry = (document: Record<string, unknown>): StorageFileEntry => | ||
| 72 | decodeStorageFileEntry(stripConvexSystemFields(document)); | ||
| 73 | |||
| 74 | const toStorageKvEntry = (document: Record<string, unknown>): StorageKvEntry => | ||
| 75 | decodeStorageKvEntry(stripConvexSystemFields(document)); | ||
| 76 | |||
| 77 | const toStorageSqlKvEntry = (document: Record<string, unknown>): StorageSqlKvEntry => | ||
| 78 | decodeStorageSqlKvEntry(stripConvexSystemFields(document)); | ||
| 79 | |||
| 80 | const storageScopeTypeValidator = v.union( | ||
| 81 | v.literal("scratch"), | ||
| 82 | v.literal("account"), | ||
| 83 | v.literal("workspace"), | ||
| 84 | v.literal("organization"), | ||
| 85 | ); | ||
| 86 | |||
| 87 | const storageDurabilityValidator = v.union( | ||
| 88 | v.literal("ephemeral"), | ||
| 89 | v.literal("durable"), | ||
| 90 | ); | ||
| 91 | |||
| 92 | const storageProviderValidator = v.union( | ||
| 93 | v.literal("agentfs-local"), | ||
| 94 | v.literal("agentfs-cloudflare"), | ||
| 95 | ); | ||
| 96 | |||
| 97 | const readStorageEncodingValidator = v.union( | ||
| 98 | v.literal("utf8"), | ||
| 99 | v.literal("base64"), | ||
| 100 | ); | ||
| 101 | |||
| 102 | const sortStorageInstances = ( | ||
| 103 | storageInstances: ReadonlyArray<StorageInstance>, | ||
| 104 | ): Array<StorageInstance> => | ||
| 105 | [...storageInstances].sort((left, right) => { | ||
| 106 | if (left.updatedAt !== right.updatedAt) { | ||
| 107 | return right.updatedAt - left.updatedAt; | ||
| 108 | } | ||
| 109 | |||
| 110 | return left.id.localeCompare(right.id); | ||
| 111 | }); | ||
| 112 | |||
| 113 | const resolveWorkspaceOrganizationId = async ( | ||
| 114 | ctx: QueryCtx | MutationCtx, | ||
| 115 | workspaceId: string, | ||
| 116 | ): Promise<string> => { | ||
| 117 | const workspace = await ctx.db | ||
| 118 | .query("workspaces") | ||
| 119 | .withIndex("by_domainId", (q) => q.eq("id", workspaceId)) | ||
| 120 | .unique(); | ||
| 121 | |||
| 122 | if (!workspace) { | ||
| 123 | throw new Error(`Workspace not found: ${workspaceId}`); | ||
| 124 | } | ||
| 125 | |||
| 126 | return workspace.organizationId; | ||
| 127 | }; | ||
| 128 | |||
| 129 | const canAccessStorageInstance = ( | ||
| 130 | storageInstance: StorageInstance, | ||
| 131 | input: { | ||
| 132 | workspaceId: string; | ||
| 133 | organizationId: string; | ||
| 134 | }, | ||
| 135 | ): boolean => | ||
| 136 | storageInstance.workspaceId === input.workspaceId | ||
| 137 | || ( | ||
| 138 | storageInstance.workspaceId === null | ||
| 139 | && storageInstance.organizationId === input.organizationId | ||
| 140 | ); | ||
| 141 | |||
| 142 | const normalizeStoragePath = (pathValue: string): string => { | ||
| 143 | const trimmed = pathValue.trim().replaceAll("\\", "/"); | ||
| 144 | const prefixed = trimmed.length > 0 | ||
| 145 | ? (trimmed.startsWith("/") ? trimmed : `/${trimmed}`) | ||
| 146 | : "/"; | ||
| 147 | |||
| 148 | const parts = prefixed.split("/"); | ||
| 149 | const normalized: Array<string> = []; | ||
| 150 | |||
| 151 | for (const part of parts) { | ||
| 152 | if (part.length === 0 || part === ".") { | ||
| 153 | continue; | ||
| 154 | } | ||
| 155 | |||
| 156 | if (part === "..") { | ||
| 157 | if (normalized.length === 0) { | ||
| 158 | throw new Error("Path escapes storage root"); | ||
| 159 | } | ||
| 160 | normalized.pop(); | ||
| 161 | continue; | ||
| 162 | } | ||
| 163 | |||
| 164 | normalized.push(part); | ||
| 165 | } | ||
| 166 | |||
| 167 | if (normalized.length === 0) { | ||
| 168 | return "/"; | ||
| 169 | } | ||
| 170 | |||
| 171 | return `/${normalized.join("/")}`; | ||
| 172 | }; | ||
| 173 | |||
| 174 | const encodeUtf8Base64 = (value: string): string => { | ||
| 175 | if (typeof Buffer !== "undefined") { | ||
| 176 | return Buffer.from(value, "utf8").toString("base64"); | ||
| 177 | } | ||
| 178 | |||
| 179 | const bytes = new TextEncoder().encode(value); | ||
| 180 | let binary = ""; | ||
| 181 | for (const byte of bytes) { | ||
| 182 | binary += String.fromCharCode(byte); | ||
| 183 | } | ||
| 184 | return btoa(binary); | ||
| 185 | }; | ||
| 186 | |||
| 187 | const decodeBase64Utf8 = (value: string): string => { | ||
| 188 | if (typeof Buffer !== "undefined") { | ||
| 189 | return Buffer.from(value, "base64").toString("utf8"); | ||
| 190 | } | ||
| 191 | |||
| 192 | const binary = atob(value); | ||
| 193 | const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0)); | ||
| 194 | return new TextDecoder().decode(bytes); | ||
| 195 | }; | ||
| 196 | |||
| 197 | const parseJsonOrString = (value: string): unknown => { | ||
| 198 | try { | ||
| 199 | return JSON.parse(value) as unknown; | ||
| 200 | } catch { | ||
| 201 | return value; | ||
| 202 | } | ||
| 203 | }; | ||
| 204 | |||
| 205 | const resolveAccessibleStorageInstance = async ( | ||
| 206 | ctx: QueryCtx | MutationCtx, | ||
| 207 | input: { | ||
| 208 | workspaceId: string; | ||
| 209 | storageInstanceId: string; | ||
| 210 | }, | ||
| 211 | ): Promise<StorageInstance | null> => { | ||
| 212 | const organizationId = await resolveWorkspaceOrganizationId(ctx, input.workspaceId); | ||
| 213 | const storageInstanceRow = await ctx.db | ||
| 214 | .query("storageInstances") | ||
| 215 | .withIndex("by_domainId", (q) => q.eq("id", input.storageInstanceId)) | ||
| 216 | .unique(); | ||
| 217 | |||
| 218 | if (!storageInstanceRow) { | ||
| 219 | return null; | ||
| 220 | } | ||
| 221 | |||
| 222 | const storageInstance = toStorageInstance( | ||
| 223 | storageInstanceRow as unknown as Record<string, unknown>, | ||
| 224 | ); | ||
| 225 | |||
| 226 | if ( | ||
| 227 | !canAccessStorageInstance(storageInstance, { | ||
| 228 | workspaceId: input.workspaceId, | ||
| 229 | organizationId, | ||
| 230 | }) | ||
| 231 | ) { | ||
| 232 | return null; | ||
| 233 | } | ||
| 234 | |||
| 235 | return storageInstance; | ||
| 236 | }; | ||
| 237 | |||
| 238 | export const upsertStorageFileEntry = internalMutation({ | ||
| 239 | args: { | ||
| 240 | workspaceId: v.string(), | ||
| 241 | storageInstanceId: v.string(), | ||
| 242 | payload: v.object({ | ||
| 243 | path: v.string(), | ||
| 244 | content: v.string(), | ||
| 245 | }), | ||
| 246 | }, | ||
| 247 | handler: async (ctx, args): Promise<StorageFileEntry> => { | ||
| 248 | const storageInstance = await resolveAccessibleStorageInstance(ctx, { | ||
| 249 | workspaceId: args.workspaceId, | ||
| 250 | storageInstanceId: args.storageInstanceId, | ||
| 251 | }); | ||
| 252 | |||
| 253 | if (!storageInstance) { | ||
| 254 | throw new Error(`Storage instance not found: ${args.storageInstanceId}`); | ||
| 255 | } | ||
| 256 | |||
| 257 | const normalizedPath = normalizeStoragePath(args.payload.path); | ||
| 258 | const now = Date.now(); | ||
| 259 | const contentBase64 = encodeUtf8Base64(args.payload.content); | ||
| 260 | const sizeBytes = args.payload.content.length; | ||
| 261 | |||
| 262 | const existingRow = await ctx.db | ||
| 263 | .query("storageFileEntries") | ||
| 264 | .withIndex("by_storageInstanceId_path", (q) => | ||
| 265 | q.eq("storageInstanceId", args.storageInstanceId).eq("path", normalizedPath) | ||
| 266 | ) | ||
| 267 | .unique(); | ||
| 268 | |||
| 269 | const nextEntry = decodeStorageFileEntry({ | ||
| 270 | id: | ||
| 271 | (existingRow | ||
| 272 | ? toStorageFileEntry(existingRow as unknown as Record<string, unknown>).id | ||
| 273 | : `storage_file_${crypto.randomUUID()}`), | ||
| 274 | storageInstanceId: args.storageInstanceId, | ||
| 275 | path: normalizedPath, | ||
| 276 | contentBase64, | ||
| 277 | sizeBytes, | ||
| 278 | updatedAt: now, | ||
| 279 | }); | ||
| 280 | |||
| 281 | if (existingRow) { | ||
| 282 | await ctx.db.patch(existingRow._id, nextEntry); | ||
| 283 | } else { | ||
| 284 | await ctx.db.insert("storageFileEntries", nextEntry); | ||
| 285 | } | ||
| 286 | |||
| 287 | return nextEntry; | ||
| 288 | }, | ||
| 289 | }); | ||
| 290 | |||
| 291 | export const upsertStorageKvEntry = internalMutation({ | ||
| 292 | args: { | ||
| 293 | workspaceId: v.string(), | ||
| 294 | storageInstanceId: v.string(), | ||
| 295 | payload: v.object({ | ||
| 296 | key: v.string(), | ||
| 297 | valueJson: v.string(), | ||
| 298 | }), | ||
| 299 | }, | ||
| 300 | handler: async (ctx, args): Promise<StorageKvEntry> => { | ||
| 301 | const storageInstance = await resolveAccessibleStorageInstance(ctx, { | ||
| 302 | workspaceId: args.workspaceId, | ||
| 303 | storageInstanceId: args.storageInstanceId, | ||
| 304 | }); | ||
| 305 | |||
| 306 | if (!storageInstance) { | ||
| 307 | throw new Error(`Storage instance not found: ${args.storageInstanceId}`); | ||
| 308 | } | ||
| 309 | |||
| 310 | const now = Date.now(); | ||
| 311 | |||
| 312 | const existingRow = await ctx.db | ||
| 313 | .query("storageKvEntries") | ||
| 314 | .withIndex("by_storageInstanceId_key", (q) => | ||
| 315 | q.eq("storageInstanceId", args.storageInstanceId).eq("key", args.payload.key) | ||
| 316 | ) | ||
| 317 | .unique(); | ||
| 318 | |||
| 319 | const nextEntry = decodeStorageKvEntry({ | ||
| 320 | id: | ||
| 321 | (existingRow | ||
| 322 | ? toStorageKvEntry(existingRow as unknown as Record<string, unknown>).id | ||
| 323 | : `storage_kv_${crypto.randomUUID()}`), | ||
| 324 | storageInstanceId: args.storageInstanceId, | ||
| 325 | key: args.payload.key, | ||
| 326 | valueJson: args.payload.valueJson, | ||
| 327 | updatedAt: now, | ||
| 328 | }); | ||
| 329 | |||
| 330 | if (existingRow) { | ||
| 331 | await ctx.db.patch(existingRow._id, nextEntry); | ||
| 332 | } else { | ||
| 333 | await ctx.db.insert("storageKvEntries", nextEntry); | ||
| 334 | } | ||
| 335 | |||
| 336 | return nextEntry; | ||
| 337 | }, | ||
| 338 | }); | ||
| 339 | |||
| 340 | const decodeSqlStringLiteral = (value: string): string => value.replaceAll("''", "'"); | ||
| 341 | |||
| 342 | const parseSqlWhere = ( | ||
| 343 | whereClause: string | undefined, | ||
| 344 | ): ((key: string) => boolean) => { | ||
| 345 | if (whereClause === undefined) { | ||
| 346 | return () => true; | ||
| 347 | } | ||
| 348 | |||
| 349 | const equalsMatch = /^key\s*=\s*'((?:''|[^'])*)'$/i.exec(whereClause.trim()); | ||
| 350 | if (equalsMatch) { | ||
| 351 | const expectedKey = decodeSqlStringLiteral(equalsMatch[1] ?? ""); | ||
| 352 | return (key) => key === expectedKey; | ||
| 353 | } | ||
| 354 | |||
| 355 | const likeMatch = /^key\s+like\s+'((?:''|[^'])*)'$/i.exec(whereClause.trim()); | ||
| 356 | if (likeMatch) { | ||
| 357 | const pattern = decodeSqlStringLiteral(likeMatch[1] ?? ""); | ||
| 358 | if (!pattern.endsWith("%") || pattern.slice(0, -1).includes("%")) { | ||
| 359 | throw new Error("Only trailing % LIKE patterns are supported"); | ||
| 360 | } | ||
| 361 | |||
| 362 | const prefix = pattern.slice(0, -1); | ||
| 363 | return (key) => key.startsWith(prefix); | ||
| 364 | } | ||
| 365 | |||
| 366 | throw new Error("Unsupported SQL WHERE clause for kv_store"); | ||
| 367 | }; | ||
| 368 | |||
| 369 | const parseSelectColumns = (columnsClause: string): Array<"key" | "value"> => { | ||
| 370 | const normalized = columnsClause.trim().toLowerCase(); | ||
| 371 | if (normalized === "*") { | ||
| 372 | return ["key", "value"]; | ||
| 373 | } | ||
| 374 | |||
| 375 | const columns = normalized | ||
| 376 | .split(",") | ||
| 377 | .map((column) => column.trim()) | ||
| 378 | .filter((column) => column.length > 0); | ||
| 379 | |||
| 380 | if (columns.length === 0) { | ||
| 381 | throw new Error("SQL SELECT columns are required"); | ||
| 382 | } | ||
| 383 | |||
| 384 | const parsedColumns: Array<"key" | "value"> = []; | ||
| 385 | |||
| 386 | for (const column of columns) { | ||
| 387 | if (column !== "key" && column !== "value") { | ||
| 388 | throw new Error("Only key/value columns are supported for kv_store"); | ||
| 389 | } | ||
| 390 | |||
| 391 | if (!parsedColumns.includes(column)) { | ||
| 392 | parsedColumns.push(column); | ||
| 393 | } | ||
| 394 | } | ||
| 395 | |||
| 396 | return parsedColumns; | ||
| 397 | }; | ||
| 398 | |||
| 399 | type SqlWrite = | ||
| 400 | | { | ||
| 401 | type: "upsert"; | ||
| 402 | key: string; | ||
| 403 | value: string; | ||
| 404 | insertOnly: boolean; | ||
| 405 | } | ||
| 406 | | { | ||
| 407 | type: "delete"; | ||
| 408 | key: string; | ||
| 409 | }; | ||
| 410 | |||
| 411 | const executeSqlForStorage = ( | ||
| 412 | sqlText: string, | ||
| 413 | sqlRows: ReadonlyArray<StorageSqlKvEntry>, | ||
| 414 | maxRows: number, | ||
| 415 | ): { | ||
| 416 | result: QueryStorageSqlResult; | ||
| 417 | writes: Array<SqlWrite>; | ||
| 418 | } => { | ||
| 419 | const trimmed = sqlText.trim(); | ||
| 420 | |||
| 421 | if (/^create\s+table\s+if\s+not\s+exists\s+kv_store\b/i.test(trimmed)) { | ||
| 422 | return { | ||
| 423 | result: { | ||
| 424 | rows: [], | ||
| 425 | columns: [], | ||
| 426 | rowCount: 0, | ||
| 427 | }, | ||
| 428 | writes: [], | ||
| 429 | }; | ||
| 430 | } | ||
| 431 | |||
| 432 | if (/^(begin|commit|rollback)\b/i.test(trimmed)) { | ||
| 433 | return { | ||
| 434 | result: { | ||
| 435 | rows: [], | ||
| 436 | columns: [], | ||
| 437 | rowCount: 0, | ||
| 438 | }, | ||
| 439 | writes: [], | ||
| 440 | }; | ||
| 441 | } | ||
| 442 | |||
| 443 | const sortedRows = [...sqlRows].sort((left, right) => left.key.localeCompare(right.key)); | ||
| 444 | |||
| 445 | const selectMatch = /^select\s+(.+?)\s+from\s+kv_store(?:\s+where\s+(.+?))?(?:\s+limit\s+(\d+))?\s*;?$/i.exec(trimmed); | ||
| 446 | if (selectMatch) { | ||
| 447 | const columns = parseSelectColumns(selectMatch[1] ?? ""); | ||
| 448 | const where = parseSqlWhere(selectMatch[2]); | ||
| 449 | const sqlLimit = | ||
| 450 | selectMatch[3] !== undefined | ||
| 451 | ? Math.max(1, Math.min(maxRows, Number.parseInt(selectMatch[3], 10))) | ||
| 452 | : maxRows; | ||
| 453 | |||
| 454 | const rows = sortedRows | ||
| 455 | .filter((row) => where(row.key)) | ||
| 456 | .slice(0, sqlLimit) | ||
| 457 | .map((row) => { | ||
| 458 | const resultRow: Record<string, unknown> = {}; | ||
| 459 | |||
| 460 | for (const column of columns) { | ||
| 461 | if (column === "key") { | ||
| 462 | resultRow.key = row.key; | ||
| 463 | } else { | ||
| 464 | resultRow.value = row.value; | ||
| 465 | } | ||
| 466 | } | ||
| 467 | |||
| 468 | return resultRow; | ||
| 469 | }); | ||
| 470 | |||
| 471 | return { | ||
| 472 | result: { | ||
| 473 | rows, | ||
| 474 | columns, | ||
| 475 | rowCount: rows.length, | ||
| 476 | }, | ||
| 477 | writes: [], | ||
| 478 | }; | ||
| 479 | } | ||
| 480 | |||
| 481 | const insertMatch = /^insert\s+into\s+kv_store\s*\(\s*key\s*,\s*value\s*\)\s*values\s*\(\s*'((?:''|[^'])*)'\s*,\s*'((?:''|[^'])*)'\s*\)\s*;?$/i.exec(trimmed); | ||
| 482 | if (insertMatch) { | ||
| 483 | return { | ||
| 484 | result: { | ||
| 485 | rows: [], | ||
| 486 | columns: [], | ||
| 487 | rowCount: 0, | ||
| 488 | }, | ||
| 489 | writes: [{ | ||
| 490 | type: "upsert", | ||
| 491 | key: decodeSqlStringLiteral(insertMatch[1] ?? ""), | ||
| 492 | value: decodeSqlStringLiteral(insertMatch[2] ?? ""), | ||
| 493 | insertOnly: true, | ||
| 494 | }], | ||
| 495 | }; | ||
| 496 | } | ||
| 497 | |||
| 498 | const replaceMatch = /^replace\s+into\s+kv_store\s*\(\s*key\s*,\s*value\s*\)\s*values\s*\(\s*'((?:''|[^'])*)'\s*,\s*'((?:''|[^'])*)'\s*\)\s*;?$/i.exec(trimmed); | ||
| 499 | if (replaceMatch) { | ||
| 500 | return { | ||
| 501 | result: { | ||
| 502 | rows: [], | ||
| 503 | columns: [], | ||
| 504 | rowCount: 0, | ||
| 505 | }, | ||
| 506 | writes: [{ | ||
| 507 | type: "upsert", | ||
| 508 | key: decodeSqlStringLiteral(replaceMatch[1] ?? ""), | ||
| 509 | value: decodeSqlStringLiteral(replaceMatch[2] ?? ""), | ||
| 510 | insertOnly: false, | ||
| 511 | }], | ||
| 512 | }; | ||
| 513 | } | ||
| 514 | |||
| 515 | const updateMatch = /^update\s+kv_store\s+set\s+value\s*=\s*'((?:''|[^'])*)'\s+where\s+key\s*=\s*'((?:''|[^'])*)'\s*;?$/i.exec(trimmed); | ||
| 516 | if (updateMatch) { | ||
| 517 | return { | ||
| 518 | result: { | ||
| 519 | rows: [], | ||
| 520 | columns: [], | ||
| 521 | rowCount: 0, | ||
| 522 | }, | ||
| 523 | writes: [{ | ||
| 524 | type: "upsert", | ||
| 525 | key: decodeSqlStringLiteral(updateMatch[2] ?? ""), | ||
| 526 | value: decodeSqlStringLiteral(updateMatch[1] ?? ""), | ||
| 527 | insertOnly: false, | ||
| 528 | }], | ||
| 529 | }; | ||
| 530 | } | ||
| 531 | |||
| 532 | const deleteMatch = /^delete\s+from\s+kv_store\s+where\s+key\s*=\s*'((?:''|[^'])*)'\s*;?$/i.exec(trimmed); | ||
| 533 | if (deleteMatch) { | ||
| 534 | return { | ||
| 535 | result: { | ||
| 536 | rows: [], | ||
| 537 | columns: [], | ||
| 538 | rowCount: 0, | ||
| 539 | }, | ||
| 540 | writes: [{ | ||
| 541 | type: "delete", | ||
| 542 | key: decodeSqlStringLiteral(deleteMatch[1] ?? ""), | ||
| 543 | }], | ||
| 544 | }; | ||
| 545 | } | ||
| 546 | |||
| 547 | throw new Error("Unsupported SQL statement for Convex storage inspector"); | ||
| 548 | }; | ||
| 549 | |||
| 550 | export const listStorageInstances = query({ | ||
| 551 | args: { | ||
| 552 | workspaceId: v.string(), | ||
| 553 | }, | ||
| 554 | handler: async (ctx, args): Promise<Array<StorageInstance>> => { | ||
| 555 | const organizationId = await resolveWorkspaceOrganizationId(ctx, args.workspaceId); | ||
| 556 | |||
| 557 | const workspaceRows = await ctx.db | ||
| 558 | .query("storageInstances") | ||
| 559 | .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId)) | ||
| 560 | .collect(); | ||
| 561 | |||
| 562 | const organizationRows = await ctx.db | ||
| 563 | .query("storageInstances") | ||
| 564 | .withIndex("by_organizationId", (q) => q.eq("organizationId", organizationId)) | ||
| 565 | .collect(); | ||
| 566 | |||
| 567 | const storageInstances = [...workspaceRows, ...organizationRows] | ||
| 568 | .map((row) => | ||
| 569 | toStorageInstance(row as unknown as Record<string, unknown>), | ||
| 570 | ) | ||
| 571 | .filter((storageInstance) => | ||
| 572 | canAccessStorageInstance(storageInstance, { | ||
| 573 | workspaceId: args.workspaceId, | ||
| 574 | organizationId, | ||
| 575 | }) | ||
| 576 | ); | ||
| 577 | |||
| 578 | const uniqueStorageInstances = Array.from( | ||
| 579 | new Map(storageInstances.map((storageInstance) => [storageInstance.id, storageInstance])) | ||
| 580 | .values(), | ||
| 581 | ); | ||
| 582 | |||
| 583 | return sortStorageInstances(uniqueStorageInstances); | ||
| 584 | }, | ||
| 585 | }); | ||
| 586 | |||
| 587 | export const openStorageInstance = mutation({ | ||
| 588 | args: { | ||
| 589 | workspaceId: v.string(), | ||
| 590 | payload: v.object({ | ||
| 591 | scopeType: storageScopeTypeValidator, | ||
| 592 | durability: storageDurabilityValidator, | ||
| 593 | provider: v.optional(storageProviderValidator), | ||
| 594 | purpose: v.optional(v.string()), | ||
| 595 | ttlHours: v.optional(v.number()), | ||
| 596 | accountId: v.optional(v.string()), | ||
| 597 | sessionId: v.optional(v.string()), | ||
| 598 | }), | ||
| 599 | }, | ||
| 600 | handler: async (ctx, args): Promise<StorageInstance> => { | ||
| 601 | const payload = args.payload as OpenStorageInstancePayload; | ||
| 602 | |||
| 603 | if (payload.scopeType === "account" && payload.accountId === undefined) { | ||
| 604 | throw new Error("Account scope storage requires accountId"); | ||
| 605 | } | ||
| 606 | |||
| 607 | const organizationId = await resolveWorkspaceOrganizationId(ctx, args.workspaceId); | ||
| 608 | const now = Date.now(); | ||
| 609 | const storageInstanceId = `storage_${crypto.randomUUID()}`; | ||
| 610 | const ttlHours = | ||
| 611 | payload.ttlHours !== undefined && Number.isFinite(payload.ttlHours) | ||
| 612 | ? Math.max(1, Math.floor(payload.ttlHours)) | ||
| 613 | : 24; | ||
| 614 | |||
| 615 | const nextStorageInstance = decodeStorageInstance({ | ||
| 616 | id: storageInstanceId, | ||
| 617 | scopeType: payload.scopeType, | ||
| 618 | durability: payload.durability, | ||
| 619 | status: "active", | ||
| 620 | provider: payload.provider ?? "agentfs-local", | ||
| 621 | backendKey: `convex:${storageInstanceId}`, | ||
| 622 | organizationId, | ||
| 623 | workspaceId: | ||
| 624 | payload.scopeType === "workspace" || payload.scopeType === "scratch" | ||
| 625 | ? args.workspaceId | ||
| 626 | : null, | ||
| 627 | accountId: payload.scopeType === "account" ? (payload.accountId ?? null) : null, | ||
| 628 | createdByAccountId: payload.accountId ?? null, | ||
| 629 | purpose: | ||
| 630 | payload.purpose !== undefined && payload.purpose.trim().length > 0 | ||
| 631 | ? payload.purpose.trim() | ||
| 632 | : null, | ||
| 633 | sizeBytes: null, | ||
| 634 | fileCount: null, | ||
| 635 | createdAt: now, | ||
| 636 | updatedAt: now, | ||
| 637 | lastSeenAt: now, | ||
| 638 | closedAt: null, | ||
| 639 | expiresAt: | ||
| 640 | payload.durability === "ephemeral" | ||
| 641 | ? now + ttlHours * 3_600_000 | ||
| 642 | : null, | ||
| 643 | }); | ||
| 644 | |||
| 645 | await ctx.db.insert("storageInstances", nextStorageInstance); | ||
| 646 | |||
| 647 | return nextStorageInstance; | ||
| 648 | }, | ||
| 649 | }); | ||
| 650 | |||
| 651 | export const closeStorageInstance = mutation({ | ||
| 652 | args: { | ||
| 653 | workspaceId: v.string(), | ||
| 654 | storageInstanceId: v.string(), | ||
| 655 | }, | ||
| 656 | handler: async (ctx, args): Promise<StorageInstance> => { | ||
| 657 | const existingStorageInstance = await resolveAccessibleStorageInstance(ctx, { | ||
| 658 | workspaceId: args.workspaceId, | ||
| 659 | storageInstanceId: args.storageInstanceId, | ||
| 660 | }); | ||
| 661 | |||
| 662 | if (!existingStorageInstance) { | ||
| 663 | throw new Error(`Storage instance not found: ${args.storageInstanceId}`); | ||
| 664 | } | ||
| 665 | |||
| 666 | const existingRow = await ctx.db | ||
| 667 | .query("storageInstances") | ||
| 668 | .withIndex("by_domainId", (q) => q.eq("id", args.storageInstanceId)) | ||
| 669 | .unique(); | ||
| 670 | |||
| 671 | if (!existingRow) { | ||
| 672 | throw new Error(`Storage instance not found: ${args.storageInstanceId}`); | ||
| 673 | } | ||
| 674 | |||
| 675 | const now = Date.now(); | ||
| 676 | const nextStorageInstance = decodeStorageInstance({ | ||
| 677 | ...existingStorageInstance, | ||
| 678 | status: "closed", | ||
| 679 | updatedAt: now, | ||
| 680 | lastSeenAt: now, | ||
| 681 | closedAt: existingStorageInstance.closedAt ?? now, | ||
| 682 | }); | ||
| 683 | |||
| 684 | await ctx.db.patch(existingRow._id, nextStorageInstance); | ||
| 685 | |||
| 686 | return nextStorageInstance; | ||
| 687 | }, | ||
| 688 | }); | ||
| 689 | |||
| 690 | export const removeStorageInstance = mutation({ | ||
| 691 | args: { | ||
| 692 | workspaceId: v.string(), | ||
| 693 | storageInstanceId: v.string(), | ||
| 694 | }, | ||
| 695 | handler: async ( | ||
| 696 | ctx, | ||
| 697 | args, | ||
| 698 | ): Promise<{ | ||
| 699 | removed: boolean; | ||
| 700 | }> => { | ||
| 701 | const existingStorageInstance = await resolveAccessibleStorageInstance(ctx, { | ||
| 702 | workspaceId: args.workspaceId, | ||
| 703 | storageInstanceId: args.storageInstanceId, | ||
| 704 | }); | ||
| 705 | |||
| 706 | if (!existingStorageInstance) { | ||
| 707 | return { removed: false }; | ||
| 708 | } | ||
| 709 | |||
| 710 | const storageInstanceRow = await ctx.db | ||
| 711 | .query("storageInstances") | ||
| 712 | .withIndex("by_domainId", (q) => q.eq("id", args.storageInstanceId)) | ||
| 713 | .unique(); | ||
| 714 | |||
| 715 | if (!storageInstanceRow) { | ||
| 716 | return { removed: false }; | ||
| 717 | } | ||
| 718 | |||
| 719 | const storageFileRows = await ctx.db | ||
| 720 | .query("storageFileEntries") | ||
| 721 | .withIndex("by_storageInstanceId", (q) => q.eq("storageInstanceId", args.storageInstanceId)) | ||
| 722 | .collect(); | ||
| 723 | |||
| 724 | for (const storageFileRow of storageFileRows) { | ||
| 725 | await ctx.db.delete(storageFileRow._id); | ||
| 726 | } | ||
| 727 | |||
| 728 | const storageKvRows = await ctx.db | ||
| 729 | .query("storageKvEntries") | ||
| 730 | .withIndex("by_storageInstanceId", (q) => q.eq("storageInstanceId", args.storageInstanceId)) | ||
| 731 | .collect(); | ||
| 732 | |||
| 733 | for (const storageKvRow of storageKvRows) { | ||
| 734 | await ctx.db.delete(storageKvRow._id); | ||
| 735 | } | ||
| 736 | |||
| 737 | const storageSqlKvRows = await ctx.db | ||
| 738 | .query("storageSqlKvEntries") | ||
| 739 | .withIndex("by_storageInstanceId", (q) => q.eq("storageInstanceId", args.storageInstanceId)) | ||
| 740 | .collect(); | ||
| 741 | |||
| 742 | for (const storageSqlKvRow of storageSqlKvRows) { | ||
| 743 | await ctx.db.delete(storageSqlKvRow._id); | ||
| 744 | } | ||
| 745 | |||
| 746 | await ctx.db.delete(storageInstanceRow._id); | ||
| 747 | |||
| 748 | return { removed: true }; | ||
| 749 | }, | ||
| 750 | }); | ||
| 751 | |||
| 752 | export const listStorageDirectory = query({ | ||
| 753 | args: { | ||
| 754 | workspaceId: v.string(), | ||
| 755 | storageInstanceId: v.string(), | ||
| 756 | payload: v.object({ | ||
| 757 | path: v.string(), | ||
| 758 | }), | ||
| 759 | }, | ||
| 760 | handler: async (ctx, args): Promise<ListStorageDirectoryResult> => { | ||
| 761 | const storageInstance = await resolveAccessibleStorageInstance(ctx, { | ||
| 762 | workspaceId: args.workspaceId, | ||
| 763 | storageInstanceId: args.storageInstanceId, | ||
| 764 | }); | ||
| 765 | |||
| 766 | if (!storageInstance) { | ||
| 767 | throw new Error(`Storage instance not found: ${args.storageInstanceId}`); | ||
| 768 | } | ||
| 769 | |||
| 770 | const normalizedPath = normalizeStoragePath(args.payload.path); | ||
| 771 | |||
| 772 | const storageFileRows = await ctx.db | ||
| 773 | .query("storageFileEntries") | ||
| 774 | .withIndex("by_storageInstanceId", (q) => q.eq("storageInstanceId", args.storageInstanceId)) | ||
| 775 | .collect(); | ||
| 776 | |||
| 777 | const storageFiles = storageFileRows.map((row) => | ||
| 778 | toStorageFileEntry(row as unknown as Record<string, unknown>), | ||
| 779 | ); | ||
| 780 | |||
| 781 | const exactFile = storageFiles.find((storageFile) => storageFile.path === normalizedPath); | ||
| 782 | if (exactFile) { | ||
| 783 | throw new Error(`Cannot list a file path as directory: ${normalizedPath}`); | ||
| 784 | } | ||
| 785 | |||
| 786 | const prefix = normalizedPath === "/" ? "/" : `${normalizedPath}/`; | ||
| 787 | const directoryByPath = new Map<string, { | ||
| 788 | name: string; | ||
| 789 | path: string; | ||
| 790 | kind: "directory"; | ||
| 791 | sizeBytes: null; | ||
| 792 | updatedAt: number; | ||
| 793 | }>(); | ||
| 794 | const fileEntries: Array<{ | ||
| 795 | name: string; | ||
| 796 | path: string; | ||
| 797 | kind: "file"; | ||
| 798 | sizeBytes: number; | ||
| 799 | updatedAt: number; | ||
| 800 | }> = []; | ||
| 801 | |||
| 802 | for (const storageFile of storageFiles) { | ||
| 803 | if (!storageFile.path.startsWith(prefix)) { | ||
| 804 | continue; | ||
| 805 | } | ||
| 806 | |||
| 807 | const remainder = storageFile.path.slice(prefix.length); | ||
| 808 | if (remainder.length === 0) { | ||
| 809 | continue; | ||
| 810 | } | ||
| 811 | |||
| 812 | const separatorIndex = remainder.indexOf("/"); | ||
| 813 | if (separatorIndex < 0) { | ||
| 814 | const fileName = remainder; | ||
| 815 | fileEntries.push({ | ||
| 816 | name: fileName, | ||
| 817 | path: storageFile.path, | ||
| 818 | kind: "file", | ||
| 819 | sizeBytes: storageFile.sizeBytes, | ||
| 820 | updatedAt: storageFile.updatedAt, | ||
| 821 | }); | ||
| 822 | continue; | ||
| 823 | } | ||
| 824 | |||
| 825 | const directoryName = remainder.slice(0, separatorIndex); | ||
| 826 | const directoryPath = normalizedPath === "/" | ||
| 827 | ? `/${directoryName}` | ||
| 828 | : `${normalizedPath}/${directoryName}`; | ||
| 829 | const existingDirectory = directoryByPath.get(directoryPath); | ||
| 830 | |||
| 831 | if (!existingDirectory) { | ||
| 832 | directoryByPath.set(directoryPath, { | ||
| 833 | name: directoryName, | ||
| 834 | path: directoryPath, | ||
| 835 | kind: "directory", | ||
| 836 | sizeBytes: null, | ||
| 837 | updatedAt: storageFile.updatedAt, | ||
| 838 | }); | ||
| 839 | continue; | ||
| 840 | } | ||
| 841 | |||
| 842 | if (storageFile.updatedAt > existingDirectory.updatedAt) { | ||
| 843 | directoryByPath.set(directoryPath, { | ||
| 844 | ...existingDirectory, | ||
| 845 | updatedAt: storageFile.updatedAt, | ||
| 846 | }); | ||
| 847 | } | ||
| 848 | } | ||
| 849 | |||
| 850 | if ( | ||
| 851 | normalizedPath !== "/" | ||
| 852 | && directoryByPath.size === 0 | ||
| 853 | && fileEntries.length === 0 | ||
| 854 | ) { | ||
| 855 | throw new Error(`Directory not found: ${normalizedPath}`); | ||
| 856 | } | ||
| 857 | |||
| 858 | const directoryEntries = [...directoryByPath.values()].sort((left, right) => | ||
| 859 | left.name.localeCompare(right.name) | ||
| 860 | ); | ||
| 861 | const sortedFileEntries = [...fileEntries].sort((left, right) => | ||
| 862 | left.name.localeCompare(right.name) | ||
| 863 | ); | ||
| 864 | |||
| 865 | return { | ||
| 866 | path: normalizedPath, | ||
| 867 | entries: [...directoryEntries, ...sortedFileEntries], | ||
| 868 | }; | ||
| 869 | }, | ||
| 870 | }); | ||
| 871 | |||
| 872 | export const readStorageFile = query({ | ||
| 873 | args: { | ||
| 874 | workspaceId: v.string(), | ||
| 875 | storageInstanceId: v.string(), | ||
| 876 | payload: v.object({ | ||
| 877 | path: v.string(), | ||
| 878 | encoding: v.optional(readStorageEncodingValidator), | ||
| 879 | }), | ||
| 880 | }, | ||
| 881 | handler: async (ctx, args): Promise<ReadStorageFileResult> => { | ||
| 882 | const storageInstance = await resolveAccessibleStorageInstance(ctx, { | ||
| 883 | workspaceId: args.workspaceId, | ||
| 884 | storageInstanceId: args.storageInstanceId, | ||
| 885 | }); | ||
| 886 | |||
| 887 | if (!storageInstance) { | ||
| 888 | throw new Error(`Storage instance not found: ${args.storageInstanceId}`); | ||
| 889 | } | ||
| 890 | |||
| 891 | const normalizedPath = normalizeStoragePath(args.payload.path); | ||
| 892 | const storageFileRow = await ctx.db | ||
| 893 | .query("storageFileEntries") | ||
| 894 | .withIndex("by_storageInstanceId_path", (q) => | ||
| 895 | q.eq("storageInstanceId", args.storageInstanceId).eq("path", normalizedPath) | ||
| 896 | ) | ||
| 897 | .unique(); | ||
| 898 | |||
| 899 | if (!storageFileRow) { | ||
| 900 | throw new Error(`Storage file not found: ${normalizedPath}`); | ||
| 901 | } | ||
| 902 | |||
| 903 | const storageFile = toStorageFileEntry(storageFileRow as unknown as Record<string, unknown>); | ||
| 904 | const encoding = args.payload.encoding ?? "utf8"; | ||
| 905 | |||
| 906 | return { | ||
| 907 | path: normalizedPath, | ||
| 908 | encoding, | ||
| 909 | content: encoding === "base64" | ||
| 910 | ? storageFile.contentBase64 | ||
| 911 | : decodeBase64Utf8(storageFile.contentBase64), | ||
| 912 | bytes: storageFile.sizeBytes, | ||
| 913 | }; | ||
| 914 | }, | ||
| 915 | }); | ||
| 916 | |||
| 917 | export const listStorageKv = query({ | ||
| 918 | args: { | ||
| 919 | workspaceId: v.string(), | ||
| 920 | storageInstanceId: v.string(), | ||
| 921 | payload: v.object({ | ||
| 922 | prefix: v.optional(v.string()), | ||
| 923 | limit: v.optional(v.number()), | ||
| 924 | }), | ||
| 925 | }, | ||
| 926 | handler: async (ctx, args): Promise<ListStorageKvResult> => { | ||
| 927 | const storageInstance = await resolveAccessibleStorageInstance(ctx, { | ||
| 928 | workspaceId: args.workspaceId, | ||
| 929 | storageInstanceId: args.storageInstanceId, | ||
| 930 | }); | ||
| 931 | |||
| 932 | if (!storageInstance) { | ||
| 933 | throw new Error(`Storage instance not found: ${args.storageInstanceId}`); | ||
| 934 | } | ||
| 935 | |||
| 936 | const prefix = args.payload.prefix ?? ""; | ||
| 937 | const requestedLimit = | ||
| 938 | args.payload.limit !== undefined && Number.isFinite(args.payload.limit) | ||
| 939 | ? Math.floor(args.payload.limit) | ||
| 940 | : DEFAULT_KV_LIMIT; | ||
| 941 | const limit = Math.max(1, Math.min(MAX_KV_LIMIT, requestedLimit)); | ||
| 942 | |||
| 943 | const storageKvRows = await ctx.db | ||
| 944 | .query("storageKvEntries") | ||
| 945 | .withIndex("by_storageInstanceId", (q) => q.eq("storageInstanceId", args.storageInstanceId)) | ||
| 946 | .collect(); | ||
| 947 | |||
| 948 | const items = storageKvRows | ||
| 949 | .map((row) => toStorageKvEntry(row as unknown as Record<string, unknown>)) | ||
| 950 | .filter((entry) => entry.key.startsWith(prefix)) | ||
| 951 | .sort((left, right) => left.key.localeCompare(right.key)) | ||
| 952 | .slice(0, limit) | ||
| 953 | .map((entry) => ({ | ||
| 954 | key: entry.key, | ||
| 955 | value: parseJsonOrString(entry.valueJson), | ||
| 956 | })); | ||
| 957 | |||
| 958 | return { | ||
| 959 | items, | ||
| 960 | }; | ||
| 961 | }, | ||
| 962 | }); | ||
| 963 | |||
| 964 | export const queryStorageSql = mutation({ | ||
| 965 | args: { | ||
| 966 | workspaceId: v.string(), | ||
| 967 | storageInstanceId: v.string(), | ||
| 968 | payload: v.object({ | ||
| 969 | sql: v.string(), | ||
| 970 | maxRows: v.optional(v.number()), | ||
| 971 | }), | ||
| 972 | }, | ||
| 973 | handler: async (ctx, args): Promise<QueryStorageSqlResult> => { | ||
| 974 | const storageInstance = await resolveAccessibleStorageInstance(ctx, { | ||
| 975 | workspaceId: args.workspaceId, | ||
| 976 | storageInstanceId: args.storageInstanceId, | ||
| 977 | }); | ||
| 978 | |||
| 979 | if (!storageInstance) { | ||
| 980 | throw new Error(`Storage instance not found: ${args.storageInstanceId}`); | ||
| 981 | } | ||
| 982 | |||
| 983 | const sqlText = args.payload.sql.trim(); | ||
| 984 | if (sqlText.length === 0) { | ||
| 985 | throw new Error("SQL query is required"); | ||
| 986 | } | ||
| 987 | |||
| 988 | const requestedMaxRows = | ||
| 989 | args.payload.maxRows !== undefined && Number.isFinite(args.payload.maxRows) | ||
| 990 | ? Math.floor(args.payload.maxRows) | ||
| 991 | : DEFAULT_SQL_MAX_ROWS; | ||
| 992 | const maxRows = Math.max(1, Math.min(MAX_SQL_MAX_ROWS, requestedMaxRows)); | ||
| 993 | |||
| 994 | const sqlRowsRaw = await ctx.db | ||
| 995 | .query("storageSqlKvEntries") | ||
| 996 | .withIndex("by_storageInstanceId", (q) => q.eq("storageInstanceId", args.storageInstanceId)) | ||
| 997 | .collect(); | ||
| 998 | |||
| 999 | const sqlRows = sqlRowsRaw.map((row) => | ||
| 1000 | toStorageSqlKvEntry(row as unknown as Record<string, unknown>), | ||
| 1001 | ); | ||
| 1002 | const byKey = new Map<string, { | ||
| 1003 | row: StorageSqlKvEntry; | ||
| 1004 | docId: unknown; | ||
| 1005 | }>(); | ||
| 1006 | |||
| 1007 | for (let index = 0; index < sqlRows.length; index += 1) { | ||
| 1008 | const row = sqlRows[index]; | ||
| 1009 | const rawRow = sqlRowsRaw[index]; | ||
| 1010 | if (row && rawRow) { | ||
| 1011 | byKey.set(row.key, { | ||
| 1012 | row, | ||
| 1013 | docId: rawRow._id, | ||
| 1014 | }); | ||
| 1015 | } | ||
| 1016 | } | ||
| 1017 | |||
| 1018 | const execution = executeSqlForStorage(sqlText, sqlRows, maxRows); | ||
| 1019 | |||
| 1020 | for (const write of execution.writes) { | ||
| 1021 | if (write.type === "delete") { | ||
| 1022 | const existing = byKey.get(write.key); | ||
| 1023 | if (existing) { | ||
| 1024 | await ctx.db.delete(existing.docId as any); | ||
| 1025 | byKey.delete(write.key); | ||
| 1026 | } | ||
| 1027 | continue; | ||
| 1028 | } | ||
| 1029 | |||
| 1030 | const existing = byKey.get(write.key); | ||
| 1031 | if (existing && write.insertOnly) { | ||
| 1032 | throw new Error(`UNIQUE constraint failed: kv_store.key (${write.key})`); | ||
| 1033 | } | ||
| 1034 | |||
| 1035 | const now = Date.now(); | ||
| 1036 | |||
| 1037 | if (existing) { | ||
| 1038 | const nextRow = decodeStorageSqlKvEntry({ | ||
| 1039 | ...existing.row, | ||
| 1040 | value: write.value, | ||
| 1041 | updatedAt: now, | ||
| 1042 | }); | ||
| 1043 | |||
| 1044 | await ctx.db.patch(existing.docId as any, nextRow); | ||
| 1045 | byKey.set(write.key, { | ||
| 1046 | row: nextRow, | ||
| 1047 | docId: existing.docId, | ||
| 1048 | }); | ||
| 1049 | continue; | ||
| 1050 | } | ||
| 1051 | |||
| 1052 | const nextRow = decodeStorageSqlKvEntry({ | ||
| 1053 | id: `storage_sql_kv_${crypto.randomUUID()}`, | ||
| 1054 | storageInstanceId: args.storageInstanceId, | ||
| 1055 | key: write.key, | ||
| 1056 | value: write.value, | ||
| 1057 | updatedAt: now, | ||
| 1058 | }); | ||
| 1059 | |||
| 1060 | const insertedId = await ctx.db.insert("storageSqlKvEntries", nextRow); | ||
| 1061 | byKey.set(write.key, { | ||
| 1062 | row: nextRow, | ||
| 1063 | docId: insertedId, | ||
| 1064 | }); | ||
| 1065 | } | ||
| 1066 | |||
| 1067 | return execution.result; | ||
| 1068 | }, | ||
| 1069 | }); | ||
| @@ -0,0 +1,1237 @@ | |||
| 1 | import { v } from "convex/values"; | ||
| 2 | import { internal } from "../_generated/api"; | ||
| 3 | |||
| 4 | import { action, internalMutation, internalQuery } from "../_generated/server"; | ||
| 5 | |||
| 6 | const defaultSearchLimit = 50; | ||
| 7 | const maxSearchLimit = 5_000; | ||
| 8 | const writeBatchSize = 500; | ||
| 9 | const runtimeInternal = internal as any; | ||
| 10 | |||
| 11 | const stripConvexSystemFields = ( | ||
| 12 | value: Record<string, unknown>, | ||
| 13 | ): Record<string, unknown> => { | ||
| 14 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 15 | return rest; | ||
| 16 | }; | ||
| 17 | |||
| 18 | const normalizePathForLookup = (path: string): string => | ||
| 19 | path | ||
| 20 | .trim() | ||
| 21 | .toLowerCase() | ||
| 22 | .replace(/[^a-z0-9]+/g, ".") | ||
| 23 | .replace(/\.+/g, ".") | ||
| 24 | .replace(/^\.|\.$/g, ""); | ||
| 25 | |||
| 26 | const normalizeLimit = (value: number | undefined): number => { | ||
| 27 | if (!Number.isFinite(value)) { | ||
| 28 | return defaultSearchLimit; | ||
| 29 | } | ||
| 30 | |||
| 31 | return Math.max(1, Math.min(maxSearchLimit, Math.floor(value ?? defaultSearchLimit))); | ||
| 32 | }; | ||
| 33 | |||
| 34 | const artifactSchemaRefId = (artifactId: string, refKey: string): string => | ||
| 35 | `${artifactId}:ref:${encodeURIComponent(refKey)}`; | ||
| 36 | |||
| 37 | const normalizeNamespacePart = (value: string): string => { | ||
| 38 | const normalized = value | ||
| 39 | .trim() | ||
| 40 | .toLowerCase() | ||
| 41 | .replace(/[^a-z0-9]+/g, "_") | ||
| 42 | .replace(/^_+|_+$/g, ""); | ||
| 43 | |||
| 44 | return normalized.length > 0 ? normalized : "source"; | ||
| 45 | }; | ||
| 46 | |||
| 47 | const sourceNamespace = (source: { | ||
| 48 | id: string; | ||
| 49 | name: string; | ||
| 50 | }): string => { | ||
| 51 | const sourceIdSuffix = source.id.slice(-6).toLowerCase(); | ||
| 52 | return `${normalizeNamespacePart(source.name)}_${sourceIdSuffix}`; | ||
| 53 | }; | ||
| 54 | |||
| 55 | const parseJsonObject = (value: string | null | undefined): Record<string, unknown> => { | ||
| 56 | if (!value) { | ||
| 57 | return {}; | ||
| 58 | } | ||
| 59 | |||
| 60 | try { | ||
| 61 | const parsed = JSON.parse(value) as unknown; | ||
| 62 | return parsed && typeof parsed === "object" && !Array.isArray(parsed) | ||
| 63 | ? (parsed as Record<string, unknown>) | ||
| 64 | : {}; | ||
| 65 | } catch { | ||
| 66 | return {}; | ||
| 67 | } | ||
| 68 | }; | ||
| 69 | |||
| 70 | const metadataSearchTerms = (metadataJson: string | null | undefined): ReadonlyArray<string> => { | ||
| 71 | if (!metadataJson) { | ||
| 72 | return []; | ||
| 73 | } | ||
| 74 | |||
| 75 | const parsed = parseJsonObject(metadataJson); | ||
| 76 | const keys = ["method", "path", "operationType", "fieldName", "toolName"] as const; | ||
| 77 | const terms: Array<string> = []; | ||
| 78 | |||
| 79 | for (const key of keys) { | ||
| 80 | const value = parsed[key]; | ||
| 81 | if (typeof value === "string" && value.trim().length > 0) { | ||
| 82 | terms.push(value); | ||
| 83 | } | ||
| 84 | } | ||
| 85 | |||
| 86 | return terms; | ||
| 87 | }; | ||
| 88 | |||
| 89 | const normalizedSearchText = (...parts: ReadonlyArray<string | null | undefined>): string => | ||
| 90 | parts | ||
| 91 | .map((part) => (typeof part === "string" ? part.trim().toLowerCase() : "")) | ||
| 92 | .filter((part) => part.length > 0) | ||
| 93 | .join(" "); | ||
| 94 | |||
| 95 | const methodFromCanonicalPath = (canonicalPath: string | null | undefined): string | null => { | ||
| 96 | if (!canonicalPath) { | ||
| 97 | return null; | ||
| 98 | } | ||
| 99 | |||
| 100 | const candidate = canonicalPath.trim().split(/\s+/)[0]?.toLowerCase() ?? null; | ||
| 101 | if ( | ||
| 102 | candidate === "get" || | ||
| 103 | candidate === "post" || | ||
| 104 | candidate === "put" || | ||
| 105 | candidate === "patch" || | ||
| 106 | candidate === "delete" || | ||
| 107 | candidate === "head" || | ||
| 108 | candidate === "options" || | ||
| 109 | candidate === "trace" | ||
| 110 | ) { | ||
| 111 | return candidate; | ||
| 112 | } | ||
| 113 | |||
| 114 | return null; | ||
| 115 | }; | ||
| 116 | |||
| 117 | const toWorkspaceToolMethod = ( | ||
| 118 | protocol: string | null | undefined, | ||
| 119 | metadataJson: string | null | undefined, | ||
| 120 | canonicalPath: string | null | undefined, | ||
| 121 | ): string => { | ||
| 122 | const canonicalMethod = methodFromCanonicalPath(canonicalPath); | ||
| 123 | if (canonicalMethod) { | ||
| 124 | return canonicalMethod; | ||
| 125 | } | ||
| 126 | |||
| 127 | const normalizedProtocol = (protocol ?? "").toLowerCase(); | ||
| 128 | if (normalizedProtocol !== "openapi") { | ||
| 129 | return "post"; | ||
| 130 | } | ||
| 131 | |||
| 132 | const metadata = parseJsonObject(metadataJson); | ||
| 133 | const method = typeof metadata.method === "string" ? metadata.method.trim().toLowerCase() : ""; | ||
| 134 | |||
| 135 | if ( | ||
| 136 | method === "get" || | ||
| 137 | method === "post" || | ||
| 138 | method === "put" || | ||
| 139 | method === "patch" || | ||
| 140 | method === "delete" || | ||
| 141 | method === "head" || | ||
| 142 | method === "options" || | ||
| 143 | method === "trace" | ||
| 144 | ) { | ||
| 145 | return method; | ||
| 146 | } | ||
| 147 | |||
| 148 | return "get"; | ||
| 149 | }; | ||
| 150 | |||
| 151 | const scoreSearchRow = (row: Record<string, unknown>, queryLower: string): number => { | ||
| 152 | const path = String(row.path ?? "").toLowerCase(); | ||
| 153 | const name = String(row.name ?? "").toLowerCase(); | ||
| 154 | const description = String(row.description ?? "").toLowerCase(); | ||
| 155 | const sourceName = String(row.sourceName ?? "").toLowerCase(); | ||
| 156 | const searchText = String(row.searchText ?? "").toLowerCase(); | ||
| 157 | |||
| 158 | if (path === queryLower) { | ||
| 159 | return 100; | ||
| 160 | } | ||
| 161 | |||
| 162 | if (path.startsWith(queryLower)) { | ||
| 163 | return 85; | ||
| 164 | } | ||
| 165 | |||
| 166 | if (name.includes(queryLower)) { | ||
| 167 | return 75; | ||
| 168 | } | ||
| 169 | |||
| 170 | if (path.includes(queryLower)) { | ||
| 171 | return 70; | ||
| 172 | } | ||
| 173 | |||
| 174 | if (sourceName.includes(queryLower)) { | ||
| 175 | return 60; | ||
| 176 | } | ||
| 177 | |||
| 178 | if (description.includes(queryLower)) { | ||
| 179 | return 50; | ||
| 180 | } | ||
| 181 | |||
| 182 | if (searchText.includes(queryLower)) { | ||
| 183 | return 40; | ||
| 184 | } | ||
| 185 | |||
| 186 | return 0; | ||
| 187 | }; | ||
| 188 | |||
| 189 | const chunkArray = <A>(values: ReadonlyArray<A>, size: number): Array<Array<A>> => { | ||
| 190 | const chunkSize = Math.max(1, Math.floor(size)); | ||
| 191 | const chunks: Array<Array<A>> = []; | ||
| 192 | |||
| 193 | for (let index = 0; index < values.length; index += chunkSize) { | ||
| 194 | chunks.push(values.slice(index, index + chunkSize)); | ||
| 195 | } | ||
| 196 | |||
| 197 | return chunks; | ||
| 198 | }; | ||
| 199 | |||
| 200 | const buildWorkspaceToolRows = async ( | ||
| 201 | ctx: any, | ||
| 202 | args: { | ||
| 203 | workspaceId: string; | ||
| 204 | sourceId?: string; | ||
| 205 | namespace?: string; | ||
| 206 | includeDisabled?: boolean; | ||
| 207 | }, | ||
| 208 | ): Promise<Array<Record<string, unknown>>> => { | ||
| 209 | const sourceRows = await ctx.db | ||
| 210 | .query("sources") | ||
| 211 | .withIndex("by_workspaceId", (q: any) => q.eq("workspaceId", args.workspaceId)) | ||
| 212 | .collect(); | ||
| 213 | |||
| 214 | const bindingRows = await ctx.db | ||
| 215 | .query("sourceArtifactBindings") | ||
| 216 | .withIndex("by_workspaceId", (q: any) => q.eq("workspaceId", args.workspaceId)) | ||
| 217 | .collect(); | ||
| 218 | |||
| 219 | const bindingBySourceId = new Map<string, Record<string, unknown>>(); | ||
| 220 | for (const row of bindingRows) { | ||
| 221 | bindingBySourceId.set(String(row.sourceId), row as unknown as Record<string, unknown>); | ||
| 222 | } | ||
| 223 | |||
| 224 | const rows: Array<Record<string, unknown>> = []; | ||
| 225 | |||
| 226 | for (const sourceRow of sourceRows) { | ||
| 227 | const source = sourceRow as unknown as Record<string, unknown>; | ||
| 228 | const sourceId = String(source.id ?? ""); | ||
| 229 | const sourceName = String(source.name ?? ""); | ||
| 230 | const sourceKind = String(source.kind ?? ""); | ||
| 231 | const sourceEnabled = source.enabled === true; | ||
| 232 | |||
| 233 | if (args.sourceId && sourceId !== args.sourceId) { | ||
| 234 | continue; | ||
| 235 | } | ||
| 236 | |||
| 237 | const status = sourceEnabled ? "active" : "disabled"; | ||
| 238 | if (args.includeDisabled !== true && status !== "active") { | ||
| 239 | continue; | ||
| 240 | } | ||
| 241 | |||
| 242 | const binding = bindingBySourceId.get(sourceId); | ||
| 243 | if (!binding) { | ||
| 244 | continue; | ||
| 245 | } | ||
| 246 | |||
| 247 | const artifactId = String(binding.artifactId ?? ""); | ||
| 248 | if (artifactId.length === 0) { | ||
| 249 | continue; | ||
| 250 | } | ||
| 251 | |||
| 252 | const namespace = sourceNamespace({ id: sourceId, name: sourceName }); | ||
| 253 | if (args.namespace && namespace !== args.namespace) { | ||
| 254 | continue; | ||
| 255 | } | ||
| 256 | |||
| 257 | const artifactTools = await ctx.db | ||
| 258 | .query("artifactTools") | ||
| 259 | .withIndex("by_artifactId", (q: any) => q.eq("artifactId", artifactId)) | ||
| 260 | .collect(); | ||
| 261 | |||
| 262 | for (const artifactToolRow of artifactTools) { | ||
| 263 | const artifactTool = artifactToolRow as unknown as Record<string, unknown>; | ||
| 264 | const toolId = String(artifactTool.toolId ?? ""); | ||
| 265 | const protocol = String(artifactTool.protocol ?? "openapi"); | ||
| 266 | const canonicalPath = | ||
| 267 | typeof artifactTool.canonicalPath === "string" && artifactTool.canonicalPath.trim().length > 0 | ||
| 268 | ? artifactTool.canonicalPath.trim() | ||
| 269 | : null; | ||
| 270 | const method = toWorkspaceToolMethod( | ||
| 271 | protocol, | ||
| 272 | typeof artifactTool.metadataJson === "string" ? artifactTool.metadataJson : null, | ||
| 273 | canonicalPath, | ||
| 274 | ); | ||
| 275 | const path = `${namespace}.${toolId}`; | ||
| 276 | const description = typeof artifactTool.description === "string" ? artifactTool.description : null; | ||
| 277 | const name = String(artifactTool.name ?? toolId); | ||
| 278 | |||
| 279 | rows.push({ | ||
| 280 | id: `wti_${args.workspaceId}_${sourceId}_${toolId}`, | ||
| 281 | workspaceId: args.workspaceId, | ||
| 282 | sourceId, | ||
| 283 | sourceName, | ||
| 284 | sourceKind, | ||
| 285 | artifactId, | ||
| 286 | toolId, | ||
| 287 | protocol, | ||
| 288 | method, | ||
| 289 | namespace, | ||
| 290 | path, | ||
| 291 | pathLower: path.toLowerCase(), | ||
| 292 | normalizedPath: normalizePathForLookup(path), | ||
| 293 | operationPath: canonicalPath, | ||
| 294 | name, | ||
| 295 | description, | ||
| 296 | searchText: normalizedSearchText( | ||
| 297 | sourceName, | ||
| 298 | String(source.endpoint ?? ""), | ||
| 299 | namespace, | ||
| 300 | toolId, | ||
| 301 | name, | ||
| 302 | description, | ||
| 303 | ...metadataSearchTerms( | ||
| 304 | typeof artifactTool.metadataJson === "string" ? artifactTool.metadataJson : null, | ||
| 305 | ), | ||
| 306 | ), | ||
| 307 | operationHash: String(artifactTool.operationHash ?? ""), | ||
| 308 | approvalMode: "auto", | ||
| 309 | status, | ||
| 310 | refHintTableJson: null, | ||
| 311 | updatedAt: Number(binding.updatedAt ?? Date.now()), | ||
| 312 | }); | ||
| 313 | } | ||
| 314 | } | ||
| 315 | |||
| 316 | rows.sort((left, right) => String(left.path).localeCompare(String(right.path))); | ||
| 317 | return rows; | ||
| 318 | }; | ||
| 319 | |||
| 320 | export const ingestOpenApiManifest = action({ | ||
| 321 | args: { | ||
| 322 | token: v.string(), | ||
| 323 | workspaceId: v.string(), | ||
| 324 | sourceId: v.string(), | ||
| 325 | sourceName: v.string(), | ||
| 326 | sourceEndpoint: v.string(), | ||
| 327 | sourceEnabled: v.boolean(), | ||
| 328 | sourceHash: v.string(), | ||
| 329 | toolCount: v.number(), | ||
| 330 | refs: v.array( | ||
| 331 | v.object({ | ||
| 332 | refKey: v.string(), | ||
| 333 | schemaJson: v.string(), | ||
| 334 | }), | ||
| 335 | ), | ||
| 336 | tools: v.array( | ||
| 337 | v.object({ | ||
| 338 | toolId: v.string(), | ||
| 339 | name: v.string(), | ||
| 340 | description: v.union(v.string(), v.null()), | ||
| 341 | method: v.string(), | ||
| 342 | path: v.string(), | ||
| 343 | operationHash: v.string(), | ||
| 344 | invocationJson: v.string(), | ||
| 345 | inputSchemaJson: v.union(v.string(), v.null()), | ||
| 346 | outputSchemaJson: v.union(v.string(), v.null()), | ||
| 347 | }), | ||
| 348 | ), | ||
| 349 | }, | ||
| 350 | handler: async (ctx, args) => { | ||
| 351 | const expectedToken = | ||
| 352 | process.env.OPENAPI_INGEST_SERVICE_TOKEN?.trim() | ||
| 353 | || process.env.OPENAPI_PARSE_API_TOKEN?.trim() | ||
| 354 | || ""; | ||
| 355 | if (expectedToken.length > 0 && args.token.trim() !== expectedToken) { | ||
| 356 | throw new Error("Unauthorized OpenAPI ingest request"); | ||
| 357 | } | ||
| 358 | |||
| 359 | const artifactMeta = await ctx.runMutation( | ||
| 360 | runtimeInternal.control_plane.tool_registry.upsertArtifactMeta, | ||
| 361 | { | ||
| 362 | protocol: "openapi", | ||
| 363 | contentHash: args.sourceHash, | ||
| 364 | extractorVersion: "openapi_v2", | ||
| 365 | toolCount: args.toolCount, | ||
| 366 | refHintTableJson: null, | ||
| 367 | }, | ||
| 368 | ); | ||
| 369 | |||
| 370 | if (args.refs.length > 0) { | ||
| 371 | let shouldPersistRefs = artifactMeta.created; | ||
| 372 | |||
| 373 | if (!shouldPersistRefs) { | ||
| 374 | const existingRefCount = await ctx.runQuery( | ||
| 375 | runtimeInternal.control_plane.tool_registry.countArtifactSchemaRefs, | ||
| 376 | { | ||
| 377 | artifactId: artifactMeta.artifactId, | ||
| 378 | }, | ||
| 379 | ); | ||
| 380 | shouldPersistRefs = existingRefCount !== args.refs.length; | ||
| 381 | } | ||
| 382 | |||
| 383 | if (shouldPersistRefs) { | ||
| 384 | await ctx.runMutation( | ||
| 385 | runtimeInternal.control_plane.tool_registry.clearArtifactSchemaRefs, | ||
| 386 | { | ||
| 387 | artifactId: artifactMeta.artifactId, | ||
| 388 | }, | ||
| 389 | ); | ||
| 390 | |||
| 391 | for (const batch of chunkArray(args.refs, writeBatchSize)) { | ||
| 392 | await ctx.runMutation( | ||
| 393 | runtimeInternal.control_plane.tool_registry.putArtifactSchemaRefsBatch, | ||
| 394 | { | ||
| 395 | artifactId: artifactMeta.artifactId, | ||
| 396 | refs: batch, | ||
| 397 | }, | ||
| 398 | ); | ||
| 399 | } | ||
| 400 | } | ||
| 401 | } | ||
| 402 | |||
| 403 | if (artifactMeta.created && args.tools.length > 0) { | ||
| 404 | const artifactRows = args.tools.map((tool) => ({ | ||
| 405 | toolId: tool.toolId, | ||
| 406 | name: tool.name, | ||
| 407 | description: tool.description, | ||
| 408 | canonicalPath: `${tool.method.toUpperCase()} ${tool.path}`, | ||
| 409 | operationHash: tool.operationHash, | ||
| 410 | invocationJson: tool.invocationJson, | ||
| 411 | inputSchemaJson: tool.inputSchemaJson, | ||
| 412 | outputSchemaJson: tool.outputSchemaJson, | ||
| 413 | metadataJson: JSON.stringify({ | ||
| 414 | method: tool.method, | ||
| 415 | path: tool.path, | ||
| 416 | }), | ||
| 417 | })); | ||
| 418 | |||
| 419 | for (const batch of chunkArray(artifactRows, writeBatchSize)) { | ||
| 420 | await ctx.runMutation(runtimeInternal.control_plane.tool_registry.putArtifactToolsBatch, { | ||
| 421 | artifactId: artifactMeta.artifactId, | ||
| 422 | protocol: "openapi", | ||
| 423 | insertOnly: true, | ||
| 424 | tools: batch, | ||
| 425 | }); | ||
| 426 | } | ||
| 427 | } | ||
| 428 | |||
| 429 | await ctx.runMutation(runtimeInternal.control_plane.tool_registry.bindSourceToArtifact, { | ||
| 430 | workspaceId: args.workspaceId, | ||
| 431 | sourceId: args.sourceId, | ||
| 432 | artifactId: artifactMeta.artifactId, | ||
| 433 | }); | ||
| 434 | |||
| 435 | return { | ||
| 436 | artifactId: artifactMeta.artifactId, | ||
| 437 | created: artifactMeta.created, | ||
| 438 | sourceHash: args.sourceHash, | ||
| 439 | toolCount: args.toolCount, | ||
| 440 | sourceName: args.sourceName, | ||
| 441 | sourceEndpoint: args.sourceEndpoint, | ||
| 442 | sourceEnabled: args.sourceEnabled, | ||
| 443 | }; | ||
| 444 | }, | ||
| 445 | }); | ||
| 446 | |||
| 447 | export const upsertArtifactMeta = internalMutation({ | ||
| 448 | args: { | ||
| 449 | protocol: v.string(), | ||
| 450 | contentHash: v.string(), | ||
| 451 | extractorVersion: v.string(), | ||
| 452 | toolCount: v.number(), | ||
| 453 | refHintTableJson: v.optional(v.union(v.string(), v.null())), | ||
| 454 | }, | ||
| 455 | handler: async (ctx, args) => { | ||
| 456 | const now = Date.now(); | ||
| 457 | const existing = await ctx.db | ||
| 458 | .query("artifacts") | ||
| 459 | .withIndex("by_protocol_contentHash_extractorVersion", (q) => | ||
| 460 | q | ||
| 461 | .eq("protocol", args.protocol) | ||
| 462 | .eq("contentHash", args.contentHash) | ||
| 463 | .eq("extractorVersion", args.extractorVersion), | ||
| 464 | ) | ||
| 465 | .unique(); | ||
| 466 | |||
| 467 | if (existing) { | ||
| 468 | await ctx.db.patch(existing._id, { | ||
| 469 | toolCount: args.toolCount, | ||
| 470 | refHintTableJson: args.refHintTableJson ?? null, | ||
| 471 | updatedAt: now, | ||
| 472 | }); | ||
| 473 | |||
| 474 | return { | ||
| 475 | artifactId: existing.id, | ||
| 476 | created: false, | ||
| 477 | }; | ||
| 478 | } | ||
| 479 | |||
| 480 | const artifactId = `art_${args.protocol}_${args.contentHash}_${args.extractorVersion}`; | ||
| 481 | await ctx.db.insert("artifacts", { | ||
| 482 | id: artifactId, | ||
| 483 | protocol: args.protocol, | ||
| 484 | contentHash: args.contentHash, | ||
| 485 | extractorVersion: args.extractorVersion, | ||
| 486 | toolCount: args.toolCount, | ||
| 487 | refHintTableJson: args.refHintTableJson ?? null, | ||
| 488 | createdAt: now, | ||
| 489 | updatedAt: now, | ||
| 490 | }); | ||
| 491 | |||
| 492 | return { | ||
| 493 | artifactId, | ||
| 494 | created: true, | ||
| 495 | }; | ||
| 496 | }, | ||
| 497 | }); | ||
| 498 | |||
| 499 | export const clearArtifactSchemaRefs = internalMutation({ | ||
| 500 | args: { | ||
| 501 | artifactId: v.string(), | ||
| 502 | }, | ||
| 503 | handler: async (ctx, args) => { | ||
| 504 | const existing = await ctx.db | ||
| 505 | .query("artifactSchemaRefs") | ||
| 506 | .withIndex("by_artifactId", (q) => q.eq("artifactId", args.artifactId)) | ||
| 507 | .collect(); | ||
| 508 | |||
| 509 | for (const row of existing) { | ||
| 510 | await ctx.db.delete(row._id); | ||
| 511 | } | ||
| 512 | |||
| 513 | return { removedCount: existing.length }; | ||
| 514 | }, | ||
| 515 | }); | ||
| 516 | |||
| 517 | export const putArtifactSchemaRefsBatch = internalMutation({ | ||
| 518 | args: { | ||
| 519 | artifactId: v.string(), | ||
| 520 | refs: v.array( | ||
| 521 | v.object({ | ||
| 522 | refKey: v.string(), | ||
| 523 | schemaJson: v.string(), | ||
| 524 | }), | ||
| 525 | ), | ||
| 526 | }, | ||
| 527 | handler: async (ctx, args) => { | ||
| 528 | const now = Date.now(); | ||
| 529 | let insertedCount = 0; | ||
| 530 | |||
| 531 | for (const ref of args.refs) { | ||
| 532 | await ctx.db.insert("artifactSchemaRefs", { | ||
| 533 | id: artifactSchemaRefId(args.artifactId, ref.refKey), | ||
| 534 | artifactId: args.artifactId, | ||
| 535 | refKey: ref.refKey, | ||
| 536 | schemaJson: ref.schemaJson, | ||
| 537 | createdAt: now, | ||
| 538 | updatedAt: now, | ||
| 539 | }); | ||
| 540 | insertedCount += 1; | ||
| 541 | } | ||
| 542 | |||
| 543 | return { insertedCount }; | ||
| 544 | }, | ||
| 545 | }); | ||
| 546 | |||
| 547 | export const countArtifactSchemaRefs = internalQuery({ | ||
| 548 | args: { | ||
| 549 | artifactId: v.string(), | ||
| 550 | }, | ||
| 551 | handler: async (ctx, args) => { | ||
| 552 | const rows = await ctx.db | ||
| 553 | .query("artifactSchemaRefs") | ||
| 554 | .withIndex("by_artifactId", (q) => q.eq("artifactId", args.artifactId)) | ||
| 555 | .collect(); | ||
| 556 | |||
| 557 | return rows.length; | ||
| 558 | }, | ||
| 559 | }); | ||
| 560 | |||
| 561 | export const putArtifactToolsBatch = internalMutation({ | ||
| 562 | args: { | ||
| 563 | artifactId: v.string(), | ||
| 564 | protocol: v.string(), | ||
| 565 | insertOnly: v.optional(v.boolean()), | ||
| 566 | tools: v.array( | ||
| 567 | v.object({ | ||
| 568 | toolId: v.string(), | ||
| 569 | name: v.string(), | ||
| 570 | description: v.union(v.string(), v.null()), | ||
| 571 | canonicalPath: v.string(), | ||
| 572 | operationHash: v.string(), | ||
| 573 | invocationJson: v.string(), | ||
| 574 | inputSchemaJson: v.optional(v.union(v.string(), v.null())), | ||
| 575 | outputSchemaJson: v.optional(v.union(v.string(), v.null())), | ||
| 576 | metadataJson: v.optional(v.union(v.string(), v.null())), | ||
| 577 | }), | ||
| 578 | ), | ||
| 579 | }, | ||
| 580 | handler: async (ctx, args) => { | ||
| 581 | const now = Date.now(); | ||
| 582 | let insertedCount = 0; | ||
| 583 | |||
| 584 | if (args.insertOnly === true) { | ||
| 585 | for (const tool of args.tools) { | ||
| 586 | await ctx.db.insert("artifactTools", { | ||
| 587 | id: `${args.artifactId}:${tool.toolId}`, | ||
| 588 | artifactId: args.artifactId, | ||
| 589 | protocol: args.protocol, | ||
| 590 | toolId: tool.toolId, | ||
| 591 | name: tool.name, | ||
| 592 | description: tool.description, | ||
| 593 | canonicalPath: tool.canonicalPath, | ||
| 594 | operationHash: tool.operationHash, | ||
| 595 | invocationJson: tool.invocationJson, | ||
| 596 | inputSchemaJson: tool.inputSchemaJson ?? null, | ||
| 597 | outputSchemaJson: tool.outputSchemaJson ?? null, | ||
| 598 | metadataJson: tool.metadataJson ?? null, | ||
| 599 | createdAt: now, | ||
| 600 | updatedAt: now, | ||
| 601 | }); | ||
| 602 | insertedCount += 1; | ||
| 603 | } | ||
| 604 | |||
| 605 | return { insertedCount }; | ||
| 606 | } | ||
| 607 | |||
| 608 | for (const tool of args.tools) { | ||
| 609 | const existing = await ctx.db | ||
| 610 | .query("artifactTools") | ||
| 611 | .withIndex("by_artifactId_toolId", (q) => | ||
| 612 | q.eq("artifactId", args.artifactId).eq("toolId", tool.toolId), | ||
| 613 | ) | ||
| 614 | .unique(); | ||
| 615 | |||
| 616 | const row = { | ||
| 617 | id: `${args.artifactId}:${tool.toolId}`, | ||
| 618 | artifactId: args.artifactId, | ||
| 619 | protocol: args.protocol, | ||
| 620 | toolId: tool.toolId, | ||
| 621 | name: tool.name, | ||
| 622 | description: tool.description, | ||
| 623 | canonicalPath: tool.canonicalPath, | ||
| 624 | operationHash: tool.operationHash, | ||
| 625 | invocationJson: tool.invocationJson, | ||
| 626 | inputSchemaJson: tool.inputSchemaJson ?? null, | ||
| 627 | outputSchemaJson: tool.outputSchemaJson ?? null, | ||
| 628 | metadataJson: tool.metadataJson ?? null, | ||
| 629 | createdAt: existing?.createdAt ?? now, | ||
| 630 | updatedAt: now, | ||
| 631 | }; | ||
| 632 | |||
| 633 | if (existing) { | ||
| 634 | await ctx.db.patch(existing._id, row); | ||
| 635 | } else { | ||
| 636 | await ctx.db.insert("artifactTools", row); | ||
| 637 | insertedCount += 1; | ||
| 638 | } | ||
| 639 | } | ||
| 640 | |||
| 641 | return { insertedCount }; | ||
| 642 | }, | ||
| 643 | }); | ||
| 644 | |||
| 645 | export const bindSourceToArtifact = internalMutation({ | ||
| 646 | args: { | ||
| 647 | workspaceId: v.string(), | ||
| 648 | sourceId: v.string(), | ||
| 649 | artifactId: v.string(), | ||
| 650 | }, | ||
| 651 | handler: async (ctx, args) => { | ||
| 652 | const existing = await ctx.db | ||
| 653 | .query("sourceArtifactBindings") | ||
| 654 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 655 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 656 | ) | ||
| 657 | .unique(); | ||
| 658 | |||
| 659 | const row = { | ||
| 660 | id: existing?.id ?? `sab_${args.workspaceId}_${args.sourceId}`, | ||
| 661 | workspaceId: args.workspaceId, | ||
| 662 | sourceId: args.sourceId, | ||
| 663 | artifactId: args.artifactId, | ||
| 664 | updatedAt: Date.now(), | ||
| 665 | }; | ||
| 666 | |||
| 667 | if (existing) { | ||
| 668 | await ctx.db.patch(existing._id, row); | ||
| 669 | } else { | ||
| 670 | await ctx.db.insert("sourceArtifactBindings", row); | ||
| 671 | } | ||
| 672 | |||
| 673 | return row; | ||
| 674 | }, | ||
| 675 | }); | ||
| 676 | |||
| 677 | export const replaceSourceIngestArtifactBatches = internalMutation({ | ||
| 678 | args: { | ||
| 679 | workspaceId: v.string(), | ||
| 680 | sourceId: v.string(), | ||
| 681 | artifactId: v.string(), | ||
| 682 | protocol: v.string(), | ||
| 683 | batches: v.array(v.string()), | ||
| 684 | }, | ||
| 685 | handler: async (ctx, args) => { | ||
| 686 | const existing = await ctx.db | ||
| 687 | .query("sourceIngestArtifactBatches") | ||
| 688 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 689 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 690 | ) | ||
| 691 | .collect(); | ||
| 692 | |||
| 693 | for (const row of existing) { | ||
| 694 | await ctx.db.delete(row._id); | ||
| 695 | } | ||
| 696 | |||
| 697 | const now = Date.now(); | ||
| 698 | for (let batchIndex = 0; batchIndex < args.batches.length; batchIndex += 1) { | ||
| 699 | await ctx.db.insert("sourceIngestArtifactBatches", { | ||
| 700 | id: `siab_${args.workspaceId}_${args.sourceId}_${args.artifactId}_${batchIndex}`, | ||
| 701 | workspaceId: args.workspaceId, | ||
| 702 | sourceId: args.sourceId, | ||
| 703 | artifactId: args.artifactId, | ||
| 704 | protocol: args.protocol, | ||
| 705 | batchIndex, | ||
| 706 | toolsJson: args.batches[batchIndex] ?? "[]", | ||
| 707 | updatedAt: now, | ||
| 708 | }); | ||
| 709 | } | ||
| 710 | |||
| 711 | return { batchCount: args.batches.length }; | ||
| 712 | }, | ||
| 713 | }); | ||
| 714 | |||
| 715 | export const clearSourceIngestArtifactBatches = internalMutation({ | ||
| 716 | args: { | ||
| 717 | workspaceId: v.string(), | ||
| 718 | sourceId: v.string(), | ||
| 719 | }, | ||
| 720 | handler: async (ctx, args) => { | ||
| 721 | const existing = await ctx.db | ||
| 722 | .query("sourceIngestArtifactBatches") | ||
| 723 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 724 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 725 | ) | ||
| 726 | .collect(); | ||
| 727 | |||
| 728 | for (const row of existing) { | ||
| 729 | await ctx.db.delete(row._id); | ||
| 730 | } | ||
| 731 | |||
| 732 | return { removedCount: existing.length }; | ||
| 733 | }, | ||
| 734 | }); | ||
| 735 | |||
| 736 | export const getSourceIngestArtifactBatch = internalQuery({ | ||
| 737 | args: { | ||
| 738 | workspaceId: v.string(), | ||
| 739 | sourceId: v.string(), | ||
| 740 | artifactId: v.string(), | ||
| 741 | batchIndex: v.number(), | ||
| 742 | }, | ||
| 743 | handler: async (ctx, args) => { | ||
| 744 | const row = await ctx.db | ||
| 745 | .query("sourceIngestArtifactBatches") | ||
| 746 | .withIndex("by_workspaceId_sourceId_artifactId_batchIndex", (q) => | ||
| 747 | q | ||
| 748 | .eq("workspaceId", args.workspaceId) | ||
| 749 | .eq("sourceId", args.sourceId) | ||
| 750 | .eq("artifactId", args.artifactId) | ||
| 751 | .eq("batchIndex", Math.max(0, Math.floor(args.batchIndex))), | ||
| 752 | ) | ||
| 753 | .unique(); | ||
| 754 | |||
| 755 | return row ? stripConvexSystemFields(row as unknown as Record<string, unknown>) : null; | ||
| 756 | }, | ||
| 757 | }); | ||
| 758 | |||
| 759 | export const replaceWorkspaceSourceToolIndex = internalMutation({ | ||
| 760 | args: { | ||
| 761 | workspaceId: v.string(), | ||
| 762 | sourceId: v.string(), | ||
| 763 | sourceName: v.string(), | ||
| 764 | sourceKind: v.string(), | ||
| 765 | artifactId: v.string(), | ||
| 766 | namespace: v.string(), | ||
| 767 | refHintTableJson: v.optional(v.union(v.string(), v.null())), | ||
| 768 | rows: v.array( | ||
| 769 | v.object({ | ||
| 770 | toolId: v.string(), | ||
| 771 | protocol: v.string(), | ||
| 772 | method: v.string(), | ||
| 773 | path: v.string(), | ||
| 774 | operationPath: v.optional(v.union(v.string(), v.null())), | ||
| 775 | name: v.string(), | ||
| 776 | description: v.union(v.string(), v.null()), | ||
| 777 | searchText: v.string(), | ||
| 778 | operationHash: v.string(), | ||
| 779 | approvalMode: v.string(), | ||
| 780 | status: v.string(), | ||
| 781 | }), | ||
| 782 | ), | ||
| 783 | }, | ||
| 784 | handler: async (ctx, args) => { | ||
| 785 | const existingRows = await ctx.db | ||
| 786 | .query("workspaceToolIndex") | ||
| 787 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 788 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 789 | ) | ||
| 790 | .collect(); | ||
| 791 | |||
| 792 | for (const row of existingRows) { | ||
| 793 | await ctx.db.delete(row._id); | ||
| 794 | } | ||
| 795 | |||
| 796 | const now = Date.now(); | ||
| 797 | let insertedCount = 0; | ||
| 798 | |||
| 799 | for (const row of args.rows) { | ||
| 800 | await ctx.db.insert("workspaceToolIndex", { | ||
| 801 | id: `wti_${args.workspaceId}_${args.sourceId}_${row.toolId}`, | ||
| 802 | workspaceId: args.workspaceId, | ||
| 803 | sourceId: args.sourceId, | ||
| 804 | sourceName: args.sourceName, | ||
| 805 | sourceKind: args.sourceKind, | ||
| 806 | artifactId: args.artifactId, | ||
| 807 | toolId: row.toolId, | ||
| 808 | protocol: row.protocol, | ||
| 809 | method: row.method, | ||
| 810 | namespace: args.namespace, | ||
| 811 | path: row.path, | ||
| 812 | pathLower: row.path.toLowerCase(), | ||
| 813 | normalizedPath: normalizePathForLookup(row.path), | ||
| 814 | operationPath: row.operationPath ?? null, | ||
| 815 | name: row.name, | ||
| 816 | description: row.description, | ||
| 817 | searchText: row.searchText, | ||
| 818 | operationHash: row.operationHash, | ||
| 819 | approvalMode: row.approvalMode, | ||
| 820 | status: row.status, | ||
| 821 | refHintTableJson: args.refHintTableJson ?? null, | ||
| 822 | updatedAt: now, | ||
| 823 | }); | ||
| 824 | insertedCount += 1; | ||
| 825 | } | ||
| 826 | |||
| 827 | return { insertedCount }; | ||
| 828 | }, | ||
| 829 | }); | ||
| 830 | |||
| 831 | export const clearWorkspaceSourceToolIndex = internalMutation({ | ||
| 832 | args: { | ||
| 833 | workspaceId: v.string(), | ||
| 834 | sourceId: v.string(), | ||
| 835 | }, | ||
| 836 | handler: async (ctx, args) => { | ||
| 837 | const existingRows = await ctx.db | ||
| 838 | .query("workspaceToolIndex") | ||
| 839 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 840 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 841 | ) | ||
| 842 | .collect(); | ||
| 843 | |||
| 844 | for (const row of existingRows) { | ||
| 845 | await ctx.db.delete(row._id); | ||
| 846 | } | ||
| 847 | |||
| 848 | return { removedCount: existingRows.length }; | ||
| 849 | }, | ||
| 850 | }); | ||
| 851 | |||
| 852 | export const appendWorkspaceSourceToolIndexChunk = internalMutation({ | ||
| 853 | args: { | ||
| 854 | workspaceId: v.string(), | ||
| 855 | sourceId: v.string(), | ||
| 856 | sourceName: v.string(), | ||
| 857 | sourceKind: v.string(), | ||
| 858 | artifactId: v.string(), | ||
| 859 | namespace: v.string(), | ||
| 860 | refHintTableJson: v.optional(v.union(v.string(), v.null())), | ||
| 861 | insertOnly: v.optional(v.boolean()), | ||
| 862 | rows: v.array( | ||
| 863 | v.object({ | ||
| 864 | toolId: v.string(), | ||
| 865 | protocol: v.string(), | ||
| 866 | method: v.string(), | ||
| 867 | path: v.string(), | ||
| 868 | operationPath: v.optional(v.union(v.string(), v.null())), | ||
| 869 | name: v.string(), | ||
| 870 | description: v.union(v.string(), v.null()), | ||
| 871 | searchText: v.string(), | ||
| 872 | operationHash: v.string(), | ||
| 873 | approvalMode: v.string(), | ||
| 874 | status: v.string(), | ||
| 875 | }), | ||
| 876 | ), | ||
| 877 | }, | ||
| 878 | handler: async (ctx, args) => { | ||
| 879 | const now = Date.now(); | ||
| 880 | let insertedCount = 0; | ||
| 881 | let updatedCount = 0; | ||
| 882 | |||
| 883 | if (args.insertOnly === true) { | ||
| 884 | for (const row of args.rows) { | ||
| 885 | const nextRow = { | ||
| 886 | id: `wti_${args.workspaceId}_${args.sourceId}_${row.toolId}`, | ||
| 887 | workspaceId: args.workspaceId, | ||
| 888 | sourceId: args.sourceId, | ||
| 889 | sourceName: args.sourceName, | ||
| 890 | sourceKind: args.sourceKind, | ||
| 891 | artifactId: args.artifactId, | ||
| 892 | toolId: row.toolId, | ||
| 893 | protocol: row.protocol, | ||
| 894 | method: row.method, | ||
| 895 | namespace: args.namespace, | ||
| 896 | path: row.path, | ||
| 897 | pathLower: row.path.toLowerCase(), | ||
| 898 | normalizedPath: normalizePathForLookup(row.path), | ||
| 899 | operationPath: row.operationPath ?? null, | ||
| 900 | name: row.name, | ||
| 901 | description: row.description, | ||
| 902 | searchText: row.searchText, | ||
| 903 | operationHash: row.operationHash, | ||
| 904 | approvalMode: row.approvalMode, | ||
| 905 | status: row.status, | ||
| 906 | refHintTableJson: args.refHintTableJson ?? null, | ||
| 907 | updatedAt: now, | ||
| 908 | }; | ||
| 909 | |||
| 910 | await ctx.db.insert("workspaceToolIndex", nextRow); | ||
| 911 | insertedCount += 1; | ||
| 912 | } | ||
| 913 | |||
| 914 | return { insertedCount, updatedCount }; | ||
| 915 | } | ||
| 916 | |||
| 917 | for (const row of args.rows) { | ||
| 918 | const id = `wti_${args.workspaceId}_${args.sourceId}_${row.toolId}`; | ||
| 919 | const existing = await ctx.db | ||
| 920 | .query("workspaceToolIndex") | ||
| 921 | .withIndex("by_domainId", (q) => q.eq("id", id)) | ||
| 922 | .unique(); | ||
| 923 | |||
| 924 | const nextRow = { | ||
| 925 | id, | ||
| 926 | workspaceId: args.workspaceId, | ||
| 927 | sourceId: args.sourceId, | ||
| 928 | sourceName: args.sourceName, | ||
| 929 | sourceKind: args.sourceKind, | ||
| 930 | artifactId: args.artifactId, | ||
| 931 | toolId: row.toolId, | ||
| 932 | protocol: row.protocol, | ||
| 933 | method: row.method, | ||
| 934 | namespace: args.namespace, | ||
| 935 | path: row.path, | ||
| 936 | pathLower: row.path.toLowerCase(), | ||
| 937 | normalizedPath: normalizePathForLookup(row.path), | ||
| 938 | operationPath: row.operationPath ?? null, | ||
| 939 | name: row.name, | ||
| 940 | description: row.description, | ||
| 941 | searchText: row.searchText, | ||
| 942 | operationHash: row.operationHash, | ||
| 943 | approvalMode: row.approvalMode, | ||
| 944 | status: row.status, | ||
| 945 | refHintTableJson: args.refHintTableJson ?? null, | ||
| 946 | updatedAt: now, | ||
| 947 | }; | ||
| 948 | |||
| 949 | if (existing) { | ||
| 950 | await ctx.db.patch(existing._id, nextRow); | ||
| 951 | updatedCount += 1; | ||
| 952 | } else { | ||
| 953 | await ctx.db.insert("workspaceToolIndex", nextRow); | ||
| 954 | insertedCount += 1; | ||
| 955 | } | ||
| 956 | } | ||
| 957 | |||
| 958 | return { insertedCount, updatedCount }; | ||
| 959 | }, | ||
| 960 | }); | ||
| 961 | |||
| 962 | export const removeSourceBindingsAndIndex = internalMutation({ | ||
| 963 | args: { | ||
| 964 | workspaceId: v.string(), | ||
| 965 | sourceId: v.string(), | ||
| 966 | }, | ||
| 967 | handler: async (ctx, args) => { | ||
| 968 | const binding = await ctx.db | ||
| 969 | .query("sourceArtifactBindings") | ||
| 970 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 971 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 972 | ) | ||
| 973 | .unique(); | ||
| 974 | |||
| 975 | if (binding) { | ||
| 976 | await ctx.db.delete(binding._id); | ||
| 977 | } | ||
| 978 | |||
| 979 | const indexRows = await ctx.db | ||
| 980 | .query("workspaceToolIndex") | ||
| 981 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 982 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 983 | ) | ||
| 984 | .collect(); | ||
| 985 | |||
| 986 | for (const row of indexRows) { | ||
| 987 | await ctx.db.delete(row._id); | ||
| 988 | } | ||
| 989 | |||
| 990 | return { | ||
| 991 | removedBinding: Boolean(binding), | ||
| 992 | removedIndexRows: indexRows.length, | ||
| 993 | }; | ||
| 994 | }, | ||
| 995 | }); | ||
| 996 | |||
| 997 | export const getSourceArtifactBinding = internalQuery({ | ||
| 998 | args: { | ||
| 999 | workspaceId: v.string(), | ||
| 1000 | sourceId: v.string(), | ||
| 1001 | }, | ||
| 1002 | handler: async (ctx, args) => { | ||
| 1003 | const binding = await ctx.db | ||
| 1004 | .query("sourceArtifactBindings") | ||
| 1005 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 1006 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 1007 | ) | ||
| 1008 | .unique(); | ||
| 1009 | |||
| 1010 | return binding ? stripConvexSystemFields(binding as unknown as Record<string, unknown>) : null; | ||
| 1011 | }, | ||
| 1012 | }); | ||
| 1013 | |||
| 1014 | export const getArtifactById = internalQuery({ | ||
| 1015 | args: { | ||
| 1016 | artifactId: v.string(), | ||
| 1017 | }, | ||
| 1018 | handler: async (ctx, args) => { | ||
| 1019 | const artifact = await ctx.db | ||
| 1020 | .query("artifacts") | ||
| 1021 | .withIndex("by_domainId", (q) => q.eq("id", args.artifactId)) | ||
| 1022 | .unique(); | ||
| 1023 | |||
| 1024 | return artifact ? stripConvexSystemFields(artifact as unknown as Record<string, unknown>) : null; | ||
| 1025 | }, | ||
| 1026 | }); | ||
| 1027 | |||
| 1028 | export const listArtifactTools = internalQuery({ | ||
| 1029 | args: { | ||
| 1030 | artifactId: v.string(), | ||
| 1031 | }, | ||
| 1032 | handler: async (ctx, args) => { | ||
| 1033 | const rows = await ctx.db | ||
| 1034 | .query("artifactTools") | ||
| 1035 | .withIndex("by_artifactId", (q) => q.eq("artifactId", args.artifactId)) | ||
| 1036 | .collect(); | ||
| 1037 | |||
| 1038 | return rows | ||
| 1039 | .map((row) => stripConvexSystemFields(row as unknown as Record<string, unknown>)) | ||
| 1040 | .sort((left, right) => String(left.toolId).localeCompare(String(right.toolId))); | ||
| 1041 | }, | ||
| 1042 | }); | ||
| 1043 | |||
| 1044 | export const listArtifactToolIndexSlice = internalQuery({ | ||
| 1045 | args: { | ||
| 1046 | artifactId: v.string(), | ||
| 1047 | offset: v.optional(v.number()), | ||
| 1048 | limit: v.optional(v.number()), | ||
| 1049 | }, | ||
| 1050 | handler: async (ctx, args) => { | ||
| 1051 | const rows = await ctx.db | ||
| 1052 | .query("artifactTools") | ||
| 1053 | .withIndex("by_artifactId", (q) => q.eq("artifactId", args.artifactId)) | ||
| 1054 | .collect(); | ||
| 1055 | |||
| 1056 | const ordered = rows | ||
| 1057 | .map((row) => stripConvexSystemFields(row as unknown as Record<string, unknown>)) | ||
| 1058 | .sort((left, right) => String(left.toolId).localeCompare(String(right.toolId))); | ||
| 1059 | |||
| 1060 | const offset = Math.max(0, Math.floor(args.offset ?? 0)); | ||
| 1061 | const limit = normalizeLimit(args.limit); | ||
| 1062 | |||
| 1063 | return ordered.slice(offset, offset + limit).map((row) => ({ | ||
| 1064 | toolId: String(row.toolId), | ||
| 1065 | protocol: String(row.protocol), | ||
| 1066 | name: String(row.name), | ||
| 1067 | description: typeof row.description === "string" ? row.description : null, | ||
| 1068 | canonicalPath: typeof row.canonicalPath === "string" ? row.canonicalPath : null, | ||
| 1069 | operationHash: String(row.operationHash), | ||
| 1070 | metadataJson: typeof row.metadataJson === "string" ? row.metadataJson : null, | ||
| 1071 | })); | ||
| 1072 | }, | ||
| 1073 | }); | ||
| 1074 | |||
| 1075 | export const getArtifactTool = internalQuery({ | ||
| 1076 | args: { | ||
| 1077 | artifactId: v.string(), | ||
| 1078 | toolId: v.string(), | ||
| 1079 | }, | ||
| 1080 | handler: async (ctx, args) => { | ||
| 1081 | const row = await ctx.db | ||
| 1082 | .query("artifactTools") | ||
| 1083 | .withIndex("by_artifactId_toolId", (q) => | ||
| 1084 | q.eq("artifactId", args.artifactId).eq("toolId", args.toolId), | ||
| 1085 | ) | ||
| 1086 | .unique(); | ||
| 1087 | |||
| 1088 | return row ? stripConvexSystemFields(row as unknown as Record<string, unknown>) : null; | ||
| 1089 | }, | ||
| 1090 | }); | ||
| 1091 | |||
| 1092 | export const searchWorkspaceTools = internalQuery({ | ||
| 1093 | args: { | ||
| 1094 | workspaceId: v.string(), | ||
| 1095 | query: v.string(), | ||
| 1096 | limit: v.optional(v.number()), | ||
| 1097 | sourceId: v.optional(v.string()), | ||
| 1098 | namespace: v.optional(v.string()), | ||
| 1099 | includeDisabled: v.optional(v.boolean()), | ||
| 1100 | }, | ||
| 1101 | handler: async (ctx, args) => { | ||
| 1102 | const trimmedQuery = args.query.trim(); | ||
| 1103 | const limit = normalizeLimit(args.limit); | ||
| 1104 | if (trimmedQuery.length === 0) { | ||
| 1105 | return []; | ||
| 1106 | } | ||
| 1107 | |||
| 1108 | const rows = await buildWorkspaceToolRows(ctx, { | ||
| 1109 | workspaceId: args.workspaceId, | ||
| 1110 | sourceId: args.sourceId, | ||
| 1111 | namespace: args.namespace, | ||
| 1112 | includeDisabled: args.includeDisabled, | ||
| 1113 | }); | ||
| 1114 | |||
| 1115 | const queryLower = trimmedQuery.toLowerCase(); | ||
| 1116 | const ranked = rows | ||
| 1117 | .map((row) => ({ | ||
| 1118 | row, | ||
| 1119 | score: scoreSearchRow(row, queryLower), | ||
| 1120 | })) | ||
| 1121 | .filter((entry) => entry.score > 0) | ||
| 1122 | .sort((left, right) => { | ||
| 1123 | if (left.score !== right.score) { | ||
| 1124 | return right.score - left.score; | ||
| 1125 | } | ||
| 1126 | |||
| 1127 | return String(left.row.path).localeCompare(String(right.row.path)); | ||
| 1128 | }); | ||
| 1129 | |||
| 1130 | return ranked.slice(0, limit).map((entry) => entry.row); | ||
| 1131 | }, | ||
| 1132 | }); | ||
| 1133 | |||
| 1134 | export const listWorkspaceTools = internalQuery({ | ||
| 1135 | args: { | ||
| 1136 | workspaceId: v.string(), | ||
| 1137 | limit: v.optional(v.number()), | ||
| 1138 | sourceId: v.optional(v.string()), | ||
| 1139 | namespace: v.optional(v.string()), | ||
| 1140 | includeDisabled: v.optional(v.boolean()), | ||
| 1141 | }, | ||
| 1142 | handler: async (ctx, args) => { | ||
| 1143 | const rows = await buildWorkspaceToolRows(ctx, { | ||
| 1144 | workspaceId: args.workspaceId, | ||
| 1145 | sourceId: args.sourceId, | ||
| 1146 | namespace: args.namespace, | ||
| 1147 | includeDisabled: args.includeDisabled, | ||
| 1148 | }); | ||
| 1149 | |||
| 1150 | return rows.slice(0, normalizeLimit(args.limit)); | ||
| 1151 | }, | ||
| 1152 | }); | ||
| 1153 | |||
| 1154 | export const getWorkspaceToolByPath = internalQuery({ | ||
| 1155 | args: { | ||
| 1156 | workspaceId: v.string(), | ||
| 1157 | pathLower: v.string(), | ||
| 1158 | }, | ||
| 1159 | handler: async (ctx, args) => { | ||
| 1160 | const rows = await buildWorkspaceToolRows(ctx, { | ||
| 1161 | workspaceId: args.workspaceId, | ||
| 1162 | includeDisabled: true, | ||
| 1163 | }); | ||
| 1164 | |||
| 1165 | return rows.find((row) => String(row.pathLower) === args.pathLower) ?? null; | ||
| 1166 | }, | ||
| 1167 | }); | ||
| 1168 | |||
| 1169 | export const listWorkspaceToolsByNormalizedPath = internalQuery({ | ||
| 1170 | args: { | ||
| 1171 | workspaceId: v.string(), | ||
| 1172 | normalizedPath: v.string(), | ||
| 1173 | limit: v.optional(v.number()), | ||
| 1174 | }, | ||
| 1175 | handler: async (ctx, args) => { | ||
| 1176 | const rows = await buildWorkspaceToolRows(ctx, { | ||
| 1177 | workspaceId: args.workspaceId, | ||
| 1178 | includeDisabled: false, | ||
| 1179 | }); | ||
| 1180 | |||
| 1181 | return rows | ||
| 1182 | .filter((row) => String(row.normalizedPath) === args.normalizedPath) | ||
| 1183 | .slice(0, normalizeLimit(args.limit)); | ||
| 1184 | }, | ||
| 1185 | }); | ||
| 1186 | |||
| 1187 | export const listWorkspaceNamespaces = internalQuery({ | ||
| 1188 | args: { | ||
| 1189 | workspaceId: v.string(), | ||
| 1190 | limit: v.optional(v.number()), | ||
| 1191 | }, | ||
| 1192 | handler: async (ctx, args) => { | ||
| 1193 | const rows = await buildWorkspaceToolRows(ctx, { | ||
| 1194 | workspaceId: args.workspaceId, | ||
| 1195 | includeDisabled: false, | ||
| 1196 | }); | ||
| 1197 | |||
| 1198 | const grouped = new Map< | ||
| 1199 | string, | ||
| 1200 | { | ||
| 1201 | sourceName: string; | ||
| 1202 | sourceId: string; | ||
| 1203 | sourceKind: string; | ||
| 1204 | paths: Array<string>; | ||
| 1205 | } | ||
| 1206 | >(); | ||
| 1207 | |||
| 1208 | for (const row of rows) { | ||
| 1209 | const namespace = String(row.namespace); | ||
| 1210 | const existing = grouped.get(namespace); | ||
| 1211 | if (existing) { | ||
| 1212 | existing.paths.push(String(row.path)); | ||
| 1213 | continue; | ||
| 1214 | } | ||
| 1215 | |||
| 1216 | grouped.set(namespace, { | ||
| 1217 | sourceName: String(row.sourceName), | ||
| 1218 | sourceId: String(row.sourceId), | ||
| 1219 | sourceKind: String(row.sourceKind), | ||
| 1220 | paths: [String(row.path)], | ||
| 1221 | }); | ||
| 1222 | } | ||
| 1223 | |||
| 1224 | const namespaces = [...grouped.entries()] | ||
| 1225 | .map(([namespace, value]) => ({ | ||
| 1226 | namespace, | ||
| 1227 | source: value.sourceName, | ||
| 1228 | sourceId: value.sourceId, | ||
| 1229 | sourceKind: value.sourceKind, | ||
| 1230 | toolCount: value.paths.length, | ||
| 1231 | samplePaths: value.paths.sort((left, right) => left.localeCompare(right)).slice(0, 3), | ||
| 1232 | })) | ||
| 1233 | .sort((left, right) => left.namespace.localeCompare(right.namespace)); | ||
| 1234 | |||
| 1235 | return namespaces.slice(0, normalizeLimit(args.limit)); | ||
| 1236 | }, | ||
| 1237 | }); | ||
| @@ -0,0 +1,393 @@ | |||
| 1 | import { type SourceToolDetail, type SourceToolSummary } from "@executor-v2/management-api"; | ||
| 2 | import { | ||
| 3 | SourceSchema, | ||
| 4 | type OpenApiHttpMethod, | ||
| 5 | type Source, | ||
| 6 | } from "@executor-v2/schema"; | ||
| 7 | import { v } from "convex/values"; | ||
| 8 | import * as Schema from "effect/Schema"; | ||
| 9 | |||
| 10 | import { query } from "../_generated/server"; | ||
| 11 | |||
| 12 | const decodeSource = Schema.decodeUnknownSync(SourceSchema); | ||
| 13 | |||
| 14 | const stripConvexSystemFields = ( | ||
| 15 | value: Record<string, unknown>, | ||
| 16 | ): Record<string, unknown> => { | ||
| 17 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 18 | return rest; | ||
| 19 | }; | ||
| 20 | |||
| 21 | const toSource = (document: Record<string, unknown>): Source => | ||
| 22 | decodeSource(stripConvexSystemFields(document)); | ||
| 23 | |||
| 24 | const parseJsonObject = (value: string | null | undefined): Record<string, unknown> => { | ||
| 25 | if (!value) { | ||
| 26 | return {}; | ||
| 27 | } | ||
| 28 | |||
| 29 | try { | ||
| 30 | const parsed = JSON.parse(value) as unknown; | ||
| 31 | return parsed && typeof parsed === "object" && !Array.isArray(parsed) | ||
| 32 | ? (parsed as Record<string, unknown>) | ||
| 33 | : {}; | ||
| 34 | } catch { | ||
| 35 | return {}; | ||
| 36 | } | ||
| 37 | }; | ||
| 38 | |||
| 39 | const parseJsonValue = (value: string | null | undefined): unknown | null => { | ||
| 40 | if (!value) { | ||
| 41 | return null; | ||
| 42 | } | ||
| 43 | |||
| 44 | try { | ||
| 45 | return JSON.parse(value) as unknown; | ||
| 46 | } catch { | ||
| 47 | return null; | ||
| 48 | } | ||
| 49 | }; | ||
| 50 | |||
| 51 | const asNullableString = (value: unknown): string | null => | ||
| 52 | typeof value === "string" && value.trim().length > 0 ? value : null; | ||
| 53 | |||
| 54 | const normalizeNamespacePart = (value: string): string => { | ||
| 55 | const normalized = value | ||
| 56 | .trim() | ||
| 57 | .toLowerCase() | ||
| 58 | .replace(/[^a-z0-9]+/g, "_") | ||
| 59 | .replace(/^_+|_+$/g, ""); | ||
| 60 | |||
| 61 | return normalized.length > 0 ? normalized : "source"; | ||
| 62 | }; | ||
| 63 | |||
| 64 | const sourceNamespace = (source: Source): string => { | ||
| 65 | const sourceIdSuffix = source.id.slice(-6).toLowerCase(); | ||
| 66 | return `${normalizeNamespacePart(source.name)}_${sourceIdSuffix}`; | ||
| 67 | }; | ||
| 68 | |||
| 69 | const isMethod = ( | ||
| 70 | value: string | null, | ||
| 71 | ): value is OpenApiHttpMethod | "post" => | ||
| 72 | value === "get" || | ||
| 73 | value === "post" || | ||
| 74 | value === "put" || | ||
| 75 | value === "patch" || | ||
| 76 | value === "delete" || | ||
| 77 | value === "head" || | ||
| 78 | value === "options" || | ||
| 79 | value === "trace"; | ||
| 80 | |||
| 81 | const methodFromCanonicalPath = (canonicalPath: string | null | undefined): OpenApiHttpMethod | "post" | null => { | ||
| 82 | if (!canonicalPath) { | ||
| 83 | return null; | ||
| 84 | } | ||
| 85 | |||
| 86 | const candidate = canonicalPath.trim().split(/\s+/)[0]?.toLowerCase() ?? null; | ||
| 87 | return isMethod(candidate) ? candidate : null; | ||
| 88 | }; | ||
| 89 | |||
| 90 | const toMethod = (protocol: string, metadataJson: string | null | undefined): OpenApiHttpMethod | "post" => { | ||
| 91 | if (protocol !== "openapi") { | ||
| 92 | return "post"; | ||
| 93 | } | ||
| 94 | |||
| 95 | const metadata = parseJsonObject(metadataJson); | ||
| 96 | const method = asNullableString(metadata.method)?.toLowerCase(); | ||
| 97 | |||
| 98 | if ( | ||
| 99 | method === "get" || | ||
| 100 | method === "post" || | ||
| 101 | method === "put" || | ||
| 102 | method === "patch" || | ||
| 103 | method === "delete" || | ||
| 104 | method === "head" || | ||
| 105 | method === "options" || | ||
| 106 | method === "trace" | ||
| 107 | ) { | ||
| 108 | return method; | ||
| 109 | } | ||
| 110 | |||
| 111 | return "get"; | ||
| 112 | }; | ||
| 113 | |||
| 114 | const collectRefKeys = (value: unknown, refs: Set<string>): void => { | ||
| 115 | if (Array.isArray(value)) { | ||
| 116 | for (const item of value) { | ||
| 117 | collectRefKeys(item, refs); | ||
| 118 | } | ||
| 119 | return; | ||
| 120 | } | ||
| 121 | |||
| 122 | if (!value || typeof value !== "object") { | ||
| 123 | return; | ||
| 124 | } | ||
| 125 | |||
| 126 | const record = value as Record<string, unknown>; | ||
| 127 | const refValue = record.$ref; | ||
| 128 | if (typeof refValue === "string" && refValue.startsWith("#/")) { | ||
| 129 | refs.add(refValue); | ||
| 130 | } | ||
| 131 | |||
| 132 | for (const nestedValue of Object.values(record)) { | ||
| 133 | collectRefKeys(nestedValue, refs); | ||
| 134 | } | ||
| 135 | }; | ||
| 136 | |||
| 137 | const resolveToolRefHintTableJson = async ( | ||
| 138 | ctx: any, | ||
| 139 | artifactId: string, | ||
| 140 | inputSchemaJson: string | null | undefined, | ||
| 141 | outputSchemaJson: string | null | undefined, | ||
| 142 | ): Promise<string | null> => { | ||
| 143 | const initialRefs = new Set<string>(); | ||
| 144 | collectRefKeys(parseJsonValue(inputSchemaJson), initialRefs); | ||
| 145 | collectRefKeys(parseJsonValue(outputSchemaJson), initialRefs); | ||
| 146 | |||
| 147 | if (initialRefs.size === 0) { | ||
| 148 | return null; | ||
| 149 | } | ||
| 150 | |||
| 151 | const queue = [...initialRefs]; | ||
| 152 | const seen = new Set<string>(); | ||
| 153 | const table: Record<string, string> = {}; | ||
| 154 | const maxRefs = 5_000; | ||
| 155 | |||
| 156 | while (queue.length > 0 && seen.size < maxRefs) { | ||
| 157 | const refKey = queue.shift(); | ||
| 158 | if (!refKey || seen.has(refKey)) { | ||
| 159 | continue; | ||
| 160 | } | ||
| 161 | |||
| 162 | seen.add(refKey); | ||
| 163 | |||
| 164 | const row = await ctx.db | ||
| 165 | .query("artifactSchemaRefs") | ||
| 166 | .withIndex("by_artifactId_refKey", (q) => | ||
| 167 | q.eq("artifactId", artifactId).eq("refKey", refKey), | ||
| 168 | ) | ||
| 169 | .unique(); | ||
| 170 | |||
| 171 | if (!row || typeof row.schemaJson !== "string") { | ||
| 172 | continue; | ||
| 173 | } | ||
| 174 | |||
| 175 | table[refKey] = row.schemaJson; | ||
| 176 | |||
| 177 | const nestedRefs = new Set<string>(); | ||
| 178 | collectRefKeys(parseJsonValue(row.schemaJson), nestedRefs); | ||
| 179 | for (const nestedRef of nestedRefs) { | ||
| 180 | if (!seen.has(nestedRef)) { | ||
| 181 | queue.push(nestedRef); | ||
| 182 | } | ||
| 183 | } | ||
| 184 | } | ||
| 185 | |||
| 186 | if (Object.keys(table).length === 0) { | ||
| 187 | return null; | ||
| 188 | } | ||
| 189 | |||
| 190 | return JSON.stringify(table); | ||
| 191 | }; | ||
| 192 | |||
| 193 | const toSummary = ( | ||
| 194 | source: Source, | ||
| 195 | toolRow: Record<string, unknown>, | ||
| 196 | metadataJson: string | null | undefined, | ||
| 197 | ): SourceToolSummary => { | ||
| 198 | const protocol = asNullableString(toolRow.protocol) ?? "openapi"; | ||
| 199 | const canonicalPath = asNullableString(toolRow.canonicalPath); | ||
| 200 | const method = methodFromCanonicalPath(canonicalPath) ?? toMethod(protocol, metadataJson); | ||
| 201 | const toolId = asNullableString(toolRow.toolId) ?? "unknown"; | ||
| 202 | const path = `${sourceNamespace(source)}.${toolId}`; | ||
| 203 | |||
| 204 | return { | ||
| 205 | sourceId: source.id, | ||
| 206 | sourceName: source.name, | ||
| 207 | sourceKind: source.kind, | ||
| 208 | toolId, | ||
| 209 | name: asNullableString(toolRow.name) ?? "Unnamed Tool", | ||
| 210 | description: asNullableString(toolRow.description), | ||
| 211 | method, | ||
| 212 | path, | ||
| 213 | operationPath: canonicalPath, | ||
| 214 | operationHash: asNullableString(toolRow.operationHash) ?? "", | ||
| 215 | }; | ||
| 216 | }; | ||
| 217 | |||
| 218 | const sortTools = (tools: ReadonlyArray<SourceToolSummary>): Array<SourceToolSummary> => | ||
| 219 | [...tools].sort((left, right) => { | ||
| 220 | const leftSource = left.sourceName.toLowerCase(); | ||
| 221 | const rightSource = right.sourceName.toLowerCase(); | ||
| 222 | |||
| 223 | if (leftSource !== rightSource) { | ||
| 224 | return leftSource.localeCompare(rightSource); | ||
| 225 | } | ||
| 226 | |||
| 227 | const leftName = left.name.toLowerCase(); | ||
| 228 | const rightName = right.name.toLowerCase(); | ||
| 229 | |||
| 230 | if (leftName !== rightName) { | ||
| 231 | return leftName.localeCompare(rightName); | ||
| 232 | } | ||
| 233 | |||
| 234 | return left.toolId.localeCompare(right.toolId); | ||
| 235 | }); | ||
| 236 | |||
| 237 | export const listWorkspaceTools = query({ | ||
| 238 | args: { | ||
| 239 | workspaceId: v.string(), | ||
| 240 | }, | ||
| 241 | handler: async (ctx, args): Promise<Array<SourceToolSummary>> => { | ||
| 242 | const sourceRows = await ctx.db | ||
| 243 | .query("sources") | ||
| 244 | .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId)) | ||
| 245 | .collect(); | ||
| 246 | |||
| 247 | const sources = sourceRows | ||
| 248 | .map((row) => toSource(row as unknown as Record<string, unknown>)) | ||
| 249 | .filter((source) => source.enabled); | ||
| 250 | const bindings = await ctx.db | ||
| 251 | .query("sourceArtifactBindings") | ||
| 252 | .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId)) | ||
| 253 | .collect(); | ||
| 254 | const bindingBySourceId = new Map<string, string>( | ||
| 255 | bindings.map((row) => [String(row.sourceId), String(row.artifactId)] as const), | ||
| 256 | ); | ||
| 257 | |||
| 258 | const summaries: Array<SourceToolSummary> = []; | ||
| 259 | |||
| 260 | for (const source of sources) { | ||
| 261 | const artifactId = bindingBySourceId.get(source.id); | ||
| 262 | if (!artifactId) { | ||
| 263 | continue; | ||
| 264 | } | ||
| 265 | |||
| 266 | const artifactTools = await ctx.db | ||
| 267 | .query("artifactTools") | ||
| 268 | .withIndex("by_artifactId", (q) => q.eq("artifactId", artifactId)) | ||
| 269 | .collect(); | ||
| 270 | |||
| 271 | for (const artifactTool of artifactTools) { | ||
| 272 | const row = stripConvexSystemFields(artifactTool as unknown as Record<string, unknown>); | ||
| 273 | summaries.push(toSummary(source, row, asNullableString(row.metadataJson))); | ||
| 274 | } | ||
| 275 | } | ||
| 276 | |||
| 277 | return sortTools(summaries); | ||
| 278 | }, | ||
| 279 | }); | ||
| 280 | |||
| 281 | export const listSourceTools = query({ | ||
| 282 | args: { | ||
| 283 | workspaceId: v.string(), | ||
| 284 | sourceId: v.string(), | ||
| 285 | }, | ||
| 286 | handler: async (ctx, args): Promise<Array<SourceToolSummary>> => { | ||
| 287 | const sourceRow = await ctx.db | ||
| 288 | .query("sources") | ||
| 289 | .withIndex("by_domainId", (q) => q.eq("id", args.sourceId)) | ||
| 290 | .unique(); | ||
| 291 | |||
| 292 | if (!sourceRow || sourceRow.workspaceId !== args.workspaceId) { | ||
| 293 | return []; | ||
| 294 | } | ||
| 295 | |||
| 296 | const source = toSource(sourceRow as unknown as Record<string, unknown>); | ||
| 297 | if (!source.enabled) { | ||
| 298 | return []; | ||
| 299 | } | ||
| 300 | |||
| 301 | const binding = await ctx.db | ||
| 302 | .query("sourceArtifactBindings") | ||
| 303 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 304 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 305 | ) | ||
| 306 | .unique(); | ||
| 307 | if (!binding) { | ||
| 308 | return []; | ||
| 309 | } | ||
| 310 | |||
| 311 | const artifactTools = await ctx.db | ||
| 312 | .query("artifactTools") | ||
| 313 | .withIndex("by_artifactId", (q) => q.eq("artifactId", binding.artifactId)) | ||
| 314 | .collect(); | ||
| 315 | |||
| 316 | const summaries: Array<SourceToolSummary> = []; | ||
| 317 | |||
| 318 | for (const artifactTool of artifactTools) { | ||
| 319 | const row = stripConvexSystemFields(artifactTool as unknown as Record<string, unknown>); | ||
| 320 | summaries.push(toSummary(source, row, asNullableString(row.metadataJson))); | ||
| 321 | } | ||
| 322 | |||
| 323 | return sortTools(summaries); | ||
| 324 | }, | ||
| 325 | }); | ||
| 326 | |||
| 327 | export const getToolDetail = query({ | ||
| 328 | args: { | ||
| 329 | workspaceId: v.string(), | ||
| 330 | sourceId: v.string(), | ||
| 331 | operationHash: v.string(), | ||
| 332 | }, | ||
| 333 | handler: async (ctx, args): Promise<SourceToolDetail | null> => { | ||
| 334 | const sourceRow = await ctx.db | ||
| 335 | .query("sources") | ||
| 336 | .withIndex("by_domainId", (q) => q.eq("id", args.sourceId)) | ||
| 337 | .unique(); | ||
| 338 | |||
| 339 | if (!sourceRow || sourceRow.workspaceId !== args.workspaceId) { | ||
| 340 | return null; | ||
| 341 | } | ||
| 342 | |||
| 343 | const source = toSource(sourceRow as unknown as Record<string, unknown>); | ||
| 344 | const binding = await ctx.db | ||
| 345 | .query("sourceArtifactBindings") | ||
| 346 | .withIndex("by_workspaceId_sourceId", (q) => | ||
| 347 | q.eq("workspaceId", args.workspaceId).eq("sourceId", args.sourceId), | ||
| 348 | ) | ||
| 349 | .unique(); | ||
| 350 | if (!binding) { | ||
| 351 | return null; | ||
| 352 | } | ||
| 353 | |||
| 354 | const artifactRows = await ctx.db | ||
| 355 | .query("artifactTools") | ||
| 356 | .withIndex("by_artifactId", (q) => q.eq("artifactId", binding.artifactId)) | ||
| 357 | .collect(); | ||
| 358 | |||
| 359 | const artifactTool = artifactRows.find((row) => row.operationHash === args.operationHash); | ||
| 360 | if (!artifactTool) { | ||
| 361 | return null; | ||
| 362 | } | ||
| 363 | |||
| 364 | const artifact = await ctx.db | ||
| 365 | .query("artifacts") | ||
| 366 | .withIndex("by_domainId", (q) => q.eq("id", binding.artifactId)) | ||
| 367 | .unique(); | ||
| 368 | |||
| 369 | const resolvedRefHintTableJson = source.kind === "openapi" | ||
| 370 | ? await resolveToolRefHintTableJson( | ||
| 371 | ctx, | ||
| 372 | binding.artifactId, | ||
| 373 | artifactTool.inputSchemaJson ?? null, | ||
| 374 | artifactTool.outputSchemaJson ?? null, | ||
| 375 | ) | ||
| 376 | : null; | ||
| 377 | |||
| 378 | const summary = toSummary( | ||
| 379 | source, | ||
| 380 | stripConvexSystemFields(artifactTool as unknown as Record<string, unknown>), | ||
| 381 | artifactTool.metadataJson ?? null, | ||
| 382 | ); | ||
| 383 | |||
| 384 | return { | ||
| 385 | ...summary, | ||
| 386 | inputSchemaJson: artifactTool.inputSchemaJson ?? null, | ||
| 387 | outputSchemaJson: artifactTool.outputSchemaJson ?? null, | ||
| 388 | refHintTableJson: resolvedRefHintTableJson | ||
| 389 | ?? artifact?.refHintTableJson | ||
| 390 | ?? null, | ||
| 391 | }; | ||
| 392 | }, | ||
| 393 | }); | ||
| @@ -0,0 +1,78 @@ | |||
| 1 | import { type UpsertWorkspacePayload } from "@executor-v2/management-api"; | ||
| 2 | import { WorkspaceSchema, type Workspace } from "@executor-v2/schema"; | ||
| 3 | import { v } from "convex/values"; | ||
| 4 | import * as Schema from "effect/Schema"; | ||
| 5 | |||
| 6 | import { mutation, query } from "../_generated/server"; | ||
| 7 | |||
| 8 | const decodeWorkspace = Schema.decodeUnknownSync(WorkspaceSchema); | ||
| 9 | |||
| 10 | const stripConvexSystemFields = ( | ||
| 11 | value: Record<string, unknown>, | ||
| 12 | ): Record<string, unknown> => { | ||
| 13 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 14 | return rest; | ||
| 15 | }; | ||
| 16 | |||
| 17 | const toWorkspace = (document: Record<string, unknown>): Workspace => | ||
| 18 | decodeWorkspace(stripConvexSystemFields(document)); | ||
| 19 | |||
| 20 | const sortWorkspaces = (workspaces: ReadonlyArray<Workspace>): Array<Workspace> => | ||
| 21 | [...workspaces].sort((left, right) => { | ||
| 22 | const leftName = left.name.toLowerCase(); | ||
| 23 | const rightName = right.name.toLowerCase(); | ||
| 24 | |||
| 25 | if (leftName === rightName) { | ||
| 26 | return left.id.localeCompare(right.id); | ||
| 27 | } | ||
| 28 | |||
| 29 | return leftName.localeCompare(rightName); | ||
| 30 | }); | ||
| 31 | |||
| 32 | export const listWorkspaces = query({ | ||
| 33 | args: {}, | ||
| 34 | handler: async (ctx): Promise<Array<Workspace>> => { | ||
| 35 | const rows = await ctx.db.query("workspaces").collect(); | ||
| 36 | |||
| 37 | return sortWorkspaces( | ||
| 38 | rows.map((row) => toWorkspace(row as unknown as Record<string, unknown>)), | ||
| 39 | ); | ||
| 40 | }, | ||
| 41 | }); | ||
| 42 | |||
| 43 | export const upsertWorkspace = mutation({ | ||
| 44 | args: { | ||
| 45 | payload: v.object({ | ||
| 46 | id: v.optional(v.string()), | ||
| 47 | organizationId: v.string(), | ||
| 48 | name: v.string(), | ||
| 49 | }), | ||
| 50 | }, | ||
| 51 | handler: async (ctx, args): Promise<Workspace> => { | ||
| 52 | const payload = args.payload as UpsertWorkspacePayload; | ||
| 53 | const now = Date.now(); | ||
| 54 | const workspaceId = payload.id ?? `ws_${crypto.randomUUID()}`; | ||
| 55 | |||
| 56 | const existing = await ctx.db | ||
| 57 | .query("workspaces") | ||
| 58 | .withIndex("by_domainId", (q) => q.eq("id", workspaceId)) | ||
| 59 | .unique(); | ||
| 60 | |||
| 61 | const nextWorkspace = decodeWorkspace({ | ||
| 62 | id: workspaceId, | ||
| 63 | organizationId: payload.organizationId, | ||
| 64 | name: payload.name, | ||
| 65 | createdByAccountId: existing?.createdByAccountId ?? null, | ||
| 66 | createdAt: existing?.createdAt ?? now, | ||
| 67 | updatedAt: now, | ||
| 68 | }); | ||
| 69 | |||
| 70 | if (existing) { | ||
| 71 | await ctx.db.patch(existing._id, nextWorkspace); | ||
| 72 | } else { | ||
| 73 | await ctx.db.insert("workspaces", nextWorkspace); | ||
| 74 | } | ||
| 75 | |||
| 76 | return nextWorkspace; | ||
| 77 | }, | ||
| 78 | }); | ||
| @@ -0,0 +1,7 @@ | |||
| 1 | import workflow from "@convex-dev/workflow/convex.config.js"; | ||
| 2 | import { defineApp } from "convex/server"; | ||
| 3 | |||
| 4 | const app = defineApp(); | ||
| 5 | app.use(workflow); | ||
| 6 | |||
| 7 | export default app; | ||
| @@ -0,0 +1,102 @@ | |||
| 1 | const encryptedPrefix = "enc:v1:"; | ||
| 2 | |||
| 3 | const encoder = new TextEncoder(); | ||
| 4 | const decoder = new TextDecoder(); | ||
| 5 | |||
| 6 | const bytesToBase64 = (bytes: Uint8Array): string => { | ||
| 7 | let binary = ""; | ||
| 8 | for (const byte of bytes) { | ||
| 9 | binary += String.fromCharCode(byte); | ||
| 10 | } | ||
| 11 | return btoa(binary); | ||
| 12 | }; | ||
| 13 | |||
| 14 | const base64ToBytes = (base64: string): Uint8Array => { | ||
| 15 | const binary = atob(base64); | ||
| 16 | const bytes = new Uint8Array(binary.length); | ||
| 17 | for (let i = 0; i < binary.length; i += 1) { | ||
| 18 | bytes[i] = binary.charCodeAt(i); | ||
| 19 | } | ||
| 20 | return bytes; | ||
| 21 | }; | ||
| 22 | |||
| 23 | const resolveEncryptionPassphrase = (): string => { | ||
| 24 | const passphrase = process.env.CREDENTIAL_ENCRYPTION_KEY?.trim() ?? ""; | ||
| 25 | if (passphrase.length === 0) { | ||
| 26 | throw new Error("Encrypted credential storage requires CREDENTIAL_ENCRYPTION_KEY"); | ||
| 27 | } | ||
| 28 | |||
| 29 | return passphrase; | ||
| 30 | }; | ||
| 31 | |||
| 32 | const deriveAesKey = async (): Promise<CryptoKey> => { | ||
| 33 | const passphraseBytes = encoder.encode(resolveEncryptionPassphrase()); | ||
| 34 | const hashBuffer = await crypto.subtle.digest("SHA-256", passphraseBytes); | ||
| 35 | return await crypto.subtle.importKey( | ||
| 36 | "raw", | ||
| 37 | hashBuffer, | ||
| 38 | { | ||
| 39 | name: "AES-GCM", | ||
| 40 | }, | ||
| 41 | false, | ||
| 42 | ["encrypt", "decrypt"], | ||
| 43 | ); | ||
| 44 | }; | ||
| 45 | |||
| 46 | const parseEncryptedValue = (value: string): { iv: Uint8Array; cipher: Uint8Array } | null => { | ||
| 47 | if (!value.startsWith(encryptedPrefix)) { | ||
| 48 | return null; | ||
| 49 | } | ||
| 50 | |||
| 51 | const payload = value.slice(encryptedPrefix.length); | ||
| 52 | const parts = payload.split(":"); | ||
| 53 | if (parts.length !== 2) { | ||
| 54 | return null; | ||
| 55 | } | ||
| 56 | |||
| 57 | try { | ||
| 58 | return { | ||
| 59 | iv: base64ToBytes(parts[0] ?? ""), | ||
| 60 | cipher: base64ToBytes(parts[1] ?? ""), | ||
| 61 | }; | ||
| 62 | } catch { | ||
| 63 | return null; | ||
| 64 | } | ||
| 65 | }; | ||
| 66 | |||
| 67 | export const isEncryptedSecret = (value: string): boolean => | ||
| 68 | value.startsWith(encryptedPrefix); | ||
| 69 | |||
| 70 | export const encryptSecretValue = async (plainText: string): Promise<string> => { | ||
| 71 | const key = await deriveAesKey(); | ||
| 72 | const iv = crypto.getRandomValues(new Uint8Array(12)); | ||
| 73 | const encrypted = await crypto.subtle.encrypt( | ||
| 74 | { | ||
| 75 | name: "AES-GCM", | ||
| 76 | iv, | ||
| 77 | }, | ||
| 78 | key, | ||
| 79 | encoder.encode(plainText), | ||
| 80 | ); | ||
| 81 | |||
| 82 | return `${encryptedPrefix}${bytesToBase64(iv)}:${bytesToBase64(new Uint8Array(encrypted))}`; | ||
| 83 | }; | ||
| 84 | |||
| 85 | export const decryptSecretValue = async (storedValue: string): Promise<string> => { | ||
| 86 | const parsed = parseEncryptedValue(storedValue); | ||
| 87 | if (parsed === null) { | ||
| 88 | throw new Error("Credential secret is not encrypted"); | ||
| 89 | } | ||
| 90 | |||
| 91 | const key = await deriveAesKey(); | ||
| 92 | const decrypted = await crypto.subtle.decrypt( | ||
| 93 | { | ||
| 94 | name: "AES-GCM", | ||
| 95 | iv: parsed.iv as unknown as BufferSource, | ||
| 96 | }, | ||
| 97 | key, | ||
| 98 | parsed.cipher as unknown as BufferSource, | ||
| 99 | ); | ||
| 100 | |||
| 101 | return decoder.decode(decrypted); | ||
| 102 | }; | ||
| @@ -0,0 +1,198 @@ | |||
| 1 | import { | ||
| 2 | buildCredentialHeaders, | ||
| 3 | CredentialResolverError, | ||
| 4 | extractCredentialResolutionContext, | ||
| 5 | makeCredentialResolver, | ||
| 6 | selectCredentialBinding, | ||
| 7 | selectOAuthAccessToken, | ||
| 8 | sourceIdFromSourceKey, | ||
| 9 | type ResolveToolCredentials, | ||
| 10 | } from "@executor-v2/engine"; | ||
| 11 | import { | ||
| 12 | OAuthTokenSchema, | ||
| 13 | SourceCredentialBindingSchema, | ||
| 14 | type OAuthToken, | ||
| 15 | type SourceCredentialBinding, | ||
| 16 | } from "@executor-v2/schema"; | ||
| 17 | import { v } from "convex/values"; | ||
| 18 | import * as Effect from "effect/Effect"; | ||
| 19 | import * as Schema from "effect/Schema"; | ||
| 20 | |||
| 21 | import { api } from "./_generated/api"; | ||
| 22 | import { query, type ActionCtx } from "./_generated/server"; | ||
| 23 | import { decryptSecretValue } from "./credential_crypto"; | ||
| 24 | |||
| 25 | const decodeSourceCredentialBinding = Schema.decodeUnknownSync( | ||
| 26 | SourceCredentialBindingSchema, | ||
| 27 | ); | ||
| 28 | const decodeOAuthToken = Schema.decodeUnknownSync(OAuthTokenSchema); | ||
| 29 | |||
| 30 | const stripConvexSystemFields = ( | ||
| 31 | value: Record<string, unknown>, | ||
| 32 | ): Record<string, unknown> => { | ||
| 33 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 34 | return rest; | ||
| 35 | }; | ||
| 36 | |||
| 37 | export const listCredentialBindingsForSource = query({ | ||
| 38 | args: { | ||
| 39 | workspaceId: v.string(), | ||
| 40 | sourceKey: v.string(), | ||
| 41 | organizationId: v.optional(v.string()), | ||
| 42 | accountId: v.optional(v.string()), | ||
| 43 | }, | ||
| 44 | handler: async (ctx, args): Promise<Array<SourceCredentialBinding>> => { | ||
| 45 | const rows = await ctx.db | ||
| 46 | .query("sourceCredentialBindings") | ||
| 47 | .withIndex("by_sourceKey", (q) => q.eq("sourceKey", args.sourceKey)) | ||
| 48 | .collect(); | ||
| 49 | |||
| 50 | return rows | ||
| 51 | .map((row) => | ||
| 52 | decodeSourceCredentialBinding( | ||
| 53 | stripConvexSystemFields(row as unknown as Record<string, unknown>), | ||
| 54 | ), | ||
| 55 | ) | ||
| 56 | .filter((binding) => { | ||
| 57 | if (binding.scopeType === "workspace") { | ||
| 58 | return binding.workspaceId === args.workspaceId; | ||
| 59 | } | ||
| 60 | |||
| 61 | if (binding.scopeType === "organization") { | ||
| 62 | return args.organizationId | ||
| 63 | ? binding.organizationId === args.organizationId | ||
| 64 | : true; | ||
| 65 | } | ||
| 66 | |||
| 67 | return args.accountId ? binding.accountId === args.accountId : true; | ||
| 68 | }); | ||
| 69 | }, | ||
| 70 | }); | ||
| 71 | |||
| 72 | export const listOAuthTokensForSource = query({ | ||
| 73 | args: { | ||
| 74 | workspaceId: v.string(), | ||
| 75 | sourceId: v.string(), | ||
| 76 | }, | ||
| 77 | handler: async (ctx, args): Promise<Array<OAuthToken>> => { | ||
| 78 | const rows = await ctx.db | ||
| 79 | .query("oauthTokens") | ||
| 80 | .withIndex("by_sourceId", (q) => q.eq("sourceId", args.sourceId)) | ||
| 81 | .collect(); | ||
| 82 | |||
| 83 | return rows | ||
| 84 | .map((row) => | ||
| 85 | decodeOAuthToken( | ||
| 86 | stripConvexSystemFields(row as unknown as Record<string, unknown>), | ||
| 87 | ), | ||
| 88 | ) | ||
| 89 | .filter((token) => token.workspaceId === args.workspaceId); | ||
| 90 | }, | ||
| 91 | }); | ||
| 92 | |||
| 93 | const toCredentialResolverError = ( | ||
| 94 | operation: string, | ||
| 95 | message: string, | ||
| 96 | details: string | null, | ||
| 97 | ): CredentialResolverError => | ||
| 98 | new CredentialResolverError({ | ||
| 99 | operation, | ||
| 100 | message, | ||
| 101 | details, | ||
| 102 | }); | ||
| 103 | |||
| 104 | const runQueryEffect = <T>( | ||
| 105 | operation: string, | ||
| 106 | run: () => Promise<T>, | ||
| 107 | ): Effect.Effect<T, CredentialResolverError> => | ||
| 108 | Effect.tryPromise({ | ||
| 109 | try: run, | ||
| 110 | catch: (cause) => | ||
| 111 | toCredentialResolverError( | ||
| 112 | operation, | ||
| 113 | "Convex credential query failed", | ||
| 114 | String(cause), | ||
| 115 | ), | ||
| 116 | }); | ||
| 117 | |||
| 118 | const requireLocalSecretProvider = ( | ||
| 119 | secretProvider: SourceCredentialBinding["secretProvider"], | ||
| 120 | ): "local" => { | ||
| 121 | if (secretProvider !== "local") { | ||
| 122 | throw new Error("Convex credentials require secretProvider 'local'"); | ||
| 123 | } | ||
| 124 | |||
| 125 | return "local"; | ||
| 126 | }; | ||
| 127 | |||
| 128 | export const createConvexResolveToolCredentials = ( | ||
| 129 | ctx: ActionCtx, | ||
| 130 | ): ResolveToolCredentials => | ||
| 131 | makeCredentialResolver((input) => | ||
| 132 | Effect.gen(function* () { | ||
| 133 | const context = extractCredentialResolutionContext(input); | ||
| 134 | if (context === null) { | ||
| 135 | return { | ||
| 136 | headers: {}, | ||
| 137 | }; | ||
| 138 | } | ||
| 139 | |||
| 140 | const bindings = yield* runQueryEffect( | ||
| 141 | "list_credential_bindings", | ||
| 142 | () => | ||
| 143 | ctx.runQuery(api.credential_resolver.listCredentialBindingsForSource, { | ||
| 144 | workspaceId: context.workspaceId, | ||
| 145 | sourceKey: context.sourceKey, | ||
| 146 | organizationId: context.organizationId ?? undefined, | ||
| 147 | accountId: context.accountId ?? undefined, | ||
| 148 | }), | ||
| 149 | ); | ||
| 150 | |||
| 151 | const binding = selectCredentialBinding(bindings, context); | ||
| 152 | if (binding === null) { | ||
| 153 | return { | ||
| 154 | headers: {}, | ||
| 155 | }; | ||
| 156 | } | ||
| 157 | |||
| 158 | const sourceId = sourceIdFromSourceKey(context.sourceKey); | ||
| 159 | |||
| 160 | const oauthAccessToken = | ||
| 161 | binding.provider === "oauth2" && sourceId | ||
| 162 | ? yield* runQueryEffect("list_oauth_tokens", () => | ||
| 163 | ctx | ||
| 164 | .runQuery(api.credential_resolver.listOAuthTokensForSource, { | ||
| 165 | workspaceId: context.workspaceId, | ||
| 166 | sourceId, | ||
| 167 | }) | ||
| 168 | .then((tokens) => | ||
| 169 | selectOAuthAccessToken(tokens, context, sourceId), | ||
| 170 | ), | ||
| 171 | ) | ||
| 172 | : null; | ||
| 173 | |||
| 174 | requireLocalSecretProvider(binding.secretProvider); | ||
| 175 | |||
| 176 | const secretRef = yield* Effect.tryPromise({ | ||
| 177 | try: () => decryptSecretValue(binding.secretRef), | ||
| 178 | catch: (cause) => | ||
| 179 | toCredentialResolverError( | ||
| 180 | "decrypt_credential_secret", | ||
| 181 | "Convex credential decryption failed", | ||
| 182 | String(cause), | ||
| 183 | ), | ||
| 184 | }); | ||
| 185 | |||
| 186 | return { | ||
| 187 | headers: buildCredentialHeaders( | ||
| 188 | { | ||
| 189 | ...binding, | ||
| 190 | secretRef, | ||
| 191 | }, | ||
| 192 | { | ||
| 193 | oauthAccessToken, | ||
| 194 | }, | ||
| 195 | ), | ||
| 196 | }; | ||
| 197 | }), | ||
| 198 | ); | ||
| @@ -0,0 +1,1489 @@ | |||
| 1 | import { describe, expect, it } from "@effect/vitest"; | ||
| 2 | import { extractOpenApiManifest } from "@executor-v2/management-api"; | ||
| 3 | import { convexTest } from "convex-test"; | ||
| 4 | import * as Effect from "effect/Effect"; | ||
| 5 | |||
| 6 | import { api, internal } from "./_generated/api"; | ||
| 7 | import { executeRunImpl } from "./executor"; | ||
| 8 | import schema from "./schema"; | ||
| 9 | |||
| 10 | const runtimeInternal = internal as any; | ||
| 11 | |||
| 12 | const setup = () => | ||
| 13 | convexTest(schema, { | ||
| 14 | "./http.ts": () => import("./http"), | ||
| 15 | "./mcp.ts": () => import("./mcp"), | ||
| 16 | "./executor.ts": () => import("./executor"), | ||
| 17 | "./runtimeCallbacks.ts": () => import("./runtimeCallbacks"), | ||
| 18 | "./source_tool_registry.ts": () => import("./source_tool_registry"), | ||
| 19 | "./task_runs.ts": () => import("./task_runs"), | ||
| 20 | "./control_plane/storage.ts": () => import("./control_plane/storage"), | ||
| 21 | "./control_plane/credentials.ts": () => import("./control_plane/credentials"), | ||
| 22 | "./control_plane/sources.ts": () => import("./control_plane/sources"), | ||
| 23 | "./control_plane/tool_registry.ts": () => import("./control_plane/tool_registry"), | ||
| 24 | "./control_plane/openapi_ingest.ts": () => import("./control_plane/openapi_ingest"), | ||
| 25 | "./workflow.ts": () => import("./workflow"), | ||
| 26 | "./controlPlane.ts": () => import("./controlPlane"), | ||
| 27 | "./_generated/api.js": () => import("./_generated/api.js"), | ||
| 28 | }); | ||
| 29 | |||
| 30 | const ensureWorkspace = async ( | ||
| 31 | t: ReturnType<typeof setup>, | ||
| 32 | workspaceId: string, | ||
| 33 | organizationId: string, | ||
| 34 | ): Promise<void> => { | ||
| 35 | await t.mutation(api.controlPlane.upsertWorkspace, { | ||
| 36 | payload: { | ||
| 37 | id: workspaceId, | ||
| 38 | organizationId, | ||
| 39 | name: workspaceId, | ||
| 40 | }, | ||
| 41 | }); | ||
| 42 | }; | ||
| 43 | |||
| 44 | describe("Convex executor and control-plane", () => { | ||
| 45 | it.effect("executes code via executeRunImpl", () => | ||
| 46 | Effect.gen(function* () { | ||
| 47 | const originalEnv = { | ||
| 48 | runUrl: process.env.CLOUDFLARE_SANDBOX_RUN_URL, | ||
| 49 | authToken: process.env.CLOUDFLARE_SANDBOX_AUTH_TOKEN, | ||
| 50 | callbackUrl: process.env.CLOUDFLARE_SANDBOX_CALLBACK_URL, | ||
| 51 | }; | ||
| 52 | const originalFetch = globalThis.fetch; | ||
| 53 | |||
| 54 | try { | ||
| 55 | process.env.CLOUDFLARE_SANDBOX_RUN_URL = "https://sandbox.local/run"; | ||
| 56 | process.env.CLOUDFLARE_SANDBOX_AUTH_TOKEN = "sandbox-token"; | ||
| 57 | process.env.CLOUDFLARE_SANDBOX_CALLBACK_URL = "https://convex.local/callback"; | ||
| 58 | |||
| 59 | globalThis.fetch = (async ( | ||
| 60 | input: RequestInfo | URL, | ||
| 61 | init?: RequestInit, | ||
| 62 | ) => { | ||
| 63 | const url = typeof input === "string" ? input : input.toString(); | ||
| 64 | if (url !== "https://sandbox.local/run") { | ||
| 65 | throw new Error(`Unexpected URL: ${url}`); | ||
| 66 | } | ||
| 67 | |||
| 68 | expect(init?.method).toBe("POST"); | ||
| 69 | const headers = new Headers(init?.headers as HeadersInit | undefined); | ||
| 70 | expect(headers.get("authorization")).toBe( | ||
| 71 | "Bearer sandbox-token", | ||
| 72 | ); | ||
| 73 | |||
| 74 | return new Response( | ||
| 75 | JSON.stringify({ | ||
| 76 | status: "completed", | ||
| 77 | result: 42, | ||
| 78 | }), | ||
| 79 | { | ||
| 80 | status: 200, | ||
| 81 | headers: { | ||
| 82 | "content-type": "application/json", | ||
| 83 | }, | ||
| 84 | }, | ||
| 85 | ); | ||
| 86 | }) as unknown as typeof fetch; | ||
| 87 | |||
| 88 | const result = yield* executeRunImpl({ | ||
| 89 | code: "return 6 * 7;", | ||
| 90 | }); | ||
| 91 | |||
| 92 | expect(result.status).toBe("completed"); | ||
| 93 | expect(result.result).toBe(42); | ||
| 94 | } finally { | ||
| 95 | globalThis.fetch = originalFetch; | ||
| 96 | |||
| 97 | if (originalEnv.runUrl === undefined) { | ||
| 98 | delete process.env.CLOUDFLARE_SANDBOX_RUN_URL; | ||
| 99 | } else { | ||
| 100 | process.env.CLOUDFLARE_SANDBOX_RUN_URL = originalEnv.runUrl; | ||
| 101 | } | ||
| 102 | |||
| 103 | if (originalEnv.authToken === undefined) { | ||
| 104 | delete process.env.CLOUDFLARE_SANDBOX_AUTH_TOKEN; | ||
| 105 | } else { | ||
| 106 | process.env.CLOUDFLARE_SANDBOX_AUTH_TOKEN = originalEnv.authToken; | ||
| 107 | } | ||
| 108 | |||
| 109 | if (originalEnv.callbackUrl === undefined) { | ||
| 110 | delete process.env.CLOUDFLARE_SANDBOX_CALLBACK_URL; | ||
| 111 | } else { | ||
| 112 | process.env.CLOUDFLARE_SANDBOX_CALLBACK_URL = originalEnv.callbackUrl; | ||
| 113 | } | ||
| 114 | } | ||
| 115 | }), | ||
| 116 | ); | ||
| 117 | |||
| 118 | it.effect("upserts, lists, and removes sources", () => | ||
| 119 | Effect.gen(function* () { | ||
| 120 | const t = setup(); | ||
| 121 | |||
| 122 | const added = (yield* Effect.tryPromise(() => | ||
| 123 | t.action(api.controlPlane.upsertSource as any, { | ||
| 124 | workspaceId: "ws_1", | ||
| 125 | payload: { | ||
| 126 | id: "src_1", | ||
| 127 | name: "Weather", | ||
| 128 | kind: "openapi", | ||
| 129 | endpoint: "https://example.com/openapi.json", | ||
| 130 | enabled: true, | ||
| 131 | configJson: "{}", | ||
| 132 | status: "draft", | ||
| 133 | sourceHash: null, | ||
| 134 | lastError: null, | ||
| 135 | }, | ||
| 136 | }), | ||
| 137 | )) as { | ||
| 138 | id: string; | ||
| 139 | workspaceId: string; | ||
| 140 | name: string; | ||
| 141 | }; | ||
| 142 | |||
| 143 | yield* Effect.tryPromise(() => t.finishAllScheduledFunctions(() => {})); | ||
| 144 | |||
| 145 | expect(added.id).toBe("src_1"); | ||
| 146 | expect(added.workspaceId).toBe("ws_1"); | ||
| 147 | expect(added.name).toBe("Weather"); | ||
| 148 | |||
| 149 | const listed = (yield* Effect.tryPromise(() => | ||
| 150 | t.query(api.controlPlane.listSources, { | ||
| 151 | workspaceId: "ws_1", | ||
| 152 | }), | ||
| 153 | )) as Array<{ | ||
| 154 | id: string; | ||
| 155 | }>; | ||
| 156 | |||
| 157 | expect(listed).toHaveLength(1); | ||
| 158 | expect(listed[0]?.id).toBe("src_1"); | ||
| 159 | |||
| 160 | const removed = (yield* Effect.tryPromise(() => | ||
| 161 | t.mutation(api.controlPlane.removeSource, { | ||
| 162 | workspaceId: "ws_1", | ||
| 163 | sourceId: "src_1", | ||
| 164 | }), | ||
| 165 | )) as { | ||
| 166 | removed: boolean; | ||
| 167 | }; | ||
| 168 | |||
| 169 | expect(removed.removed).toBe(true); | ||
| 170 | |||
| 171 | const listedAfterRemove = (yield* Effect.tryPromise(() => | ||
| 172 | t.query(api.controlPlane.listSources, { | ||
| 173 | workspaceId: "ws_1", | ||
| 174 | }), | ||
| 175 | )) as Array<unknown>; | ||
| 176 | |||
| 177 | expect(listedAfterRemove).toHaveLength(0); | ||
| 178 | }), | ||
| 179 | ); | ||
| 180 | |||
| 181 | it.effect("upserts, lists, and removes credentials, policies, and storage", () => | ||
| 182 | Effect.gen(function* () { | ||
| 183 | const t = setup(); | ||
| 184 | |||
| 185 | yield* Effect.tryPromise(() => ensureWorkspace(t, "ws_1", "org_1")); | ||
| 186 | |||
| 187 | const addedCredential = (yield* Effect.tryPromise(() => | ||
| 188 | t.action(api.controlPlane.upsertCredentialBinding, { | ||
| 189 | workspaceId: "ws_1", | ||
| 190 | payload: { | ||
| 191 | id: "credential_binding_1", | ||
| 192 | credentialId: "cred_1", | ||
| 193 | scopeType: "workspace", | ||
| 194 | sourceKey: "github", | ||
| 195 | provider: "bearer", | ||
| 196 | secretRef: "secret://github/token", | ||
| 197 | accountId: null, | ||
| 198 | additionalHeadersJson: null, | ||
| 199 | boundAuthFingerprint: null, | ||
| 200 | }, | ||
| 201 | }), | ||
| 202 | )) as { | ||
| 203 | id: string; | ||
| 204 | workspaceId: string | null; | ||
| 205 | }; | ||
| 206 | |||
| 207 | expect(addedCredential.id).toBe("credential_binding_1"); | ||
| 208 | expect(addedCredential.workspaceId).toBe("ws_1"); | ||
| 209 | |||
| 210 | const listedCredentials = (yield* Effect.tryPromise(() => | ||
| 211 | t.query(api.controlPlane.listCredentialBindings, { | ||
| 212 | workspaceId: "ws_1", | ||
| 213 | }), | ||
| 214 | )) as Array<{ | ||
| 215 | id: string; | ||
| 216 | }>; | ||
| 217 | |||
| 218 | expect(listedCredentials).toHaveLength(1); | ||
| 219 | expect(listedCredentials[0]?.id).toBe("credential_binding_1"); | ||
| 220 | |||
| 221 | const removedCredential = (yield* Effect.tryPromise(() => | ||
| 222 | t.mutation(api.controlPlane.removeCredentialBinding, { | ||
| 223 | workspaceId: "ws_1", | ||
| 224 | credentialBindingId: "credential_binding_1", | ||
| 225 | }), | ||
| 226 | )) as { | ||
| 227 | removed: boolean; | ||
| 228 | }; | ||
| 229 | |||
| 230 | expect(removedCredential.removed).toBe(true); | ||
| 231 | |||
| 232 | const listedCredentialsAfterRemove = (yield* Effect.tryPromise(() => | ||
| 233 | t.query(api.controlPlane.listCredentialBindings, { | ||
| 234 | workspaceId: "ws_1", | ||
| 235 | }), | ||
| 236 | )) as Array<unknown>; | ||
| 237 | |||
| 238 | expect(listedCredentialsAfterRemove).toHaveLength(0); | ||
| 239 | |||
| 240 | const addedPolicy = (yield* Effect.tryPromise(() => | ||
| 241 | t.mutation(api.controlPlane.upsertPolicy, { | ||
| 242 | workspaceId: "ws_1", | ||
| 243 | payload: { | ||
| 244 | id: "pol_1", | ||
| 245 | toolPathPattern: "github.repos.*", | ||
| 246 | decision: "require_approval", | ||
| 247 | }, | ||
| 248 | }), | ||
| 249 | )) as { | ||
| 250 | id: string; | ||
| 251 | workspaceId: string; | ||
| 252 | }; | ||
| 253 | |||
| 254 | expect(addedPolicy.id).toBe("pol_1"); | ||
| 255 | expect(addedPolicy.workspaceId).toBe("ws_1"); | ||
| 256 | |||
| 257 | const listedPolicies = (yield* Effect.tryPromise(() => | ||
| 258 | t.query(api.controlPlane.listPolicies, { | ||
| 259 | workspaceId: "ws_1", | ||
| 260 | }), | ||
| 261 | )) as Array<{ | ||
| 262 | id: string; | ||
| 263 | }>; | ||
| 264 | |||
| 265 | expect(listedPolicies).toHaveLength(1); | ||
| 266 | expect(listedPolicies[0]?.id).toBe("pol_1"); | ||
| 267 | |||
| 268 | const removedPolicy = (yield* Effect.tryPromise(() => | ||
| 269 | t.mutation(api.controlPlane.removePolicy, { | ||
| 270 | workspaceId: "ws_1", | ||
| 271 | policyId: "pol_1", | ||
| 272 | }), | ||
| 273 | )) as { | ||
| 274 | removed: boolean; | ||
| 275 | }; | ||
| 276 | |||
| 277 | expect(removedPolicy.removed).toBe(true); | ||
| 278 | |||
| 279 | const listedPoliciesAfterRemove = (yield* Effect.tryPromise(() => | ||
| 280 | t.query(api.controlPlane.listPolicies, { | ||
| 281 | workspaceId: "ws_1", | ||
| 282 | }), | ||
| 283 | )) as Array<unknown>; | ||
| 284 | |||
| 285 | expect(listedPoliciesAfterRemove).toHaveLength(0); | ||
| 286 | |||
| 287 | const openedStorage = (yield* Effect.tryPromise(() => | ||
| 288 | t.mutation(api.controlPlane.openStorageInstance, { | ||
| 289 | workspaceId: "ws_1", | ||
| 290 | payload: { | ||
| 291 | scopeType: "workspace", | ||
| 292 | durability: "ephemeral", | ||
| 293 | provider: "agentfs-local", | ||
| 294 | purpose: "test storage", | ||
| 295 | ttlHours: 1, | ||
| 296 | sessionId: "session_1", | ||
| 297 | }, | ||
| 298 | }), | ||
| 299 | )) as { | ||
| 300 | id: string; | ||
| 301 | status: string; | ||
| 302 | }; | ||
| 303 | |||
| 304 | expect(openedStorage.status).toBe("active"); | ||
| 305 | |||
| 306 | const listedStorage = (yield* Effect.tryPromise(() => | ||
| 307 | t.query(api.controlPlane.listStorageInstances, { | ||
| 308 | workspaceId: "ws_1", | ||
| 309 | }), | ||
| 310 | )) as Array<{ | ||
| 311 | id: string; | ||
| 312 | }>; | ||
| 313 | |||
| 314 | expect(listedStorage).toHaveLength(1); | ||
| 315 | expect(listedStorage[0]?.id).toBe(openedStorage.id); | ||
| 316 | |||
| 317 | yield* Effect.tryPromise(() => | ||
| 318 | t.mutation(runtimeInternal.control_plane.storage.upsertStorageFileEntry, { | ||
| 319 | workspaceId: "ws_1", | ||
| 320 | storageInstanceId: openedStorage.id, | ||
| 321 | payload: { | ||
| 322 | path: "/notes/today.txt", | ||
| 323 | content: "hello convex storage", | ||
| 324 | }, | ||
| 325 | }), | ||
| 326 | ); | ||
| 327 | |||
| 328 | const listedDirectory = (yield* Effect.tryPromise(() => | ||
| 329 | t.query(api.controlPlane.listStorageDirectory, { | ||
| 330 | workspaceId: "ws_1", | ||
| 331 | storageInstanceId: openedStorage.id, | ||
| 332 | payload: { | ||
| 333 | path: "/", | ||
| 334 | }, | ||
| 335 | }), | ||
| 336 | )) as { | ||
| 337 | path: string; | ||
| 338 | entries: ReadonlyArray<{ | ||
| 339 | name: string; | ||
| 340 | path: string; | ||
| 341 | kind: "file" | "directory"; | ||
| 342 | }>; | ||
| 343 | }; | ||
| 344 | |||
| 345 | expect(listedDirectory.path).toBe("/"); | ||
| 346 | expect(listedDirectory.entries).toHaveLength(1); | ||
| 347 | expect(listedDirectory.entries[0]?.name).toBe("notes"); | ||
| 348 | expect(listedDirectory.entries[0]?.kind).toBe("directory"); | ||
| 349 | |||
| 350 | const listedNestedDirectory = (yield* Effect.tryPromise(() => | ||
| 351 | t.query(api.controlPlane.listStorageDirectory, { | ||
| 352 | workspaceId: "ws_1", | ||
| 353 | storageInstanceId: openedStorage.id, | ||
| 354 | payload: { | ||
| 355 | path: "/notes", | ||
| 356 | }, | ||
| 357 | }), | ||
| 358 | )) as { | ||
| 359 | path: string; | ||
| 360 | entries: ReadonlyArray<{ | ||
| 361 | name: string; | ||
| 362 | path: string; | ||
| 363 | kind: "file" | "directory"; | ||
| 364 | }>; | ||
| 365 | }; | ||
| 366 | |||
| 367 | expect(listedNestedDirectory.path).toBe("/notes"); | ||
| 368 | expect(listedNestedDirectory.entries).toHaveLength(1); | ||
| 369 | expect(listedNestedDirectory.entries[0]?.name).toBe("today.txt"); | ||
| 370 | expect(listedNestedDirectory.entries[0]?.kind).toBe("file"); | ||
| 371 | |||
| 372 | const readStorageFile = (yield* Effect.tryPromise(() => | ||
| 373 | t.query(api.controlPlane.readStorageFile, { | ||
| 374 | workspaceId: "ws_1", | ||
| 375 | storageInstanceId: openedStorage.id, | ||
| 376 | payload: { | ||
| 377 | path: "/notes/today.txt", | ||
| 378 | encoding: "utf8", | ||
| 379 | }, | ||
| 380 | }), | ||
| 381 | )) as { | ||
| 382 | content: string; | ||
| 383 | }; | ||
| 384 | |||
| 385 | expect(readStorageFile.content).toBe("hello convex storage"); | ||
| 386 | |||
| 387 | yield* Effect.tryPromise(() => | ||
| 388 | t.mutation(runtimeInternal.control_plane.storage.upsertStorageKvEntry, { | ||
| 389 | workspaceId: "ws_1", | ||
| 390 | storageInstanceId: openedStorage.id, | ||
| 391 | payload: { | ||
| 392 | key: "feature.enabled", | ||
| 393 | valueJson: "true", | ||
| 394 | }, | ||
| 395 | }), | ||
| 396 | ); | ||
| 397 | |||
| 398 | const listedKv = (yield* Effect.tryPromise(() => | ||
| 399 | t.query(api.controlPlane.listStorageKv, { | ||
| 400 | workspaceId: "ws_1", | ||
| 401 | storageInstanceId: openedStorage.id, | ||
| 402 | payload: { | ||
| 403 | prefix: "feature.", | ||
| 404 | }, | ||
| 405 | }), | ||
| 406 | )) as { | ||
| 407 | items: Array<{ | ||
| 408 | key: string; | ||
| 409 | value: unknown; | ||
| 410 | }>; | ||
| 411 | }; | ||
| 412 | |||
| 413 | expect(listedKv.items).toHaveLength(1); | ||
| 414 | expect(listedKv.items[0]?.key).toBe("feature.enabled"); | ||
| 415 | expect(listedKv.items[0]?.value).toBe(true); | ||
| 416 | |||
| 417 | yield* Effect.tryPromise(() => | ||
| 418 | t.mutation(api.controlPlane.queryStorageSql, { | ||
| 419 | workspaceId: "ws_1", | ||
| 420 | storageInstanceId: openedStorage.id, | ||
| 421 | payload: { | ||
| 422 | sql: "CREATE TABLE IF NOT EXISTS kv_store (key TEXT PRIMARY KEY, value TEXT NOT NULL);", | ||
| 423 | }, | ||
| 424 | }), | ||
| 425 | ); | ||
| 426 | |||
| 427 | yield* Effect.tryPromise(() => | ||
| 428 | t.mutation(api.controlPlane.queryStorageSql, { | ||
| 429 | workspaceId: "ws_1", | ||
| 430 | storageInstanceId: openedStorage.id, | ||
| 431 | payload: { | ||
| 432 | sql: "INSERT INTO kv_store (key, value) VALUES ('hello', 'world');", | ||
| 433 | }, | ||
| 434 | }), | ||
| 435 | ); | ||
| 436 | |||
| 437 | const queriedSql = (yield* Effect.tryPromise(() => | ||
| 438 | t.mutation(api.controlPlane.queryStorageSql, { | ||
| 439 | workspaceId: "ws_1", | ||
| 440 | storageInstanceId: openedStorage.id, | ||
| 441 | payload: { | ||
| 442 | sql: "SELECT key, value FROM kv_store LIMIT 10;", | ||
| 443 | }, | ||
| 444 | }), | ||
| 445 | )) as { | ||
| 446 | rowCount: number; | ||
| 447 | columns: Array<string>; | ||
| 448 | rows: Array<Record<string, unknown>>; | ||
| 449 | }; | ||
| 450 | |||
| 451 | expect(queriedSql.rowCount).toBe(1); | ||
| 452 | expect(queriedSql.columns).toEqual(["key", "value"]); | ||
| 453 | expect(queriedSql.rows[0]).toEqual({ key: "hello", value: "world" }); | ||
| 454 | |||
| 455 | const closedStorage = (yield* Effect.tryPromise(() => | ||
| 456 | t.mutation(api.controlPlane.closeStorageInstance, { | ||
| 457 | workspaceId: "ws_1", | ||
| 458 | storageInstanceId: openedStorage.id, | ||
| 459 | }), | ||
| 460 | )) as { | ||
| 461 | id: string; | ||
| 462 | status: string; | ||
| 463 | }; | ||
| 464 | |||
| 465 | expect(closedStorage.id).toBe(openedStorage.id); | ||
| 466 | expect(closedStorage.status).toBe("closed"); | ||
| 467 | |||
| 468 | const removedStorage = (yield* Effect.tryPromise(() => | ||
| 469 | t.mutation(api.controlPlane.removeStorageInstance, { | ||
| 470 | workspaceId: "ws_1", | ||
| 471 | storageInstanceId: openedStorage.id, | ||
| 472 | }), | ||
| 473 | )) as { | ||
| 474 | removed: boolean; | ||
| 475 | }; | ||
| 476 | |||
| 477 | expect(removedStorage.removed).toBe(true); | ||
| 478 | |||
| 479 | const listedStorageAfterRemove = (yield* Effect.tryPromise(() => | ||
| 480 | t.query(api.controlPlane.listStorageInstances, { | ||
| 481 | workspaceId: "ws_1", | ||
| 482 | }), | ||
| 483 | )) as Array<unknown>; | ||
| 484 | |||
| 485 | expect(listedStorageAfterRemove).toHaveLength(0); | ||
| 486 | }), | ||
| 487 | ); | ||
| 488 | |||
| 489 | it.effect("upserts and lists organizations/workspaces and tool views", () => | ||
| 490 | Effect.gen(function* () { | ||
| 491 | const t = setup(); | ||
| 492 | |||
| 493 | const organization = (yield* Effect.tryPromise(() => | ||
| 494 | t.mutation(api.controlPlane.upsertOrganization, { | ||
| 495 | payload: { | ||
| 496 | id: "org_1", | ||
| 497 | slug: "acme", | ||
| 498 | name: "Acme Inc", | ||
| 499 | status: "active", | ||
| 500 | }, | ||
| 501 | }), | ||
| 502 | )) as { | ||
| 503 | id: string; | ||
| 504 | name: string; | ||
| 505 | }; | ||
| 506 | |||
| 507 | expect(organization.id).toBe("org_1"); | ||
| 508 | expect(organization.name).toBe("Acme Inc"); | ||
| 509 | |||
| 510 | const organizations = (yield* Effect.tryPromise(() => | ||
| 511 | t.query(api.controlPlane.listOrganizations, {}), | ||
| 512 | )) as Array<{ | ||
| 513 | id: string; | ||
| 514 | }>; | ||
| 515 | |||
| 516 | expect(organizations).toHaveLength(1); | ||
| 517 | expect(organizations[0]?.id).toBe("org_1"); | ||
| 518 | |||
| 519 | const workspace = (yield* Effect.tryPromise(() => | ||
| 520 | t.mutation(api.controlPlane.upsertWorkspace, { | ||
| 521 | payload: { | ||
| 522 | id: "ws_1", | ||
| 523 | organizationId: "org_1", | ||
| 524 | name: "Primary Workspace", | ||
| 525 | }, | ||
| 526 | }), | ||
| 527 | )) as { | ||
| 528 | id: string; | ||
| 529 | organizationId: string; | ||
| 530 | }; | ||
| 531 | |||
| 532 | expect(workspace.id).toBe("ws_1"); | ||
| 533 | expect(workspace.organizationId).toBe("org_1"); | ||
| 534 | |||
| 535 | const workspaces = (yield* Effect.tryPromise(() => | ||
| 536 | t.query(api.controlPlane.listWorkspaces, {}), | ||
| 537 | )) as Array<{ | ||
| 538 | id: string; | ||
| 539 | }>; | ||
| 540 | |||
| 541 | expect(workspaces).toHaveLength(1); | ||
| 542 | expect(workspaces[0]?.id).toBe("ws_1"); | ||
| 543 | |||
| 544 | const nowForOpenApiSource = Date.now(); | ||
| 545 | yield* Effect.tryPromise(() => | ||
| 546 | t.run(async (ctx) => { | ||
| 547 | await ctx.db.insert("sources", { | ||
| 548 | id: "src_1", | ||
| 549 | workspaceId: "ws_1", | ||
| 550 | name: "Weather API", | ||
| 551 | kind: "openapi", | ||
| 552 | endpoint: "https://example.com/openapi.json", | ||
| 553 | enabled: true, | ||
| 554 | configJson: "{}", | ||
| 555 | status: "draft", | ||
| 556 | sourceHash: null, | ||
| 557 | lastError: null, | ||
| 558 | createdAt: nowForOpenApiSource, | ||
| 559 | updatedAt: nowForOpenApiSource, | ||
| 560 | }); | ||
| 561 | }), | ||
| 562 | ); | ||
| 563 | |||
| 564 | const manifest = yield* extractOpenApiManifest("Weather API", { | ||
| 565 | openapi: "3.0.0", | ||
| 566 | info: { | ||
| 567 | title: "Weather API", | ||
| 568 | version: "1.0.0", | ||
| 569 | }, | ||
| 570 | paths: { | ||
| 571 | "/weather": { | ||
| 572 | get: { | ||
| 573 | operationId: "getWeather", | ||
| 574 | responses: { | ||
| 575 | "200": { | ||
| 576 | description: "ok", | ||
| 577 | }, | ||
| 578 | }, | ||
| 579 | }, | ||
| 580 | }, | ||
| 581 | }, | ||
| 582 | }); | ||
| 583 | |||
| 584 | const now = Date.now(); | ||
| 585 | const openApiArtifactMeta = (yield* Effect.tryPromise(() => | ||
| 586 | t.mutation(runtimeInternal.control_plane.tool_registry.upsertArtifactMeta, { | ||
| 587 | protocol: "openapi", | ||
| 588 | contentHash: manifest.sourceHash, | ||
| 589 | extractorVersion: "openapi_v2", | ||
| 590 | toolCount: manifest.tools.length, | ||
| 591 | refHintTableJson: manifest.refHintTable ? JSON.stringify(manifest.refHintTable) : null, | ||
| 592 | }), | ||
| 593 | )) as { | ||
| 594 | artifactId: string; | ||
| 595 | created: boolean; | ||
| 596 | }; | ||
| 597 | |||
| 598 | yield* Effect.tryPromise(() => | ||
| 599 | t.mutation(runtimeInternal.control_plane.tool_registry.putArtifactToolsBatch, { | ||
| 600 | artifactId: openApiArtifactMeta.artifactId, | ||
| 601 | protocol: "openapi", | ||
| 602 | insertOnly: true, | ||
| 603 | tools: manifest.tools.map((tool) => ({ | ||
| 604 | toolId: tool.toolId, | ||
| 605 | name: tool.name, | ||
| 606 | description: tool.description, | ||
| 607 | canonicalPath: `${tool.method.toUpperCase()} ${tool.path}`, | ||
| 608 | operationHash: tool.operationHash, | ||
| 609 | invocationJson: JSON.stringify(tool.invocation), | ||
| 610 | inputSchemaJson: tool.typing?.inputSchemaJson ?? null, | ||
| 611 | outputSchemaJson: tool.typing?.outputSchemaJson ?? null, | ||
| 612 | metadataJson: JSON.stringify({ | ||
| 613 | method: tool.method, | ||
| 614 | path: tool.path, | ||
| 615 | }), | ||
| 616 | })), | ||
| 617 | }), | ||
| 618 | ); | ||
| 619 | |||
| 620 | yield* Effect.tryPromise(() => | ||
| 621 | t.mutation(runtimeInternal.control_plane.tool_registry.bindSourceToArtifact, { | ||
| 622 | workspaceId: "ws_1", | ||
| 623 | sourceId: "src_1", | ||
| 624 | artifactId: openApiArtifactMeta.artifactId, | ||
| 625 | }), | ||
| 626 | ); | ||
| 627 | |||
| 628 | yield* Effect.tryPromise(() => | ||
| 629 | t.mutation(runtimeInternal.control_plane.tool_registry.replaceWorkspaceSourceToolIndex, { | ||
| 630 | workspaceId: "ws_1", | ||
| 631 | sourceId: "src_1", | ||
| 632 | sourceName: "Weather API", | ||
| 633 | sourceKind: "openapi", | ||
| 634 | artifactId: openApiArtifactMeta.artifactId, | ||
| 635 | namespace: "weather_api_src_1", | ||
| 636 | refHintTableJson: manifest.refHintTable ? JSON.stringify(manifest.refHintTable) : null, | ||
| 637 | rows: manifest.tools.map((tool) => ({ | ||
| 638 | toolId: tool.toolId, | ||
| 639 | protocol: "openapi", | ||
| 640 | method: tool.method, | ||
| 641 | path: `weather_api_src_1.${tool.toolId}`, | ||
| 642 | name: tool.name, | ||
| 643 | description: tool.description, | ||
| 644 | searchText: `weather api ${tool.name.toLowerCase()} ${tool.path.toLowerCase()} ${tool.method.toLowerCase()}`, | ||
| 645 | operationHash: tool.operationHash, | ||
| 646 | approvalMode: "auto", | ||
| 647 | status: "active", | ||
| 648 | })), | ||
| 649 | }), | ||
| 650 | ); | ||
| 651 | |||
| 652 | const workspaceTools = (yield* Effect.tryPromise(() => | ||
| 653 | t.query(api.controlPlane.listWorkspaceTools, { | ||
| 654 | workspaceId: "ws_1", | ||
| 655 | }), | ||
| 656 | )) as Array<{ | ||
| 657 | sourceId: string; | ||
| 658 | }>; | ||
| 659 | |||
| 660 | expect(workspaceTools).toHaveLength(1); | ||
| 661 | expect(workspaceTools[0]?.sourceId).toBe("src_1"); | ||
| 662 | |||
| 663 | const sourceTools = (yield* Effect.tryPromise(() => | ||
| 664 | t.query(api.controlPlane.listSourceTools, { | ||
| 665 | workspaceId: "ws_1", | ||
| 666 | sourceId: "src_1", | ||
| 667 | }), | ||
| 668 | )) as Array<{ | ||
| 669 | sourceId: string; | ||
| 670 | }>; | ||
| 671 | |||
| 672 | expect(sourceTools).toHaveLength(1); | ||
| 673 | expect(sourceTools[0]?.sourceId).toBe("src_1"); | ||
| 674 | |||
| 675 | const nowForGraphqlSource = Date.now(); | ||
| 676 | yield* Effect.tryPromise(() => | ||
| 677 | t.run(async (ctx) => { | ||
| 678 | await ctx.db.insert("sources", { | ||
| 679 | id: "src_graphql_1", | ||
| 680 | workspaceId: "ws_1", | ||
| 681 | name: "Linear API", | ||
| 682 | kind: "graphql", | ||
| 683 | endpoint: "https://api.linear.app/graphql", | ||
| 684 | enabled: true, | ||
| 685 | configJson: "{}", | ||
| 686 | status: "draft", | ||
| 687 | sourceHash: null, | ||
| 688 | lastError: null, | ||
| 689 | createdAt: nowForGraphqlSource, | ||
| 690 | updatedAt: nowForGraphqlSource, | ||
| 691 | }); | ||
| 692 | }), | ||
| 693 | ); | ||
| 694 | |||
| 695 | const graphqlArtifactMeta = (yield* Effect.tryPromise(() => | ||
| 696 | t.mutation(runtimeInternal.control_plane.tool_registry.upsertArtifactMeta, { | ||
| 697 | protocol: "graphql", | ||
| 698 | contentHash: "graphql_schema_hash_1", | ||
| 699 | extractorVersion: "graphql_v1", | ||
| 700 | toolCount: 2, | ||
| 701 | refHintTableJson: null, | ||
| 702 | }), | ||
| 703 | )) as { | ||
| 704 | artifactId: string; | ||
| 705 | created: boolean; | ||
| 706 | }; | ||
| 707 | |||
| 708 | expect(graphqlArtifactMeta.created).toBe(true); | ||
| 709 | |||
| 710 | yield* Effect.tryPromise(() => | ||
| 711 | t.mutation(runtimeInternal.control_plane.tool_registry.putArtifactToolsBatch, { | ||
| 712 | artifactId: graphqlArtifactMeta.artifactId, | ||
| 713 | protocol: "graphql", | ||
| 714 | insertOnly: true, | ||
| 715 | tools: [ | ||
| 716 | { | ||
| 717 | toolId: "linear.graphql", | ||
| 718 | name: "Linear GraphQL", | ||
| 719 | description: "Run raw GraphQL queries against Linear", | ||
| 720 | canonicalPath: "raw.graphql", | ||
| 721 | operationHash: "raw_hash", | ||
| 722 | invocationJson: "{}", | ||
| 723 | metadataJson: JSON.stringify({ | ||
| 724 | operationType: "raw", | ||
| 725 | fieldName: "graphql", | ||
| 726 | }), | ||
| 727 | }, | ||
| 728 | { | ||
| 729 | toolId: "linear.query.viewer", | ||
| 730 | name: "viewer", | ||
| 731 | description: "Current viewer", | ||
| 732 | canonicalPath: "query.viewer", | ||
| 733 | operationHash: "viewer_hash", | ||
| 734 | invocationJson: "{}", | ||
| 735 | metadataJson: JSON.stringify({ | ||
| 736 | operationType: "query", | ||
| 737 | fieldName: "viewer", | ||
| 738 | }), | ||
| 739 | }, | ||
| 740 | ], | ||
| 741 | }), | ||
| 742 | ); | ||
| 743 | |||
| 744 | yield* Effect.tryPromise(() => | ||
| 745 | t.mutation(runtimeInternal.control_plane.tool_registry.bindSourceToArtifact, { | ||
| 746 | workspaceId: "ws_1", | ||
| 747 | sourceId: "src_graphql_1", | ||
| 748 | artifactId: graphqlArtifactMeta.artifactId, | ||
| 749 | }), | ||
| 750 | ); | ||
| 751 | |||
| 752 | yield* Effect.tryPromise(() => | ||
| 753 | t.mutation(runtimeInternal.control_plane.tool_registry.replaceWorkspaceSourceToolIndex, { | ||
| 754 | workspaceId: "ws_1", | ||
| 755 | sourceId: "src_graphql_1", | ||
| 756 | sourceName: "Linear API", | ||
| 757 | sourceKind: "graphql", | ||
| 758 | artifactId: graphqlArtifactMeta.artifactId, | ||
| 759 | namespace: "linear_api_phql_1", | ||
| 760 | refHintTableJson: null, | ||
| 761 | rows: [ | ||
| 762 | { | ||
| 763 | toolId: "linear.graphql", | ||
| 764 | protocol: "graphql", | ||
| 765 | method: "post", | ||
| 766 | path: "linear_api_phql_1.linear.graphql", | ||
| 767 | name: "Linear GraphQL", | ||
| 768 | description: "Run raw GraphQL queries against Linear", | ||
| 769 | searchText: "linear api graphql linear.graphql", | ||
| 770 | operationHash: "raw_hash", | ||
| 771 | approvalMode: "auto", | ||
| 772 | status: "active", | ||
| 773 | }, | ||
| 774 | { | ||
| 775 | toolId: "linear.query.viewer", | ||
| 776 | protocol: "graphql", | ||
| 777 | method: "post", | ||
| 778 | path: "linear_api_phql_1.linear.query.viewer", | ||
| 779 | name: "viewer", | ||
| 780 | description: "Current viewer", | ||
| 781 | searchText: "linear api graphql viewer linear.query.viewer", | ||
| 782 | operationHash: "viewer_hash", | ||
| 783 | approvalMode: "auto", | ||
| 784 | status: "active", | ||
| 785 | }, | ||
| 786 | ], | ||
| 787 | }), | ||
| 788 | ); | ||
| 789 | |||
| 790 | const graphqlSourceTools = (yield* Effect.tryPromise(() => | ||
| 791 | t.query(api.controlPlane.listSourceTools, { | ||
| 792 | workspaceId: "ws_1", | ||
| 793 | sourceId: "src_graphql_1", | ||
| 794 | }), | ||
| 795 | )) as Array<{ | ||
| 796 | sourceId: string; | ||
| 797 | toolId: string; | ||
| 798 | method: string; | ||
| 799 | }>; | ||
| 800 | |||
| 801 | expect(graphqlSourceTools).toHaveLength(2); | ||
| 802 | expect(graphqlSourceTools[0]?.sourceId).toBe("src_graphql_1"); | ||
| 803 | expect(graphqlSourceTools[0]?.method).toBe("post"); | ||
| 804 | |||
| 805 | const workspaceToolsWithGraphql = (yield* Effect.tryPromise(() => | ||
| 806 | t.query(api.controlPlane.listWorkspaceTools, { | ||
| 807 | workspaceId: "ws_1", | ||
| 808 | }), | ||
| 809 | )) as Array<{ | ||
| 810 | sourceId: string; | ||
| 811 | }>; | ||
| 812 | |||
| 813 | expect(workspaceToolsWithGraphql.some((tool) => tool.sourceId === "src_graphql_1")).toBe( | ||
| 814 | true, | ||
| 815 | ); | ||
| 816 | |||
| 817 | const nowForMcpSource = Date.now(); | ||
| 818 | |||
| 819 | yield* Effect.tryPromise(() => | ||
| 820 | t.run(async (ctx) => { | ||
| 821 | await ctx.db.insert("sources", { | ||
| 822 | id: "src_mcp_1", | ||
| 823 | workspaceId: "ws_1", | ||
| 824 | name: "Deepwiki", | ||
| 825 | kind: "mcp", | ||
| 826 | endpoint: "https://example.com/mcp", | ||
| 827 | enabled: true, | ||
| 828 | configJson: "{}", | ||
| 829 | status: "draft", | ||
| 830 | sourceHash: null, | ||
| 831 | lastError: null, | ||
| 832 | createdAt: nowForMcpSource, | ||
| 833 | updatedAt: nowForMcpSource, | ||
| 834 | }); | ||
| 835 | }), | ||
| 836 | ); | ||
| 837 | |||
| 838 | const mcpArtifactMeta = (yield* Effect.tryPromise(() => | ||
| 839 | t.mutation(runtimeInternal.control_plane.tool_registry.upsertArtifactMeta, { | ||
| 840 | protocol: "mcp", | ||
| 841 | contentHash: "mcp_source_hash_1", | ||
| 842 | extractorVersion: "mcp_v1", | ||
| 843 | toolCount: 1, | ||
| 844 | refHintTableJson: null, | ||
| 845 | }), | ||
| 846 | )) as { | ||
| 847 | artifactId: string; | ||
| 848 | created: boolean; | ||
| 849 | }; | ||
| 850 | |||
| 851 | expect(mcpArtifactMeta.created).toBe(true); | ||
| 852 | |||
| 853 | yield* Effect.tryPromise(() => | ||
| 854 | t.mutation(runtimeInternal.control_plane.tool_registry.putArtifactToolsBatch, { | ||
| 855 | artifactId: mcpArtifactMeta.artifactId, | ||
| 856 | protocol: "mcp", | ||
| 857 | insertOnly: true, | ||
| 858 | tools: [ | ||
| 859 | { | ||
| 860 | toolId: "deepwiki.mcp.search_docs", | ||
| 861 | name: "search_docs", | ||
| 862 | description: "Search docs", | ||
| 863 | canonicalPath: "search_docs", | ||
| 864 | operationHash: "mcp_hash_1", | ||
| 865 | invocationJson: "{}", | ||
| 866 | metadataJson: JSON.stringify({ | ||
| 867 | toolName: "search_docs", | ||
| 868 | }), | ||
| 869 | }, | ||
| 870 | ], | ||
| 871 | }), | ||
| 872 | ); | ||
| 873 | |||
| 874 | yield* Effect.tryPromise(() => | ||
| 875 | t.mutation(runtimeInternal.control_plane.tool_registry.bindSourceToArtifact, { | ||
| 876 | workspaceId: "ws_1", | ||
| 877 | sourceId: "src_mcp_1", | ||
| 878 | artifactId: mcpArtifactMeta.artifactId, | ||
| 879 | }), | ||
| 880 | ); | ||
| 881 | |||
| 882 | yield* Effect.tryPromise(() => | ||
| 883 | t.mutation(runtimeInternal.control_plane.tool_registry.replaceWorkspaceSourceToolIndex, { | ||
| 884 | workspaceId: "ws_1", | ||
| 885 | sourceId: "src_mcp_1", | ||
| 886 | sourceName: "Deepwiki", | ||
| 887 | sourceKind: "mcp", | ||
| 888 | artifactId: mcpArtifactMeta.artifactId, | ||
| 889 | namespace: "deepwiki_mcp_1", | ||
| 890 | refHintTableJson: null, | ||
| 891 | rows: [ | ||
| 892 | { | ||
| 893 | toolId: "deepwiki.mcp.search_docs", | ||
| 894 | protocol: "mcp", | ||
| 895 | method: "post", | ||
| 896 | path: "deepwiki_mcp_1.deepwiki.mcp.search_docs", | ||
| 897 | name: "search_docs", | ||
| 898 | description: "Search docs", | ||
| 899 | searchText: "deepwiki mcp search docs", | ||
| 900 | operationHash: "mcp_hash_1", | ||
| 901 | approvalMode: "auto", | ||
| 902 | status: "active", | ||
| 903 | }, | ||
| 904 | ], | ||
| 905 | }), | ||
| 906 | ); | ||
| 907 | |||
| 908 | const mcpSourceTools = (yield* Effect.tryPromise(() => | ||
| 909 | t.query(api.controlPlane.listSourceTools, { | ||
| 910 | workspaceId: "ws_1", | ||
| 911 | sourceId: "src_mcp_1", | ||
| 912 | }), | ||
| 913 | )) as Array<{ | ||
| 914 | sourceId: string; | ||
| 915 | path: string; | ||
| 916 | }>; | ||
| 917 | |||
| 918 | expect(mcpSourceTools).toHaveLength(1); | ||
| 919 | expect(mcpSourceTools[0]?.sourceId).toBe("src_mcp_1"); | ||
| 920 | expect(mcpSourceTools[0]?.path).toContain("deepwiki.mcp.search_docs"); | ||
| 921 | |||
| 922 | const workspaceToolsWithMcp = (yield* Effect.tryPromise(() => | ||
| 923 | t.query(api.controlPlane.listWorkspaceTools, { | ||
| 924 | workspaceId: "ws_1", | ||
| 925 | }), | ||
| 926 | )) as Array<{ | ||
| 927 | sourceId: string; | ||
| 928 | }>; | ||
| 929 | |||
| 930 | expect(workspaceToolsWithMcp.some((tool) => tool.sourceId === "src_mcp_1")).toBe(true); | ||
| 931 | |||
| 932 | const sourceToolsFromWrongWorkspace = (yield* Effect.tryPromise(() => | ||
| 933 | t.query(api.controlPlane.listSourceTools, { | ||
| 934 | workspaceId: "ws_2", | ||
| 935 | sourceId: "src_1", | ||
| 936 | }), | ||
| 937 | )) as Array<unknown>; | ||
| 938 | |||
| 939 | expect(sourceToolsFromWrongWorkspace).toHaveLength(0); | ||
| 940 | }), | ||
| 941 | ); | ||
| 942 | |||
| 943 | it.effect("marks graphql sources auth_required when introspection is unauthorized", () => | ||
| 944 | Effect.gen(function* () { | ||
| 945 | const t = setup(); | ||
| 946 | const originalFetch = globalThis.fetch; | ||
| 947 | |||
| 948 | yield* Effect.tryPromise(() => ensureWorkspace(t, "ws_auth", "org_auth")); | ||
| 949 | |||
| 950 | globalThis.fetch = (async () => | ||
| 951 | new Response( | ||
| 952 | JSON.stringify({ | ||
| 953 | errors: [ | ||
| 954 | { | ||
| 955 | message: "Unauthorized", | ||
| 956 | }, | ||
| 957 | ], | ||
| 958 | }), | ||
| 959 | { | ||
| 960 | status: 401, | ||
| 961 | headers: { | ||
| 962 | "content-type": "application/json", | ||
| 963 | }, | ||
| 964 | }, | ||
| 965 | )) as unknown as typeof fetch; | ||
| 966 | |||
| 967 | try { | ||
| 968 | const now = Date.now(); | ||
| 969 | |||
| 970 | yield* Effect.tryPromise(() => | ||
| 971 | t.run(async (ctx) => { | ||
| 972 | await ctx.db.insert("sources", { | ||
| 973 | id: "src_graphql_auth_1", | ||
| 974 | workspaceId: "ws_auth", | ||
| 975 | name: "Linear API", | ||
| 976 | kind: "graphql", | ||
| 977 | endpoint: "https://api.linear.app/graphql", | ||
| 978 | enabled: true, | ||
| 979 | configJson: "{}", | ||
| 980 | status: "draft", | ||
| 981 | sourceHash: null, | ||
| 982 | lastError: null, | ||
| 983 | createdAt: now, | ||
| 984 | updatedAt: now, | ||
| 985 | }); | ||
| 986 | }), | ||
| 987 | ); | ||
| 988 | |||
| 989 | yield* Effect.tryPromise(() => | ||
| 990 | t.action(runtimeInternal.control_plane.openapi_ingest.ingestSourceArtifact, { | ||
| 991 | workspaceId: "ws_auth", | ||
| 992 | sourceId: "src_graphql_auth_1", | ||
| 993 | }), | ||
| 994 | ); | ||
| 995 | |||
| 996 | const sources = (yield* Effect.tryPromise(() => | ||
| 997 | t.query(api.controlPlane.listSources, { | ||
| 998 | workspaceId: "ws_auth", | ||
| 999 | }), | ||
| 1000 | )) as Array<{ | ||
| 1001 | status: string; | ||
| 1002 | lastError: string | null; | ||
| 1003 | }>; | ||
| 1004 | |||
| 1005 | expect(sources).toHaveLength(1); | ||
| 1006 | expect(sources[0]?.status).toBe("auth_required"); | ||
| 1007 | expect(sources[0]?.lastError?.toLowerCase()).toContain("unauthor"); | ||
| 1008 | } finally { | ||
| 1009 | globalThis.fetch = originalFetch; | ||
| 1010 | } | ||
| 1011 | }), | ||
| 1012 | ); | ||
| 1013 | |||
| 1014 | it.effect("uses credential bindings when ingesting graphql sources", () => | ||
| 1015 | Effect.gen(function* () { | ||
| 1016 | const t = setup(); | ||
| 1017 | const originalFetch = globalThis.fetch; | ||
| 1018 | |||
| 1019 | yield* Effect.tryPromise(() => ensureWorkspace(t, "ws_cred", "org_cred")); | ||
| 1020 | |||
| 1021 | globalThis.fetch = (async (_input: unknown, init?: RequestInit) => { | ||
| 1022 | const authHeader = new Headers(init?.headers).get("authorization"); | ||
| 1023 | if (authHeader !== "Bearer linear_token") { | ||
| 1024 | return new Response( | ||
| 1025 | JSON.stringify({ | ||
| 1026 | errors: [ | ||
| 1027 | { | ||
| 1028 | message: "Unauthorized", | ||
| 1029 | }, | ||
| 1030 | ], | ||
| 1031 | }), | ||
| 1032 | { | ||
| 1033 | status: 401, | ||
| 1034 | headers: { | ||
| 1035 | "content-type": "application/json", | ||
| 1036 | }, | ||
| 1037 | }, | ||
| 1038 | ); | ||
| 1039 | } | ||
| 1040 | |||
| 1041 | const bodyText = typeof init?.body === "string" ? init.body : "{}"; | ||
| 1042 | const payload = JSON.parse(bodyText) as { | ||
| 1043 | query?: string; | ||
| 1044 | variables?: { | ||
| 1045 | name?: string; | ||
| 1046 | }; | ||
| 1047 | }; | ||
| 1048 | |||
| 1049 | if (payload.query?.includes("SchemaRoots")) { | ||
| 1050 | return new Response( | ||
| 1051 | JSON.stringify({ | ||
| 1052 | data: { | ||
| 1053 | __schema: { | ||
| 1054 | queryType: { name: "Query" }, | ||
| 1055 | mutationType: null, | ||
| 1056 | }, | ||
| 1057 | }, | ||
| 1058 | }), | ||
| 1059 | { | ||
| 1060 | status: 200, | ||
| 1061 | headers: { | ||
| 1062 | "content-type": "application/json", | ||
| 1063 | }, | ||
| 1064 | }, | ||
| 1065 | ); | ||
| 1066 | } | ||
| 1067 | |||
| 1068 | if (payload.query?.includes("RootFields") && payload.variables?.name === "Query") { | ||
| 1069 | return new Response( | ||
| 1070 | JSON.stringify({ | ||
| 1071 | data: { | ||
| 1072 | __type: { | ||
| 1073 | name: "Query", | ||
| 1074 | fields: [ | ||
| 1075 | { | ||
| 1076 | name: "viewer", | ||
| 1077 | description: "Current viewer", | ||
| 1078 | args: [], | ||
| 1079 | }, | ||
| 1080 | ], | ||
| 1081 | }, | ||
| 1082 | }, | ||
| 1083 | }), | ||
| 1084 | { | ||
| 1085 | status: 200, | ||
| 1086 | headers: { | ||
| 1087 | "content-type": "application/json", | ||
| 1088 | }, | ||
| 1089 | }, | ||
| 1090 | ); | ||
| 1091 | } | ||
| 1092 | |||
| 1093 | return new Response( | ||
| 1094 | JSON.stringify({ | ||
| 1095 | data: { | ||
| 1096 | __type: { | ||
| 1097 | name: payload.variables?.name ?? "Unknown", | ||
| 1098 | fields: [], | ||
| 1099 | }, | ||
| 1100 | }, | ||
| 1101 | }), | ||
| 1102 | { | ||
| 1103 | status: 200, | ||
| 1104 | headers: { | ||
| 1105 | "content-type": "application/json", | ||
| 1106 | }, | ||
| 1107 | }, | ||
| 1108 | ); | ||
| 1109 | }) as unknown as typeof fetch; | ||
| 1110 | |||
| 1111 | try { | ||
| 1112 | const now = Date.now(); | ||
| 1113 | |||
| 1114 | yield* Effect.tryPromise(() => | ||
| 1115 | t.action(api.controlPlane.upsertCredentialBinding, { | ||
| 1116 | workspaceId: "ws_cred", | ||
| 1117 | payload: { | ||
| 1118 | id: "credential_binding_linear", | ||
| 1119 | credentialId: "cred_linear", | ||
| 1120 | scopeType: "workspace", | ||
| 1121 | sourceKey: "source:src_graphql_cred_1", | ||
| 1122 | provider: "bearer", | ||
| 1123 | secretRef: "linear_token", | ||
| 1124 | accountId: null, | ||
| 1125 | additionalHeadersJson: null, | ||
| 1126 | boundAuthFingerprint: null, | ||
| 1127 | }, | ||
| 1128 | }), | ||
| 1129 | ); | ||
| 1130 | |||
| 1131 | yield* Effect.tryPromise(() => | ||
| 1132 | t.run(async (ctx) => { | ||
| 1133 | await ctx.db.insert("sources", { | ||
| 1134 | id: "src_graphql_cred_1", | ||
| 1135 | workspaceId: "ws_cred", | ||
| 1136 | name: "Linear API", | ||
| 1137 | kind: "graphql", | ||
| 1138 | endpoint: "https://api.linear.app/graphql", | ||
| 1139 | enabled: true, | ||
| 1140 | configJson: "{}", | ||
| 1141 | status: "draft", | ||
| 1142 | sourceHash: null, | ||
| 1143 | lastError: null, | ||
| 1144 | createdAt: now, | ||
| 1145 | updatedAt: now, | ||
| 1146 | }); | ||
| 1147 | }), | ||
| 1148 | ); | ||
| 1149 | |||
| 1150 | yield* Effect.tryPromise(() => | ||
| 1151 | t.action(runtimeInternal.control_plane.openapi_ingest.ingestSourceArtifact, { | ||
| 1152 | workspaceId: "ws_cred", | ||
| 1153 | sourceId: "src_graphql_cred_1", | ||
| 1154 | }), | ||
| 1155 | ); | ||
| 1156 | |||
| 1157 | const sources = (yield* Effect.tryPromise(() => | ||
| 1158 | t.query(api.controlPlane.listSources, { | ||
| 1159 | workspaceId: "ws_cred", | ||
| 1160 | }), | ||
| 1161 | )) as Array<{ | ||
| 1162 | status: string; | ||
| 1163 | sourceHash: string | null; | ||
| 1164 | }>; | ||
| 1165 | |||
| 1166 | expect(sources).toHaveLength(1); | ||
| 1167 | expect(sources[0]?.status).toBe("connected"); | ||
| 1168 | expect(sources[0]?.sourceHash).toBeTypeOf("string"); | ||
| 1169 | |||
| 1170 | const sourceTools = (yield* Effect.tryPromise(() => | ||
| 1171 | t.query(api.controlPlane.listSourceTools, { | ||
| 1172 | workspaceId: "ws_cred", | ||
| 1173 | sourceId: "src_graphql_cred_1", | ||
| 1174 | }), | ||
| 1175 | )) as Array<{ | ||
| 1176 | toolId: string; | ||
| 1177 | }>; | ||
| 1178 | |||
| 1179 | expect(sourceTools.length).toBeGreaterThan(0); | ||
| 1180 | } finally { | ||
| 1181 | globalThis.fetch = originalFetch; | ||
| 1182 | } | ||
| 1183 | }), | ||
| 1184 | ); | ||
| 1185 | |||
| 1186 | it.effect("ingests mcp sources with credential headers", () => | ||
| 1187 | Effect.gen(function* () { | ||
| 1188 | const t = setup(); | ||
| 1189 | const originalFetch = globalThis.fetch; | ||
| 1190 | |||
| 1191 | yield* Effect.tryPromise(() => | ||
| 1192 | ensureWorkspace(t, "ws_mcp_ingest", "org_mcp_ingest") | ||
| 1193 | ); | ||
| 1194 | |||
| 1195 | globalThis.fetch = (async (_input: unknown, init?: RequestInit) => { | ||
| 1196 | const authHeader = new Headers(init?.headers).get("authorization"); | ||
| 1197 | if (authHeader !== "Bearer mcp_token") { | ||
| 1198 | return new Response( | ||
| 1199 | JSON.stringify({ | ||
| 1200 | error: { | ||
| 1201 | code: 401, | ||
| 1202 | message: "Unauthorized", | ||
| 1203 | }, | ||
| 1204 | }), | ||
| 1205 | { | ||
| 1206 | status: 401, | ||
| 1207 | headers: { | ||
| 1208 | "content-type": "application/json", | ||
| 1209 | }, | ||
| 1210 | }, | ||
| 1211 | ); | ||
| 1212 | } | ||
| 1213 | |||
| 1214 | const bodyText = typeof init?.body === "string" ? init.body : "{}"; | ||
| 1215 | const payload = JSON.parse(bodyText) as { | ||
| 1216 | id?: string | number; | ||
| 1217 | method?: string; | ||
| 1218 | }; | ||
| 1219 | |||
| 1220 | if (payload.method === "initialize") { | ||
| 1221 | return new Response( | ||
| 1222 | JSON.stringify({ | ||
| 1223 | jsonrpc: "2.0", | ||
| 1224 | id: payload.id, | ||
| 1225 | result: { | ||
| 1226 | protocolVersion: "2025-03-26", | ||
| 1227 | capabilities: { | ||
| 1228 | tools: {}, | ||
| 1229 | }, | ||
| 1230 | serverInfo: { | ||
| 1231 | name: "fake-mcp", | ||
| 1232 | version: "0.1.0", | ||
| 1233 | }, | ||
| 1234 | }, | ||
| 1235 | }), | ||
| 1236 | { | ||
| 1237 | status: 200, | ||
| 1238 | headers: { | ||
| 1239 | "content-type": "application/json", | ||
| 1240 | }, | ||
| 1241 | }, | ||
| 1242 | ); | ||
| 1243 | } | ||
| 1244 | |||
| 1245 | if (payload.method === "notifications/initialized") { | ||
| 1246 | return new Response(null, { | ||
| 1247 | status: 204, | ||
| 1248 | }); | ||
| 1249 | } | ||
| 1250 | |||
| 1251 | if (payload.method === "tools/list") { | ||
| 1252 | return new Response( | ||
| 1253 | JSON.stringify({ | ||
| 1254 | jsonrpc: "2.0", | ||
| 1255 | id: payload.id, | ||
| 1256 | result: { | ||
| 1257 | tools: [ | ||
| 1258 | { | ||
| 1259 | name: "search_docs", | ||
| 1260 | description: "Search docs", | ||
| 1261 | inputSchema: { | ||
| 1262 | type: "object", | ||
| 1263 | properties: {}, | ||
| 1264 | }, | ||
| 1265 | outputSchema: { | ||
| 1266 | type: "object", | ||
| 1267 | properties: { | ||
| 1268 | results: { | ||
| 1269 | type: "array", | ||
| 1270 | }, | ||
| 1271 | }, | ||
| 1272 | }, | ||
| 1273 | }, | ||
| 1274 | ], | ||
| 1275 | }, | ||
| 1276 | }), | ||
| 1277 | { | ||
| 1278 | status: 200, | ||
| 1279 | headers: { | ||
| 1280 | "content-type": "application/json", | ||
| 1281 | }, | ||
| 1282 | }, | ||
| 1283 | ); | ||
| 1284 | } | ||
| 1285 | |||
| 1286 | return new Response( | ||
| 1287 | JSON.stringify({ | ||
| 1288 | jsonrpc: "2.0", | ||
| 1289 | id: payload.id, | ||
| 1290 | error: { | ||
| 1291 | code: -32601, | ||
| 1292 | message: "Method not found", | ||
| 1293 | }, | ||
| 1294 | }), | ||
| 1295 | { | ||
| 1296 | status: 200, | ||
| 1297 | headers: { | ||
| 1298 | "content-type": "application/json", | ||
| 1299 | }, | ||
| 1300 | }, | ||
| 1301 | ); | ||
| 1302 | }) as unknown as typeof fetch; | ||
| 1303 | |||
| 1304 | try { | ||
| 1305 | const now = Date.now(); | ||
| 1306 | |||
| 1307 | yield* Effect.tryPromise(() => | ||
| 1308 | t.action(api.controlPlane.upsertCredentialBinding, { | ||
| 1309 | workspaceId: "ws_mcp_ingest", | ||
| 1310 | payload: { | ||
| 1311 | id: "credential_binding_mcp", | ||
| 1312 | credentialId: "cred_mcp", | ||
| 1313 | scopeType: "workspace", | ||
| 1314 | sourceKey: "source:src_mcp_ingest_1", | ||
| 1315 | provider: "bearer", | ||
| 1316 | secretRef: "mcp_token", | ||
| 1317 | accountId: null, | ||
| 1318 | additionalHeadersJson: null, | ||
| 1319 | boundAuthFingerprint: null, | ||
| 1320 | }, | ||
| 1321 | }), | ||
| 1322 | ); | ||
| 1323 | |||
| 1324 | yield* Effect.tryPromise(() => | ||
| 1325 | t.run(async (ctx) => { | ||
| 1326 | await ctx.db.insert("sources", { | ||
| 1327 | id: "src_mcp_ingest_1", | ||
| 1328 | workspaceId: "ws_mcp_ingest", | ||
| 1329 | name: "Deepwiki", | ||
| 1330 | kind: "mcp", | ||
| 1331 | endpoint: "https://example.com/mcp", | ||
| 1332 | enabled: true, | ||
| 1333 | configJson: "{}", | ||
| 1334 | status: "draft", | ||
| 1335 | sourceHash: null, | ||
| 1336 | lastError: null, | ||
| 1337 | createdAt: now, | ||
| 1338 | updatedAt: now, | ||
| 1339 | }); | ||
| 1340 | }), | ||
| 1341 | ); | ||
| 1342 | |||
| 1343 | yield* Effect.tryPromise(() => | ||
| 1344 | t.action(runtimeInternal.control_plane.openapi_ingest.ingestSourceArtifact, { | ||
| 1345 | workspaceId: "ws_mcp_ingest", | ||
| 1346 | sourceId: "src_mcp_ingest_1", | ||
| 1347 | }), | ||
| 1348 | ); | ||
| 1349 | |||
| 1350 | const sources = (yield* Effect.tryPromise(() => | ||
| 1351 | t.query(api.controlPlane.listSources, { | ||
| 1352 | workspaceId: "ws_mcp_ingest", | ||
| 1353 | }), | ||
| 1354 | )) as Array<{ | ||
| 1355 | status: string; | ||
| 1356 | sourceHash: string | null; | ||
| 1357 | }>; | ||
| 1358 | |||
| 1359 | expect(sources).toHaveLength(1); | ||
| 1360 | expect(sources[0]?.status).toBe("connected"); | ||
| 1361 | expect(sources[0]?.sourceHash).toBeTypeOf("string"); | ||
| 1362 | |||
| 1363 | const sourceTools = (yield* Effect.tryPromise(() => | ||
| 1364 | t.query(api.controlPlane.listSourceTools, { | ||
| 1365 | workspaceId: "ws_mcp_ingest", | ||
| 1366 | sourceId: "src_mcp_ingest_1", | ||
| 1367 | }), | ||
| 1368 | )) as Array<{ | ||
| 1369 | sourceId: string; | ||
| 1370 | path: string; | ||
| 1371 | }>; | ||
| 1372 | |||
| 1373 | expect(sourceTools).toHaveLength(1); | ||
| 1374 | expect(sourceTools[0]?.sourceId).toBe("src_mcp_ingest_1"); | ||
| 1375 | expect(sourceTools[0]?.path).toContain("deepwiki.mcp.search_docs"); | ||
| 1376 | } finally { | ||
| 1377 | globalThis.fetch = originalFetch; | ||
| 1378 | } | ||
| 1379 | }), | ||
| 1380 | ); | ||
| 1381 | |||
| 1382 | it.effect("persists approval state for runtime tool calls", () => | ||
| 1383 | Effect.gen(function* () { | ||
| 1384 | const t = setup(); | ||
| 1385 | |||
| 1386 | const missingRunDecision = (yield* Effect.tryPromise(() => | ||
| 1387 | t.mutation(runtimeInternal.source_tool_registry.evaluateToolApproval, { | ||
| 1388 | workspaceId: "ws_1", | ||
| 1389 | runId: "run_approval_1", | ||
| 1390 | callId: "call_approval_1", | ||
| 1391 | toolPath: "github.repos.delete", | ||
| 1392 | inputPreviewJson: "{}", | ||
| 1393 | defaultMode: "auto", | ||
| 1394 | requireApprovals: true, | ||
| 1395 | retryAfterMs: 333, | ||
| 1396 | }), | ||
| 1397 | )) as { | ||
| 1398 | kind: "approved" | "pending" | "denied"; | ||
| 1399 | error?: string; | ||
| 1400 | }; | ||
| 1401 | |||
| 1402 | expect(missingRunDecision.kind).toBe("denied"); | ||
| 1403 | expect(missingRunDecision.error).toContain("Unknown run for approval request"); | ||
| 1404 | |||
| 1405 | yield* Effect.tryPromise(() => | ||
| 1406 | t.mutation(runtimeInternal.task_runs.startTaskRun, { | ||
| 1407 | workspaceId: "ws_1", | ||
| 1408 | runId: "run_approval_1", | ||
| 1409 | }), | ||
| 1410 | ); | ||
| 1411 | |||
| 1412 | // First evaluation writes a pending approval row when this runId/callId is unseen. | ||
| 1413 | const firstDecision = (yield* Effect.tryPromise(() => | ||
| 1414 | t.mutation(runtimeInternal.source_tool_registry.evaluateToolApproval, { | ||
| 1415 | workspaceId: "ws_1", | ||
| 1416 | runId: "run_approval_1", | ||
| 1417 | callId: "call_approval_1", | ||
| 1418 | toolPath: "github.repos.delete", | ||
| 1419 | inputPreviewJson: "{}", | ||
| 1420 | defaultMode: "auto", | ||
| 1421 | requireApprovals: true, | ||
| 1422 | retryAfterMs: 333, | ||
| 1423 | }), | ||
| 1424 | )) as { | ||
| 1425 | kind: "approved" | "pending" | "denied"; | ||
| 1426 | approvalId?: string; | ||
| 1427 | retryAfterMs?: number; | ||
| 1428 | }; | ||
| 1429 | |||
| 1430 | expect(firstDecision.kind).toBe("pending"); | ||
| 1431 | expect(firstDecision.retryAfterMs).toBe(333); | ||
| 1432 | expect(firstDecision.approvalId).toBeTypeOf("string"); | ||
| 1433 | |||
| 1434 | const secondDecision = (yield* Effect.tryPromise(() => | ||
| 1435 | t.mutation(runtimeInternal.source_tool_registry.evaluateToolApproval, { | ||
| 1436 | workspaceId: "ws_1", | ||
| 1437 | runId: "run_approval_1", | ||
| 1438 | callId: "call_approval_1", | ||
| 1439 | toolPath: "github.repos.delete", | ||
| 1440 | inputPreviewJson: "{}", | ||
| 1441 | defaultMode: "auto", | ||
| 1442 | requireApprovals: true, | ||
| 1443 | retryAfterMs: 333, | ||
| 1444 | }), | ||
| 1445 | )) as { | ||
| 1446 | kind: "approved" | "pending" | "denied"; | ||
| 1447 | approvalId?: string; | ||
| 1448 | }; | ||
| 1449 | |||
| 1450 | expect(secondDecision.kind).toBe("pending"); | ||
| 1451 | expect(secondDecision.approvalId).toBe(firstDecision.approvalId); | ||
| 1452 | |||
| 1453 | const approvalId = firstDecision.approvalId; | ||
| 1454 | if (!approvalId) { | ||
| 1455 | throw new Error("expected approval id"); | ||
| 1456 | } | ||
| 1457 | |||
| 1458 | yield* Effect.tryPromise(() => | ||
| 1459 | t.mutation(api.controlPlane.resolveApproval, { | ||
| 1460 | workspaceId: "ws_1", | ||
| 1461 | approvalId, | ||
| 1462 | payload: { | ||
| 1463 | status: "approved", | ||
| 1464 | reason: "approved by test", | ||
| 1465 | }, | ||
| 1466 | }), | ||
| 1467 | ); | ||
| 1468 | |||
| 1469 | const resolvedDecision = (yield* Effect.tryPromise(() => | ||
| 1470 | t.mutation(runtimeInternal.source_tool_registry.evaluateToolApproval, { | ||
| 1471 | workspaceId: "ws_1", | ||
| 1472 | runId: "run_approval_1", | ||
| 1473 | callId: "call_approval_1", | ||
| 1474 | toolPath: "github.repos.delete", | ||
| 1475 | inputPreviewJson: "{}", | ||
| 1476 | defaultMode: "auto", | ||
| 1477 | requireApprovals: true, | ||
| 1478 | retryAfterMs: 333, | ||
| 1479 | }), | ||
| 1480 | )) as { | ||
| 1481 | kind: "approved" | "pending" | "denied"; | ||
| 1482 | }; | ||
| 1483 | |||
| 1484 | expect(resolvedDecision).toEqual({ | ||
| 1485 | kind: "approved", | ||
| 1486 | }); | ||
| 1487 | }), | ||
| 1488 | ); | ||
| 1489 | }); | ||
| @@ -0,0 +1,29 @@ | |||
| 1 | import { | ||
| 2 | createRunExecutor, | ||
| 3 | type ToolRegistry, | ||
| 4 | } from "@executor-v2/engine"; | ||
| 5 | import type { ExecuteRunInput, ExecuteRunResult } from "@executor-v2/sdk"; | ||
| 6 | import * as Effect from "effect/Effect"; | ||
| 7 | |||
| 8 | import { createExecuteRuntimeRunInConvex } from "./runtime_execution_port"; | ||
| 9 | |||
| 10 | export type ExecuteRunImplOptions = { | ||
| 11 | toolRegistry?: ToolRegistry; | ||
| 12 | makeRunId?: () => string; | ||
| 13 | }; | ||
| 14 | |||
| 15 | export const executeRunImpl = ( | ||
| 16 | input: ExecuteRunInput, | ||
| 17 | options: ExecuteRunImplOptions = {}, | ||
| 18 | ): Effect.Effect<ExecuteRunResult> => { | ||
| 19 | const runExecutor = createRunExecutor( | ||
| 20 | createExecuteRuntimeRunInConvex({ | ||
| 21 | toolRegistry: options.toolRegistry, | ||
| 22 | }), | ||
| 23 | { | ||
| 24 | makeRunId: options.makeRunId, | ||
| 25 | }, | ||
| 26 | ); | ||
| 27 | |||
| 28 | return runExecutor.executeRun(input); | ||
| 29 | }; | ||
| @@ -0,0 +1,62 @@ | |||
| 1 | import { httpRouter } from "convex/server"; | ||
| 2 | |||
| 3 | import { controlPlaneHttpHandler } from "./controlPlane"; | ||
| 4 | import { mcpHandler } from "./mcp"; | ||
| 5 | import { | ||
| 6 | oauthAuthorizationServerHandler, | ||
| 7 | oauthProtectedResourceHandler, | ||
| 8 | } from "./mcp_auth"; | ||
| 9 | import { handleToolCallHttp } from "./runtimeCallbacks"; | ||
| 10 | |||
| 11 | const http = httpRouter(); | ||
| 12 | |||
| 13 | http.route({ path: "/v1/mcp", method: "POST", handler: mcpHandler }); | ||
| 14 | http.route({ path: "/v1/mcp", method: "GET", handler: mcpHandler }); | ||
| 15 | http.route({ path: "/v1/mcp", method: "DELETE", handler: mcpHandler }); | ||
| 16 | http.route({ | ||
| 17 | path: "/.well-known/oauth-protected-resource", | ||
| 18 | method: "GET", | ||
| 19 | handler: oauthProtectedResourceHandler, | ||
| 20 | }); | ||
| 21 | http.route({ | ||
| 22 | path: "/.well-known/oauth-authorization-server", | ||
| 23 | method: "GET", | ||
| 24 | handler: oauthAuthorizationServerHandler, | ||
| 25 | }); | ||
| 26 | http.route({ | ||
| 27 | path: "/v1/runtime/tool-call", | ||
| 28 | method: "POST", | ||
| 29 | handler: handleToolCallHttp, | ||
| 30 | }); | ||
| 31 | http.route({ | ||
| 32 | pathPrefix: "/v1/", | ||
| 33 | method: "GET", | ||
| 34 | handler: controlPlaneHttpHandler, | ||
| 35 | }); | ||
| 36 | http.route({ | ||
| 37 | pathPrefix: "/v1/", | ||
| 38 | method: "POST", | ||
| 39 | handler: controlPlaneHttpHandler, | ||
| 40 | }); | ||
| 41 | http.route({ | ||
| 42 | pathPrefix: "/v1/", | ||
| 43 | method: "PUT", | ||
| 44 | handler: controlPlaneHttpHandler, | ||
| 45 | }); | ||
| 46 | http.route({ | ||
| 47 | pathPrefix: "/v1/", | ||
| 48 | method: "PATCH", | ||
| 49 | handler: controlPlaneHttpHandler, | ||
| 50 | }); | ||
| 51 | http.route({ | ||
| 52 | pathPrefix: "/v1/", | ||
| 53 | method: "DELETE", | ||
| 54 | handler: controlPlaneHttpHandler, | ||
| 55 | }); | ||
| 56 | http.route({ | ||
| 57 | pathPrefix: "/v1/", | ||
| 58 | method: "OPTIONS", | ||
| 59 | handler: controlPlaneHttpHandler, | ||
| 60 | }); | ||
| 61 | |||
| 62 | export default http; | ||
| @@ -0,0 +1,199 @@ | |||
| 1 | import { | ||
| 2 | buildExecuteToolDescription, | ||
| 3 | defaultExecuteToolDescription, | ||
| 4 | defaultExecuteToolExposureMode, | ||
| 5 | parseExecuteToolExposureMode, | ||
| 6 | type ExecuteToolExposureMode, | ||
| 7 | } from "@executor-v2/engine"; | ||
| 8 | import { handleMcpHttpRequest } from "@executor-v2/mcp-gateway"; | ||
| 9 | import { createExecutorRunClient } from "@executor-v2/sdk"; | ||
| 10 | import * as Effect from "effect/Effect"; | ||
| 11 | |||
| 12 | import { internal } from "./_generated/api"; | ||
| 13 | import { httpAction, type ActionCtx } from "./_generated/server"; | ||
| 14 | import { executeRunImpl } from "./executor"; | ||
| 15 | import { | ||
| 16 | getMcpAuthConfig, | ||
| 17 | unauthorizedMcpResponse, | ||
| 18 | verifyMcpToken, | ||
| 19 | } from "./mcp_auth"; | ||
| 20 | import { createConvexSourceToolRegistry } from "./source_tool_registry"; | ||
| 21 | |||
| 22 | const readConfiguredWorkspaceId = (value: string | undefined): string => { | ||
| 23 | const normalized = value?.trim(); | ||
| 24 | return normalized && normalized.length > 0 ? normalized : "ws_local"; | ||
| 25 | }; | ||
| 26 | |||
| 27 | const readWorkspaceIdFromRequest = (request: Request): string | null => { | ||
| 28 | const value = new URL(request.url).searchParams.get("workspaceId")?.trim(); | ||
| 29 | return value && value.length > 0 ? value : null; | ||
| 30 | }; | ||
| 31 | |||
| 32 | const readRequestedWorkspaceId = (request: Request, fallbackWorkspaceId: string): string => | ||
| 33 | readWorkspaceIdFromRequest(request) ?? fallbackWorkspaceId; | ||
| 34 | |||
| 35 | const readToolExposureModeFromRequest = ( | ||
| 36 | request: Request, | ||
| 37 | fallbackMode: ExecuteToolExposureMode, | ||
| 38 | ): ExecuteToolExposureMode => { | ||
| 39 | const url = new URL(request.url); | ||
| 40 | const rawMode = | ||
| 41 | url.searchParams.get("toolExposureMode") ?? | ||
| 42 | url.searchParams.get("toolContextMode") ?? | ||
| 43 | undefined; | ||
| 44 | |||
| 45 | return parseExecuteToolExposureMode(rawMode ?? undefined) ?? fallbackMode; | ||
| 46 | }; | ||
| 47 | |||
| 48 | const resolveExecuteToolDescription = async ( | ||
| 49 | mode: ExecuteToolExposureMode, | ||
| 50 | toolRegistry: ReturnType<typeof createConvexSourceToolRegistry>, | ||
| 51 | ): Promise<string> => { | ||
| 52 | try { | ||
| 53 | return await Effect.runPromise( | ||
| 54 | buildExecuteToolDescription({ | ||
| 55 | toolRegistry, | ||
| 56 | mode, | ||
| 57 | }), | ||
| 58 | ); | ||
| 59 | } catch { | ||
| 60 | return defaultExecuteToolDescription; | ||
| 61 | } | ||
| 62 | }; | ||
| 63 | |||
| 64 | const hasWorkspaceAccess = async ( | ||
| 65 | ctx: ActionCtx, | ||
| 66 | workspaceId: string, | ||
| 67 | accountId: string, | ||
| 68 | ): Promise<boolean> => { | ||
| 69 | try { | ||
| 70 | const workspace = (await ctx.runQuery( | ||
| 71 | runtimeInternal.control_plane.actor.getWorkspaceForActor, | ||
| 72 | { workspaceId }, | ||
| 73 | )) as { | ||
| 74 | organizationId: string; | ||
| 75 | createdByAccountId: string | null; | ||
| 76 | } | null; | ||
| 77 | |||
| 78 | if (!workspace) { | ||
| 79 | return false; | ||
| 80 | } | ||
| 81 | |||
| 82 | if (workspace.createdByAccountId === accountId) { | ||
| 83 | return true; | ||
| 84 | } | ||
| 85 | |||
| 86 | const memberships = (await ctx.runQuery( | ||
| 87 | runtimeInternal.control_plane.actor.listOrganizationMembershipsForActor, | ||
| 88 | { accountId }, | ||
| 89 | )) as Array<{ | ||
| 90 | organizationId: string; | ||
| 91 | }>; | ||
| 92 | |||
| 93 | return memberships.some((membership) => membership.organizationId === workspace.organizationId); | ||
| 94 | } catch { | ||
| 95 | return false; | ||
| 96 | } | ||
| 97 | }; | ||
| 98 | |||
| 99 | const fallbackWorkspaceId = readConfiguredWorkspaceId(process.env.CONVEX_WORKSPACE_ID); | ||
| 100 | const defaultToolExposureMode = | ||
| 101 | parseExecuteToolExposureMode(process.env.CONVEX_TOOL_EXPOSURE_MODE) ?? | ||
| 102 | defaultExecuteToolExposureMode; | ||
| 103 | const runtimeInternal = internal as any; | ||
| 104 | |||
| 105 | export const mcpHandler = httpAction(async (ctx, request) => { | ||
| 106 | const mcpAuthConfig = getMcpAuthConfig(); | ||
| 107 | const requestWorkspaceId = readWorkspaceIdFromRequest(request); | ||
| 108 | const workspaceId = readRequestedWorkspaceId(request, fallbackWorkspaceId); | ||
| 109 | |||
| 110 | if (!mcpAuthConfig.enabled) { | ||
| 111 | if (mcpAuthConfig.required) { | ||
| 112 | return Response.json( | ||
| 113 | { | ||
| 114 | error: "MCP OAuth must be configured for cloud deployments", | ||
| 115 | }, | ||
| 116 | { status: 503 }, | ||
| 117 | ); | ||
| 118 | } | ||
| 119 | } else { | ||
| 120 | const auth = await verifyMcpToken(request, mcpAuthConfig); | ||
| 121 | if (!auth) { | ||
| 122 | return unauthorizedMcpResponse(request, "No valid bearer token provided."); | ||
| 123 | } | ||
| 124 | |||
| 125 | if (!requestWorkspaceId) { | ||
| 126 | return Response.json( | ||
| 127 | { | ||
| 128 | error: "workspaceId query parameter is required when MCP OAuth is enabled", | ||
| 129 | }, | ||
| 130 | { status: 400 }, | ||
| 131 | ); | ||
| 132 | } | ||
| 133 | |||
| 134 | const authorized = await hasWorkspaceAccess(ctx, requestWorkspaceId, auth.subject); | ||
| 135 | if (!authorized) { | ||
| 136 | return Response.json( | ||
| 137 | { | ||
| 138 | error: "Workspace authorization failed", | ||
| 139 | }, | ||
| 140 | { status: 403 }, | ||
| 141 | ); | ||
| 142 | } | ||
| 143 | } | ||
| 144 | |||
| 145 | const toolRegistry = createConvexSourceToolRegistry(ctx, workspaceId); | ||
| 146 | const toolExposureMode = readToolExposureModeFromRequest( | ||
| 147 | request, | ||
| 148 | defaultToolExposureMode, | ||
| 149 | ); | ||
| 150 | const executeToolDescription = await resolveExecuteToolDescription( | ||
| 151 | toolExposureMode, | ||
| 152 | toolRegistry, | ||
| 153 | ); | ||
| 154 | |||
| 155 | const runClient = createExecutorRunClient(async (input) => { | ||
| 156 | const runId = `run_${crypto.randomUUID()}`; | ||
| 157 | |||
| 158 | await ctx.runMutation(runtimeInternal.task_runs.startTaskRun, { | ||
| 159 | workspaceId, | ||
| 160 | runId, | ||
| 161 | sessionId: "session_mcp", | ||
| 162 | runtimeId: "runtime_local_inproc", | ||
| 163 | codeHash: `code_length_${input.code.length}`, | ||
| 164 | }); | ||
| 165 | |||
| 166 | try { | ||
| 167 | const result = await Effect.runPromise( | ||
| 168 | executeRunImpl(input, { | ||
| 169 | toolRegistry, | ||
| 170 | makeRunId: () => runId, | ||
| 171 | }), | ||
| 172 | ); | ||
| 173 | |||
| 174 | await ctx.runMutation(runtimeInternal.task_runs.finishTaskRun, { | ||
| 175 | workspaceId, | ||
| 176 | runId, | ||
| 177 | status: result.status, | ||
| 178 | error: result.error ?? null, | ||
| 179 | }); | ||
| 180 | |||
| 181 | return result; | ||
| 182 | } catch (cause) { | ||
| 183 | await ctx.runMutation(runtimeInternal.task_runs.finishTaskRun, { | ||
| 184 | workspaceId, | ||
| 185 | runId, | ||
| 186 | status: "failed", | ||
| 187 | error: String(cause), | ||
| 188 | }); | ||
| 189 | throw cause; | ||
| 190 | } | ||
| 191 | }); | ||
| 192 | |||
| 193 | return handleMcpHttpRequest(request, { | ||
| 194 | serverName: "executor-v2-convex", | ||
| 195 | serverVersion: "0.0.0", | ||
| 196 | runClient, | ||
| 197 | executeToolDescription, | ||
| 198 | }); | ||
| 199 | }); | ||
| @@ -0,0 +1,216 @@ | |||
| 1 | import { createRemoteJWKSet, jwtVerify } from "jose"; | ||
| 2 | |||
| 3 | import { httpAction } from "./_generated/server"; | ||
| 4 | |||
| 5 | export const MCP_PATH = "/v1/mcp"; | ||
| 6 | |||
| 7 | type McpAuthConfig = { | ||
| 8 | required: boolean; | ||
| 9 | enabled: boolean; | ||
| 10 | authorizationServer: string | null; | ||
| 11 | jwks: ReturnType<typeof createRemoteJWKSet> | null; | ||
| 12 | }; | ||
| 13 | |||
| 14 | type VerifiedMcpToken = { | ||
| 15 | provider: "workos"; | ||
| 16 | subject: string; | ||
| 17 | }; | ||
| 18 | |||
| 19 | const isTruthyEnvValue = (value: string | undefined): boolean => { | ||
| 20 | const normalized = value?.trim().toLowerCase(); | ||
| 21 | return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on"; | ||
| 22 | }; | ||
| 23 | |||
| 24 | const mcpAuthRequired = (): boolean => { | ||
| 25 | const deploymentMode = (process.env.EXECUTOR_DEPLOYMENT_MODE ?? "").trim().toLowerCase(); | ||
| 26 | if ( | ||
| 27 | deploymentMode === "cloud" | ||
| 28 | || deploymentMode === "hosted" | ||
| 29 | || deploymentMode === "production" | ||
| 30 | || deploymentMode === "prod" | ||
| 31 | ) { | ||
| 32 | return true; | ||
| 33 | } | ||
| 34 | |||
| 35 | if ( | ||
| 36 | deploymentMode === "self-hosted" | ||
| 37 | || deploymentMode === "self_hosted" | ||
| 38 | || deploymentMode === "selfhosted" | ||
| 39 | ) { | ||
| 40 | return false; | ||
| 41 | } | ||
| 42 | |||
| 43 | return isTruthyEnvValue(process.env.EXECUTOR_ENFORCE_MCP_AUTH); | ||
| 44 | }; | ||
| 45 | |||
| 46 | const getMcpAuthorizationServer = (): string | null => | ||
| 47 | process.env.MCP_AUTHORIZATION_SERVER | ||
| 48 | ?? process.env.MCP_AUTHORIZATION_SERVER_URL | ||
| 49 | ?? process.env.WORKOS_AUTHKIT_ISSUER | ||
| 50 | ?? process.env.WORKOS_AUTHKIT_DOMAIN | ||
| 51 | ?? null; | ||
| 52 | |||
| 53 | export const getMcpAuthConfig = (): McpAuthConfig => { | ||
| 54 | const required = mcpAuthRequired(); | ||
| 55 | const authorizationServer = getMcpAuthorizationServer(); | ||
| 56 | |||
| 57 | if (!authorizationServer) { | ||
| 58 | return { | ||
| 59 | required, | ||
| 60 | enabled: false, | ||
| 61 | authorizationServer: null, | ||
| 62 | jwks: null, | ||
| 63 | }; | ||
| 64 | } | ||
| 65 | |||
| 66 | return { | ||
| 67 | required, | ||
| 68 | enabled: true, | ||
| 69 | authorizationServer, | ||
| 70 | jwks: createRemoteJWKSet(new URL("/oauth2/jwks", authorizationServer)), | ||
| 71 | }; | ||
| 72 | }; | ||
| 73 | |||
| 74 | const parseBearerToken = (request: Request): string | null => { | ||
| 75 | const header = request.headers.get("authorization"); | ||
| 76 | if (!header || !header.startsWith("Bearer ")) { | ||
| 77 | return null; | ||
| 78 | } | ||
| 79 | |||
| 80 | const token = header.slice("Bearer ".length).trim(); | ||
| 81 | return token.length > 0 ? token : null; | ||
| 82 | }; | ||
| 83 | |||
| 84 | const resourceMetadataUrl = (request: Request): string => { | ||
| 85 | const url = new URL(request.url); | ||
| 86 | const metadata = new URL("/.well-known/oauth-protected-resource", url.origin); | ||
| 87 | metadata.search = url.search; | ||
| 88 | |||
| 89 | const resource = new URL(url.pathname, url.origin); | ||
| 90 | resource.search = url.search; | ||
| 91 | metadata.searchParams.set("resource", resource.toString()); | ||
| 92 | |||
| 93 | return metadata.toString(); | ||
| 94 | }; | ||
| 95 | |||
| 96 | export const unauthorizedMcpResponse = (request: Request, message: string): Response => { | ||
| 97 | const challenge = [ | ||
| 98 | 'Bearer error="unauthorized"', | ||
| 99 | 'error_description="Authorization needed"', | ||
| 100 | `resource_metadata="${resourceMetadataUrl(request)}"`, | ||
| 101 | ].join(", "); | ||
| 102 | |||
| 103 | return Response.json( | ||
| 104 | { error: message }, | ||
| 105 | { | ||
| 106 | status: 401, | ||
| 107 | headers: { | ||
| 108 | "WWW-Authenticate": challenge, | ||
| 109 | }, | ||
| 110 | }, | ||
| 111 | ); | ||
| 112 | }; | ||
| 113 | |||
| 114 | export const verifyMcpToken = async ( | ||
| 115 | request: Request, | ||
| 116 | config: McpAuthConfig, | ||
| 117 | ): Promise<VerifiedMcpToken | null> => { | ||
| 118 | if (!config.enabled || !config.jwks || !config.authorizationServer) { | ||
| 119 | return null; | ||
| 120 | } | ||
| 121 | |||
| 122 | const token = parseBearerToken(request); | ||
| 123 | if (!token) { | ||
| 124 | return null; | ||
| 125 | } | ||
| 126 | |||
| 127 | try { | ||
| 128 | const { payload } = await jwtVerify(token, config.jwks, { | ||
| 129 | issuer: config.authorizationServer, | ||
| 130 | }); | ||
| 131 | |||
| 132 | if (typeof payload.sub !== "string" || payload.sub.length === 0) { | ||
| 133 | return null; | ||
| 134 | } | ||
| 135 | |||
| 136 | const providerClaim = typeof payload.provider === "string" ? payload.provider : undefined; | ||
| 137 | if (providerClaim === "anonymous") { | ||
| 138 | return null; | ||
| 139 | } | ||
| 140 | |||
| 141 | return { | ||
| 142 | provider: "workos", | ||
| 143 | subject: payload.sub, | ||
| 144 | }; | ||
| 145 | } catch (error) { | ||
| 146 | console.error("MCP token verification failed:", error instanceof Error ? error.message : String(error)); | ||
| 147 | return null; | ||
| 148 | } | ||
| 149 | }; | ||
| 150 | |||
| 151 | const errorResponseForMissingConfig = (config: McpAuthConfig): Response => | ||
| 152 | Response.json( | ||
| 153 | { | ||
| 154 | error: config.required | ||
| 155 | ? "MCP OAuth must be configured for cloud deployments" | ||
| 156 | : "MCP OAuth is not configured", | ||
| 157 | }, | ||
| 158 | { status: config.required ? 503 : 404 }, | ||
| 159 | ); | ||
| 160 | |||
| 161 | export const oauthProtectedResourceHandler = httpAction(async (_ctx, request) => { | ||
| 162 | const config = getMcpAuthConfig(); | ||
| 163 | if (!config.enabled || !config.authorizationServer) { | ||
| 164 | return errorResponseForMissingConfig(config); | ||
| 165 | } | ||
| 166 | |||
| 167 | const url = new URL(request.url); | ||
| 168 | let resource = new URL(MCP_PATH, url.origin); | ||
| 169 | resource.search = url.search; | ||
| 170 | |||
| 171 | const resourceHint = url.searchParams.get("resource"); | ||
| 172 | if (resourceHint) { | ||
| 173 | try { | ||
| 174 | const parsed = new URL(resourceHint); | ||
| 175 | if (parsed.origin !== url.origin) { | ||
| 176 | return Response.json({ error: "resource hint origin must match this server" }, { status: 400 }); | ||
| 177 | } | ||
| 178 | |||
| 179 | if (parsed.pathname === MCP_PATH) { | ||
| 180 | resource = new URL(MCP_PATH, url.origin); | ||
| 181 | resource.search = parsed.search; | ||
| 182 | } | ||
| 183 | } catch { | ||
| 184 | return Response.json({ error: "Invalid resource hint" }, { status: 400 }); | ||
| 185 | } | ||
| 186 | } | ||
| 187 | |||
| 188 | return Response.json({ | ||
| 189 | resource: resource.toString(), | ||
| 190 | authorization_servers: [config.authorizationServer], | ||
| 191 | bearer_methods_supported: ["header"], | ||
| 192 | }); | ||
| 193 | }); | ||
| 194 | |||
| 195 | export const oauthAuthorizationServerHandler = httpAction(async (_ctx, _request) => { | ||
| 196 | const config = getMcpAuthConfig(); | ||
| 197 | if (!config.enabled || !config.authorizationServer) { | ||
| 198 | return errorResponseForMissingConfig(config); | ||
| 199 | } | ||
| 200 | |||
| 201 | const upstream = new URL("/.well-known/oauth-authorization-server", config.authorizationServer); | ||
| 202 | const response = await fetch(upstream.toString(), { | ||
| 203 | headers: { | ||
| 204 | accept: "application/json", | ||
| 205 | }, | ||
| 206 | }); | ||
| 207 | |||
| 208 | const body = await response.text(); | ||
| 209 | |||
| 210 | return new Response(body, { | ||
| 211 | status: response.status, | ||
| 212 | headers: { | ||
| 213 | "content-type": response.headers.get("content-type") ?? "application/json", | ||
| 214 | }, | ||
| 215 | }); | ||
| 216 | }); | ||
| @@ -0,0 +1,5 @@ | |||
| 1 | import { type ExecuteRunInput } from "@executor-v2/sdk"; | ||
| 2 | |||
| 3 | import { executeRunImpl } from "./executor"; | ||
| 4 | |||
| 5 | export const executeRun = (input: ExecuteRunInput) => executeRunImpl(input); | ||
| @@ -0,0 +1,124 @@ | |||
| 1 | import { | ||
| 2 | RuntimeAdapterError, | ||
| 3 | invokeRuntimeToolCallResult, | ||
| 4 | } from "@executor-v2/engine"; | ||
| 5 | import type { | ||
| 6 | RuntimeToolCallRequest, | ||
| 7 | RuntimeToolCallResult, | ||
| 8 | } from "@executor-v2/sdk"; | ||
| 9 | import * as Data from "effect/Data"; | ||
| 10 | import * as Effect from "effect/Effect"; | ||
| 11 | import * as ParseResult from "effect/ParseResult"; | ||
| 12 | import * as Schema from "effect/Schema"; | ||
| 13 | |||
| 14 | import { httpAction, type ActionCtx } from "./_generated/server"; | ||
| 15 | import { createConvexSourceToolRegistry } from "./source_tool_registry"; | ||
| 16 | |||
| 17 | class RuntimeToolCallBadRequestError extends Data.TaggedError( | ||
| 18 | "RuntimeToolCallBadRequestError", | ||
| 19 | )<{ | ||
| 20 | message: string; | ||
| 21 | details: string; | ||
| 22 | }> {} | ||
| 23 | |||
| 24 | const RuntimeToolCallCredentialContextSchema = Schema.Struct({ | ||
| 25 | workspaceId: Schema.String, | ||
| 26 | sourceKey: Schema.String, | ||
| 27 | organizationId: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 28 | accountId: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 29 | }); | ||
| 30 | |||
| 31 | const RuntimeToolCallRequestSchema = Schema.Struct({ | ||
| 32 | runId: Schema.String, | ||
| 33 | callId: Schema.String, | ||
| 34 | toolPath: Schema.String, | ||
| 35 | input: Schema.optional( | ||
| 36 | Schema.Record({ | ||
| 37 | key: Schema.String, | ||
| 38 | value: Schema.Unknown, | ||
| 39 | }), | ||
| 40 | ), | ||
| 41 | credentialContext: Schema.optional(RuntimeToolCallCredentialContextSchema), | ||
| 42 | }); | ||
| 43 | |||
| 44 | const decodeRuntimeToolCallRequest = Schema.decodeUnknown(RuntimeToolCallRequestSchema); | ||
| 45 | |||
| 46 | const readConfiguredWorkspaceId = (value: string | undefined): string => { | ||
| 47 | const normalized = value?.trim(); | ||
| 48 | return normalized && normalized.length > 0 ? normalized : "ws_local"; | ||
| 49 | }; | ||
| 50 | |||
| 51 | const fallbackWorkspaceId = readConfiguredWorkspaceId(process.env.CONVEX_WORKSPACE_ID); | ||
| 52 | |||
| 53 | const badRequest = (message: string): Response => | ||
| 54 | Response.json( | ||
| 55 | { | ||
| 56 | ok: false, | ||
| 57 | kind: "failed", | ||
| 58 | error: message, | ||
| 59 | } satisfies RuntimeToolCallResult, | ||
| 60 | { status: 400 }, | ||
| 61 | ); | ||
| 62 | |||
| 63 | const formatBadRequestMessage = (error: RuntimeToolCallBadRequestError): string => | ||
| 64 | error.details.length > 0 ? `${error.message}: ${error.details}` : error.message; | ||
| 65 | |||
| 66 | const formatRuntimeAdapterError = (error: RuntimeAdapterError): string => | ||
| 67 | error.details ? `${error.message}: ${error.details}` : error.message; | ||
| 68 | |||
| 69 | const formatUnknownDetails = (cause: unknown): string => String(cause); | ||
| 70 | |||
| 71 | const decodeToolCallRequest = (request: Request): Effect.Effect<RuntimeToolCallRequest, RuntimeToolCallBadRequestError> => | ||
| 72 | Effect.gen(function* () { | ||
| 73 | const body = yield* Effect.tryPromise({ | ||
| 74 | try: () => request.json(), | ||
| 75 | catch: (cause) => | ||
| 76 | new RuntimeToolCallBadRequestError({ | ||
| 77 | message: "Invalid runtime callback request body", | ||
| 78 | details: formatUnknownDetails(cause), | ||
| 79 | }), | ||
| 80 | }); | ||
| 81 | |||
| 82 | return yield* decodeRuntimeToolCallRequest(body).pipe( | ||
| 83 | Effect.mapError( | ||
| 84 | (cause) => | ||
| 85 | new RuntimeToolCallBadRequestError({ | ||
| 86 | message: "Runtime callback request body is invalid", | ||
| 87 | details: ParseResult.TreeFormatter.formatErrorSync(cause), | ||
| 88 | }), | ||
| 89 | ), | ||
| 90 | ); | ||
| 91 | }); | ||
| 92 | |||
| 93 | const handleToolCallHttpEffect = ( | ||
| 94 | ctx: ActionCtx, | ||
| 95 | request: Request, | ||
| 96 | ): Effect.Effect<Response, never> => | ||
| 97 | Effect.gen(function* () { | ||
| 98 | const input = yield* decodeToolCallRequest(request); | ||
| 99 | |||
| 100 | const workspaceId = | ||
| 101 | input.credentialContext?.workspaceId?.trim() || fallbackWorkspaceId; | ||
| 102 | |||
| 103 | const toolRegistry = createConvexSourceToolRegistry(ctx, workspaceId); | ||
| 104 | |||
| 105 | const result = yield* invokeRuntimeToolCallResult(toolRegistry, input).pipe( | ||
| 106 | Effect.catchTag("RuntimeAdapterError", (error) => | ||
| 107 | Effect.succeed<RuntimeToolCallResult>({ | ||
| 108 | ok: false, | ||
| 109 | kind: "failed", | ||
| 110 | error: formatRuntimeAdapterError(error), | ||
| 111 | }), | ||
| 112 | ), | ||
| 113 | ); | ||
| 114 | |||
| 115 | return Response.json(result, { status: 200 }); | ||
| 116 | }).pipe( | ||
| 117 | Effect.catchTag("RuntimeToolCallBadRequestError", (error) => | ||
| 118 | Effect.succeed(badRequest(formatBadRequestMessage(error))), | ||
| 119 | ), | ||
| 120 | ); | ||
| 121 | |||
| 122 | export const handleToolCallHttp = httpAction((ctx, request) => | ||
| 123 | Effect.runPromise(handleToolCallHttpEffect(ctx, request)), | ||
| 124 | ); | ||
| @@ -0,0 +1,10 @@ | |||
| 1 | import { | ||
| 2 | type RuntimeAdapter, | ||
| 3 | type RuntimeExecuteError, | ||
| 4 | type RuntimeExecuteInput, | ||
| 5 | } from "@executor-v2/engine"; | ||
| 6 | import { makeCloudflareWorkerLoaderRuntimeAdapter } from "@executor-v2/runtime-cloudflare-worker-loader"; | ||
| 7 | |||
| 8 | export type { RuntimeAdapter, RuntimeExecuteError, RuntimeExecuteInput }; | ||
| 9 | |||
| 10 | export { makeCloudflareWorkerLoaderRuntimeAdapter }; | ||
| @@ -0,0 +1,74 @@ | |||
| 1 | import { | ||
| 2 | RuntimeExecutionPortError, | ||
| 3 | createRuntimeToolCallService, | ||
| 4 | createStaticToolRegistry, | ||
| 5 | type ExecuteRuntimeRun, | ||
| 6 | type ExecuteRuntimeRunInput, | ||
| 7 | type ToolRegistry, | ||
| 8 | makeRuntimeAdapterRegistry, | ||
| 9 | type RuntimeExecuteError, | ||
| 10 | } from "@executor-v2/engine"; | ||
| 11 | import { makeCloudflareWorkerLoaderRuntimeAdapter } from "@executor-v2/runtime-cloudflare-worker-loader"; | ||
| 12 | import * as Effect from "effect/Effect"; | ||
| 13 | |||
| 14 | export type ConvexRuntimeExecutionPortOptions = { | ||
| 15 | toolRegistry?: ToolRegistry; | ||
| 16 | }; | ||
| 17 | |||
| 18 | export const createExecuteRuntimeRunInConvex = ( | ||
| 19 | options: ConvexRuntimeExecutionPortOptions = {}, | ||
| 20 | ): ExecuteRuntimeRun => { | ||
| 21 | const convexRuntimeAdapter = makeCloudflareWorkerLoaderRuntimeAdapter(); | ||
| 22 | const runtimeAdapters = makeRuntimeAdapterRegistry([convexRuntimeAdapter]); | ||
| 23 | |||
| 24 | const toolRegistry = | ||
| 25 | options.toolRegistry ?? | ||
| 26 | createStaticToolRegistry({ | ||
| 27 | tools: {}, | ||
| 28 | }); | ||
| 29 | const toolCallService = createRuntimeToolCallService(toolRegistry); | ||
| 30 | |||
| 31 | return (input: ExecuteRuntimeRunInput) => | ||
| 32 | Effect.gen(function* () { | ||
| 33 | const runtimeAdapter = yield* runtimeAdapters.get(convexRuntimeAdapter.kind).pipe( | ||
| 34 | Effect.mapError( | ||
| 35 | (error) => | ||
| 36 | new RuntimeExecutionPortError({ | ||
| 37 | operation: "resolve_runtime_adapter", | ||
| 38 | message: error.message, | ||
| 39 | details: null, | ||
| 40 | }), | ||
| 41 | ), | ||
| 42 | ); | ||
| 43 | |||
| 44 | const isAvailable = yield* runtimeAdapter.isAvailable(); | ||
| 45 | if (!isAvailable) { | ||
| 46 | return yield* new RuntimeExecutionPortError({ | ||
| 47 | operation: "runtime_available", | ||
| 48 | message: `Runtime '${convexRuntimeAdapter.kind}' is not configured in this convex process.`, | ||
| 49 | details: | ||
| 50 | "Set CLOUDFLARE_SANDBOX_RUN_URL, CLOUDFLARE_SANDBOX_AUTH_TOKEN, and CLOUDFLARE_SANDBOX_CALLBACK_URL.", | ||
| 51 | }); | ||
| 52 | } | ||
| 53 | |||
| 54 | return yield* runtimeAdapter | ||
| 55 | .execute({ | ||
| 56 | runId: input.runId, | ||
| 57 | code: input.code, | ||
| 58 | timeoutMs: input.timeoutMs, | ||
| 59 | toolCallService, | ||
| 60 | }) | ||
| 61 | .pipe( | ||
| 62 | Effect.mapError( | ||
| 63 | (error: RuntimeExecuteError) => | ||
| 64 | new RuntimeExecutionPortError({ | ||
| 65 | operation: "runtime_execute", | ||
| 66 | message: error.message, | ||
| 67 | details: error.details, | ||
| 68 | }), | ||
| 69 | ), | ||
| 70 | ); | ||
| 71 | }); | ||
| 72 | }; | ||
| 73 | |||
| 74 | export const executeRuntimeRunInConvex = createExecuteRuntimeRunInConvex(); | ||
| @@ -0,0 +1,236 @@ | |||
| 1 | import { defineSchema, defineTable, type TablesFromSchemaDefinition } from "@executor-v2/confect"; | ||
| 2 | import { | ||
| 3 | ApprovalSchema, | ||
| 4 | EventEnvelopeSchema, | ||
| 5 | OAuthTokenSchema, | ||
| 6 | OrganizationMembershipSchema, | ||
| 7 | OrganizationSchema, | ||
| 8 | PolicySchema, | ||
| 9 | ProfileSchema, | ||
| 10 | SourceCredentialBindingSchema, | ||
| 11 | SourceSchema, | ||
| 12 | StorageInstanceSchema, | ||
| 13 | SyncStateSchema, | ||
| 14 | TaskRunSchema, | ||
| 15 | WorkspaceSchema, | ||
| 16 | } from "@executor-v2/schema"; | ||
| 17 | import * as Schema from "effect/Schema"; | ||
| 18 | |||
| 19 | const StorageFileEntrySchema = Schema.Struct({ | ||
| 20 | id: Schema.String, | ||
| 21 | storageInstanceId: Schema.String, | ||
| 22 | path: Schema.String, | ||
| 23 | contentBase64: Schema.String, | ||
| 24 | sizeBytes: Schema.Number, | ||
| 25 | updatedAt: Schema.Number, | ||
| 26 | }); | ||
| 27 | |||
| 28 | const StorageKvEntrySchema = Schema.Struct({ | ||
| 29 | id: Schema.String, | ||
| 30 | storageInstanceId: Schema.String, | ||
| 31 | key: Schema.String, | ||
| 32 | valueJson: Schema.String, | ||
| 33 | updatedAt: Schema.Number, | ||
| 34 | }); | ||
| 35 | |||
| 36 | const StorageSqlKvEntrySchema = Schema.Struct({ | ||
| 37 | id: Schema.String, | ||
| 38 | storageInstanceId: Schema.String, | ||
| 39 | key: Schema.String, | ||
| 40 | value: Schema.String, | ||
| 41 | updatedAt: Schema.Number, | ||
| 42 | }); | ||
| 43 | |||
| 44 | const ArtifactSchema = Schema.Struct({ | ||
| 45 | id: Schema.String, | ||
| 46 | protocol: Schema.String, | ||
| 47 | contentHash: Schema.String, | ||
| 48 | extractorVersion: Schema.String, | ||
| 49 | toolCount: Schema.Number, | ||
| 50 | refHintTableJson: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 51 | createdAt: Schema.Number, | ||
| 52 | updatedAt: Schema.Number, | ||
| 53 | }); | ||
| 54 | |||
| 55 | const ArtifactToolSchema = Schema.Struct({ | ||
| 56 | id: Schema.String, | ||
| 57 | artifactId: Schema.String, | ||
| 58 | protocol: Schema.String, | ||
| 59 | toolId: Schema.String, | ||
| 60 | name: Schema.String, | ||
| 61 | description: Schema.NullOr(Schema.String), | ||
| 62 | canonicalPath: Schema.String, | ||
| 63 | operationHash: Schema.String, | ||
| 64 | invocationJson: Schema.String, | ||
| 65 | inputSchemaJson: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 66 | outputSchemaJson: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 67 | metadataJson: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 68 | createdAt: Schema.Number, | ||
| 69 | updatedAt: Schema.Number, | ||
| 70 | }); | ||
| 71 | |||
| 72 | const ArtifactSchemaRefSchema = Schema.Struct({ | ||
| 73 | id: Schema.String, | ||
| 74 | artifactId: Schema.String, | ||
| 75 | refKey: Schema.String, | ||
| 76 | schemaJson: Schema.String, | ||
| 77 | createdAt: Schema.Number, | ||
| 78 | updatedAt: Schema.Number, | ||
| 79 | }); | ||
| 80 | |||
| 81 | const SourceArtifactBindingSchema = Schema.Struct({ | ||
| 82 | id: Schema.String, | ||
| 83 | workspaceId: Schema.String, | ||
| 84 | sourceId: Schema.String, | ||
| 85 | artifactId: Schema.String, | ||
| 86 | updatedAt: Schema.Number, | ||
| 87 | }); | ||
| 88 | |||
| 89 | const SourceIngestArtifactBatchSchema = Schema.Struct({ | ||
| 90 | id: Schema.String, | ||
| 91 | workspaceId: Schema.String, | ||
| 92 | sourceId: Schema.String, | ||
| 93 | artifactId: Schema.String, | ||
| 94 | protocol: Schema.String, | ||
| 95 | batchIndex: Schema.Number, | ||
| 96 | toolsJson: Schema.String, | ||
| 97 | updatedAt: Schema.Number, | ||
| 98 | }); | ||
| 99 | |||
| 100 | const WorkspaceToolIndexSchema = Schema.Struct({ | ||
| 101 | id: Schema.String, | ||
| 102 | workspaceId: Schema.String, | ||
| 103 | sourceId: Schema.String, | ||
| 104 | sourceName: Schema.String, | ||
| 105 | sourceKind: Schema.String, | ||
| 106 | artifactId: Schema.String, | ||
| 107 | toolId: Schema.String, | ||
| 108 | protocol: Schema.String, | ||
| 109 | method: Schema.String, | ||
| 110 | namespace: Schema.String, | ||
| 111 | path: Schema.String, | ||
| 112 | pathLower: Schema.String, | ||
| 113 | normalizedPath: Schema.String, | ||
| 114 | operationPath: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 115 | name: Schema.String, | ||
| 116 | description: Schema.NullOr(Schema.String), | ||
| 117 | searchText: Schema.String, | ||
| 118 | operationHash: Schema.String, | ||
| 119 | approvalMode: Schema.String, | ||
| 120 | status: Schema.String, | ||
| 121 | refHintTableJson: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 122 | updatedAt: Schema.Number, | ||
| 123 | }); | ||
| 124 | |||
| 125 | export const executorConfectSchema = defineSchema({ | ||
| 126 | profiles: defineTable(ProfileSchema).index("by_domainId", ["id"]), | ||
| 127 | organizations: defineTable(OrganizationSchema) | ||
| 128 | .index("by_domainId", ["id"]) | ||
| 129 | .index("by_slug", ["slug"]), | ||
| 130 | organizationMemberships: defineTable(OrganizationMembershipSchema) | ||
| 131 | .index("by_domainId", ["id"]) | ||
| 132 | .index("by_organizationId", ["organizationId"]) | ||
| 133 | .index("by_accountId", ["accountId"]) | ||
| 134 | .index("by_organizationId_accountId", ["organizationId", "accountId"]), | ||
| 135 | workspaces: defineTable(WorkspaceSchema) | ||
| 136 | .index("by_domainId", ["id"]) | ||
| 137 | .index("by_organizationId", ["organizationId"]) | ||
| 138 | .index("by_createdByAccountId", ["createdByAccountId"]), | ||
| 139 | sources: defineTable(SourceSchema) | ||
| 140 | .index("by_domainId", ["id"]) | ||
| 141 | .index("by_workspaceId", ["workspaceId"]), | ||
| 142 | artifacts: defineTable(ArtifactSchema) | ||
| 143 | .index("by_domainId", ["id"]) | ||
| 144 | .index("by_protocol_contentHash_extractorVersion", [ | ||
| 145 | "protocol", | ||
| 146 | "contentHash", | ||
| 147 | "extractorVersion", | ||
| 148 | ]), | ||
| 149 | artifactTools: defineTable(ArtifactToolSchema) | ||
| 150 | .index("by_domainId", ["id"]) | ||
| 151 | .index("by_artifactId", ["artifactId"]) | ||
| 152 | .index("by_artifactId_toolId", ["artifactId", "toolId"]), | ||
| 153 | artifactSchemaRefs: defineTable(ArtifactSchemaRefSchema) | ||
| 154 | .index("by_domainId", ["id"]) | ||
| 155 | .index("by_artifactId", ["artifactId"]) | ||
| 156 | .index("by_artifactId_refKey", ["artifactId", "refKey"]), | ||
| 157 | sourceArtifactBindings: defineTable(SourceArtifactBindingSchema) | ||
| 158 | .index("by_domainId", ["id"]) | ||
| 159 | .index("by_workspaceId", ["workspaceId"]) | ||
| 160 | .index("by_workspaceId_sourceId", ["workspaceId", "sourceId"]) | ||
| 161 | .index("by_artifactId", ["artifactId"]), | ||
| 162 | sourceIngestArtifactBatches: defineTable(SourceIngestArtifactBatchSchema) | ||
| 163 | .index("by_domainId", ["id"]) | ||
| 164 | .index("by_workspaceId_sourceId", ["workspaceId", "sourceId"]) | ||
| 165 | .index("by_workspaceId_sourceId_artifactId_batchIndex", [ | ||
| 166 | "workspaceId", | ||
| 167 | "sourceId", | ||
| 168 | "artifactId", | ||
| 169 | "batchIndex", | ||
| 170 | ]) | ||
| 171 | .index("by_artifactId", ["artifactId"]), | ||
| 172 | workspaceToolIndex: defineTable(WorkspaceToolIndexSchema) | ||
| 173 | .index("by_domainId", ["id"]) | ||
| 174 | .index("by_workspaceId", ["workspaceId"]) | ||
| 175 | .index("by_workspaceId_sourceId", ["workspaceId", "sourceId"]) | ||
| 176 | .index("by_workspaceId_namespace", ["workspaceId", "namespace"]) | ||
| 177 | .index("by_workspaceId_pathLower", ["workspaceId", "pathLower"]) | ||
| 178 | .index("by_workspaceId_normalizedPath", ["workspaceId", "normalizedPath"]) | ||
| 179 | .index("by_workspaceId_operationHash", ["workspaceId", "operationHash"]) | ||
| 180 | .searchIndex("search_text", { | ||
| 181 | searchField: "searchText", | ||
| 182 | filterFields: ["workspaceId", "sourceId", "status", "namespace"], | ||
| 183 | }), | ||
| 184 | sourceCredentialBindings: defineTable(SourceCredentialBindingSchema) | ||
| 185 | .index("by_domainId", ["id"]) | ||
| 186 | .index("by_credentialId", ["credentialId"]) | ||
| 187 | .index("by_workspaceId", ["workspaceId"]) | ||
| 188 | .index("by_organizationId", ["organizationId"]) | ||
| 189 | .index("by_accountId", ["accountId"]) | ||
| 190 | .index("by_sourceKey", ["sourceKey"]), | ||
| 191 | oauthTokens: defineTable(OAuthTokenSchema) | ||
| 192 | .index("by_domainId", ["id"]) | ||
| 193 | .index("by_workspaceId", ["workspaceId"]) | ||
| 194 | .index("by_organizationId", ["organizationId"]) | ||
| 195 | .index("by_accountId", ["accountId"]) | ||
| 196 | .index("by_sourceId", ["sourceId"]), | ||
| 197 | policies: defineTable(PolicySchema) | ||
| 198 | .index("by_domainId", ["id"]) | ||
| 199 | .index("by_workspaceId", ["workspaceId"]), | ||
| 200 | storageInstances: defineTable(StorageInstanceSchema) | ||
| 201 | .index("by_domainId", ["id"]) | ||
| 202 | .index("by_workspaceId", ["workspaceId"]) | ||
| 203 | .index("by_organizationId", ["organizationId"]), | ||
| 204 | storageFileEntries: defineTable(StorageFileEntrySchema) | ||
| 205 | .index("by_domainId", ["id"]) | ||
| 206 | .index("by_storageInstanceId", ["storageInstanceId"]) | ||
| 207 | .index("by_storageInstanceId_path", ["storageInstanceId", "path"]), | ||
| 208 | storageKvEntries: defineTable(StorageKvEntrySchema) | ||
| 209 | .index("by_domainId", ["id"]) | ||
| 210 | .index("by_storageInstanceId", ["storageInstanceId"]) | ||
| 211 | .index("by_storageInstanceId_key", ["storageInstanceId", "key"]), | ||
| 212 | storageSqlKvEntries: defineTable(StorageSqlKvEntrySchema) | ||
| 213 | .index("by_domainId", ["id"]) | ||
| 214 | .index("by_storageInstanceId", ["storageInstanceId"]) | ||
| 215 | .index("by_storageInstanceId_key", ["storageInstanceId", "key"]), | ||
| 216 | approvals: defineTable(ApprovalSchema) | ||
| 217 | .index("by_domainId", ["id"]) | ||
| 218 | .index("by_workspaceId", ["workspaceId"]) | ||
| 219 | .index("by_taskRunId", ["taskRunId"]) | ||
| 220 | .index("by_taskRunId_callId", ["taskRunId", "callId"]), | ||
| 221 | taskRuns: defineTable(TaskRunSchema) | ||
| 222 | .index("by_domainId", ["id"]) | ||
| 223 | .index("by_workspaceId", ["workspaceId"]) | ||
| 224 | .index("by_sessionId", ["sessionId"]), | ||
| 225 | syncStates: defineTable(SyncStateSchema) | ||
| 226 | .index("by_domainId", ["id"]) | ||
| 227 | .index("by_workspaceId", ["workspaceId"]), | ||
| 228 | events: defineTable(EventEnvelopeSchema) | ||
| 229 | .index("by_domainId", ["id"]) | ||
| 230 | .index("by_workspaceId", ["workspaceId"]) | ||
| 231 | .index("by_workspaceId_sequence", ["workspaceId", "sequence"]), | ||
| 232 | }); | ||
| 233 | |||
| 234 | export type ExecutorConfectTables = TablesFromSchemaDefinition<typeof executorConfectSchema>; | ||
| 235 | |||
| 236 | export default executorConfectSchema.convexSchemaDefinition; | ||
| @@ -0,0 +1,1686 @@ | |||
| 1 | import { | ||
| 2 | PersistentToolApprovalPolicyStoreError, | ||
| 3 | RuntimeAdapterError, | ||
| 4 | ToolProviderError, | ||
| 5 | createPersistentToolApprovalPolicy, | ||
| 6 | makeOpenApiToolProvider, | ||
| 7 | makeToolProviderRegistry, | ||
| 8 | type PersistentToolApprovalRecord, | ||
| 9 | type PersistentToolApprovalStore, | ||
| 10 | type ToolApprovalPolicy, | ||
| 11 | type ToolRegistry, | ||
| 12 | type ToolRegistryCatalogNamespacesInput, | ||
| 13 | type ToolRegistryCatalogNamespacesOutput, | ||
| 14 | type ToolRegistryCatalogToolsInput, | ||
| 15 | type ToolRegistryCatalogToolsOutput, | ||
| 16 | type ToolRegistryDiscoverInput, | ||
| 17 | type ToolRegistryDiscoverOutput, | ||
| 18 | type ToolRegistryToolSummary, | ||
| 19 | } from "@executor-v2/engine"; | ||
| 20 | import { | ||
| 21 | ApprovalSchema, | ||
| 22 | OpenApiInvocationPayloadSchema, | ||
| 23 | type Approval, | ||
| 24 | type CanonicalToolDescriptor, | ||
| 25 | type Source, | ||
| 26 | } from "@executor-v2/schema"; | ||
| 27 | import type { RuntimeToolCallResult } from "@executor-v2/sdk"; | ||
| 28 | import { v } from "convex/values"; | ||
| 29 | import * as Effect from "effect/Effect"; | ||
| 30 | import * as ParseResult from "effect/ParseResult"; | ||
| 31 | import * as Schema from "effect/Schema"; | ||
| 32 | |||
| 33 | import { internal } from "./_generated/api"; | ||
| 34 | import { internalMutation, type ActionCtx } from "./_generated/server"; | ||
| 35 | |||
| 36 | const runtimeInternal = internal as any; | ||
| 37 | |||
| 38 | const decodeApproval = Schema.decodeUnknownSync(ApprovalSchema); | ||
| 39 | const decodeOpenApiInvocationPayload = Schema.decodeUnknownSync(OpenApiInvocationPayloadSchema); | ||
| 40 | |||
| 41 | const sourceToolRegistryRuntimeKind = "source-tool-registry"; | ||
| 42 | const defaultPendingRetryAfterMs = 1_000; | ||
| 43 | const maxCatalogNamespacesLimit = 5_000; | ||
| 44 | const maxCatalogToolsLimit = 50_000; | ||
| 45 | const maxUnknownToolSuggestions = 3; | ||
| 46 | |||
| 47 | const readBooleanFlag = (value: string | undefined): boolean => { | ||
| 48 | const normalized = value?.trim().toLowerCase(); | ||
| 49 | return normalized === "1" || normalized === "true" || normalized === "yes"; | ||
| 50 | }; | ||
| 51 | |||
| 52 | const requireToolApprovalsByDefault = readBooleanFlag( | ||
| 53 | process.env.CONVEX_REQUIRE_TOOL_APPROVALS, | ||
| 54 | ); | ||
| 55 | |||
| 56 | const stripConvexSystemFields = ( | ||
| 57 | value: Record<string, unknown>, | ||
| 58 | ): Record<string, unknown> => { | ||
| 59 | const { _id: _ignoredId, _creationTime: _ignoredCreationTime, ...rest } = value; | ||
| 60 | return rest; | ||
| 61 | }; | ||
| 62 | |||
| 63 | const toRuntimeAdapterError = ( | ||
| 64 | operation: string, | ||
| 65 | message: string, | ||
| 66 | details: string | null, | ||
| 67 | ): RuntimeAdapterError => | ||
| 68 | new RuntimeAdapterError({ | ||
| 69 | operation, | ||
| 70 | runtimeKind: sourceToolRegistryRuntimeKind, | ||
| 71 | message, | ||
| 72 | details, | ||
| 73 | }); | ||
| 74 | |||
| 75 | const normalizePendingRetryAfterMs = (value: number | undefined): number => { | ||
| 76 | if (typeof value !== "number" || !Number.isFinite(value) || value < 0) { | ||
| 77 | return defaultPendingRetryAfterMs; | ||
| 78 | } | ||
| 79 | |||
| 80 | return Math.round(value); | ||
| 81 | }; | ||
| 82 | |||
| 83 | const normalizeDeniedError = (value: string | undefined, toolPath: string): string => { | ||
| 84 | const normalized = value?.trim(); | ||
| 85 | if (normalized && normalized.length > 0) { | ||
| 86 | return normalized; | ||
| 87 | } | ||
| 88 | |||
| 89 | return `Tool call denied: ${toolPath}`; | ||
| 90 | }; | ||
| 91 | |||
| 92 | const toToolCallResultFromDecision = ( | ||
| 93 | decision: | ||
| 94 | | { kind: "approved" } | ||
| 95 | | { kind: "pending"; approvalId: string; retryAfterMs?: number; error?: string } | ||
| 96 | | { kind: "denied"; error: string }, | ||
| 97 | toolPath: string, | ||
| 98 | ): RuntimeToolCallResult => { | ||
| 99 | if (decision.kind === "approved") { | ||
| 100 | return { | ||
| 101 | ok: true, | ||
| 102 | value: undefined, | ||
| 103 | }; | ||
| 104 | } | ||
| 105 | |||
| 106 | if (decision.kind === "pending") { | ||
| 107 | return { | ||
| 108 | ok: false, | ||
| 109 | kind: "pending", | ||
| 110 | approvalId: decision.approvalId, | ||
| 111 | retryAfterMs: normalizePendingRetryAfterMs(decision.retryAfterMs), | ||
| 112 | error: decision.error, | ||
| 113 | }; | ||
| 114 | } | ||
| 115 | |||
| 116 | return { | ||
| 117 | ok: false, | ||
| 118 | kind: "denied", | ||
| 119 | error: normalizeDeniedError(decision.error, toolPath), | ||
| 120 | }; | ||
| 121 | }; | ||
| 122 | |||
| 123 | const serializeInputPreview = (input: Record<string, unknown> | undefined): string => { | ||
| 124 | try { | ||
| 125 | return JSON.stringify(input ?? {}); | ||
| 126 | } catch { | ||
| 127 | return "{}"; | ||
| 128 | } | ||
| 129 | }; | ||
| 130 | |||
| 131 | const toPersistentApprovalStoreError = ( | ||
| 132 | operation: string, | ||
| 133 | message: string, | ||
| 134 | details: string | null, | ||
| 135 | ): PersistentToolApprovalPolicyStoreError => | ||
| 136 | new PersistentToolApprovalPolicyStoreError({ | ||
| 137 | operation, | ||
| 138 | message, | ||
| 139 | details, | ||
| 140 | }); | ||
| 141 | |||
| 142 | const toPersistentApprovalRecord = ( | ||
| 143 | approval: Approval, | ||
| 144 | ): PersistentToolApprovalRecord => ({ | ||
| 145 | approvalId: approval.id, | ||
| 146 | workspaceId: approval.workspaceId, | ||
| 147 | runId: approval.taskRunId, | ||
| 148 | callId: approval.callId, | ||
| 149 | toolPath: approval.toolPath, | ||
| 150 | status: approval.status, | ||
| 151 | reason: approval.reason, | ||
| 152 | }); | ||
| 153 | |||
| 154 | const normalizeToolPathForLookup = (path: string): string => | ||
| 155 | path | ||
| 156 | .trim() | ||
| 157 | .toLowerCase() | ||
| 158 | .replace(/[^a-z0-9]+/g, ".") | ||
| 159 | .replace(/\.+/g, ".") | ||
| 160 | .replace(/^\.|\.$/g, ""); | ||
| 161 | |||
| 162 | const safeJsonParse = (value: string): unknown => { | ||
| 163 | try { | ||
| 164 | return JSON.parse(value); | ||
| 165 | } catch { | ||
| 166 | return null; | ||
| 167 | } | ||
| 168 | }; | ||
| 169 | |||
| 170 | const jsonObjectFromUnknown = (value: unknown): Record<string, unknown> => { | ||
| 171 | if (!value || typeof value !== "object" || Array.isArray(value)) { | ||
| 172 | return {}; | ||
| 173 | } | ||
| 174 | |||
| 175 | return value as Record<string, unknown>; | ||
| 176 | }; | ||
| 177 | |||
| 178 | const normalizeHeaderString = (value: unknown): string | null => { | ||
| 179 | if (typeof value !== "string") { | ||
| 180 | return null; | ||
| 181 | } | ||
| 182 | |||
| 183 | const trimmed = value.trim(); | ||
| 184 | return trimmed.length > 0 ? trimmed : null; | ||
| 185 | }; | ||
| 186 | |||
| 187 | const parseSourceConfig = (source: Source): Record<string, unknown> => | ||
| 188 | jsonObjectFromUnknown(safeJsonParse(source.configJson)); | ||
| 189 | |||
| 190 | const collectConfiguredHeadersFromSourceConfig = ( | ||
| 191 | config: Record<string, unknown>, | ||
| 192 | ): Record<string, string> => { | ||
| 193 | const headers = jsonObjectFromUnknown(config.headers); | ||
| 194 | const nextHeaders: Record<string, string> = {}; | ||
| 195 | |||
| 196 | for (const [rawKey, rawValue] of Object.entries(headers)) { | ||
| 197 | const key = normalizeHeaderString(rawKey); | ||
| 198 | const value = normalizeHeaderString(rawValue); | ||
| 199 | if (key && value) { | ||
| 200 | nextHeaders[key] = value; | ||
| 201 | } | ||
| 202 | } | ||
| 203 | |||
| 204 | return nextHeaders; | ||
| 205 | }; | ||
| 206 | |||
| 207 | const collectAuthHeadersFromSourceConfig = ( | ||
| 208 | config: Record<string, unknown>, | ||
| 209 | ): Record<string, string> => { | ||
| 210 | const auth = jsonObjectFromUnknown(config.auth); | ||
| 211 | const authType = normalizeHeaderString(auth.type)?.toLowerCase(); | ||
| 212 | const nextHeaders: Record<string, string> = {}; | ||
| 213 | |||
| 214 | if (authType === "bearer") { | ||
| 215 | const token = normalizeHeaderString(auth.token) ?? normalizeHeaderString(auth.value); | ||
| 216 | if (token) { | ||
| 217 | nextHeaders.Authorization = `Bearer ${token}`; | ||
| 218 | } | ||
| 219 | } | ||
| 220 | |||
| 221 | if (authType === "apikey" || authType === "api_key") { | ||
| 222 | const token = normalizeHeaderString(auth.value) ?? normalizeHeaderString(auth.token); | ||
| 223 | if (token) { | ||
| 224 | const headerName = normalizeHeaderString(auth.header) ?? "Authorization"; | ||
| 225 | nextHeaders[headerName] = token; | ||
| 226 | } | ||
| 227 | } | ||
| 228 | |||
| 229 | if (authType === "basic") { | ||
| 230 | const username = normalizeHeaderString(auth.username); | ||
| 231 | const password = normalizeHeaderString(auth.password); | ||
| 232 | if (username && password && typeof btoa === "function") { | ||
| 233 | nextHeaders.Authorization = `Basic ${btoa(`${username}:${password}`)}`; | ||
| 234 | } | ||
| 235 | } | ||
| 236 | |||
| 237 | return nextHeaders; | ||
| 238 | }; | ||
| 239 | |||
| 240 | const mergeHeaders = (...sets: ReadonlyArray<Record<string, string>>): Record<string, string> => { | ||
| 241 | const merged: Record<string, string> = {}; | ||
| 242 | const keyByLower = new Map<string, string>(); | ||
| 243 | |||
| 244 | for (const headers of sets) { | ||
| 245 | for (const [rawKey, rawValue] of Object.entries(headers)) { | ||
| 246 | const key = rawKey.trim(); | ||
| 247 | const value = rawValue.trim(); | ||
| 248 | if (key.length === 0 || value.length === 0) { | ||
| 249 | continue; | ||
| 250 | } | ||
| 251 | |||
| 252 | const normalizedKey = key.toLowerCase(); | ||
| 253 | const existingKey = keyByLower.get(normalizedKey); | ||
| 254 | if (existingKey && existingKey !== key) { | ||
| 255 | delete merged[existingKey]; | ||
| 256 | } | ||
| 257 | |||
| 258 | keyByLower.set(normalizedKey, key); | ||
| 259 | merged[key] = value; | ||
| 260 | } | ||
| 261 | } | ||
| 262 | |||
| 263 | return merged; | ||
| 264 | }; | ||
| 265 | |||
| 266 | const resolveSourceCredentialHeadersForInvocation = async ( | ||
| 267 | ctx: ActionCtx, | ||
| 268 | source: Source, | ||
| 269 | ): Promise<Record<string, string>> => { | ||
| 270 | try { | ||
| 271 | const resolved = (await ctx.runAction( | ||
| 272 | runtimeInternal.control_plane.credentials.resolveSourceCredentialHeadersForIngest, | ||
| 273 | { | ||
| 274 | workspaceId: source.workspaceId, | ||
| 275 | sourceId: source.id, | ||
| 276 | sourceName: source.name, | ||
| 277 | sourceEndpoint: source.endpoint, | ||
| 278 | }, | ||
| 279 | )) as { headers?: unknown }; | ||
| 280 | |||
| 281 | const headers = jsonObjectFromUnknown(resolved.headers); | ||
| 282 | const normalized: Record<string, string> = {}; | ||
| 283 | |||
| 284 | for (const [rawKey, rawValue] of Object.entries(headers)) { | ||
| 285 | const key = normalizeHeaderString(rawKey); | ||
| 286 | const value = normalizeHeaderString(rawValue); | ||
| 287 | if (key && value) { | ||
| 288 | normalized[key] = value; | ||
| 289 | } | ||
| 290 | } | ||
| 291 | |||
| 292 | return normalized; | ||
| 293 | } catch { | ||
| 294 | return {}; | ||
| 295 | } | ||
| 296 | }; | ||
| 297 | |||
| 298 | const resolveSourceHeadersForInvocation = async ( | ||
| 299 | ctx: ActionCtx, | ||
| 300 | source: Source, | ||
| 301 | ): Promise<Record<string, string>> => { | ||
| 302 | const config = parseSourceConfig(source); | ||
| 303 | |||
| 304 | return mergeHeaders( | ||
| 305 | collectConfiguredHeadersFromSourceConfig(config), | ||
| 306 | collectAuthHeadersFromSourceConfig(config), | ||
| 307 | await resolveSourceCredentialHeadersForInvocation(ctx, source), | ||
| 308 | ); | ||
| 309 | }; | ||
| 310 | |||
| 311 | const headersToRecord = (headers: Headers): Record<string, string> => { | ||
| 312 | const record: Record<string, string> = {}; | ||
| 313 | headers.forEach((value, key) => { | ||
| 314 | record[key] = value; | ||
| 315 | }); | ||
| 316 | return record; | ||
| 317 | }; | ||
| 318 | |||
| 319 | const GraphqlInvocationArgSchema = Schema.Struct({ | ||
| 320 | name: Schema.String, | ||
| 321 | description: Schema.NullOr(Schema.String), | ||
| 322 | required: Schema.Boolean, | ||
| 323 | type: Schema.String, | ||
| 324 | defaultValue: Schema.NullOr(Schema.String), | ||
| 325 | }); | ||
| 326 | |||
| 327 | const GraphqlRawInvocationSchema = Schema.Struct({ | ||
| 328 | kind: Schema.Literal("graphql_raw"), | ||
| 329 | endpoint: Schema.String, | ||
| 330 | }); | ||
| 331 | |||
| 332 | const GraphqlFieldInvocationSchema = Schema.Struct({ | ||
| 333 | kind: Schema.Literal("graphql_field"), | ||
| 334 | endpoint: Schema.String, | ||
| 335 | operationType: Schema.Literal("query", "mutation"), | ||
| 336 | fieldName: Schema.String, | ||
| 337 | args: Schema.Array(GraphqlInvocationArgSchema), | ||
| 338 | }); | ||
| 339 | |||
| 340 | const GraphqlInvocationPayloadSchema = Schema.Union( | ||
| 341 | GraphqlRawInvocationSchema, | ||
| 342 | GraphqlFieldInvocationSchema, | ||
| 343 | ); | ||
| 344 | |||
| 345 | type GraphqlInvocationPayload = typeof GraphqlInvocationPayloadSchema.Type; | ||
| 346 | |||
| 347 | const decodeGraphqlInvocationPayload = Schema.decodeUnknownSync(GraphqlInvocationPayloadSchema); | ||
| 348 | |||
| 349 | const McpInvocationPayloadSchema = Schema.Struct({ | ||
| 350 | kind: Schema.Literal("mcp_tool"), | ||
| 351 | endpoint: Schema.String, | ||
| 352 | transport: Schema.Literal("streamable-http", "sse"), | ||
| 353 | queryParams: Schema.Record({ | ||
| 354 | key: Schema.String, | ||
| 355 | value: Schema.String, | ||
| 356 | }), | ||
| 357 | toolName: Schema.String, | ||
| 358 | inputSchema: Schema.optional(Schema.Unknown), | ||
| 359 | outputSchema: Schema.optional(Schema.Unknown), | ||
| 360 | }); | ||
| 361 | |||
| 362 | type McpInvocationPayload = typeof McpInvocationPayloadSchema.Type; | ||
| 363 | |||
| 364 | const decodeMcpInvocationPayload = Schema.decodeUnknownSync(McpInvocationPayloadSchema); | ||
| 365 | |||
| 366 | const asOptionalString = (value: unknown): string | null => | ||
| 367 | typeof value === "string" && value.trim().length > 0 ? value : null; | ||
| 368 | |||
| 369 | const normalizeInvokeInput = (input: unknown): Record<string, unknown> => { | ||
| 370 | if (!input || typeof input !== "object" || Array.isArray(input)) { | ||
| 371 | return {}; | ||
| 372 | } | ||
| 373 | |||
| 374 | return input as Record<string, unknown>; | ||
| 375 | }; | ||
| 376 | |||
| 377 | const createGraphqlOperationQuery = ( | ||
| 378 | payload: Extract<GraphqlInvocationPayload, { kind: "graphql_field" }>, | ||
| 379 | args: Record<string, unknown>, | ||
| 380 | ): { | ||
| 381 | query: string; | ||
| 382 | variables: Record<string, unknown>; | ||
| 383 | } => { | ||
| 384 | const definitions: Array<string> = []; | ||
| 385 | const callArgs: Array<string> = []; | ||
| 386 | const variables: Record<string, unknown> = {}; | ||
| 387 | |||
| 388 | for (const arg of payload.args) { | ||
| 389 | const value = args[arg.name]; | ||
| 390 | |||
| 391 | if (value === undefined || value === null) { | ||
| 392 | if (arg.required) { | ||
| 393 | throw new Error(`Missing required GraphQL argument: ${arg.name}`); | ||
| 394 | } | ||
| 395 | |||
| 396 | continue; | ||
| 397 | } | ||
| 398 | |||
| 399 | const varType = arg.type.trim().length > 0 ? arg.type : "String"; | ||
| 400 | definitions.push(`$${arg.name}: ${varType}`); | ||
| 401 | callArgs.push(`${arg.name}: $${arg.name}`); | ||
| 402 | variables[arg.name] = value; | ||
| 403 | } | ||
| 404 | |||
| 405 | const variableDefs = definitions.length > 0 ? `(${definitions.join(", ")})` : ""; | ||
| 406 | const fieldArgs = callArgs.length > 0 ? `(${callArgs.join(", ")})` : ""; | ||
| 407 | const selectionSet = asOptionalString(args.selectionSet); | ||
| 408 | const fieldSelection = | ||
| 409 | selectionSet && selectionSet.length > 0 | ||
| 410 | ? `${payload.fieldName}${fieldArgs} { ${selectionSet} }` | ||
| 411 | : `${payload.fieldName}${fieldArgs}`; | ||
| 412 | const query = `${payload.operationType}${variableDefs} { ${fieldSelection} }`; | ||
| 413 | |||
| 414 | return { query, variables }; | ||
| 415 | }; | ||
| 416 | |||
| 417 | const graphqlResponseBody = async (response: Response): Promise<unknown> => { | ||
| 418 | const contentType = response.headers.get("content-type")?.toLowerCase() ?? ""; | ||
| 419 | if (contentType.includes("application/json")) { | ||
| 420 | return await response.json(); | ||
| 421 | } | ||
| 422 | |||
| 423 | return await response.text(); | ||
| 424 | }; | ||
| 425 | |||
| 426 | const createMcpEndpointUrl = (payload: McpInvocationPayload): URL => { | ||
| 427 | const url = new URL(payload.endpoint); | ||
| 428 | |||
| 429 | for (const [key, value] of Object.entries(payload.queryParams)) { | ||
| 430 | url.searchParams.set(key, value); | ||
| 431 | } | ||
| 432 | |||
| 433 | return url; | ||
| 434 | }; | ||
| 435 | |||
| 436 | const postMcpJsonRpc = async ( | ||
| 437 | endpoint: URL, | ||
| 438 | body: unknown, | ||
| 439 | sessionId: string | null, | ||
| 440 | sourceHeaders: Record<string, string>, | ||
| 441 | ): Promise<Response> => { | ||
| 442 | const headers = new Headers({ | ||
| 443 | "content-type": "application/json", | ||
| 444 | accept: "application/json, text/event-stream", | ||
| 445 | }); | ||
| 446 | |||
| 447 | for (const [key, value] of Object.entries(sourceHeaders)) { | ||
| 448 | headers.set(key, value); | ||
| 449 | } | ||
| 450 | |||
| 451 | if (sessionId && sessionId.trim().length > 0) { | ||
| 452 | headers.set("mcp-session-id", sessionId); | ||
| 453 | } | ||
| 454 | |||
| 455 | return await fetch(endpoint, { | ||
| 456 | method: "POST", | ||
| 457 | headers, | ||
| 458 | body: JSON.stringify(body), | ||
| 459 | }); | ||
| 460 | }; | ||
| 461 | |||
| 462 | const decodeMcpJsonResponse = async (response: Response): Promise<Record<string, unknown>> => { | ||
| 463 | const contentType = response.headers.get("content-type")?.toLowerCase() ?? ""; | ||
| 464 | |||
| 465 | if (!contentType.includes("application/json")) { | ||
| 466 | const text = await response.text(); | ||
| 467 | return { raw: text }; | ||
| 468 | } | ||
| 469 | |||
| 470 | return jsonObjectFromUnknown(await response.json()); | ||
| 471 | }; | ||
| 472 | |||
| 473 | const describeOutput = (value: unknown): string => { | ||
| 474 | if (typeof value === "string") { | ||
| 475 | return value; | ||
| 476 | } | ||
| 477 | |||
| 478 | try { | ||
| 479 | return JSON.stringify(value); | ||
| 480 | } catch { | ||
| 481 | return String(value); | ||
| 482 | } | ||
| 483 | }; | ||
| 484 | |||
| 485 | const deriveHintFromSchemaJson = ( | ||
| 486 | schemaJson: string | null | undefined, | ||
| 487 | fallback: string, | ||
| 488 | ): string => { | ||
| 489 | if (!schemaJson) { | ||
| 490 | return fallback; | ||
| 491 | } | ||
| 492 | |||
| 493 | const schema = safeJsonParse(schemaJson); | ||
| 494 | if (!schema || typeof schema !== "object" || Array.isArray(schema)) { | ||
| 495 | return fallback; | ||
| 496 | } | ||
| 497 | |||
| 498 | const schemaRecord = schema as Record<string, unknown>; | ||
| 499 | const title = schemaRecord.title; | ||
| 500 | if (typeof title === "string" && title.trim().length > 0) { | ||
| 501 | return title.trim(); | ||
| 502 | } | ||
| 503 | |||
| 504 | const type = schemaRecord.type; | ||
| 505 | if (type === "object") { | ||
| 506 | const properties = schemaRecord.properties; | ||
| 507 | if (properties && typeof properties === "object" && !Array.isArray(properties)) { | ||
| 508 | const keys = Object.keys(properties); | ||
| 509 | if (keys.length > 0) { | ||
| 510 | const shown = keys.slice(0, 3).join(", "); | ||
| 511 | return keys.length <= 3 ? `object { ${shown} }` : `object { ${shown}, ... }`; | ||
| 512 | } | ||
| 513 | } | ||
| 514 | |||
| 515 | return "object"; | ||
| 516 | } | ||
| 517 | |||
| 518 | if (type === "array") { | ||
| 519 | return "array"; | ||
| 520 | } | ||
| 521 | |||
| 522 | if (typeof type === "string") { | ||
| 523 | return type; | ||
| 524 | } | ||
| 525 | |||
| 526 | return fallback; | ||
| 527 | }; | ||
| 528 | |||
| 529 | type WorkspaceToolIndexRow = { | ||
| 530 | workspaceId: string; | ||
| 531 | sourceId: string; | ||
| 532 | sourceName: string; | ||
| 533 | sourceKind: string; | ||
| 534 | artifactId: string; | ||
| 535 | toolId: string; | ||
| 536 | protocol: string; | ||
| 537 | namespace: string; | ||
| 538 | path: string; | ||
| 539 | pathLower: string; | ||
| 540 | normalizedPath: string; | ||
| 541 | name: string; | ||
| 542 | description: string | null; | ||
| 543 | operationHash: string; | ||
| 544 | approvalMode: string; | ||
| 545 | status: string; | ||
| 546 | refHintTableJson?: string | null; | ||
| 547 | }; | ||
| 548 | |||
| 549 | type ArtifactToolRow = { | ||
| 550 | artifactId: string; | ||
| 551 | protocol: string; | ||
| 552 | toolId: string; | ||
| 553 | name: string; | ||
| 554 | description: string | null; | ||
| 555 | canonicalPath: string; | ||
| 556 | operationHash: string; | ||
| 557 | invocationJson: string; | ||
| 558 | inputSchemaJson?: string | null; | ||
| 559 | outputSchemaJson?: string | null; | ||
| 560 | metadataJson?: string | null; | ||
| 561 | }; | ||
| 562 | |||
| 563 | const toToolProviderDetails = (cause: unknown): string => | ||
| 564 | ParseResult.isParseError(cause) | ||
| 565 | ? ParseResult.TreeFormatter.formatErrorSync(cause) | ||
| 566 | : String(cause); | ||
| 567 | |||
| 568 | const toToolProviderError = ( | ||
| 569 | providerKind: "openapi" | "graphql" | "mcp", | ||
| 570 | operation: string, | ||
| 571 | message: string, | ||
| 572 | cause: unknown, | ||
| 573 | ): ToolProviderError => | ||
| 574 | new ToolProviderError({ | ||
| 575 | providerKind, | ||
| 576 | operation, | ||
| 577 | message, | ||
| 578 | details: toToolProviderDetails(cause), | ||
| 579 | }); | ||
| 580 | |||
| 581 | const scoreSummary = (summary: ToolRegistryToolSummary, query: string): number => { | ||
| 582 | if (query.length === 0) { | ||
| 583 | return 1; | ||
| 584 | } | ||
| 585 | |||
| 586 | const lowerQuery = query.toLowerCase(); | ||
| 587 | const lowerPath = summary.path.toLowerCase(); | ||
| 588 | const lowerSource = (summary.source ?? "").toLowerCase(); | ||
| 589 | const lowerDescription = (summary.description ?? "").toLowerCase(); | ||
| 590 | |||
| 591 | if (lowerPath === lowerQuery) { | ||
| 592 | return 100; | ||
| 593 | } | ||
| 594 | |||
| 595 | if (lowerPath.startsWith(lowerQuery)) { | ||
| 596 | return 80; | ||
| 597 | } | ||
| 598 | |||
| 599 | if (lowerPath.includes(lowerQuery)) { | ||
| 600 | return 60; | ||
| 601 | } | ||
| 602 | |||
| 603 | if (lowerSource.includes(lowerQuery)) { | ||
| 604 | return 40; | ||
| 605 | } | ||
| 606 | |||
| 607 | if (lowerDescription.includes(lowerQuery)) { | ||
| 608 | return 30; | ||
| 609 | } | ||
| 610 | |||
| 611 | return 0; | ||
| 612 | }; | ||
| 613 | |||
| 614 | const levenshteinDistance = (left: string, right: string): number => { | ||
| 615 | if (left === right) { | ||
| 616 | return 0; | ||
| 617 | } | ||
| 618 | |||
| 619 | if (left.length === 0) { | ||
| 620 | return right.length; | ||
| 621 | } | ||
| 622 | |||
| 623 | if (right.length === 0) { | ||
| 624 | return left.length; | ||
| 625 | } | ||
| 626 | |||
| 627 | const previous = new Array<number>(right.length + 1); | ||
| 628 | const current = new Array<number>(right.length + 1); | ||
| 629 | |||
| 630 | for (let column = 0; column <= right.length; column += 1) { | ||
| 631 | previous[column] = column; | ||
| 632 | } | ||
| 633 | |||
| 634 | for (let row = 1; row <= left.length; row += 1) { | ||
| 635 | current[0] = row; | ||
| 636 | |||
| 637 | for (let column = 1; column <= right.length; column += 1) { | ||
| 638 | const substitutionCost = left[row - 1] === right[column - 1] ? 0 : 1; | ||
| 639 | current[column] = Math.min( | ||
| 640 | previous[column] + 1, | ||
| 641 | current[column - 1] + 1, | ||
| 642 | previous[column - 1] + substitutionCost, | ||
| 643 | ); | ||
| 644 | } | ||
| 645 | |||
| 646 | for (let column = 0; column <= right.length; column += 1) { | ||
| 647 | previous[column] = current[column]; | ||
| 648 | } | ||
| 649 | } | ||
| 650 | |||
| 651 | return previous[right.length] ?? right.length; | ||
| 652 | }; | ||
| 653 | |||
| 654 | const uniquePaths = (paths: ReadonlyArray<string>): Array<string> => { | ||
| 655 | const seen = new Set<string>(); | ||
| 656 | const ordered: Array<string> = []; | ||
| 657 | |||
| 658 | for (const path of paths) { | ||
| 659 | if (!seen.has(path)) { | ||
| 660 | seen.add(path); | ||
| 661 | ordered.push(path); | ||
| 662 | } | ||
| 663 | |||
| 664 | if (ordered.length >= maxUnknownToolSuggestions) { | ||
| 665 | break; | ||
| 666 | } | ||
| 667 | } | ||
| 668 | |||
| 669 | return ordered; | ||
| 670 | }; | ||
| 671 | |||
| 672 | const toToolSummary = ( | ||
| 673 | row: WorkspaceToolIndexRow, | ||
| 674 | options: { | ||
| 675 | includeSchemas: boolean; | ||
| 676 | compact: boolean; | ||
| 677 | artifactTool?: ArtifactToolRow | null; | ||
| 678 | }, | ||
| 679 | ): ToolRegistryToolSummary => { | ||
| 680 | const inputSchemaJson = options.artifactTool?.inputSchemaJson ?? undefined; | ||
| 681 | const outputSchemaJson = options.artifactTool?.outputSchemaJson ?? undefined; | ||
| 682 | |||
| 683 | return { | ||
| 684 | path: row.path, | ||
| 685 | source: row.sourceName, | ||
| 686 | approval: row.approvalMode === "required" ? "required" : "auto", | ||
| 687 | description: options.compact ? undefined : row.description ?? undefined, | ||
| 688 | inputHint: options.compact | ||
| 689 | ? undefined | ||
| 690 | : options.artifactTool | ||
| 691 | ? deriveHintFromSchemaJson(inputSchemaJson ?? null, "input") | ||
| 692 | : undefined, | ||
| 693 | outputHint: options.compact | ||
| 694 | ? undefined | ||
| 695 | : options.artifactTool | ||
| 696 | ? deriveHintFromSchemaJson(outputSchemaJson ?? null, "output") | ||
| 697 | : undefined, | ||
| 698 | typing: | ||
| 699 | options.includeSchemas && (inputSchemaJson || outputSchemaJson) | ||
| 700 | ? { | ||
| 701 | inputSchemaJson, | ||
| 702 | outputSchemaJson, | ||
| 703 | refHintKeys: [], | ||
| 704 | } | ||
| 705 | : undefined, | ||
| 706 | }; | ||
| 707 | }; | ||
| 708 | |||
| 709 | const toSearchScoringSummary = (row: WorkspaceToolIndexRow): ToolRegistryToolSummary => ({ | ||
| 710 | path: row.path, | ||
| 711 | source: row.sourceName, | ||
| 712 | approval: row.approvalMode === "required" ? "required" : "auto", | ||
| 713 | description: row.description ?? undefined, | ||
| 714 | }); | ||
| 715 | |||
| 716 | const hydrateRowsWithArtifactTools = ( | ||
| 717 | ctx: ActionCtx, | ||
| 718 | rows: ReadonlyArray<WorkspaceToolIndexRow>, | ||
| 719 | ): Effect.Effect<Array<{ row: WorkspaceToolIndexRow; artifactTool: ArtifactToolRow | null }>, RuntimeAdapterError> => | ||
| 720 | Effect.forEach( | ||
| 721 | rows, | ||
| 722 | (row) => | ||
| 723 | getArtifactToolEffect(ctx, row.artifactId, row.toolId).pipe( | ||
| 724 | Effect.map((artifactTool) => ({ | ||
| 725 | row, | ||
| 726 | artifactTool, | ||
| 727 | })), | ||
| 728 | ), | ||
| 729 | { concurrency: 8 }, | ||
| 730 | ); | ||
| 731 | |||
| 732 | const parseRefHintTableJson = (value: string | null | undefined): Record<string, string> | null => { | ||
| 733 | if (!value) { | ||
| 734 | return null; | ||
| 735 | } | ||
| 736 | |||
| 737 | const parsed = safeJsonParse(value); | ||
| 738 | if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) { | ||
| 739 | return null; | ||
| 740 | } | ||
| 741 | |||
| 742 | const next: Record<string, string> = {}; | ||
| 743 | for (const [key, raw] of Object.entries(parsed as Record<string, unknown>)) { | ||
| 744 | if (typeof raw === "string") { | ||
| 745 | next[key] = raw; | ||
| 746 | } | ||
| 747 | } | ||
| 748 | |||
| 749 | return Object.keys(next).length > 0 ? next : null; | ||
| 750 | }; | ||
| 751 | |||
| 752 | const mergeRefHintTables = ( | ||
| 753 | rows: ReadonlyArray<WorkspaceToolIndexRow>, | ||
| 754 | includeSchemas: boolean, | ||
| 755 | ): Record<string, string> | undefined => { | ||
| 756 | if (!includeSchemas) { | ||
| 757 | return undefined; | ||
| 758 | } | ||
| 759 | |||
| 760 | const merged: Record<string, string> = {}; | ||
| 761 | for (const row of rows) { | ||
| 762 | const table = parseRefHintTableJson(row.refHintTableJson ?? null); | ||
| 763 | if (!table) { | ||
| 764 | continue; | ||
| 765 | } | ||
| 766 | |||
| 767 | Object.assign(merged, table); | ||
| 768 | } | ||
| 769 | |||
| 770 | return Object.keys(merged).length > 0 ? merged : undefined; | ||
| 771 | }; | ||
| 772 | |||
| 773 | const listWorkspaceToolsEffect = ( | ||
| 774 | ctx: ActionCtx, | ||
| 775 | workspaceId: string, | ||
| 776 | options: { | ||
| 777 | limit: number; | ||
| 778 | sourceId?: string; | ||
| 779 | namespace?: string; | ||
| 780 | }, | ||
| 781 | ): Effect.Effect<Array<WorkspaceToolIndexRow>, RuntimeAdapterError> => | ||
| 782 | Effect.tryPromise({ | ||
| 783 | try: async () => | ||
| 784 | (await ctx.runQuery(runtimeInternal.control_plane.tool_registry.listWorkspaceTools, { | ||
| 785 | workspaceId, | ||
| 786 | limit: options.limit, | ||
| 787 | sourceId: options.sourceId, | ||
| 788 | namespace: options.namespace, | ||
| 789 | includeDisabled: false, | ||
| 790 | })) as Array<WorkspaceToolIndexRow>, | ||
| 791 | catch: (cause) => | ||
| 792 | toRuntimeAdapterError( | ||
| 793 | "list_workspace_tools", | ||
| 794 | "Failed to list indexed workspace tools", | ||
| 795 | String(cause), | ||
| 796 | ), | ||
| 797 | }); | ||
| 798 | |||
| 799 | const searchWorkspaceToolsEffect = ( | ||
| 800 | ctx: ActionCtx, | ||
| 801 | workspaceId: string, | ||
| 802 | options: { | ||
| 803 | query: string; | ||
| 804 | limit: number; | ||
| 805 | sourceId?: string; | ||
| 806 | namespace?: string; | ||
| 807 | }, | ||
| 808 | ): Effect.Effect<Array<WorkspaceToolIndexRow>, RuntimeAdapterError> => | ||
| 809 | Effect.tryPromise({ | ||
| 810 | try: async () => | ||
| 811 | (await ctx.runQuery(runtimeInternal.control_plane.tool_registry.searchWorkspaceTools, { | ||
| 812 | workspaceId, | ||
| 813 | query: options.query, | ||
| 814 | limit: options.limit, | ||
| 815 | sourceId: options.sourceId, | ||
| 816 | namespace: options.namespace, | ||
| 817 | includeDisabled: false, | ||
| 818 | })) as Array<WorkspaceToolIndexRow>, | ||
| 819 | catch: (cause) => | ||
| 820 | toRuntimeAdapterError( | ||
| 821 | "search_workspace_tools", | ||
| 822 | "Failed to search indexed workspace tools", | ||
| 823 | String(cause), | ||
| 824 | ), | ||
| 825 | }); | ||
| 826 | |||
| 827 | const getWorkspaceToolByPathEffect = ( | ||
| 828 | ctx: ActionCtx, | ||
| 829 | workspaceId: string, | ||
| 830 | toolPath: string, | ||
| 831 | ): Effect.Effect<WorkspaceToolIndexRow | null, RuntimeAdapterError> => | ||
| 832 | Effect.tryPromise({ | ||
| 833 | try: async () => | ||
| 834 | (await ctx.runQuery(runtimeInternal.control_plane.tool_registry.getWorkspaceToolByPath, { | ||
| 835 | workspaceId, | ||
| 836 | pathLower: toolPath.toLowerCase(), | ||
| 837 | })) as WorkspaceToolIndexRow | null, | ||
| 838 | catch: (cause) => | ||
| 839 | toRuntimeAdapterError( | ||
| 840 | "resolve_tool_path", | ||
| 841 | "Failed to resolve tool path", | ||
| 842 | String(cause), | ||
| 843 | ), | ||
| 844 | }); | ||
| 845 | |||
| 846 | const listWorkspaceToolsByNormalizedPathEffect = ( | ||
| 847 | ctx: ActionCtx, | ||
| 848 | workspaceId: string, | ||
| 849 | normalizedPath: string, | ||
| 850 | ): Effect.Effect<Array<WorkspaceToolIndexRow>, RuntimeAdapterError> => | ||
| 851 | Effect.tryPromise({ | ||
| 852 | try: async () => | ||
| 853 | (await ctx.runQuery(runtimeInternal.control_plane.tool_registry.listWorkspaceToolsByNormalizedPath, { | ||
| 854 | workspaceId, | ||
| 855 | normalizedPath, | ||
| 856 | limit: 25, | ||
| 857 | })) as Array<WorkspaceToolIndexRow>, | ||
| 858 | catch: (cause) => | ||
| 859 | toRuntimeAdapterError( | ||
| 860 | "resolve_tool_path", | ||
| 861 | "Failed to resolve normalized tool path", | ||
| 862 | String(cause), | ||
| 863 | ), | ||
| 864 | }); | ||
| 865 | |||
| 866 | const getArtifactToolEffect = ( | ||
| 867 | ctx: ActionCtx, | ||
| 868 | artifactId: string, | ||
| 869 | toolId: string, | ||
| 870 | ): Effect.Effect<ArtifactToolRow | null, RuntimeAdapterError> => | ||
| 871 | Effect.tryPromise({ | ||
| 872 | try: async () => | ||
| 873 | (await ctx.runQuery(runtimeInternal.control_plane.tool_registry.getArtifactTool, { | ||
| 874 | artifactId, | ||
| 875 | toolId, | ||
| 876 | })) as ArtifactToolRow | null, | ||
| 877 | catch: (cause) => | ||
| 878 | toRuntimeAdapterError( | ||
| 879 | "load_artifact_tool", | ||
| 880 | `Failed to load artifact tool: ${artifactId}:${toolId}`, | ||
| 881 | String(cause), | ||
| 882 | ), | ||
| 883 | }); | ||
| 884 | |||
| 885 | const getSourceForInvocationEffect = ( | ||
| 886 | ctx: ActionCtx, | ||
| 887 | workspaceId: string, | ||
| 888 | sourceId: string, | ||
| 889 | ): Effect.Effect<Source | null, RuntimeAdapterError> => | ||
| 890 | Effect.tryPromise({ | ||
| 891 | try: async () => { | ||
| 892 | const source = (await ctx.runQuery(runtimeInternal.control_plane.sources.getSourceForIngest, { | ||
| 893 | sourceId, | ||
| 894 | })) as Source | null; | ||
| 895 | |||
| 896 | if (!source || source.workspaceId !== workspaceId || !source.enabled) { | ||
| 897 | return null; | ||
| 898 | } | ||
| 899 | |||
| 900 | return source; | ||
| 901 | }, | ||
| 902 | catch: (cause) => | ||
| 903 | toRuntimeAdapterError( | ||
| 904 | "load_source", | ||
| 905 | `Failed to load source for invocation: ${sourceId}`, | ||
| 906 | String(cause), | ||
| 907 | ), | ||
| 908 | }); | ||
| 909 | |||
| 910 | const invokeToolWithRegistry = ( | ||
| 911 | ctx: ActionCtx, | ||
| 912 | source: Source, | ||
| 913 | artifactTool: ArtifactToolRow, | ||
| 914 | args: Record<string, unknown>, | ||
| 915 | ): Effect.Effect<{ output: unknown; isError: boolean }, RuntimeAdapterError> => | ||
| 916 | Effect.gen(function* () { | ||
| 917 | const openApiProvider = makeOpenApiToolProvider(); | ||
| 918 | |||
| 919 | const graphqlProvider = { | ||
| 920 | kind: "graphql" as const, | ||
| 921 | invoke: (input: { source: Source | null; tool: CanonicalToolDescriptor; args: unknown }) => | ||
| 922 | Effect.tryPromise({ | ||
| 923 | try: async () => { | ||
| 924 | if (!input.source) { | ||
| 925 | throw new Error("GraphQL provider requires a source"); | ||
| 926 | } | ||
| 927 | |||
| 928 | const payload = decodeGraphqlInvocationPayload(input.tool.providerPayload); | ||
| 929 | const invokeArgs = normalizeInvokeInput(input.args); | ||
| 930 | |||
| 931 | let query: string; | ||
| 932 | let variables: Record<string, unknown> | undefined; | ||
| 933 | let operationName: string | undefined; | ||
| 934 | |||
| 935 | if (payload.kind === "graphql_raw") { | ||
| 936 | const rawQuery = asOptionalString(invokeArgs.query); | ||
| 937 | if (!rawQuery) { | ||
| 938 | throw new Error("Missing required GraphQL query string at args.query"); | ||
| 939 | } | ||
| 940 | |||
| 941 | query = rawQuery; | ||
| 942 | variables = jsonObjectFromUnknown(invokeArgs.variables); | ||
| 943 | operationName = asOptionalString(invokeArgs.operationName) ?? undefined; | ||
| 944 | } else { | ||
| 945 | const built = createGraphqlOperationQuery(payload, invokeArgs); | ||
| 946 | query = built.query; | ||
| 947 | variables = built.variables; | ||
| 948 | operationName = payload.fieldName; | ||
| 949 | } | ||
| 950 | |||
| 951 | const sourceHeaders = await resolveSourceHeadersForInvocation(ctx, input.source); | ||
| 952 | |||
| 953 | const response = await fetch(payload.endpoint, { | ||
| 954 | method: "POST", | ||
| 955 | headers: mergeHeaders( | ||
| 956 | { | ||
| 957 | "content-type": "application/json", | ||
| 958 | }, | ||
| 959 | sourceHeaders, | ||
| 960 | ), | ||
| 961 | body: JSON.stringify({ | ||
| 962 | query, | ||
| 963 | variables, | ||
| 964 | operationName, | ||
| 965 | }), | ||
| 966 | }); | ||
| 967 | |||
| 968 | const body = await graphqlResponseBody(response); | ||
| 969 | const bodyRecord = jsonObjectFromUnknown(body); | ||
| 970 | const hasErrors = Array.isArray(bodyRecord.errors); | ||
| 971 | |||
| 972 | return { | ||
| 973 | output: { | ||
| 974 | status: response.status, | ||
| 975 | headers: headersToRecord(response.headers), | ||
| 976 | body, | ||
| 977 | }, | ||
| 978 | isError: response.status >= 400 || hasErrors, | ||
| 979 | }; | ||
| 980 | }, | ||
| 981 | catch: (cause) => | ||
| 982 | toToolProviderError( | ||
| 983 | "graphql", | ||
| 984 | "invoke_tool", | ||
| 985 | `GraphQL invocation failed for tool: ${input.tool.toolId}`, | ||
| 986 | cause, | ||
| 987 | ), | ||
| 988 | }), | ||
| 989 | }; | ||
| 990 | |||
| 991 | const mcpProvider = { | ||
| 992 | kind: "mcp" as const, | ||
| 993 | invoke: (input: { source: Source | null; tool: CanonicalToolDescriptor; args: unknown }) => | ||
| 994 | Effect.tryPromise({ | ||
| 995 | try: async () => { | ||
| 996 | if (!input.source) { | ||
| 997 | throw new Error("MCP provider requires a source"); | ||
| 998 | } | ||
| 999 | |||
| 1000 | const payload = decodeMcpInvocationPayload(input.tool.providerPayload); | ||
| 1001 | const invokeArgs = normalizeInvokeInput(input.args); | ||
| 1002 | const sourceHeaders = await resolveSourceHeadersForInvocation(ctx, input.source); | ||
| 1003 | |||
| 1004 | if (payload.transport !== "streamable-http") { | ||
| 1005 | throw new Error( | ||
| 1006 | `Unsupported MCP transport for runtime invocation: ${payload.transport}`, | ||
| 1007 | ); | ||
| 1008 | } | ||
| 1009 | |||
| 1010 | const endpoint = createMcpEndpointUrl(payload); | ||
| 1011 | const initializeResponse = await postMcpJsonRpc( | ||
| 1012 | endpoint, | ||
| 1013 | { | ||
| 1014 | jsonrpc: "2.0", | ||
| 1015 | id: `init_${crypto.randomUUID()}`, | ||
| 1016 | method: "initialize", | ||
| 1017 | params: { | ||
| 1018 | protocolVersion: "2024-11-05", | ||
| 1019 | capabilities: {}, | ||
| 1020 | clientInfo: { | ||
| 1021 | name: "executor-v2-runtime", | ||
| 1022 | version: "0.1.0", | ||
| 1023 | }, | ||
| 1024 | }, | ||
| 1025 | }, | ||
| 1026 | null, | ||
| 1027 | sourceHeaders, | ||
| 1028 | ); | ||
| 1029 | const initializeBody = await decodeMcpJsonResponse(initializeResponse); | ||
| 1030 | |||
| 1031 | const sessionId = initializeResponse.headers.get("mcp-session-id"); | ||
| 1032 | |||
| 1033 | if (initializeResponse.status >= 400 || initializeBody.error !== undefined) { | ||
| 1034 | return { | ||
| 1035 | output: { | ||
| 1036 | status: initializeResponse.status, | ||
| 1037 | headers: headersToRecord(initializeResponse.headers), | ||
| 1038 | body: initializeBody, | ||
| 1039 | }, | ||
| 1040 | isError: true, | ||
| 1041 | }; | ||
| 1042 | } | ||
| 1043 | |||
| 1044 | await postMcpJsonRpc( | ||
| 1045 | endpoint, | ||
| 1046 | { | ||
| 1047 | jsonrpc: "2.0", | ||
| 1048 | method: "notifications/initialized", | ||
| 1049 | params: {}, | ||
| 1050 | }, | ||
| 1051 | sessionId, | ||
| 1052 | sourceHeaders, | ||
| 1053 | ); | ||
| 1054 | |||
| 1055 | const callResponse = await postMcpJsonRpc( | ||
| 1056 | endpoint, | ||
| 1057 | { | ||
| 1058 | jsonrpc: "2.0", | ||
| 1059 | id: `call_${crypto.randomUUID()}`, | ||
| 1060 | method: "tools/call", | ||
| 1061 | params: { | ||
| 1062 | name: payload.toolName, | ||
| 1063 | arguments: invokeArgs, | ||
| 1064 | }, | ||
| 1065 | }, | ||
| 1066 | sessionId, | ||
| 1067 | sourceHeaders, | ||
| 1068 | ); | ||
| 1069 | const callBody = await decodeMcpJsonResponse(callResponse); | ||
| 1070 | |||
| 1071 | return { | ||
| 1072 | output: { | ||
| 1073 | status: callResponse.status, | ||
| 1074 | headers: headersToRecord(callResponse.headers), | ||
| 1075 | body: callBody, | ||
| 1076 | }, | ||
| 1077 | isError: callResponse.status >= 400 || callBody.error !== undefined, | ||
| 1078 | }; | ||
| 1079 | }, | ||
| 1080 | catch: (cause) => | ||
| 1081 | toToolProviderError( | ||
| 1082 | "mcp", | ||
| 1083 | "invoke_tool", | ||
| 1084 | `MCP invocation failed for tool: ${input.tool.toolId}`, | ||
| 1085 | cause, | ||
| 1086 | ), | ||
| 1087 | }), | ||
| 1088 | }; | ||
| 1089 | |||
| 1090 | const registry = makeToolProviderRegistry([ | ||
| 1091 | { | ||
| 1092 | kind: "openapi", | ||
| 1093 | invoke: (input) => openApiProvider.invoke(input), | ||
| 1094 | }, | ||
| 1095 | graphqlProvider, | ||
| 1096 | mcpProvider, | ||
| 1097 | ]); | ||
| 1098 | |||
| 1099 | const providerKind = artifactTool.protocol; | ||
| 1100 | const invocationPayload = safeJsonParse(artifactTool.invocationJson); | ||
| 1101 | |||
| 1102 | const descriptor: CanonicalToolDescriptor = { | ||
| 1103 | providerKind: providerKind as any, | ||
| 1104 | sourceId: source.id, | ||
| 1105 | workspaceId: source.workspaceId, | ||
| 1106 | toolId: artifactTool.toolId, | ||
| 1107 | name: artifactTool.name, | ||
| 1108 | description: artifactTool.description, | ||
| 1109 | invocationMode: | ||
| 1110 | providerKind === "graphql" | ||
| 1111 | ? "graphql" | ||
| 1112 | : providerKind === "mcp" | ||
| 1113 | ? "mcp" | ||
| 1114 | : "http", | ||
| 1115 | availability: "remote_capable", | ||
| 1116 | providerPayload: | ||
| 1117 | providerKind === "openapi" | ||
| 1118 | ? decodeOpenApiInvocationPayload(invocationPayload) | ||
| 1119 | : providerKind === "graphql" | ||
| 1120 | ? decodeGraphqlInvocationPayload(invocationPayload) | ||
| 1121 | : decodeMcpInvocationPayload(invocationPayload), | ||
| 1122 | }; | ||
| 1123 | |||
| 1124 | const invocation = yield* registry | ||
| 1125 | .invoke({ | ||
| 1126 | source, | ||
| 1127 | tool: descriptor, | ||
| 1128 | args, | ||
| 1129 | }) | ||
| 1130 | .pipe( | ||
| 1131 | Effect.mapError((cause) => | ||
| 1132 | cause._tag === "ToolProviderError" | ||
| 1133 | ? toRuntimeAdapterError("invoke_tool", cause.message, cause.details) | ||
| 1134 | : toRuntimeAdapterError("invoke_tool", cause.message, null), | ||
| 1135 | ), | ||
| 1136 | ); | ||
| 1137 | |||
| 1138 | return invocation; | ||
| 1139 | }); | ||
| 1140 | |||
| 1141 | const unknownToolPathErrorMessage = ( | ||
| 1142 | requestedPath: string, | ||
| 1143 | suggestions: ReadonlyArray<string>, | ||
| 1144 | ): string => { | ||
| 1145 | const hintQuery = requestedPath.trim().length > 0 ? requestedPath.trim() : "tool"; | ||
| 1146 | const suggestionText = | ||
| 1147 | suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}.` : ""; | ||
| 1148 | |||
| 1149 | return `Unknown tool path: ${requestedPath}.${suggestionText} Use tools.discover({ query: ${JSON.stringify( | ||
| 1150 | hintQuery, | ||
| 1151 | )} }) or tools.catalog.tools({ query: ${JSON.stringify(hintQuery)} }) to find available tool paths.`; | ||
| 1152 | }; | ||
| 1153 | |||
| 1154 | const resolveToolPath = ( | ||
| 1155 | ctx: ActionCtx, | ||
| 1156 | workspaceId: string, | ||
| 1157 | requestedPath: string, | ||
| 1158 | ): Effect.Effect< | ||
| 1159 | { row: WorkspaceToolIndexRow | null; suggestions: Array<string> }, | ||
| 1160 | RuntimeAdapterError | ||
| 1161 | > => | ||
| 1162 | Effect.gen(function* () { | ||
| 1163 | const trimmedPath = requestedPath.trim(); | ||
| 1164 | if (trimmedPath.length === 0) { | ||
| 1165 | return { | ||
| 1166 | row: null, | ||
| 1167 | suggestions: [], | ||
| 1168 | }; | ||
| 1169 | } | ||
| 1170 | |||
| 1171 | const exact = yield* getWorkspaceToolByPathEffect(ctx, workspaceId, trimmedPath); | ||
| 1172 | if (exact && exact.status === "active") { | ||
| 1173 | return { | ||
| 1174 | row: exact, | ||
| 1175 | suggestions: [], | ||
| 1176 | }; | ||
| 1177 | } | ||
| 1178 | |||
| 1179 | const normalizedPath = normalizeToolPathForLookup(trimmedPath); | ||
| 1180 | const normalizedMatches = yield* listWorkspaceToolsByNormalizedPathEffect( | ||
| 1181 | ctx, | ||
| 1182 | workspaceId, | ||
| 1183 | normalizedPath, | ||
| 1184 | ); | ||
| 1185 | |||
| 1186 | if (normalizedMatches.length === 1) { | ||
| 1187 | return { | ||
| 1188 | row: normalizedMatches[0] ?? null, | ||
| 1189 | suggestions: [], | ||
| 1190 | }; | ||
| 1191 | } | ||
| 1192 | |||
| 1193 | if (normalizedMatches.length > 1) { | ||
| 1194 | const preferred = [...normalizedMatches].sort((left, right) => { | ||
| 1195 | if (left.path.length !== right.path.length) { | ||
| 1196 | return left.path.length - right.path.length; | ||
| 1197 | } | ||
| 1198 | |||
| 1199 | return left.path.localeCompare(right.path); | ||
| 1200 | })[0]; | ||
| 1201 | |||
| 1202 | return { | ||
| 1203 | row: preferred ?? null, | ||
| 1204 | suggestions: [], | ||
| 1205 | }; | ||
| 1206 | } | ||
| 1207 | |||
| 1208 | const candidates = yield* searchWorkspaceToolsEffect(ctx, workspaceId, { | ||
| 1209 | query: trimmedPath, | ||
| 1210 | limit: 20, | ||
| 1211 | }); | ||
| 1212 | |||
| 1213 | if (candidates.length === 0) { | ||
| 1214 | return { | ||
| 1215 | row: null, | ||
| 1216 | suggestions: [], | ||
| 1217 | }; | ||
| 1218 | } | ||
| 1219 | |||
| 1220 | const lowerRequested = trimmedPath.toLowerCase(); | ||
| 1221 | const closest = [...candidates] | ||
| 1222 | .map((candidate) => ({ | ||
| 1223 | candidate, | ||
| 1224 | distance: levenshteinDistance(candidate.path.toLowerCase(), lowerRequested), | ||
| 1225 | })) | ||
| 1226 | .sort((left, right) => { | ||
| 1227 | if (left.distance !== right.distance) { | ||
| 1228 | return left.distance - right.distance; | ||
| 1229 | } | ||
| 1230 | |||
| 1231 | return left.candidate.path.localeCompare(right.candidate.path); | ||
| 1232 | }); | ||
| 1233 | |||
| 1234 | const best = closest[0]; | ||
| 1235 | const maxDistance = Math.max(2, Math.floor(trimmedPath.length * 0.2)); | ||
| 1236 | |||
| 1237 | if (best && best.distance <= maxDistance) { | ||
| 1238 | return { | ||
| 1239 | row: best.candidate, | ||
| 1240 | suggestions: [], | ||
| 1241 | }; | ||
| 1242 | } | ||
| 1243 | |||
| 1244 | return { | ||
| 1245 | row: null, | ||
| 1246 | suggestions: uniquePaths(closest.map((item) => item.candidate.path)), | ||
| 1247 | }; | ||
| 1248 | }); | ||
| 1249 | |||
| 1250 | const approvalModeValidator = v.union(v.literal("auto"), v.literal("required")); | ||
| 1251 | |||
| 1252 | export const evaluateToolApproval = internalMutation({ | ||
| 1253 | args: { | ||
| 1254 | workspaceId: v.string(), | ||
| 1255 | runId: v.string(), | ||
| 1256 | callId: v.string(), | ||
| 1257 | toolPath: v.string(), | ||
| 1258 | inputPreviewJson: v.string(), | ||
| 1259 | defaultMode: approvalModeValidator, | ||
| 1260 | requireApprovals: v.optional(v.boolean()), | ||
| 1261 | retryAfterMs: v.optional(v.number()), | ||
| 1262 | }, | ||
| 1263 | handler: async (ctx, args) => { | ||
| 1264 | const taskRunRow = await ctx.db | ||
| 1265 | .query("taskRuns") | ||
| 1266 | .withIndex("by_domainId", (q) => q.eq("id", args.runId)) | ||
| 1267 | .unique(); | ||
| 1268 | |||
| 1269 | if (!taskRunRow || taskRunRow.workspaceId !== args.workspaceId) { | ||
| 1270 | return { | ||
| 1271 | kind: "denied" as const, | ||
| 1272 | error: `Unknown run for approval request: ${args.runId}`, | ||
| 1273 | }; | ||
| 1274 | } | ||
| 1275 | |||
| 1276 | const store: PersistentToolApprovalStore = { | ||
| 1277 | findByRunAndCall: (input) => | ||
| 1278 | Effect.tryPromise({ | ||
| 1279 | try: async () => { | ||
| 1280 | const rows = await ctx.db | ||
| 1281 | .query("approvals") | ||
| 1282 | .withIndex("by_taskRunId_callId", (q) => | ||
| 1283 | q.eq("taskRunId", input.runId).eq("callId", input.callId), | ||
| 1284 | ) | ||
| 1285 | .collect(); | ||
| 1286 | |||
| 1287 | const row = rows.find((candidate) => candidate.workspaceId === input.workspaceId) ?? null; | ||
| 1288 | if (!row) { | ||
| 1289 | return null; | ||
| 1290 | } | ||
| 1291 | |||
| 1292 | const approval = decodeApproval( | ||
| 1293 | stripConvexSystemFields(row as unknown as Record<string, unknown>), | ||
| 1294 | ); | ||
| 1295 | |||
| 1296 | return toPersistentApprovalRecord(approval); | ||
| 1297 | }, | ||
| 1298 | catch: (cause) => | ||
| 1299 | toPersistentApprovalStoreError( | ||
| 1300 | "approvals.find", | ||
| 1301 | "Failed to query approval", | ||
| 1302 | String(cause), | ||
| 1303 | ), | ||
| 1304 | }), | ||
| 1305 | |||
| 1306 | createPending: (input) => | ||
| 1307 | Effect.tryPromise({ | ||
| 1308 | try: async () => { | ||
| 1309 | const existingRows = await ctx.db | ||
| 1310 | .query("approvals") | ||
| 1311 | .withIndex("by_taskRunId_callId", (q) => | ||
| 1312 | q.eq("taskRunId", input.runId).eq("callId", input.callId), | ||
| 1313 | ) | ||
| 1314 | .collect(); | ||
| 1315 | |||
| 1316 | const existingRow = | ||
| 1317 | existingRows.find((candidate) => candidate.workspaceId === input.workspaceId) ?? null; | ||
| 1318 | if (existingRow) { | ||
| 1319 | return toPersistentApprovalRecord( | ||
| 1320 | decodeApproval( | ||
| 1321 | stripConvexSystemFields(existingRow as unknown as Record<string, unknown>), | ||
| 1322 | ), | ||
| 1323 | ); | ||
| 1324 | } | ||
| 1325 | |||
| 1326 | const approval = { | ||
| 1327 | id: `apr_${crypto.randomUUID()}`, | ||
| 1328 | workspaceId: input.workspaceId, | ||
| 1329 | taskRunId: input.runId, | ||
| 1330 | callId: input.callId, | ||
| 1331 | toolPath: input.toolPath, | ||
| 1332 | status: "pending", | ||
| 1333 | inputPreviewJson: input.inputPreviewJson, | ||
| 1334 | reason: null, | ||
| 1335 | requestedAt: Date.now(), | ||
| 1336 | resolvedAt: null, | ||
| 1337 | } as Approval; | ||
| 1338 | |||
| 1339 | await ctx.db.insert("approvals", approval); | ||
| 1340 | return toPersistentApprovalRecord(approval); | ||
| 1341 | }, | ||
| 1342 | catch: (cause) => | ||
| 1343 | toPersistentApprovalStoreError( | ||
| 1344 | "approvals.create", | ||
| 1345 | "Failed to create pending approval", | ||
| 1346 | String(cause), | ||
| 1347 | ), | ||
| 1348 | }), | ||
| 1349 | }; | ||
| 1350 | |||
| 1351 | const policy = createPersistentToolApprovalPolicy({ | ||
| 1352 | store, | ||
| 1353 | requireApprovals: args.requireApprovals === true, | ||
| 1354 | retryAfterMs: args.retryAfterMs, | ||
| 1355 | serializeInputPreview: () => args.inputPreviewJson, | ||
| 1356 | onStoreError: (error) => ({ | ||
| 1357 | kind: "denied", | ||
| 1358 | error: | ||
| 1359 | error.details && error.details.length > 0 | ||
| 1360 | ? `${error.message}: ${error.details}` | ||
| 1361 | : error.message, | ||
| 1362 | }), | ||
| 1363 | }); | ||
| 1364 | |||
| 1365 | return await policy.evaluate({ | ||
| 1366 | workspaceId: args.workspaceId, | ||
| 1367 | runId: args.runId, | ||
| 1368 | callId: args.callId, | ||
| 1369 | toolPath: args.toolPath, | ||
| 1370 | defaultMode: args.defaultMode, | ||
| 1371 | }); | ||
| 1372 | }, | ||
| 1373 | }); | ||
| 1374 | |||
| 1375 | const createConvexPersistentToolApprovalPolicy = ( | ||
| 1376 | ctx: ActionCtx, | ||
| 1377 | workspaceId: string, | ||
| 1378 | options: { | ||
| 1379 | requireApprovals: boolean; | ||
| 1380 | retryAfterMs: number; | ||
| 1381 | }, | ||
| 1382 | ): ToolApprovalPolicy => ({ | ||
| 1383 | evaluate: (input) => | ||
| 1384 | ctx.runMutation(runtimeInternal.source_tool_registry.evaluateToolApproval, { | ||
| 1385 | workspaceId, | ||
| 1386 | runId: input.runId, | ||
| 1387 | callId: input.callId, | ||
| 1388 | toolPath: input.toolPath, | ||
| 1389 | inputPreviewJson: serializeInputPreview(input.input), | ||
| 1390 | defaultMode: input.defaultMode, | ||
| 1391 | requireApprovals: options.requireApprovals, | ||
| 1392 | retryAfterMs: options.retryAfterMs, | ||
| 1393 | }), | ||
| 1394 | }); | ||
| 1395 | |||
| 1396 | const evaluateApprovalDecisionEffect = ( | ||
| 1397 | policy: ToolApprovalPolicy, | ||
| 1398 | input: { | ||
| 1399 | workspaceId: string; | ||
| 1400 | runId: string; | ||
| 1401 | callId: string; | ||
| 1402 | toolPath: string; | ||
| 1403 | source: string; | ||
| 1404 | defaultMode: "auto" | "required"; | ||
| 1405 | args: Record<string, unknown>; | ||
| 1406 | }, | ||
| 1407 | ): Effect.Effect< | ||
| 1408 | | { kind: "approved" } | ||
| 1409 | | { kind: "pending"; approvalId: string; retryAfterMs?: number; error?: string } | ||
| 1410 | | { kind: "denied"; error: string }, | ||
| 1411 | RuntimeAdapterError | ||
| 1412 | > => | ||
| 1413 | Effect.tryPromise({ | ||
| 1414 | try: () => | ||
| 1415 | Promise.resolve( | ||
| 1416 | policy.evaluate({ | ||
| 1417 | workspaceId: input.workspaceId, | ||
| 1418 | runId: input.runId, | ||
| 1419 | callId: input.callId, | ||
| 1420 | toolPath: input.toolPath, | ||
| 1421 | source: input.source, | ||
| 1422 | input: input.args, | ||
| 1423 | defaultMode: input.defaultMode, | ||
| 1424 | }), | ||
| 1425 | ), | ||
| 1426 | catch: (cause) => | ||
| 1427 | toRuntimeAdapterError( | ||
| 1428 | "evaluate_approval", | ||
| 1429 | `Tool approval evaluation failed: ${input.toolPath}`, | ||
| 1430 | String(cause), | ||
| 1431 | ), | ||
| 1432 | }); | ||
| 1433 | |||
| 1434 | const describeSource = (row: { | ||
| 1435 | sourceName: string; | ||
| 1436 | sourceKind: string; | ||
| 1437 | }): string => `${row.sourceKind.toUpperCase()} source: ${row.sourceName}`; | ||
| 1438 | |||
| 1439 | export type ConvexSourceToolRegistryOptions = { | ||
| 1440 | requireToolApprovals?: boolean; | ||
| 1441 | approvalRetryAfterMs?: number; | ||
| 1442 | }; | ||
| 1443 | |||
| 1444 | export const createConvexSourceToolRegistry = ( | ||
| 1445 | ctx: ActionCtx, | ||
| 1446 | workspaceId: string, | ||
| 1447 | options: ConvexSourceToolRegistryOptions = {}, | ||
| 1448 | ): ToolRegistry => { | ||
| 1449 | const requireApprovals = options.requireToolApprovals ?? requireToolApprovalsByDefault; | ||
| 1450 | const approvalRetryAfterMs = | ||
| 1451 | typeof options.approvalRetryAfterMs === "number" && | ||
| 1452 | Number.isFinite(options.approvalRetryAfterMs) && | ||
| 1453 | options.approvalRetryAfterMs >= 0 | ||
| 1454 | ? Math.round(options.approvalRetryAfterMs) | ||
| 1455 | : defaultPendingRetryAfterMs; | ||
| 1456 | |||
| 1457 | const approvalPolicy = createConvexPersistentToolApprovalPolicy(ctx, workspaceId, { | ||
| 1458 | requireApprovals, | ||
| 1459 | retryAfterMs: approvalRetryAfterMs, | ||
| 1460 | }); | ||
| 1461 | |||
| 1462 | return { | ||
| 1463 | callTool: (input) => | ||
| 1464 | Effect.gen(function* () { | ||
| 1465 | const resolved = yield* resolveToolPath(ctx, workspaceId, input.toolPath); | ||
| 1466 | if (!resolved.row) { | ||
| 1467 | return { | ||
| 1468 | ok: false, | ||
| 1469 | kind: "failed", | ||
| 1470 | error: unknownToolPathErrorMessage(input.toolPath, resolved.suggestions), | ||
| 1471 | } satisfies RuntimeToolCallResult; | ||
| 1472 | } | ||
| 1473 | |||
| 1474 | const args = normalizeInvokeInput(input.input); | ||
| 1475 | const toolPath = resolved.row.path; | ||
| 1476 | const approval = yield* evaluateApprovalDecisionEffect(approvalPolicy, { | ||
| 1477 | workspaceId, | ||
| 1478 | runId: input.runId, | ||
| 1479 | callId: input.callId, | ||
| 1480 | toolPath, | ||
| 1481 | source: resolved.row.sourceName, | ||
| 1482 | defaultMode: | ||
| 1483 | resolved.row.approvalMode === "required" | ||
| 1484 | ? "required" | ||
| 1485 | : "auto", | ||
| 1486 | args, | ||
| 1487 | }); | ||
| 1488 | |||
| 1489 | if (approval.kind !== "approved") { | ||
| 1490 | return toToolCallResultFromDecision(approval, toolPath); | ||
| 1491 | } | ||
| 1492 | |||
| 1493 | const artifactTool = yield* getArtifactToolEffect( | ||
| 1494 | ctx, | ||
| 1495 | resolved.row.artifactId, | ||
| 1496 | resolved.row.toolId, | ||
| 1497 | ); | ||
| 1498 | |||
| 1499 | if (!artifactTool) { | ||
| 1500 | return { | ||
| 1501 | ok: false, | ||
| 1502 | kind: "failed", | ||
| 1503 | error: `Missing artifact tool payload for ${resolved.row.path}`, | ||
| 1504 | } satisfies RuntimeToolCallResult; | ||
| 1505 | } | ||
| 1506 | |||
| 1507 | const source = yield* getSourceForInvocationEffect(ctx, workspaceId, resolved.row.sourceId); | ||
| 1508 | if (!source) { | ||
| 1509 | return { | ||
| 1510 | ok: false, | ||
| 1511 | kind: "failed", | ||
| 1512 | error: `Source unavailable for tool: ${resolved.row.path}`, | ||
| 1513 | } satisfies RuntimeToolCallResult; | ||
| 1514 | } | ||
| 1515 | |||
| 1516 | const invocation = yield* invokeToolWithRegistry(ctx, source, artifactTool, args); | ||
| 1517 | if (invocation.isError) { | ||
| 1518 | return { | ||
| 1519 | ok: false, | ||
| 1520 | kind: "failed", | ||
| 1521 | error: describeOutput(invocation.output), | ||
| 1522 | } satisfies RuntimeToolCallResult; | ||
| 1523 | } | ||
| 1524 | |||
| 1525 | return { | ||
| 1526 | ok: true, | ||
| 1527 | value: invocation.output, | ||
| 1528 | } satisfies RuntimeToolCallResult; | ||
| 1529 | }), | ||
| 1530 | |||
| 1531 | discover: (input: ToolRegistryDiscoverInput) => | ||
| 1532 | Effect.gen(function* () { | ||
| 1533 | const limit = Math.max(1, Math.min(50, input.limit ?? 8)); | ||
| 1534 | const queryText = (input.query ?? "").trim(); | ||
| 1535 | const compact = input.compact === true; | ||
| 1536 | const includeSchemas = input.includeSchemas === true; | ||
| 1537 | const fetchLimit = Math.max(limit * 6, 50); | ||
| 1538 | |||
| 1539 | const rows = | ||
| 1540 | queryText.length > 0 | ||
| 1541 | ? yield* searchWorkspaceToolsEffect(ctx, workspaceId, { | ||
| 1542 | query: queryText, | ||
| 1543 | limit: fetchLimit, | ||
| 1544 | }) | ||
| 1545 | : yield* listWorkspaceToolsEffect(ctx, workspaceId, { | ||
| 1546 | limit: fetchLimit, | ||
| 1547 | }); | ||
| 1548 | |||
| 1549 | const rankedRows = rows | ||
| 1550 | .map((row) => ({ | ||
| 1551 | row, | ||
| 1552 | score: scoreSummary(toSearchScoringSummary(row), queryText.toLowerCase()), | ||
| 1553 | })) | ||
| 1554 | .filter((item) => item.score > 0) | ||
| 1555 | .sort((left, right) => right.score - left.score) | ||
| 1556 | .slice(0, limit); | ||
| 1557 | |||
| 1558 | const selectedRows = rankedRows.map((item) => item.row); | ||
| 1559 | |||
| 1560 | const summaries = includeSchemas | ||
| 1561 | ? ( | ||
| 1562 | yield* hydrateRowsWithArtifactTools(ctx, selectedRows).pipe( | ||
| 1563 | Effect.map((entries) => | ||
| 1564 | entries.map(({ row, artifactTool }) => | ||
| 1565 | toToolSummary(row, { | ||
| 1566 | includeSchemas, | ||
| 1567 | compact, | ||
| 1568 | artifactTool, | ||
| 1569 | }), | ||
| 1570 | ), | ||
| 1571 | ), | ||
| 1572 | ) | ||
| 1573 | ) | ||
| 1574 | : selectedRows.map((row) => | ||
| 1575 | toToolSummary(row, { | ||
| 1576 | includeSchemas, | ||
| 1577 | compact, | ||
| 1578 | }), | ||
| 1579 | ); | ||
| 1580 | |||
| 1581 | return { | ||
| 1582 | bestPath: summaries[0]?.path ?? null, | ||
| 1583 | results: summaries, | ||
| 1584 | total: summaries.length, | ||
| 1585 | refHintTable: mergeRefHintTables(rows, includeSchemas), | ||
| 1586 | } satisfies ToolRegistryDiscoverOutput; | ||
| 1587 | }), | ||
| 1588 | |||
| 1589 | catalogNamespaces: (input: ToolRegistryCatalogNamespacesInput) => | ||
| 1590 | Effect.gen(function* () { | ||
| 1591 | const limit = Math.max(1, Math.min(maxCatalogNamespacesLimit, input.limit ?? 50)); | ||
| 1592 | |||
| 1593 | const rows = yield* Effect.tryPromise({ | ||
| 1594 | try: async () => | ||
| 1595 | (await ctx.runQuery(runtimeInternal.control_plane.tool_registry.listWorkspaceNamespaces, { | ||
| 1596 | workspaceId, | ||
| 1597 | limit, | ||
| 1598 | })) as Array<{ | ||
| 1599 | namespace: string; | ||
| 1600 | source: string; | ||
| 1601 | sourceId: string; | ||
| 1602 | sourceKind: string; | ||
| 1603 | toolCount: number; | ||
| 1604 | samplePaths: Array<string>; | ||
| 1605 | }>, | ||
| 1606 | catch: (cause) => | ||
| 1607 | toRuntimeAdapterError( | ||
| 1608 | "catalog_namespaces", | ||
| 1609 | "Failed to catalog namespaces", | ||
| 1610 | String(cause), | ||
| 1611 | ), | ||
| 1612 | }); | ||
| 1613 | |||
| 1614 | return { | ||
| 1615 | namespaces: rows.map((row) => ({ | ||
| 1616 | namespace: row.namespace, | ||
| 1617 | toolCount: row.toolCount, | ||
| 1618 | samplePaths: row.samplePaths, | ||
| 1619 | source: row.source, | ||
| 1620 | sourceKey: row.sourceId, | ||
| 1621 | description: describeSource({ sourceName: row.source, sourceKind: row.sourceKind }), | ||
| 1622 | })), | ||
| 1623 | total: rows.length, | ||
| 1624 | } satisfies ToolRegistryCatalogNamespacesOutput; | ||
| 1625 | }), | ||
| 1626 | |||
| 1627 | catalogTools: (input: ToolRegistryCatalogToolsInput) => | ||
| 1628 | Effect.gen(function* () { | ||
| 1629 | const limit = Math.max(1, Math.min(maxCatalogToolsLimit, input.limit ?? 50)); | ||
| 1630 | const queryText = (input.query ?? "").trim(); | ||
| 1631 | const compact = input.compact === true; | ||
| 1632 | const includeSchemas = input.includeSchemas === true; | ||
| 1633 | const namespace = input.namespace?.trim(); | ||
| 1634 | |||
| 1635 | const rows = | ||
| 1636 | queryText.length > 0 | ||
| 1637 | ? yield* searchWorkspaceToolsEffect(ctx, workspaceId, { | ||
| 1638 | query: queryText, | ||
| 1639 | namespace, | ||
| 1640 | limit: Math.max(limit * 4, 50), | ||
| 1641 | }) | ||
| 1642 | : yield* listWorkspaceToolsEffect(ctx, workspaceId, { | ||
| 1643 | namespace, | ||
| 1644 | limit: Math.max(limit * 4, 50), | ||
| 1645 | }); | ||
| 1646 | |||
| 1647 | const rankedRows = rows | ||
| 1648 | .map((row) => ({ | ||
| 1649 | row, | ||
| 1650 | score: scoreSummary(toSearchScoringSummary(row), queryText.toLowerCase()), | ||
| 1651 | })) | ||
| 1652 | .filter((item) => item.score > 0) | ||
| 1653 | .sort((left, right) => right.score - left.score) | ||
| 1654 | .slice(0, limit); | ||
| 1655 | |||
| 1656 | const selectedRows = rankedRows.map((item) => item.row); | ||
| 1657 | |||
| 1658 | const summaries = includeSchemas | ||
| 1659 | ? ( | ||
| 1660 | yield* hydrateRowsWithArtifactTools(ctx, selectedRows).pipe( | ||
| 1661 | Effect.map((entries) => | ||
| 1662 | entries.map(({ row, artifactTool }) => | ||
| 1663 | toToolSummary(row, { | ||
| 1664 | includeSchemas, | ||
| 1665 | compact, | ||
| 1666 | artifactTool, | ||
| 1667 | }), | ||
| 1668 | ), | ||
| 1669 | ), | ||
| 1670 | ) | ||
| 1671 | ) | ||
| 1672 | : selectedRows.map((row) => | ||
| 1673 | toToolSummary(row, { | ||
| 1674 | includeSchemas, | ||
| 1675 | compact, | ||
| 1676 | }), | ||
| 1677 | ); | ||
| 1678 | |||
| 1679 | return { | ||
| 1680 | results: summaries, | ||
| 1681 | total: summaries.length, | ||
| 1682 | refHintTable: mergeRefHintTables(rows, includeSchemas), | ||
| 1683 | } satisfies ToolRegistryCatalogToolsOutput; | ||
| 1684 | }), | ||
| 1685 | } as ToolRegistry; | ||
| 1686 | }; | ||
| @@ -0,0 +1,78 @@ | |||
| 1 | import { type TaskRun } from "@executor-v2/schema"; | ||
| 2 | import { v } from "convex/values"; | ||
| 3 | |||
| 4 | import { internalMutation } from "./_generated/server"; | ||
| 5 | |||
| 6 | const taskRunTerminalStatusValidator = v.union( | ||
| 7 | v.literal("completed"), | ||
| 8 | v.literal("failed"), | ||
| 9 | v.literal("timed_out"), | ||
| 10 | v.literal("denied"), | ||
| 11 | ); | ||
| 12 | |||
| 13 | export const startTaskRun = internalMutation({ | ||
| 14 | args: { | ||
| 15 | workspaceId: v.string(), | ||
| 16 | runId: v.string(), | ||
| 17 | sessionId: v.optional(v.string()), | ||
| 18 | runtimeId: v.optional(v.string()), | ||
| 19 | codeHash: v.optional(v.string()), | ||
| 20 | }, | ||
| 21 | handler: async (ctx, args): Promise<void> => { | ||
| 22 | const existing = await ctx.db | ||
| 23 | .query("taskRuns") | ||
| 24 | .withIndex("by_domainId", (q) => q.eq("id", args.runId)) | ||
| 25 | .unique(); | ||
| 26 | |||
| 27 | if (existing) { | ||
| 28 | if (existing.workspaceId !== args.workspaceId) { | ||
| 29 | throw new Error(`Task run workspace mismatch: ${args.runId}`); | ||
| 30 | } | ||
| 31 | return; | ||
| 32 | } | ||
| 33 | |||
| 34 | const taskRun = { | ||
| 35 | id: args.runId, | ||
| 36 | workspaceId: args.workspaceId, | ||
| 37 | sessionId: args.sessionId ?? "session_runtime", | ||
| 38 | runtimeId: args.runtimeId ?? "runtime", | ||
| 39 | codeHash: args.codeHash ?? "runtime", | ||
| 40 | status: "running", | ||
| 41 | startedAt: Date.now(), | ||
| 42 | completedAt: null, | ||
| 43 | exitCode: null, | ||
| 44 | error: null, | ||
| 45 | } as TaskRun; | ||
| 46 | |||
| 47 | await ctx.db.insert("taskRuns", taskRun); | ||
| 48 | }, | ||
| 49 | }); | ||
| 50 | |||
| 51 | export const finishTaskRun = internalMutation({ | ||
| 52 | args: { | ||
| 53 | workspaceId: v.string(), | ||
| 54 | runId: v.string(), | ||
| 55 | status: taskRunTerminalStatusValidator, | ||
| 56 | error: v.optional(v.union(v.string(), v.null())), | ||
| 57 | }, | ||
| 58 | handler: async (ctx, args): Promise<void> => { | ||
| 59 | const existing = await ctx.db | ||
| 60 | .query("taskRuns") | ||
| 61 | .withIndex("by_domainId", (q) => q.eq("id", args.runId)) | ||
| 62 | .unique(); | ||
| 63 | |||
| 64 | if (!existing) { | ||
| 65 | return; | ||
| 66 | } | ||
| 67 | |||
| 68 | if (existing.workspaceId !== args.workspaceId) { | ||
| 69 | throw new Error(`Task run workspace mismatch: ${args.runId}`); | ||
| 70 | } | ||
| 71 | |||
| 72 | await ctx.db.patch(existing._id, { | ||
| 73 | status: args.status, | ||
| 74 | completedAt: Date.now(), | ||
| 75 | error: args.error ?? null, | ||
| 76 | }); | ||
| 77 | }, | ||
| 78 | }); | ||
| @@ -0,0 +1,25 @@ | |||
| 1 | { | ||
| 2 | /* This TypeScript project config describes the environment that | ||
| 3 | * Convex functions run in and is used to typecheck them. | ||
| 4 | * You can modify it, but some settings are required to use Convex. | ||
| 5 | */ | ||
| 6 | "compilerOptions": { | ||
| 7 | /* These settings are not required by Convex and can be modified. */ | ||
| 8 | "allowJs": true, | ||
| 9 | "strict": true, | ||
| 10 | "moduleResolution": "Bundler", | ||
| 11 | "jsx": "react-jsx", | ||
| 12 | "skipLibCheck": true, | ||
| 13 | "allowSyntheticDefaultImports": true, | ||
| 14 | |||
| 15 | /* These compiler options are required by Convex */ | ||
| 16 | "target": "ESNext", | ||
| 17 | "lib": ["ES2021", "dom"], | ||
| 18 | "forceConsistentCasingInFileNames": true, | ||
| 19 | "module": "ESNext", | ||
| 20 | "isolatedModules": true, | ||
| 21 | "noEmit": true | ||
| 22 | }, | ||
| 23 | "include": ["./**/*"], | ||
| 24 | "exclude": ["./_generated"] | ||
| 25 | } | ||
| @@ -0,0 +1,15 @@ | |||
| 1 | import { WorkflowManager } from "@convex-dev/workflow"; | ||
| 2 | |||
| 3 | import { components } from "./_generated/api"; | ||
| 4 | |||
| 5 | export const workflow = new WorkflowManager(components.workflow, { | ||
| 6 | workpoolOptions: { | ||
| 7 | defaultRetryBehavior: { | ||
| 8 | maxAttempts: 3, | ||
| 9 | initialBackoffMs: 250, | ||
| 10 | base: 2, | ||
| 11 | }, | ||
| 12 | retryActionsByDefault: true, | ||
| 13 | maxParallelism: 8, | ||
| 14 | }, | ||
| 15 | }); | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../convex/bin/main.js | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../vitest/vitest.mjs | ||
| @@ -0,0 +1 @@ | |||
| 1 | {"version":"3.2.4","results":[[":convex/executor.test.ts",{"duration":746.3599650000001,"failed":false}],[":convex/sources.test.ts",{"duration":235.0589490000002,"failed":false}]]} | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@convex-dev+workflow@0.3.4+e4a957bbb87593a0/node_modules/@convex-dev/workflow | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@effect+vitest@0.27.0+745106daec5afff3/node_modules/@effect/vitest | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/confect | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/control-plane | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/domain | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/engine | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/management-api | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/mcp-gateway | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/state-convex | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/state-contracts | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/rpc | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/runtime-cloudflare-worker-loader | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/runtime-local-inproc | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/schema | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/sdk | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/state-convex | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@workos-inc+node@8.7.0/node_modules/@workos-inc/node | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/convex@1.32.0+b1ab299f0a400331/node_modules/convex | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../packages/convex-test | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/effect@3.19.19/node_modules/effect | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/jose@6.1.3/node_modules/jose | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/vitest@3.2.4+dddfa60a3fc73abb/node_modules/vitest | ||
| @@ -0,0 +1,32 @@ | |||
| 1 | { | ||
| 2 | "name": "@executor-v2/app-convex", | ||
| 3 | "private": true, | ||
| 4 | "type": "module", | ||
| 5 | "scripts": { | ||
| 6 | "dev": "CREDENTIAL_ENCRYPTION_KEY=dev-credential-encryption-key bunx convex dev", | ||
| 7 | "test": "CREDENTIAL_ENCRYPTION_KEY=test-credential-encryption-key bunx vitest run --no-watch convex/*.test.ts", | ||
| 8 | "typecheck": "bunx tsc --noEmit -p tsconfig.json", | ||
| 9 | "convex:codegen": "bunx convex codegen" | ||
| 10 | }, | ||
| 11 | "dependencies": { | ||
| 12 | "@convex-dev/workflow": "^0.3.4", | ||
| 13 | "@modelcontextprotocol/sdk": "^1.27.1", | ||
| 14 | "@executor-v2/confect": "workspace:*", | ||
| 15 | "@executor-v2/domain": "workspace:*", | ||
| 16 | "@executor-v2/engine": "workspace:*", | ||
| 17 | "@executor-v2/management-api": "workspace:*", | ||
| 18 | "@executor-v2/mcp-gateway": "workspace:*", | ||
| 19 | "@executor-v2/persistence-ports": "workspace:*", | ||
| 20 | "@executor-v2/runtime-cloudflare-worker-loader": "workspace:*", | ||
| 21 | "@executor-v2/schema": "workspace:*", | ||
| 22 | "@executor-v2/sdk": "workspace:*", | ||
| 23 | "convex": "catalog:", | ||
| 24 | "effect": "catalog:", | ||
| 25 | "jose": "^6.1.0" | ||
| 26 | }, | ||
| 27 | "devDependencies": { | ||
| 28 | "@effect/vitest": "catalog:", | ||
| 29 | "convex-test": "workspace:*", | ||
| 30 | "vitest": "catalog:" | ||
| 31 | } | ||
| 32 | } | ||
| @@ -0,0 +1 @@ | |||
| 1 | export {}; | ||
| @@ -0,0 +1,4 @@ | |||
| 1 | { | ||
| 2 | "extends": "../../tsconfig.json", | ||
| 3 | "include": ["src", "convex"] | ||
| 4 | } | ||
| @@ -0,0 +1,19 @@ | |||
| 1 | # app-pm | ||
| 2 | |||
| 3 | Local Process Manager app scaffold for Executor v2. | ||
| 4 | |||
| 5 | Current scaffold includes: | ||
| 6 | - local MCP endpoint at `GET/POST/DELETE /v1/mcp` | ||
| 7 | - health endpoint at `GET /healthz` | ||
| 8 | - MCP tool routing via `@executor-v2/mcp-gateway` | ||
| 9 | - runtime selection via `PM_RUNTIME_KIND` (`local-inproc`, `deno-subprocess`, `cloudflare-worker-loader`) | ||
| 10 | - runtime callback endpoint at `POST /v1/runtime/tool-call` | ||
| 11 | - control-plane source endpoints at `GET/POST /v1/workspaces/:workspaceId/sources` | ||
| 12 | - control-plane source removal endpoint at `DELETE /v1/workspaces/:workspaceId/sources/:sourceId` | ||
| 13 | - generated OpenAPI spec endpoint at `GET /v1/openapi.json` | ||
| 14 | |||
| 15 | App wiring is now split by responsibility: | ||
| 16 | - `src/config.ts`: Effect config service (`PORT`) | ||
| 17 | - `src/mcp-handler.ts`: MCP transport wiring to shared run execution service | ||
| 18 | - `src/http-server.ts`: Effect HTTP server startup | ||
| 19 | - `src/main.ts`: Layer composition + process entrypoint | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../vitest/vitest.mjs | ||
| @@ -0,0 +1 @@ | |||
| 1 | {"version":"3.2.4","results":[[":src/tool-call-handler.test.ts",{"duration":65.40639299999975,"failed":false}],[":src/execute.e2e.test.ts",{"duration":1312.0678289999998,"failed":false}],[":src/sources-handler.test.ts",{"duration":90.26854400000002,"failed":false}],[":src/persistent-approval-policy.test.ts",{"duration":66.12446200000022,"failed":false}],[":src/storage-service.test.ts",{"duration":96.20161000000007,"failed":false}]]} | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@effect+platform@0.93.8+a91c478e54a5dd97/node_modules/@effect/platform | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@effect+platform-bun@0.86.0+e085871485f58d8a/node_modules/@effect/platform-bun | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@effect+vitest@0.27.0+745106daec5afff3/node_modules/@effect/vitest | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/control-plane | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/domain | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/engine | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/management-api | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/mcp-gateway | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/state-local-file | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/state-contracts | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/rpc | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/runtime-cloudflare-worker-loader | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/runtime-deno-subprocess | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/runtime-local-inproc | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/schema | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/sdk | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../packages/source-manager | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/effect@3.19.19/node_modules/effect | ||
| @@ -0,0 +1 @@ | |||
| 1 | ../../../node_modules/.bun/vitest@3.2.4+dddfa60a3fc73abb/node_modules/vitest | ||
| @@ -0,0 +1,30 @@ | |||
| 1 | { | ||
| 2 | "name": "@executor-v2/app-pm", | ||
| 3 | "private": true, | ||
| 4 | "type": "module", | ||
| 5 | "scripts": { | ||
| 6 | "dev": "bun --watch src/main.ts", | ||
| 7 | "start": "bun src/main.ts", | ||
| 8 | "test": "bunx vitest run --no-watch src/*.test.ts", | ||
| 9 | "typecheck": "bunx tsc --noEmit -p tsconfig.json" | ||
| 10 | }, | ||
| 11 | "dependencies": { | ||
| 12 | "@effect/platform": "catalog:", | ||
| 13 | "@effect/platform-bun": "^0.86.0", | ||
| 14 | "@executor-v2/management-api": "workspace:*", | ||
| 15 | "@executor-v2/domain": "workspace:*", | ||
| 16 | "@executor-v2/engine": "workspace:*", | ||
| 17 | "@executor-v2/mcp-gateway": "workspace:*", | ||
| 18 | "@executor-v2/persistence-local": "workspace:*", | ||
| 19 | "@executor-v2/runtime-cloudflare-worker-loader": "workspace:*", | ||
| 20 | "@executor-v2/runtime-deno-subprocess": "workspace:*", | ||
| 21 | "@executor-v2/runtime-local-inproc": "workspace:*", | ||
| 22 | "@executor-v2/sdk": "workspace:*", | ||
| 23 | "effect": "catalog:" | ||
| 24 | }, | ||
| 25 | "devDependencies": { | ||
| 26 | "@effect/vitest": "catalog:", | ||
| 27 | "@modelcontextprotocol/sdk": "^1.26.0", | ||
| 28 | "vitest": "catalog:" | ||
| 29 | } | ||
| 30 | } | ||
| @@ -0,0 +1,143 @@ | |||
| 1 | import { | ||
| 2 | ControlPlaneActorResolverLive, | ||
| 3 | deriveWorkspaceMembershipsForPrincipal, | ||
| 4 | requirePrincipalFromHeaders, | ||
| 5 | } from "@executor-v2/management-api"; | ||
| 6 | import { | ||
| 7 | ActorUnauthenticatedError, | ||
| 8 | makeActor, | ||
| 9 | makeAllowAllActor, | ||
| 10 | } from "@executor-v2/domain"; | ||
| 11 | import { | ||
| 12 | type LocalStateSnapshot, | ||
| 13 | type LocalStateStore, | ||
| 14 | } from "@executor-v2/persistence-local"; | ||
| 15 | import { | ||
| 16 | type OrganizationMembership, | ||
| 17 | type WorkspaceMembership, | ||
| 18 | } from "@executor-v2/schema"; | ||
| 19 | import * as PlatformHeaders from "@effect/platform/Headers"; | ||
| 20 | import * as Effect from "effect/Effect"; | ||
| 21 | import * as Option from "effect/Option"; | ||
| 22 | |||
| 23 | const isTruthy = (value: string | undefined): boolean => { | ||
| 24 | const normalized = value?.trim().toLowerCase(); | ||
| 25 | return normalized === "1" || normalized === "true" || normalized === "yes"; | ||
| 26 | }; | ||
| 27 | |||
| 28 | const localAdminFallbackEnabled = (() => { | ||
| 29 | const configured = process.env.PM_ALLOW_LOCAL_ADMIN; | ||
| 30 | |||
| 31 | if (configured === undefined || configured.trim().length === 0) { | ||
| 32 | return process.env.NODE_ENV !== "production"; | ||
| 33 | } | ||
| 34 | |||
| 35 | return isTruthy(configured); | ||
| 36 | })(); | ||
| 37 | |||
| 38 | const organizationMembershipsForAccount = ( | ||
| 39 | snapshot: LocalStateSnapshot, | ||
| 40 | accountId: OrganizationMembership["accountId"], | ||
| 41 | ): ReadonlyArray<OrganizationMembership> => | ||
| 42 | snapshot.organizationMemberships.filter( | ||
| 43 | (membership) => membership.accountId === accountId, | ||
| 44 | ); | ||
| 45 | |||
| 46 | const workspaceMembershipsForAccount = ( | ||
| 47 | snapshot: LocalStateSnapshot, | ||
| 48 | accountId: OrganizationMembership["accountId"], | ||
| 49 | organizationMemberships: ReadonlyArray<OrganizationMembership>, | ||
| 50 | ): ReadonlyArray<WorkspaceMembership> => | ||
| 51 | snapshot.workspaces.flatMap((workspace) => | ||
| 52 | deriveWorkspaceMembershipsForPrincipal({ | ||
| 53 | principalAccountId: accountId, | ||
| 54 | workspaceId: workspace.id, | ||
| 55 | workspace, | ||
| 56 | organizationMemberships, | ||
| 57 | }), | ||
| 58 | ); | ||
| 59 | |||
| 60 | const resolveActorFromSnapshot = ( | ||
| 61 | localStateStore: LocalStateStore, | ||
| 62 | headers: PlatformHeaders.Headers, | ||
| 63 | ) => | ||
| 64 | Effect.gen(function* () { | ||
| 65 | const principal = yield* requirePrincipalFromHeaders(headers); | ||
| 66 | |||
| 67 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 68 | Effect.mapError( | ||
| 69 | (error) => | ||
| 70 | new ActorUnauthenticatedError({ | ||
| 71 | message: `Unable to read local auth state (${error.operation})`, | ||
| 72 | }), | ||
| 73 | ), | ||
| 74 | ); | ||
| 75 | |||
| 76 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 77 | |||
| 78 | if (snapshot === null && localAdminFallbackEnabled) { | ||
| 79 | return makeAllowAllActor(principal); | ||
| 80 | } | ||
| 81 | |||
| 82 | const organizationMemberships = | ||
| 83 | snapshot === null | ||
| 84 | ? [] | ||
| 85 | : organizationMembershipsForAccount(snapshot, principal.accountId); | ||
| 86 | const workspaceMemberships = | ||
| 87 | snapshot === null | ||
| 88 | ? [] | ||
| 89 | : workspaceMembershipsForAccount(snapshot, principal.accountId, organizationMemberships); | ||
| 90 | |||
| 91 | return yield* makeActor({ | ||
| 92 | principal, | ||
| 93 | workspaceMemberships, | ||
| 94 | organizationMemberships, | ||
| 95 | }); | ||
| 96 | }); | ||
| 97 | |||
| 98 | export const PmActorLive = (localStateStore: LocalStateStore) => | ||
| 99 | ControlPlaneActorResolverLive({ | ||
| 100 | resolveActor: (input) => resolveActorFromSnapshot(localStateStore, input.headers), | ||
| 101 | resolveWorkspaceActor: (input) => | ||
| 102 | Effect.gen(function* () { | ||
| 103 | const principal = yield* requirePrincipalFromHeaders(input.headers); | ||
| 104 | |||
| 105 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 106 | Effect.mapError( | ||
| 107 | (error) => | ||
| 108 | new ActorUnauthenticatedError({ | ||
| 109 | message: `Unable to read local auth state (${error.operation})`, | ||
| 110 | }), | ||
| 111 | ), | ||
| 112 | ); | ||
| 113 | |||
| 114 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 115 | |||
| 116 | if (snapshot === null && localAdminFallbackEnabled) { | ||
| 117 | return makeAllowAllActor(principal); | ||
| 118 | } | ||
| 119 | |||
| 120 | const organizationMemberships = | ||
| 121 | snapshot === null | ||
| 122 | ? [] | ||
| 123 | : organizationMembershipsForAccount(snapshot, principal.accountId); | ||
| 124 | |||
| 125 | const workspace = | ||
| 126 | snapshot === null | ||
| 127 | ? null | ||
| 128 | : snapshot.workspaces.find((item) => item.id === input.workspaceId) ?? null; | ||
| 129 | |||
| 130 | const workspaceMemberships = deriveWorkspaceMembershipsForPrincipal({ | ||
| 131 | principalAccountId: principal.accountId, | ||
| 132 | workspaceId: input.workspaceId, | ||
| 133 | workspace, | ||
| 134 | organizationMemberships, | ||
| 135 | }); | ||
| 136 | |||
| 137 | return yield* makeActor({ | ||
| 138 | principal, | ||
| 139 | workspaceMemberships, | ||
| 140 | organizationMemberships, | ||
| 141 | }); | ||
| 142 | }), | ||
| 143 | }); | ||
| @@ -0,0 +1,264 @@ | |||
| 1 | import { | ||
| 2 | PersistentToolApprovalPolicyStoreError, | ||
| 3 | createPersistentToolApprovalPolicy, | ||
| 4 | type PersistentToolApprovalRecord, | ||
| 5 | type PersistentToolApprovalStore, | ||
| 6 | type ToolApprovalPolicy, | ||
| 7 | } from "@executor-v2/engine"; | ||
| 8 | import { SourceStoreError } from "@executor-v2/persistence-ports"; | ||
| 9 | import { | ||
| 10 | type LocalStateSnapshot, | ||
| 11 | type LocalStateStore, | ||
| 12 | type LocalStateStoreError, | ||
| 13 | } from "@executor-v2/persistence-local"; | ||
| 14 | import { | ||
| 15 | makeControlPlaneApprovalsService, | ||
| 16 | type ControlPlaneApprovalsServiceShape, | ||
| 17 | } from "@executor-v2/management-api"; | ||
| 18 | import { type Approval } from "@executor-v2/schema"; | ||
| 19 | import * as Effect from "effect/Effect"; | ||
| 20 | import * as Option from "effect/Option"; | ||
| 21 | |||
| 22 | const toSourceStoreError = ( | ||
| 23 | operation: string, | ||
| 24 | message: string, | ||
| 25 | details: string | null, | ||
| 26 | ): SourceStoreError => | ||
| 27 | new SourceStoreError({ | ||
| 28 | operation, | ||
| 29 | backend: "local-file", | ||
| 30 | location: "snapshot.json", | ||
| 31 | message, | ||
| 32 | reason: null, | ||
| 33 | details, | ||
| 34 | }); | ||
| 35 | |||
| 36 | const toSourceStoreErrorFromLocalState = ( | ||
| 37 | operation: string, | ||
| 38 | error: LocalStateStoreError, | ||
| 39 | ): SourceStoreError => | ||
| 40 | toSourceStoreError(operation, error.message, error.details ?? error.reason ?? null); | ||
| 41 | |||
| 42 | const findApprovalIndex = ( | ||
| 43 | approvals: ReadonlyArray<Approval>, | ||
| 44 | workspaceId: string, | ||
| 45 | approvalId: string, | ||
| 46 | ): number => | ||
| 47 | approvals.findIndex( | ||
| 48 | (approval) => approval.workspaceId === workspaceId && approval.id === approvalId, | ||
| 49 | ); | ||
| 50 | |||
| 51 | const sortApprovals = (approvals: ReadonlyArray<Approval>): Array<Approval> => | ||
| 52 | [...approvals].sort((left, right) => right.requestedAt - left.requestedAt); | ||
| 53 | |||
| 54 | const toPersistentApprovalStoreError = ( | ||
| 55 | operation: string, | ||
| 56 | message: string, | ||
| 57 | details: string | null, | ||
| 58 | ): PersistentToolApprovalPolicyStoreError => | ||
| 59 | new PersistentToolApprovalPolicyStoreError({ | ||
| 60 | operation, | ||
| 61 | message, | ||
| 62 | details, | ||
| 63 | }); | ||
| 64 | |||
| 65 | const toPersistentApprovalStoreErrorFromLocalState = ( | ||
| 66 | operation: string, | ||
| 67 | error: LocalStateStoreError, | ||
| 68 | ): PersistentToolApprovalPolicyStoreError => | ||
| 69 | toPersistentApprovalStoreError(operation, error.message, error.details ?? error.reason ?? null); | ||
| 70 | |||
| 71 | const toPersistentApprovalRecord = (approval: Approval): PersistentToolApprovalRecord => ({ | ||
| 72 | approvalId: approval.id, | ||
| 73 | workspaceId: approval.workspaceId, | ||
| 74 | runId: approval.taskRunId, | ||
| 75 | callId: approval.callId, | ||
| 76 | toolPath: approval.toolPath, | ||
| 77 | status: approval.status, | ||
| 78 | reason: approval.reason, | ||
| 79 | }); | ||
| 80 | |||
| 81 | const updateApproval = ( | ||
| 82 | snapshot: LocalStateSnapshot, | ||
| 83 | index: number, | ||
| 84 | nextApproval: Approval, | ||
| 85 | ): LocalStateSnapshot => { | ||
| 86 | const approvals = [...snapshot.approvals]; | ||
| 87 | approvals[index] = nextApproval; | ||
| 88 | |||
| 89 | return { | ||
| 90 | ...snapshot, | ||
| 91 | generatedAt: Date.now(), | ||
| 92 | approvals, | ||
| 93 | }; | ||
| 94 | }; | ||
| 95 | |||
| 96 | export type PmPersistentToolApprovalPolicyOptions = { | ||
| 97 | requireApprovals?: boolean; | ||
| 98 | retryAfterMs?: number; | ||
| 99 | }; | ||
| 100 | |||
| 101 | export const createPmPersistentToolApprovalPolicy = ( | ||
| 102 | localStateStore: LocalStateStore, | ||
| 103 | options: PmPersistentToolApprovalPolicyOptions = {}, | ||
| 104 | ): ToolApprovalPolicy => { | ||
| 105 | const missingSnapshotError = (operation: string): PersistentToolApprovalPolicyStoreError => | ||
| 106 | toPersistentApprovalStoreError( | ||
| 107 | operation, | ||
| 108 | "Persistent approvals require an initialized local state snapshot", | ||
| 109 | null, | ||
| 110 | ); | ||
| 111 | |||
| 112 | const store: PersistentToolApprovalStore = { | ||
| 113 | findByRunAndCall: (input) => | ||
| 114 | localStateStore.getSnapshot().pipe( | ||
| 115 | Effect.mapError((error) => | ||
| 116 | toPersistentApprovalStoreErrorFromLocalState("approvals.read", error), | ||
| 117 | ), | ||
| 118 | Effect.flatMap((snapshotOption) => { | ||
| 119 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 120 | if (snapshot === null) { | ||
| 121 | return Effect.fail(missingSnapshotError("approvals.read")); | ||
| 122 | } | ||
| 123 | |||
| 124 | const approval = | ||
| 125 | snapshot.approvals.find( | ||
| 126 | (candidate) => | ||
| 127 | candidate.workspaceId === input.workspaceId && | ||
| 128 | candidate.taskRunId === input.runId && | ||
| 129 | candidate.callId === input.callId, | ||
| 130 | ) ?? null; | ||
| 131 | |||
| 132 | return Effect.succeed(approval ? toPersistentApprovalRecord(approval) : null); | ||
| 133 | }), | ||
| 134 | ), | ||
| 135 | |||
| 136 | createPending: (input) => | ||
| 137 | localStateStore.getSnapshot().pipe( | ||
| 138 | Effect.mapError((error) => | ||
| 139 | toPersistentApprovalStoreErrorFromLocalState("approvals.read", error), | ||
| 140 | ), | ||
| 141 | Effect.flatMap((snapshotOption) => { | ||
| 142 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 143 | if (snapshot === null) { | ||
| 144 | return Effect.fail(missingSnapshotError("approvals.create")); | ||
| 145 | } | ||
| 146 | |||
| 147 | const pendingApproval = { | ||
| 148 | id: `apr_${crypto.randomUUID()}`, | ||
| 149 | workspaceId: input.workspaceId, | ||
| 150 | taskRunId: input.runId, | ||
| 151 | callId: input.callId, | ||
| 152 | toolPath: input.toolPath, | ||
| 153 | status: "pending", | ||
| 154 | inputPreviewJson: input.inputPreviewJson, | ||
| 155 | reason: null, | ||
| 156 | requestedAt: Date.now(), | ||
| 157 | resolvedAt: null, | ||
| 158 | } as Approval; | ||
| 159 | |||
| 160 | const nextSnapshot: LocalStateSnapshot = { | ||
| 161 | ...snapshot, | ||
| 162 | generatedAt: Date.now(), | ||
| 163 | approvals: [...snapshot.approvals, pendingApproval], | ||
| 164 | }; | ||
| 165 | |||
| 166 | return localStateStore.writeSnapshot(nextSnapshot).pipe( | ||
| 167 | Effect.mapError((error) => | ||
| 168 | toPersistentApprovalStoreErrorFromLocalState("approvals.write", error), | ||
| 169 | ), | ||
| 170 | Effect.as(toPersistentApprovalRecord(pendingApproval)), | ||
| 171 | ); | ||
| 172 | }), | ||
| 173 | ), | ||
| 174 | }; | ||
| 175 | |||
| 176 | return createPersistentToolApprovalPolicy({ | ||
| 177 | store, | ||
| 178 | requireApprovals: options.requireApprovals, | ||
| 179 | retryAfterMs: options.retryAfterMs, | ||
| 180 | }); | ||
| 181 | }; | ||
| 182 | |||
| 183 | export const createPmApprovalsService = ( | ||
| 184 | localStateStore: LocalStateStore, | ||
| 185 | ): ControlPlaneApprovalsServiceShape => | ||
| 186 | makeControlPlaneApprovalsService({ | ||
| 187 | listApprovals: (workspaceId) => | ||
| 188 | Effect.gen(function* () { | ||
| 189 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 190 | Effect.mapError((error) => | ||
| 191 | toSourceStoreErrorFromLocalState("approvals.list", error), | ||
| 192 | ), | ||
| 193 | ); | ||
| 194 | |||
| 195 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 196 | if (snapshot === null) { | ||
| 197 | return []; | ||
| 198 | } | ||
| 199 | |||
| 200 | const approvals = snapshot.approvals.filter( | ||
| 201 | (approval) => approval.workspaceId === workspaceId, | ||
| 202 | ); | ||
| 203 | |||
| 204 | return sortApprovals(approvals); | ||
| 205 | }), | ||
| 206 | |||
| 207 | resolveApproval: (input) => | ||
| 208 | Effect.gen(function* () { | ||
| 209 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 210 | Effect.mapError((error) => | ||
| 211 | toSourceStoreErrorFromLocalState("approvals.resolve", error), | ||
| 212 | ), | ||
| 213 | ); | ||
| 214 | |||
| 215 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 216 | if (snapshot === null) { | ||
| 217 | return yield* toSourceStoreError( | ||
| 218 | "approvals.resolve", | ||
| 219 | "Approval snapshot not found", | ||
| 220 | `workspace=${input.workspaceId} approval=${input.approvalId}`, | ||
| 221 | ); | ||
| 222 | } | ||
| 223 | |||
| 224 | const index = findApprovalIndex( | ||
| 225 | snapshot.approvals, | ||
| 226 | input.workspaceId, | ||
| 227 | input.approvalId, | ||
| 228 | ); | ||
| 229 | |||
| 230 | if (index < 0) { | ||
| 231 | return yield* toSourceStoreError( | ||
| 232 | "approvals.resolve", | ||
| 233 | "Approval not found", | ||
| 234 | `workspace=${input.workspaceId} approval=${input.approvalId}`, | ||
| 235 | ); | ||
| 236 | } | ||
| 237 | |||
| 238 | const approval = snapshot.approvals[index]; | ||
| 239 | if (approval.status !== "pending") { | ||
| 240 | return yield* toSourceStoreError( | ||
| 241 | "approvals.resolve", | ||
| 242 | "Approval is not pending", | ||
| 243 | `approval=${input.approvalId} status=${approval.status}`, | ||
| 244 | ); | ||
| 245 | } | ||
| 246 | |||
| 247 | const resolvedApproval: Approval = { | ||
| 248 | ...approval, | ||
| 249 | status: input.payload.status, | ||
| 250 | reason: input.payload.reason ?? approval.reason ?? null, | ||
| 251 | resolvedAt: Date.now(), | ||
| 252 | }; | ||
| 253 | |||
| 254 | const nextSnapshot = updateApproval(snapshot, index, resolvedApproval); | ||
| 255 | |||
| 256 | yield* localStateStore.writeSnapshot(nextSnapshot).pipe( | ||
| 257 | Effect.mapError((error) => | ||
| 258 | toSourceStoreErrorFromLocalState("approvals.resolve_write", error), | ||
| 259 | ), | ||
| 260 | ); | ||
| 261 | |||
| 262 | return resolvedApproval; | ||
| 263 | }), | ||
| 264 | }); | ||
| @@ -0,0 +1,26 @@ | |||
| 1 | import * as Config from "effect/Config"; | ||
| 2 | import * as Context from "effect/Context"; | ||
| 3 | import * as Effect from "effect/Effect"; | ||
| 4 | import * as Layer from "effect/Layer"; | ||
| 5 | |||
| 6 | export type PmConfigService = { | ||
| 7 | port: number; | ||
| 8 | }; | ||
| 9 | |||
| 10 | export class PmConfig extends Context.Tag("@executor-v2/app-pm/PmConfig")< | ||
| 11 | PmConfig, | ||
| 12 | PmConfigService | ||
| 13 | >() {} | ||
| 14 | |||
| 15 | export const PmConfigLive = Layer.effect( | ||
| 16 | PmConfig, | ||
| 17 | Effect.gen(function* () { | ||
| 18 | const port = yield* Config.integer("PORT").pipe( | ||
| 19 | Config.orElse(() => Config.succeed(8788)), | ||
| 20 | ); | ||
| 21 | |||
| 22 | return PmConfig.of({ | ||
| 23 | port, | ||
| 24 | }); | ||
| 25 | }), | ||
| 26 | ); | ||
| @@ -0,0 +1,78 @@ | |||
| 1 | import { | ||
| 2 | buildCredentialHeaders, | ||
| 3 | CredentialResolverError, | ||
| 4 | extractCredentialResolutionContext, | ||
| 5 | makeCredentialResolver, | ||
| 6 | selectCredentialBinding, | ||
| 7 | selectOAuthAccessToken, | ||
| 8 | sourceIdFromSourceKey, | ||
| 9 | type ResolveToolCredentials, | ||
| 10 | } from "@executor-v2/engine"; | ||
| 11 | import { type LocalStateStore } from "@executor-v2/persistence-local"; | ||
| 12 | import * as Effect from "effect/Effect"; | ||
| 13 | import * as Option from "effect/Option"; | ||
| 14 | |||
| 15 | const toCredentialResolverError = ( | ||
| 16 | operation: string, | ||
| 17 | message: string, | ||
| 18 | details: string | null, | ||
| 19 | ): CredentialResolverError => | ||
| 20 | new CredentialResolverError({ | ||
| 21 | operation, | ||
| 22 | message, | ||
| 23 | details, | ||
| 24 | }); | ||
| 25 | |||
| 26 | export const createPmResolveToolCredentials = ( | ||
| 27 | localStateStore: LocalStateStore, | ||
| 28 | ): ResolveToolCredentials => | ||
| 29 | makeCredentialResolver((input) => | ||
| 30 | Effect.gen(function* () { | ||
| 31 | const context = extractCredentialResolutionContext(input); | ||
| 32 | if (context === null) { | ||
| 33 | return { | ||
| 34 | headers: {}, | ||
| 35 | }; | ||
| 36 | } | ||
| 37 | |||
| 38 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 39 | Effect.mapError((error) => | ||
| 40 | toCredentialResolverError( | ||
| 41 | "read_local_state_snapshot", | ||
| 42 | "Failed reading local snapshot while resolving credentials", | ||
| 43 | error.details ?? error.message, | ||
| 44 | ), | ||
| 45 | ), | ||
| 46 | ); | ||
| 47 | |||
| 48 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 49 | if (snapshot === null) { | ||
| 50 | return { | ||
| 51 | headers: {}, | ||
| 52 | }; | ||
| 53 | } | ||
| 54 | |||
| 55 | const binding = selectCredentialBinding( | ||
| 56 | snapshot.credentialBindings, | ||
| 57 | context, | ||
| 58 | ); | ||
| 59 | if (binding === null) { | ||
| 60 | return { | ||
| 61 | headers: {}, | ||
| 62 | }; | ||
| 63 | } | ||
| 64 | |||
| 65 | const sourceId = sourceIdFromSourceKey(context.sourceKey); | ||
| 66 | |||
| 67 | const oauthAccessToken = | ||
| 68 | binding.provider === "oauth2" && sourceId | ||
| 69 | ? selectOAuthAccessToken(snapshot.oauthTokens, context, sourceId) | ||
| 70 | : null; | ||
| 71 | |||
| 72 | return { | ||
| 73 | headers: buildCredentialHeaders(binding, { | ||
| 74 | oauthAccessToken, | ||
| 75 | }), | ||
| 76 | }; | ||
| 77 | }), | ||
| 78 | ); | ||
| @@ -0,0 +1,263 @@ | |||
| 1 | import { SourceStoreError } from "@executor-v2/persistence-ports"; | ||
| 2 | import { | ||
| 3 | type LocalStateSnapshot, | ||
| 4 | type LocalStateStore, | ||
| 5 | type LocalStateStoreError, | ||
| 6 | } from "@executor-v2/persistence-local"; | ||
| 7 | import { | ||
| 8 | makeControlPlaneCredentialsService, | ||
| 9 | type ControlPlaneCredentialsServiceShape, | ||
| 10 | } from "@executor-v2/management-api"; | ||
| 11 | import { | ||
| 12 | type OrganizationId, | ||
| 13 | type SourceCredentialBinding, | ||
| 14 | type WorkspaceId, | ||
| 15 | } from "@executor-v2/schema"; | ||
| 16 | import * as Effect from "effect/Effect"; | ||
| 17 | import * as Option from "effect/Option"; | ||
| 18 | |||
| 19 | const toSourceStoreError = ( | ||
| 20 | operation: string, | ||
| 21 | message: string, | ||
| 22 | details: string | null, | ||
| 23 | ): SourceStoreError => | ||
| 24 | new SourceStoreError({ | ||
| 25 | operation, | ||
| 26 | backend: "local-file", | ||
| 27 | location: "snapshot.json", | ||
| 28 | message, | ||
| 29 | reason: null, | ||
| 30 | details, | ||
| 31 | }); | ||
| 32 | |||
| 33 | const toSourceStoreErrorFromLocalState = ( | ||
| 34 | operation: string, | ||
| 35 | error: LocalStateStoreError, | ||
| 36 | ): SourceStoreError => | ||
| 37 | toSourceStoreError(operation, error.message, error.details ?? error.reason ?? null); | ||
| 38 | |||
| 39 | const resolveWorkspaceOrganizationId = ( | ||
| 40 | snapshot: LocalStateSnapshot, | ||
| 41 | workspaceId: WorkspaceId, | ||
| 42 | ): OrganizationId => { | ||
| 43 | const workspace = snapshot.workspaces.find((item) => item.id === workspaceId); | ||
| 44 | |||
| 45 | if (!workspace) { | ||
| 46 | throw new Error(`Workspace not found: ${workspaceId}`); | ||
| 47 | } | ||
| 48 | |||
| 49 | return workspace.organizationId; | ||
| 50 | }; | ||
| 51 | |||
| 52 | const sortCredentialBindings = ( | ||
| 53 | bindings: ReadonlyArray<SourceCredentialBinding>, | ||
| 54 | ): Array<SourceCredentialBinding> => | ||
| 55 | [...bindings].sort((left, right) => { | ||
| 56 | const leftKey = `${left.sourceKey}:${left.provider}:${left.id}`.toLowerCase(); | ||
| 57 | const rightKey = `${right.sourceKey}:${right.provider}:${right.id}`.toLowerCase(); | ||
| 58 | return leftKey.localeCompare(rightKey); | ||
| 59 | }); | ||
| 60 | |||
| 61 | const replaceCredentialBindingAt = ( | ||
| 62 | snapshot: LocalStateSnapshot, | ||
| 63 | index: number, | ||
| 64 | binding: SourceCredentialBinding, | ||
| 65 | ): LocalStateSnapshot => { | ||
| 66 | const next = [...snapshot.credentialBindings]; | ||
| 67 | next[index] = binding; | ||
| 68 | |||
| 69 | return { | ||
| 70 | ...snapshot, | ||
| 71 | generatedAt: Date.now(), | ||
| 72 | credentialBindings: next, | ||
| 73 | }; | ||
| 74 | }; | ||
| 75 | |||
| 76 | const appendCredentialBinding = ( | ||
| 77 | snapshot: LocalStateSnapshot, | ||
| 78 | binding: SourceCredentialBinding, | ||
| 79 | ): LocalStateSnapshot => ({ | ||
| 80 | ...snapshot, | ||
| 81 | generatedAt: Date.now(), | ||
| 82 | credentialBindings: [...snapshot.credentialBindings, binding], | ||
| 83 | }); | ||
| 84 | |||
| 85 | const removeCredentialBindingForWorkspace = ( | ||
| 86 | snapshot: LocalStateSnapshot, | ||
| 87 | workspaceId: WorkspaceId, | ||
| 88 | credentialBindingId: string, | ||
| 89 | ): { snapshot: LocalStateSnapshot; removed: boolean } => { | ||
| 90 | const organizationId = resolveWorkspaceOrganizationId(snapshot, workspaceId); | ||
| 91 | const removeIndex = snapshot.credentialBindings.findIndex( | ||
| 92 | (binding) => | ||
| 93 | binding.id === credentialBindingId | ||
| 94 | && ( | ||
| 95 | binding.workspaceId === workspaceId | ||
| 96 | || (binding.workspaceId === null && binding.organizationId === organizationId) | ||
| 97 | ), | ||
| 98 | ); | ||
| 99 | |||
| 100 | if (removeIndex < 0) { | ||
| 101 | return { | ||
| 102 | snapshot, | ||
| 103 | removed: false, | ||
| 104 | }; | ||
| 105 | } | ||
| 106 | |||
| 107 | const next = [...snapshot.credentialBindings]; | ||
| 108 | next.splice(removeIndex, 1); | ||
| 109 | |||
| 110 | return { | ||
| 111 | removed: true, | ||
| 112 | snapshot: { | ||
| 113 | ...snapshot, | ||
| 114 | generatedAt: Date.now(), | ||
| 115 | credentialBindings: next, | ||
| 116 | }, | ||
| 117 | }; | ||
| 118 | }; | ||
| 119 | |||
| 120 | export const createPmCredentialsService = ( | ||
| 121 | localStateStore: LocalStateStore, | ||
| 122 | ): ControlPlaneCredentialsServiceShape => | ||
| 123 | makeControlPlaneCredentialsService({ | ||
| 124 | listCredentialBindings: (workspaceId) => | ||
| 125 | Effect.gen(function* () { | ||
| 126 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 127 | Effect.mapError((error) => | ||
| 128 | toSourceStoreErrorFromLocalState("credentials.list", error), | ||
| 129 | ), | ||
| 130 | ); | ||
| 131 | |||
| 132 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 133 | if (snapshot === null) { | ||
| 134 | return []; | ||
| 135 | } | ||
| 136 | |||
| 137 | const organizationId = resolveWorkspaceOrganizationId(snapshot, workspaceId); | ||
| 138 | |||
| 139 | return sortCredentialBindings( | ||
| 140 | snapshot.credentialBindings.filter( | ||
| 141 | (binding) => | ||
| 142 | binding.workspaceId === workspaceId | ||
| 143 | || (binding.workspaceId === null && binding.organizationId === organizationId), | ||
| 144 | ), | ||
| 145 | ); | ||
| 146 | }), | ||
| 147 | |||
| 148 | upsertCredentialBinding: (input) => | ||
| 149 | Effect.gen(function* () { | ||
| 150 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 151 | Effect.mapError((error) => | ||
| 152 | toSourceStoreErrorFromLocalState("credentials.upsert", error), | ||
| 153 | ), | ||
| 154 | ); | ||
| 155 | |||
| 156 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 157 | if (snapshot === null) { | ||
| 158 | return yield* toSourceStoreError( | ||
| 159 | "credentials.upsert", | ||
| 160 | "Credential snapshot not found", | ||
| 161 | `workspace=${input.workspaceId}`, | ||
| 162 | ); | ||
| 163 | } | ||
| 164 | |||
| 165 | if (input.payload.scopeType === "account" && input.payload.accountId === null) { | ||
| 166 | return yield* toSourceStoreError( | ||
| 167 | "credentials.upsert", | ||
| 168 | "Account scope credentials require accountId", | ||
| 169 | `workspace=${input.workspaceId}`, | ||
| 170 | ); | ||
| 171 | } | ||
| 172 | |||
| 173 | const now = Date.now(); | ||
| 174 | const requestedId = input.payload.id; | ||
| 175 | |||
| 176 | const existingIndex = requestedId | ||
| 177 | ? snapshot.credentialBindings.findIndex( | ||
| 178 | (binding) => | ||
| 179 | binding.workspaceId === input.workspaceId && binding.id === requestedId, | ||
| 180 | ) | ||
| 181 | : -1; | ||
| 182 | |||
| 183 | const existing = existingIndex >= 0 ? snapshot.credentialBindings[existingIndex] : null; | ||
| 184 | const organizationId = resolveWorkspaceOrganizationId(snapshot, input.workspaceId); | ||
| 185 | |||
| 186 | const nextBinding: SourceCredentialBinding = { | ||
| 187 | id: | ||
| 188 | existing?.id | ||
| 189 | ?? (requestedId | ||
| 190 | ?? (`credential_binding_${crypto.randomUUID()}` as SourceCredentialBinding["id"])), | ||
| 191 | credentialId: input.payload.credentialId, | ||
| 192 | organizationId, | ||
| 193 | workspaceId: | ||
| 194 | input.payload.scopeType === "workspace" ? input.workspaceId : null, | ||
| 195 | accountId: | ||
| 196 | input.payload.scopeType === "account" | ||
| 197 | ? (input.payload.accountId ?? null) | ||
| 198 | : null, | ||
| 199 | scopeType: input.payload.scopeType, | ||
| 200 | sourceKey: input.payload.sourceKey, | ||
| 201 | provider: input.payload.provider, | ||
| 202 | secretProvider: | ||
| 203 | input.payload.secretProvider | ||
| 204 | ?? existing?.secretProvider | ||
| 205 | ?? "local", | ||
| 206 | secretRef: input.payload.secretRef, | ||
| 207 | additionalHeadersJson: input.payload.additionalHeadersJson ?? null, | ||
| 208 | boundAuthFingerprint: input.payload.boundAuthFingerprint ?? null, | ||
| 209 | createdAt: existing?.createdAt ?? now, | ||
| 210 | updatedAt: now, | ||
| 211 | }; | ||
| 212 | |||
| 213 | const nextSnapshot = existingIndex >= 0 | ||
| 214 | ? replaceCredentialBindingAt(snapshot, existingIndex, nextBinding) | ||
| 215 | : appendCredentialBinding(snapshot, nextBinding); | ||
| 216 | |||
| 217 | yield* localStateStore.writeSnapshot(nextSnapshot).pipe( | ||
| 218 | Effect.mapError((error) => | ||
| 219 | toSourceStoreErrorFromLocalState("credentials.upsert_write", error), | ||
| 220 | ), | ||
| 221 | ); | ||
| 222 | |||
| 223 | return nextBinding; | ||
| 224 | }), | ||
| 225 | |||
| 226 | removeCredentialBinding: (input) => | ||
| 227 | Effect.gen(function* () { | ||
| 228 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 229 | Effect.mapError((error) => | ||
| 230 | toSourceStoreErrorFromLocalState("credentials.remove", error), | ||
| 231 | ), | ||
| 232 | ); | ||
| 233 | |||
| 234 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 235 | if (snapshot === null) { | ||
| 236 | return { | ||
| 237 | removed: false, | ||
| 238 | }; | ||
| 239 | } | ||
| 240 | |||
| 241 | const next = removeCredentialBindingForWorkspace( | ||
| 242 | snapshot, | ||
| 243 | input.workspaceId, | ||
| 244 | input.credentialBindingId, | ||
| 245 | ); | ||
| 246 | |||
| 247 | if (!next.removed) { | ||
| 248 | return { | ||
| 249 | removed: false, | ||
| 250 | }; | ||
| 251 | } | ||
| 252 | |||
| 253 | yield* localStateStore.writeSnapshot(next.snapshot).pipe( | ||
| 254 | Effect.mapError((error) => | ||
| 255 | toSourceStoreErrorFromLocalState("credentials.remove_write", error), | ||
| 256 | ), | ||
| 257 | ); | ||
| 258 | |||
| 259 | return { | ||
| 260 | removed: true, | ||
| 261 | }; | ||
| 262 | }), | ||
| 263 | }); | ||
| @@ -0,0 +1,167 @@ | |||
| 1 | import { spawn } from "node:child_process"; | ||
| 2 | import { createServer } from "node:net"; | ||
| 3 | import { Client } from "@modelcontextprotocol/sdk/client/index.js"; | ||
| 4 | import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"; | ||
| 5 | import { describe, expect, it } from "@effect/vitest"; | ||
| 6 | import * as Data from "effect/Data"; | ||
| 7 | import * as Effect from "effect/Effect"; | ||
| 8 | |||
| 9 | const pmAppDir = new URL("..", import.meta.url).pathname; | ||
| 10 | |||
| 11 | type McpCallToolResult = { | ||
| 12 | isError?: boolean; | ||
| 13 | content?: Array<{ type?: string; text?: string }>; | ||
| 14 | }; | ||
| 15 | |||
| 16 | class ExecuteE2eError extends Data.TaggedError("ExecuteE2eError")<{ | ||
| 17 | message: string; | ||
| 18 | details: string | null; | ||
| 19 | }> {} | ||
| 20 | |||
| 21 | const toExecuteE2eError = (message: string, cause: unknown): ExecuteE2eError => | ||
| 22 | new ExecuteE2eError({ | ||
| 23 | message, | ||
| 24 | details: cause instanceof Error ? cause.message : String(cause), | ||
| 25 | }); | ||
| 26 | |||
| 27 | const findFreePort = Effect.async<number, ExecuteE2eError, never>((resume) => { | ||
| 28 | const server = createServer(); | ||
| 29 | |||
| 30 | server.once("error", (cause) => { | ||
| 31 | resume(Effect.fail(toExecuteE2eError("Failed to allocate free TCP port", cause))); | ||
| 32 | }); | ||
| 33 | |||
| 34 | server.listen(0, "127.0.0.1", () => { | ||
| 35 | const address = server.address(); | ||
| 36 | const port = typeof address === "object" && address ? address.port : null; | ||
| 37 | |||
| 38 | server.close((cause) => { | ||
| 39 | if (cause) { | ||
| 40 | resume(Effect.fail(toExecuteE2eError("Failed closing port probe server", cause))); | ||
| 41 | return; | ||
| 42 | } | ||
| 43 | |||
| 44 | if (!port) { | ||
| 45 | resume( | ||
| 46 | Effect.fail( | ||
| 47 | new ExecuteE2eError({ | ||
| 48 | message: "Failed to allocate free TCP port", | ||
| 49 | details: "No port returned from node:net server", | ||
| 50 | }), | ||
| 51 | ), | ||
| 52 | ); | ||
| 53 | return; | ||
| 54 | } | ||
| 55 | |||
| 56 | resume(Effect.succeed(port)); | ||
| 57 | }); | ||
| 58 | }); | ||
| 59 | }); | ||
| 60 | |||
| 61 | const waitForHealth = (port: number) => | ||
| 62 | Effect.gen(function* () { | ||
| 63 | for (let attempt = 0; attempt < 80; attempt += 1) { | ||
| 64 | const healthy = yield* Effect.tryPromise({ | ||
| 65 | try: async () => { | ||
| 66 | const signal = AbortSignal.timeout(250); | ||
| 67 | const response = await fetch(`http://127.0.0.1:${port}/healthz`, { signal }); | ||
| 68 | return response.status === 200; | ||
| 69 | }, | ||
| 70 | catch: (cause) => | ||
| 71 | toExecuteE2eError("Failed polling PM health endpoint", cause), | ||
| 72 | }).pipe(Effect.catchAll(() => Effect.succeed(false))); | ||
| 73 | |||
| 74 | if (healthy) { | ||
| 75 | return; | ||
| 76 | } | ||
| 77 | |||
| 78 | yield* Effect.sleep("100 millis"); | ||
| 79 | } | ||
| 80 | |||
| 81 | return yield* new ExecuteE2eError({ | ||
| 82 | message: "PM server did not become healthy in time", | ||
| 83 | details: `http://127.0.0.1:${port}/healthz`, | ||
| 84 | }); | ||
| 85 | }); | ||
| 86 | |||
| 87 | const withPmProcess = (port: number) => | ||
| 88 | Effect.acquireRelease( | ||
| 89 | Effect.sync(() => | ||
| 90 | spawn("bun", ["src/main.ts"], { | ||
| 91 | cwd: pmAppDir, | ||
| 92 | env: { | ||
| 93 | ...process.env, | ||
| 94 | PORT: String(port), | ||
| 95 | }, | ||
| 96 | stdio: "pipe", | ||
| 97 | }), | ||
| 98 | ), | ||
| 99 | (child) => | ||
| 100 | Effect.sync(() => { | ||
| 101 | if (!child.killed) { | ||
| 102 | child.kill("SIGTERM"); | ||
| 103 | } | ||
| 104 | }), | ||
| 105 | ); | ||
| 106 | |||
| 107 | const withMcpClient = (port: number) => | ||
| 108 | Effect.acquireRelease( | ||
| 109 | Effect.tryPromise({ | ||
| 110 | try: async () => { | ||
| 111 | const transport = new StreamableHTTPClientTransport( | ||
| 112 | new URL(`http://127.0.0.1:${port}/v1/mcp`), | ||
| 113 | ); | ||
| 114 | const client = new Client( | ||
| 115 | { name: "executor-v2-pm-e2e", version: "0.0.0" }, | ||
| 116 | { capabilities: {} }, | ||
| 117 | ); | ||
| 118 | |||
| 119 | await client.connect(transport); | ||
| 120 | return { client, transport }; | ||
| 121 | }, | ||
| 122 | catch: (cause) => | ||
| 123 | toExecuteE2eError("Failed to initialize MCP client transport", cause), | ||
| 124 | }), | ||
| 125 | ({ client, transport }) => | ||
| 126 | Effect.tryPromise({ | ||
| 127 | try: async () => { | ||
| 128 | await transport.close().catch(() => undefined); | ||
| 129 | await client.close().catch(() => undefined); | ||
| 130 | }, | ||
| 131 | catch: (cause) => | ||
| 132 | toExecuteE2eError("Failed closing MCP client transport", cause), | ||
| 133 | }).pipe(Effect.orDie), | ||
| 134 | ); | ||
| 135 | |||
| 136 | describe("PM execute E2E", () => { | ||
| 137 | it.live( | ||
| 138 | "runs executor.execute code through MCP", | ||
| 139 | () => | ||
| 140 | Effect.scoped( | ||
| 141 | Effect.gen(function* () { | ||
| 142 | const port = yield* findFreePort; | ||
| 143 | yield* withPmProcess(port); | ||
| 144 | yield* waitForHealth(port); | ||
| 145 | |||
| 146 | const { client } = yield* withMcpClient(port); | ||
| 147 | |||
| 148 | const result = (yield* Effect.tryPromise({ | ||
| 149 | try: () => | ||
| 150 | client.callTool({ | ||
| 151 | name: "executor.execute", | ||
| 152 | arguments: { | ||
| 153 | code: "return 2 + 3;", | ||
| 154 | }, | ||
| 155 | }), | ||
| 156 | catch: (cause) => | ||
| 157 | toExecuteE2eError("Failed calling executor.execute over MCP", cause), | ||
| 158 | })) as McpCallToolResult; | ||
| 159 | |||
| 160 | expect(result.isError).toBe(false); | ||
| 161 | const textPart = result.content?.find((part) => part.type === "text"); | ||
| 162 | expect(textPart?.text).toBe("5"); | ||
| 163 | }), | ||
| 164 | ), | ||
| 165 | 30_000, | ||
| 166 | ); | ||
| 167 | }); | ||
| @@ -0,0 +1,92 @@ | |||
| 1 | import { controlPlaneOpenApiSpec } from "@executor-v2/management-api"; | ||
| 2 | |||
| 3 | export type StartPmHttpServerOptions = { | ||
| 4 | port: number; | ||
| 5 | handleMcp: (request: Request) => Promise<Response>; | ||
| 6 | handleToolCall: (request: Request) => Promise<Response>; | ||
| 7 | handleControlPlane: (request: Request) => Promise<Response>; | ||
| 8 | }; | ||
| 9 | |||
| 10 | export type PmHttpServer = { | ||
| 11 | stop: () => void; | ||
| 12 | }; | ||
| 13 | |||
| 14 | const methodNotAllowed = (allowed: string): Response => | ||
| 15 | Response.json( | ||
| 16 | { | ||
| 17 | ok: false, | ||
| 18 | error: `Method not allowed. Expected ${allowed}`, | ||
| 19 | }, | ||
| 20 | { status: 405 }, | ||
| 21 | ); | ||
| 22 | |||
| 23 | const notFound = (): Response => | ||
| 24 | Response.json( | ||
| 25 | { | ||
| 26 | ok: false, | ||
| 27 | error: "Not found", | ||
| 28 | }, | ||
| 29 | { status: 404 }, | ||
| 30 | ); | ||
| 31 | |||
| 32 | const isControlPlaneMethod = (method: string): boolean => | ||
| 33 | method === "GET" || | ||
| 34 | method === "POST" || | ||
| 35 | method === "PUT" || | ||
| 36 | method === "PATCH" || | ||
| 37 | method === "DELETE" || | ||
| 38 | method === "OPTIONS"; | ||
| 39 | |||
| 40 | export const startPmHttpServer = (options: StartPmHttpServerOptions): PmHttpServer => { | ||
| 41 | const server = Bun.serve({ | ||
| 42 | port: options.port, | ||
| 43 | hostname: "127.0.0.1", | ||
| 44 | fetch: async (request) => { | ||
| 45 | const { pathname } = new URL(request.url); | ||
| 46 | |||
| 47 | if (pathname === "/healthz") { | ||
| 48 | return Response.json({ ok: true, service: "pm" }); | ||
| 49 | } | ||
| 50 | |||
| 51 | if (pathname === "/v1/mcp") { | ||
| 52 | if ( | ||
| 53 | request.method !== "GET" && | ||
| 54 | request.method !== "POST" && | ||
| 55 | request.method !== "DELETE" | ||
| 56 | ) { | ||
| 57 | return methodNotAllowed("GET, POST, DELETE"); | ||
| 58 | } | ||
| 59 | |||
| 60 | return options.handleMcp(request); | ||
| 61 | } | ||
| 62 | |||
| 63 | if (pathname === "/v1/runtime/tool-call") { | ||
| 64 | if (request.method !== "POST") { | ||
| 65 | return methodNotAllowed("POST"); | ||
| 66 | } | ||
| 67 | |||
| 68 | return options.handleToolCall(request); | ||
| 69 | } | ||
| 70 | |||
| 71 | if (pathname === "/v1/openapi.json") { | ||
| 72 | if (request.method !== "GET") { | ||
| 73 | return methodNotAllowed("GET"); | ||
| 74 | } | ||
| 75 | |||
| 76 | return Response.json(controlPlaneOpenApiSpec); | ||
| 77 | } | ||
| 78 | |||
| 79 | if (pathname.startsWith("/v1/") && isControlPlaneMethod(request.method)) { | ||
| 80 | return options.handleControlPlane(request); | ||
| 81 | } | ||
| 82 | |||
| 83 | return notFound(); | ||
| 84 | }, | ||
| 85 | }); | ||
| 86 | |||
| 87 | return { | ||
| 88 | stop: () => { | ||
| 89 | server.stop(true); | ||
| 90 | }, | ||
| 91 | }; | ||
| 92 | }; | ||
| @@ -0,0 +1,239 @@ | |||
| 1 | import * as BunContext from "@effect/platform-bun/BunContext"; | ||
| 2 | import { | ||
| 3 | ControlPlaneService, | ||
| 4 | makeControlPlaneService, | ||
| 5 | makeControlPlaneSourcesService, | ||
| 6 | fetchOpenApiDocument, | ||
| 7 | makeControlPlaneWebHandler, | ||
| 8 | makeSourceCatalogService, | ||
| 9 | makeSourceManagerService, | ||
| 10 | } from "@executor-v2/management-api"; | ||
| 11 | import { | ||
| 12 | RuntimeAdapterError, | ||
| 13 | makeGraphqlToolProvider, | ||
| 14 | makeMcpToolProvider, | ||
| 15 | createRunExecutor, | ||
| 16 | createSourceToolRegistry, | ||
| 17 | defaultExecuteToolExposureMode, | ||
| 18 | invokeRuntimeToolCallResult, | ||
| 19 | makeOpenApiToolProvider, | ||
| 20 | makeRuntimeAdapterRegistry, | ||
| 21 | makeToolProviderRegistry, | ||
| 22 | parseExecuteToolExposureMode, | ||
| 23 | } from "@executor-v2/engine"; | ||
| 24 | import { | ||
| 25 | makeLocalSourceStore, | ||
| 26 | makeLocalStateStore, | ||
| 27 | makeLocalToolArtifactStore, | ||
| 28 | } from "@executor-v2/persistence-local"; | ||
| 29 | import { type RuntimeToolCallResult } from "@executor-v2/sdk"; | ||
| 30 | import { makeCloudflareWorkerLoaderRuntimeAdapter } from "@executor-v2/runtime-cloudflare-worker-loader"; | ||
| 31 | import { makeDenoSubprocessRuntimeAdapter } from "@executor-v2/runtime-deno-subprocess"; | ||
| 32 | import { makeLocalInProcessRuntimeAdapter } from "@executor-v2/runtime-local-inproc"; | ||
| 33 | import * as Effect from "effect/Effect"; | ||
| 34 | import * as Layer from "effect/Layer"; | ||
| 35 | |||
| 36 | import { PmActorLive } from "./actor"; | ||
| 37 | import { | ||
| 38 | createPmApprovalsService, | ||
| 39 | createPmPersistentToolApprovalPolicy, | ||
| 40 | } from "./approvals-service"; | ||
| 41 | import { startPmHttpServer } from "./http-server"; | ||
| 42 | import { createPmPoliciesService } from "./policies-service"; | ||
| 43 | import { createPmCredentialsService } from "./credentials-service"; | ||
| 44 | import { createPmOrganizationsService } from "./organizations-service"; | ||
| 45 | import { createPmStorageService } from "./storage-service"; | ||
| 46 | import { createPmToolsService } from "./tools-service"; | ||
| 47 | import { createPmWorkspacesService } from "./workspaces-service"; | ||
| 48 | import { createPmMcpHandler } from "./mcp-handler"; | ||
| 49 | import { createPmExecuteRuntimeRun } from "./runtime-execution-port"; | ||
| 50 | import { createPmToolCallHttpHandler } from "./tool-call-handler"; | ||
| 51 | |||
| 52 | const pmStateRootDir = process.env.PM_STATE_ROOT_DIR ?? ".executor-v2/pm-state"; | ||
| 53 | |||
| 54 | const parsePort = (value: string | undefined): number => { | ||
| 55 | const parsed = Number.parseInt(value ?? "", 10); | ||
| 56 | return Number.isFinite(parsed) && parsed > 0 ? parsed : 8787; | ||
| 57 | }; | ||
| 58 | |||
| 59 | const readConfiguredRuntimeKind = (value: string | undefined): string | undefined => { | ||
| 60 | if (!value) { | ||
| 61 | return undefined; | ||
| 62 | } | ||
| 63 | |||
| 64 | const normalized = value.trim(); | ||
| 65 | return normalized.length > 0 ? normalized : undefined; | ||
| 66 | }; | ||
| 67 | |||
| 68 | const readConfiguredWorkspaceId = (value: string | undefined): string => { | ||
| 69 | const normalized = value?.trim(); | ||
| 70 | return normalized && normalized.length > 0 ? normalized : "ws_local"; | ||
| 71 | }; | ||
| 72 | |||
| 73 | const readBooleanFlag = (value: string | undefined): boolean => { | ||
| 74 | const normalized = value?.trim().toLowerCase(); | ||
| 75 | return normalized === "1" || normalized === "true" || normalized === "yes"; | ||
| 76 | }; | ||
| 77 | |||
| 78 | const readConfiguredToolExposureMode = ( | ||
| 79 | value: string | undefined, | ||
| 80 | ): "all_tools" | "sources_only" => | ||
| 81 | parseExecuteToolExposureMode(value ?? undefined) ?? | ||
| 82 | defaultExecuteToolExposureMode; | ||
| 83 | |||
| 84 | const formatRuntimeAdapterError = (error: RuntimeAdapterError): string => | ||
| 85 | error.details ? `${error.message}: ${error.details}` : error.message; | ||
| 86 | |||
| 87 | const port = parsePort(process.env.PORT); | ||
| 88 | const workspaceId = readConfiguredWorkspaceId(process.env.PM_WORKSPACE_ID); | ||
| 89 | const requireToolApprovals = readBooleanFlag(process.env.PM_REQUIRE_TOOL_APPROVALS); | ||
| 90 | const defaultToolExposureMode = readConfiguredToolExposureMode( | ||
| 91 | process.env.PM_TOOL_EXPOSURE_MODE, | ||
| 92 | ); | ||
| 93 | |||
| 94 | const pmRuntimeAdapters = [ | ||
| 95 | makeLocalInProcessRuntimeAdapter(), | ||
| 96 | makeDenoSubprocessRuntimeAdapter(), | ||
| 97 | makeCloudflareWorkerLoaderRuntimeAdapter(), | ||
| 98 | ]; | ||
| 99 | |||
| 100 | const runtimeAdapters = makeRuntimeAdapterRegistry(pmRuntimeAdapters); | ||
| 101 | const defaultRuntimeKind = | ||
| 102 | readConfiguredRuntimeKind(process.env.PM_RUNTIME_KIND) ?? pmRuntimeAdapters[0].kind; | ||
| 103 | |||
| 104 | const sourceStore = await Effect.runPromise( | ||
| 105 | makeLocalSourceStore({ | ||
| 106 | rootDir: pmStateRootDir, | ||
| 107 | }).pipe(Effect.provide(BunContext.layer)), | ||
| 108 | ); | ||
| 109 | |||
| 110 | const localStateStore = await Effect.runPromise( | ||
| 111 | makeLocalStateStore({ | ||
| 112 | rootDir: pmStateRootDir, | ||
| 113 | }).pipe(Effect.provide(BunContext.layer)), | ||
| 114 | ); | ||
| 115 | |||
| 116 | const toolArtifactStore = await Effect.runPromise( | ||
| 117 | makeLocalToolArtifactStore({ | ||
| 118 | rootDir: pmStateRootDir, | ||
| 119 | }).pipe(Effect.provide(BunContext.layer)), | ||
| 120 | ); | ||
| 121 | |||
| 122 | const sourceCatalog = makeSourceCatalogService(sourceStore); | ||
| 123 | const sourceManager = makeSourceManagerService(toolArtifactStore); | ||
| 124 | const baseSourcesService = makeControlPlaneSourcesService(sourceCatalog); | ||
| 125 | const sourcesService = { | ||
| 126 | ...baseSourcesService, | ||
| 127 | upsertSource: (input: Parameters<typeof baseSourcesService.upsertSource>[0]) => | ||
| 128 | Effect.gen(function* () { | ||
| 129 | const source = yield* baseSourcesService.upsertSource(input); | ||
| 130 | |||
| 131 | if (source.kind !== "openapi") { | ||
| 132 | return source; | ||
| 133 | } | ||
| 134 | |||
| 135 | const openApiSpecResult = yield* Effect.tryPromise({ | ||
| 136 | try: () => fetchOpenApiDocument(source.endpoint), | ||
| 137 | catch: (cause) => String(cause), | ||
| 138 | }).pipe(Effect.either); | ||
| 139 | |||
| 140 | if (openApiSpecResult._tag === "Left") { | ||
| 141 | return source; | ||
| 142 | } | ||
| 143 | |||
| 144 | yield* sourceManager | ||
| 145 | .refreshOpenApiArtifact({ | ||
| 146 | source, | ||
| 147 | openApiSpec: openApiSpecResult.right, | ||
| 148 | }) | ||
| 149 | .pipe(Effect.ignore); | ||
| 150 | |||
| 151 | return source; | ||
| 152 | }), | ||
| 153 | }; | ||
| 154 | |||
| 155 | const credentialsService = createPmCredentialsService(localStateStore); | ||
| 156 | const policiesService = createPmPoliciesService(localStateStore); | ||
| 157 | const organizationsService = createPmOrganizationsService(localStateStore); | ||
| 158 | const workspacesService = createPmWorkspacesService(localStateStore); | ||
| 159 | const toolsService = createPmToolsService(sourceStore, toolArtifactStore); | ||
| 160 | const storageService = createPmStorageService(localStateStore, { | ||
| 161 | stateRootDir: pmStateRootDir, | ||
| 162 | }); | ||
| 163 | const approvalsService = createPmApprovalsService(localStateStore); | ||
| 164 | const controlPlaneService = makeControlPlaneService({ | ||
| 165 | sources: sourcesService, | ||
| 166 | credentials: credentialsService, | ||
| 167 | policies: policiesService, | ||
| 168 | organizations: organizationsService, | ||
| 169 | workspaces: workspacesService, | ||
| 170 | tools: toolsService, | ||
| 171 | storage: storageService, | ||
| 172 | approvals: approvalsService, | ||
| 173 | }); | ||
| 174 | |||
| 175 | const controlPlaneWebHandler = makeControlPlaneWebHandler( | ||
| 176 | Layer.succeed(ControlPlaneService, controlPlaneService), | ||
| 177 | PmActorLive(localStateStore), | ||
| 178 | ); | ||
| 179 | |||
| 180 | const toolProviderRegistry = makeToolProviderRegistry([ | ||
| 181 | makeOpenApiToolProvider(), | ||
| 182 | makeMcpToolProvider(), | ||
| 183 | makeGraphqlToolProvider(), | ||
| 184 | ]); | ||
| 185 | const persistentApprovalPolicy = createPmPersistentToolApprovalPolicy(localStateStore, { | ||
| 186 | requireApprovals: requireToolApprovals, | ||
| 187 | }); | ||
| 188 | const toolRegistry = createSourceToolRegistry({ | ||
| 189 | workspaceId, | ||
| 190 | sourceStore, | ||
| 191 | toolArtifactStore, | ||
| 192 | toolProviderRegistry, | ||
| 193 | approvalPolicy: persistentApprovalPolicy, | ||
| 194 | }); | ||
| 195 | const executeRuntimeRun = createPmExecuteRuntimeRun({ | ||
| 196 | defaultRuntimeKind, | ||
| 197 | runtimeAdapters, | ||
| 198 | toolRegistry, | ||
| 199 | }); | ||
| 200 | |||
| 201 | const runExecutor = createRunExecutor(executeRuntimeRun); | ||
| 202 | const handleMcp = createPmMcpHandler(runExecutor.executeRun, { | ||
| 203 | toolRegistry, | ||
| 204 | defaultToolExposureMode, | ||
| 205 | }); | ||
| 206 | |||
| 207 | const handleToolCallHttp = createPmToolCallHttpHandler((input) => | ||
| 208 | Effect.runPromise( | ||
| 209 | invokeRuntimeToolCallResult(toolRegistry, input).pipe( | ||
| 210 | Effect.catchTag("RuntimeAdapterError", (error) => | ||
| 211 | Effect.succeed<RuntimeToolCallResult>({ | ||
| 212 | ok: false, | ||
| 213 | kind: "failed", | ||
| 214 | error: formatRuntimeAdapterError(error), | ||
| 215 | }), | ||
| 216 | ), | ||
| 217 | ), | ||
| 218 | ), | ||
| 219 | ); | ||
| 220 | |||
| 221 | const server = startPmHttpServer({ | ||
| 222 | port, | ||
| 223 | handleMcp, | ||
| 224 | handleToolCall: handleToolCallHttp, | ||
| 225 | handleControlPlane: controlPlaneWebHandler.handler, | ||
| 226 | }); | ||
| 227 | |||
| 228 | const shutdown = async () => { | ||
| 229 | server.stop(); | ||
| 230 | await controlPlaneWebHandler.dispose(); | ||
| 231 | }; | ||
| 232 | |||
| 233 | process.on("SIGINT", () => { | ||
| 234 | void shutdown().finally(() => process.exit(0)); | ||
| 235 | }); | ||
| 236 | |||
| 237 | process.on("SIGTERM", () => { | ||
| 238 | void shutdown().finally(() => process.exit(0)); | ||
| 239 | }); | ||
| @@ -0,0 +1,76 @@ | |||
| 1 | import { | ||
| 2 | buildExecuteToolDescription, | ||
| 3 | defaultExecuteToolDescription, | ||
| 4 | defaultExecuteToolExposureMode, | ||
| 5 | parseExecuteToolExposureMode, | ||
| 6 | type ExecuteToolExposureMode, | ||
| 7 | type ToolRegistry, | ||
| 8 | } from "@executor-v2/engine"; | ||
| 9 | import { | ||
| 10 | type ExecuteRunInput, | ||
| 11 | type ExecuteRunResult, | ||
| 12 | createExecutorRunClient, | ||
| 13 | } from "@executor-v2/sdk"; | ||
| 14 | import { handleMcpHttpRequest } from "@executor-v2/mcp-gateway"; | ||
| 15 | import * as Effect from "effect/Effect"; | ||
| 16 | |||
| 17 | export type PmMcpHandlerOptions = { | ||
| 18 | toolRegistry: ToolRegistry; | ||
| 19 | defaultToolExposureMode?: ExecuteToolExposureMode; | ||
| 20 | }; | ||
| 21 | |||
| 22 | const readToolExposureModeFromRequest = ( | ||
| 23 | request: Request, | ||
| 24 | fallback: ExecuteToolExposureMode, | ||
| 25 | ): ExecuteToolExposureMode => { | ||
| 26 | const url = new URL(request.url); | ||
| 27 | const rawMode = | ||
| 28 | url.searchParams.get("toolExposureMode") ?? | ||
| 29 | url.searchParams.get("toolContextMode") ?? | ||
| 30 | undefined; | ||
| 31 | |||
| 32 | return parseExecuteToolExposureMode(rawMode ?? undefined) ?? fallback; | ||
| 33 | }; | ||
| 34 | |||
| 35 | const resolveExecuteToolDescription = async ( | ||
| 36 | toolRegistry: ToolRegistry, | ||
| 37 | mode: ExecuteToolExposureMode, | ||
| 38 | ): Promise<string> => { | ||
| 39 | try { | ||
| 40 | return await Effect.runPromise( | ||
| 41 | buildExecuteToolDescription({ | ||
| 42 | toolRegistry, | ||
| 43 | mode, | ||
| 44 | }), | ||
| 45 | ); | ||
| 46 | } catch { | ||
| 47 | return defaultExecuteToolDescription; | ||
| 48 | } | ||
| 49 | }; | ||
| 50 | |||
| 51 | export const createPmMcpHandler = ( | ||
| 52 | executeRun: (input: ExecuteRunInput) => Effect.Effect<ExecuteRunResult>, | ||
| 53 | options: PmMcpHandlerOptions, | ||
| 54 | ): ((request: Request) => Promise<Response>) => { | ||
| 55 | const runClient = createExecutorRunClient((input) => | ||
| 56 | Effect.runPromise(executeRun(input)), | ||
| 57 | ); | ||
| 58 | |||
| 59 | const defaultMode = | ||
| 60 | options.defaultToolExposureMode ?? defaultExecuteToolExposureMode; | ||
| 61 | |||
| 62 | return async (request: Request) => { | ||
| 63 | const mode = readToolExposureModeFromRequest(request, defaultMode); | ||
| 64 | const executeToolDescription = await resolveExecuteToolDescription( | ||
| 65 | options.toolRegistry, | ||
| 66 | mode, | ||
| 67 | ); | ||
| 68 | |||
| 69 | return handleMcpHttpRequest(request, { | ||
| 70 | serverName: "executor-v2-pm", | ||
| 71 | serverVersion: "0.0.0", | ||
| 72 | runClient, | ||
| 73 | executeToolDescription, | ||
| 74 | }); | ||
| 75 | }; | ||
| 76 | }; | ||
| @@ -0,0 +1,180 @@ | |||
| 1 | import { SourceStoreError } from "@executor-v2/persistence-ports"; | ||
| 2 | import { | ||
| 3 | makeControlPlaneOrganizationsService, | ||
| 4 | type ControlPlaneOrganizationsServiceShape, | ||
| 5 | } from "@executor-v2/management-api"; | ||
| 6 | import { | ||
| 7 | type LocalStateSnapshot, | ||
| 8 | type LocalStateStore, | ||
| 9 | type LocalStateStoreError, | ||
| 10 | } from "@executor-v2/persistence-local"; | ||
| 11 | import { | ||
| 12 | type Organization, | ||
| 13 | type OrganizationMembership, | ||
| 14 | } from "@executor-v2/schema"; | ||
| 15 | import * as Effect from "effect/Effect"; | ||
| 16 | import * as Option from "effect/Option"; | ||
| 17 | |||
| 18 | const toSourceStoreError = ( | ||
| 19 | operation: string, | ||
| 20 | message: string, | ||
| 21 | details: string | null, | ||
| 22 | ): SourceStoreError => | ||
| 23 | new SourceStoreError({ | ||
| 24 | operation, | ||
| 25 | backend: "local-file", | ||
| 26 | location: "snapshot.json", | ||
| 27 | message, | ||
| 28 | reason: null, | ||
| 29 | details, | ||
| 30 | }); | ||
| 31 | |||
| 32 | const toSourceStoreErrorFromLocalState = ( | ||
| 33 | operation: string, | ||
| 34 | error: LocalStateStoreError, | ||
| 35 | ): SourceStoreError => | ||
| 36 | toSourceStoreError(operation, error.message, error.details ?? error.reason ?? null); | ||
| 37 | |||
| 38 | const sortOrganizations = ( | ||
| 39 | organizations: ReadonlyArray<Organization>, | ||
| 40 | ): Array<Organization> => | ||
| 41 | [...organizations].sort((left, right) => { | ||
| 42 | const leftName = left.name.toLowerCase(); | ||
| 43 | const rightName = right.name.toLowerCase(); | ||
| 44 | |||
| 45 | if (leftName === rightName) { | ||
| 46 | return left.id.localeCompare(right.id); | ||
| 47 | } | ||
| 48 | |||
| 49 | return leftName.localeCompare(rightName); | ||
| 50 | }); | ||
| 51 | |||
| 52 | const replaceOrganizationAt = ( | ||
| 53 | snapshot: LocalStateSnapshot, | ||
| 54 | index: number, | ||
| 55 | organization: Organization, | ||
| 56 | ): LocalStateSnapshot => { | ||
| 57 | const next = [...snapshot.organizations]; | ||
| 58 | next[index] = organization; | ||
| 59 | |||
| 60 | return { | ||
| 61 | ...snapshot, | ||
| 62 | generatedAt: Date.now(), | ||
| 63 | organizations: next, | ||
| 64 | }; | ||
| 65 | }; | ||
| 66 | |||
| 67 | const appendOrganization = ( | ||
| 68 | snapshot: LocalStateSnapshot, | ||
| 69 | organization: Organization, | ||
| 70 | ): LocalStateSnapshot => ({ | ||
| 71 | ...snapshot, | ||
| 72 | generatedAt: Date.now(), | ||
| 73 | organizations: [...snapshot.organizations, organization], | ||
| 74 | }); | ||
| 75 | |||
| 76 | const appendOrganizationMembership = ( | ||
| 77 | snapshot: LocalStateSnapshot, | ||
| 78 | membership: OrganizationMembership, | ||
| 79 | ): LocalStateSnapshot => ({ | ||
| 80 | ...snapshot, | ||
| 81 | generatedAt: Date.now(), | ||
| 82 | organizationMemberships: [...snapshot.organizationMemberships, membership], | ||
| 83 | }); | ||
| 84 | |||
| 85 | export const createPmOrganizationsService = ( | ||
| 86 | localStateStore: LocalStateStore, | ||
| 87 | ): ControlPlaneOrganizationsServiceShape => | ||
| 88 | makeControlPlaneOrganizationsService({ | ||
| 89 | listOrganizations: () => | ||
| 90 | Effect.gen(function* () { | ||
| 91 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 92 | Effect.mapError((error) => | ||
| 93 | toSourceStoreErrorFromLocalState("organizations.list", error), | ||
| 94 | ), | ||
| 95 | ); | ||
| 96 | |||
| 97 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 98 | if (snapshot === null) { | ||
| 99 | return []; | ||
| 100 | } | ||
| 101 | |||
| 102 | return sortOrganizations(snapshot.organizations); | ||
| 103 | }), | ||
| 104 | |||
| 105 | upsertOrganization: (input) => | ||
| 106 | Effect.gen(function* () { | ||
| 107 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 108 | Effect.mapError((error) => | ||
| 109 | toSourceStoreErrorFromLocalState("organizations.upsert", error), | ||
| 110 | ), | ||
| 111 | ); | ||
| 112 | |||
| 113 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 114 | if (snapshot === null) { | ||
| 115 | return yield* toSourceStoreError( | ||
| 116 | "organizations.upsert", | ||
| 117 | "Organization snapshot not found", | ||
| 118 | null, | ||
| 119 | ); | ||
| 120 | } | ||
| 121 | |||
| 122 | const now = Date.now(); | ||
| 123 | const existingIndex = input.payload.id | ||
| 124 | ? snapshot.organizations.findIndex((organization) => organization.id === input.payload.id) | ||
| 125 | : snapshot.organizations.findIndex( | ||
| 126 | (organization) => organization.slug === input.payload.slug, | ||
| 127 | ); | ||
| 128 | const existing = existingIndex >= 0 ? snapshot.organizations[existingIndex] : null; | ||
| 129 | |||
| 130 | const nextOrganization: Organization = { | ||
| 131 | id: | ||
| 132 | existing?.id | ||
| 133 | ?? (input.payload.id ?? (`org_${crypto.randomUUID()}` as Organization["id"])), | ||
| 134 | slug: input.payload.slug, | ||
| 135 | name: input.payload.name, | ||
| 136 | status: input.payload.status ?? existing?.status ?? "active", | ||
| 137 | createdByAccountId: | ||
| 138 | existing?.createdByAccountId | ||
| 139 | ?? input.payload.createdByAccountId | ||
| 140 | ?? null, | ||
| 141 | createdAt: existing?.createdAt ?? now, | ||
| 142 | updatedAt: now, | ||
| 143 | }; | ||
| 144 | |||
| 145 | let nextSnapshot = existingIndex >= 0 | ||
| 146 | ? replaceOrganizationAt(snapshot, existingIndex, nextOrganization) | ||
| 147 | : appendOrganization(snapshot, nextOrganization); | ||
| 148 | |||
| 149 | if (existing === null && nextOrganization.createdByAccountId !== null) { | ||
| 150 | const existingMembership = nextSnapshot.organizationMemberships.find( | ||
| 151 | (membership) => | ||
| 152 | membership.organizationId === nextOrganization.id | ||
| 153 | && membership.accountId === nextOrganization.createdByAccountId, | ||
| 154 | ); | ||
| 155 | |||
| 156 | if (!existingMembership) { | ||
| 157 | nextSnapshot = appendOrganizationMembership(nextSnapshot, { | ||
| 158 | id: `org_member_${crypto.randomUUID()}` as OrganizationMembership["id"], | ||
| 159 | organizationId: nextOrganization.id, | ||
| 160 | accountId: nextOrganization.createdByAccountId, | ||
| 161 | role: "owner", | ||
| 162 | status: "active", | ||
| 163 | billable: false, | ||
| 164 | invitedByAccountId: null, | ||
| 165 | joinedAt: now, | ||
| 166 | createdAt: now, | ||
| 167 | updatedAt: now, | ||
| 168 | }); | ||
| 169 | } | ||
| 170 | } | ||
| 171 | |||
| 172 | yield* localStateStore.writeSnapshot(nextSnapshot).pipe( | ||
| 173 | Effect.mapError((error) => | ||
| 174 | toSourceStoreErrorFromLocalState("organizations.upsert_write", error), | ||
| 175 | ), | ||
| 176 | ); | ||
| 177 | |||
| 178 | return nextOrganization; | ||
| 179 | }), | ||
| 180 | }); | ||
| @@ -0,0 +1,134 @@ | |||
| 1 | import { describe, expect, it } from "@effect/vitest"; | ||
| 2 | import type { | ||
| 3 | LocalStateSnapshot, | ||
| 4 | LocalStateStore, | ||
| 5 | } from "@executor-v2/persistence-local"; | ||
| 6 | import * as Effect from "effect/Effect"; | ||
| 7 | import * as Option from "effect/Option"; | ||
| 8 | |||
| 9 | import { | ||
| 10 | createPmApprovalsService, | ||
| 11 | createPmPersistentToolApprovalPolicy, | ||
| 12 | } from "./approvals-service"; | ||
| 13 | |||
| 14 | const createTestSnapshot = (): LocalStateSnapshot => | ||
| 15 | ({ | ||
| 16 | schemaVersion: 1, | ||
| 17 | generatedAt: Date.now(), | ||
| 18 | profile: { | ||
| 19 | id: "profile_local", | ||
| 20 | defaultWorkspaceId: "ws_local", | ||
| 21 | displayName: "Local", | ||
| 22 | runtimeMode: "local", | ||
| 23 | createdAt: Date.now(), | ||
| 24 | updatedAt: Date.now(), | ||
| 25 | }, | ||
| 26 | organizations: [], | ||
| 27 | organizationMemberships: [], | ||
| 28 | workspaces: [], | ||
| 29 | sources: [], | ||
| 30 | toolArtifacts: [], | ||
| 31 | credentialBindings: [], | ||
| 32 | oauthTokens: [], | ||
| 33 | policies: [], | ||
| 34 | approvals: [], | ||
| 35 | taskRuns: [], | ||
| 36 | storageInstances: [], | ||
| 37 | syncStates: [], | ||
| 38 | }) as unknown as LocalStateSnapshot; | ||
| 39 | |||
| 40 | describe("PM persistent approval policy", () => { | ||
| 41 | it.effect("creates pending approval records and reuses resolved decisions", () => | ||
| 42 | Effect.gen(function* () { | ||
| 43 | let snapshot: LocalStateSnapshot = createTestSnapshot(); | ||
| 44 | |||
| 45 | const localStateStore: LocalStateStore = { | ||
| 46 | getSnapshot: () => Effect.succeed(Option.some(snapshot)), | ||
| 47 | writeSnapshot: (nextSnapshot) => | ||
| 48 | Effect.sync(() => { | ||
| 49 | snapshot = nextSnapshot; | ||
| 50 | }), | ||
| 51 | readEvents: () => Effect.succeed([]), | ||
| 52 | appendEvents: () => Effect.void, | ||
| 53 | }; | ||
| 54 | |||
| 55 | const policy = createPmPersistentToolApprovalPolicy(localStateStore, { | ||
| 56 | requireApprovals: true, | ||
| 57 | retryAfterMs: 250, | ||
| 58 | }); | ||
| 59 | |||
| 60 | const first = yield* Effect.promise(() => | ||
| 61 | Promise.resolve( | ||
| 62 | policy.evaluate({ | ||
| 63 | runId: "run_approval_1", | ||
| 64 | callId: "call_approval_1", | ||
| 65 | toolPath: "github.repos.delete", | ||
| 66 | input: { | ||
| 67 | owner: "octocat", | ||
| 68 | repo: "hello-world", | ||
| 69 | }, | ||
| 70 | workspaceId: "ws_local", | ||
| 71 | source: "github", | ||
| 72 | defaultMode: "auto", | ||
| 73 | }), | ||
| 74 | ), | ||
| 75 | ); | ||
| 76 | |||
| 77 | expect(first.kind).toBe("pending"); | ||
| 78 | if (first.kind === "pending") { | ||
| 79 | expect(first.retryAfterMs).toBe(250); | ||
| 80 | } | ||
| 81 | expect(snapshot.approvals).toHaveLength(1); | ||
| 82 | expect(snapshot.approvals[0]?.status).toBe("pending"); | ||
| 83 | expect(snapshot.approvals[0]?.callId).toBe("call_approval_1"); | ||
| 84 | |||
| 85 | const second = yield* Effect.promise(() => | ||
| 86 | Promise.resolve( | ||
| 87 | policy.evaluate({ | ||
| 88 | runId: "run_approval_1", | ||
| 89 | callId: "call_approval_1", | ||
| 90 | toolPath: "github.repos.delete", | ||
| 91 | workspaceId: "ws_local", | ||
| 92 | source: "github", | ||
| 93 | defaultMode: "auto", | ||
| 94 | }), | ||
| 95 | ), | ||
| 96 | ); | ||
| 97 | |||
| 98 | expect(second).toEqual(first); | ||
| 99 | expect(snapshot.approvals).toHaveLength(1); | ||
| 100 | |||
| 101 | const approvalsService = createPmApprovalsService(localStateStore); | ||
| 102 | const createdApproval = snapshot.approvals[0]; | ||
| 103 | if (!createdApproval) { | ||
| 104 | throw new Error("expected pending approval record"); | ||
| 105 | } | ||
| 106 | |||
| 107 | yield* approvalsService.resolveApproval({ | ||
| 108 | workspaceId: "ws_local" as any, | ||
| 109 | approvalId: createdApproval.id, | ||
| 110 | payload: { | ||
| 111 | status: "approved", | ||
| 112 | reason: "approved by test", | ||
| 113 | }, | ||
| 114 | }); | ||
| 115 | |||
| 116 | const finalDecision = yield* Effect.promise(() => | ||
| 117 | Promise.resolve( | ||
| 118 | policy.evaluate({ | ||
| 119 | runId: "run_approval_1", | ||
| 120 | callId: "call_approval_1", | ||
| 121 | toolPath: "github.repos.delete", | ||
| 122 | workspaceId: "ws_local", | ||
| 123 | source: "github", | ||
| 124 | defaultMode: "auto", | ||
| 125 | }), | ||
| 126 | ), | ||
| 127 | ); | ||
| 128 | |||
| 129 | expect(finalDecision).toEqual({ | ||
| 130 | kind: "approved", | ||
| 131 | }); | ||
| 132 | }), | ||
| 133 | ); | ||
| 134 | }); | ||
| @@ -0,0 +1,208 @@ | |||
| 1 | import { SourceStoreError } from "@executor-v2/persistence-ports"; | ||
| 2 | import { | ||
| 3 | type LocalStateSnapshot, | ||
| 4 | type LocalStateStore, | ||
| 5 | type LocalStateStoreError, | ||
| 6 | } from "@executor-v2/persistence-local"; | ||
| 7 | import { | ||
| 8 | makeControlPlanePoliciesService, | ||
| 9 | type ControlPlanePoliciesServiceShape, | ||
| 10 | } from "@executor-v2/management-api"; | ||
| 11 | import { type Policy } from "@executor-v2/schema"; | ||
| 12 | import * as Effect from "effect/Effect"; | ||
| 13 | import * as Option from "effect/Option"; | ||
| 14 | |||
| 15 | const toSourceStoreError = ( | ||
| 16 | operation: string, | ||
| 17 | message: string, | ||
| 18 | details: string | null, | ||
| 19 | ): SourceStoreError => | ||
| 20 | new SourceStoreError({ | ||
| 21 | operation, | ||
| 22 | backend: "local-file", | ||
| 23 | location: "snapshot.json", | ||
| 24 | message, | ||
| 25 | reason: null, | ||
| 26 | details, | ||
| 27 | }); | ||
| 28 | |||
| 29 | const toSourceStoreErrorFromLocalState = ( | ||
| 30 | operation: string, | ||
| 31 | error: LocalStateStoreError, | ||
| 32 | ): SourceStoreError => | ||
| 33 | toSourceStoreError(operation, error.message, error.details ?? error.reason ?? null); | ||
| 34 | |||
| 35 | const sortPolicies = (policies: ReadonlyArray<Policy>): Array<Policy> => | ||
| 36 | [...policies].sort((left, right) => { | ||
| 37 | const leftPattern = left.toolPathPattern.toLowerCase(); | ||
| 38 | const rightPattern = right.toolPathPattern.toLowerCase(); | ||
| 39 | if (leftPattern === rightPattern) { | ||
| 40 | return right.updatedAt - left.updatedAt; | ||
| 41 | } | ||
| 42 | |||
| 43 | return leftPattern.localeCompare(rightPattern); | ||
| 44 | }); | ||
| 45 | |||
| 46 | const replacePolicyAt = ( | ||
| 47 | snapshot: LocalStateSnapshot, | ||
| 48 | index: number, | ||
| 49 | policy: Policy, | ||
| 50 | ): LocalStateSnapshot => { | ||
| 51 | const next = [...snapshot.policies]; | ||
| 52 | next[index] = policy; | ||
| 53 | |||
| 54 | return { | ||
| 55 | ...snapshot, | ||
| 56 | generatedAt: Date.now(), | ||
| 57 | policies: next, | ||
| 58 | }; | ||
| 59 | }; | ||
| 60 | |||
| 61 | const appendPolicy = ( | ||
| 62 | snapshot: LocalStateSnapshot, | ||
| 63 | policy: Policy, | ||
| 64 | ): LocalStateSnapshot => ({ | ||
| 65 | ...snapshot, | ||
| 66 | generatedAt: Date.now(), | ||
| 67 | policies: [...snapshot.policies, policy], | ||
| 68 | }); | ||
| 69 | |||
| 70 | const removePolicyForWorkspace = ( | ||
| 71 | snapshot: LocalStateSnapshot, | ||
| 72 | workspaceId: Policy["workspaceId"], | ||
| 73 | policyId: string, | ||
| 74 | ): { snapshot: LocalStateSnapshot; removed: boolean } => { | ||
| 75 | const removeIndex = snapshot.policies.findIndex( | ||
| 76 | (policy) => policy.workspaceId === workspaceId && policy.id === policyId, | ||
| 77 | ); | ||
| 78 | |||
| 79 | if (removeIndex < 0) { | ||
| 80 | return { | ||
| 81 | snapshot, | ||
| 82 | removed: false, | ||
| 83 | }; | ||
| 84 | } | ||
| 85 | |||
| 86 | const next = [...snapshot.policies]; | ||
| 87 | next.splice(removeIndex, 1); | ||
| 88 | |||
| 89 | return { | ||
| 90 | removed: true, | ||
| 91 | snapshot: { | ||
| 92 | ...snapshot, | ||
| 93 | generatedAt: Date.now(), | ||
| 94 | policies: next, | ||
| 95 | }, | ||
| 96 | }; | ||
| 97 | }; | ||
| 98 | |||
| 99 | export const createPmPoliciesService = ( | ||
| 100 | localStateStore: LocalStateStore, | ||
| 101 | ): ControlPlanePoliciesServiceShape => | ||
| 102 | makeControlPlanePoliciesService({ | ||
| 103 | listPolicies: (workspaceId) => | ||
| 104 | Effect.gen(function* () { | ||
| 105 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 106 | Effect.mapError((error) => | ||
| 107 | toSourceStoreErrorFromLocalState("policies.list", error), | ||
| 108 | ), | ||
| 109 | ); | ||
| 110 | |||
| 111 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 112 | if (snapshot === null) { | ||
| 113 | return []; | ||
| 114 | } | ||
| 115 | |||
| 116 | return sortPolicies( | ||
| 117 | snapshot.policies.filter((policy) => policy.workspaceId === workspaceId), | ||
| 118 | ); | ||
| 119 | }), | ||
| 120 | |||
| 121 | upsertPolicy: (input) => | ||
| 122 | Effect.gen(function* () { | ||
| 123 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 124 | Effect.mapError((error) => | ||
| 125 | toSourceStoreErrorFromLocalState("policies.upsert", error), | ||
| 126 | ), | ||
| 127 | ); | ||
| 128 | |||
| 129 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 130 | if (snapshot === null) { | ||
| 131 | return yield* toSourceStoreError( | ||
| 132 | "policies.upsert", | ||
| 133 | "Policy snapshot not found", | ||
| 134 | `workspace=${input.workspaceId}`, | ||
| 135 | ); | ||
| 136 | } | ||
| 137 | |||
| 138 | const now = Date.now(); | ||
| 139 | const requestedId = input.payload.id; | ||
| 140 | |||
| 141 | const existingIndex = requestedId | ||
| 142 | ? snapshot.policies.findIndex( | ||
| 143 | (policy) => | ||
| 144 | policy.workspaceId === input.workspaceId && policy.id === requestedId, | ||
| 145 | ) | ||
| 146 | : -1; | ||
| 147 | |||
| 148 | const existing = existingIndex >= 0 ? snapshot.policies[existingIndex] : null; | ||
| 149 | |||
| 150 | const nextPolicy: Policy = { | ||
| 151 | id: existing?.id ?? (requestedId ?? (`pol_${crypto.randomUUID()}` as Policy["id"])), | ||
| 152 | workspaceId: input.workspaceId, | ||
| 153 | toolPathPattern: input.payload.toolPathPattern, | ||
| 154 | decision: input.payload.decision, | ||
| 155 | createdAt: existing?.createdAt ?? now, | ||
| 156 | updatedAt: now, | ||
| 157 | }; | ||
| 158 | |||
| 159 | const nextSnapshot = existingIndex >= 0 | ||
| 160 | ? replacePolicyAt(snapshot, existingIndex, nextPolicy) | ||
| 161 | : appendPolicy(snapshot, nextPolicy); | ||
| 162 | |||
| 163 | yield* localStateStore.writeSnapshot(nextSnapshot).pipe( | ||
| 164 | Effect.mapError((error) => | ||
| 165 | toSourceStoreErrorFromLocalState("policies.upsert_write", error), | ||
| 166 | ), | ||
| 167 | ); | ||
| 168 | |||
| 169 | return nextPolicy; | ||
| 170 | }), | ||
| 171 | |||
| 172 | removePolicy: (input) => | ||
| 173 | Effect.gen(function* () { | ||
| 174 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 175 | Effect.mapError((error) => | ||
| 176 | toSourceStoreErrorFromLocalState("policies.remove", error), | ||
| 177 | ), | ||
| 178 | ); | ||
| 179 | |||
| 180 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 181 | if (snapshot === null) { | ||
| 182 | return { | ||
| 183 | removed: false, | ||
| 184 | }; | ||
| 185 | } | ||
| 186 | |||
| 187 | const next = removePolicyForWorkspace( | ||
| 188 | snapshot, | ||
| 189 | input.workspaceId, | ||
| 190 | input.policyId, | ||
| 191 | ); | ||
| 192 | if (!next.removed) { | ||
| 193 | return { | ||
| 194 | removed: false, | ||
| 195 | }; | ||
| 196 | } | ||
| 197 | |||
| 198 | yield* localStateStore.writeSnapshot(next.snapshot).pipe( | ||
| 199 | Effect.mapError((error) => | ||
| 200 | toSourceStoreErrorFromLocalState("policies.remove_write", error), | ||
| 201 | ), | ||
| 202 | ); | ||
| 203 | |||
| 204 | return { | ||
| 205 | removed: true, | ||
| 206 | }; | ||
| 207 | }), | ||
| 208 | }); | ||
| @@ -0,0 +1,65 @@ | |||
| 1 | import { | ||
| 2 | createRuntimeToolCallService, | ||
| 3 | RuntimeExecutionPortError, | ||
| 4 | type ExecuteRuntimeRun, | ||
| 5 | type ExecuteRuntimeRunInput, | ||
| 6 | type RuntimeAdapterRegistry, | ||
| 7 | type RuntimeExecuteError, | ||
| 8 | type ToolRegistry, | ||
| 9 | } from "@executor-v2/engine"; | ||
| 10 | import * as Effect from "effect/Effect"; | ||
| 11 | |||
| 12 | export type PmRuntimeExecutionPortOptions = { | ||
| 13 | defaultRuntimeKind: string; | ||
| 14 | runtimeAdapters: RuntimeAdapterRegistry; | ||
| 15 | toolRegistry: ToolRegistry; | ||
| 16 | }; | ||
| 17 | |||
| 18 | export const createPmExecuteRuntimeRun = ( | ||
| 19 | options: PmRuntimeExecutionPortOptions, | ||
| 20 | ): ExecuteRuntimeRun => { | ||
| 21 | const runtimeToolCallService = createRuntimeToolCallService(options.toolRegistry); | ||
| 22 | |||
| 23 | return (input: ExecuteRuntimeRunInput) => | ||
| 24 | Effect.gen(function* () { | ||
| 25 | const runtimeAdapter = yield* options.runtimeAdapters | ||
| 26 | .get(options.defaultRuntimeKind) | ||
| 27 | .pipe( | ||
| 28 | Effect.mapError( | ||
| 29 | (error) => | ||
| 30 | new RuntimeExecutionPortError({ | ||
| 31 | operation: "resolve_runtime_adapter", | ||
| 32 | message: error.message, | ||
| 33 | details: null, | ||
| 34 | }), | ||
| 35 | ), | ||
| 36 | ); | ||
| 37 | |||
| 38 | const isAvailable = yield* runtimeAdapter.isAvailable(); | ||
| 39 | if (!isAvailable) { | ||
| 40 | return yield* new RuntimeExecutionPortError({ | ||
| 41 | operation: "runtime_available", | ||
| 42 | message: `Runtime '${options.defaultRuntimeKind}' is not available in this pm process.`, | ||
| 43 | details: null, | ||
| 44 | }); | ||
| 45 | } | ||
| 46 | |||
| 47 | return yield* runtimeAdapter | ||
| 48 | .execute({ | ||
| 49 | runId: input.runId, | ||
| 50 | code: input.code, | ||
| 51 | timeoutMs: input.timeoutMs, | ||
| 52 | toolCallService: runtimeToolCallService, | ||
| 53 | }) | ||
| 54 | .pipe( | ||
| 55 | Effect.mapError( | ||
| 56 | (error: RuntimeExecuteError) => | ||
| 57 | new RuntimeExecutionPortError({ | ||
| 58 | operation: "runtime_execute", | ||
| 59 | message: error.message, | ||
| 60 | details: error.details, | ||
| 61 | }), | ||
| 62 | ), | ||
| 63 | ); | ||
| 64 | }); | ||
| 65 | }; | ||
| @@ -0,0 +1,161 @@ | |||
| 1 | import { describe, expect, it } from "@effect/vitest"; | ||
| 2 | import type { | ||
| 3 | LocalStateSnapshot, | ||
| 4 | LocalStateStore, | ||
| 5 | } from "@executor-v2/persistence-local"; | ||
| 6 | import type { StorageInstance, WorkspaceId } from "@executor-v2/schema"; | ||
| 7 | import * as Effect from "effect/Effect"; | ||
| 8 | import * as Option from "effect/Option"; | ||
| 9 | import { mkdtemp, rm, writeFile } from "node:fs/promises"; | ||
| 10 | import { tmpdir } from "node:os"; | ||
| 11 | import * as path from "node:path"; | ||
| 12 | |||
| 13 | import { createPmStorageService } from "./storage-service"; | ||
| 14 | |||
| 15 | const createTestSnapshot = (): LocalStateSnapshot => | ||
| 16 | ({ | ||
| 17 | schemaVersion: 1, | ||
| 18 | generatedAt: Date.now(), | ||
| 19 | profile: { | ||
| 20 | id: "profile_local", | ||
| 21 | defaultWorkspaceId: "ws_local", | ||
| 22 | displayName: "Local", | ||
| 23 | runtimeMode: "local", | ||
| 24 | createdAt: Date.now(), | ||
| 25 | updatedAt: Date.now(), | ||
| 26 | }, | ||
| 27 | organizations: [], | ||
| 28 | organizationMemberships: [], | ||
| 29 | workspaces: [ | ||
| 30 | { | ||
| 31 | id: "ws_local", | ||
| 32 | organizationId: "org_local", | ||
| 33 | name: "Local Workspace", | ||
| 34 | createdByAccountId: null, | ||
| 35 | createdAt: Date.now(), | ||
| 36 | updatedAt: Date.now(), | ||
| 37 | }, | ||
| 38 | ], | ||
| 39 | sources: [], | ||
| 40 | toolArtifacts: [], | ||
| 41 | credentialBindings: [], | ||
| 42 | oauthTokens: [], | ||
| 43 | policies: [], | ||
| 44 | approvals: [], | ||
| 45 | taskRuns: [], | ||
| 46 | storageInstances: [], | ||
| 47 | syncStates: [], | ||
| 48 | }) as unknown as LocalStateSnapshot; | ||
| 49 | |||
| 50 | describe("PM storage service", () => { | ||
| 51 | it.effect("opens, inspects, queries, and removes storage instances", () => | ||
| 52 | Effect.gen(function* () { | ||
| 53 | const stateRootDir = yield* Effect.promise(() => | ||
| 54 | mkdtemp(path.join(tmpdir(), "executor-v2-pm-storage-")), | ||
| 55 | ); | ||
| 56 | |||
| 57 | let snapshot: LocalStateSnapshot = createTestSnapshot(); | ||
| 58 | |||
| 59 | const localStateStore: LocalStateStore = { | ||
| 60 | getSnapshot: () => Effect.succeed(Option.some(snapshot)), | ||
| 61 | writeSnapshot: (nextSnapshot) => | ||
| 62 | Effect.sync(() => { | ||
| 63 | snapshot = nextSnapshot; | ||
| 64 | }), | ||
| 65 | readEvents: () => Effect.succeed([]), | ||
| 66 | appendEvents: () => Effect.void, | ||
| 67 | }; | ||
| 68 | |||
| 69 | const service = createPmStorageService(localStateStore, { | ||
| 70 | stateRootDir, | ||
| 71 | }); | ||
| 72 | |||
| 73 | const workspaceId = "ws_local" as WorkspaceId; | ||
| 74 | |||
| 75 | const storageInstance = yield* service.openStorageInstance({ | ||
| 76 | workspaceId, | ||
| 77 | payload: { | ||
| 78 | scopeType: "workspace", | ||
| 79 | durability: "ephemeral", | ||
| 80 | ttlHours: 24, | ||
| 81 | }, | ||
| 82 | }); | ||
| 83 | |||
| 84 | expect(storageInstance.status).toBe("active"); | ||
| 85 | |||
| 86 | const listed = yield* service.listStorageInstances(workspaceId); | ||
| 87 | expect(listed).toHaveLength(1); | ||
| 88 | |||
| 89 | const directoryBeforeWrite = yield* service.listStorageDirectory({ | ||
| 90 | workspaceId, | ||
| 91 | storageInstanceId: storageInstance.id, | ||
| 92 | payload: { | ||
| 93 | path: "/", | ||
| 94 | }, | ||
| 95 | }); | ||
| 96 | expect(directoryBeforeWrite.entries).toHaveLength(0); | ||
| 97 | |||
| 98 | const storageFsPath = path.resolve( | ||
| 99 | stateRootDir, | ||
| 100 | "storage", | ||
| 101 | storageInstance.id, | ||
| 102 | "fs", | ||
| 103 | "hello.txt", | ||
| 104 | ); | ||
| 105 | |||
| 106 | yield* Effect.promise(() => | ||
| 107 | writeFile(storageFsPath, "hello from storage", "utf8"), | ||
| 108 | ); | ||
| 109 | |||
| 110 | const directoryAfterWrite = yield* service.listStorageDirectory({ | ||
| 111 | workspaceId, | ||
| 112 | storageInstanceId: storageInstance.id, | ||
| 113 | payload: { | ||
| 114 | path: "/", | ||
| 115 | }, | ||
| 116 | }); | ||
| 117 | expect(directoryAfterWrite.entries.some((entry) => entry.name === "hello.txt")).toBe( | ||
| 118 | true, | ||
| 119 | ); | ||
| 120 | |||
| 121 | const filePreview = yield* service.readStorageFile({ | ||
| 122 | workspaceId, | ||
| 123 | storageInstanceId: storageInstance.id, | ||
| 124 | payload: { | ||
| 125 | path: "/hello.txt", | ||
| 126 | encoding: "utf8", | ||
| 127 | }, | ||
| 128 | }); | ||
| 129 | expect(filePreview.content).toBe("hello from storage"); | ||
| 130 | |||
| 131 | const kvResult = yield* service.listStorageKv({ | ||
| 132 | workspaceId, | ||
| 133 | storageInstanceId: storageInstance.id, | ||
| 134 | payload: { | ||
| 135 | prefix: "", | ||
| 136 | limit: 20, | ||
| 137 | }, | ||
| 138 | }); | ||
| 139 | expect(kvResult.items).toHaveLength(0); | ||
| 140 | |||
| 141 | const closedStorage = yield* service.closeStorageInstance({ | ||
| 142 | workspaceId, | ||
| 143 | storageInstanceId: storageInstance.id, | ||
| 144 | }); | ||
| 145 | expect(closedStorage.status).toBe("closed"); | ||
| 146 | |||
| 147 | const removed = yield* service.removeStorageInstance({ | ||
| 148 | workspaceId, | ||
| 149 | storageInstanceId: storageInstance.id, | ||
| 150 | }); | ||
| 151 | expect(removed.removed).toBe(true); | ||
| 152 | |||
| 153 | const listedAfterRemove = yield* service.listStorageInstances(workspaceId); | ||
| 154 | expect(listedAfterRemove).toHaveLength(0); | ||
| 155 | |||
| 156 | yield* Effect.promise(() => | ||
| 157 | rm(stateRootDir, { recursive: true, force: true }), | ||
| 158 | ); | ||
| 159 | }), | ||
| 160 | ); | ||
| 161 | }); | ||
| @@ -0,0 +1,939 @@ | |||
| 1 | import { | ||
| 2 | makeControlPlaneStorageService, | ||
| 3 | type ControlPlaneStorageServiceShape, | ||
| 4 | } from "@executor-v2/management-api"; | ||
| 5 | import { SourceStoreError } from "@executor-v2/persistence-ports"; | ||
| 6 | import { | ||
| 7 | type LocalStateSnapshot, | ||
| 8 | type LocalStateStore, | ||
| 9 | type LocalStateStoreError, | ||
| 10 | } from "@executor-v2/persistence-local"; | ||
| 11 | import { | ||
| 12 | type OrganizationId, | ||
| 13 | type StorageInstance, | ||
| 14 | type WorkspaceId, | ||
| 15 | } from "@executor-v2/schema"; | ||
| 16 | import * as Effect from "effect/Effect"; | ||
| 17 | import * as Option from "effect/Option"; | ||
| 18 | import { | ||
| 19 | mkdir, | ||
| 20 | readdir, | ||
| 21 | readFile, | ||
| 22 | rm, | ||
| 23 | stat, | ||
| 24 | writeFile, | ||
| 25 | } from "node:fs/promises"; | ||
| 26 | import * as path from "node:path"; | ||
| 27 | |||
| 28 | const DEFAULT_EPHEMERAL_TTL_HOURS = 24; | ||
| 29 | const DEFAULT_KV_LIMIT = 100; | ||
| 30 | const MAX_KV_LIMIT = 1000; | ||
| 31 | const DEFAULT_SQL_MAX_ROWS = 200; | ||
| 32 | const MAX_SQL_MAX_ROWS = 5000; | ||
| 33 | const MILLIS_PER_HOUR = 3_600_000; | ||
| 34 | const STORAGE_ROOT_DIRECTORY = "storage"; | ||
| 35 | const STORAGE_FS_DIRECTORY = "fs"; | ||
| 36 | const STORAGE_KV_FILE = "kv-store.json"; | ||
| 37 | const STORAGE_SQLITE_FILE = "storage.sqlite"; | ||
| 38 | |||
| 39 | type SqliteDatabaseInstance = { | ||
| 40 | exec: (sql: string) => void; | ||
| 41 | query: (sql: string) => { | ||
| 42 | all: () => Array<Record<string, unknown>>; | ||
| 43 | }; | ||
| 44 | run: (sql: string) => unknown; | ||
| 45 | close: () => void; | ||
| 46 | }; | ||
| 47 | |||
| 48 | type SqliteDatabaseConstructor = new ( | ||
| 49 | filename: string, | ||
| 50 | options?: { | ||
| 51 | create?: boolean; | ||
| 52 | }, | ||
| 53 | ) => SqliteDatabaseInstance; | ||
| 54 | |||
| 55 | const loadSqliteDatabase = async (): Promise<SqliteDatabaseConstructor | null> => { | ||
| 56 | try { | ||
| 57 | const sqliteModule = await import("bun:sqlite"); | ||
| 58 | return sqliteModule.Database as SqliteDatabaseConstructor; | ||
| 59 | } catch { | ||
| 60 | return null; | ||
| 61 | } | ||
| 62 | }; | ||
| 63 | |||
| 64 | const toSourceStoreError = ( | ||
| 65 | operation: string, | ||
| 66 | message: string, | ||
| 67 | details: string | null, | ||
| 68 | ): SourceStoreError => | ||
| 69 | new SourceStoreError({ | ||
| 70 | operation, | ||
| 71 | backend: "local-file", | ||
| 72 | location: "snapshot.json", | ||
| 73 | message, | ||
| 74 | reason: null, | ||
| 75 | details, | ||
| 76 | }); | ||
| 77 | |||
| 78 | const toSourceStoreErrorFromLocalState = ( | ||
| 79 | operation: string, | ||
| 80 | error: LocalStateStoreError, | ||
| 81 | ): SourceStoreError => | ||
| 82 | toSourceStoreError(operation, error.message, error.details ?? error.reason ?? null); | ||
| 83 | |||
| 84 | const toSourceStoreErrorFromCause = ( | ||
| 85 | operation: string, | ||
| 86 | cause: unknown, | ||
| 87 | details?: string, | ||
| 88 | ): SourceStoreError => | ||
| 89 | toSourceStoreError( | ||
| 90 | operation, | ||
| 91 | cause instanceof Error ? cause.message : String(cause), | ||
| 92 | details ?? null, | ||
| 93 | ); | ||
| 94 | |||
| 95 | const resolveWorkspaceOrganizationId = ( | ||
| 96 | snapshot: LocalStateSnapshot, | ||
| 97 | workspaceId: WorkspaceId, | ||
| 98 | ): OrganizationId => { | ||
| 99 | const workspace = snapshot.workspaces.find((item) => item.id === workspaceId); | ||
| 100 | |||
| 101 | if (!workspace) { | ||
| 102 | throw new Error(`Workspace not found: ${workspaceId}`); | ||
| 103 | } | ||
| 104 | |||
| 105 | return workspace.organizationId; | ||
| 106 | }; | ||
| 107 | |||
| 108 | const canAccessStorageInstance = ( | ||
| 109 | instance: StorageInstance, | ||
| 110 | workspaceId: WorkspaceId, | ||
| 111 | organizationId: OrganizationId, | ||
| 112 | ): boolean => | ||
| 113 | instance.workspaceId === workspaceId | ||
| 114 | || (instance.workspaceId === null && instance.organizationId === organizationId); | ||
| 115 | |||
| 116 | const sortStorageInstances = ( | ||
| 117 | storageInstances: ReadonlyArray<StorageInstance>, | ||
| 118 | ): Array<StorageInstance> => | ||
| 119 | [...storageInstances].sort((left, right) => { | ||
| 120 | if (left.updatedAt !== right.updatedAt) { | ||
| 121 | return right.updatedAt - left.updatedAt; | ||
| 122 | } | ||
| 123 | |||
| 124 | return left.id.localeCompare(right.id); | ||
| 125 | }); | ||
| 126 | |||
| 127 | const replaceStorageInstanceAt = ( | ||
| 128 | snapshot: LocalStateSnapshot, | ||
| 129 | index: number, | ||
| 130 | storageInstance: StorageInstance, | ||
| 131 | ): LocalStateSnapshot => { | ||
| 132 | const next = [...snapshot.storageInstances]; | ||
| 133 | next[index] = storageInstance; | ||
| 134 | |||
| 135 | return { | ||
| 136 | ...snapshot, | ||
| 137 | generatedAt: Date.now(), | ||
| 138 | storageInstances: next, | ||
| 139 | }; | ||
| 140 | }; | ||
| 141 | |||
| 142 | const appendStorageInstance = ( | ||
| 143 | snapshot: LocalStateSnapshot, | ||
| 144 | storageInstance: StorageInstance, | ||
| 145 | ): LocalStateSnapshot => ({ | ||
| 146 | ...snapshot, | ||
| 147 | generatedAt: Date.now(), | ||
| 148 | storageInstances: [...snapshot.storageInstances, storageInstance], | ||
| 149 | }); | ||
| 150 | |||
| 151 | const removeStorageInstanceById = ( | ||
| 152 | snapshot: LocalStateSnapshot, | ||
| 153 | input: { | ||
| 154 | workspaceId: WorkspaceId; | ||
| 155 | organizationId: OrganizationId; | ||
| 156 | storageInstanceId: StorageInstance["id"]; | ||
| 157 | }, | ||
| 158 | ): { snapshot: LocalStateSnapshot; removed: boolean } => { | ||
| 159 | let removed = false; | ||
| 160 | |||
| 161 | const next = snapshot.storageInstances.filter((instance) => { | ||
| 162 | const matches = | ||
| 163 | instance.id === input.storageInstanceId | ||
| 164 | && canAccessStorageInstance(instance, input.workspaceId, input.organizationId); | ||
| 165 | |||
| 166 | if (matches) { | ||
| 167 | removed = true; | ||
| 168 | return false; | ||
| 169 | } | ||
| 170 | |||
| 171 | return true; | ||
| 172 | }); | ||
| 173 | |||
| 174 | if (!removed) { | ||
| 175 | return { | ||
| 176 | snapshot, | ||
| 177 | removed: false, | ||
| 178 | }; | ||
| 179 | } | ||
| 180 | |||
| 181 | return { | ||
| 182 | removed: true, | ||
| 183 | snapshot: { | ||
| 184 | ...snapshot, | ||
| 185 | generatedAt: Date.now(), | ||
| 186 | storageInstances: next, | ||
| 187 | }, | ||
| 188 | }; | ||
| 189 | }; | ||
| 190 | |||
| 191 | const storageInstanceRootPath = (stateRootDir: string, storageInstanceId: string): string => | ||
| 192 | path.resolve(stateRootDir, STORAGE_ROOT_DIRECTORY, storageInstanceId); | ||
| 193 | |||
| 194 | const storageInstanceFsRootPath = ( | ||
| 195 | stateRootDir: string, | ||
| 196 | storageInstanceId: string, | ||
| 197 | ): string => | ||
| 198 | path.resolve( | ||
| 199 | storageInstanceRootPath(stateRootDir, storageInstanceId), | ||
| 200 | STORAGE_FS_DIRECTORY, | ||
| 201 | ); | ||
| 202 | |||
| 203 | const storageInstanceKvPath = (stateRootDir: string, storageInstanceId: string): string => | ||
| 204 | path.resolve( | ||
| 205 | storageInstanceRootPath(stateRootDir, storageInstanceId), | ||
| 206 | STORAGE_KV_FILE, | ||
| 207 | ); | ||
| 208 | |||
| 209 | const storageInstanceSqlitePath = ( | ||
| 210 | stateRootDir: string, | ||
| 211 | storageInstanceId: string, | ||
| 212 | ): string => | ||
| 213 | path.resolve( | ||
| 214 | storageInstanceRootPath(stateRootDir, storageInstanceId), | ||
| 215 | STORAGE_SQLITE_FILE, | ||
| 216 | ); | ||
| 217 | |||
| 218 | const initializeStorageInstanceFiles = async ( | ||
| 219 | stateRootDir: string, | ||
| 220 | storageInstanceId: string, | ||
| 221 | ): Promise<void> => { | ||
| 222 | const rootPath = storageInstanceRootPath(stateRootDir, storageInstanceId); | ||
| 223 | const fsRootPath = storageInstanceFsRootPath(stateRootDir, storageInstanceId); | ||
| 224 | const kvPath = storageInstanceKvPath(stateRootDir, storageInstanceId); | ||
| 225 | const sqlitePath = storageInstanceSqlitePath(stateRootDir, storageInstanceId); | ||
| 226 | |||
| 227 | await mkdir(rootPath, { recursive: true }); | ||
| 228 | await mkdir(fsRootPath, { recursive: true }); | ||
| 229 | |||
| 230 | const kvJson = JSON.stringify({}, null, 2); | ||
| 231 | await writeFile(kvPath, kvJson, { encoding: "utf8" }); | ||
| 232 | |||
| 233 | const SqliteDatabase = await loadSqliteDatabase(); | ||
| 234 | if (SqliteDatabase === null) { | ||
| 235 | await writeFile(sqlitePath, "", { encoding: "utf8" }); | ||
| 236 | return; | ||
| 237 | } | ||
| 238 | |||
| 239 | const db = new SqliteDatabase(sqlitePath, { create: true }); | ||
| 240 | try { | ||
| 241 | db.exec( | ||
| 242 | "CREATE TABLE IF NOT EXISTS kv_store (key TEXT PRIMARY KEY, value TEXT NOT NULL);", | ||
| 243 | ); | ||
| 244 | } finally { | ||
| 245 | db.close(); | ||
| 246 | } | ||
| 247 | }; | ||
| 248 | |||
| 249 | const resolvePathWithinRoot = ( | ||
| 250 | rootPath: string, | ||
| 251 | requestedPath: string, | ||
| 252 | ): { | ||
| 253 | normalizedPath: string; | ||
| 254 | absolutePath: string; | ||
| 255 | } => { | ||
| 256 | const trimmed = requestedPath.trim(); | ||
| 257 | const normalizedPath = path.posix.normalize( | ||
| 258 | trimmed.length > 0 | ||
| 259 | ? (trimmed.startsWith("/") ? trimmed : `/${trimmed}`) | ||
| 260 | : "/", | ||
| 261 | ); | ||
| 262 | |||
| 263 | const relativePath = normalizedPath.replace(/^\/+/, ""); | ||
| 264 | const absolutePath = path.resolve(rootPath, relativePath); | ||
| 265 | |||
| 266 | if (absolutePath !== rootPath && !absolutePath.startsWith(`${rootPath}${path.sep}`)) { | ||
| 267 | throw new Error("Path escapes storage root"); | ||
| 268 | } | ||
| 269 | |||
| 270 | return { | ||
| 271 | normalizedPath, | ||
| 272 | absolutePath, | ||
| 273 | }; | ||
| 274 | }; | ||
| 275 | |||
| 276 | const toStorageEntryPath = (absolutePath: string, fsRootPath: string): string => { | ||
| 277 | const relativePath = path.relative(fsRootPath, absolutePath); | ||
| 278 | return `/${relativePath.split(path.sep).join("/")}`; | ||
| 279 | }; | ||
| 280 | |||
| 281 | const readKvStore = async ( | ||
| 282 | kvPath: string, | ||
| 283 | ): Promise<Record<string, unknown>> => { | ||
| 284 | const raw = await readFile(kvPath, "utf8"); | ||
| 285 | const parsed = JSON.parse(raw) as unknown; | ||
| 286 | |||
| 287 | if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) { | ||
| 288 | return parsed as Record<string, unknown>; | ||
| 289 | } | ||
| 290 | |||
| 291 | return {}; | ||
| 292 | }; | ||
| 293 | |||
| 294 | const findStorageInstance = ( | ||
| 295 | snapshot: LocalStateSnapshot, | ||
| 296 | input: { | ||
| 297 | workspaceId: WorkspaceId; | ||
| 298 | storageInstanceId: StorageInstance["id"]; | ||
| 299 | }, | ||
| 300 | ): { | ||
| 301 | storageInstance: StorageInstance; | ||
| 302 | storageInstanceIndex: number; | ||
| 303 | } | null => { | ||
| 304 | const organizationId = resolveWorkspaceOrganizationId(snapshot, input.workspaceId); | ||
| 305 | const storageInstanceIndex = snapshot.storageInstances.findIndex((instance) => | ||
| 306 | instance.id === input.storageInstanceId | ||
| 307 | && canAccessStorageInstance(instance, input.workspaceId, organizationId) | ||
| 308 | ); | ||
| 309 | |||
| 310 | if (storageInstanceIndex < 0) { | ||
| 311 | return null; | ||
| 312 | } | ||
| 313 | |||
| 314 | const storageInstance = snapshot.storageInstances[storageInstanceIndex]; | ||
| 315 | if (!storageInstance) { | ||
| 316 | return null; | ||
| 317 | } | ||
| 318 | |||
| 319 | return { | ||
| 320 | storageInstance, | ||
| 321 | storageInstanceIndex, | ||
| 322 | }; | ||
| 323 | }; | ||
| 324 | |||
| 325 | const touchStorageInstance = ( | ||
| 326 | snapshot: LocalStateSnapshot, | ||
| 327 | storageInstanceIndex: number, | ||
| 328 | ): { | ||
| 329 | snapshot: LocalStateSnapshot; | ||
| 330 | storageInstance: StorageInstance; | ||
| 331 | } => { | ||
| 332 | const existing = snapshot.storageInstances[storageInstanceIndex]; | ||
| 333 | const now = Date.now(); | ||
| 334 | |||
| 335 | const touchedStorageInstance: StorageInstance = { | ||
| 336 | ...existing, | ||
| 337 | updatedAt: now, | ||
| 338 | lastSeenAt: now, | ||
| 339 | }; | ||
| 340 | |||
| 341 | return { | ||
| 342 | storageInstance: touchedStorageInstance, | ||
| 343 | snapshot: replaceStorageInstanceAt(snapshot, storageInstanceIndex, touchedStorageInstance), | ||
| 344 | }; | ||
| 345 | }; | ||
| 346 | |||
| 347 | export const createPmStorageService = ( | ||
| 348 | localStateStore: LocalStateStore, | ||
| 349 | options: { | ||
| 350 | stateRootDir: string; | ||
| 351 | }, | ||
| 352 | ): ControlPlaneStorageServiceShape => | ||
| 353 | makeControlPlaneStorageService({ | ||
| 354 | listStorageInstances: (workspaceId) => | ||
| 355 | Effect.gen(function* () { | ||
| 356 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 357 | Effect.mapError((error) => | ||
| 358 | toSourceStoreErrorFromLocalState("storage.list", error), | ||
| 359 | ), | ||
| 360 | ); | ||
| 361 | |||
| 362 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 363 | if (snapshot === null) { | ||
| 364 | return []; | ||
| 365 | } | ||
| 366 | |||
| 367 | const organizationId = resolveWorkspaceOrganizationId(snapshot, workspaceId); | ||
| 368 | |||
| 369 | return sortStorageInstances( | ||
| 370 | snapshot.storageInstances.filter((instance) => | ||
| 371 | canAccessStorageInstance(instance, workspaceId, organizationId) | ||
| 372 | ), | ||
| 373 | ); | ||
| 374 | }), | ||
| 375 | |||
| 376 | openStorageInstance: (input) => | ||
| 377 | Effect.gen(function* () { | ||
| 378 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 379 | Effect.mapError((error) => | ||
| 380 | toSourceStoreErrorFromLocalState("storage.open", error), | ||
| 381 | ), | ||
| 382 | ); | ||
| 383 | |||
| 384 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 385 | if (snapshot === null) { | ||
| 386 | return yield* toSourceStoreError( | ||
| 387 | "storage.open", | ||
| 388 | "Storage snapshot not found", | ||
| 389 | `workspace=${input.workspaceId}`, | ||
| 390 | ); | ||
| 391 | } | ||
| 392 | |||
| 393 | if (input.payload.scopeType === "account" && input.payload.accountId === undefined) { | ||
| 394 | return yield* toSourceStoreError( | ||
| 395 | "storage.open", | ||
| 396 | "Account scope storage requires accountId", | ||
| 397 | `workspace=${input.workspaceId}`, | ||
| 398 | ); | ||
| 399 | } | ||
| 400 | |||
| 401 | const now = Date.now(); | ||
| 402 | const organizationId = resolveWorkspaceOrganizationId(snapshot, input.workspaceId); | ||
| 403 | const storageInstanceId = | ||
| 404 | `storage_${crypto.randomUUID()}` as StorageInstance["id"]; | ||
| 405 | const ttlHours = | ||
| 406 | input.payload.ttlHours !== undefined && Number.isFinite(input.payload.ttlHours) | ||
| 407 | ? Math.max(1, Math.floor(input.payload.ttlHours)) | ||
| 408 | : DEFAULT_EPHEMERAL_TTL_HOURS; | ||
| 409 | |||
| 410 | yield* Effect.tryPromise({ | ||
| 411 | try: () => initializeStorageInstanceFiles(options.stateRootDir, storageInstanceId), | ||
| 412 | catch: (cause) => | ||
| 413 | toSourceStoreErrorFromCause( | ||
| 414 | "storage.open_initialize", | ||
| 415 | cause, | ||
| 416 | `storageInstance=${storageInstanceId}`, | ||
| 417 | ), | ||
| 418 | }); | ||
| 419 | |||
| 420 | const nextStorageInstance: StorageInstance = { | ||
| 421 | id: storageInstanceId, | ||
| 422 | scopeType: input.payload.scopeType, | ||
| 423 | durability: input.payload.durability, | ||
| 424 | status: "active", | ||
| 425 | provider: input.payload.provider ?? "agentfs-local", | ||
| 426 | backendKey: `local:${storageInstanceId}`, | ||
| 427 | organizationId, | ||
| 428 | workspaceId: | ||
| 429 | input.payload.scopeType === "workspace" || input.payload.scopeType === "scratch" | ||
| 430 | ? input.workspaceId | ||
| 431 | : null, | ||
| 432 | accountId: | ||
| 433 | input.payload.scopeType === "account" | ||
| 434 | ? (input.payload.accountId ?? null) | ||
| 435 | : null, | ||
| 436 | createdByAccountId: input.payload.accountId ?? null, | ||
| 437 | purpose: | ||
| 438 | input.payload.purpose !== undefined && input.payload.purpose.trim().length > 0 | ||
| 439 | ? input.payload.purpose.trim() | ||
| 440 | : null, | ||
| 441 | sizeBytes: null, | ||
| 442 | fileCount: null, | ||
| 443 | createdAt: now, | ||
| 444 | updatedAt: now, | ||
| 445 | lastSeenAt: now, | ||
| 446 | closedAt: null, | ||
| 447 | expiresAt: | ||
| 448 | input.payload.durability === "ephemeral" | ||
| 449 | ? now + ttlHours * MILLIS_PER_HOUR | ||
| 450 | : null, | ||
| 451 | }; | ||
| 452 | |||
| 453 | const nextSnapshot = appendStorageInstance(snapshot, nextStorageInstance); | ||
| 454 | |||
| 455 | yield* localStateStore.writeSnapshot(nextSnapshot).pipe( | ||
| 456 | Effect.mapError((error) => | ||
| 457 | toSourceStoreErrorFromLocalState("storage.open_write", error), | ||
| 458 | ), | ||
| 459 | ); | ||
| 460 | |||
| 461 | return nextStorageInstance; | ||
| 462 | }), | ||
| 463 | |||
| 464 | closeStorageInstance: (input) => | ||
| 465 | Effect.gen(function* () { | ||
| 466 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 467 | Effect.mapError((error) => | ||
| 468 | toSourceStoreErrorFromLocalState("storage.close", error), | ||
| 469 | ), | ||
| 470 | ); | ||
| 471 | |||
| 472 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 473 | if (snapshot === null) { | ||
| 474 | return yield* toSourceStoreError( | ||
| 475 | "storage.close", | ||
| 476 | "Storage snapshot not found", | ||
| 477 | `workspace=${input.workspaceId}`, | ||
| 478 | ); | ||
| 479 | } | ||
| 480 | |||
| 481 | const found = findStorageInstance(snapshot, { | ||
| 482 | workspaceId: input.workspaceId, | ||
| 483 | storageInstanceId: input.storageInstanceId, | ||
| 484 | }); | ||
| 485 | |||
| 486 | if (found === null) { | ||
| 487 | return yield* toSourceStoreError( | ||
| 488 | "storage.close", | ||
| 489 | "Storage instance not found", | ||
| 490 | `workspace=${input.workspaceId} id=${input.storageInstanceId}`, | ||
| 491 | ); | ||
| 492 | } | ||
| 493 | |||
| 494 | const now = Date.now(); | ||
| 495 | |||
| 496 | const nextStorageInstance: StorageInstance = { | ||
| 497 | ...found.storageInstance, | ||
| 498 | status: "closed", | ||
| 499 | updatedAt: now, | ||
| 500 | lastSeenAt: now, | ||
| 501 | closedAt: found.storageInstance.closedAt ?? now, | ||
| 502 | }; | ||
| 503 | |||
| 504 | const nextSnapshot = replaceStorageInstanceAt( | ||
| 505 | snapshot, | ||
| 506 | found.storageInstanceIndex, | ||
| 507 | nextStorageInstance, | ||
| 508 | ); | ||
| 509 | |||
| 510 | yield* localStateStore.writeSnapshot(nextSnapshot).pipe( | ||
| 511 | Effect.mapError((error) => | ||
| 512 | toSourceStoreErrorFromLocalState("storage.close_write", error), | ||
| 513 | ), | ||
| 514 | ); | ||
| 515 | |||
| 516 | return nextStorageInstance; | ||
| 517 | }), | ||
| 518 | |||
| 519 | removeStorageInstance: (input) => | ||
| 520 | Effect.gen(function* () { | ||
| 521 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 522 | Effect.mapError((error) => | ||
| 523 | toSourceStoreErrorFromLocalState("storage.remove", error), | ||
| 524 | ), | ||
| 525 | ); | ||
| 526 | |||
| 527 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 528 | if (snapshot === null) { | ||
| 529 | return { | ||
| 530 | removed: false, | ||
| 531 | }; | ||
| 532 | } | ||
| 533 | |||
| 534 | const organizationId = resolveWorkspaceOrganizationId(snapshot, input.workspaceId); | ||
| 535 | |||
| 536 | const next = removeStorageInstanceById(snapshot, { | ||
| 537 | workspaceId: input.workspaceId, | ||
| 538 | organizationId, | ||
| 539 | storageInstanceId: input.storageInstanceId, | ||
| 540 | }); | ||
| 541 | |||
| 542 | if (!next.removed) { | ||
| 543 | return { | ||
| 544 | removed: false, | ||
| 545 | }; | ||
| 546 | } | ||
| 547 | |||
| 548 | yield* Effect.tryPromise({ | ||
| 549 | try: () => | ||
| 550 | rm( | ||
| 551 | storageInstanceRootPath(options.stateRootDir, input.storageInstanceId), | ||
| 552 | { | ||
| 553 | recursive: true, | ||
| 554 | force: true, | ||
| 555 | }, | ||
| 556 | ), | ||
| 557 | catch: (cause) => | ||
| 558 | toSourceStoreErrorFromCause( | ||
| 559 | "storage.remove_files", | ||
| 560 | cause, | ||
| 561 | `storageInstance=${input.storageInstanceId}`, | ||
| 562 | ), | ||
| 563 | }); | ||
| 564 | |||
| 565 | yield* localStateStore.writeSnapshot(next.snapshot).pipe( | ||
| 566 | Effect.mapError((error) => | ||
| 567 | toSourceStoreErrorFromLocalState("storage.remove_write", error), | ||
| 568 | ), | ||
| 569 | ); | ||
| 570 | |||
| 571 | return { | ||
| 572 | removed: true, | ||
| 573 | }; | ||
| 574 | }), | ||
| 575 | |||
| 576 | listStorageDirectory: (input) => | ||
| 577 | Effect.gen(function* () { | ||
| 578 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 579 | Effect.mapError((error) => | ||
| 580 | toSourceStoreErrorFromLocalState("storage.listDirectory", error), | ||
| 581 | ), | ||
| 582 | ); | ||
| 583 | |||
| 584 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 585 | if (snapshot === null) { | ||
| 586 | return yield* toSourceStoreError( | ||
| 587 | "storage.listDirectory", | ||
| 588 | "Storage snapshot not found", | ||
| 589 | `workspace=${input.workspaceId}`, | ||
| 590 | ); | ||
| 591 | } | ||
| 592 | |||
| 593 | const found = findStorageInstance(snapshot, { | ||
| 594 | workspaceId: input.workspaceId, | ||
| 595 | storageInstanceId: input.storageInstanceId, | ||
| 596 | }); | ||
| 597 | |||
| 598 | if (found === null) { | ||
| 599 | return yield* toSourceStoreError( | ||
| 600 | "storage.listDirectory", | ||
| 601 | "Storage instance not found", | ||
| 602 | `workspace=${input.workspaceId} id=${input.storageInstanceId}`, | ||
| 603 | ); | ||
| 604 | } | ||
| 605 | |||
| 606 | const fsRootPath = storageInstanceFsRootPath( | ||
| 607 | options.stateRootDir, | ||
| 608 | found.storageInstance.id, | ||
| 609 | ); | ||
| 610 | |||
| 611 | const result = yield* Effect.tryPromise({ | ||
| 612 | try: async () => { | ||
| 613 | await mkdir(fsRootPath, { recursive: true }); | ||
| 614 | |||
| 615 | const resolved = resolvePathWithinRoot( | ||
| 616 | fsRootPath, | ||
| 617 | input.payload.path, | ||
| 618 | ); | ||
| 619 | |||
| 620 | const entries = await readdir(resolved.absolutePath, { | ||
| 621 | withFileTypes: true, | ||
| 622 | }); | ||
| 623 | |||
| 624 | const mapped = await Promise.all( | ||
| 625 | entries.map(async (entry) => { | ||
| 626 | const entryAbsolutePath = path.resolve( | ||
| 627 | resolved.absolutePath, | ||
| 628 | entry.name, | ||
| 629 | ); | ||
| 630 | const entryStat = await stat(entryAbsolutePath); | ||
| 631 | |||
| 632 | return { | ||
| 633 | name: entry.name, | ||
| 634 | path: toStorageEntryPath(entryAbsolutePath, fsRootPath), | ||
| 635 | kind: entry.isDirectory() ? "directory" : "file", | ||
| 636 | sizeBytes: entry.isDirectory() ? null : entryStat.size, | ||
| 637 | updatedAt: entryStat.mtimeMs, | ||
| 638 | } as const; | ||
| 639 | }), | ||
| 640 | ); | ||
| 641 | |||
| 642 | mapped.sort((left, right) => { | ||
| 643 | if (left.kind !== right.kind) { | ||
| 644 | return left.kind === "directory" ? -1 : 1; | ||
| 645 | } | ||
| 646 | |||
| 647 | return left.name.localeCompare(right.name); | ||
| 648 | }); | ||
| 649 | |||
| 650 | return { | ||
| 651 | path: resolved.normalizedPath, | ||
| 652 | entries: mapped, | ||
| 653 | }; | ||
| 654 | }, | ||
| 655 | catch: (cause) => | ||
| 656 | toSourceStoreErrorFromCause( | ||
| 657 | "storage.listDirectory_read", | ||
| 658 | cause, | ||
| 659 | `storageInstance=${found.storageInstance.id} path=${input.payload.path}`, | ||
| 660 | ), | ||
| 661 | }); | ||
| 662 | |||
| 663 | const touched = touchStorageInstance(snapshot, found.storageInstanceIndex); | ||
| 664 | |||
| 665 | yield* localStateStore.writeSnapshot(touched.snapshot).pipe( | ||
| 666 | Effect.mapError((error) => | ||
| 667 | toSourceStoreErrorFromLocalState( | ||
| 668 | "storage.listDirectory_touch", | ||
| 669 | error, | ||
| 670 | ), | ||
| 671 | ), | ||
| 672 | ); | ||
| 673 | |||
| 674 | return result; | ||
| 675 | }), | ||
| 676 | |||
| 677 | readStorageFile: (input) => | ||
| 678 | Effect.gen(function* () { | ||
| 679 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 680 | Effect.mapError((error) => | ||
| 681 | toSourceStoreErrorFromLocalState("storage.readFile", error), | ||
| 682 | ), | ||
| 683 | ); | ||
| 684 | |||
| 685 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 686 | if (snapshot === null) { | ||
| 687 | return yield* toSourceStoreError( | ||
| 688 | "storage.readFile", | ||
| 689 | "Storage snapshot not found", | ||
| 690 | `workspace=${input.workspaceId}`, | ||
| 691 | ); | ||
| 692 | } | ||
| 693 | |||
| 694 | const found = findStorageInstance(snapshot, { | ||
| 695 | workspaceId: input.workspaceId, | ||
| 696 | storageInstanceId: input.storageInstanceId, | ||
| 697 | }); | ||
| 698 | |||
| 699 | if (found === null) { | ||
| 700 | return yield* toSourceStoreError( | ||
| 701 | "storage.readFile", | ||
| 702 | "Storage instance not found", | ||
| 703 | `workspace=${input.workspaceId} id=${input.storageInstanceId}`, | ||
| 704 | ); | ||
| 705 | } | ||
| 706 | |||
| 707 | const fsRootPath = storageInstanceFsRootPath( | ||
| 708 | options.stateRootDir, | ||
| 709 | found.storageInstance.id, | ||
| 710 | ); | ||
| 711 | const encoding = input.payload.encoding ?? "utf8"; | ||
| 712 | |||
| 713 | const result = yield* Effect.tryPromise({ | ||
| 714 | try: async () => { | ||
| 715 | await mkdir(fsRootPath, { recursive: true }); | ||
| 716 | |||
| 717 | const resolved = resolvePathWithinRoot(fsRootPath, input.payload.path); | ||
| 718 | const entryStat = await stat(resolved.absolutePath); | ||
| 719 | |||
| 720 | if (entryStat.isDirectory()) { | ||
| 721 | throw new Error("Cannot read a directory"); | ||
| 722 | } | ||
| 723 | |||
| 724 | const contentBuffer = await readFile(resolved.absolutePath); | ||
| 725 | |||
| 726 | return { | ||
| 727 | path: resolved.normalizedPath, | ||
| 728 | encoding, | ||
| 729 | content: | ||
| 730 | encoding === "base64" | ||
| 731 | ? contentBuffer.toString("base64") | ||
| 732 | : contentBuffer.toString("utf8"), | ||
| 733 | bytes: contentBuffer.byteLength, | ||
| 734 | }; | ||
| 735 | }, | ||
| 736 | catch: (cause) => | ||
| 737 | toSourceStoreErrorFromCause( | ||
| 738 | "storage.readFile_read", | ||
| 739 | cause, | ||
| 740 | `storageInstance=${found.storageInstance.id} path=${input.payload.path}`, | ||
| 741 | ), | ||
| 742 | }); | ||
| 743 | |||
| 744 | const touched = touchStorageInstance(snapshot, found.storageInstanceIndex); | ||
| 745 | |||
| 746 | yield* localStateStore.writeSnapshot(touched.snapshot).pipe( | ||
| 747 | Effect.mapError((error) => | ||
| 748 | toSourceStoreErrorFromLocalState("storage.readFile_touch", error), | ||
| 749 | ), | ||
| 750 | ); | ||
| 751 | |||
| 752 | return result; | ||
| 753 | }), | ||
| 754 | |||
| 755 | listStorageKv: (input) => | ||
| 756 | Effect.gen(function* () { | ||
| 757 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 758 | Effect.mapError((error) => | ||
| 759 | toSourceStoreErrorFromLocalState("storage.listKv", error), | ||
| 760 | ), | ||
| 761 | ); | ||
| 762 | |||
| 763 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 764 | if (snapshot === null) { | ||
| 765 | return yield* toSourceStoreError( | ||
| 766 | "storage.listKv", | ||
| 767 | "Storage snapshot not found", | ||
| 768 | `workspace=${input.workspaceId}`, | ||
| 769 | ); | ||
| 770 | } | ||
| 771 | |||
| 772 | const found = findStorageInstance(snapshot, { | ||
| 773 | workspaceId: input.workspaceId, | ||
| 774 | storageInstanceId: input.storageInstanceId, | ||
| 775 | }); | ||
| 776 | |||
| 777 | if (found === null) { | ||
| 778 | return yield* toSourceStoreError( | ||
| 779 | "storage.listKv", | ||
| 780 | "Storage instance not found", | ||
| 781 | `workspace=${input.workspaceId} id=${input.storageInstanceId}`, | ||
| 782 | ); | ||
| 783 | } | ||
| 784 | |||
| 785 | const kvPath = storageInstanceKvPath( | ||
| 786 | options.stateRootDir, | ||
| 787 | found.storageInstance.id, | ||
| 788 | ); | ||
| 789 | |||
| 790 | const result = yield* Effect.tryPromise({ | ||
| 791 | try: async () => { | ||
| 792 | const kvStore = await readKvStore(kvPath); | ||
| 793 | const prefix = input.payload.prefix ?? ""; | ||
| 794 | const requestedLimit = | ||
| 795 | input.payload.limit !== undefined && Number.isFinite(input.payload.limit) | ||
| 796 | ? Math.floor(input.payload.limit) | ||
| 797 | : DEFAULT_KV_LIMIT; | ||
| 798 | const limit = Math.max(1, Math.min(MAX_KV_LIMIT, requestedLimit)); | ||
| 799 | |||
| 800 | const items = Object.entries(kvStore) | ||
| 801 | .filter(([key]) => key.startsWith(prefix)) | ||
| 802 | .sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)) | ||
| 803 | .slice(0, limit) | ||
| 804 | .map(([key, value]) => ({ key, value })); | ||
| 805 | |||
| 806 | return { | ||
| 807 | items, | ||
| 808 | }; | ||
| 809 | }, | ||
| 810 | catch: (cause) => | ||
| 811 | toSourceStoreErrorFromCause( | ||
| 812 | "storage.listKv_read", | ||
| 813 | cause, | ||
| 814 | `storageInstance=${found.storageInstance.id}`, | ||
| 815 | ), | ||
| 816 | }); | ||
| 817 | |||
| 818 | const touched = touchStorageInstance(snapshot, found.storageInstanceIndex); | ||
| 819 | |||
| 820 | yield* localStateStore.writeSnapshot(touched.snapshot).pipe( | ||
| 821 | Effect.mapError((error) => | ||
| 822 | toSourceStoreErrorFromLocalState("storage.listKv_touch", error), | ||
| 823 | ), | ||
| 824 | ); | ||
| 825 | |||
| 826 | return result; | ||
| 827 | }), | ||
| 828 | |||
| 829 | queryStorageSql: (input) => | ||
| 830 | Effect.gen(function* () { | ||
| 831 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 832 | Effect.mapError((error) => | ||
| 833 | toSourceStoreErrorFromLocalState("storage.querySql", error), | ||
| 834 | ), | ||
| 835 | ); | ||
| 836 | |||
| 837 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 838 | if (snapshot === null) { | ||
| 839 | return yield* toSourceStoreError( | ||
| 840 | "storage.querySql", | ||
| 841 | "Storage snapshot not found", | ||
| 842 | `workspace=${input.workspaceId}`, | ||
| 843 | ); | ||
| 844 | } | ||
| 845 | |||
| 846 | const found = findStorageInstance(snapshot, { | ||
| 847 | workspaceId: input.workspaceId, | ||
| 848 | storageInstanceId: input.storageInstanceId, | ||
| 849 | }); | ||
| 850 | |||
| 851 | if (found === null) { | ||
| 852 | return yield* toSourceStoreError( | ||
| 853 | "storage.querySql", | ||
| 854 | "Storage instance not found", | ||
| 855 | `workspace=${input.workspaceId} id=${input.storageInstanceId}`, | ||
| 856 | ); | ||
| 857 | } | ||
| 858 | |||
| 859 | const sqlText = input.payload.sql.trim(); | ||
| 860 | if (sqlText.length === 0) { | ||
| 861 | return yield* toSourceStoreError( | ||
| 862 | "storage.querySql", | ||
| 863 | "SQL query is required", | ||
| 864 | `workspace=${input.workspaceId} id=${input.storageInstanceId}`, | ||
| 865 | ); | ||
| 866 | } | ||
| 867 | |||
| 868 | const sqlitePath = storageInstanceSqlitePath( | ||
| 869 | options.stateRootDir, | ||
| 870 | found.storageInstance.id, | ||
| 871 | ); | ||
| 872 | |||
| 873 | const result = yield* Effect.tryPromise({ | ||
| 874 | try: async () => { | ||
| 875 | await mkdir(path.dirname(sqlitePath), { recursive: true }); | ||
| 876 | |||
| 877 | const SqliteDatabase = await loadSqliteDatabase(); | ||
| 878 | if (SqliteDatabase === null) { | ||
| 879 | throw new Error("SQLite runtime is unavailable in this environment"); | ||
| 880 | } | ||
| 881 | |||
| 882 | const db = new SqliteDatabase(sqlitePath, { create: true }); | ||
| 883 | |||
| 884 | try { | ||
| 885 | db.exec( | ||
| 886 | "CREATE TABLE IF NOT EXISTS kv_store (key TEXT PRIMARY KEY, value TEXT NOT NULL);", | ||
| 887 | ); | ||
| 888 | |||
| 889 | const maxRows = | ||
| 890 | input.payload.maxRows !== undefined && Number.isFinite(input.payload.maxRows) | ||
| 891 | ? Math.max(1, Math.min(MAX_SQL_MAX_ROWS, Math.floor(input.payload.maxRows))) | ||
| 892 | : DEFAULT_SQL_MAX_ROWS; | ||
| 893 | |||
| 894 | try { | ||
| 895 | const statement = db.query(sqlText); | ||
| 896 | const rawRows = statement.all() as Array<Record<string, unknown>>; | ||
| 897 | const rows = rawRows.slice(0, maxRows); | ||
| 898 | const columns = | ||
| 899 | rows.length > 0 | ||
| 900 | ? Array.from(new Set(rows.flatMap((row) => Object.keys(row)))) | ||
| 901 | : []; | ||
| 902 | |||
| 903 | return { | ||
| 904 | rows, | ||
| 905 | columns, | ||
| 906 | rowCount: rows.length, | ||
| 907 | }; | ||
| 908 | } catch { | ||
| 909 | db.run(sqlText); | ||
| 910 | |||
| 911 | return { | ||
| 912 | rows: [], | ||
| 913 | columns: [], | ||
| 914 | rowCount: 0, | ||
| 915 | }; | ||
| 916 | } | ||
| 917 | } finally { | ||
| 918 | db.close(); | ||
| 919 | } | ||
| 920 | }, | ||
| 921 | catch: (cause) => | ||
| 922 | toSourceStoreErrorFromCause( | ||
| 923 | "storage.querySql_run", | ||
| 924 | cause, | ||
| 925 | `storageInstance=${found.storageInstance.id}`, | ||
| 926 | ), | ||
| 927 | }); | ||
| 928 | |||
| 929 | const touched = touchStorageInstance(snapshot, found.storageInstanceIndex); | ||
| 930 | |||
| 931 | yield* localStateStore.writeSnapshot(touched.snapshot).pipe( | ||
| 932 | Effect.mapError((error) => | ||
| 933 | toSourceStoreErrorFromLocalState("storage.querySql_touch", error), | ||
| 934 | ), | ||
| 935 | ); | ||
| 936 | |||
| 937 | return result; | ||
| 938 | }), | ||
| 939 | }); | ||
| @@ -0,0 +1,42 @@ | |||
| 1 | import { | ||
| 2 | createRuntimeToolCallHandler, | ||
| 3 | createUnimplementedRuntimeToolInvoker, | ||
| 4 | } from "@executor-v2/engine"; | ||
| 5 | import { describe, expect, it } from "@effect/vitest"; | ||
| 6 | import * as Effect from "effect/Effect"; | ||
| 7 | import * as Option from "effect/Option"; | ||
| 8 | |||
| 9 | import { createPmResolveToolCredentials } from "./credential-resolver"; | ||
| 10 | |||
| 11 | const emptyLocalStateStore = { | ||
| 12 | getSnapshot: () => Effect.succeed(Option.none()), | ||
| 13 | writeSnapshot: () => Effect.void, | ||
| 14 | readEvents: () => Effect.succeed([]), | ||
| 15 | appendEvents: () => Effect.void, | ||
| 16 | }; | ||
| 17 | |||
| 18 | describe("PM runtime tool-call handling", () => { | ||
| 19 | it.effect("returns failed callback result for unimplemented invoker", () => | ||
| 20 | Effect.gen(function* () { | ||
| 21 | const resolveCredentials = createPmResolveToolCredentials(emptyLocalStateStore); | ||
| 22 | const invokeRuntimeTool = createUnimplementedRuntimeToolInvoker("pm"); | ||
| 23 | const handleToolCall = createRuntimeToolCallHandler({ | ||
| 24 | resolveCredentials, | ||
| 25 | invokeRuntimeTool, | ||
| 26 | }); | ||
| 27 | |||
| 28 | const result = yield* handleToolCall({ | ||
| 29 | runId: "run_2", | ||
| 30 | callId: "call_2", | ||
| 31 | toolPath: "tools.example.weather", | ||
| 32 | input: { city: "London" }, | ||
| 33 | }); | ||
| 34 | |||
| 35 | expect(result.ok).toBe(false); | ||
| 36 | if (!result.ok) { | ||
| 37 | expect(result.kind).toBe("failed"); | ||
| 38 | expect(result.error).toContain("tools.example.weather"); | ||
| 39 | } | ||
| 40 | }), | ||
| 41 | ); | ||
| 42 | }); | ||
| @@ -0,0 +1,107 @@ | |||
| 1 | import { | ||
| 2 | type RuntimeToolCallResult, | ||
| 3 | type RuntimeToolCallRequest, | ||
| 4 | } from "@executor-v2/sdk"; | ||
| 5 | import * as Data from "effect/Data"; | ||
| 6 | import * as Effect from "effect/Effect"; | ||
| 7 | import * as ParseResult from "effect/ParseResult"; | ||
| 8 | import * as Schema from "effect/Schema"; | ||
| 9 | |||
| 10 | class PmToolCallHttpRequestError extends Data.TaggedError( | ||
| 11 | "PmToolCallHttpRequestError", | ||
| 12 | )<{ | ||
| 13 | message: string; | ||
| 14 | details: string | null; | ||
| 15 | }> {} | ||
| 16 | |||
| 17 | const RuntimeToolCallCredentialContextSchema = Schema.Struct({ | ||
| 18 | workspaceId: Schema.String, | ||
| 19 | sourceKey: Schema.String, | ||
| 20 | organizationId: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 21 | accountId: Schema.optional(Schema.NullOr(Schema.String)), | ||
| 22 | }); | ||
| 23 | |||
| 24 | const RuntimeToolCallRequestSchema = Schema.Struct({ | ||
| 25 | runId: Schema.String, | ||
| 26 | callId: Schema.String, | ||
| 27 | toolPath: Schema.String, | ||
| 28 | input: Schema.optional( | ||
| 29 | Schema.Record({ | ||
| 30 | key: Schema.String, | ||
| 31 | value: Schema.Unknown, | ||
| 32 | }), | ||
| 33 | ), | ||
| 34 | credentialContext: Schema.optional(RuntimeToolCallCredentialContextSchema), | ||
| 35 | }); | ||
| 36 | |||
| 37 | const decodeRuntimeToolCallRequest = Schema.decodeUnknown(RuntimeToolCallRequestSchema); | ||
| 38 | |||
| 39 | const decodeRequestBodyError = (cause: unknown): PmToolCallHttpRequestError => | ||
| 40 | new PmToolCallHttpRequestError({ | ||
| 41 | message: "Invalid runtime callback request body", | ||
| 42 | details: String(cause), | ||
| 43 | }); | ||
| 44 | |||
| 45 | const decodeRequestPayloadError = (cause: unknown): PmToolCallHttpRequestError => | ||
| 46 | new PmToolCallHttpRequestError({ | ||
| 47 | message: "Runtime callback request body is invalid", | ||
| 48 | details: ParseResult.isParseError(cause) | ||
| 49 | ? ParseResult.TreeFormatter.formatErrorSync(cause) | ||
| 50 | : String(cause), | ||
| 51 | }); | ||
| 52 | |||
| 53 | const formatHttpRequestError = (error: PmToolCallHttpRequestError): string => | ||
| 54 | error.details && error.details.length > 0 | ||
| 55 | ? `${error.message}: ${error.details}` | ||
| 56 | : error.message; | ||
| 57 | |||
| 58 | const decodeToolCallRequest = async ( | ||
| 59 | request: Request, | ||
| 60 | ): Promise<RuntimeToolCallRequest> => { | ||
| 61 | let body: unknown; | ||
| 62 | try { | ||
| 63 | body = await request.json(); | ||
| 64 | } catch (cause) { | ||
| 65 | throw decodeRequestBodyError(cause); | ||
| 66 | } | ||
| 67 | |||
| 68 | try { | ||
| 69 | return await Effect.runPromise(decodeRuntimeToolCallRequest(body)); | ||
| 70 | } catch (cause) { | ||
| 71 | throw decodeRequestPayloadError(cause); | ||
| 72 | } | ||
| 73 | }; | ||
| 74 | |||
| 75 | export const createPmToolCallHttpHandler = ( | ||
| 76 | handleToolCall: ( | ||
| 77 | input: RuntimeToolCallRequest, | ||
| 78 | ) => Promise<RuntimeToolCallResult>, | ||
| 79 | ): ((request: Request) => Promise<Response>) => { | ||
| 80 | return async (request: Request) => { | ||
| 81 | try { | ||
| 82 | const input = await decodeToolCallRequest(request); | ||
| 83 | const result = await handleToolCall(input); | ||
| 84 | return Response.json(result, { status: 200 }); | ||
| 85 | } catch (error) { | ||
| 86 | if (error instanceof PmToolCallHttpRequestError) { | ||
| 87 | return Response.json( | ||
| 88 | { | ||
| 89 | ok: false, | ||
| 90 | kind: "failed", | ||
| 91 | error: formatHttpRequestError(error), | ||
| 92 | } satisfies RuntimeToolCallResult, | ||
| 93 | { status: 400 }, | ||
| 94 | ); | ||
| 95 | } | ||
| 96 | |||
| 97 | return Response.json( | ||
| 98 | { | ||
| 99 | ok: false, | ||
| 100 | kind: "failed", | ||
| 101 | error: String(error), | ||
| 102 | } satisfies RuntimeToolCallResult, | ||
| 103 | { status: 500 }, | ||
| 104 | ); | ||
| 105 | } | ||
| 106 | }; | ||
| 107 | }; | ||
| @@ -0,0 +1,253 @@ | |||
| 1 | import { | ||
| 2 | SourceStoreError, | ||
| 3 | ToolArtifactStoreError, | ||
| 4 | type SourceStore, | ||
| 5 | type ToolArtifactStore, | ||
| 6 | } from "@executor-v2/persistence-ports"; | ||
| 7 | import { | ||
| 8 | makeControlPlaneToolsService, | ||
| 9 | type ControlPlaneToolsServiceShape, | ||
| 10 | type SourceToolDetail, | ||
| 11 | type SourceToolSummary, | ||
| 12 | } from "@executor-v2/management-api"; | ||
| 13 | import { | ||
| 14 | OpenApiToolManifestSchema, | ||
| 15 | type Source, | ||
| 16 | type SourceId, | ||
| 17 | type ToolArtifact, | ||
| 18 | type WorkspaceId, | ||
| 19 | } from "@executor-v2/schema"; | ||
| 20 | import * as Effect from "effect/Effect"; | ||
| 21 | import * as Option from "effect/Option"; | ||
| 22 | import * as ParseResult from "effect/ParseResult"; | ||
| 23 | import * as Schema from "effect/Schema"; | ||
| 24 | |||
| 25 | const decodeOpenApiToolManifest = Schema.decodeUnknown(OpenApiToolManifestSchema); | ||
| 26 | |||
| 27 | const toSourceStoreError = ( | ||
| 28 | operation: string, | ||
| 29 | message: string, | ||
| 30 | details: string | null, | ||
| 31 | ): SourceStoreError => | ||
| 32 | new SourceStoreError({ | ||
| 33 | operation, | ||
| 34 | backend: "local-file", | ||
| 35 | location: "tool-artifacts.json", | ||
| 36 | message, | ||
| 37 | reason: null, | ||
| 38 | details, | ||
| 39 | }); | ||
| 40 | |||
| 41 | const toSourceStoreErrorFromSourceStore = ( | ||
| 42 | operation: string, | ||
| 43 | error: SourceStoreError, | ||
| 44 | ): SourceStoreError => | ||
| 45 | toSourceStoreError(operation, error.message, error.details ?? error.reason ?? null); | ||
| 46 | |||
| 47 | const toSourceStoreErrorFromToolArtifactStore = ( | ||
| 48 | operation: string, | ||
| 49 | error: ToolArtifactStoreError, | ||
| 50 | ): SourceStoreError => | ||
| 51 | toSourceStoreError(operation, error.message, error.details ?? error.reason ?? null); | ||
| 52 | |||
| 53 | const parseArtifactManifest = ( | ||
| 54 | source: Source, | ||
| 55 | artifact: ToolArtifact, | ||
| 56 | ): Effect.Effect<ReadonlyArray<SourceToolSummary>, SourceStoreError> => | ||
| 57 | Effect.try({ | ||
| 58 | try: () => JSON.parse(artifact.manifestJson) as unknown, | ||
| 59 | catch: (cause) => | ||
| 60 | toSourceStoreError( | ||
| 61 | "tools.decode_manifest_json", | ||
| 62 | cause instanceof Error ? cause.message : String(cause), | ||
| 63 | `sourceId=${source.id}`, | ||
| 64 | ), | ||
| 65 | }).pipe( | ||
| 66 | Effect.flatMap((manifestJson) => | ||
| 67 | decodeOpenApiToolManifest(manifestJson).pipe( | ||
| 68 | Effect.mapError((cause) => | ||
| 69 | toSourceStoreError( | ||
| 70 | "tools.decode_manifest", | ||
| 71 | "Unable to decode OpenAPI manifest", | ||
| 72 | ParseResult.TreeFormatter.formatErrorSync(cause), | ||
| 73 | ), | ||
| 74 | ), | ||
| 75 | ) | ||
| 76 | ), | ||
| 77 | Effect.map((manifest) => | ||
| 78 | manifest.tools.map((tool) => ({ | ||
| 79 | sourceId: source.id, | ||
| 80 | sourceName: source.name, | ||
| 81 | sourceKind: source.kind, | ||
| 82 | toolId: tool.toolId, | ||
| 83 | name: tool.name, | ||
| 84 | description: tool.description, | ||
| 85 | method: tool.method, | ||
| 86 | path: tool.path, | ||
| 87 | operationHash: tool.operationHash, | ||
| 88 | })), | ||
| 89 | ), | ||
| 90 | ); | ||
| 91 | |||
| 92 | const sortTools = (tools: ReadonlyArray<SourceToolSummary>): Array<SourceToolSummary> => | ||
| 93 | [...tools].sort((left, right) => { | ||
| 94 | const leftSource = left.sourceName.toLowerCase(); | ||
| 95 | const rightSource = right.sourceName.toLowerCase(); | ||
| 96 | |||
| 97 | if (leftSource !== rightSource) { | ||
| 98 | return leftSource.localeCompare(rightSource); | ||
| 99 | } | ||
| 100 | |||
| 101 | const leftName = left.name.toLowerCase(); | ||
| 102 | const rightName = right.name.toLowerCase(); | ||
| 103 | |||
| 104 | if (leftName !== rightName) { | ||
| 105 | return leftName.localeCompare(rightName); | ||
| 106 | } | ||
| 107 | |||
| 108 | return left.toolId.localeCompare(right.toolId); | ||
| 109 | }); | ||
| 110 | |||
| 111 | const listSourceTools = ( | ||
| 112 | sourceStore: SourceStore, | ||
| 113 | toolArtifactStore: ToolArtifactStore, | ||
| 114 | input: { | ||
| 115 | workspaceId: WorkspaceId; | ||
| 116 | sourceId: SourceId; | ||
| 117 | }, | ||
| 118 | ): Effect.Effect<ReadonlyArray<SourceToolSummary>, SourceStoreError> => | ||
| 119 | Effect.gen(function* () { | ||
| 120 | const sourceOption = yield* sourceStore.getById(input.workspaceId, input.sourceId).pipe( | ||
| 121 | Effect.mapError((error) => | ||
| 122 | toSourceStoreErrorFromSourceStore("tools.get_source", error), | ||
| 123 | ), | ||
| 124 | ); | ||
| 125 | |||
| 126 | const source = Option.getOrNull(sourceOption); | ||
| 127 | if (source === null) { | ||
| 128 | return []; | ||
| 129 | } | ||
| 130 | |||
| 131 | const artifactOption = yield* toolArtifactStore | ||
| 132 | .getBySource(input.workspaceId, input.sourceId) | ||
| 133 | .pipe( | ||
| 134 | Effect.mapError((error) => | ||
| 135 | toSourceStoreErrorFromToolArtifactStore("tools.get_artifact", error), | ||
| 136 | ), | ||
| 137 | ); | ||
| 138 | |||
| 139 | const artifact = Option.getOrNull(artifactOption); | ||
| 140 | if (artifact === null) { | ||
| 141 | return []; | ||
| 142 | } | ||
| 143 | |||
| 144 | return yield* parseArtifactManifest(source, artifact); | ||
| 145 | }); | ||
| 146 | |||
| 147 | export const createPmToolsService = ( | ||
| 148 | sourceStore: SourceStore, | ||
| 149 | toolArtifactStore: ToolArtifactStore, | ||
| 150 | ): ControlPlaneToolsServiceShape => | ||
| 151 | makeControlPlaneToolsService({ | ||
| 152 | listWorkspaceTools: (workspaceId) => | ||
| 153 | Effect.gen(function* () { | ||
| 154 | const sources = yield* sourceStore.listByWorkspace(workspaceId).pipe( | ||
| 155 | Effect.mapError((error) => | ||
| 156 | toSourceStoreErrorFromSourceStore("tools.list_sources", error), | ||
| 157 | ), | ||
| 158 | ); | ||
| 159 | |||
| 160 | const toolGroups = yield* Effect.forEach( | ||
| 161 | sources, | ||
| 162 | (source) => | ||
| 163 | listSourceTools(sourceStore, toolArtifactStore, { | ||
| 164 | workspaceId, | ||
| 165 | sourceId: source.id, | ||
| 166 | }), | ||
| 167 | { | ||
| 168 | concurrency: "unbounded", | ||
| 169 | }, | ||
| 170 | ); | ||
| 171 | |||
| 172 | return sortTools(toolGroups.flat()); | ||
| 173 | }), | ||
| 174 | |||
| 175 | listSourceTools: (input) => | ||
| 176 | listSourceTools(sourceStore, toolArtifactStore, { | ||
| 177 | workspaceId: input.workspaceId, | ||
| 178 | sourceId: input.sourceId, | ||
| 179 | }), | ||
| 180 | |||
| 181 | getToolDetail: (input) => | ||
| 182 | Effect.gen(function* () { | ||
| 183 | const sourceOption = yield* sourceStore | ||
| 184 | .getById(input.workspaceId, input.sourceId) | ||
| 185 | .pipe( | ||
| 186 | Effect.mapError((error) => | ||
| 187 | toSourceStoreErrorFromSourceStore("tools.get_detail_source", error), | ||
| 188 | ), | ||
| 189 | ); | ||
| 190 | |||
| 191 | const source = Option.getOrNull(sourceOption); | ||
| 192 | if (source === null) { | ||
| 193 | return null; | ||
| 194 | } | ||
| 195 | |||
| 196 | const artifactOption = yield* toolArtifactStore | ||
| 197 | .getBySource(input.workspaceId, input.sourceId) | ||
| 198 | .pipe( | ||
| 199 | Effect.mapError((error) => | ||
| 200 | toSourceStoreErrorFromToolArtifactStore("tools.get_detail_artifact", error), | ||
| 201 | ), | ||
| 202 | ); | ||
| 203 | |||
| 204 | const artifact = Option.getOrNull(artifactOption); | ||
| 205 | if (artifact === null) { | ||
| 206 | return null; | ||
| 207 | } | ||
| 208 | |||
| 209 | const manifestResult = yield* Effect.try({ | ||
| 210 | try: () => JSON.parse(artifact.manifestJson) as unknown, | ||
| 211 | catch: () => null as never, | ||
| 212 | }).pipe(Effect.option); | ||
| 213 | |||
| 214 | if (Option.isNone(manifestResult)) { | ||
| 215 | return null; | ||
| 216 | } | ||
| 217 | |||
| 218 | const decoded = yield* decodeOpenApiToolManifest(manifestResult.value).pipe( | ||
| 219 | Effect.option, | ||
| 220 | ); | ||
| 221 | |||
| 222 | if (Option.isNone(decoded)) { | ||
| 223 | return null; | ||
| 224 | } | ||
| 225 | |||
| 226 | const manifest = decoded.value; | ||
| 227 | const tool = manifest.tools.find((t) => t.operationHash === input.operationHash); | ||
| 228 | if (!tool) { | ||
| 229 | return null; | ||
| 230 | } | ||
| 231 | |||
| 232 | |||
| 233 | |||
| 234 | const detail: SourceToolDetail = { | ||
| 235 | sourceId: source.id, | ||
| 236 | sourceName: source.name, | ||
| 237 | sourceKind: source.kind, | ||
| 238 | toolId: tool.toolId, | ||
| 239 | name: tool.name, | ||
| 240 | description: tool.description, | ||
| 241 | method: tool.method, | ||
| 242 | path: tool.path, | ||
| 243 | operationHash: tool.operationHash, | ||
| 244 | inputSchemaJson: tool.typing?.inputSchemaJson ?? null, | ||
| 245 | outputSchemaJson: tool.typing?.outputSchemaJson ?? null, | ||
| 246 | refHintTableJson: manifest.refHintTable | ||
| 247 | ? JSON.stringify(manifest.refHintTable) | ||
| 248 | : null, | ||
| 249 | }; | ||
| 250 | |||
| 251 | return detail; | ||
| 252 | }), | ||
| 253 | }); | ||
| @@ -0,0 +1,135 @@ | |||
| 1 | import { SourceStoreError } from "@executor-v2/persistence-ports"; | ||
| 2 | import { | ||
| 3 | makeControlPlaneWorkspacesService, | ||
| 4 | type ControlPlaneWorkspacesServiceShape, | ||
| 5 | } from "@executor-v2/management-api"; | ||
| 6 | import { | ||
| 7 | type LocalStateSnapshot, | ||
| 8 | type LocalStateStore, | ||
| 9 | type LocalStateStoreError, | ||
| 10 | } from "@executor-v2/persistence-local"; | ||
| 11 | import { type Workspace } from "@executor-v2/schema"; | ||
| 12 | import * as Effect from "effect/Effect"; | ||
| 13 | import * as Option from "effect/Option"; | ||
| 14 | |||
| 15 | const toSourceStoreError = ( | ||
| 16 | operation: string, | ||
| 17 | message: string, | ||
| 18 | details: string | null, | ||
| 19 | ): SourceStoreError => | ||
| 20 | new SourceStoreError({ | ||
| 21 | operation, | ||
| 22 | backend: "local-file", | ||
| 23 | location: "snapshot.json", | ||
| 24 | message, | ||
| 25 | reason: null, | ||
| 26 | details, | ||
| 27 | }); | ||
| 28 | |||
| 29 | const toSourceStoreErrorFromLocalState = ( | ||
| 30 | operation: string, | ||
| 31 | error: LocalStateStoreError, | ||
| 32 | ): SourceStoreError => | ||
| 33 | toSourceStoreError(operation, error.message, error.details ?? error.reason ?? null); | ||
| 34 | |||
| 35 | const sortWorkspaces = (workspaces: ReadonlyArray<Workspace>): Array<Workspace> => | ||
| 36 | [...workspaces].sort((left, right) => { | ||
| 37 | const leftName = left.name.toLowerCase(); | ||
| 38 | const rightName = right.name.toLowerCase(); | ||
| 39 | |||
| 40 | if (leftName === rightName) { | ||
| 41 | return left.id.localeCompare(right.id); | ||
| 42 | } | ||
| 43 | |||
| 44 | return leftName.localeCompare(rightName); | ||
| 45 | }); | ||
| 46 | |||
| 47 | const replaceWorkspaceAt = ( | ||
| 48 | snapshot: LocalStateSnapshot, | ||
| 49 | index: number, | ||
| 50 | workspace: Workspace, | ||
| 51 | ): LocalStateSnapshot => { | ||
| 52 | const next = [...snapshot.workspaces]; | ||
| 53 | next[index] = workspace; | ||
| 54 | |||
| 55 | return { | ||
| 56 | ...snapshot, | ||
| 57 | generatedAt: Date.now(), | ||
| 58 | workspaces: next, | ||
| 59 | }; | ||
| 60 | }; | ||
| 61 | |||
| 62 | const appendWorkspace = ( | ||
| 63 | snapshot: LocalStateSnapshot, | ||
| 64 | workspace: Workspace, | ||
| 65 | ): LocalStateSnapshot => ({ | ||
| 66 | ...snapshot, | ||
| 67 | generatedAt: Date.now(), | ||
| 68 | workspaces: [...snapshot.workspaces, workspace], | ||
| 69 | }); | ||
| 70 | |||
| 71 | export const createPmWorkspacesService = ( | ||
| 72 | localStateStore: LocalStateStore, | ||
| 73 | ): ControlPlaneWorkspacesServiceShape => | ||
| 74 | makeControlPlaneWorkspacesService({ | ||
| 75 | listWorkspaces: () => | ||
| 76 | Effect.gen(function* () { | ||
| 77 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 78 | Effect.mapError((error) => | ||
| 79 | toSourceStoreErrorFromLocalState("workspaces.list", error), | ||
| 80 | ), | ||
| 81 | ); | ||
| 82 | |||
| 83 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 84 | if (snapshot === null) { | ||
| 85 | return []; | ||
| 86 | } | ||
| 87 | |||
| 88 | return sortWorkspaces(snapshot.workspaces); | ||
| 89 | }), | ||
| 90 | |||
| 91 | upsertWorkspace: (input) => | ||
| 92 | Effect.gen(function* () { | ||
| 93 | const snapshotOption = yield* localStateStore.getSnapshot().pipe( | ||
| 94 | Effect.mapError((error) => | ||
| 95 | toSourceStoreErrorFromLocalState("workspaces.upsert", error), | ||
| 96 | ), | ||
| 97 | ); | ||
| 98 | |||
| 99 | const snapshot = Option.getOrNull(snapshotOption); | ||
| 100 | if (snapshot === null) { | ||
| 101 | return yield* toSourceStoreError( | ||
| 102 | "workspaces.upsert", | ||
| 103 | "Workspace snapshot not found", | ||
| 104 | null, | ||
| 105 | ); | ||
| 106 | } | ||
| 107 | |||
| 108 | const now = Date.now(); | ||
| 109 | const existingIndex = input.payload.id | ||
| 110 | ? snapshot.workspaces.findIndex((workspace) => workspace.id === input.payload.id) | ||
| 111 | : -1; | ||
| 112 | const existing = existingIndex >= 0 ? snapshot.workspaces[existingIndex] : null; | ||
| 113 | |||
| 114 | const nextWorkspace: Workspace = { | ||
| 115 | id: existing?.id ?? (input.payload.id ?? (`ws_${crypto.randomUUID()}` as Workspace["id"])), | ||
| 116 | organizationId: input.payload.organizationId, | ||
| 117 | name: input.payload.name, | ||
| 118 | createdByAccountId: existing?.createdByAccountId ?? null, | ||
| 119 | createdAt: existing?.createdAt ?? now, | ||
| 120 | updatedAt: now, | ||
| 121 | }; | ||
| 122 | |||
| 123 | const nextSnapshot = existingIndex >= 0 | ||
| 124 | ? replaceWorkspaceAt(snapshot, existingIndex, nextWorkspace) | ||
| 125 | : appendWorkspace(snapshot, nextWorkspace); | ||
| 126 | |||
| 127 | yield* localStateStore.writeSnapshot(nextSnapshot).pipe( | ||
| 128 | Effect.mapError((error) => | ||
| 129 | toSourceStoreErrorFromLocalState("workspaces.upsert_write", error), | ||
| 130 | ), | ||
| 131 | ); | ||
| 132 | |||
| 133 | return nextWorkspace; | ||
| 134 | }), | ||
| 135 | }); | ||
| @@ -0,0 +1,7 @@ | |||
| 1 | { | ||
| 2 | "extends": "../../tsconfig.json", | ||
| 3 | "compilerOptions": { | ||
| 4 | "types": ["bun"] | ||
| 5 | }, | ||
| 6 | "include": ["src"] | ||
| 7 | } | ||
| @@ -0,0 +1,30 @@ | |||
| 1 | # app-web | ||
| 2 | |||
| 3 | Basic Next.js frontend for Executor v2 control plane. | ||
| 4 | |||
| 5 | - Uses `@executor-v2/control-plane` Effect HttpApi client | ||
| 6 | - Uses Effect Atom (`@effect-atom/atom`, `@effect-atom/atom-react`) for query state | ||
| 7 | |||
| 8 | Run: | ||
| 9 | |||
| 10 | - `bun run --cwd apps/web dev` | ||
| 11 | - Open `http://127.0.0.1:3000` | ||
| 12 | |||
| 13 | By default, control-plane API calls go directly to `http://127.0.0.1:8788`. | ||
| 14 | Override with `NEXT_PUBLIC_CONTROL_PLANE_BASE_URL` (and optionally `CONTROL_PLANE_SERVER_BASE_URL` for SSR). | ||
| 15 | |||
| 16 | MCP install URL generation: | ||
| 17 | |||
| 18 | - Derives from existing control-plane/frontend config. | ||
| 19 | - Prioritizes server-side `CONTROL_PLANE_UPSTREAM_URL` (or server/base control-plane URL) when available. | ||
| 20 | - In local dev, defaults to direct Convex MCP URL: `http://127.0.0.1:8788/v1/mcp?...` | ||
| 21 | |||
| 22 | WorkOS auth setup (optional but recommended): | ||
| 23 | |||
| 24 | - `WORKOS_CLIENT_ID` | ||
| 25 | - `WORKOS_API_KEY` | ||
| 26 | - `WORKOS_COOKIE_PASSWORD` (32+ chars) | ||
| 27 | - `WORKOS_REDIRECT_URI` or `NEXT_PUBLIC_WORKOS_REDIRECT_URI` (for example `http://localhost:4312/callback`) | ||
| 28 | |||
| 29 | When WorkOS is configured, the app requires sign-in and forwards the authenticated WorkOS user id to control-plane as `x-executor-account-id`. | ||
| 30 | For local non-WorkOS testing, you can still set `NEXT_PUBLIC_CONTROL_PLANE_ACCOUNT_ID` to send a static account id. | ||
| @@ -0,0 +1,114 @@ | |||
| 1 | # Effect Atom guide for `apps/web` | ||
| 2 | |||
| 3 | This file defines how we write Effect Atom code in this app. | ||
| 4 | |||
| 5 | ## Goal | ||
| 6 | |||
| 7 | Keep React components dumb. Put async/result orchestration in atoms, and render from typed state objects. | ||
| 8 | |||
| 9 | ## Hard rules | ||
| 10 | |||
| 11 | - Do not create query atoms in render with `useMemo`. | ||
| 12 | - Do not hand-roll `isLoading` / `hasError` booleans from `_tag` checks in components. | ||
| 13 | - Do not manually mirror server state with React local state. | ||
| 14 | - Prefer `Atom.family` + derived state atoms over component-level branching. | ||
| 15 | |||
| 16 | ## Baseline stack | ||
| 17 | |||
| 18 | - `@effect-atom/atom` | ||
| 19 | - `@effect-atom/atom-react` | ||
| 20 | - `@executor-v2/control-plane` client (Effect HttpApi) | ||
| 21 | |||
| 22 | ## Recommended structure | ||
| 23 | |||
| 24 | - `lib/control-plane/client.ts` | ||
| 25 | - Export one shared `createControlPlaneAtomClient(...)` instance. | ||
| 26 | - `lib/control-plane/atoms.ts` | ||
| 27 | - Export query/mutation atoms and derived state atoms. | ||
| 28 | - `app/.../page.tsx` | ||
| 29 | - Use `useAtomValue`, `useAtomSet`, and `useAtomRefresh`. | ||
| 30 | - Render from derived state atom output. | ||
| 31 | |||
| 32 | ## Preferred patterns | ||
| 33 | |||
| 34 | ### 1) Parametrized query atom with `Atom.family` | ||
| 35 | |||
| 36 | Create once at module scope: | ||
| 37 | |||
| 38 | ```ts | ||
| 39 | const sourcesResultByWorkspace = Atom.family((workspaceId: WorkspaceId) => | ||
| 40 | controlPlaneClient.query("sources", "list", { | ||
| 41 | path: { workspaceId }, | ||
| 42 | }), | ||
| 43 | ); | ||
| 44 | ``` | ||
| 45 | |||
| 46 | Then in component: | ||
| 47 | |||
| 48 | ```ts | ||
| 49 | const result = useAtomValue(sourcesResultByWorkspace(workspaceId)); | ||
| 50 | ``` | ||
| 51 | |||
| 52 | No `useMemo` needed. | ||
| 53 | |||
| 54 | ### 2) Derived state atom for UI projection | ||
| 55 | |||
| 56 | Map `Result` once in atom-land: | ||
| 57 | |||
| 58 | ```ts | ||
| 59 | const sourcesByWorkspace = Atom.family((workspaceId: WorkspaceId) => | ||
| 60 | Atom.make((get) => { | ||
| 61 | const result = get(sourcesResultByWorkspace(workspaceId)); | ||
| 62 | return Result.match(result, { | ||
| 63 | onInitial: () => ({ state: "loading" as const, items: [] as const, message: null }), | ||
| 64 | onFailure: (failure) => ({ | ||
| 65 | state: "error" as const, | ||
| 66 | items: Option.getOrElse(Result.value(result), () => []), | ||
| 67 | message: Cause.pretty(failure.cause), | ||
| 68 | }), | ||
| 69 | onSuccess: (success) => ({ | ||
| 70 | state: success.waiting ? ("refreshing" as const) : ("ready" as const), | ||
| 71 | items: success.value, | ||
| 72 | message: null, | ||
| 73 | }), | ||
| 74 | }); | ||
| 75 | }), | ||
| 76 | ); | ||
| 77 | ``` | ||
| 78 | |||
| 79 | Components switch on `sources.state`, not raw result internals. | ||
| 80 | |||
| 81 | ### 3) Mutations as atoms | ||
| 82 | |||
| 83 | Define mutation atoms once: | ||
| 84 | |||
| 85 | ```ts | ||
| 86 | const upsertSource = controlPlaneClient.mutation("sources", "upsert"); | ||
| 87 | const removeSource = controlPlaneClient.mutation("sources", "remove"); | ||
| 88 | ``` | ||
| 89 | |||
| 90 | In components, execute with `useAtomSet(..., { mode: "promise" })`, then refresh the related query atom. | ||
| 91 | |||
| 92 | ## React hooks usage | ||
| 93 | |||
| 94 | - `useAtomValue(atom)` for reads. | ||
| 95 | - `useAtomSet(writableAtom, { mode: "promise" })` for mutation execution. | ||
| 96 | - `useAtomRefresh(atom)` for explicit refresh. | ||
| 97 | - `useAtomSuspense(...)` is preferred when route is Suspense-driven. | ||
| 98 | |||
| 99 | ## Error formatting | ||
| 100 | |||
| 101 | - Prefer `Cause.pretty(...)` for UI/debug text when surfacing failures. | ||
| 102 | - Keep raw `Cause` in atom-derived state when useful; do not stringify ad-hoc in JSX. | ||
| 103 | |||
| 104 | ## Internal references | ||
| 105 | |||
| 106 | - `@effect-atom/atom` d.ts: `dist/dts/Atom.d.ts`, `dist/dts/Result.d.ts`, `dist/dts/AtomHttpApi.d.ts` | ||
| 107 | - `@effect-atom/atom-react` d.ts: `dist/dts/Hooks.d.ts`, `dist/dts/RegistryContext.d.ts` | ||
| 108 | |||
| 109 | ## Anti-pattern checklist (reject in review) | ||
| 110 | |||
| 111 | - `useMemo(() => client.query(...), [deps])` | ||
| 112 | - `const isLoading = result._tag === "Initial" || ...` | ||
| 113 | - component-level `if/else` trees over raw `Result` in many places | ||
| 114 | - duplicating remote state into `useState` unless it is true form draft state | ||
| @@ -0,0 +1,5 @@ | |||
| 1 | import { ApprovalsView } from "../../../components/approvals/approvals-view"; | ||
| 2 | |||
| 3 | const ApprovalsPage = () => <ApprovalsView />; | ||
| 4 | |||
| 5 | export default ApprovalsPage; | ||
| @@ -0,0 +1,56 @@ | |||
| 1 | "use client"; | ||
| 2 | |||
| 3 | import { memo, type ReactNode } from "react"; | ||
| 4 | import { useAtomValue } from "@effect-atom/atom-react"; | ||
| 5 | |||
| 6 | import { AppShell } from "../../components/shell/app-shell"; | ||
| 7 | import { WorkspaceProvider, useWorkspace } from "../../lib/hooks/use-workspace"; | ||
| 8 | import { approvalsByWorkspace } from "../../lib/control-plane/atoms"; | ||
| 9 | |||
| 10 | type ConsoleShellProps = { | ||
| 11 | authEnabled: boolean; | ||
| 12 | initialWorkspaceId: string; | ||
| 13 | children: ReactNode; | ||
| 14 | }; | ||
| 15 | |||
| 16 | export function ConsoleShell({ authEnabled, initialWorkspaceId, children }: ConsoleShellProps) { | ||
| 17 | return ( | ||
| 18 | <WorkspaceProvider initialWorkspaceId={initialWorkspaceId}> | ||
| 19 | <ConsoleShellInner authEnabled={authEnabled}> | ||
| 20 | {children} | ||
| 21 | </ConsoleShellInner> | ||
| 22 | </WorkspaceProvider> | ||
| 23 | ); | ||
| 24 | } | ||
| 25 | |||
| 26 | function ConsoleShellInner({ | ||
| 27 | authEnabled, | ||
| 28 | children, | ||
| 29 | }: { | ||
| 30 | authEnabled: boolean; | ||
| 31 | children: ReactNode; | ||
| 32 | }) { | ||
| 33 | return ( | ||
| 34 | <AppShell | ||
| 35 | authEnabled={authEnabled} | ||
| 36 | approvalsBadge={<ApprovalsBadge />} | ||
| 37 | > | ||
| 38 | {children} | ||
| 39 | </AppShell> | ||
| 40 | ); | ||
| 41 | } | ||
| 42 | |||
| 43 | /** Isolated subscription boundary: only this component re-renders when approvals change. */ | ||
| 44 | const ApprovalsBadge = memo(function ApprovalsBadge() { | ||
| 45 | const { workspaceId } = useWorkspace(); | ||
| 46 | const approvalsState = useAtomValue(approvalsByWorkspace(workspaceId)); | ||
| 47 | const pendingCount = approvalsState.items.filter((a) => a.status === "pending").length; | ||
| 48 | |||
| 49 | if (pendingCount === 0) return null; | ||
| 50 | |||
| 51 | return ( | ||
| 52 | <span className="flex size-5 items-center justify-center rounded-full bg-primary/80 text-[10px] font-semibold text-primary-foreground"> | ||
| 53 | {pendingCount} | ||
| 54 | </span> | ||
| 55 | ); | ||
| 56 | }); | ||
| @@ -0,0 +1,5 @@ | |||
| 1 | import { CredentialsView } from "../../../components/credentials/credentials-view"; | ||
| 2 | |||
| 3 | const CredentialsPage = () => <CredentialsView />; | ||
| 4 | |||
| 5 | export default CredentialsPage; | ||
| @@ -0,0 +1,42 @@ | |||
| 1 | import { withAuth } from "@workos-inc/authkit-nextjs"; | ||
| 2 | import { redirect } from "next/navigation"; | ||
| 3 | import type { ReactNode } from "react"; | ||
| 4 | |||
| 5 | import { isWorkosEnabled } from "../../lib/workos"; | ||
| 6 | import { ConsoleShell } from "./console-shell"; | ||
| 7 | |||
| 8 | type ConsoleLayoutProps = { | ||
| 9 | children: ReactNode; | ||
| 10 | }; | ||
| 11 | |||
| 12 | const ConsoleLayout = async ({ children }: ConsoleLayoutProps) => { | ||
| 13 | const authEnabled = isWorkosEnabled(); | ||
| 14 | |||
| 15 | if (authEnabled) { | ||
| 16 | const { user } = await withAuth(); | ||
| 17 | |||
| 18 | if (!user) { | ||
| 19 | redirect("/sign-in"); | ||
| 20 | } | ||
| 21 | |||
| 22 | return ( | ||
| 23 | <ConsoleShell | ||
| 24 | authEnabled | ||
| 25 | initialWorkspaceId={`ws_${user.id}`} | ||
| 26 | > | ||
| 27 | {children} | ||
| 28 | </ConsoleShell> | ||
| 29 | ); | ||
| 30 | } | ||
| 31 | |||
| 32 | return ( | ||
| 33 | <ConsoleShell | ||
| 34 | authEnabled={false} | ||
| 35 | initialWorkspaceId="ws_demo" | ||
| 36 | > | ||
| 37 | {children} | ||
| 38 | </ConsoleShell> | ||
| 39 | ); | ||
| 40 | }; | ||
| 41 | |||
| 42 | export default ConsoleLayout; | ||
| @@ -0,0 +1,5 @@ | |||
| 1 | import { PoliciesView } from "../../../components/policies/policies-view"; | ||
| 2 | |||
| 3 | const PoliciesPage = () => <PoliciesView />; | ||
| 4 | |||
| 5 | export default PoliciesPage; | ||
| @@ -0,0 +1,5 @@ | |||
| 1 | import SettingsView from "../../../components/settings/settings-view"; | ||
| 2 | |||
| 3 | const SettingsPage = () => <SettingsView />; | ||
| 4 | |||
| 5 | export default SettingsPage; | ||
| @@ -0,0 +1,5 @@ | |||
| 1 | import StorageView from "../../../components/storage/storage-view"; | ||
| 2 | |||
| 3 | const StoragePage = () => <StorageView />; | ||
| 4 | |||
| 5 | export default StoragePage; | ||
| @@ -0,0 +1,28 @@ | |||
| 1 | import { ToolsView } from "../../../components/tools/tools-view"; | ||
| 2 | |||
| 3 | const resolveMcpBaseUrl = (): string | null => { | ||
| 4 | const candidates = [ | ||
| 5 | process.env.CONTROL_PLANE_UPSTREAM_URL, | ||
| 6 | process.env.CONTROL_PLANE_SERVER_BASE_URL, | ||
| 7 | process.env.NEXT_PUBLIC_CONTROL_PLANE_BASE_URL, | ||
| 8 | ]; | ||
| 9 | |||
| 10 | for (const candidate of candidates) { | ||
| 11 | const value = candidate?.trim(); | ||
| 12 | if (!value) { | ||
| 13 | continue; | ||
| 14 | } | ||
| 15 | |||
| 16 | try { | ||
| 17 | return new URL(value).origin; | ||
| 18 | } catch { | ||
| 19 | // ignore invalid URL and continue | ||
| 20 | } | ||
| 21 | } | ||
| 22 | |||
| 23 | return null; | ||
| 24 | }; | ||
| 25 | |||
| 26 | const ToolsPage = () => <ToolsView mcpBaseUrl={resolveMcpBaseUrl()} />; | ||
| 27 | |||
| 28 | export default ToolsPage; | ||
| @@ -0,0 +1,11 @@ | |||
| 1 | import type { NextRequest } from "next/server"; | ||
| 2 | import { handleAuth } from "@workos-inc/authkit-nextjs"; | ||
| 3 | |||
| 4 | import { externalOriginFromRequest } from "../../lib/workos"; | ||
| 5 | |||
| 6 | export async function GET(request: NextRequest): Promise<Response> { | ||
| 7 | return handleAuth({ | ||
| 8 | baseURL: externalOriginFromRequest(request), | ||
| 9 | returnPathname: "/", | ||
| 10 | })(request); | ||
| 11 | } | ||
| @@ -0,0 +1,127 @@ | |||
| 1 | @import "tailwindcss"; | ||
| 2 | @import "tw-animate-css"; | ||
| 3 | |||
| 4 | @custom-variant dark (&:is(.dark *)); | ||
| 5 | |||
| 6 | @theme inline { | ||
| 7 | --font-sans: var(--font-body), "IBM Plex Sans", ui-sans-serif, sans-serif; | ||
| 8 | --font-mono: "IBM Plex Mono", ui-monospace, monospace; | ||
| 9 | --font-display: var(--font-display), "Fraunces", serif; | ||
| 10 | |||
| 11 | --color-background: var(--background); | ||
| 12 | --color-foreground: var(--foreground); | ||
| 13 | --color-card: var(--card); | ||
| 14 | --color-card-foreground: var(--card-foreground); | ||
| 15 | --color-popover: var(--popover); | ||
| 16 | --color-popover-foreground: var(--popover-foreground); | ||
| 17 | --color-primary: var(--primary); | ||
| 18 | --color-primary-foreground: var(--primary-foreground); | ||
| 19 | --color-secondary: var(--secondary); | ||
| 20 | --color-secondary-foreground: var(--secondary-foreground); | ||
| 21 | --color-muted: var(--muted); | ||
| 22 | --color-muted-foreground: var(--muted-foreground); | ||
| 23 | --color-accent: var(--accent); | ||
| 24 | --color-accent-foreground: var(--accent-foreground); | ||
| 25 | --color-destructive: var(--destructive); | ||
| 26 | --color-border: var(--border); | ||
| 27 | --color-input: var(--input); | ||
| 28 | --color-ring: var(--ring); | ||
| 29 | |||
| 30 | --color-sidebar: var(--sidebar); | ||
| 31 | --color-sidebar-foreground: var(--sidebar-foreground); | ||
| 32 | --color-sidebar-border: var(--sidebar-border); | ||
| 33 | --color-sidebar-active: var(--sidebar-active); | ||
| 34 | } | ||
| 35 | |||
| 36 | :root { | ||
| 37 | --background: oklch(0.985 0.002 260); | ||
| 38 | --foreground: oklch(0.18 0.01 260); | ||
| 39 | --card: oklch(1 0 0); | ||
| 40 | --card-foreground: oklch(0.18 0.01 260); | ||
| 41 | --popover: oklch(1 0 0); | ||
| 42 | --popover-foreground: oklch(0.18 0.01 260); | ||
| 43 | --primary: oklch(0.45 0.18 155); | ||
| 44 | --primary-foreground: oklch(0.98 0.005 155); | ||
| 45 | --secondary: oklch(0.95 0.005 260); | ||
| 46 | --secondary-foreground: oklch(0.30 0.01 260); | ||
| 47 | --muted: oklch(0.94 0.005 260); | ||
| 48 | --muted-foreground: oklch(0.45 0.01 260); | ||
| 49 | --accent: oklch(0.94 0.008 260); | ||
| 50 | --accent-foreground: oklch(0.18 0.01 260); | ||
| 51 | --destructive: oklch(0.55 0.22 25); | ||
| 52 | --border: oklch(0.88 0.008 260); | ||
| 53 | --input: oklch(0.88 0.008 260); | ||
| 54 | --ring: oklch(0.45 0.18 155); | ||
| 55 | |||
| 56 | --sidebar: oklch(0.97 0.004 260); | ||
| 57 | --sidebar-foreground: oklch(0.30 0.01 260); | ||
| 58 | --sidebar-border: oklch(0.88 0.008 260); | ||
| 59 | --sidebar-active: oklch(0.93 0.01 260); | ||
| 60 | |||
| 61 | --shiki-light: #24292e; | ||
| 62 | --shiki-light-bg: #ffffff; | ||
| 63 | --shiki-dark: #e1e4e8; | ||
| 64 | --shiki-dark-bg: #0d1117; | ||
| 65 | } | ||
| 66 | |||
| 67 | .dark { | ||
| 68 | --background: oklch(0.11 0.005 260); | ||
| 69 | --foreground: oklch(0.88 0.01 250); | ||
| 70 | --card: oklch(0.15 0.005 260); | ||
| 71 | --card-foreground: oklch(0.88 0.01 250); | ||
| 72 | --popover: oklch(0.15 0.005 260); | ||
| 73 | --popover-foreground: oklch(0.88 0.01 250); | ||
| 74 | --primary: oklch(0.75 0.18 155); | ||
| 75 | --primary-foreground: oklch(0.13 0.01 155); | ||
| 76 | --secondary: oklch(0.2 0.008 260); | ||
| 77 | --secondary-foreground: oklch(0.75 0.01 250); | ||
| 78 | --muted: oklch(0.18 0.005 260); | ||
| 79 | --muted-foreground: oklch(0.55 0.01 250); | ||
| 80 | --accent: oklch(0.2 0.01 260); | ||
| 81 | --accent-foreground: oklch(0.88 0.01 250); | ||
| 82 | --destructive: oklch(0.65 0.22 25); | ||
| 83 | --border: oklch(0.24 0.008 260); | ||
| 84 | --input: oklch(0.2 0.008 260); | ||
| 85 | --ring: oklch(0.75 0.18 155); | ||
| 86 | |||
| 87 | --sidebar: oklch(0.13 0.005 260); | ||
| 88 | --sidebar-foreground: oklch(0.75 0.01 250); | ||
| 89 | --sidebar-border: oklch(0.22 0.008 260); | ||
| 90 | --sidebar-active: oklch(0.2 0.01 260); | ||
| 91 | } | ||
| 92 | |||
| 93 | @layer base { | ||
| 94 | * { | ||
| 95 | @apply border-border; | ||
| 96 | } | ||
| 97 | |||
| 98 | html, | ||
| 99 | body { | ||
| 100 | min-height: 100%; | ||
| 101 | } | ||
| 102 | |||
| 103 | body { | ||
| 104 | @apply bg-background font-sans text-foreground antialiased; | ||
| 105 | } | ||
| 106 | } | ||
| 107 | |||
| 108 | [style*="--shiki-light"] { | ||
| 109 | color: var(--shiki-light) !important; | ||
| 110 | background-color: transparent !important; | ||
| 111 | } | ||
| 112 | |||
| 113 | .dark [style*="--shiki-dark"] { | ||
| 114 | color: var(--shiki-dark) !important; | ||
| 115 | background-color: transparent !important; | ||
| 116 | } | ||
| 117 | |||
| 118 | .dark [style*="--shiki-light"] { | ||
| 119 | color: var(--shiki-dark) !important; | ||
| 120 | background-color: transparent !important; | ||
| 121 | } | ||
| 122 | |||
| 123 | [data-streamdown="code-block-body"] { | ||
| 124 | background-color: var(--muted) !important; | ||
| 125 | border: 1px solid var(--border); | ||
| 126 | border-radius: 0.375rem; | ||
| 127 | } | ||
| @@ -0,0 +1,38 @@ | |||
| 1 | import type { Metadata } from "next"; | ||
| 2 | import { Fraunces, IBM_Plex_Sans } from "next/font/google"; | ||
| 3 | import type { ReactNode } from "react"; | ||
| 4 | |||
| 5 | import { Providers } from "./providers"; | ||
| 6 | import "./globals.css"; | ||
| 7 | |||
| 8 | const bodyFont = IBM_Plex_Sans({ | ||
| 9 | subsets: ["latin"], | ||
| 10 | variable: "--font-body", | ||
| 11 | weight: ["400", "500", "600"], | ||
| 12 | }); | ||
| 13 | |||
| 14 | const displayFont = Fraunces({ | ||
| 15 | subsets: ["latin"], | ||
| 16 | variable: "--font-display", | ||
| 17 | weight: ["500", "700"], | ||
| 18 | }); | ||
| 19 | |||
| 20 | export const metadata: Metadata = { | ||
| 21 | title: "Executor v2 Control Plane", | ||
| 22 | description: "Basic Next.js frontend for Executor v2 control plane", | ||
| 23 | }; | ||
| 24 | |||
| 25 | type RootLayoutProps = { | ||
| 26 | children: ReactNode; | ||
| 27 | }; | ||
| 28 | |||
| 29 | const RootLayout = ({ children }: RootLayoutProps) => ( | ||
| 30 | <html lang="en" suppressHydrationWarning className={`${bodyFont.variable} ${displayFont.variable}`}> | ||
| 31 | <body className="antialiased"> | ||
| 32 | <Providers>{children}</Providers> | ||
| 33 | </body> | ||
| 34 | </html> | ||
| 35 | ); | ||
| 36 | |||
| 37 | |||
| 38 | export default RootLayout; | ||
| @@ -0,0 +1,169 @@ | |||
| 1 | import { auth } from "@modelcontextprotocol/sdk/client/auth.js"; | ||
| 2 | import type { NextRequest } from "next/server"; | ||
| 3 | import { NextResponse } from "next/server"; | ||
| 4 | |||
| 5 | import { fetchMcpOAuth } from "../../../../lib/mcp/oauth-fetch"; | ||
| 6 | import { getExternalOrigin, isExternalHttps } from "../../../../lib/mcp/oauth-request"; | ||
| 7 | import { parseMcpSourceUrl } from "../../../../lib/mcp/oauth-url"; | ||
| 8 | import { | ||
| 9 | buildPendingCookieName, | ||
| 10 | decodePendingCookieValue, | ||
| 11 | encodePopupResultCookieValue, | ||
| 12 | MCP_OAUTH_RESULT_COOKIE, | ||
| 13 | McpPopupOAuthProvider, | ||
| 14 | type McpOAuthPopupResult, | ||
| 15 | } from "../../../../lib/mcp/oauth-provider"; | ||
| 16 | |||
| 17 | const MCP_OAUTH_CALLBACK_FLOW_TIMEOUT_MS = 75_000; | ||
| 18 | const MCP_OAUTH_CALLBACK_REQUEST_TIMEOUT_MS = 20_000; | ||
| 19 | |||
| 20 | const withTimeout = async <T>( | ||
| 21 | factory: () => Promise<T>, | ||
| 22 | timeoutMs: number, | ||
| 23 | label: string, | ||
| 24 | ): Promise<T> => | ||
| 25 | await new Promise<T>((resolve, reject) => { | ||
| 26 | const timeoutId = setTimeout(() => { | ||
| 27 | reject(new Error(`${label} timed out after ${timeoutMs}ms`)); | ||
| 28 | }, timeoutMs); | ||
| 29 | |||
| 30 | factory().then( | ||
| 31 | (value) => { | ||
| 32 | clearTimeout(timeoutId); | ||
| 33 | resolve(value); | ||
| 34 | }, | ||
| 35 | (error) => { | ||
| 36 | clearTimeout(timeoutId); | ||
| 37 | reject(error); | ||
| 38 | }, | ||
| 39 | ); | ||
| 40 | }); | ||
| 41 | |||
| 42 | const popupResultRedirect = ( | ||
| 43 | request: NextRequest, | ||
| 44 | pendingCookieName: string | null, | ||
| 45 | payload: McpOAuthPopupResult, | ||
| 46 | ): Response => { | ||
| 47 | const origin = getExternalOrigin(request); | ||
| 48 | const response = NextResponse.redirect(new URL("/mcp/oauth/complete", origin)); | ||
| 49 | |||
| 50 | response.cookies.set({ | ||
| 51 | name: MCP_OAUTH_RESULT_COOKIE, | ||
| 52 | value: encodePopupResultCookieValue(payload), | ||
| 53 | httpOnly: true, | ||
| 54 | secure: isExternalHttps(request), | ||
| 55 | sameSite: "lax", | ||
| 56 | maxAge: 2 * 60, | ||
| 57 | path: "/", | ||
| 58 | }); | ||
| 59 | |||
| 60 | if (pendingCookieName) { | ||
| 61 | response.cookies.set({ | ||
| 62 | name: pendingCookieName, | ||
| 63 | value: "", | ||
| 64 | expires: new Date(0), | ||
| 65 | path: "/", | ||
| 66 | }); | ||
| 67 | } | ||
| 68 | |||
| 69 | return response; | ||
| 70 | }; | ||
| 71 | |||
| 72 | const toErrorMessage = (error: unknown, fallback: string): string => | ||
| 73 | error instanceof Error ? error.message : fallback; | ||
| 74 | |||
| 75 | export async function GET(request: NextRequest): Promise<Response> { | ||
| 76 | const code = request.nextUrl.searchParams.get("code")?.trim() ?? ""; | ||
| 77 | const state = request.nextUrl.searchParams.get("state")?.trim() ?? ""; | ||
| 78 | const oauthError = request.nextUrl.searchParams.get("error")?.trim() ?? ""; | ||
| 79 | |||
| 80 | if (!state) { | ||
| 81 | return popupResultRedirect(request, null, { | ||
| 82 | ok: false, | ||
| 83 | error: "Missing OAuth state", | ||
| 84 | }); | ||
| 85 | } | ||
| 86 | |||
| 87 | const pendingCookieName = buildPendingCookieName(state); | ||
| 88 | const rawPending = request.cookies.get(pendingCookieName)?.value ?? ""; | ||
| 89 | const pending = rawPending ? decodePendingCookieValue(rawPending) : null; | ||
| 90 | |||
| 91 | if (!pending) { | ||
| 92 | return popupResultRedirect(request, pendingCookieName, { | ||
| 93 | ok: false, | ||
| 94 | error: "OAuth session expired. Try connecting again.", | ||
| 95 | }); | ||
| 96 | } | ||
| 97 | |||
| 98 | if (oauthError.length > 0) { | ||
| 99 | return popupResultRedirect(request, pendingCookieName, { | ||
| 100 | ok: false, | ||
| 101 | error: `OAuth error: ${oauthError}`, | ||
| 102 | }); | ||
| 103 | } | ||
| 104 | |||
| 105 | if (code.length === 0) { | ||
| 106 | return popupResultRedirect(request, pendingCookieName, { | ||
| 107 | ok: false, | ||
| 108 | error: "Missing OAuth authorization code", | ||
| 109 | }); | ||
| 110 | } | ||
| 111 | |||
| 112 | let sourceUrl: URL; | ||
| 113 | try { | ||
| 114 | sourceUrl = parseMcpSourceUrl(pending.sourceUrl); | ||
| 115 | } catch { | ||
| 116 | return popupResultRedirect(request, pendingCookieName, { | ||
| 117 | ok: false, | ||
| 118 | error: "Invalid MCP source URL", | ||
| 119 | }); | ||
| 120 | } | ||
| 121 | |||
| 122 | const provider = new McpPopupOAuthProvider({ | ||
| 123 | redirectUrl: pending.redirectUrl, | ||
| 124 | state: pending.state, | ||
| 125 | codeVerifier: pending.codeVerifier, | ||
| 126 | clientInformation: pending.clientInformation, | ||
| 127 | }); | ||
| 128 | |||
| 129 | try { | ||
| 130 | await withTimeout( | ||
| 131 | () => | ||
| 132 | auth(provider, { | ||
| 133 | serverUrl: sourceUrl, | ||
| 134 | authorizationCode: code, | ||
| 135 | fetchFn: (input, init) => | ||
| 136 | fetchMcpOAuth(input, init ?? {}, { | ||
| 137 | timeoutMs: MCP_OAUTH_CALLBACK_REQUEST_TIMEOUT_MS, | ||
| 138 | label: "OAuth callback request", | ||
| 139 | }), | ||
| 140 | }), | ||
| 141 | MCP_OAUTH_CALLBACK_FLOW_TIMEOUT_MS, | ||
| 142 | "OAuth callback", | ||
| 143 | ); | ||
| 144 | } catch (error) { | ||
| 145 | return popupResultRedirect(request, pendingCookieName, { | ||
| 146 | ok: false, | ||
| 147 | error: toErrorMessage(error, "Failed to finish OAuth"), | ||
| 148 | }); | ||
| 149 | } | ||
| 150 | |||
| 151 | const tokens = provider.getTokens(); | ||
| 152 | const accessToken = tokens?.access_token?.trim() ?? ""; | ||
| 153 | |||
| 154 | if (accessToken.length === 0) { | ||
| 155 | return popupResultRedirect(request, pendingCookieName, { | ||
| 156 | ok: false, | ||
| 157 | error: "OAuth completed without an access token", | ||
| 158 | }); | ||
| 159 | } | ||
| 160 | |||
| 161 | return popupResultRedirect(request, pendingCookieName, { | ||
| 162 | ok: true, | ||
| 163 | sourceUrl: pending.sourceUrl, | ||
| 164 | accessToken, | ||
| 165 | refreshToken: tokens?.refresh_token, | ||
| 166 | scope: tokens?.scope, | ||
| 167 | expiresIn: typeof tokens?.expires_in === "number" ? tokens.expires_in : undefined, | ||
| 168 | }); | ||
| 169 | } | ||
| @@ -0,0 +1,86 @@ | |||
| 1 | "use client"; | ||
| 2 | |||
| 3 | import { useEffect, useRef, useState } from "react"; | ||
| 4 | |||
| 5 | type PopupMessage = | ||
| 6 | | { | ||
| 7 | type: "executor-v2:mcp-oauth-result"; | ||
| 8 | ok: true; | ||
| 9 | sourceUrl: string; | ||
| 10 | payload: { | ||
| 11 | accessToken: string; | ||
| 12 | refreshToken?: string; | ||
| 13 | scope?: string; | ||
| 14 | expiresIn?: number; | ||
| 15 | }; | ||
| 16 | } | ||
| 17 | | { | ||
| 18 | type: "executor-v2:mcp-oauth-result"; | ||
| 19 | ok: false; | ||
| 20 | error: string; | ||
| 21 | }; | ||
| 22 | |||
| 23 | const fallbackErrorMessage = (error: unknown): PopupMessage => ({ | ||
| 24 | type: "executor-v2:mcp-oauth-result", | ||
| 25 | ok: false, | ||
| 26 | error: error instanceof Error ? error.message : "Failed to finalize OAuth", | ||
| 27 | }); | ||
| 28 | |||
| 29 | const fetchPopupResult = async (): Promise<PopupMessage> => { | ||
| 30 | const response = await fetch("/mcp/oauth/result", { | ||
| 31 | method: "GET", | ||
| 32 | cache: "no-store", | ||
| 33 | credentials: "same-origin", | ||
| 34 | }); | ||
| 35 | |||
| 36 | const data = (await response.json()) as PopupMessage; | ||
| 37 | if (!data || data.type !== "executor-v2:mcp-oauth-result") { | ||
| 38 | throw new Error("Invalid OAuth completion payload"); | ||
| 39 | } | ||
| 40 | |||
| 41 | return data; | ||
| 42 | }; | ||
| 43 | |||
| 44 | export default function McpOAuthCompletePage() { | ||
| 45 | const sentRef = useRef(false); | ||
| 46 | const [statusText, setStatusText] = useState("Finishing OAuth"); | ||
| 47 | |||
| 48 | useEffect(() => { | ||
| 49 | if (sentRef.current) { | ||
| 50 | return; | ||
| 51 | } | ||
| 52 | |||
| 53 | sentRef.current = true; | ||
| 54 | |||
| 55 | void fetchPopupResult() | ||
| 56 | .then((message) => { | ||
| 57 | setStatusText("OAuth complete"); | ||
| 58 | |||
| 59 | if (window.opener) { | ||
| 60 | window.opener.postMessage(message, window.location.origin); | ||
| 61 | } | ||
| 62 | }) | ||
| 63 | .catch((error) => { | ||
| 64 | const message = fallbackErrorMessage(error); | ||
| 65 | setStatusText("OAuth failed"); | ||
| 66 | |||
| 67 | if (window.opener) { | ||
| 68 | window.opener.postMessage(message, window.location.origin); | ||
| 69 | } | ||
| 70 | }) | ||
| 71 | .finally(() => { | ||
| 72 | window.close(); | ||
| 73 | }); | ||
| 74 | }, []); | ||
| 75 | |||
| 76 | return ( | ||
| 77 | <main className="min-h-screen flex items-center justify-center bg-background p-6"> | ||
| 78 | <div className="text-center space-y-2"> | ||
| 79 | <h1 className="text-base font-medium">{statusText}</h1> | ||
| 80 | <p className="text-sm text-muted-foreground"> | ||
| 81 | You can close this window if it does not close automatically. | ||
| 82 | </p> | ||
| 83 | </div> | ||
| 84 | </main> | ||
| 85 | ); | ||
| 86 | } | ||
| @@ -0,0 +1,178 @@ | |||
| 1 | import { discoverOAuthProtectedResourceMetadata, extractWWWAuthenticateParams } from "@modelcontextprotocol/sdk/client/auth.js"; | ||
| 2 | import { LATEST_PROTOCOL_VERSION } from "@modelcontextprotocol/sdk/types.js"; | ||
| 3 | |||
| 4 | import { fetchMcpOAuth } from "../../../../lib/mcp/oauth-fetch"; | ||
| 5 | import { parseMcpSourceUrl } from "../../../../lib/mcp/oauth-url"; | ||
| 6 | |||
| 7 | type DetectResponse = { | ||
| 8 | oauth: boolean; | ||
| 9 | authorizationServers: Array<string>; | ||
| 10 | detail?: string; | ||
| 11 | }; | ||
| 12 | |||
| 13 | const MCP_OAUTH_CHALLENGE_PROBE_TIMEOUT_MS = 2_500; | ||
| 14 | const MCP_OAUTH_METADATA_TIMEOUT_MS = 12_000; | ||
| 15 | |||
| 16 | const noStoreDetectJson = (payload: DetectResponse, status = 200): Response => | ||
| 17 | Response.json(payload, { | ||
| 18 | status, | ||
| 19 | headers: { | ||
| 20 | "cache-control": "no-store", | ||
| 21 | }, | ||
| 22 | }); | ||
| 23 | |||
| 24 | const withTimeout = async <T>( | ||
| 25 | factory: () => Promise<T>, | ||
| 26 | timeoutMs: number, | ||
| 27 | label: string, | ||
| 28 | ): Promise<T> => | ||
| 29 | await new Promise<T>((resolve, reject) => { | ||
| 30 | const timeoutId = setTimeout(() => { | ||
| 31 | reject(new Error(`${label} timed out after ${timeoutMs}ms`)); | ||
| 32 | }, timeoutMs); | ||
| 33 | |||
| 34 | factory().then( | ||
| 35 | (value) => { | ||
| 36 | clearTimeout(timeoutId); | ||
| 37 | resolve(value); | ||
| 38 | }, | ||
| 39 | (error) => { | ||
| 40 | clearTimeout(timeoutId); | ||
| 41 | reject(error); | ||
| 42 | }, | ||
| 43 | ); | ||
| 44 | }); | ||
| 45 | |||
| 46 | const probeOAuthChallenge = async (sourceUrl: URL): Promise<boolean> => { | ||
| 47 | const response = await fetchMcpOAuth( | ||
| 48 | sourceUrl, | ||
| 49 | { | ||
| 50 | method: "POST", | ||
| 51 | headers: { | ||
| 52 | "content-type": "application/json", | ||
| 53 | accept: "application/json, text/event-stream", | ||
| 54 | "mcp-protocol-version": LATEST_PROTOCOL_VERSION, | ||
| 55 | }, | ||
| 56 | body: JSON.stringify({ | ||
| 57 | jsonrpc: "2.0", | ||
| 58 | id: "oauth-detect", | ||
| 59 | method: "initialize", | ||
| 60 | params: { | ||
| 61 | protocolVersion: LATEST_PROTOCOL_VERSION, | ||
| 62 | capabilities: {}, | ||
| 63 | clientInfo: { | ||
| 64 | name: "Executor v2 OAuth Detector", | ||
| 65 | version: "1.0.0", | ||
| 66 | }, | ||
| 67 | }, | ||
| 68 | }), | ||
| 69 | }, | ||
| 70 | { | ||
| 71 | timeoutMs: MCP_OAUTH_CHALLENGE_PROBE_TIMEOUT_MS, | ||
| 72 | label: "OAuth challenge probe", | ||
| 73 | }, | ||
| 74 | ); | ||
| 75 | |||
| 76 | const hasBearerChallenge = /^Bearer\s/i.test( | ||
| 77 | response.headers.get("WWW-Authenticate") ?? "", | ||
| 78 | ); | ||
| 79 | const challenge = extractWWWAuthenticateParams(response); | ||
| 80 | |||
| 81 | await response.body?.cancel(); | ||
| 82 | |||
| 83 | if ((response.status === 401 || response.status === 403) && hasBearerChallenge) { | ||
| 84 | return true; | ||
| 85 | } | ||
| 86 | |||
| 87 | return Boolean(challenge.resourceMetadataUrl); | ||
| 88 | }; | ||
| 89 | |||
| 90 | const toErrorDetail = (error: unknown, fallback: string): string => | ||
| 91 | error instanceof Error ? error.message : fallback; | ||
| 92 | |||
| 93 | export async function GET(request: Request): Promise<Response> { | ||
| 94 | const requestUrl = new URL(request.url); | ||
| 95 | const sourceUrlRaw = requestUrl.searchParams.get("sourceUrl")?.trim() ?? ""; | ||
| 96 | |||
| 97 | if (!sourceUrlRaw) { | ||
| 98 | return noStoreDetectJson( | ||
| 99 | { | ||
| 100 | oauth: false, | ||
| 101 | authorizationServers: [], | ||
| 102 | detail: "Missing sourceUrl", | ||
| 103 | }, | ||
| 104 | 400, | ||
| 105 | ); | ||
| 106 | } | ||
| 107 | |||
| 108 | let sourceUrl: URL; | ||
| 109 | try { | ||
| 110 | sourceUrl = parseMcpSourceUrl(sourceUrlRaw); | ||
| 111 | } catch (error) { | ||
| 112 | return noStoreDetectJson( | ||
| 113 | { | ||
| 114 | oauth: false, | ||
| 115 | authorizationServers: [], | ||
| 116 | detail: toErrorDetail(error, "Invalid sourceUrl"), | ||
| 117 | }, | ||
| 118 | 400, | ||
| 119 | ); | ||
| 120 | } | ||
| 121 | |||
| 122 | try { | ||
| 123 | const oauthByChallenge = await probeOAuthChallenge(sourceUrl); | ||
| 124 | if (oauthByChallenge) { | ||
| 125 | return noStoreDetectJson({ | ||
| 126 | oauth: true, | ||
| 127 | authorizationServers: [], | ||
| 128 | detail: "OAuth detected from endpoint challenge", | ||
| 129 | }); | ||
| 130 | } | ||
| 131 | } catch { | ||
| 132 | // Continue to metadata discovery. | ||
| 133 | } | ||
| 134 | |||
| 135 | let metadata: unknown; | ||
| 136 | try { | ||
| 137 | metadata = await withTimeout( | ||
| 138 | () => | ||
| 139 | discoverOAuthProtectedResourceMetadata( | ||
| 140 | sourceUrl, | ||
| 141 | undefined, | ||
| 142 | (input, init) => | ||
| 143 | fetchMcpOAuth(input, init ?? {}, { | ||
| 144 | timeoutMs: MCP_OAUTH_METADATA_TIMEOUT_MS, | ||
| 145 | label: "OAuth metadata lookup", | ||
| 146 | }), | ||
| 147 | ), | ||
| 148 | MCP_OAUTH_METADATA_TIMEOUT_MS, | ||
| 149 | "OAuth metadata lookup", | ||
| 150 | ); | ||
| 151 | } catch (error) { | ||
| 152 | return noStoreDetectJson( | ||
| 153 | { | ||
| 154 | oauth: false, | ||
| 155 | authorizationServers: [], | ||
| 156 | detail: toErrorDetail(error, "OAuth metadata lookup failed"), | ||
| 157 | }, | ||
| 158 | 502, | ||
| 159 | ); | ||
| 160 | } | ||
| 161 | |||
| 162 | const authorizationServersRaw = | ||
| 163 | metadata && typeof metadata === "object" && !Array.isArray(metadata) | ||
| 164 | ? (metadata as { authorization_servers?: unknown }).authorization_servers | ||
| 165 | : undefined; | ||
| 166 | |||
| 167 | const authorizationServers = Array.isArray(authorizationServersRaw) | ||
| 168 | ? authorizationServersRaw | ||
| 169 | .filter((entry): entry is string => typeof entry === "string") | ||
| 170 | .map((entry) => entry.trim()) | ||
| 171 | .filter((entry) => entry.length > 0) | ||
| 172 | : []; | ||
| 173 | |||
| 174 | return noStoreDetectJson({ | ||
| 175 | oauth: authorizationServers.length > 0, | ||
| 176 | authorizationServers, | ||
| 177 | }); | ||
| 178 | } | ||
| @@ -0,0 +1,89 @@ | |||
| 1 | import type { NextRequest } from "next/server"; | ||
| 2 | import { NextResponse } from "next/server"; | ||
| 3 | |||
| 4 | import { | ||
| 5 | decodePopupResultCookieValue, | ||
| 6 | MCP_OAUTH_RESULT_COOKIE, | ||
| 7 | type McpOAuthPopupResult, | ||
| 8 | } from "../../../../lib/mcp/oauth-provider"; | ||
| 9 | |||
| 10 | type PopupMessage = | ||
| 11 | | { | ||
| 12 | type: "executor-v2:mcp-oauth-result"; | ||
| 13 | ok: true; | ||
| 14 | sourceUrl: string; | ||
| 15 | payload: { | ||
| 16 | accessToken: string; | ||
| 17 | refreshToken?: string; | ||
| 18 | scope?: string; | ||
| 19 | expiresIn?: number; | ||
| 20 | }; | ||
| 21 | } | ||
| 22 | | { | ||
| 23 | type: "executor-v2:mcp-oauth-result"; | ||
| 24 | ok: false; | ||
| 25 | error: string; | ||
| 26 | }; | ||
| 27 | |||
| 28 | const toPopupMessage = (result: McpOAuthPopupResult | null): PopupMessage => { | ||
| 29 | if (!result) { | ||
| 30 | return { | ||
| 31 | type: "executor-v2:mcp-oauth-result", | ||
| 32 | ok: false, | ||
| 33 | error: "OAuth result is missing or expired", | ||
| 34 | }; | ||
| 35 | } | ||
| 36 | |||
| 37 | if (!result.ok) { | ||
| 38 | return { | ||
| 39 | type: "executor-v2:mcp-oauth-result", | ||
| 40 | ok: false, | ||
| 41 | error: result.error ?? "OAuth failed", | ||
| 42 | }; | ||
| 43 | } | ||
| 44 | |||
| 45 | const accessToken = result.accessToken?.trim() ?? ""; | ||
| 46 | if (accessToken.length === 0) { | ||
| 47 | return { | ||
| 48 | type: "executor-v2:mcp-oauth-result", | ||
| 49 | ok: false, | ||
| 50 | error: "OAuth finished without an access token", | ||
| 51 | }; | ||
| 52 | } | ||
| 53 | |||
| 54 | return { | ||
| 55 | type: "executor-v2:mcp-oauth-result", | ||
| 56 | ok: true, | ||
| 57 | sourceUrl: result.sourceUrl ?? "", | ||
| 58 | payload: { | ||
| 59 | accessToken, | ||
| 60 | ...(result.refreshToken ? { refreshToken: result.refreshToken } : {}), | ||
| 61 | ...(result.scope ? { scope: result.scope } : {}), | ||
| 62 | ...(typeof result.expiresIn === "number" | ||
| 63 | ? { expiresIn: result.expiresIn } | ||
| 64 | : {}), | ||
| 65 | }, | ||
| 66 | }; | ||
| 67 | }; | ||
| 68 | |||
| 69 | export async function GET(request: NextRequest): Promise<Response> { | ||
| 70 | const encoded = request.cookies.get(MCP_OAUTH_RESULT_COOKIE)?.value ?? ""; | ||
| 71 | const parsed = encoded ? decodePopupResultCookieValue(encoded) : null; | ||
| 72 | const message = toPopupMessage(parsed); | ||
| 73 | |||
| 74 | const response = NextResponse.json(message, { | ||
| 75 | status: message.ok ? 200 : 400, | ||
| 76 | headers: { | ||
| 77 | "cache-control": "no-store", | ||
| 78 | }, | ||
| 79 | }); | ||
| 80 | |||
| 81 | response.cookies.set({ | ||
| 82 | name: MCP_OAUTH_RESULT_COOKIE, | ||
| 83 | value: "", | ||
| 84 | expires: new Date(0), | ||
| 85 | path: "/", | ||
| 86 | }); | ||
| 87 | |||
| 88 | return response; | ||
| 89 | } | ||
| @@ -0,0 +1,152 @@ | |||
| 1 | import { auth } from "@modelcontextprotocol/sdk/client/auth.js"; | ||
| 2 | import type { NextRequest } from "next/server"; | ||
| 3 | import { NextResponse } from "next/server"; | ||
| 4 | |||
| 5 | import { fetchMcpOAuth } from "../../../../lib/mcp/oauth-fetch"; | ||
| 6 | import { getExternalOrigin, isExternalHttps } from "../../../../lib/mcp/oauth-request"; | ||
| 7 | import { parseMcpSourceUrl } from "../../../../lib/mcp/oauth-url"; | ||
| 8 | import { | ||
| 9 | buildPendingCookieName, | ||
| 10 | createOAuthState, | ||
| 11 | encodePendingCookieValue, | ||
| 12 | encodePopupResultCookieValue, | ||
| 13 | MCP_OAUTH_RESULT_COOKIE, | ||
| 14 | McpPopupOAuthProvider, | ||
| 15 | type McpOAuthPopupResult, | ||
| 16 | } from "../../../../lib/mcp/oauth-provider"; | ||
| 17 | |||
| 18 | const MCP_OAUTH_FLOW_TIMEOUT_MS = 75_000; | ||
| 19 | const MCP_OAUTH_REQUEST_TIMEOUT_MS = 20_000; | ||
| 20 | |||
| 21 | const withTimeout = async <T>( | ||
| 22 | factory: () => Promise<T>, | ||
| 23 | timeoutMs: number, | ||
| 24 | label: string, | ||
| 25 | ): Promise<T> => | ||
| 26 | await new Promise<T>((resolve, reject) => { | ||
| 27 | const timeoutId = setTimeout(() => { | ||
| 28 | reject(new Error(`${label} timed out after ${timeoutMs}ms`)); | ||
| 29 | }, timeoutMs); | ||
| 30 | |||
| 31 | factory().then( | ||
| 32 | (value) => { | ||
| 33 | clearTimeout(timeoutId); | ||
| 34 | resolve(value); | ||
| 35 | }, | ||
| 36 | (error) => { | ||
| 37 | clearTimeout(timeoutId); | ||
| 38 | reject(error); | ||
| 39 | }, | ||
| 40 | ); | ||
| 41 | }); | ||
| 42 | |||
| 43 | const popupResultRedirect = ( | ||
| 44 | request: NextRequest, | ||
| 45 | payload: McpOAuthPopupResult, | ||
| 46 | ): Response => { | ||
| 47 | const origin = getExternalOrigin(request); | ||
| 48 | const response = NextResponse.redirect(new URL("/mcp/oauth/complete", origin)); | ||
| 49 | |||
| 50 | response.cookies.set({ | ||
| 51 | name: MCP_OAUTH_RESULT_COOKIE, | ||
| 52 | value: encodePopupResultCookieValue(payload), | ||
| 53 | httpOnly: true, | ||
| 54 | secure: isExternalHttps(request), | ||
| 55 | sameSite: "lax", | ||
| 56 | maxAge: 2 * 60, | ||
| 57 | path: "/", | ||
| 58 | }); | ||
| 59 | |||
| 60 | return response; | ||
| 61 | }; | ||
| 62 | |||
| 63 | const badPopupResponse = (request: NextRequest, message: string): Response => | ||
| 64 | popupResultRedirect(request, { ok: false, error: message }); | ||
| 65 | |||
| 66 | const toErrorMessage = (error: unknown, fallback: string): string => | ||
| 67 | error instanceof Error ? error.message : fallback; | ||
| 68 | |||
| 69 | export async function GET(request: NextRequest): Promise<Response> { | ||
| 70 | const sourceUrlRaw = request.nextUrl.searchParams.get("sourceUrl")?.trim() ?? ""; | ||
| 71 | if (sourceUrlRaw.length === 0) { | ||
| 72 | return badPopupResponse(request, "Missing sourceUrl"); | ||
| 73 | } | ||
| 74 | |||
| 75 | let sourceUrl: URL; | ||
| 76 | try { | ||
| 77 | sourceUrl = parseMcpSourceUrl(sourceUrlRaw); | ||
| 78 | } catch (error) { | ||
| 79 | return badPopupResponse(request, toErrorMessage(error, "Invalid sourceUrl")); | ||
| 80 | } | ||
| 81 | |||
| 82 | const state = createOAuthState(); | ||
| 83 | const redirectUrl = `${getExternalOrigin(request)}/mcp/oauth/callback`; | ||
| 84 | const provider = new McpPopupOAuthProvider({ | ||
| 85 | redirectUrl, | ||
| 86 | state, | ||
| 87 | }); | ||
| 88 | |||
| 89 | let authResult: "AUTHORIZED" | "REDIRECT"; | ||
| 90 | try { | ||
| 91 | authResult = await withTimeout( | ||
| 92 | () => | ||
| 93 | auth(provider, { | ||
| 94 | serverUrl: sourceUrl, | ||
| 95 | fetchFn: (input, init) => | ||
| 96 | fetchMcpOAuth(input, init ?? {}, { | ||
| 97 | timeoutMs: MCP_OAUTH_REQUEST_TIMEOUT_MS, | ||
| 98 | label: "OAuth startup request", | ||
| 99 | }), | ||
| 100 | }), | ||
| 101 | MCP_OAUTH_FLOW_TIMEOUT_MS, | ||
| 102 | "OAuth startup", | ||
| 103 | ); | ||
| 104 | } catch (error) { | ||
| 105 | return badPopupResponse( | ||
| 106 | request, | ||
| 107 | toErrorMessage(error, "Failed to start OAuth flow"), | ||
| 108 | ); | ||
| 109 | } | ||
| 110 | |||
| 111 | if (authResult === "AUTHORIZED") { | ||
| 112 | const tokens = provider.getTokens(); | ||
| 113 | const accessToken = tokens?.access_token?.trim() ?? ""; | ||
| 114 | if (accessToken.length === 0) { | ||
| 115 | return badPopupResponse( | ||
| 116 | request, | ||
| 117 | "OAuth flow completed without an access token", | ||
| 118 | ); | ||
| 119 | } | ||
| 120 | |||
| 121 | return popupResultRedirect(request, { | ||
| 122 | ok: true, | ||
| 123 | sourceUrl: sourceUrl.toString(), | ||
| 124 | accessToken, | ||
| 125 | refreshToken: tokens?.refresh_token, | ||
| 126 | scope: tokens?.scope, | ||
| 127 | expiresIn: | ||
| 128 | typeof tokens?.expires_in === "number" ? tokens.expires_in : undefined, | ||
| 129 | }); | ||
| 130 | } | ||
| 131 | |||
| 132 | const authorizationUrl = provider.getAuthorizationUrl(); | ||
| 133 | if (!authorizationUrl) { | ||
| 134 | return badPopupResponse( | ||
| 135 | request, | ||
| 136 | "Server did not request an OAuth authorization step", | ||
| 137 | ); | ||
| 138 | } | ||
| 139 | |||
| 140 | const response = NextResponse.redirect(authorizationUrl); | ||
| 141 | response.cookies.set({ | ||
| 142 | name: buildPendingCookieName(state), | ||
| 143 | value: encodePendingCookieValue(provider.toPending(sourceUrl.toString())), | ||
| 144 | httpOnly: true, | ||
| 145 | secure: isExternalHttps(request), | ||
| 146 | sameSite: "lax", | ||
| 147 | maxAge: 10 * 60, | ||
| 148 | path: "/", | ||
| 149 | }); | ||
| 150 | |||
| 151 | return response; | ||
| 152 | } | ||
| @@ -0,0 +1,7 @@ | |||
| 1 | import { redirect } from "next/navigation"; | ||
| 2 | |||
| 3 | const Page = () => { | ||
| 4 | redirect("/tools"); | ||
| 5 | }; | ||
| 6 | |||
| 7 | export default Page; | ||
| @@ -0,0 +1,20 @@ | |||
| 1 | "use client"; | ||
| 2 | |||
| 3 | import { RegistryProvider } from "@effect-atom/atom-react"; | ||
| 4 | import { ThemeProvider } from "next-themes"; | ||
| 5 | import type { ReactNode } from "react"; | ||
| 6 | |||
| 7 | type ProvidersProps = { | ||
| 8 | children: ReactNode; | ||
| 9 | }; | ||
| 10 | |||
| 11 | export const Providers = ({ children }: ProvidersProps) => ( | ||
| 12 | <ThemeProvider | ||
| 13 | attribute="class" | ||
| 14 | defaultTheme="dark" | ||
| 15 | enableSystem | ||
| 16 | enableColorScheme | ||
| 17 | > | ||
| 18 | <RegistryProvider>{children}</RegistryProvider> | ||
| 19 | </ThemeProvider> | ||
| 20 | ); | ||
| @@ -0,0 +1,22 @@ | |||
| 1 | import type { NextRequest } from "next/server"; | ||
| 2 | import { NextResponse } from "next/server"; | ||
| 3 | import { getSignInUrl } from "@workos-inc/authkit-nextjs"; | ||
| 4 | |||
| 5 | import { isWorkosEnabled, resolveWorkosRedirectUri } from "../../lib/workos"; | ||
| 6 | |||
| 7 | export async function GET(request: NextRequest): Promise<Response> { | ||
| 8 | if (!isWorkosEnabled()) { | ||
| 9 | return NextResponse.redirect(new URL("/", request.url)); | ||
| 10 | } | ||
| 11 | |||
| 12 | const redirectUri = resolveWorkosRedirectUri(request); | ||
| 13 | if (!redirectUri) { | ||
| 14 | return NextResponse.redirect(new URL("/", request.url)); | ||
| 15 | } | ||
| 16 | |||
| 17 | const signInUrl = await getSignInUrl({ | ||
| 18 | redirectUri, | ||
| 19 | }); | ||
| 20 | |||
| 21 | return NextResponse.redirect(signInUrl); | ||
| 22 | } | ||
| @@ -0,0 +1,17 @@ | |||
| 1 | import type { NextRequest } from "next/server"; | ||
| 2 | import { NextResponse } from "next/server"; | ||
| 3 | import { signOut } from "@workos-inc/authkit-nextjs"; | ||
| 4 | |||
| 5 | import { externalOriginFromRequest, isWorkosEnabled } from "../../lib/workos"; | ||
| 6 | |||
| 7 | export async function GET(request: NextRequest): Promise<Response> { | ||
| 8 | if (!isWorkosEnabled()) { | ||
| 9 | return NextResponse.redirect(new URL("/", request.url)); | ||
| 10 | } | ||
| 11 | |||
| 12 | await signOut({ | ||
| 13 | returnTo: `${externalOriginFromRequest(request)}/`, | ||
| 14 | }); | ||
| 15 | |||
| 16 | return NextResponse.redirect(new URL("/", request.url)); | ||
| 17 | } | ||
| @@ -0,0 +1,20 @@ | |||
| 1 | { | ||
| 2 | "$schema": "https://ui.shadcn.com/schema.json", | ||
| 3 | "style": "new-york", | ||
| 4 | "rsc": true, | ||
| 5 | "tsx": true, | ||
| 6 | "tailwind": { | ||
| 7 | "config": "", | ||
| 8 | "css": "app/globals.css", | ||
| 9 | "baseColor": "neutral", | ||
| 10 | "cssVariables": true, | ||
| 11 | "prefix": "" | ||
| 12 | }, | ||
| 13 | "iconLibrary": "lucide", | ||
| 14 | "aliases": { | ||
| 15 | "components": "./components", | ||
| 16 | "utils": "./lib/utils", | ||
| 17 | "ui": "./components/ui", | ||
| 18 | "lib": "./lib" | ||
| 19 | } | ||
| 20 | } | ||
| @@ -0,0 +1,284 @@ | |||
| 1 | "use client"; | ||
| 2 | |||
| 3 | import { useAtomSet, useAtomValue } from "@effect-atom/atom-react"; | ||
| 4 | import type { Approval, ApprovalId } from "@executor-v2/schema"; | ||
| 5 | import { useMemo, useState } from "react"; | ||
| 6 | |||
| 7 | import { useWorkspace } from "../../lib/hooks/use-workspace"; | ||
| 8 | import { | ||
| 9 | approvalsByWorkspace, | ||
| 10 | optimisticResolveApproval, | ||
| 11 | resolveApproval, | ||
| 12 | } from "../../lib/control-plane/atoms"; | ||
| 13 | import { Button } from "../ui/button"; | ||
| 14 | import { | ||
| 15 | Card, | ||
| 16 | CardContent, | ||
| 17 | CardDescription, | ||
| 18 | CardHeader, | ||
| 19 | CardTitle, | ||
| 20 | } from "../ui/card"; | ||
| 21 | import { Input } from "../ui/input"; | ||
| 22 | import { Select } from "../ui/select"; | ||
| 23 | import { Badge } from "../ui/badge"; | ||
| 24 | import { cn, formatTimestamp } from "../../lib/utils"; | ||
| 25 | import { matchState } from "../shared/match-state"; | ||
| 26 | import { PageHeader } from "../shared/page-header"; | ||
| 27 | import { StatusMessage } from "../shared/status-message"; | ||
| 28 | |||
| 29 | type ApprovalFilterValue = "pending" | "resolved" | "all"; | ||
| 30 | |||
| 31 | const statusBadgeVariant = ( | ||
| 32 | status: Approval["status"], | ||
| 33 | ): "pending" | "approved" | "denied" | "outline" => { | ||
| 34 | if (status === "pending") { | ||
| 35 | return "pending"; | ||
| 36 | } | ||
| 37 | |||
| 38 | if (status === "approved") { | ||
| 39 | return "approved"; | ||
| 40 | } | ||
| 41 | |||
| 42 | if (status === "denied") { | ||
| 43 | return "denied"; | ||
| 44 | } | ||
| 45 | |||
| 46 | return "outline"; | ||
| 47 | }; | ||
| 48 | |||
| 49 | const previewFromInputJson = (inputPreviewJson: string): string => { | ||
| 50 | const trimmed = inputPreviewJson.trim(); | ||
| 51 | |||
| 52 | if (trimmed.length === 0) { | ||
| 53 | return "{}"; | ||
| 54 | } | ||
| 55 | |||
| 56 | try { | ||
| 57 | const parsed = JSON.parse(trimmed) as unknown; | ||
| 58 | const pretty = JSON.stringify(parsed, null, 2); | ||
| 59 | return pretty.length > 640 ? `${pretty.slice(0, 640)}\n...` : pretty; | ||
| 60 | } catch { | ||
| 61 | return trimmed.length > 640 ? `${trimmed.slice(0, 640)}...` : trimmed; | ||
| 62 | } | ||
| 63 | }; | ||
| 64 | |||
| 65 | export function usePendingApprovalCount(): number { | ||
| 66 | const { workspaceId } = useWorkspace(); | ||
| 67 | const approvalsState = useAtomValue(approvalsByWorkspace(workspaceId)); | ||
| 68 | |||
| 69 | return approvalsState.items.filter((approval) => approval.status === "pending").length; | ||
| 70 | } | ||
| 71 | |||
| 72 | export function ApprovalsView() { | ||
| 73 | const { workspaceId } = useWorkspace(); | ||
| 74 | |||
| 75 | const [approvalFilter, setApprovalFilter] = useState<ApprovalFilterValue>("pending"); | ||
| 76 | const [approvalSearchQuery, setApprovalSearchQuery] = useState(""); | ||
| 77 | const [approvalStatusText, setApprovalStatusText] = useState<string | null>(null); | ||
| 78 | const [approvalStatusVariant, setApprovalStatusVariant] = useState<"info" | "error">("info"); | ||
| 79 | const [approvalBusyId, setApprovalBusyId] = useState<ApprovalId | null>(null); | ||
| 80 | const [optimisticApprovals, setOptimisticApprovals] = useState< | ||
| 81 | ReadonlyArray<Approval> | null | ||
| 82 | >(null); | ||
| 83 | |||
| 84 | const approvalsState = useAtomValue(approvalsByWorkspace(workspaceId)); | ||
| 85 | const runResolveApproval = useAtomSet(resolveApproval, { mode: "promise" }); | ||
| 86 | |||
| 87 | const approvalItems = optimisticApprovals ?? approvalsState.items; | ||
| 88 | |||
| 89 | const filteredApprovals = useMemo(() => { | ||
| 90 | const query = approvalSearchQuery.trim().toLowerCase(); | ||
| 91 | |||
| 92 | return approvalItems.filter((approval) => { | ||
| 93 | if (approvalFilter === "pending" && approval.status !== "pending") { | ||
| 94 | return false; | ||
| 95 | } | ||
| 96 | |||
| 97 | if ( | ||
| 98 | approvalFilter === "resolved" && | ||
| 99 | (approval.status === "pending" || approval.status === "expired") | ||
| 100 | ) { | ||
| 101 | return false; | ||
| 102 | } | ||
| 103 | |||
| 104 | if (query.length === 0) { | ||
| 105 | return true; | ||
| 106 | } | ||
| 107 | |||
| 108 | return ( | ||
| 109 | approval.toolPath.toLowerCase().includes(query) || | ||
| 110 | approval.status.toLowerCase().includes(query) || | ||
| 111 | approval.callId.toLowerCase().includes(query) || | ||
| 112 | approval.taskRunId.toLowerCase().includes(query) || | ||
| 113 | (approval.reason ?? "").toLowerCase().includes(query) | ||
| 114 | ); | ||
| 115 | }); | ||
| 116 | }, [approvalFilter, approvalItems, approvalSearchQuery]); | ||
| 117 | |||
| 118 | const setStatus = (message: string | null, variant: "info" | "error" = "info") => { | ||
| 119 | setApprovalStatusText(message); | ||
| 120 | setApprovalStatusVariant(variant); | ||
| 121 | }; | ||
| 122 | |||
| 123 | const handleResolveApproval = (approvalId: ApprovalId, status: "approved" | "denied") => { | ||
| 124 | if (approvalBusyId !== null) { | ||
| 125 | return; | ||
| 126 | } | ||
| 127 | |||
| 128 | setApprovalBusyId(approvalId); | ||
| 129 | |||
| 130 | const nextOptimistic = optimisticResolveApproval(approvalItems, { | ||
| 131 | approvalId, | ||
| 132 | payload: { | ||
| 133 | status, | ||
| 134 | reason: null, | ||
| 135 | }, | ||
| 136 | }); | ||
| 137 | |||
| 138 | setOptimisticApprovals(nextOptimistic); | ||
| 139 | |||
| 140 | void runResolveApproval({ | ||
| 141 | path: { | ||
| 142 | workspaceId, | ||
| 143 | approvalId, | ||
| 144 | }, | ||
| 145 | payload: { | ||
| 146 | status, | ||
| 147 | reason: null, | ||
| 148 | }, | ||
| 149 | }) | ||
| 150 | .then(() => { | ||
| 151 | setStatus(status === "approved" ? "Approval granted." : "Approval denied."); | ||
| 152 | setOptimisticApprovals(null); | ||
| 153 | }) | ||
| 154 | .catch(() => { | ||
| 155 | setStatus("Approval update failed.", "error"); | ||
| 156 | setOptimisticApprovals(null); | ||
| 157 | }) | ||
| 158 | .finally(() => { | ||
| 159 | setApprovalBusyId(null); | ||
| 160 | }); | ||
| 161 | }; | ||
| 162 | |||
| 163 | return ( | ||
| 164 | <section className="mx-auto flex w-full max-w-5xl flex-col gap-4"> | ||
| 165 | <PageHeader title="Approvals" description="Review and resolve tool-call approvals." /> | ||
| 166 | |||
| 167 | <Card className="border-border/70"> | ||
| 168 | <CardHeader className="pb-3"> | ||
| 169 | <CardTitle>Approval Requests</CardTitle> | ||
| 170 | <CardDescription>Manage request status and inspect input previews.</CardDescription> | ||
| 171 | </CardHeader> | ||
| 172 | |||
| 173 | <CardContent className="space-y-4"> | ||
| 174 | <div className="grid gap-3 sm:grid-cols-2"> | ||
| 175 | <div className="grid gap-1.5"> | ||
| 176 | <label className="text-xs text-muted-foreground" htmlFor="approval-filter"> | ||
| 177 | Filter | ||
| 178 | </label> | ||
| 179 | <Select | ||
| 180 | id="approval-filter" | ||
| 181 | value={approvalFilter} | ||
| 182 | onChange={(event) => | ||
| 183 | setApprovalFilter(event.target.value as ApprovalFilterValue) | ||
| 184 | } | ||
| 185 | > | ||
| 186 | <option value="pending">pending</option> | ||
| 187 | <option value="resolved">resolved</option> | ||
| 188 | <option value="all">all</option> | ||
| 189 | </Select> | ||
| 190 | </div> | ||
| 191 | |||
| 192 | <div className="grid gap-1.5"> | ||
| 193 | <label className="text-xs text-muted-foreground" htmlFor="approval-search"> | ||
| 194 | Search | ||
| 195 | </label> | ||
| 196 | <Input | ||
| 197 | id="approval-search" | ||
| 198 | value={approvalSearchQuery} | ||
| 199 | onChange={(event) => { | ||
| 200 | setApprovalSearchQuery(event.target.value); | ||
| 201 | }} | ||
| 202 | placeholder="tool path, status, task run, call id" | ||
| 203 | /> | ||
| 204 | </div> | ||
| 205 | </div> | ||
| 206 | |||
| 207 | <StatusMessage message={approvalStatusText} variant={approvalStatusVariant} /> | ||
| 208 | |||
| 209 | {matchState(approvalsState, { | ||
| 210 | loading: "Loading approvals...", | ||
| 211 | empty: | ||
| 212 | approvalsState.items.length === 0 | ||
| 213 | ? "No approvals found for this workspace." | ||
| 214 | : "No approvals match your filter and search.", | ||
| 215 | filteredCount: filteredApprovals.length, | ||
| 216 | ready: () => ( | ||
| 217 | <div className="space-y-2"> | ||
| 218 | {filteredApprovals.map((approval) => { | ||
| 219 | const isBusy = approvalBusyId === approval.id; | ||
| 220 | const canResolve = approval.status === "pending"; | ||
| 221 | |||
| 222 | return ( | ||
| 223 | <article | ||
| 224 | key={approval.id} | ||
| 225 | className={cn( | ||
| 226 | "rounded-lg border border-border bg-background/70 p-3", | ||
| 227 | isBusy && "opacity-80", | ||
| 228 | )} | ||
| 229 | > | ||
| 230 | <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between"> | ||
| 231 | <div className="min-w-0 space-y-1"> | ||
| 232 | <p className="break-all text-sm font-medium">{approval.toolPath}</p> | ||
| 233 | <div className="flex flex-wrap items-center gap-1.5 text-xs text-muted-foreground"> | ||
| 234 | <Badge variant={statusBadgeVariant(approval.status)}>{approval.status}</Badge> | ||
| 235 | <span>requested {formatTimestamp(approval.requestedAt)}</span> | ||
| 236 | <span>resolved {formatTimestamp(approval.resolvedAt)}</span> | ||
| 237 | </div> | ||
| 238 | <p className="break-all text-xs text-muted-foreground">task {approval.taskRunId}</p> | ||
| 239 | <p className="break-all text-xs text-muted-foreground">call {approval.callId}</p> | ||
| 240 | {approval.reason ? ( | ||
| 241 | <p className="break-all text-xs text-muted-foreground"> | ||
| 242 | reason: {approval.reason} | ||
| 243 | </p> | ||
| 244 | ) : null} | ||
| 245 | </div> | ||
| 246 | |||
| 247 | {canResolve ? ( | ||
| 248 | <div className="flex items-center gap-2"> | ||
| 249 | <Button | ||
| 250 | type="button" | ||
| 251 | size="sm" | ||
| 252 | variant="outline" | ||
| 253 | onClick={() => handleResolveApproval(approval.id, "approved")} | ||
| 254 | disabled={isBusy} | ||
| 255 | > | ||
| 256 | {isBusy ? "Working..." : "Approve"} | ||
| 257 | </Button> | ||
| 258 | <Button | ||
| 259 | type="button" | ||
| 260 | size="sm" | ||
| 261 | variant="destructive" | ||
| 262 | onClick={() => handleResolveApproval(approval.id, "denied")} | ||
| 263 | disabled={isBusy} | ||
| 264 | > | ||
| 265 | {isBusy ? "Working..." : "Deny"} | ||
| 266 | </Button> | ||
| 267 | </div> | ||
| 268 | ) : null} | ||
| 269 | </div> | ||
| 270 | |||
| 271 | <pre className="mt-3 max-h-56 overflow-auto rounded-md border border-border bg-muted/45 p-3 text-[11px] leading-5 text-muted-foreground"> | ||
| 272 | {previewFromInputJson(approval.inputPreviewJson)} | ||
| 273 | </pre> | ||
| 274 | </article> | ||
| 275 | ); | ||
| 276 | })} | ||
| 277 | </div> | ||
| 278 | ), | ||
| 279 | })} | ||
| 280 | </CardContent> | ||
| 281 | </Card> | ||
| 282 | </section> | ||
| 283 | ); | ||
| 284 | } | ||
| @@ -0,0 +1,520 @@ | |||
| 1 | "use client"; | ||
| 2 | |||
| 3 | import { useMemo, useState, type FormEvent } from "react"; | ||
| 4 | import { | ||
| 5 | useAtomSet, | ||
| 6 | useAtomValue, | ||
| 7 | } from "@effect-atom/atom-react"; | ||
| 8 | |||
| 9 | import { useWorkspace } from "../../lib/hooks/use-workspace"; | ||
| 10 | import { | ||
| 11 | credentialBindingsByWorkspace, | ||
| 12 | removeCredentialBinding, | ||
| 13 | toCredentialBindingRemoveResult, | ||
| 14 | toCredentialBindingUpsertPayload, | ||
| 15 | upsertCredentialBinding, | ||
| 16 | } from "../../lib/control-plane/atoms"; | ||
| 17 | import type { | ||
| 18 | CredentialProvider, | ||
| 19 | CredentialScopeType, | ||
| 20 | SourceCredentialBinding, | ||
| 21 | } from "@executor-v2/schema"; | ||
| 22 | |||
| 23 | import { Badge } from "../ui/badge"; | ||
| 24 | import { Button } from "../ui/button"; | ||
| 25 | import { Card, CardContent, CardHeader } from "../ui/card"; | ||
| 26 | import { Input } from "../ui/input"; | ||
| 27 | import { Select } from "../ui/select"; | ||
| 28 | import { matchState } from "../shared/match-state"; | ||
| 29 | import { PageHeader } from "../shared/page-header"; | ||
| 30 | import { StatusMessage } from "../shared/status-message"; | ||
| 31 | import { cn, createLocalId } from "../../lib/utils"; | ||
| 32 | |||
| 33 | const providerOptions: ReadonlyArray<CredentialProvider> = [ | ||
| 34 | "api_key", | ||
| 35 | "bearer", | ||
| 36 | "oauth2", | ||
| 37 | "custom", | ||
| 38 | ]; | ||
| 39 | |||
| 40 | const scopeTypeOptions: ReadonlyArray<CredentialScopeType> = [ | ||
| 41 | "workspace", | ||
| 42 | "organization", | ||
| 43 | "account", | ||
| 44 | ]; | ||
| 45 | |||
| 46 | export function CredentialsView() { | ||
| 47 | const { workspaceId } = useWorkspace(); | ||
| 48 | |||
| 49 | const credentialBindingsState = useAtomValue(credentialBindingsByWorkspace(workspaceId)); | ||
| 50 | const runUpsertCredentialBinding = useAtomSet(upsertCredentialBinding, { | ||
| 51 | mode: "promise", | ||
| 52 | }); | ||
| 53 | const runRemoveCredentialBinding = useAtomSet(removeCredentialBinding, { | ||
| 54 | mode: "promise", | ||
| 55 | }); | ||
| 56 | |||
| 57 | const [credentialSourceKey, setCredentialSourceKey] = useState(""); | ||
| 58 | const [credentialProvider, setCredentialProvider] = useState<CredentialProvider>( | ||
| 59 | "api_key", | ||
| 60 | ); | ||
| 61 | const [credentialScopeType, setCredentialScopeType] = | ||
| 62 | useState<CredentialScopeType>("workspace"); | ||
| 63 | const [credentialIdInput, setCredentialIdInput] = useState(""); | ||
| 64 | const [credentialSecretRef, setCredentialSecretRef] = useState(""); | ||
| 65 | const [credentialAccountId, setCredentialAccountId] = useState(""); | ||
| 66 | const [credentialAdditionalHeadersJson, setCredentialAdditionalHeadersJson] = | ||
| 67 | useState(""); | ||
| 68 | const [credentialBoundAuthFingerprint, setCredentialBoundAuthFingerprint] = | ||
| 69 | useState(""); | ||
| 70 | |||
| 71 | const [credentialEditingId, setCredentialEditingId] = useState< | ||
| 72 | SourceCredentialBinding["id"] | null | ||
| 73 | >(null); | ||
| 74 | const [credentialSearchQuery, setCredentialSearchQuery] = useState(""); | ||
| 75 | |||
| 76 | const [credentialStatusText, setCredentialStatusText] = useState<string | null>( | ||
| 77 | null, | ||
| 78 | ); | ||
| 79 | const [credentialStatusIsError, setCredentialStatusIsError] = useState(false); | ||
| 80 | |||
| 81 | const [credentialBusyId, setCredentialBusyId] = | ||
| 82 | useState<SourceCredentialBinding["id"] | null>(null); | ||
| 83 | |||
| 84 | const filteredCredentialBindings = useMemo(() => { | ||
| 85 | const query = credentialSearchQuery.trim().toLowerCase(); | ||
| 86 | if (query.length === 0) { | ||
| 87 | return credentialBindingsState.items; | ||
| 88 | } | ||
| 89 | |||
| 90 | return credentialBindingsState.items.filter((binding) => { | ||
| 91 | return ( | ||
| 92 | binding.sourceKey.toLowerCase().includes(query) || | ||
| 93 | binding.provider.toLowerCase().includes(query) || | ||
| 94 | binding.scopeType.toLowerCase().includes(query) || | ||
| 95 | binding.credentialId.toLowerCase().includes(query) || | ||
| 96 | binding.secretRef.toLowerCase().includes(query) || | ||
| 97 | (binding.accountId ?? "").toLowerCase().includes(query) | ||
| 98 | ); | ||
| 99 | }); | ||
| 100 | }, [credentialBindingsState.items, credentialSearchQuery]); | ||
| 101 | |||
| 102 | const setInfoStatus = (message: string) => { | ||
| 103 | setCredentialStatusIsError(false); | ||
| 104 | setCredentialStatusText(message); | ||
| 105 | }; | ||
| 106 | |||
| 107 | const setErrorStatus = (message: string) => { | ||
| 108 | setCredentialStatusIsError(true); | ||
| 109 | setCredentialStatusText(message); | ||
| 110 | }; | ||
| 111 | |||
| 112 | const resetCredentialForm = () => { | ||
| 113 | setCredentialEditingId(null); | ||
| 114 | setCredentialSourceKey(""); | ||
| 115 | setCredentialProvider("api_key"); | ||
| 116 | setCredentialScopeType("workspace"); | ||
| 117 | setCredentialIdInput(""); | ||
| 118 | setCredentialSecretRef(""); | ||
| 119 | setCredentialAccountId(""); | ||
| 120 | setCredentialAdditionalHeadersJson(""); | ||
| 121 | setCredentialBoundAuthFingerprint(""); | ||
| 122 | }; | ||
| 123 | |||
| 124 | const handleEditCredential = (credentialBindingId: SourceCredentialBinding["id"]) => { | ||
| 125 | const binding = credentialBindingsState.items.find((item) => item.id === credentialBindingId); | ||
| 126 | if (!binding) { | ||
| 127 | setErrorStatus("Unable to load selected credential binding."); | ||
| 128 | return; | ||
| 129 | } | ||
| 130 | |||
| 131 | setCredentialEditingId(binding.id); | ||
| 132 | setCredentialSourceKey(binding.sourceKey); | ||
| 133 | setCredentialProvider(binding.provider); | ||
| 134 | setCredentialScopeType(binding.scopeType); | ||
| 135 | setCredentialIdInput(binding.credentialId); | ||
| 136 | setCredentialSecretRef(binding.secretRef); | ||
| 137 | setCredentialAccountId(binding.accountId ?? ""); | ||
| 138 | setCredentialAdditionalHeadersJson(binding.additionalHeadersJson ?? ""); | ||
| 139 | setCredentialBoundAuthFingerprint(binding.boundAuthFingerprint ?? ""); | ||
| 140 | setInfoStatus(`Loaded binding ${binding.sourceKey} for editing.`); | ||
| 141 | }; | ||
| 142 | |||
| 143 | const handleCancelCredentialEdit = () => { | ||
| 144 | resetCredentialForm(); | ||
| 145 | setInfoStatus("Credential edit cancelled."); | ||
| 146 | }; | ||
| 147 | |||
| 148 | const handleUpsertCredential = (event: FormEvent<HTMLFormElement>) => { | ||
| 149 | event.preventDefault(); | ||
| 150 | |||
| 151 | if (credentialBusyId !== null) { | ||
| 152 | return; | ||
| 153 | } | ||
| 154 | |||
| 155 | const sourceKey = credentialSourceKey.trim(); | ||
| 156 | const credentialId = credentialIdInput.trim(); | ||
| 157 | const secretRef = credentialSecretRef.trim(); | ||
| 158 | const accountId = credentialAccountId.trim(); | ||
| 159 | const additionalHeadersJson = credentialAdditionalHeadersJson.trim(); | ||
| 160 | const boundAuthFingerprint = credentialBoundAuthFingerprint.trim(); | ||
| 161 | |||
| 162 | if (sourceKey.length === 0 || credentialId.length === 0 || secretRef.length === 0) { | ||
| 163 | setErrorStatus("Source key, credential id, and secret ref are required."); | ||
| 164 | return; | ||
| 165 | } | ||
| 166 | |||
| 167 | if (credentialScopeType === "account" && accountId.length === 0) { | ||
| 168 | setErrorStatus("Account scope credentials require account id."); | ||
| 169 | return; | ||
| 170 | } | ||
| 171 | |||
| 172 | const requestId = | ||
| 173 | credentialEditingId ?? | ||
| 174 | (createLocalId("credential_binding_") as SourceCredentialBinding["id"]); | ||
| 175 | |||
| 176 | setCredentialBusyId(requestId); | ||
| 177 | |||
| 178 | void runUpsertCredentialBinding({ | ||
| 179 | path: { workspaceId }, | ||
| 180 | payload: toCredentialBindingUpsertPayload({ | ||
| 181 | id: credentialEditingId ?? undefined, | ||
| 182 | credentialId: credentialId as SourceCredentialBinding["credentialId"], | ||
| 183 | scopeType: credentialScopeType, | ||
| 184 | sourceKey, | ||
| 185 | provider: credentialProvider, | ||
| 186 | secretRef, | ||
| 187 | accountId: | ||
| 188 | credentialScopeType === "account" | ||
| 189 | ? (accountId as SourceCredentialBinding["accountId"]) | ||
| 190 | : null, | ||
| 191 | additionalHeadersJson: additionalHeadersJson.length > 0 ? additionalHeadersJson : null, | ||
| 192 | boundAuthFingerprint: boundAuthFingerprint.length > 0 ? boundAuthFingerprint : null, | ||
| 193 | }), | ||
| 194 | }) | ||
| 195 | .then(() => { | ||
| 196 | setInfoStatus( | ||
| 197 | credentialEditingId | ||
| 198 | ? `Updated credential binding ${sourceKey}.` | ||
| 199 | : `Added credential binding ${sourceKey}.`, | ||
| 200 | ); | ||
| 201 | resetCredentialForm(); | ||
| 202 | }) | ||
| 203 | .catch(() => { | ||
| 204 | setErrorStatus("Credential save failed."); | ||
| 205 | }) | ||
| 206 | .finally(() => { | ||
| 207 | setCredentialBusyId(null); | ||
| 208 | }); | ||
| 209 | }; | ||
| 210 | |||
| 211 | const handleRemoveCredential = (credentialBindingId: SourceCredentialBinding["id"]) => { | ||
| 212 | if (credentialBusyId !== null) { | ||
| 213 | return; | ||
| 214 | } | ||
| 215 | |||
| 216 | setCredentialBusyId(credentialBindingId); | ||
| 217 | |||
| 218 | void runRemoveCredentialBinding({ | ||
| 219 | path: { | ||
| 220 | workspaceId, | ||
| 221 | credentialBindingId, | ||
| 222 | }, | ||
| 223 | }) | ||
| 224 | .then((result) => { | ||
| 225 | const removed = toCredentialBindingRemoveResult(result); | ||
| 226 | setInfoStatus( | ||
| 227 | removed ? "Credential binding removed." : "Credential binding not found.", | ||
| 228 | ); | ||
| 229 | |||
| 230 | if (credentialEditingId === credentialBindingId) { | ||
| 231 | handleCancelCredentialEdit(); | ||
| 232 | } | ||
| 233 | |||
| 234 | }) | ||
| 235 | .catch(() => { | ||
| 236 | setErrorStatus("Credential removal failed."); | ||
| 237 | }) | ||
| 238 | .finally(() => { | ||
| 239 | setCredentialBusyId(null); | ||
| 240 | }); | ||
| 241 | }; | ||
| 242 | |||
| 243 | return ( | ||
| 244 | <div className="grid gap-5 lg:grid-cols-2"> | ||
| 245 | <Card className="border-border/70"> | ||
| 246 | <CardHeader className="pb-3"> | ||
| 247 | <PageHeader | ||
| 248 | title={ | ||
| 249 | credentialEditingId ? "Edit Credential Binding" : "Add Credential Binding" | ||
| 250 | } | ||
| 251 | description="Bind workspace credentials to sources and providers." | ||
| 252 | /> | ||
| 253 | </CardHeader> | ||
| 254 | <CardContent className="space-y-4"> | ||
| 255 | <form className="space-y-3" onSubmit={handleUpsertCredential}> | ||
| 256 | <div className="grid gap-1.5"> | ||
| 257 | <label className="text-xs text-muted-foreground" htmlFor="credential-source-key"> | ||
| 258 | Source key | ||
| 259 | </label> | ||
| 260 | <Input | ||
| 261 | id="credential-source-key" | ||
| 262 | value={credentialSourceKey} | ||
| 263 | onChange={(event) => setCredentialSourceKey(event.target.value)} | ||
| 264 | placeholder="source_github" | ||
| 265 | required | ||
| 266 | disabled={credentialBusyId !== null} | ||
| 267 | /> | ||
| 268 | </div> | ||
| 269 | |||
| 270 | <div className="grid gap-3 sm:grid-cols-2"> | ||
| 271 | <div className="grid gap-1.5"> | ||
| 272 | <label className="text-xs text-muted-foreground" htmlFor="credential-provider"> | ||
| 273 | Provider | ||
| 274 | </label> | ||
| 275 | <Select | ||
| 276 | id="credential-provider" | ||
| 277 | value={credentialProvider} | ||
| 278 | onChange={(event) => | ||
| 279 | setCredentialProvider(event.target.value as CredentialProvider) | ||
| 280 | } | ||
| 281 | disabled={credentialBusyId !== null} | ||
| 282 | > | ||
| 283 | {providerOptions.map((provider) => ( | ||
| 284 | <option key={provider} value={provider}> | ||
| 285 | {provider} | ||
| 286 | </option> | ||
| 287 | ))} | ||
| 288 | </Select> | ||
| 289 | </div> | ||
| 290 | |||
| 291 | <div className="grid gap-1.5"> | ||
| 292 | <label | ||
| 293 | className="text-xs text-muted-foreground" | ||
| 294 | htmlFor="credential-scope-type" | ||
| 295 | > | ||
| 296 | Scope | ||
| 297 | </label> | ||
| 298 | <Select | ||
| 299 | id="credential-scope-type" | ||
| 300 | value={credentialScopeType} | ||
| 301 | onChange={(event) => | ||
| 302 | setCredentialScopeType(event.target.value as CredentialScopeType) | ||
| 303 | } | ||
| 304 | disabled={credentialBusyId !== null} | ||
| 305 | > | ||
| 306 | {scopeTypeOptions.map((scopeType) => ( | ||
| 307 | <option key={scopeType} value={scopeType}> | ||
| 308 | {scopeType} | ||
| 309 | </option> | ||
| 310 | ))} | ||
| 311 | </Select> | ||
| 312 | </div> | ||
| 313 | </div> | ||
| 314 | |||
| 315 | <div className="grid gap-3 sm:grid-cols-2"> | ||
| 316 | <div className="grid gap-1.5"> | ||
| 317 | <label className="text-xs text-muted-foreground" htmlFor="credential-id"> | ||
| 318 | Credential id | ||
| 319 | </label> | ||
| 320 | <Input | ||
| 321 | id="credential-id" | ||
| 322 | value={credentialIdInput} | ||
| 323 | onChange={(event) => setCredentialIdInput(event.target.value)} | ||
| 324 | placeholder="cred_123" | ||
| 325 | required | ||
| 326 | disabled={credentialBusyId !== null} | ||
| 327 | /> | ||
| 328 | </div> | ||
| 329 | |||
| 330 | <div className="grid gap-1.5"> | ||
| 331 | <label | ||
| 332 | className="text-xs text-muted-foreground" | ||
| 333 | htmlFor="credential-secret-ref" | ||
| 334 | > | ||
| 335 | Secret ref | ||
| 336 | </label> | ||
| 337 | <Input | ||
| 338 | id="credential-secret-ref" | ||
| 339 | value={credentialSecretRef} | ||
| 340 | onChange={(event) => setCredentialSecretRef(event.target.value)} | ||
| 341 | placeholder="secrets/github-token" | ||
| 342 | required | ||
| 343 | disabled={credentialBusyId !== null} | ||
| 344 | /> | ||
| 345 | </div> | ||
| 346 | </div> | ||
| 347 | |||
| 348 | {credentialScopeType === "account" ? ( | ||
| 349 | <div className="grid gap-1.5"> | ||
| 350 | <label | ||
| 351 | className="text-xs text-muted-foreground" | ||
| 352 | htmlFor="credential-account-id" | ||
| 353 | > | ||
| 354 | Account id | ||
| 355 | </label> | ||
| 356 | <Input | ||
| 357 | id="credential-account-id" | ||
| 358 | value={credentialAccountId} | ||
| 359 | onChange={(event) => setCredentialAccountId(event.target.value)} | ||
| 360 | placeholder="acct_123" | ||
| 361 | required | ||
| 362 | disabled={credentialBusyId !== null} | ||
| 363 | /> | ||
| 364 | </div> | ||
| 365 | ) : null} | ||
| 366 | |||
| 367 | <div className="grid gap-1.5"> | ||
| 368 | <label | ||
| 369 | className="text-xs text-muted-foreground" | ||
| 370 | htmlFor="credential-headers-json" | ||
| 371 | > | ||
| 372 | Additional headers JSON (optional) | ||
| 373 | </label> | ||
| 374 | <Input | ||
| 375 | id="credential-headers-json" | ||
| 376 | value={credentialAdditionalHeadersJson} | ||
| 377 | onChange={(event) => | ||
| 378 | setCredentialAdditionalHeadersJson(event.target.value) | ||
| 379 | } | ||
| 380 | placeholder='{"X-Team": "tools"}' | ||
| 381 | disabled={credentialBusyId !== null} | ||
| 382 | /> | ||
| 383 | </div> | ||
| 384 | |||
| 385 | <div className="grid gap-1.5"> | ||
| 386 | <label | ||
| 387 | className="text-xs text-muted-foreground" | ||
| 388 | htmlFor="credential-auth-fingerprint" | ||
| 389 | > | ||
| 390 | Bound auth fingerprint (optional) | ||
| 391 | </label> | ||
| 392 | <Input | ||
| 393 | id="credential-auth-fingerprint" | ||
| 394 | value={credentialBoundAuthFingerprint} | ||
| 395 | onChange={(event) => | ||
| 396 | setCredentialBoundAuthFingerprint(event.target.value) | ||
| 397 | } | ||
| 398 | placeholder="fingerprint hash" | ||
| 399 | disabled={credentialBusyId !== null} | ||
| 400 | /> | ||
| 401 | </div> | ||
| 402 | |||
| 403 | <div className="grid gap-2 sm:grid-cols-2"> | ||
| 404 | <Button type="submit" disabled={credentialBusyId !== null}> | ||
| 405 | {credentialBusyId !== null | ||
| 406 | ? "Saving..." | ||
| 407 | : credentialEditingId | ||
| 408 | ? "Save Binding" | ||
| 409 | : "Add Binding"} | ||
| 410 | </Button> | ||
| 411 | {credentialEditingId ? ( | ||
| 412 | <Button | ||
| 413 | type="button" | ||
| 414 | variant="outline" | ||
| 415 | onClick={handleCancelCredentialEdit} | ||
| 416 | disabled={credentialBusyId !== null} | ||
| 417 | > | ||
| 418 | Cancel | ||
| 419 | </Button> | ||
| 420 | ) : null} | ||
| 421 | </div> | ||
| 422 | </form> | ||
| 423 | |||
| 424 | <StatusMessage | ||
| 425 | message={credentialStatusText} | ||
| 426 | variant={credentialStatusIsError ? "error" : "info"} | ||
| 427 | /> | ||
| 428 | </CardContent> | ||
| 429 | </Card> | ||
| 430 | |||
| 431 | <Card className="border-border/70"> | ||
| 432 | <CardHeader className="pb-3"> | ||
| 433 | <PageHeader | ||
| 434 | title="Credential Bindings" | ||
| 435 | description="Credentials currently linked to sources." | ||
| 436 | /> | ||
| 437 | </CardHeader> | ||
| 438 | <CardContent className="space-y-4"> | ||
| 439 | <div className="grid gap-1.5"> | ||
| 440 | <label className="text-xs text-muted-foreground" htmlFor="credential-search"> | ||
| 441 | Search | ||
| 442 | </label> | ||
| 443 | <Input | ||
| 444 | id="credential-search" | ||
| 445 | value={credentialSearchQuery} | ||
| 446 | onChange={(event) => setCredentialSearchQuery(event.target.value)} | ||
| 447 | placeholder="source key, provider, scope, credential id, secret" | ||
| 448 | disabled={credentialBindingsState.state === "loading"} | ||
| 449 | /> | ||
| 450 | </div> | ||
| 451 | |||
| 452 | {matchState(credentialBindingsState, { | ||
| 453 | loading: "Loading credential bindings...", | ||
| 454 | empty: | ||
| 455 | credentialSearchQuery.trim().length > 0 | ||
| 456 | ? "No credentials match this search." | ||
| 457 | : "No credential bindings found.", | ||
| 458 | filteredCount: filteredCredentialBindings.length, | ||
| 459 | ready: () => ( | ||
| 460 | <div className="space-y-2"> | ||
| 461 | {filteredCredentialBindings.map((binding) => { | ||
| 462 | const isBusy = credentialBusyId === binding.id; | ||
| 463 | |||
| 464 | return ( | ||
| 465 | <div | ||
| 466 | key={binding.id} | ||
| 467 | className={cn( | ||
| 468 | "rounded-lg border border-border bg-background/70 p-3", | ||
| 469 | isBusy && "opacity-75", | ||
| 470 | )} | ||
| 471 | > | ||
| 472 | <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between"> | ||
| 473 | <div className="min-w-0 space-y-1"> | ||
| 474 | <p className="truncate text-sm font-medium">{binding.sourceKey}</p> | ||
| 475 | <div className="flex flex-wrap items-center gap-1.5 text-xs text-muted-foreground"> | ||
| 476 | <Badge variant="outline">{binding.provider}</Badge> | ||
| 477 | <Badge variant="outline">{binding.scopeType}</Badge> | ||
| 478 | <span>{binding.credentialId}</span> | ||
| 479 | </div> | ||
| 480 | <p className="break-all text-xs text-muted-foreground"> | ||
| 481 | secret {binding.secretRef} | ||
| 482 | </p> | ||
| 483 | {binding.accountId ? ( | ||
| 484 | <p className="break-all text-xs text-muted-foreground"> | ||
| 485 | account {binding.accountId} | ||
| 486 | </p> | ||
| 487 | ) : null} | ||
| 488 | </div> | ||
| 489 | <div className="flex items-center gap-2"> | ||
| 490 | <Button | ||
| 491 | type="button" | ||
| 492 | size="sm" | ||
| 493 | variant="outline" | ||
| 494 | onClick={() => handleEditCredential(binding.id)} | ||
| 495 | disabled={credentialBusyId !== null} | ||
| 496 | > | ||
| 497 | Edit | ||
| 498 | </Button> | ||
| 499 | <Button | ||
| 500 | type="button" | ||
| 501 | size="sm" | ||
| 502 | variant="destructive" | ||
| 503 | onClick={() => handleRemoveCredential(binding.id)} | ||
| 504 | disabled={credentialBusyId !== null} | ||
| 505 | > | ||
| 506 | {isBusy ? "Working..." : "Remove"} | ||
| 507 | </Button> | ||
| 508 | </div> | ||
| 509 | </div> | ||
| 510 | </div> | ||
| 511 | ); | ||
| 512 | })} | ||
| 513 | </div> | ||
| 514 | ), | ||
| 515 | })} | ||
| 516 | </CardContent> | ||
| 517 | </Card> | ||
| 518 | </div> | ||
| 519 | ); | ||
| 520 | } | ||
| @@ -0,0 +1,285 @@ | |||
| 1 | "use client"; | ||
| 2 | |||
| 3 | import { useAtomSet, useAtomValue } from "@effect-atom/atom-react"; | ||
| 4 | import type { Policy, PolicyDecision, PolicyId } from "@executor-v2/schema"; | ||
| 5 | import { useMemo, useState } from "react"; | ||
| 6 | import type { FormEvent } from "react"; | ||
| 7 | |||
| 8 | import { useWorkspace } from "../../lib/hooks/use-workspace"; | ||
| 9 | import { | ||
| 10 | optimisticRemovePolicy, | ||
| 11 | optimisticUpsertPolicy, | ||
| 12 | policiesByWorkspace, | ||
| 13 | removePolicy, | ||
| 14 | toPolicyRemoveResult, | ||
| 15 | toPolicyUpsertPayload, | ||
| 16 | upsertPolicy, | ||
| 17 | } from "../../lib/control-plane/atoms"; | ||
| 18 | import { Badge } from "../ui/badge"; | ||
| 19 | import { Button } from "../ui/button"; | ||
| 20 | import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "../ui/card"; | ||
| 21 | import { Input } from "../ui/input"; | ||
| 22 | import { Select } from "../ui/select"; | ||
| 23 | import { cn, createLocalId, formatTimestamp } from "../../lib/utils"; | ||
| 24 | import { matchState } from "../shared/match-state"; | ||
| 25 | import { PageHeader } from "../shared/page-header"; | ||
| 26 | import { StatusMessage } from "../shared/status-message"; | ||
| 27 | |||
| 28 | const policyDecisionOptions: ReadonlyArray<PolicyDecision> = ["allow", "require_approval", "deny"]; | ||
| 29 | |||
| 30 | const decisionBadgeVariant = (decision: PolicyDecision): "secondary" | "pending" | "denied" => { | ||
| 31 | if (decision === "allow") return "secondary"; | ||
| 32 | if (decision === "require_approval") return "pending"; | ||
| 33 | return "denied"; | ||
| 34 | }; | ||
| 35 | |||
| 36 | export function PoliciesView() { | ||
| 37 | const { workspaceId } = useWorkspace(); | ||
| 38 | |||
| 39 | const [policyEditingId, setPolicyEditingId] = useState<PolicyId | null>(null); | ||
| 40 | const [policyPattern, setPolicyPattern] = useState(""); | ||
| 41 | const [policyDecision, setPolicyDecision] = useState<PolicyDecision>("require_approval"); | ||
| 42 | const [policySearchQuery, setPolicySearchQuery] = useState(""); | ||
| 43 | const [policyBusyId, setPolicyBusyId] = useState<PolicyId | null>(null); | ||
| 44 | const [policyStatusText, setPolicyStatusText] = useState<string | null>(null); | ||
| 45 | const [policyStatusVariant, setPolicyStatusVariant] = useState<"info" | "error">("info"); | ||
| 46 | const [optimisticPolicies, setOptimisticPolicies] = useState<ReadonlyArray<Policy> | null>(null); | ||
| 47 | |||
| 48 | const policiesState = useAtomValue(policiesByWorkspace(workspaceId)); | ||
| 49 | const runUpsertPolicy = useAtomSet(upsertPolicy, { mode: "promise" }); | ||
| 50 | const runRemovePolicy = useAtomSet(removePolicy, { mode: "promise" }); | ||
| 51 | |||
| 52 | const policyItems = optimisticPolicies ?? policiesState.items; | ||
| 53 | const filteredPolicies = useMemo(() => { | ||
| 54 | const query = policySearchQuery.trim().toLowerCase(); | ||
| 55 | if (query.length === 0) return policyItems; | ||
| 56 | return policyItems.filter((policy) => | ||
| 57 | policy.toolPathPattern.toLowerCase().includes(query) || | ||
| 58 | policy.decision.toLowerCase().includes(query), | ||
| 59 | ); | ||
| 60 | }, [policyItems, policySearchQuery]); | ||
| 61 | |||
| 62 | const setStatus = (message: string | null, variant: "info" | "error" = "info") => { | ||
| 63 | setPolicyStatusText(message); | ||
| 64 | setPolicyStatusVariant(variant); | ||
| 65 | }; | ||
| 66 | |||
| 67 | const clearPolicyForm = () => { | ||
| 68 | setPolicyEditingId(null); | ||
| 69 | setPolicyPattern(""); | ||
| 70 | setPolicyDecision("require_approval"); | ||
| 71 | }; | ||
| 72 | |||
| 73 | const handleEditPolicy = (policyId: PolicyId) => { | ||
| 74 | if (policyBusyId !== null) return; | ||
| 75 | const target = policyItems.find((policy) => policy.id === policyId); | ||
| 76 | if (!target) return; | ||
| 77 | setPolicyEditingId(policyId); | ||
| 78 | setPolicyPattern(target.toolPathPattern); | ||
| 79 | setPolicyDecision(target.decision); | ||
| 80 | setStatus(`Editing policy ${target.toolPathPattern}.`); | ||
| 81 | }; | ||
| 82 | |||
| 83 | const handleCancelPolicyEdit = () => { | ||
| 84 | if (policyBusyId !== null) return; | ||
| 85 | clearPolicyForm(); | ||
| 86 | setStatus("Policy edit cancelled."); | ||
| 87 | }; | ||
| 88 | |||
| 89 | const handleUpsertPolicy = (event: FormEvent<HTMLFormElement>) => { | ||
| 90 | event.preventDefault(); | ||
| 91 | if (policyBusyId !== null) return; | ||
| 92 | |||
| 93 | const toolPathPattern = policyPattern.trim(); | ||
| 94 | if (toolPathPattern.length === 0) { | ||
| 95 | setStatus("Tool path pattern is required.", "error"); | ||
| 96 | return; | ||
| 97 | } | ||
| 98 | |||
| 99 | const policyId = policyEditingId ?? (createLocalId("pol_") as PolicyId); | ||
| 100 | const nextPolicies = optimisticUpsertPolicy(policyItems, { | ||
| 101 | workspaceId, | ||
| 102 | policyId, | ||
| 103 | toolPathPattern, | ||
| 104 | decision: policyDecision, | ||
| 105 | }); | ||
| 106 | |||
| 107 | setPolicyBusyId(policyId); | ||
| 108 | setOptimisticPolicies(nextPolicies); | ||
| 109 | |||
| 110 | void runUpsertPolicy({ | ||
| 111 | path: { workspaceId }, | ||
| 112 | payload: toPolicyUpsertPayload({ | ||
| 113 | id: policyEditingId ?? undefined, | ||
| 114 | toolPathPattern, | ||
| 115 | decision: policyDecision, | ||
| 116 | }), | ||
| 117 | }) | ||
| 118 | .then(() => { | ||
| 119 | setStatus(policyEditingId ? `Updated policy ${toolPathPattern}.` : `Added policy ${toolPathPattern}.`); | ||
| 120 | clearPolicyForm(); | ||
| 121 | setOptimisticPolicies(null); | ||
| 122 | }) | ||
| 123 | .catch(() => { | ||
| 124 | setStatus("Policy save failed.", "error"); | ||
| 125 | setOptimisticPolicies(null); | ||
| 126 | }) | ||
| 127 | .finally(() => { | ||
| 128 | setPolicyBusyId(null); | ||
| 129 | }); | ||
| 130 | }; | ||
| 131 | |||
| 132 | const handleRemovePolicy = (policyId: PolicyId) => { | ||
| 133 | if (policyBusyId !== null) return; | ||
| 134 | |||
| 135 | const nextPolicies = optimisticRemovePolicy(policyItems, policyId); | ||
| 136 | setPolicyBusyId(policyId); | ||
| 137 | setOptimisticPolicies(nextPolicies); | ||
| 138 | |||
| 139 | void runRemovePolicy({ path: { workspaceId, policyId } }) | ||
| 140 | .then((result) => { | ||
| 141 | const removed = toPolicyRemoveResult(result); | ||
| 142 | setStatus(removed ? "Policy removed." : "Policy not found."); | ||
| 143 | if (policyEditingId === policyId) clearPolicyForm(); | ||
| 144 | setOptimisticPolicies(null); | ||
| 145 | }) | ||
| 146 | .catch(() => { | ||
| 147 | setStatus("Policy removal failed.", "error"); | ||
| 148 | setOptimisticPolicies(null); | ||
| 149 | }) | ||
| 150 | .finally(() => { | ||
| 151 | setPolicyBusyId(null); | ||
| 152 | }); | ||
| 153 | }; | ||
| 154 | |||
| 155 | const emptyMessage = | ||
| 156 | policySearchQuery.trim().length > 0 | ||
| 157 | ? "No policies match your search." | ||
| 158 | : policyItems.length === 0 | ||
| 159 | ? "No policies configured for this workspace." | ||
| 160 | : null; | ||
| 161 | |||
| 162 | return ( | ||
| 163 | <div className="mx-auto flex w-full max-w-5xl flex-col gap-4"> | ||
| 164 | <PageHeader title="Policies" description="Define and manage tool path policy behavior." /> | ||
| 165 | <Card className={cn("border-border/70")}> | ||
| 166 | <CardHeader className="pb-3"> | ||
| 167 | <CardTitle>Policies</CardTitle> | ||
| 168 | <CardDescription>Use these rules to control default policy decisions.</CardDescription> | ||
| 169 | </CardHeader> | ||
| 170 | <CardContent className="space-y-4"> | ||
| 171 | <form className="space-y-3" onSubmit={handleUpsertPolicy}> | ||
| 172 | <div className="grid gap-1.5"> | ||
| 173 | <label className="text-xs text-muted-foreground" htmlFor="policy-pattern"> | ||
| 174 | Tool path pattern | ||
| 175 | </label> | ||
| 176 | <Input | ||
| 177 | id="policy-pattern" | ||
| 178 | value={policyPattern} | ||
| 179 | onChange={(event) => { | ||
| 180 | setPolicyPattern(event.target.value); | ||
| 181 | }} | ||
| 182 | placeholder="source:* or source:github/*" | ||
| 183 | required | ||
| 184 | /> | ||
| 185 | </div> | ||
| 186 | <div className="grid gap-1.5"> | ||
| 187 | <label className="text-xs text-muted-foreground" htmlFor="policy-decision"> | ||
| 188 | Decision | ||
| 189 | </label> | ||
| 190 | <Select | ||
| 191 | id="policy-decision" | ||
| 192 | value={policyDecision} | ||
| 193 | onChange={(event) => { | ||
| 194 | setPolicyDecision(event.target.value as PolicyDecision); | ||
| 195 | }} | ||
| 196 | > | ||
| 197 | {policyDecisionOptions.map((decision) => ( | ||
| 198 | <option key={decision} value={decision}> | ||
| 199 | {decision} | ||
| 200 | </option> | ||
| 201 | ))} | ||
| 202 | </Select> | ||
| 203 | </div> | ||
| 204 | <div className="grid gap-2 sm:grid-cols-2"> | ||
| 205 | <Button type="submit" disabled={policyBusyId !== null}> | ||
| 206 | {policyBusyId !== null | ||
| 207 | ? "Saving..." | ||
| 208 | : policyEditingId | ||
| 209 | ? "Save Policy" | ||
| 210 | : "Add Policy"} | ||
| 211 | </Button> | ||
| 212 | <Button | ||
| 213 | type="button" | ||
| 214 | variant="outline" | ||
| 215 | onClick={handleCancelPolicyEdit} | ||
| 216 | disabled={policyBusyId !== null || policyEditingId === null} | ||
| 217 | > | ||
| 218 | Cancel | ||
| 219 | </Button> | ||
| 220 | </div> | ||
| 221 | </form> | ||
| 222 | |||
| 223 | <StatusMessage message={policyStatusText} variant={policyStatusVariant} /> | ||
| 224 | |||
| 225 | <div className="grid gap-1.5"> | ||
| 226 | <label className="text-xs text-muted-foreground" htmlFor="policy-search"> | ||
| 227 | Search policies | ||
| 228 | </label> | ||
| 229 | <Input | ||
| 230 | id="policy-search" | ||
| 231 | value={policySearchQuery} | ||
| 232 | onChange={(event) => { | ||
| 233 | setPolicySearchQuery(event.target.value); | ||
| 234 | }} | ||
| 235 | placeholder="pattern or decision" | ||
| 236 | /> | ||
| 237 | </div> | ||
| 238 | |||
| 239 | {matchState(policiesState, { | ||
| 240 | loading: "Loading policies...", | ||
| 241 | empty: emptyMessage, | ||
| 242 | filteredCount: filteredPolicies.length, | ||
| 243 | ready: () => ( | ||
| 244 | <div className="space-y-2"> | ||
| 245 | {filteredPolicies.map((policy) => ( | ||
| 246 | <div key={policy.id} className="rounded-lg border border-border bg-background/70 p-3"> | ||
| 247 | <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between"> | ||
| 248 | <div className="min-w-0 space-y-1"> | ||
| 249 | <p className="break-all text-sm font-medium">{policy.toolPathPattern}</p> | ||
| 250 | <div className="flex flex-wrap items-center gap-1.5 text-xs text-muted-foreground"> | ||
| 251 | <Badge variant={decisionBadgeVariant(policy.decision)}>{policy.decision}</Badge> | ||
| 252 | <span>updated {formatTimestamp(policy.updatedAt)}</span> | ||
| 253 | </div> | ||
| 254 | </div> | ||
| 255 | <div className="flex items-center gap-2"> | ||
| 256 | <Button | ||
| 257 | type="button" | ||
| 258 | size="sm" | ||
| 259 | variant="outline" | ||
| 260 | onClick={() => handleEditPolicy(policy.id)} | ||
| 261 | disabled={policyBusyId !== null} | ||
| 262 | > | ||
| 263 | Edit | ||
| 264 | </Button> | ||
| 265 | <Button | ||
| 266 | type="button" | ||
| 267 | size="sm" | ||
| 268 | variant="destructive" | ||
| 269 | onClick={() => handleRemovePolicy(policy.id)} | ||
| 270 | disabled={policyBusyId !== null} | ||
| 271 | > | ||
| 272 | {policyBusyId === policy.id ? "Working..." : "Remove"} | ||
| 273 | </Button> | ||
| 274 | </div> | ||
| 275 | </div> | ||
| 276 | </div> | ||
| 277 | ))} | ||
| 278 | </div> | ||
| 279 | ), | ||
| 280 | })} | ||
| 281 | </CardContent> | ||
| 282 | </Card> | ||
| 283 | </div> | ||
| 284 | ); | ||
| 285 | } | ||
| @@ -0,0 +1,522 @@ | |||
| 1 | "use client"; | ||
| 2 | |||
| 3 | import { useEffect, useState, type FormEvent } from "react"; | ||
| 4 | import { useAtomSet, useAtomValue } from "@effect-atom/atom-react"; | ||
| 5 | import type { Organization, Workspace } from "@executor-v2/schema"; | ||
| 6 | |||
| 7 | import { useWorkspace } from "../../lib/hooks/use-workspace"; | ||
| 8 | import { | ||
| 9 | organizationsState, | ||
| 10 | upsertOrganization, | ||
| 11 | upsertWorkspace, | ||
| 12 | toOrganizationUpsertPayload, | ||
| 13 | toWorkspaceUpsertPayload, | ||
| 14 | workspacesState, | ||
| 15 | } from "../../lib/control-plane/atoms"; | ||
| 16 | import { Badge } from "../ui/badge"; | ||
| 17 | import { Button } from "../ui/button"; | ||
| 18 | import { | ||
| 19 | Card, | ||
| 20 | CardContent, | ||
| 21 | CardDescription, | ||
| 22 | CardHeader, | ||
| 23 | CardTitle, | ||
| 24 | } from "../ui/card"; | ||
| 25 | import { Input } from "../ui/input"; | ||
| 26 | import { Select } from "../ui/select"; | ||
| 27 | import { matchState } from "../shared/match-state"; | ||
| 28 | import { PageHeader } from "../shared/page-header"; | ||
| 29 | import { StatusMessage } from "../shared/status-message"; | ||
| 30 | |||
| 31 | type OrganizationForm = { | ||
| 32 | id: string; | ||
| 33 | slug: string; | ||
| 34 | name: string; | ||
| 35 | status: Organization["status"]; | ||
| 36 | }; | ||
| 37 | |||
| 38 | type WorkspaceForm = { | ||
| 39 | id: string; | ||
| 40 | name: string; | ||
| 41 | organizationId: string; | ||
| 42 | }; | ||
| 43 | |||
| 44 | const organizationStatusOptions: ReadonlyArray<Organization["status"]> = [ | ||
| 45 | "active", | ||
| 46 | "suspended", | ||
| 47 | "archived", | ||
| 48 | ]; | ||
| 49 | |||
| 50 | const defaultOrganizationForm = (): OrganizationForm => ({ | ||
| 51 | id: "", | ||
| 52 | slug: "", | ||
| 53 | name: "", | ||
| 54 | status: "active", | ||
| 55 | }); | ||
| 56 | |||
| 57 | const defaultWorkspaceForm = (): WorkspaceForm => ({ | ||
| 58 | id: "", | ||
| 59 | name: "", | ||
| 60 | organizationId: "", | ||
| 61 | }); | ||
| 62 | |||
| 63 | const createOrganizationId = (): Organization["id"] => | ||
| 64 | `org_${crypto.randomUUID()}` as Organization["id"]; | ||
| 65 | |||
| 66 | const createWorkspaceId = (): Workspace["id"] => | ||
| 67 | `ws_${crypto.randomUUID()}` as Workspace["id"]; | ||
| 68 | |||
| 69 | const errorMessage = (cause: unknown, fallback: string): string => | ||
| 70 | cause instanceof Error && cause.message.trim().length > 0 | ||
| 71 | ? cause.message | ||
| 72 | : fallback; | ||
| 73 | |||
| 74 | const organizationStatusVariant = ( | ||
| 75 | status: Organization["status"], | ||
| 76 | ): "approved" | "pending" | "denied" | "outline" => { | ||
| 77 | if (status === "active") { | ||
| 78 | return "approved"; | ||
| 79 | } | ||
| 80 | if (status === "suspended") { | ||
| 81 | return "pending"; | ||
| 82 | } | ||
| 83 | return "denied"; | ||
| 84 | }; | ||
| 85 | |||
| 86 | const statusVariant = (message: string | null): "info" | "error" => { | ||
| 87 | return message?.toLowerCase().includes("failed") ? "error" : "info"; | ||
| 88 | }; | ||
| 89 | |||
| 90 | export default function SettingsView() { | ||
| 91 | const { workspaceId, setWorkspaceId } = useWorkspace(); | ||
| 92 | |||
| 93 | const organizations = useAtomValue(organizationsState); | ||
| 94 | const workspaces = useAtomValue(workspacesState); | ||
| 95 | const runUpsertOrganization = useAtomSet(upsertOrganization, { mode: "promise" }); | ||
| 96 | const runUpsertWorkspace = useAtomSet(upsertWorkspace, { mode: "promise" }); | ||
| 97 | |||
| 98 | const [organizationForm, setOrganizationForm] = useState<OrganizationForm>(defaultOrganizationForm); | ||
| 99 | const [workspaceForm, setWorkspaceForm] = useState<WorkspaceForm>(defaultWorkspaceForm); | ||
| 100 | const [organizationStatusText, setOrganizationStatusText] = useState<string | null>(null); | ||
| 101 | const [workspaceStatusText, setWorkspaceStatusText] = useState<string | null>(null); | ||
| 102 | |||
| 103 | const organizationsLoading = organizations.state === "loading"; | ||
| 104 | const workspacesLoading = workspaces.state === "loading"; | ||
| 105 | |||
| 106 | useEffect(() => { | ||
| 107 | if (workspaceForm.name.trim().length > 0) { | ||
| 108 | return; | ||
| 109 | } | ||
| 110 | |||
| 111 | const currentWorkspace = workspaces.items.find((workspace) => workspace.id === workspaceId); | ||
| 112 | if (!currentWorkspace) { | ||
| 113 | return; | ||
| 114 | } | ||
| 115 | |||
| 116 | setWorkspaceForm((current) => ({ | ||
| 117 | ...current, | ||
| 118 | id: currentWorkspace.id, | ||
| 119 | name: currentWorkspace.name, | ||
| 120 | organizationId: currentWorkspace.organizationId, | ||
| 121 | })); | ||
| 122 | }, [workspaceId, workspaceForm.name, workspaces.items]); | ||
| 123 | |||
| 124 | useEffect(() => { | ||
| 125 | if (organizationForm.id.trim().length > 0) { | ||
| 126 | return; | ||
| 127 | } | ||
| 128 | |||
| 129 | const currentWorkspace = workspaces.items.find((workspace) => workspace.id === workspaceId); | ||
| 130 | if (!currentWorkspace) { | ||
| 131 | return; | ||
| 132 | } | ||
| 133 | |||
| 134 | const currentOrganization = organizations.items.find( | ||
| 135 | (organization) => organization.id === currentWorkspace.organizationId, | ||
| 136 | ); | ||
| 137 | if (!currentOrganization) { | ||
| 138 | return; | ||
| 139 | } | ||
| 140 | |||
| 141 | setOrganizationForm({ | ||
| 142 | id: currentOrganization.id, | ||
| 143 | slug: currentOrganization.slug, | ||
| 144 | name: currentOrganization.name, | ||
| 145 | status: currentOrganization.status, | ||
| 146 | }); | ||
| 147 | }, [organizationForm.id, organizations.items, workspaceId, workspaces.items]); | ||
| 148 | |||
| 149 | const handleUpsertOrganization = (event: FormEvent<HTMLFormElement>) => { | ||
| 150 | event.preventDefault(); | ||
| 151 | |||
| 152 | const slug = organizationForm.slug.trim(); | ||
| 153 | const name = organizationForm.name.trim(); | ||
| 154 | const inputId = organizationForm.id.trim(); | ||
| 155 | const organizationId = inputId.length > 0 | ||
| 156 | ? (inputId as Organization["id"]) | ||
| 157 | : createOrganizationId(); | ||
| 158 | |||
| 159 | if (slug.length === 0 || name.length === 0) { | ||
| 160 | setOrganizationStatusText("Organization slug and name are required."); | ||
| 161 | return; | ||
| 162 | } | ||
| 163 | |||
| 164 | const payload = toOrganizationUpsertPayload({ | ||
| 165 | id: organizationId, | ||
| 166 | slug, | ||
| 167 | name, | ||
| 168 | status: organizationForm.status, | ||
| 169 | }); | ||
| 170 | |||
| 171 | void runUpsertOrganization({ payload }) | ||
| 172 | .then((organization) => { | ||
| 173 | setOrganizationStatusText(`Saved organization ${organization.slug}.`); | ||
| 174 | setOrganizationForm({ | ||
| 175 | id: organization.id, | ||
| 176 | slug: organization.slug, | ||
| 177 | name: organization.name, | ||
| 178 | status: organization.status, | ||
| 179 | }); | ||
| 180 | }) | ||
| 181 | .catch((cause) => { | ||
| 182 | setOrganizationStatusText(errorMessage(cause, "Organization save failed.")); | ||
| 183 | }); | ||
| 184 | }; | ||
| 185 | |||
| 186 | const handleUpsertWorkspace = (event: FormEvent<HTMLFormElement>) => { | ||
| 187 | event.preventDefault(); | ||
| 188 | |||
| 189 | const name = workspaceForm.name.trim(); | ||
| 190 | const inputId = workspaceForm.id.trim(); | ||
| 191 | const organizationId = workspaceForm.organizationId.trim(); | ||
| 192 | const workspaceId = inputId.length > 0 | ||
| 193 | ? (inputId as Workspace["id"]) | ||
| 194 | : createWorkspaceId(); | ||
| 195 | |||
| 196 | if (name.length === 0) { | ||
| 197 | setWorkspaceStatusText("Workspace name is required."); | ||
| 198 | return; | ||
| 199 | } | ||
| 200 | |||
| 201 | if (organizationId.length === 0) { | ||
| 202 | setWorkspaceStatusText("Workspace organization is required."); | ||
| 203 | return; | ||
| 204 | } | ||
| 205 | |||
| 206 | const payload = toWorkspaceUpsertPayload({ | ||
| 207 | id: workspaceId, | ||
| 208 | name, | ||
| 209 | organizationId: organizationId as Workspace["organizationId"], | ||
| 210 | }); | ||
| 211 | |||
| 212 | void runUpsertWorkspace({ payload }) | ||
| 213 | .then((workspace) => { | ||
| 214 | setWorkspaceStatusText(`Saved workspace ${workspace.name}.`); | ||
| 215 | setWorkspaceForm({ | ||
| 216 | id: workspace.id, | ||
| 217 | name: workspace.name, | ||
| 218 | organizationId: workspace.organizationId, | ||
| 219 | }); | ||
| 220 | setWorkspaceId(workspace.id); | ||
| 221 | }) | ||
| 222 | .catch((cause) => { | ||
| 223 | setWorkspaceStatusText(errorMessage(cause, "Workspace save failed.")); | ||
| 224 | }); | ||
| 225 | }; | ||
| 226 | |||
| 227 | const handleLoadOrganization = (organization: Organization) => { | ||
| 228 | setOrganizationForm({ | ||
| 229 | id: organization.id, | ||
| 230 | slug: organization.slug, | ||
| 231 | name: organization.name, | ||
| 232 | status: organization.status, | ||
| 233 | }); | ||
| 234 | setOrganizationStatusText(`Loaded organization ${organization.slug}.`); | ||
| 235 | }; | ||
| 236 | |||
| 237 | const handleLoadWorkspace = (workspace: Workspace) => { | ||
| 238 | setWorkspaceForm({ | ||
| 239 | id: workspace.id, | ||
| 240 | name: workspace.name, | ||
| 241 | organizationId: workspace.organizationId, | ||
| 242 | }); | ||
| 243 | setWorkspaceId(workspace.id); | ||
| 244 | setWorkspaceStatusText(`Loaded workspace ${workspace.id}.`); | ||
| 245 | }; | ||
| 246 | |||
| 247 | return ( | ||
| 248 | <section className="space-y-8"> | ||
| 249 | <PageHeader | ||
| 250 | title="Settings" | ||
| 251 | description="Manage organizations and workspaces in a single combined view." | ||
| 252 | /> | ||
| 253 | |||
| 254 | <section className="space-y-5"> | ||
| 255 | <div className="grid gap-5 lg:grid-cols-2"> | ||
| 256 | <Card className="border-border/70"> | ||
| 257 | <CardHeader className="pb-3"> | ||
| 258 | <CardTitle>Organization Profile</CardTitle> | ||
| 259 | <CardDescription> | ||
| 260 | Create and edit organization records used by workspace definitions. | ||
| 261 | </CardDescription> | ||
| 262 | </CardHeader> | ||
| 263 | |||
| 264 | <CardContent className="space-y-4"> | ||
| 265 | <form className="space-y-3" onSubmit={handleUpsertOrganization}> | ||
| 266 | <div className="grid gap-1.5"> | ||
| 267 | <label className="text-xs text-muted-foreground" htmlFor="organization-id"> | ||
| 268 | ID (optional) | ||
| 269 | </label> | ||
| 270 | <Input | ||
| 271 | id="organization-id" | ||
| 272 | value={organizationForm.id} | ||
| 273 | onChange={(event) => | ||
| 274 | setOrganizationForm((current) => ({ ...current, id: event.target.value })) | ||
| 275 | } | ||
| 276 | placeholder="org_local" | ||
| 277 | disabled={organizationsLoading} | ||
| 278 | /> | ||
| 279 | </div> | ||
| 280 | <div className="grid gap-1.5"> | ||
| 281 | <label className="text-xs text-muted-foreground" htmlFor="organization-slug"> | ||
| 282 | Slug | ||
| 283 | </label> | ||
| 284 | <Input | ||
| 285 | id="organization-slug" | ||
| 286 | value={organizationForm.slug} | ||
| 287 | onChange={(event) => | ||
| 288 | setOrganizationForm((current) => ({ ...current, slug: event.target.value })) | ||
| 289 | } | ||
| 290 | placeholder="acme" | ||
| 291 | required | ||
| 292 | disabled={organizationsLoading} | ||
| 293 | /> | ||
| 294 | </div> | ||
| 295 | <div className="grid gap-1.5"> | ||
| 296 | <label className="text-xs text-muted-foreground" htmlFor="organization-name"> | ||
| 297 | Name | ||
| 298 | </label> | ||
| 299 | <Input | ||
| 300 | id="organization-name" | ||
| 301 | value={organizationForm.name} | ||
| 302 | onChange={(event) => | ||
| 303 | setOrganizationForm((current) => ({ ...current, name: event.target.value })) | ||
| 304 | } | ||
| 305 | placeholder="Acme" | ||
| 306 | required | ||
| 307 | disabled={organizationsLoading} | ||
| 308 | /> | ||
| 309 | </div> | ||
| 310 | <div className="grid gap-1.5"> | ||
| 311 | <label className="text-xs text-muted-foreground" htmlFor="organization-status"> | ||
| 312 | Status | ||
| 313 | </label> | ||
| 314 | <Select | ||
| 315 | id="organization-status" | ||
| 316 | value={organizationForm.status} | ||
| 317 | onChange={(event) => | ||
| 318 | setOrganizationForm((current) => ({ | ||
| 319 | ...current, | ||
| 320 | status: event.target.value as Organization["status"], | ||
| 321 | })) | ||
| 322 | } | ||
| 323 | disabled={organizationsLoading} | ||
| 324 | > | ||
| 325 | {organizationStatusOptions.map((status) => ( | ||
| 326 | <option key={status} value={status}> | ||
| 327 | {status} | ||
| 328 | </option> | ||
| 329 | ))} | ||
| 330 | </Select> | ||
| 331 | </div> | ||
| 332 | |||
| 333 | <div className="flex gap-2"> | ||
| 334 | <Button type="submit" disabled={organizationsLoading}> | ||
| 335 | Save Organization | ||
| 336 | </Button> | ||
| 337 | </div> | ||
| 338 | </form> | ||
| 339 | |||
| 340 | <StatusMessage | ||
| 341 | message={organizationStatusText} | ||
| 342 | variant={statusVariant(organizationStatusText)} | ||
| 343 | className="text-[13px]" | ||
| 344 | /> | ||
| 345 | </CardContent> | ||
| 346 | </Card> | ||
| 347 | |||
| 348 | <Card className="border-border/70"> | ||
| 349 | <CardHeader className="pb-3"> | ||
| 350 | <CardTitle>Organizations</CardTitle> | ||
| 351 | <CardDescription>Available organizations from the control plane.</CardDescription> | ||
| 352 | </CardHeader> | ||
| 353 | |||
| 354 | <CardContent className="space-y-3"> | ||
| 355 | {matchState(organizations, { | ||
| 356 | loading: "Loading organizations...", | ||
| 357 | empty: "No organizations yet.", | ||
| 358 | ready: (organizationItems) => ( | ||
| 359 | <> | ||
| 360 | {organizationItems.map((organization) => ( | ||
| 361 | <div | ||
| 362 | key={organization.id} | ||
| 363 | className="rounded-lg border border-border bg-background/70 p-3" | ||
| 364 | > | ||
| 365 | <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between"> | ||
| 366 | <div className="min-w-0 space-y-1"> | ||
| 367 | <p className="truncate text-sm font-medium">{organization.name}</p> | ||
| 368 | <div className="flex flex-wrap items-center gap-1.5 text-xs text-muted-foreground"> | ||
| 369 | <Badge variant={organizationStatusVariant(organization.status)}>{organization.status}</Badge> | ||
| 370 | <span className="break-all">{organization.slug}</span> | ||
| 371 | <span className="break-all">{organization.id}</span> | ||
| 372 | </div> | ||
| 373 | </div> | ||
| 374 | <Button | ||
| 375 | type="button" | ||
| 376 | size="sm" | ||
| 377 | variant="outline" | ||
| 378 | onClick={() => { | ||
| 379 | handleLoadOrganization(organization); | ||
| 380 | }} | ||
| 381 | > | ||
| 382 | Load | ||
| 383 | </Button> | ||
| 384 | </div> | ||
| 385 | </div> | ||
| 386 | ))} | ||
| 387 | </> | ||
| 388 | ), | ||
| 389 | })} | ||
| 390 | </CardContent> | ||
| 391 | </Card> | ||
| 392 | </div> | ||
| 393 | </section> | ||
| 394 | |||
| 395 | <section className="space-y-5"> | ||
| 396 | <div className="grid gap-5 lg:grid-cols-2"> | ||
| 397 | <Card className="border-border/70"> | ||
| 398 | <CardHeader className="pb-3"> | ||
| 399 | <CardTitle>Workspace Profile</CardTitle> | ||
| 400 | <CardDescription> | ||
| 401 | Create or update workspace records scoped to an organization. | ||
| 402 | </CardDescription> | ||
| 403 | </CardHeader> | ||
| 404 | |||
| 405 | <CardContent className="space-y-4"> | ||
| 406 | <form className="space-y-3" onSubmit={handleUpsertWorkspace}> | ||
| 407 | <div className="grid gap-1.5"> | ||
| 408 | <label className="text-xs text-muted-foreground" htmlFor="workspace-id"> | ||
| 409 | ID (optional) | ||
| 410 | </label> | ||
| 411 | <Input | ||
| 412 | id="workspace-id" | ||
| 413 | value={workspaceForm.id} | ||
| 414 | onChange={(event) => | ||
| 415 | setWorkspaceForm((current) => ({ ...current, id: event.target.value })) | ||
| 416 | } | ||
| 417 | placeholder="ws_local" | ||
| 418 | disabled={workspacesLoading} | ||
| 419 | /> | ||
| 420 | </div> | ||
| 421 | <div className="grid gap-1.5"> | ||
| 422 | <label className="text-xs text-muted-foreground" htmlFor="workspace-name"> | ||
| 423 | Name | ||
| 424 | </label> | ||
| 425 | <Input | ||
| 426 | id="workspace-name" | ||
| 427 | value={workspaceForm.name} | ||
| 428 | onChange={(event) => | ||
| 429 | setWorkspaceForm((current) => ({ ...current, name: event.target.value })) | ||
| 430 | } | ||
| 431 | placeholder="Local Workspace" | ||
| 432 | required | ||
| 433 | disabled={workspacesLoading} | ||
| 434 | /> | ||
| 435 | </div> | ||
| 436 | <div className="grid gap-1.5"> | ||
| 437 | <label className="text-xs text-muted-foreground" htmlFor="workspace-organization-id"> | ||
| 438 | Organization | ||
| 439 | </label> | ||
| 440 | <Select | ||
| 441 | id="workspace-organization-id" | ||
| 442 | value={workspaceForm.organizationId} | ||
| 443 | onChange={(event) => | ||
| 444 | setWorkspaceForm((current) => ({ | ||
| 445 | ...current, | ||
| 446 | organizationId: event.target.value, | ||
| 447 | })) | ||
| 448 | } | ||
| 449 | disabled={workspacesLoading} | ||
| 450 | > | ||
| 451 | <option value="">Select organization</option> | ||
| 452 | {organizations.items.map((organization) => ( | ||
| 453 | <option key={organization.id} value={organization.id}> | ||
| 454 | {organization.name} | ||
| 455 | </option> | ||
| 456 | ))} | ||
| 457 | </Select> | ||
| 458 | </div> | ||
| 459 | |||
| 460 | <div className="flex gap-2"> | ||
| 461 | <Button type="submit" disabled={workspacesLoading}> | ||
| 462 | Save Workspace | ||
| 463 | </Button> | ||
| 464 | </div> | ||
| 465 | </form> | ||
| 466 | |||
| 467 | <StatusMessage | ||
| 468 | message={workspaceStatusText} | ||
| 469 | variant={statusVariant(workspaceStatusText)} | ||
| 470 | className="text-[13px]" | ||
| 471 | /> | ||
| 472 | </CardContent> | ||
| 473 | </Card> | ||
| 474 | |||
| 475 | <Card className="border-border/70"> | ||
| 476 | <CardHeader className="pb-3"> | ||
| 477 | <CardTitle>Workspaces</CardTitle> | ||
| 478 | <CardDescription>Available workspaces from the control plane.</CardDescription> | ||
| 479 | </CardHeader> | ||
| 480 | |||
| 481 | <CardContent className="space-y-3"> | ||
| 482 | {matchState(workspaces, { | ||
| 483 | loading: "Loading workspaces...", | ||
| 484 | empty: "No workspaces yet.", | ||
| 485 | ready: (workspaceItems) => ( | ||
| 486 | <> | ||
| 487 | {workspaceItems.map((workspace) => ( | ||
| 488 | <div | ||
| 489 | key={workspace.id} | ||
| 490 | className="rounded-lg border border-border bg-background/70 p-3" | ||
| 491 | > | ||
| 492 | <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between"> | ||
| 493 | <div className="min-w-0 space-y-1"> | ||
| 494 | <p className="truncate text-sm font-medium">{workspace.name}</p> | ||
| 495 | <div className="flex flex-wrap items-center gap-1.5 text-xs text-muted-foreground"> | ||
| 496 | <span className="break-all">{workspace.id}</span> | ||
| 497 | <span className="break-all">org {workspace.organizationId}</span> | ||
| 498 | </div> | ||
| 499 | </div> | ||
| 500 | <Button | ||
| 501 | type="button" | ||
| 502 | size="sm" | ||
| 503 | variant="outline" | ||
| 504 | onClick={() => { | ||
| 505 | handleLoadWorkspace(workspace); | ||
| 506 | }} | ||
| 507 | > | ||
| 508 | Load | ||
| 509 | </Button> | ||
| 510 | </div> | ||
| 511 | </div> | ||
| 512 | ))} | ||
| 513 | </> | ||
| 514 | ), | ||
| 515 | })} | ||
| 516 | </CardContent> | ||
| 517 | </Card> | ||
| 518 | </div> | ||
| 519 | </section> | ||
| 520 | </section> | ||
| 521 | ); | ||
| 522 | } | ||
| @@ -0,0 +1,19 @@ | |||
| 1 | import { cn } from "../../lib/utils"; | ||
| 2 | |||
| 3 | type EmptyStateProps = { | ||
| 4 | message: string; | ||
| 5 | className?: string; | ||
| 6 | }; | ||
| 7 | |||
| 8 | export function EmptyState({ message, className }: EmptyStateProps) { | ||
| 9 | return ( | ||
| 10 | <div | ||
| 11 | className={cn( | ||
| 12 | "flex items-center justify-center rounded-md border border-dashed border-border py-8 text-[13px] text-muted-foreground", | ||
| 13 | className, | ||
| 14 | )} | ||
| 15 | > | ||
| 16 | {message} | ||
| 17 | </div> | ||
| 18 | ); | ||
| 19 | } | ||
| @@ -0,0 +1,23 @@ | |||
| 1 | import { cn } from "../../lib/utils"; | ||
| 2 | |||
| 3 | type LoadingStateProps = { | ||
| 4 | message?: string; | ||
| 5 | className?: string; | ||
| 6 | }; | ||
| 7 | |||
| 8 | export function LoadingState({ message = "Loading...", className }: LoadingStateProps) { | ||
| 9 | return ( | ||
| 10 | <div | ||
| 11 | className={cn( | ||
| 12 | "flex items-center gap-2 rounded-md border border-border bg-muted/30 px-3 py-2 text-[13px] text-muted-foreground", | ||
| 13 | className, | ||
| 14 | )} | ||
| 15 | > | ||
| 16 | <svg className="size-3.5 animate-spin" viewBox="0 0 16 16" fill="none"> | ||
| 17 | <circle cx="8" cy="8" r="6" stroke="currentColor" strokeWidth="1.5" opacity="0.25" /> | ||
| 18 | <path d="M14 8a6 6 0 00-6-6" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" /> | ||
| 19 | </svg> | ||
| 20 | {message} | ||
| 21 | </div> | ||
| 22 | ); | ||
| 23 | } | ||
| @@ -0,0 +1,55 @@ | |||
| 1 | import type { ReactNode } from "react"; | ||
| 2 | |||
| 3 | import type { EntityState } from "../../lib/control-plane/atoms"; | ||
| 4 | import { EmptyState } from "./empty-state"; | ||
| 5 | import { LoadingState } from "./loading-state"; | ||
| 6 | import { StatusMessage } from "./status-message"; | ||
| 7 | |||
| 8 | // --------------------------------------------------------------------------- | ||
| 9 | // matchState — eliminates the repeated loading/error/empty conditionals | ||
| 10 | // across every view component. | ||
| 11 | // | ||
| 12 | // Usage: | ||
| 13 | // matchState(state, { | ||
| 14 | // loading: "Loading sources...", | ||
| 15 | // empty: sourceItems.length === 0 ? "No sources yet." : "No matches.", | ||
| 16 | // ready: (items) => <SourceList items={items} />, | ||
| 17 | // }) | ||
| 18 | // | ||
| 19 | // The `filteredCount` option lets you provide a filtered subset for the empty | ||
| 20 | // check while the full item list is still used for the "ready" callback. | ||
| 21 | // --------------------------------------------------------------------------- | ||
| 22 | |||
| 23 | type MatchStateOptions<T> = { | ||
| 24 | loading?: string; | ||
| 25 | empty: string | null; | ||
| 26 | ready: (items: ReadonlyArray<T>) => ReactNode; | ||
| 27 | filteredCount?: number; | ||
| 28 | }; | ||
| 29 | |||
| 30 | export function matchState<T>( | ||
| 31 | state: EntityState<T>, | ||
| 32 | options: MatchStateOptions<T>, | ||
| 33 | ): ReactNode { | ||
| 34 | if (state.state === "loading") { | ||
| 35 | return <LoadingState message={options.loading ?? "Loading..."} />; | ||
| 36 | } | ||
| 37 | |||
| 38 | const isEmpty = | ||
| 39 | options.filteredCount !== undefined | ||
| 40 | ? options.filteredCount === 0 | ||
| 41 | : state.items.length === 0; | ||
| 42 | |||
| 43 | return ( | ||
| 44 | <> | ||
| 45 | {state.state === "error" ? ( | ||
| 46 | <StatusMessage message={state.message} variant="error" /> | ||
| 47 | ) : null} | ||
| 48 | {isEmpty | ||
| 49 | ? options.empty !== null | ||
| 50 | ? <EmptyState message={options.empty} /> | ||
| 51 | : null | ||
| 52 | : options.ready(state.items)} | ||
| 53 | </> | ||
| 54 | ); | ||
| 55 | } | ||
| @@ -0,0 +1,21 @@ | |||
| 1 | import type { ReactNode } from "react"; | ||
| 2 | |||
| 3 | type PageHeaderProps = { | ||
| 4 | title: string; | ||
| 5 | description?: string; | ||
| 6 | actions?: ReactNode; | ||
| 7 | }; | ||
| 8 | |||
| 9 | export function PageHeader({ title, description, actions }: PageHeaderProps) { | ||
| 10 | return ( | ||
| 11 | <div className="flex items-start justify-between border-b border-border px-6 py-4"> | ||
| 12 | <div className="min-w-0"> | ||
| 13 | <h1 className="font-display text-lg font-semibold tracking-tight">{title}</h1> | ||
| 14 | {description ? ( | ||
| 15 | <p className="mt-0.5 text-[13px] text-muted-foreground">{description}</p> | ||
| 16 | ) : null} | ||
| 17 | </div> | ||
| 18 | {actions ? <div className="flex shrink-0 items-center gap-2">{actions}</div> : null} | ||
| 19 | </div> | ||
| 20 | ); | ||
| 21 | } | ||
| @@ -0,0 +1,25 @@ | |||
| 1 | import { cn } from "../../lib/utils"; | ||
| 2 | |||
| 3 | type StatusMessageProps = { | ||
| 4 | message: string | null; | ||
| 5 | variant?: "info" | "error"; | ||
| 6 | className?: string; | ||
| 7 | }; | ||
| 8 | |||
| 9 | export function StatusMessage({ message, variant = "info", className }: StatusMessageProps) { | ||
| 10 | if (!message) return null; | ||
| 11 | |||
| 12 | return ( | ||
| 13 | <div | ||
| 14 | className={cn( | ||
| 15 | "rounded-md border px-3 py-2 text-[13px]", | ||
| 16 | variant === "error" | ||
| 17 | ? "border-destructive/25 bg-destructive/5 text-destructive" | ||
| 18 | : "border-border bg-muted/40 text-muted-foreground", | ||
| 19 | className, | ||
| 20 | )} | ||
| 21 | > | ||
| 22 | {message} | ||
| 23 | </div> | ||
| 24 | ); | ||
| 25 | } | ||
| @@ -0,0 +1,205 @@ | |||
| 1 | "use client"; | ||
| 2 | |||
| 3 | import Link from "next/link"; | ||
| 4 | import { usePathname } from "next/navigation"; | ||
| 5 | import type { ReactNode } from "react"; | ||
| 6 | |||
| 7 | import { cn } from "../../lib/utils"; | ||
| 8 | import { ThemeSwitcher } from "./theme-switcher"; | ||
| 9 | import { WorkspaceSelector } from "./workspace-selector"; | ||
| 10 | |||
| 11 | type NavItem = { | ||
| 12 | href: string; | ||
| 13 | label: string; | ||
| 14 | icon: ReactNode; | ||
| 15 | matchPrefixes?: ReadonlyArray<string>; | ||
| 16 | children?: ReadonlyArray<NavItem>; | ||
| 17 | badge?: ReactNode; | ||
| 18 | }; | ||
| 19 | |||
| 20 | const NAV_ITEMS: ReadonlyArray<NavItem> = [ | ||
| 21 | { | ||
| 22 | href: "/tools", | ||
| 23 | label: "Tools", | ||
| 24 | icon: ( | ||
| 25 | <svg viewBox="0 0 16 16" fill="none" className="size-4"> | ||
| 26 | <path | ||
| 27 | d="M10.5 2.5L13.5 5.5L6 13H3V10L10.5 2.5Z" | ||
| 28 | stroke="currentColor" | ||
| 29 | strokeWidth="1.3" | ||
| 30 | strokeLinejoin="round" | ||
| 31 | /> | ||
| 32 | </svg> | ||
| 33 | ), | ||
| 34 | }, | ||
| 35 | { | ||
| 36 | href: "/credentials", | ||
| 37 | label: "Credentials", | ||
| 38 | icon: ( | ||
| 39 | <svg viewBox="0 0 16 16" fill="none" className="size-4"> | ||
| 40 | <rect x="2" y="6" width="12" height="7" rx="1.5" stroke="currentColor" strokeWidth="1.3" /> | ||
| 41 | <path d="M5 6V4.5a3 3 0 016 0V6" stroke="currentColor" strokeWidth="1.3" /> | ||
| 42 | <circle cx="8" cy="10" r="1" fill="currentColor" /> | ||
| 43 | </svg> | ||
| 44 | ), | ||
| 45 | }, | ||
| 46 | { | ||
| 47 | href: "/policies", | ||
| 48 | label: "Policies", | ||
| 49 | icon: ( | ||
| 50 | <svg viewBox="0 0 16 16" fill="none" className="size-4"> | ||
| 51 | <path | ||
| 52 | d="M8 1.5L13 4v4c0 3-2.5 5-5 6.5C5.5 13 3 11 3 8V4l5-2.5z" | ||
| 53 | stroke="currentColor" | ||
| 54 | strokeWidth="1.3" | ||
| 55 | strokeLinejoin="round" | ||
| 56 | /> | ||
| 57 | <path d="M6 8l1.5 1.5L10.5 6" stroke="currentColor" strokeWidth="1.3" strokeLinecap="round" strokeLinejoin="round" /> | ||
| 58 | </svg> | ||
| 59 | ), | ||
| 60 | }, | ||
| 61 | { | ||
| 62 | href: "/storage", | ||
| 63 | label: "Storage", | ||
| 64 | icon: ( | ||
| 65 | <svg viewBox="0 0 16 16" fill="none" className="size-4"> | ||
| 66 | <ellipse cx="8" cy="4" rx="5" ry="2" stroke="currentColor" strokeWidth="1.3" /> | ||
| 67 | <path d="M3 4v8c0 1.1 2.24 2 5 2s5-.9 5-2V4" stroke="currentColor" strokeWidth="1.3" /> | ||
| 68 | <path d="M3 8c0 1.1 2.24 2 5 2s5-.9 5-2" stroke="currentColor" strokeWidth="1.3" /> | ||
| 69 | </svg> | ||
| 70 | ), | ||
| 71 | }, | ||
| 72 | { | ||
| 73 | href: "/approvals", | ||
| 74 | label: "Approvals", | ||
| 75 | icon: ( | ||
| 76 | <svg viewBox="0 0 16 16" fill="none" className="size-4"> | ||
| 77 | <circle cx="8" cy="8" r="6" stroke="currentColor" strokeWidth="1.3" /> | ||
| 78 | <path d="M5.5 8l2 2 3.5-4" stroke="currentColor" strokeWidth="1.3" strokeLinecap="round" strokeLinejoin="round" /> | ||
| 79 | </svg> | ||
| 80 | ), | ||
| 81 | }, | ||
| 82 | { | ||
| 83 | href: "/settings", | ||
| 84 | label: "Settings", | ||
| 85 | icon: ( | ||
| 86 | <svg viewBox="0 0 16 16" fill="none" className="size-4"> | ||
| 87 | <circle cx="8" cy="8" r="2" stroke="currentColor" strokeWidth="1.3" /> | ||
| 88 | <path | ||
| 89 | d="M8 1v2M8 13v2M1 8h2M13 8h2M3 3l1.4 1.4M11.6 11.6L13 13M13 3l-1.4 1.4M4.4 11.6L3 13" | ||
| 90 | stroke="currentColor" | ||
| 91 | strokeWidth="1.3" | ||
| 92 | strokeLinecap="round" | ||
| 93 | /> | ||
| 94 | </svg> | ||
| 95 | ), | ||
| 96 | }, | ||
| 97 | ]; | ||
| 98 | |||
| 99 | const isActivePath = (pathname: string, item: NavItem): boolean => { | ||
| 100 | if (item.matchPrefixes) { | ||
| 101 | return item.matchPrefixes.some((prefix) => pathname.startsWith(prefix)); | ||
| 102 | } | ||
| 103 | if (item.href === "/") { | ||
| 104 | return pathname === "/"; | ||
| 105 | } | ||
| 106 | return pathname.startsWith(item.href); | ||
| 107 | }; | ||
| 108 | |||
| 109 | type AppShellProps = { | ||
| 110 | children: ReactNode; | ||
| 111 | authEnabled: boolean; | ||
| 112 | approvalsBadge?: ReactNode; | ||
| 113 | }; | ||
| 114 | |||
| 115 | export function AppShell({ | ||
| 116 | children, | ||
| 117 | authEnabled, | ||
| 118 | approvalsBadge, | ||
| 119 | }: AppShellProps) { | ||
| 120 | const pathname = usePathname(); | ||
| 121 | |||
| 122 | // Compact chrome: pages that manage their own scroll (full-viewport layout) | ||
| 123 | const useCompactChrome = | ||
| 124 | pathname.startsWith("/tools") || | ||
| 125 | pathname.startsWith("/approvals"); | ||
| 126 | return ( | ||
| 127 | <div className="flex h-screen overflow-hidden"> | ||
| 128 | {/* ---- Sidebar ---- */} | ||
| 129 | <aside className="flex w-[220px] shrink-0 flex-col border-r border-sidebar-border bg-sidebar"> | ||
| 130 | {/* Logo / brand */} | ||
| 131 | <div className="border-b border-sidebar-border px-3 py-2"> | ||
| 132 | <div className="min-w-0"> | ||
| 133 | <WorkspaceSelector /> | ||
| 134 | </div> | ||
| 135 | </div> | ||
| 136 | |||
| 137 | {/* Nav items */} | ||
| 138 | <nav className="flex-1 overflow-y-auto px-2 py-2"> | ||
| 139 | <ul className="space-y-0.5"> | ||
| 140 | {NAV_ITEMS.map((item) => { | ||
| 141 | const active = isActivePath(pathname, item); | ||
| 142 | const isApprovals = item.href === "/approvals"; | ||
| 143 | |||
62 more lines aren’t shown here.
This diff is large: its 83 lines aren’t shown here.
This diff is large: its 558 lines aren’t shown here.
This diff is large: its 853 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 400 lines aren’t shown here.
This diff is large: its 83 lines aren’t shown here.
This diff is large: its 946 lines aren’t shown here.
This diff is large: its 1334 lines aren’t shown here.
This diff is large: its 30 lines aren’t shown here.
This diff is large: its 41 lines aren’t shown here.
This diff is large: its 42 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 18 lines aren’t shown here.
This diff is large: its 71 lines aren’t shown here.
This diff is large: its 88 lines aren’t shown here.
This diff is large: its 81 lines aren’t shown here.
This diff is large: its 109 lines aren’t shown here.
This diff is large: its 23 lines aren’t shown here.
This diff is large: its 93 lines aren’t shown here.
This diff is large: its 79 lines aren’t shown here.
This diff is large: its 142 lines aren’t shown here.
This diff is large: its 125 lines aren’t shown here.
This diff is large: its 64 lines aren’t shown here.
This diff is large: its 33 lines aren’t shown here.
This diff is large: its 267 lines aren’t shown here.
This diff is large: its 45 lines aren’t shown here.
This diff is large: its 113 lines aren’t shown here.
This diff is large: its 129 lines aren’t shown here.
This diff is large: its 250 lines aren’t shown here.
This diff is large: its 60 lines aren’t shown here.
This diff is large: its 31 lines aren’t shown here.
This diff is large: its 131 lines aren’t shown here.
This diff is large: its 387 lines aren’t shown here.
This diff is large: its 130 lines aren’t shown here.
This diff is large: its 36 lines aren’t shown here.
This diff is large: its 86 lines aren’t shown here.
This diff is large: its 25 lines aren’t shown here.
This diff is large: its 7 lines aren’t shown here.
This diff is large: its 12 lines aren’t shown here.
This diff is large: its 2 lines aren’t shown here.
This diff is large: its 2 lines aren’t shown here.
This diff is large: its 2 lines aren’t shown here.
This diff is large: its 2 lines aren’t shown here.
This diff is large: its 295 lines aren’t shown here.
This diff is large: its 8 lines aren’t shown here.
This diff is large: its 35 lines aren’t shown here.
This diff is large: its 8 lines aren’t shown here.
This diff is large: its 6732 lines aren’t shown here.
This diff is larger than a page shows: the files after these aren’t listed. Clone the repository to see all of it.