@tinacms/cli 2.2.5 → 2.2.6

package/README.md

@@ -32,11 +32,31 @@ Commands:
   schema:types [options]    Generate a GraphQL query for your site's schema, (and optionally Typescript types)
   init [options]            Add TinaCloud to an existing project
   audit [options]           Audit your schema and the files to check for errors
+  doctor [options]          Check direct TinaCMS dependencies against npm latest
   help [command]            display help for command
 ```
 
 [See our docs](https://tina.io/docs/cli-overview/) for more information about the commands.
 
+### `doctor`
+
+Use `tinacms doctor` to check whether the Tina packages installed in your
+project are current against the npm `latest` dist-tag.
+
+The command reads your `package.json`, resolves installed versions from
+`node_modules` or the project lockfile, filters to Tina package names
+(`tinacms`, `@tinacms/*`, `tinacms-*`, `next-tinacms-*`, and
+`create-tina-app`), then prints the installed version next to the latest
+published version.
+
+```bash
+pnpm tinacms doctor
+```
+
+Use `--json` for machine-readable output. The command exits with code `1` if a
+Tina package is outdated or if a package version cannot be checked, which makes
+it suitable for CI.
+
 ## Getting started
 
 The simplest way to get started is to add a `.tina/schema.ts` file

package/dist/index.js

@@ -2,7 +2,7 @@
 import { Cli, Builtins } from "clipanion";
 
 // package.json
-var version = "2.2.5";
+var version = "2.2.6";
 
 // src/next/commands/dev-command/index.ts
 import path9 from "path";
@@ -691,7 +691,7 @@ var Codegen = class {
 import { resolve } from "@tinacms/datalayer";
 import type { TinaClient } from "tinacms/dist/client";
 
-import { queries } from "./types";
+import { queries } from "${this.configManager.isUsingTs() ? "./types.ts" : "./types.js"}";
 import database from "../database";
 
 export async function databaseRequest({ query, variables, user }) {
@@ -757,7 +757,7 @@ export default databaseClient;
     const errorPolicy = this.configManager.config?.client?.errorPolicy;
     const apiURL = this.getApiURL();
     const clientString = `import { createClient } from "tinacms/dist/client";
-import { queries } from "./types";
+import { queries } from "${this.configManager.isUsingTs() ? "./types.ts" : "./types.js"}";
 export const client = createClient({ ${this.noClientBuildCache === false ? `cacheDir: '${normalizePath(
       this.configManager.generatedCachePath
     )}', ` : ""}url: ${this.localContentBuild ? `process.env.TINA_LOCAL_URL || '${apiURL}'` : `'${apiURL}'`}, token: '${token}', queries, ${errorPolicy ? `errorPolicy: '${errorPolicy}'` : ""} });
@@ -894,6 +894,7 @@ var ConfigManager = class {
   rootPath;
   tinaFolderPath;
   isUsingLegacyFolder;
+  hasWarnedLegacyFolder = false;
   tinaConfigFilePath;
   tinaSpaPackagePath;
   contentRootPath;
@@ -957,6 +958,14 @@ var ConfigManager = class {
   async processConfig() {
     const require2 = createRequire(import.meta.url);
     this.tinaFolderPath = await this.getTinaFolderPath(this.rootPath);
+    if (this.isUsingLegacyFolder && !this.hasWarnedLegacyFolder) {
+      this.hasWarnedLegacyFolder = true;
+      logger.warn(
+        warnText(
+          "WARN: Detected legacy `.tina/` config folder. `tina-lock.json` is only generated for the new `tina/` layout, and TinaCloud requires it to index your schema. Migrate by renaming `.tina/` to `tina/` (the contents stay the same). See https://tina.io/docs/tina-folder/overview/."
+        )
+      );
+    }
     this.envFilePath = path4.resolve(
       path4.join(this.tinaFolderPath, "..", ".env")
     );
@@ -1129,28 +1138,41 @@ var ConfigManager = class {
   }
   printGeneratedClientFilePath() {
     if (this.isUsingTs()) {
-      return this.generatedClientTSFilePath.replace(`${this.rootPath}/`, "");
+      return normalizePath2(
+        path4.relative(this.rootPath, this.generatedClientTSFilePath)
+      );
     }
-    return this.generatedClientJSFilePath.replace(`${this.rootPath}/`, "");
+    return normalizePath2(
+      path4.relative(this.rootPath, this.generatedClientJSFilePath)
+    );
   }
   printGeneratedTypesFilePath() {
-    return this.generatedTypesTSFilePath.replace(`${this.rootPath}/`, "");
+    return normalizePath2(
+      path4.relative(this.rootPath, this.generatedTypesTSFilePath)
+    );
   }
   printoutputHTMLFilePath() {
-    return this.outputHTMLFilePath.replace(`${this.publicFolderPath}/`, "");
+    return normalizePath2(
+      path4.relative(this.publicFolderPath, this.outputHTMLFilePath)
+    );
   }
   printRelativePath(filename) {
     if (filename) {
-      return filename.replace(/\\/g, "/").replace(`${this.rootPath}/`, "");
+      return normalizePath2(path4.relative(this.rootPath, filename));
     }
     throw `No path provided to print`;
   }
   printPrebuildFilePath() {
-    return this.prebuildFilePath.replace(/\\/g, "/").replace(`${this.rootPath}/${this.tinaFolderPath}/`, "");
+    return normalizePath2(
+      path4.relative(
+        path4.join(this.rootPath, this.tinaFolderPath),
+        this.prebuildFilePath
+      )
+    );
   }
   printContentRelativePath(filename) {
     if (filename) {
-      return filename.replace(/\\/g, "/").replace(`${this.contentRootPath}/`, "");
+      return normalizePath2(path4.relative(this.contentRootPath, filename));
     }
     throw `No path provided to print`;
   }
@@ -1499,7 +1521,7 @@ var BaseCommand = class extends Command {
             pathFilter
           });
           const tinaPathUpdates = modified.filter(
-            (path16) => path16.startsWith(".tina/__generated__/_schema.json") || path16.startsWith("tina/tina-lock.json")
+            (path17) => path17.startsWith(".tina/__generated__/_schema.json") || path17.startsWith("tina/tina-lock.json")
           );
           if (tinaPathUpdates.length > 0) {
             res = await database.indexContent({
@@ -6711,22 +6733,22 @@ var writeGeneratedFile = async ({
   content,
   typescript
 }) => {
-  const { exists, path: path16, parentPath } = generatedFile.resolve(typescript);
+  const { exists, path: path17, parentPath } = generatedFile.resolve(typescript);
   if (exists) {
     if (overwrite) {
-      logger.info(`Overwriting file at ${path16}... \u2705`);
-      fs15.outputFileSync(path16, content);
+      logger.info(`Overwriting file at ${path17}... \u2705`);
+      fs15.outputFileSync(path17, content);
     } else {
-      logger.info(`Not overwriting file at ${path16}.`);
+      logger.info(`Not overwriting file at ${path17}.`);
       logger.info(
-        logText(`Please add the following to ${path16}:
+        logText(`Please add the following to ${path17}:
 ${indentText(content)}}`)
       );
     }
   } else {
-    logger.info(`Adding file at ${path16}... \u2705`);
+    logger.info(`Adding file at ${path17}... \u2705`);
     await fs15.ensureDir(parentPath);
-    fs15.outputFileSync(path16, content);
+    fs15.outputFileSync(path17, content);
   }
 };
 var addConfigFile = async ({
@@ -7121,6 +7143,356 @@ var SearchIndexCommand = class extends Command7 {
   }
 };
 
+// src/next/commands/doctor-command/index.ts
+import { Command as Command8, Option as Option8 } from "clipanion";
+
+// src/next/commands/doctor-command/doctor.ts
+import path16 from "path";
+import fs16 from "fs-extra";
+import yaml3 from "js-yaml";
+var DEPENDENCY_TYPES = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+var LOCAL_REFERENCE_PREFIXES = [
+  "file:",
+  "link:",
+  "patch:",
+  "portal:",
+  "workspace:"
+];
+function isTinaPackage(name2) {
+  return name2 === "tinacms" || name2 === "create-tina-app" || name2.startsWith("@tinacms/") || name2.startsWith("tinacms-") || name2.startsWith("next-tinacms-");
+}
+function getTinaDependencies(packageJson) {
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const dependencyType of DEPENDENCY_TYPES) {
+    for (const [name2, declared] of Object.entries(
+      packageJson[dependencyType] || {}
+    )) {
+      if (!isTinaPackage(name2) || dependencies.has(name2)) continue;
+      dependencies.set(name2, { name: name2, declared, dependencyType });
+    }
+  }
+  return [...dependencies.values()].sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+}
+async function readProjectPackageJson(rootPath) {
+  const packageJsonPath = path16.join(rootPath, "package.json");
+  if (!await fs16.pathExists(packageJsonPath)) {
+    throw new Error(`No package.json found at ${packageJsonPath}`);
+  }
+  return fs16.readJSON(packageJsonPath);
+}
+async function resolveInstalledVersions({
+  rootPath,
+  dependencies
+}) {
+  const lockfileVersions = await readLockfileVersions(rootPath);
+  return Promise.all(
+    dependencies.map(async (dependency) => {
+      const installed = await readNodeModulesVersion(rootPath, dependency.name) || lockfileVersions.get(dependency.name);
+      return { ...dependency, installed };
+    })
+  );
+}
+async function fetchLatestVersion(packageName, timeoutMs) {
+  const controller = new AbortController();
+  const timeout2 = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}`,
+      { signal: controller.signal }
+    );
+    if (!response.ok) {
+      throw new Error(`npm registry returned ${response.status}`);
+    }
+    const body = await response.json();
+    const latest = body?.["dist-tags"]?.latest;
+    if (typeof latest !== "string" || latest.length === 0) {
+      throw new Error("npm registry response did not include dist-tags.latest");
+    }
+    return latest;
+  } finally {
+    clearTimeout(timeout2);
+  }
+}
+function classifyDependency(dependency, latest, error) {
+  if (!dependency.installed) {
+    return {
+      ...dependency,
+      latest,
+      status: "unknown",
+      error: "Installed version could not be resolved from node_modules or lockfile"
+    };
+  }
+  if (isLocalReference(dependency.installed)) {
+    return {
+      ...dependency,
+      latest,
+      status: "local",
+      error
+    };
+  }
+  if (!latest || error) {
+    return {
+      ...dependency,
+      latest,
+      status: "unknown",
+      error
+    };
+  }
+  return {
+    ...dependency,
+    latest,
+    status: normalizeVersion(dependency.installed) === normalizeVersion(latest) ? "current" : "outdated"
+  };
+}
+async function checkTinaDependencies({
+  dependencies,
+  fetchLatest
+}) {
+  return Promise.all(
+    dependencies.map(async (dependency) => {
+      try {
+        const latest = await fetchLatest(dependency.name);
+        return classifyDependency(dependency, latest);
+      } catch (error) {
+        return classifyDependency(
+          dependency,
+          void 0,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    })
+  );
+}
+function formatDoctorTable(results) {
+  const rows = [
+    ["Package", "Type", "Declared", "Installed", "Latest", "Status"],
+    ...results.map((result) => [
+      result.name,
+      result.dependencyType,
+      result.declared,
+      result.installed || "-",
+      result.latest || "-",
+      formatStatus(result)
+    ])
+  ];
+  const widths = rows[0].map(
+    (_, column) => Math.max(...rows.map((row) => row[column].length))
+  );
+  return rows.map((row, rowIndex) => {
+    const line = row.map((cell, column) => cell.padEnd(widths[column])).join("  ");
+    return rowIndex === 0 ? `${line}
+${widths.map((w) => "-".repeat(w)).join("  ")}` : line;
+  }).join("\n");
+}
+function formatStatus(result) {
+  if (result.status === "outdated") return "OUTDATED";
+  if (result.status === "local") return "LOCAL";
+  if (result.status === "unknown")
+    return `UNKNOWN${result.error ? ` (${result.error})` : ""}`;
+  return "CURRENT";
+}
+function normalizeVersion(version2) {
+  return version2.trim().replace(/^v/, "").split("(")[0].trim();
+}
+function isLocalReference(version2) {
+  const normalized = version2.trim();
+  return LOCAL_REFERENCE_PREFIXES.some(
+    (prefix) => normalized.startsWith(prefix)
+  );
+}
+async function readNodeModulesVersion(rootPath, packageName) {
+  const packageJsonPath = path16.join(
+    rootPath,
+    "node_modules",
+    ...packageName.split("/"),
+    "package.json"
+  );
+  if (!await fs16.pathExists(packageJsonPath)) return void 0;
+  const packageJson = await fs16.readJSON(packageJsonPath);
+  return typeof packageJson.version === "string" ? packageJson.version : void 0;
+}
+async function readLockfileVersions(rootPath) {
+  const readers = [
+    readPackageLockVersions,
+    readPnpmLockVersions,
+    readYarnLockVersions
+  ];
+  for (const reader of readers) {
+    const versions = await reader(rootPath);
+    if (versions.size > 0) return versions;
+  }
+  return /* @__PURE__ */ new Map();
+}
+async function readPackageLockVersions(rootPath) {
+  const lockfilePath = path16.join(rootPath, "package-lock.json");
+  const versions = /* @__PURE__ */ new Map();
+  if (!await fs16.pathExists(lockfilePath)) return versions;
+  const lockfile = await fs16.readJSON(lockfilePath);
+  for (const [key, value] of Object.entries(lockfile.packages || {})) {
+    if (!key.startsWith("node_modules/")) continue;
+    const name2 = key.replace(/^node_modules\//, "");
+    const version2 = value.version;
+    if (isTinaPackage(name2) && typeof version2 === "string") {
+      versions.set(name2, version2);
+    }
+  }
+  for (const [name2, value] of Object.entries(lockfile.dependencies || {})) {
+    const version2 = value.version;
+    if (isTinaPackage(name2) && typeof version2 === "string") {
+      versions.set(name2, version2);
+    }
+  }
+  return versions;
+}
+async function readPnpmLockVersions(rootPath) {
+  const lockfilePath = path16.join(rootPath, "pnpm-lock.yaml");
+  const versions = /* @__PURE__ */ new Map();
+  if (!await fs16.pathExists(lockfilePath)) return versions;
+  const lockfile = yaml3.load(await fs16.readFile(lockfilePath, "utf8"));
+  const rootImporter = lockfile?.importers?.["."];
+  for (const dependencyType of DEPENDENCY_TYPES) {
+    for (const [name2, value] of Object.entries(
+      rootImporter?.[dependencyType] || {}
+    )) {
+      if (!isTinaPackage(name2)) continue;
+      const version2 = typeof value === "string" ? value : typeof value.version === "string" ? value.version : void 0;
+      if (version2) versions.set(name2, normalizeInstalledVersion(version2));
+    }
+  }
+  for (const key of Object.keys(lockfile?.packages || {})) {
+    const parsed = parsePnpmPackageKey(key);
+    if (parsed && isTinaPackage(parsed.name) && !versions.has(parsed.name)) {
+      versions.set(parsed.name, parsed.version);
+    }
+  }
+  return versions;
+}
+async function readYarnLockVersions(rootPath) {
+  const lockfilePath = path16.join(rootPath, "yarn.lock");
+  const versions = /* @__PURE__ */ new Map();
+  if (!await fs16.pathExists(lockfilePath)) return versions;
+  const contents = await fs16.readFile(lockfilePath, "utf8");
+  if (contents.includes("__metadata:")) {
+    return readYarnBerryLockVersions(contents);
+  }
+  const lines = contents.split("\n");
+  let activeNames = [];
+  for (const line of lines) {
+    if (line.length > 0 && !line.startsWith(" ") && line.includes("@")) {
+      activeNames = extractYarnPackageNames(line);
+      continue;
+    }
+    const version2 = line.match(/^\s+version\s+"([^"]+)"/)?.[1];
+    if (!version2) continue;
+    for (const name2 of activeNames) {
+      if (isTinaPackage(name2) && !versions.has(name2)) {
+        versions.set(name2, version2);
+      }
+    }
+  }
+  return versions;
+}
+function readYarnBerryLockVersions(contents) {
+  const versions = /* @__PURE__ */ new Map();
+  const lockfile = yaml3.load(contents);
+  for (const [descriptor, value] of Object.entries(lockfile || {})) {
+    if (descriptor === "__metadata") continue;
+    const name2 = extractYarnBerryPackageName(descriptor);
+    const version2 = getYarnBerryInstalledVersion(descriptor, value?.version);
+    if (name2 && isTinaPackage(name2) && version2) {
+      versions.set(name2, version2);
+    }
+  }
+  return versions;
+}
+function parsePnpmPackageKey(key) {
+  const normalized = key.replace(/^\//, "");
+  const match = normalized.match(/^(@[^/]+\/[^@]+|[^@/]+)@([^(/]+)/);
+  if (!match) return void 0;
+  return { name: match[1], version: normalizeVersion(match[2]) };
+}
+function normalizeInstalledVersion(version2) {
+  return isLocalReference(version2) ? version2 : normalizeVersion(version2);
+}
+function extractYarnPackageNames(line) {
+  return line.replace(/:$/, "").split(/,\s*/).map((descriptor) => descriptor.trim().replace(/^"|"$/g, "")).map((descriptor) => {
+    if (descriptor.startsWith("@")) {
+      const [, scope, name2] = descriptor.match(/^(@[^/]+)\/([^@]+)/) || [];
+      return scope && name2 ? `${scope}/${name2}` : descriptor;
+    }
+    return descriptor.split("@")[0];
+  }).filter(Boolean);
+}
+function extractYarnBerryPackageName(descriptor) {
+  if (descriptor.startsWith("@")) {
+    return descriptor.match(/^(@[^/]+\/[^@]+)/)?.[1];
+  }
+  return descriptor.split("@")[0] || void 0;
+}
+function getYarnBerryInstalledVersion(descriptor, version2) {
+  const name2 = extractYarnBerryPackageName(descriptor);
+  const reference = name2 ? descriptor.slice(name2.length + 1) : void 0;
+  if (reference && isLocalReference(reference)) return reference;
+  return typeof version2 === "string" ? normalizeInstalledVersion(version2) : void 0;
+}
+
+// src/next/commands/doctor-command/index.ts
+var DoctorCommand = class extends Command8 {
+  static paths = [["doctor"]];
+  rootPath = Option8.String("--rootPath", {
+    description: "Specify the root directory to inspect (defaults to current working directory)"
+  });
+  json = Option8.Boolean("--json", false, {
+    description: "Print machine-readable JSON output"
+  });
+  timeout = Option8.String("--timeout", "5000", {
+    description: "npm registry request timeout in milliseconds"
+  });
+  static usage = Command8.Usage({
+    category: "Commands",
+    description: "Check direct TinaCMS dependencies against npm latest"
+  });
+  async catch(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Error occurred during tinacms doctor: ${message}`);
+    process.exit(1);
+  }
+  async execute() {
+    const rootPath = this.rootPath || process.cwd();
+    const timeoutMs = Number(this.timeout);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      logger.error("--timeout must be a positive number");
+      return 1;
+    }
+    const packageJson = await readProjectPackageJson(rootPath);
+    const dependencies = await resolveInstalledVersions({
+      rootPath,
+      dependencies: getTinaDependencies(packageJson)
+    });
+    const results = await checkTinaDependencies({
+      dependencies,
+      fetchLatest: (name2) => fetchLatestVersion(name2, timeoutMs)
+    });
+    if (this.json) {
+      logger.info(JSON.stringify({ rootPath, results }, null, 2));
+    } else if (results.length === 0) {
+      logger.info("No direct TinaCMS dependencies found.");
+    } else {
+      logger.info(formatDoctorTable(results));
+    }
+    const hasOutdated = results.some((result) => result.status === "outdated");
+    const hasUnknown = results.some((result) => result.status === "unknown");
+    return hasOutdated || hasUnknown ? 1 : 0;
+  }
+};
+
 // src/index.ts
 var cli = new Cli({
   binaryName: `tinacms`,
@@ -7133,6 +7505,7 @@ cli.register(AuditCommand);
 cli.register(InitCommand);
 cli.register(CodemodCommand);
 cli.register(SearchIndexCommand);
+cli.register(DoctorCommand);
 cli.register(Builtins.DefinitionsCommand);
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);

package/dist/next/commands/doctor-command/doctor.d.ts

@@ -0,0 +1,34 @@
+export type DoctorStatus = 'current' | 'local' | 'outdated' | 'unknown';
+export type TinaDependency = {
+    name: string;
+    declared: string;
+    dependencyType: DependencyType;
+    installed?: string;
+};
+export type DoctorResult = TinaDependency & {
+    latest?: string;
+    status: DoctorStatus;
+    error?: string;
+};
+type PackageJson = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+};
+type DependencyType = 'dependencies' | 'devDependencies' | 'optionalDependencies' | 'peerDependencies';
+export declare function isTinaPackage(name: string): boolean;
+export declare function getTinaDependencies(packageJson: PackageJson): TinaDependency[];
+export declare function readProjectPackageJson(rootPath: string): Promise<any>;
+export declare function resolveInstalledVersions({ rootPath, dependencies, }: {
+    rootPath: string;
+    dependencies: TinaDependency[];
+}): Promise<TinaDependency[]>;
+export declare function fetchLatestVersion(packageName: string, timeoutMs: number): Promise<string>;
+export declare function classifyDependency(dependency: TinaDependency, latest?: string, error?: string): DoctorResult;
+export declare function checkTinaDependencies({ dependencies, fetchLatest, }: {
+    dependencies: TinaDependency[];
+    fetchLatest: (name: string) => Promise<string>;
+}): Promise<DoctorResult[]>;
+export declare function formatDoctorTable(results: DoctorResult[]): string;
+export {};

package/dist/next/commands/doctor-command/index.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'clipanion';
+export declare class DoctorCommand extends Command {
+    static paths: string[][];
+    rootPath: string;
+    json: boolean;
+    timeout: string;
+    static usage: import("clipanion").Usage;
+    catch(error: unknown): Promise<void>;
+    execute(): Promise<number | void>;
+}

package/dist/next/config-manager.d.ts

@@ -8,6 +8,7 @@ export declare class ConfigManager {
     rootPath: string;
     tinaFolderPath: string;
     isUsingLegacyFolder: boolean;
+    private hasWarnedLegacyFolder;
     tinaConfigFilePath: string;
     tinaSpaPackagePath: string;
     contentRootPath?: string;
@@ -63,12 +64,12 @@ export declare class ConfigManager {
         minor: string;
         patch: string;
     };
-    printGeneratedClientFilePath(): string;
-    printGeneratedTypesFilePath(): string;
-    printoutputHTMLFilePath(): string;
-    printRelativePath(filename: string): string;
-    printPrebuildFilePath(): string;
-    printContentRelativePath(filename: string): string;
+    printGeneratedClientFilePath(): any;
+    printGeneratedTypesFilePath(): any;
+    printoutputHTMLFilePath(): any;
+    printRelativePath(filename: string): any;
+    printPrebuildFilePath(): any;
+    printContentRelativePath(filename: string): any;
     /**
      * Given a filepath without an extension, find the first match (eg. tsx, ts, jsx, js)
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tinacms/cli",
   "type": "module",
-  "version": "2.2.5",
+  "version": "2.2.6",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -41,7 +41,7 @@
     "@types/progress": "^2.0.7",
     "@types/prompts": "^2.4.9",
     "jest": "^29.7.0",
-    "@tinacms/scripts": "1.6.0"
+    "@tinacms/scripts": "1.6.1"
   },
   "dependencies": {
     "@graphql-codegen/core": "^2.6.8",
@@ -88,12 +88,12 @@
     "vite": "^4.5.9",
     "yup": "^1.6.1",
     "zod": "^3.24.2",
-    "@tinacms/app": "2.4.5",
-    "@tinacms/graphql": "2.3.0",
-    "@tinacms/schema-tools": "2.7.3",
+    "@tinacms/app": "2.4.6",
+    "@tinacms/graphql": "2.3.1",
     "@tinacms/metrics": "2.0.1",
-    "@tinacms/search": "1.2.12",
-    "tinacms": "3.7.5"
+    "@tinacms/search": "1.2.13",
+    "tinacms": "3.7.6",
+    "@tinacms/schema-tools": "2.7.4"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"