convex 1.44.0 → 1.45.0

package/src/cli/lib/config.test.ts

@@ -1,1026 +0,0 @@
-import {
-  vi,
-  test,
-  expect,
-  beforeEach,
-  afterEach,
-  describe,
-  MockInstance,
-  beforeAll,
-} from "vitest";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import {
-  parseProjectConfig,
-  type ProjectConfig,
-  ensureConvexFunctionsDir,
-  readProjectConfig,
-  resetUnknownKeyWarnings,
-  writeAiFilesConfig,
-} from "./config.js";
-import { Context, oneoffContext } from "../../bundler/context.js";
-import { logFailure } from "../../bundler/log.js";
-import { stripVTControlCharacters } from "util";
-
-let ctx: Context;
-let stderrSpy: MockInstance;
-
-beforeAll(async () => {
-  stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
-});
-
-beforeEach(async () => {
-  const originalContext = await oneoffContext({
-    url: undefined,
-    adminKey: undefined,
-    envFile: undefined,
-  });
-  ctx = {
-    ...originalContext,
-    crash: (args: { printedMessage: string | null }) => {
-      if (args.printedMessage !== null) {
-        logFailure(args.printedMessage);
-      }
-      throw new Error();
-    },
-  };
-  stderrSpy.mockClear();
-  resetUnknownKeyWarnings(); // Reset warning state between tests
-});
-
-const assertParses = async (
-  inp: Record<string, any>,
-  expected?: ProjectConfig,
-) => {
-  const result = await parseProjectConfig(ctx, inp);
-  expect(result).toEqual(expected ?? inp);
-};
-
-const assertParseError = async (inp: any, err: string) => {
-  stderrSpy.mockClear();
-  await expect(parseProjectConfig(ctx, inp)).rejects.toThrow();
-  const calledWith = stderrSpy.mock.calls as string[][];
-  expect(stripVTControlCharacters(calledWith[0][0])).toEqual(err);
-};
-
-test("parseProjectConfig basic valid configs", async () => {
-  await assertParses(
-    {
-      functions: "functions/",
-    },
-    {
-      functions: "functions/",
-      // default values (note that node version *has no default*
-      node: { externalPackages: [] },
-      generateCommonJSApi: false,
-      codegen: { staticApi: false, staticDataModel: false },
-    },
-  );
-
-  await assertParses(
-    {
-      functions: "functions/",
-
-      // unknown property
-      futureFeature: 123,
-
-      // deprecated
-      team: "team",
-      project: "proj",
-      prodUrl: "prodUrl",
-      authInfo: [
-        {
-          applicationID: "hello",
-          domain: "world",
-        },
-      ],
-    },
-    {
-      functions: "functions/",
-      // default values
-      node: { externalPackages: [] },
-      generateCommonJSApi: false,
-      codegen: { staticApi: false, staticDataModel: false },
-
-      // unknown properties are preserved
-      ...({ futureFeature: 123 } as any),
-
-      // deprecated
-      team: "team",
-      project: "proj",
-      prodUrl: "prodUrl",
-      authInfo: [
-        {
-          applicationID: "hello",
-          domain: "world",
-        },
-      ],
-    },
-  );
-});
-
-test("parseProjectConfig - node defaults", async () => {
-  // No node field -> gets defaulted
-  await assertParses(
-    {},
-    {
-      functions: "convex/",
-      node: { externalPackages: [] },
-      generateCommonJSApi: false,
-      codegen: { staticApi: false, staticDataModel: false },
-    },
-  );
-
-  // node exists but externalPackages missing -> gets defaulted
-  await assertParses(
-    { node: { extraField: 123 } },
-    {
-      functions: "convex/",
-      node: { externalPackages: [], ...{ extraField: 123 } },
-      generateCommonJSApi: false,
-      codegen: { staticApi: false, staticDataModel: false },
-    },
-  );
-
-  // node with nodeVersion but no externalPackages
-  await assertParses(
-    { node: { nodeVersion: "18", extraField: 123 } },
-    {
-      functions: "convex/",
-      node: { externalPackages: [], nodeVersion: "18", ...{ extraField: 123 } },
-      generateCommonJSApi: false,
-      codegen: { staticApi: false, staticDataModel: false },
-    },
-  );
-});
-
-test("parseProjectConfig - node validation errors", async () => {
-  await assertParseError(
-    { node: { externalPackages: "not-an-array" } },
-    "✖ `node.externalPackages` in `convex.json`: Expected array, received string\n",
-  );
-
-  await assertParseError(
-    { node: { externalPackages: [123] } },
-    "✖ `node.externalPackages.0` in `convex.json`: Expected string, received number\n",
-  );
-
-  await assertParseError(
-    { node: { nodeVersion: 18 } },
-    "✖ `node.nodeVersion` in `convex.json`: Expected string, received number\n",
-  );
-});
-
-test("parseProjectConfig - codegen fields", async () => {
-  // fileType with valid values
-  await assertParses(
-    { codegen: { fileType: "ts" } },
-    {
-      functions: "convex/",
-      node: { externalPackages: [] },
-      generateCommonJSApi: false,
-      codegen: { staticApi: false, staticDataModel: false, fileType: "ts" },
-    },
-  );
-
-  await assertParses(
-    { codegen: { fileType: "js/dts" } },
-    {
-      functions: "convex/",
-      node: { externalPackages: [] },
-      generateCommonJSApi: false,
-      codegen: { staticApi: false, staticDataModel: false, fileType: "js/dts" },
-    },
-  );
-
-  // legacyComponentApi
-  await assertParses(
-    { codegen: { legacyComponentApi: false } },
-    {
-      functions: "convex/",
-      node: { externalPackages: [] },
-      generateCommonJSApi: false,
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-        legacyComponentApi: false,
-      },
-    },
-  );
-
-  await assertParses(
-    { codegen: { legacyComponentApi: true } },
-    {
-      functions: "convex/",
-      node: { externalPackages: [] },
-      generateCommonJSApi: false,
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-        legacyComponentApi: true,
-      },
-    },
-  );
-});
-
-test("parseProjectConfig - codegen validation errors", async () => {
-  // Invalid fileType value
-  await assertParseError(
-    { codegen: { fileType: "invalid" } },
-    "✖ `codegen.fileType` in `convex.json`: Invalid enum value. Expected 'ts' | 'js/dts', received 'invalid'\n",
-  );
-
-  // Invalid legacyComponentApi type
-  await assertParseError(
-    { codegen: { legacyComponentApi: "yes" } },
-    "✖ `codegen.legacyComponentApi` in `convex.json`: Expected boolean, received string\n",
-  );
-
-  // Cross-field validation: generateCommonJSApi: true with fileType: "ts" should fail
-  await assertParseError(
-    { generateCommonJSApi: true, codegen: { fileType: "ts" } },
-    '✖ `generateCommonJSApi` in `convex.json`: Cannot use `generateCommonJSApi: true` with `codegen.fileType: "ts"`. CommonJS modules require JavaScript generation. Either set `codegen.fileType: "js/dts"` or remove `generateCommonJSApi`.\n',
-  );
-});
-
-test("parseProjectConfig - top-level validation", async () => {
-  await assertParseError(
-    "not-an-object",
-    "✖ Expected `convex.json` to contain an object\n",
-  );
-  await assertParseError(
-    123,
-    "✖ Expected `convex.json` to contain an object\n",
-  );
-  await assertParseError(
-    null,
-    "✖ Expected `convex.json` to contain an object\n",
-  );
-  await assertParseError([], "✖ Expected `convex.json` to contain an object\n");
-});
-
-test("ensureConvexFunctionsDir - creates functions directory", async () => {
-  let mkdirCalled = false;
-  let mkdirPath = "";
-  const testCtx = {
-    ...ctx,
-    fs: {
-      ...ctx.fs,
-      exists: () => false,
-      mkdir: (path: string) => {
-        mkdirCalled = true;
-        mkdirPath = path;
-      },
-    },
-  };
-
-  const config: ProjectConfig = {
-    functions: "my-functions/",
-    node: { externalPackages: [] },
-    generateCommonJSApi: false,
-    codegen: { staticApi: false, staticDataModel: false },
-  };
-
-  await ensureConvexFunctionsDir(testCtx, config);
-  expect(mkdirCalled).toBe(true);
-  expect(mkdirPath).toMatch(/^my-functions[\\/]$/);
-});
-
-test("ensureConvexFunctionsDir - does not write to convex.json", async () => {
-  let writeUtf8FileCalled = false;
-  const testCtx = {
-    ...ctx,
-    fs: {
-      ...ctx.fs,
-      exists: () => false,
-      writeUtf8File: () => {
-        writeUtf8FileCalled = true;
-      },
-      mkdir: () => {},
-    },
-  };
-
-  // Even with non-default config, should NOT write to convex.json
-  const config: ProjectConfig = {
-    functions: "my-functions/",
-    node: { externalPackages: ["axios"] },
-    generateCommonJSApi: true,
-    codegen: { staticApi: true, staticDataModel: true },
-  };
-
-  await ensureConvexFunctionsDir(testCtx, config);
-  expect(writeUtf8FileCalled).toBe(false);
-});
-
-test("readProjectConfig - returns defaults when file doesn't exist", async () => {
-  const testCtx = {
-    ...ctx,
-    fs: {
-      ...ctx.fs,
-      exists: () => false,
-      readUtf8File: (path: string) => {
-        // Mock package.json without react-scripts
-        if (path === "package.json") {
-          return JSON.stringify({ name: "test-app" });
-        }
-        throw new Error(`Unexpected read: ${path}`);
-      },
-    },
-  };
-
-  const { projectConfig, configPath } = await readProjectConfig(testCtx);
-
-  expect(configPath).toBe("convex.json");
-  expect(projectConfig).toEqual({
-    functions: "convex/",
-    node: { externalPackages: [] },
-    generateCommonJSApi: false,
-    codegen: { staticApi: false, staticDataModel: false },
-    aiFiles: {},
-  });
-});
-
-test("parseProjectConfig - preserves unknown properties", async () => {
-  // Unknown properties should be preserved for forward/backward compatibility
-  await assertParses(
-    {
-      functions: "convex/",
-      unknownField: "some-value",
-      futureFeature: {
-        nested: "data",
-        count: 42,
-      },
-    },
-    {
-      functions: "convex/",
-      node: { externalPackages: [] },
-      generateCommonJSApi: false,
-      codegen: { staticApi: false, staticDataModel: false },
-      unknownField: "some-value",
-      futureFeature: {
-        nested: "data",
-        count: 42,
-      },
-    } as any,
-  );
-
-  // Unknown properties alongside known ones
-  await assertParses(
-    {
-      functions: "my-functions/",
-      generateCommonJSApi: true,
-      customMetadata: {
-        version: "1.0.0",
-        author: "test",
-      },
-      experimentalFlag: true,
-    },
-    {
-      functions: "my-functions/",
-      node: { externalPackages: [] },
-      generateCommonJSApi: true,
-      codegen: { staticApi: false, staticDataModel: false },
-      customMetadata: {
-        version: "1.0.0",
-        author: "test",
-      },
-      experimentalFlag: true,
-    } as any,
-  );
-});
-
-test("parseProjectConfig - warns about unknown properties", async () => {
-  // Single unknown property
-  stderrSpy.mockClear();
-  const config1 = await parseProjectConfig(ctx, {
-    functions: "convex/",
-    unknownField: "value",
-  });
-  expect(config1.functions).toBe("convex/");
-  expect((config1 as any).unknownField).toBe("value");
-
-  // Check that warning was logged
-  const stderr1 = stderrSpy.mock.calls.map((call) => call[0]).join("");
-  expect(stripVTControlCharacters(stderr1)).toContain(
-    "Warning: Unknown property in `convex.json`: `unknownField`",
-  );
-  expect(stripVTControlCharacters(stderr1)).toContain(
-    "These properties will be preserved but are not recognized by this version of Convex",
-  );
-
-  // Multiple unknown properties
-  stderrSpy.mockClear();
-  const config2 = await parseProjectConfig(ctx, {
-    functions: "my-functions/",
-    customField1: "value1",
-    customField2: 42,
-    futureFeature: { nested: true },
-  });
-  expect((config2 as any).customField1).toBe("value1");
-  expect((config2 as any).customField2).toBe(42);
-
-  // No warning for known fields only
-  stderrSpy.mockClear();
-  await parseProjectConfig(ctx, {
-    functions: "convex/",
-    generateCommonJSApi: true,
-  });
-  const stderr3 = stderrSpy.mock.calls.map((call) => call[0]).join("");
-  expect(stripVTControlCharacters(stderr3)).not.toContain("Warning");
-  expect(stripVTControlCharacters(stderr3)).not.toContain("Unknown");
-
-  // No warning for $schema field (used by JSON schema validation)
-  stderrSpy.mockClear();
-  await parseProjectConfig(ctx, {
-    functions: "convex/",
-    $schema: "../../../convex/schemas/convex.schema.json",
-  });
-  const stderr5 = stderrSpy.mock.calls.map((call) => call[0]).join("");
-  expect(stripVTControlCharacters(stderr5)).not.toContain("Warning");
-  expect(stripVTControlCharacters(stderr5)).not.toContain("Unknown");
-});
-
-test("parseProjectConfig - aiFiles fields", async () => {
-  await assertParses(
-    {
-      functions: "convex/",
-      aiFiles: {
-        enabled: false,
-        disableStalenessMessage: true,
-        skills: {
-          agents: ["cursor", "windsurf"],
-        },
-      },
-    },
-    {
-      functions: "convex/",
-      aiFiles: {
-        enabled: false,
-        disableStalenessMessage: true,
-        skills: {
-          agents: ["cursor", "windsurf"],
-        },
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-});
-
-// AuthKit configuration tests
-test("parseProjectConfig - authKit basic valid configs", async () => {
-  // Basic config with no settings
-  await assertParses(
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {},
-      },
-    },
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {},
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-
-  // Absence of environment config means manual setup
-  // No authKit config at all is valid
-  await assertParses(
-    {
-      functions: "convex/",
-    },
-    {
-      functions: "convex/",
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-
-  // Config with configure settings
-  await assertParses(
-    {
-      functions: "convex/",
-      authKit: {
-        prod: {
-          configure: {
-            redirectUris: ["https://example.com/callback"],
-            corsOrigins: ["https://example.com"],
-          },
-        },
-      },
-    },
-    {
-      functions: "convex/",
-      authKit: {
-        prod: {
-          configure: {
-            redirectUris: ["https://example.com/callback"],
-            corsOrigins: ["https://example.com"],
-          },
-        },
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-
-  // Full config with all deployment types
-  await assertParses(
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          configure: {
-            redirectUris: ["http://localhost:5173/callback"],
-            corsOrigins: ["http://localhost:5173"],
-          },
-          localEnvVars: {
-            VITE_WORKOS_CLIENT_ID: "${authEnv.WORKOS_CLIENT_ID}",
-          },
-        },
-        preview: {
-          configure: {
-            redirectUris: ["${buildEnv.VERCEL_BRANCH_URL}/callback"],
-            corsOrigins: ["${buildEnv.VERCEL_BRANCH_URL}"],
-          },
-        },
-        prod: {
-          environmentType: "production",
-          configure: {
-            redirectUris: ["https://example.com/callback"],
-            corsOrigins: ["https://example.com"],
-          },
-        },
-      },
-    },
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          configure: {
-            redirectUris: ["http://localhost:5173/callback"],
-            corsOrigins: ["http://localhost:5173"],
-          },
-          localEnvVars: {
-            VITE_WORKOS_CLIENT_ID: "${authEnv.WORKOS_CLIENT_ID}",
-          },
-        },
-        preview: {
-          configure: {
-            redirectUris: ["${buildEnv.VERCEL_BRANCH_URL}/callback"],
-            corsOrigins: ["${buildEnv.VERCEL_BRANCH_URL}"],
-          },
-        },
-        prod: {
-          environmentType: "production",
-          configure: {
-            redirectUris: ["https://example.com/callback"],
-            corsOrigins: ["https://example.com"],
-          },
-        },
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-});
-
-test("parseProjectConfig - authKit validation errors", async () => {
-  // environmentType only allowed in prod
-  await assertParseError(
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          environmentType: "development",
-        },
-      },
-    },
-    "✖ `authKit.environmentType` in `convex.json`: authKit.environmentType is only allowed in the prod section\n",
-  );
-
-  // Invalid environmentType value
-  await assertParseError(
-    {
-      functions: "convex/",
-      authKit: {
-        prod: {
-          environmentType: "invalid" as any,
-        },
-      },
-    },
-    "✖ `authKit.prod.environmentType` in `convex.json`: Invalid enum value. Expected 'development' | 'staging' | 'production', received 'invalid'\n",
-  );
-
-  // authEnv references are allowed in localEnvVars
-  await assertParses(
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          localEnvVars: {
-            WORKOS_CLIENT_ID: "${authEnv.WORKOS_CLIENT_ID}",
-          },
-        },
-      },
-    },
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          localEnvVars: {
-            WORKOS_CLIENT_ID: "${authEnv.WORKOS_CLIENT_ID}",
-          },
-        },
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-
-  // buildEnv references are also allowed in localEnvVars
-  await assertParses(
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          localEnvVars: {
-            WORKOS_CLIENT_ID: "${buildEnv.MY_WORKOS_CLIENT_ID}",
-          },
-        },
-      },
-    },
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          localEnvVars: {
-            WORKOS_CLIENT_ID: "${buildEnv.MY_WORKOS_CLIENT_ID}",
-          },
-        },
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-
-  // authEnv references are allowed in configure
-  await assertParses(
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          configure: {
-            redirectUris: ["${authEnv.WORKOS_CLIENT_ID}/callback"],
-          },
-        },
-      },
-    },
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          configure: {
-            redirectUris: ["${authEnv.WORKOS_CLIENT_ID}/callback"],
-          },
-        },
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-
-  // Mixed buildEnv and authEnv references are allowed
-  await assertParses(
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          localEnvVars: {
-            WORKOS_CLIENT_ID: "${authEnv.WORKOS_CLIENT_ID}",
-            WORKOS_API_KEY: "${authEnv.WORKOS_API_KEY}",
-          },
-          configure: {
-            redirectUris: ["${buildEnv.VERCEL_URL}/callback"],
-          },
-        },
-      },
-    },
-    {
-      functions: "convex/",
-      authKit: {
-        dev: {
-          localEnvVars: {
-            WORKOS_CLIENT_ID: "${authEnv.WORKOS_CLIENT_ID}",
-            WORKOS_API_KEY: "${authEnv.WORKOS_API_KEY}",
-          },
-          configure: {
-            redirectUris: ["${buildEnv.VERCEL_URL}/callback"],
-          },
-        },
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-});
-
-test("parseProjectConfig - authKit preview and prod restrictions", async () => {
-  // Preview with localEnvVars should fail
-  await assertParseError(
-    {
-      authKit: {
-        preview: {
-          localEnvVars: {
-            WORKOS_CLIENT_ID: "${buildEnv.WORKOS_CLIENT_ID}",
-          },
-        },
-      },
-    },
-    "✖ `authKit.localEnvVars` in `convex.json`: authKit.localEnvVars is only supported for dev deployments. Preview and prod deployments must configure environment variables directly in the deployment platform.\n",
-  );
-
-  // Prod with localEnvVars should fail
-  await assertParseError(
-    {
-      authKit: {
-        prod: {
-          localEnvVars: {
-            WORKOS_CLIENT_ID: "${buildEnv.WORKOS_CLIENT_ID}",
-          },
-        },
-      },
-    },
-    "✖ `authKit.localEnvVars` in `convex.json`: authKit.localEnvVars is only supported for dev deployments. Preview and prod deployments must configure environment variables directly in the deployment platform.\n",
-  );
-
-  // Dev with localEnvVars should still work
-  await assertParses({
-    functions: "convex/",
-    authKit: {
-      dev: {
-        localEnvVars: {
-          WORKOS_CLIENT_ID: "${authEnv.WORKOS_CLIENT_ID}",
-        },
-      },
-    },
-    codegen: {
-      staticApi: false,
-      staticDataModel: false,
-    },
-    generateCommonJSApi: false,
-    node: {
-      externalPackages: [],
-    },
-  });
-
-  // Preview with just configure should work (will use env vars)
-  await assertParses(
-    {
-      functions: "convex/",
-      authKit: {
-        preview: {
-          configure: {
-            redirectUris: ["https://preview.example.com/callback"],
-          },
-        },
-      },
-    },
-    {
-      functions: "convex/",
-      authKit: {
-        preview: {
-          configure: {
-            redirectUris: ["https://preview.example.com/callback"],
-          },
-        },
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-
-  // Prod without localEnvVars should work
-  await assertParses(
-    {
-      functions: "convex/",
-      authKit: {
-        prod: {
-          environmentType: "production",
-        },
-      },
-    },
-    {
-      functions: "convex/",
-      authKit: {
-        prod: {
-          environmentType: "production",
-        },
-      },
-      codegen: {
-        staticApi: false,
-        staticDataModel: false,
-      },
-      generateCommonJSApi: false,
-      node: {
-        externalPackages: [],
-      },
-    },
-  );
-});
-
-// ---------------------------------------------------------------------------
-// writeAiFilesConfig
-// ---------------------------------------------------------------------------
-
-describe("writeAiFilesConfig", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(`${os.tmpdir()}${path.sep}`);
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test("creates convex.json with $schema when file does not exist", async () => {
-    await writeAiFilesConfig({
-      projectDir: tmpDir,
-      aiFiles: { enabled: false },
-    });
-
-    const written = JSON.parse(
-      fs.readFileSync(path.join(tmpDir, "convex.json"), "utf8"),
-    );
-    expect(written.$schema).toBe(
-      "node_modules/convex/schemas/convex.schema.json",
-    );
-    expect(written.aiFiles).toEqual({ enabled: false });
-  });
-
-  test("writes aiFiles as-is without merging sub-keys", async () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "convex.json"),
-      JSON.stringify({ aiFiles: { disableStalenessMessage: true } }, null, 2),
-      "utf8",
-    );
-
-    await writeAiFilesConfig({
-      projectDir: tmpDir,
-      aiFiles: { enabled: false },
-    });
-
-    const written = JSON.parse(
-      fs.readFileSync(path.join(tmpDir, "convex.json"), "utf8"),
-    );
-    expect(written.aiFiles).toEqual({ enabled: false });
-  });
-
-  test("preserves other existing fields in convex.json", async () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "convex.json"),
-      JSON.stringify(
-        {
-          functions: "src/convex/",
-          customKey: "preserved",
-          aiFiles: { skills: { agents: ["cursor"] } },
-        },
-        null,
-        2,
-      ),
-      "utf8",
-    );
-
-    await writeAiFilesConfig({
-      projectDir: tmpDir,
-      aiFiles: { enabled: false },
-    });
-
-    const written = JSON.parse(
-      fs.readFileSync(path.join(tmpDir, "convex.json"), "utf8"),
-    );
-    expect(written.functions).toBe("src/convex/");
-    expect(written.customKey).toBe("preserved");
-    expect(written.aiFiles).toEqual({ enabled: false });
-  });
-
-  test("removes aiFiles key when undefined", async () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "convex.json"),
-      JSON.stringify({ aiFiles: { enabled: false } }, null, 2),
-      "utf8",
-    );
-
-    await writeAiFilesConfig({
-      projectDir: tmpDir,
-      aiFiles: undefined,
-    });
-
-    const written = JSON.parse(
-      fs.readFileSync(path.join(tmpDir, "convex.json"), "utf8"),
-    );
-    expect(written.aiFiles).toBeUndefined();
-  });
-
-  test("preserves existing $schema when file already has one", async () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "convex.json"),
-      JSON.stringify({ $schema: "./custom-schema.json" }, null, 2),
-      "utf8",
-    );
-
-    await writeAiFilesConfig({
-      projectDir: tmpDir,
-      aiFiles: undefined,
-    });
-
-    const written = JSON.parse(
-      fs.readFileSync(path.join(tmpDir, "convex.json"), "utf8"),
-    );
-    expect(written.$schema).toBe("./custom-schema.json");
-  });
-
-  test("handles invalid JSON in existing convex.json gracefully", async () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "convex.json"),
-      "not valid json",
-      "utf8",
-    );
-
-    await writeAiFilesConfig({
-      projectDir: tmpDir,
-      aiFiles: { enabled: false },
-    });
-
-    const written = JSON.parse(
-      fs.readFileSync(path.join(tmpDir, "convex.json"), "utf8"),
-    );
-    expect(written.aiFiles).toEqual({ enabled: false });
-  });
-});