Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { make as makeJsonSchemaGenerator } from "@effect/openapi-generator/JsonSchemaGenerator";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import { FetchHttpClient } from "effect/unstable/http";
import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
import {
UPSTREAM_REF,
decodeJsonSchemaDocument,
fetchText,
fetchDirectoryEntries,
collectSchemaEntries,
} from "./generate/upstream.ts";
import { type GeneratedPaths, type JsonSchemaFile } from "./generate/types.ts";
import { GeneratorError } from "./generate/errors.ts";
import {
ManualSchemas,
Codex0150DefinitionSchemas,
applyCodex0151DefinitionCompatibility,
} from "./generate/compatibility.ts";
import {
normalizeNullableTypes,
stripNullDefaults,
buildJsonSchemaFiles,
rewriteExternalRefs,
} from "./generate/jsonSchema.ts";
import {
parseRequestEntries,
parseNotificationEntries,
resolveSchemaTypeName,
resolveResponseTypeName,
} from "./generate/methods.ts";
import {
renderMethodConstants,
renderTypeInterface,
renderSchemaMap,
renderSchemaTypeReference,
} from "./generate/render.ts";
const getGeneratedPaths = Effect.fn("getGeneratedPaths")(function* () {
const path = yield* Path.Path;
const generatedDir = path.join(import.meta.dirname, "..", "src", "_generated");
return {
generatedDir,
schemaOutputPath: path.join(generatedDir, "schema.gen.ts"),
metaOutputPath: path.join(generatedDir, "meta.gen.ts"),
namespacesOutputPath: path.join(generatedDir, "namespaces.gen.ts"),
} satisfies GeneratedPaths;
});
const ensureGeneratedDir = Effect.fn("ensureGeneratedDir")(function* () {
const fs = yield* FileSystem.FileSystem;
const { generatedDir } = yield* getGeneratedPaths();
yield* fs.makeDirectory(generatedDir, { recursive: true });
});
const generateFiles = Effect.fn("generateFiles")(function* () {
yield* ensureGeneratedDir();
const [rootJsonEntries, v1JsonEntries, v2JsonEntries] = yield* Effect.all([
fetchDirectoryEntries("schema/json"),
fetchDirectoryEntries("schema/json/v1"),
fetchDirectoryEntries("schema/json/v2"),
]);
const jsonSchemaFiles = [
...buildJsonSchemaFiles(rootJsonEntries),
...buildJsonSchemaFiles(v1JsonEntries),
...buildJsonSchemaFiles(v2JsonEntries),
].toSorted((left, right) => left.exportName.localeCompare(right.exportName));
const exportNameByQualifiedName = new Map(
jsonSchemaFiles.map((file) => [file.qualifiedName, file.exportName]),
);
const aggregateSchemas: Record<string, Schema.Json> = {};
for (const file of jsonSchemaFiles) {
const raw = yield* fetchText(file.downloadUrl);
const parsed = yield* decodeJsonSchemaDocument(raw);
const localDefinitionNames = new Map(
Object.keys(parsed.definitions ?? {}).map((definitionName) => [
definitionName,
`${file.exportName}__${definitionName.replace(/[^A-Za-z0-9]/g, "")}`,
]),
);
for (const [definitionName, definitionSchema] of Object.entries(parsed.definitions ?? {})) {
const compatibleDefinitionSchema =
Codex0150DefinitionSchemas.get(definitionName) ??
applyCodex0151DefinitionCompatibility(file.exportName, definitionName, definitionSchema);
aggregateSchemas[localDefinitionNames.get(definitionName)!] = stripNullDefaults(
normalizeNullableTypes(
rewriteExternalRefs(
compatibleDefinitionSchema,
localDefinitionNames,
file.namespace,
exportNameByQualifiedName,
),
),
);
}
const topLevelSchema: Record<string, Schema.Json> = {};
for (const [key, value] of Object.entries(parsed)) {
if (key !== "definitions") {
topLevelSchema[key] = value;
}
}
aggregateSchemas[file.exportName] = stripNullDefaults(
normalizeNullableTypes(
rewriteExternalRefs(
topLevelSchema,
localDefinitionNames,
file.namespace,
exportNameByQualifiedName,
),
),
);
}
for (const [name, schema] of ManualSchemas.entries()) {
if (!(name in aggregateSchemas)) {
aggregateSchemas[name] = stripNullDefaults(normalizeNullableTypes(schema));
}
}
const generator = makeJsonSchemaGenerator();
for (const [name, schema] of Object.entries(aggregateSchemas).toSorted(([left], [right]) =>
left.localeCompare(right),
)) {
// SAFETY: These are upstream JSON Schema definitions; normalization keeps their schema structure. The generator types only its supported dialect.
generator.addSchema(name, schema as never);
}
const generatedEntries = new Map<string, string>();
// SAFETY: Every entry is an upstream or explicit compatibility JSON Schema definition normalized for OpenAPI 3.1.
const output = generator.generate("openapi-3.1", aggregateSchemas as never, false).trim();
if (output.length > 0) {
for (const entry of collectSchemaEntries(output)) {
if (!generatedEntries.has(entry.name)) {
generatedEntries.set(entry.name, entry.code);
}
}
}
const generatedSchemaNames = new Set(generatedEntries.keys());
const clientRequestRaw = yield* fetchText(
`https://raw.githubusercontent.com/openai/codex/${UPSTREAM_REF}/codex-rs/app-server-protocol/schema/typescript/ClientRequest.ts`,
);
const clientNotificationRaw = yield* fetchText(
`https://raw.githubusercontent.com/openai/codex/${UPSTREAM_REF}/codex-rs/app-server-protocol/schema/typescript/ClientNotification.ts`,
);
const serverRequestRaw = yield* fetchText(
`https://raw.githubusercontent.com/openai/codex/${UPSTREAM_REF}/codex-rs/app-server-protocol/schema/typescript/ServerRequest.ts`,
);
const serverNotificationRaw = yield* fetchText(
`https://raw.githubusercontent.com/openai/codex/${UPSTREAM_REF}/codex-rs/app-server-protocol/schema/typescript/ServerNotification.ts`,
);
const clientRequestEntries = parseRequestEntries(clientRequestRaw);
const clientNotificationEntries = parseNotificationEntries(clientNotificationRaw);
const serverRequestEntries = parseRequestEntries(serverRequestRaw);
const serverNotificationEntries = parseNotificationEntries(serverNotificationRaw);
const prelude = [
"// This file is generated by the effect-codex-app-server package. Do not edit manually.",
`// Upstream protocol ref: ${UPSTREAM_REF}`,
"",
];
const schemaOutput = [
...prelude,
'import * as Schema from "effect/Schema";',
"",
[...generatedEntries.values()].join("\n\n"),
"",
].join("\n");
const metaOutput = [
...prelude,
'import * as CodexSchema from "./schema.gen.ts";',
"",
renderMethodConstants("CLIENT_REQUEST_METHODS", clientRequestEntries),
renderMethodConstants("CLIENT_NOTIFICATION_METHODS", clientNotificationEntries),
renderMethodConstants("SERVER_REQUEST_METHODS", serverRequestEntries),
renderMethodConstants("SERVER_NOTIFICATION_METHODS", serverNotificationEntries),
"export type ClientRequestMethod = keyof typeof CLIENT_REQUEST_METHODS;",
"export type ClientNotificationMethod = keyof typeof CLIENT_NOTIFICATION_METHODS;",
"export type ServerRequestMethod = keyof typeof SERVER_REQUEST_METHODS;",
"export type ServerNotificationMethod = keyof typeof SERVER_NOTIFICATION_METHODS;",
"",
renderTypeInterface("ClientRequestParamsByMethod", clientRequestEntries, (entry) =>
renderSchemaTypeReference(
resolveSchemaTypeName(entry.paramsType ?? "undefined", generatedSchemaNames),
),
),
renderTypeInterface("ClientRequestResponsesByMethod", clientRequestEntries, (entry) =>
renderSchemaTypeReference(
resolveResponseTypeName(entry.method, entry.paramsType, generatedSchemaNames),
),
),
renderTypeInterface("ClientNotificationParamsByMethod", clientNotificationEntries, (entry) =>
renderSchemaTypeReference(
resolveSchemaTypeName(entry.paramsType ?? "undefined", generatedSchemaNames),
),
),
renderTypeInterface("ServerRequestParamsByMethod", serverRequestEntries, (entry) =>
renderSchemaTypeReference(
resolveSchemaTypeName(entry.paramsType ?? "undefined", generatedSchemaNames),
),
),
renderTypeInterface("ServerRequestResponsesByMethod", serverRequestEntries, (entry) =>
renderSchemaTypeReference(
resolveResponseTypeName(entry.method, entry.paramsType, generatedSchemaNames),
),
),
renderTypeInterface("ServerNotificationParamsByMethod", serverNotificationEntries, (entry) =>
renderSchemaTypeReference(
resolveSchemaTypeName(entry.paramsType ?? "undefined", generatedSchemaNames),
),
),
renderSchemaMap("CLIENT_REQUEST_PARAMS", clientRequestEntries, (entry) =>
resolveSchemaTypeName(entry.paramsType ?? "undefined", generatedSchemaNames),
),
renderSchemaMap("CLIENT_REQUEST_RESPONSES", clientRequestEntries, (entry) =>
resolveResponseTypeName(entry.method, entry.paramsType, generatedSchemaNames),
),
renderSchemaMap("CLIENT_NOTIFICATION_PARAMS", clientNotificationEntries, (entry) =>
resolveSchemaTypeName(entry.paramsType ?? "undefined", generatedSchemaNames),
),
renderSchemaMap("SERVER_REQUEST_PARAMS", serverRequestEntries, (entry) =>
resolveSchemaTypeName(entry.paramsType ?? "undefined", generatedSchemaNames),
),
renderSchemaMap("SERVER_REQUEST_RESPONSES", serverRequestEntries, (entry) =>
resolveResponseTypeName(entry.method, entry.paramsType, generatedSchemaNames),
),
renderSchemaMap("SERVER_NOTIFICATION_PARAMS", serverNotificationEntries, (entry) =>
resolveSchemaTypeName(entry.paramsType ?? "undefined", generatedSchemaNames),
),
].join("\n");
const namespaceGroups = new Map<string, Array<JsonSchemaFile>>();
for (const file of jsonSchemaFiles) {
if (!file.namespace) {
continue;
}
const current = namespaceGroups.get(file.namespace) ?? [];
current.push(file);
namespaceGroups.set(file.namespace, current);
}
const namespacesOutput = [
...prelude,
'import * as CodexSchema from "./schema.gen.ts";',
"",
...[...namespaceGroups.entries()]
.toSorted(([left], [right]) => left.localeCompare(right))
.map(([namespace, files]) => {
const constantName = namespace.replace(/[^A-Za-z0-9]/g, "");
return [
`export const ${constantName} = {`,
...files
.toSorted((left, right) => left.fileName.localeCompare(right.fileName))
.map(
(file) =>
` ${JSON.stringify(file.fileName.replace(/\.json$/, ""))}: CodexSchema.${file.exportName},`,
),
"} as const;",
"",
].join("\n");
}),
].join("\n");
const fs = yield* FileSystem.FileSystem;
const { generatedDir, metaOutputPath, namespacesOutputPath, schemaOutputPath } =
yield* getGeneratedPaths();
yield* fs.writeFileString(schemaOutputPath, schemaOutput);
yield* fs.writeFileString(metaOutputPath, metaOutput);
yield* fs.writeFileString(namespacesOutputPath, namespacesOutput);
yield* Effect.log(`Generated Codex App Server schemas from ${UPSTREAM_REF}`);
yield* Effect.service(ChildProcessSpawner.ChildProcessSpawner).pipe(
Effect.flatMap((spawner) =>
spawner.spawn(ChildProcess.make("vp", ["fmt", generatedDir, "--write"])),
),
Effect.flatMap((child) => child.exitCode),
Effect.tap((code) =>
code === 0
? Effect.void
: Effect.fail(
new GeneratorError({
detail: `vp fmt failed with exit code ${code}`,
}),
),
),
);
});
generateFiles().pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
Logger.layer([Logger.consolePretty()]),
NodeServices.layer,
FetchHttpClient.layer,
),
),
NodeRuntime.runMain,
);