@tinacms/cli 1.0.5 → 1.0.7

package/dist/buildTina/attachPath.d.ts

@@ -10,5 +10,5 @@
  See the License for the specific language governing permissions and
  limitations under the License.
  */
-export declare const attachPath: (ctx: any, next: () => void, _options: any) => Promise<void>;
+export declare const attachPath: (ctx: any, next: () => void, options: any) => Promise<void>;
 export declare const isProjectTs: (rootPath: string) => Promise<boolean>;

package/dist/buildTina/index.d.ts

@@ -17,6 +17,7 @@ interface ClientGenOptions {
     local?: boolean;
     verbose?: boolean;
     port?: number;
+    rootPath?: string;
 }
 interface BuildOptions {
     local: boolean;
@@ -53,7 +54,7 @@ export declare class ConfigBuilder {
         graphQLSchema: DocumentNode;
         tinaSchema: any;
     }>;
-    genTypedClient({ usingTs, compiledSchema, noSDK, verbose, local, port, }: ClientGenOptions & {
+    genTypedClient({ usingTs, compiledSchema, noSDK, verbose, local, port, rootPath, }: ClientGenOptions & {
         usingTs: boolean;
         compiledSchema: any;
     }): Promise<string>;

package/dist/cmds/forestry-migrate/index.d.ts

@@ -10,7 +10,13 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-import type { TinaCloudCollection } from '@tinacms/schema-tools';
+import type { TinaCloudCollection, TinaFieldInner } from '@tinacms/schema-tools';
+export declare const generateAllCollections: ({ rootPath, }: {
+    rootPath: string;
+}) => Promise<Map<string, {
+    fields: TinaFieldInner<false>[];
+    templateObj: any;
+}>>;
 export declare const generateCollections: ({ forestryPath, rootPath, }: {
     forestryPath: string;
     rootPath: string;

package/dist/cmds/forestry-migrate/util/errorSingleton.d.ts

@@ -0,0 +1,40 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+interface NameError {
+    name: string;
+    template: string;
+    newName: string;
+}
+/**
+ * The Singleton class defines the `getInstance` method that lets clients access
+ * the unique singleton instance.
+ */
+export declare class ErrorSingleton {
+    private static instance;
+    /**
+     * The Singleton's constructor should always be private to prevent direct
+     * construction calls with the `new` operator.
+     */
+    private constructor();
+    /**
+     * The static method that controls the access to the singleton instance.
+     *
+     * This implementation let you subclass the Singleton class while keeping
+     * just one instance of each subclass around.
+     */
+    static getInstance(): ErrorSingleton;
+    private allErrorNames;
+    addErrorName(error: NameError): void;
+    printNameErrors(): void;
+}
+export {};

package/dist/cmds/forestry-migrate/util/index.d.ts

@@ -12,20 +12,24 @@ limitations under the License.
 */
 import z from 'zod';
 import type { TinaFieldInner } from '@tinacms/schema-tools';
+export declare const stringifyName: (name: string, template: string) => string;
 declare const forestryFieldWithoutField: z.ZodObject<{
     type: z.ZodUnion<[z.ZodLiteral<"text">, z.ZodLiteral<"datetime">, z.ZodLiteral<"list">, z.ZodLiteral<"file">, z.ZodLiteral<"image_gallery">, z.ZodLiteral<"textarea">, z.ZodLiteral<"tag_list">, z.ZodLiteral<"number">, z.ZodLiteral<"boolean">, z.ZodLiteral<"field_group">, z.ZodLiteral<"field_group_list">, z.ZodLiteral<"select">, z.ZodLiteral<"include">, z.ZodLiteral<"blocks">, z.ZodLiteral<"color">]>;
+    template_types: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
     name: z.ZodString;
     label: z.ZodString;
     default: z.ZodOptional<z.ZodAny>;
     config: z.ZodOptional<z.ZodObject<{
-        required: z.ZodOptional<z.ZodBoolean>;
-        use_select: z.ZodOptional<z.ZodBoolean>;
-        date_format: z.ZodOptional<z.ZodString>;
-        time_format: z.ZodOptional<z.ZodString>;
-        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        min: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        max: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        required: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        use_select: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        date_format: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        time_format: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        options: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
         source: z.ZodOptional<z.ZodObject<{
-            type: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"custom">, z.ZodLiteral<"pages">, z.ZodLiteral<"documents">, z.ZodLiteral<"simple">, z.ZodString]>>;
-            section: z.ZodOptional<z.ZodString>;
+            type: z.ZodNullable<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"custom">, z.ZodLiteral<"pages">, z.ZodLiteral<"documents">, z.ZodLiteral<"simple">, z.ZodString]>>>;
+            section: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         }, "strip", z.ZodTypeAny, {
             type?: string;
             section?: string;
@@ -36,6 +40,8 @@ declare const forestryFieldWithoutField: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         required?: boolean;
         options?: string[];
+        min?: number;
+        max?: number;
         use_select?: boolean;
         date_format?: string;
         time_format?: string;
@@ -46,6 +52,8 @@ declare const forestryFieldWithoutField: z.ZodObject<{
     }, {
         required?: boolean;
         options?: string[];
+        min?: number;
+        max?: number;
         use_select?: boolean;
         date_format?: string;
         time_format?: string;
@@ -60,6 +68,8 @@ declare const forestryFieldWithoutField: z.ZodObject<{
     config?: {
         required?: boolean;
         options?: string[];
+        min?: number;
+        max?: number;
         use_select?: boolean;
         date_format?: string;
         time_format?: string;
@@ -70,12 +80,15 @@ declare const forestryFieldWithoutField: z.ZodObject<{
     };
     name?: string;
     type?: "number" | "boolean" | "file" | "datetime" | "text" | "list" | "select" | "image_gallery" | "textarea" | "tag_list" | "field_group" | "field_group_list" | "include" | "blocks" | "color";
+    template_types?: string[];
 }, {
     default?: any;
     label?: string;
     config?: {
         required?: boolean;
         options?: string[];
+        min?: number;
+        max?: number;
         use_select?: boolean;
         date_format?: string;
         time_format?: string;
@@ -86,6 +99,7 @@ declare const forestryFieldWithoutField: z.ZodObject<{
     };
     name?: string;
     type?: "number" | "boolean" | "file" | "datetime" | "text" | "list" | "select" | "image_gallery" | "textarea" | "tag_list" | "field_group" | "field_group_list" | "include" | "blocks" | "color";
+    template_types?: string[];
 }>;
 declare type ForestryFieldWithoutFieldType = z.infer<typeof forestryFieldWithoutField>;
 interface ForestryFieldType extends ForestryFieldWithoutFieldType {
@@ -104,15 +118,25 @@ declare const FrontmatterTemplateSchema: z.ZodObject<{
     fields?: ForestryFieldType[];
     hide_body?: boolean;
 }>;
-export declare const transformForestryFieldsToTinaFields: ({ fields, collection, }: {
+export declare const transformForestryFieldsToTinaFields: ({ fields, rootPath, template, skipBlocks, }: {
     fields: z.infer<typeof FrontmatterTemplateSchema>['fields'];
-    collection: string;
+    rootPath: string;
+    template: string;
+    skipBlocks?: boolean;
 }) => TinaFieldInner<false>[];
-export declare const getFieldsFromTemplates: ({ tem, rootPath, collection, }: {
+export declare const getFieldsFromTemplates: (_args: {
     tem: string;
-    collection: string;
     rootPath: string;
-}) => TinaFieldInner<false>[];
+    skipBlocks?: boolean;
+}) => {
+    fields: TinaFieldInner<false>[];
+    templateObj: any;
+    template: {
+        label?: string;
+        hide_body?: boolean;
+        fields?: ForestryFieldType[];
+    };
+};
 export declare const parseTemplates: ({ val }: {
     val: unknown;
 }) => {

package/dist/cmds/query-gen/genTypes.d.ts

@@ -13,11 +13,13 @@ limitations under the License.
 import { GraphQLSchema } from 'graphql';
 import { TinaCloudSchema } from '@tinacms/schema-tools';
 export declare const TINA_HOST = "content.tinajs.io";
-export declare function genClient({ tinaSchema, usingTs, }: {
+export declare function genClient({ tinaSchema, usingTs, rootPath, }: {
     tinaSchema: TinaCloudSchema<false>;
     usingTs?: boolean;
+    rootPath: string;
 }, options: any): Promise<string>;
-export declare function genTypes({ schema, usingTs }: {
+export declare function genTypes({ schema, usingTs, rootPath, }: {
     schema: GraphQLSchema;
     usingTs?: boolean;
+    rootPath: string;
 }, next: () => void, options: any): Promise<void>;

package/dist/index.js

@@ -77,13 +77,14 @@ var init_media = __esm({
     import_path9 = __toModule(require("path"));
     init_utils();
     MediaModel = class {
-      constructor({ publicFolder, mediaRoot }) {
+      constructor({ rootPath: rootPath2, publicFolder, mediaRoot }) {
+        this.rootPath = rootPath2;
         this.mediaRoot = mediaRoot;
         this.publicFolder = publicFolder;
       }
       async listMedia(args) {
         try {
-          const folderPath = (0, import_path9.join)(this.publicFolder, this.mediaRoot, args.searchPath);
+          const folderPath = (0, import_path9.join)(this.rootPath, this.publicFolder, this.mediaRoot, args.searchPath);
           const searchPath = parseMediaFolder(args.searchPath);
           const filesStr = await import_fs_extra7.default.readdir(folderPath);
           const filesProm = filesStr.map(async (file) => {
@@ -144,7 +145,7 @@ var init_media = __esm({
       }
       async deleteMedia(args) {
         try {
-          const file = (0, import_path9.join)(this.publicFolder, this.mediaRoot, args.searchPath);
+          const file = (0, import_path9.join)(this.rootPath, this.publicFolder, this.mediaRoot, args.searchPath);
           await import_fs_extra7.default.stat(file);
           await import_fs_extra7.default.remove(file);
           return { ok: true };
@@ -166,7 +167,7 @@ var init_routes = __esm({
     import_multer = __toModule(require("multer"));
     init_media();
     createMediaRouter = (config2) => {
-      const mediaFolder = (0, import_path10.join)(process.cwd(), config2.publicFolder, config2.mediaRoot);
+      const mediaFolder = (0, import_path10.join)(config2.rootPath, config2.publicFolder, config2.mediaRoot);
       const storage = import_multer.default.diskStorage({
         destination: function(req, file, cb) {
           cb(null, mediaFolder);
@@ -265,6 +266,7 @@ var init_server = __esm({
       const schema = await db.getSchema();
       const mediaPaths = (_c = (_b = (_a = schema == null ? void 0 : schema.schema) == null ? void 0 : _a.config) == null ? void 0 : _b.media) == null ? void 0 : _c.tina;
       app.use("/media", createMediaRouter({
+        rootPath: db.bridge.rootPath,
         publicFolder: parseMediaFolder((mediaPaths == null ? void 0 : mediaPaths.publicFolder) || ""),
         mediaRoot: parseMediaFolder((mediaPaths == null ? void 0 : mediaPaths.mediaRoot) || "")
       }));
@@ -302,7 +304,7 @@ var commander = __toModule(require("commander"));
 
 // package.json
 var name = "@tinacms/cli";
-var version = "1.0.5";
+var version = "1.0.7";
 
 // src/cmds/audit/audit.ts
 var import_graphql = __toModule(require("@tinacms/graphql"));
@@ -366,7 +368,7 @@ var auditDocuments = async (args) => {
         includeCollection: true,
         includeTemplate: typeof collection.templates !== "undefined"
       }, topLevelDefaults);
-      const mutation = `mutation($collection: String!, $relativePath: String!, $params: DocumentMutation!) {
+      const mutation = `mutation($collection: String!, $relativePath: String!, $params: DocumentUpdateMutation!) {
         updateDocument(
           collection: $collection,
           relativePath: $relativePath,
@@ -626,9 +628,9 @@ var fileExists = ({
   }
   const filePaths = allowedTypes.map((ext) => import_path2.default.join(projectDir, `${filename}.${ext}`));
   let inputFile = void 0;
-  filePaths.every((path10) => {
-    if (import_fs_extra.default.existsSync(path10)) {
-      inputFile = path10;
+  filePaths.every((path11) => {
+    if (import_fs_extra.default.existsSync(path11)) {
+      inputFile = path11;
       return false;
     }
     return true;
@@ -646,9 +648,9 @@ var getPath = ({
   }
   const filePaths = allowedTypes.map((ext) => import_path2.default.join(projectDir, `${filename}.${ext}`));
   let inputFile = void 0;
-  filePaths.every((path10) => {
-    if (import_fs_extra.default.existsSync(path10)) {
-      inputFile = path10;
+  filePaths.every((path11) => {
+    if (import_fs_extra.default.existsSync(path11)) {
+      inputFile = path11;
       return false;
     }
     return true;
@@ -724,15 +726,15 @@ var cleanup = async ({ tinaTempPath }) => {
   await import_fs_extra2.default.remove(tinaTempPath);
 };
 var compileFile = async (options, fileName) => {
-  const root2 = options.rootPath;
-  if (!root2) {
+  const root = options.rootPath;
+  if (!root) {
     throw new Error("ctx.rootPath has not been attached");
   }
-  const tinaPath = import_path3.default.join(root2, ".tina");
-  const tsConfigPath = import_path3.default.join(root2, "tsconfig.json");
+  const tinaPath = import_path3.default.join(root, ".tina");
+  const tsConfigPath = import_path3.default.join(root, "tsconfig.json");
   const tinaGeneratedPath = import_path3.default.join(tinaPath, "__generated__");
   const tinaTempPath = import_path3.default.join(tinaGeneratedPath, `temp_${fileName}`);
-  const packageJSONFilePath = import_path3.default.join(root2, "package.json");
+  const packageJSONFilePath = import_path3.default.join(root, "package.json");
   if (!options.schemaFileType) {
     const usingTs = await import_fs_extra2.default.pathExists(tsConfigPath);
     options = __spreadProps(__spreadValues({}, options), { schemaFileType: usingTs ? "ts" : "js" });
@@ -783,8 +785,8 @@ var compileFile = async (options, fileName) => {
   return returnObject;
 };
 var compileSchema = async (options) => {
-  const root2 = options.rootPath;
-  const tinaPath = import_path3.default.join(root2, ".tina");
+  const root = options.rootPath;
+  const tinaPath = import_path3.default.join(root, ".tina");
   const tinaGeneratedPath = import_path3.default.join(tinaPath, "__generated__");
   const tinaConfigPath = import_path3.default.join(tinaGeneratedPath, "config");
   const schemaExists = fileExists({
@@ -1081,13 +1083,13 @@ var loadGraphQLDocuments = async (globPath) => {
 // src/cmds/query-gen/genTypes.ts
 var import_esbuild2 = __toModule(require("esbuild"));
 var TINA_HOST = "content.tinajs.io";
-var root = process.cwd();
-var generatedPath = import_path5.default.join(root, ".tina", "__generated__");
 async function genClient({
   tinaSchema,
-  usingTs
+  usingTs,
+  rootPath: rootPath2
 }, options) {
   var _a, _b, _c, _d, _e;
+  const generatedPath = import_path5.default.join(rootPath2, ".tina", "__generated__");
   const branch = (_a = tinaSchema == null ? void 0 : tinaSchema.config) == null ? void 0 : _a.branch;
   const clientId = (_b = tinaSchema == null ? void 0 : tinaSchema.config) == null ? void 0 : _b.clientId;
   const token = (_c = tinaSchema.config) == null ? void 0 : _c.token;
@@ -1111,12 +1113,16 @@ export default client;
   `);
   return apiURL;
 }
-async function genTypes({ schema, usingTs }, next, options) {
-  const typesPath = process.cwd() + "/.tina/__generated__/types.ts";
-  const typesJSPath = process.cwd() + "/.tina/__generated__/types.js";
-  const typesDPath = process.cwd() + "/.tina/__generated__/types.d.ts";
-  const fragPath = process.cwd() + "/.tina/__generated__/*.{graphql,gql}";
-  const queryPathGlob = process.cwd() + "/.tina/queries/**/*.{graphql,gql}";
+async function genTypes({
+  schema,
+  usingTs,
+  rootPath: rootPath2
+}, next, options) {
+  const typesPath = rootPath2 + "/.tina/__generated__/types.ts";
+  const typesJSPath = rootPath2 + "/.tina/__generated__/types.js";
+  const typesDPath = rootPath2 + "/.tina/__generated__/types.d.ts";
+  const fragPath = rootPath2 + "/.tina/__generated__/*.{graphql,gql}";
+  const queryPathGlob = rootPath2 + "/.tina/queries/**/*.{graphql,gql}";
   const typescriptTypes = await generateTypes(schema, queryPathGlob, fragPath, options);
   const code = `//@ts-nocheck
   // DO NOT MODIFY THIS FILE. This file is automatically generated by Tina
@@ -1137,7 +1143,7 @@ async function genTypes({ schema, usingTs }, next, options) {
     await import_fs_extra3.default.outputFile(typesJSPath, jsCode.code);
   }
   const schemaString = await (0, import_graphql8.printSchema)(schema);
-  const schemaPath = process.cwd() + "/.tina/__generated__/schema.gql";
+  const schemaPath = rootPath2 + "/.tina/__generated__/schema.gql";
   await import_fs_extra3.default.outputFile(schemaPath, `# DO NOT MODIFY THIS FILE. This file is automatically generated by Tina
 ${schemaString}
 schema {
@@ -1219,7 +1225,7 @@ var import_app = __toModule(require("@tinacms/app"));
 
 // src/utils/spinner.ts
 var import_cli_spinner = __toModule(require("cli-spinner"));
-async function spin({
+async function localSpin({
   waitFor,
   text
 }) {
@@ -1238,12 +1244,26 @@ async function spin({
   console.log("");
   return res;
 }
+function spin({
+  waitFor,
+  text
+}) {
+  if (process.env.CI) {
+    console.log(text);
+    return waitFor();
+  } else {
+    return localSpin({
+      text,
+      waitFor
+    });
+  }
+}
 
 // src/buildTina/attachPath.ts
 var import_fs_extra5 = __toModule(require("fs-extra"));
 var import_path7 = __toModule(require("path"));
-var attachPath = async (ctx, next, _options) => {
-  ctx.rootPath = process.cwd();
+var attachPath = async (ctx, next, options) => {
+  ctx.rootPath = options.rootPath || process.cwd();
   ctx.usingTs = await isProjectTs(ctx.rootPath);
   next();
 };
@@ -1310,6 +1330,7 @@ var buildCmdBuild = async (ctx, next, options) => {
     noSDK: options.noSDK,
     verbose: options.verbose,
     usingTs: ctx.usingTs,
+    rootPath: ctx.rootPath,
     port: options.port
   });
   ctx.apiUrl = apiUrl;
@@ -1340,6 +1361,7 @@ var ConfigBuilder = class {
     this.database = database;
   }
   async build({ dev, verbose, rootPath: rootPath2, local }) {
+    var _a, _b, _c;
     const usingTs = await isProjectTs(rootPath2);
     if (!rootPath2) {
       throw new Error("Root path has not been attached");
@@ -1359,6 +1381,23 @@ var ConfigBuilder = class {
       dev,
       rootPath: rootPath2
     });
+    if (this.database.bridge.addOutputPath && ((_a = compiledSchema.config) == null ? void 0 : _a.localContentPath)) {
+      if ((_c = (_b = compiledSchema == null ? void 0 : compiledSchema.config) == null ? void 0 : _b.media) == null ? void 0 : _c.tina) {
+        throw new Error(`"media.tina" is not supported when the "localContentPath" property is present.`);
+      }
+      let localContentPath = compiledSchema.config.localContentPath;
+      if (!localContentPath.startsWith("/")) {
+        localContentPath = import_path8.default.join(process.cwd(), ".tina", localContentPath);
+      }
+      if (await import_fs_extra6.default.pathExists(localContentPath)) {
+        logger.info(logText(`Using separate content path ${localContentPath}`));
+      } else {
+        logger.warn(warnText(`Using separate content path ${localContentPath}
+  but no directory was found at that location, creating one...`));
+        await import_fs_extra6.default.mkdir(localContentPath);
+      }
+      this.database.bridge.addOutputPath(localContentPath);
+    }
     const { graphQLSchema, tinaSchema } = await (0, import_graphql9.buildSchema)(rootPath2, this.database, ["experimentalData", "isomorphicGitBridge"]);
     return { schema: compiledSchema, graphQLSchema, tinaSchema };
   }
@@ -1368,15 +1407,16 @@ var ConfigBuilder = class {
     noSDK,
     verbose,
     local,
-    port
+    port,
+    rootPath: rootPath2
   }) {
     const astSchema = await (0, import_graphql9.getASTSchema)(this.database);
-    await genTypes({ schema: astSchema, usingTs }, () => {
+    await genTypes({ schema: astSchema, usingTs, rootPath: rootPath2 }, () => {
     }, {
       noSDK,
       verbose
     });
-    return genClient({ tinaSchema: compiledSchema, usingTs }, {
+    return genClient({ tinaSchema: compiledSchema, usingTs, rootPath: rootPath2 }, {
       local,
       port
     });
@@ -1524,7 +1564,8 @@ async function startServer(ctx, next, {
         noSDK,
         verbose,
         usingTs: ctx.usingTs,
-        port
+        port,
+        rootPath: ctx.rootPath
       });
       await spin({
         waitFor: async () => {
@@ -1640,7 +1681,8 @@ var waitForDB = async (ctx, next, options) => {
       }
       const response = await fetch(`https://${host}/db/${clientId}/status/${branch}`, {
         method: "GET",
-        headers
+        headers,
+        cache: "no-cache"
       });
       const { status, error } = await response.json();
       const statusMessage = `Indexing status: '${status}'`;
@@ -1728,7 +1770,7 @@ stack: ${code.stack || "No stack was provided"}`);
 };
 
 // src/cmds/init/index.ts
-var import_path13 = __toModule(require("path"));
+var import_path14 = __toModule(require("path"));
 var import_prettier = __toModule(require("prettier"));
 var import_fs_extra10 = __toModule(require("fs-extra"));
 var import_prompts2 = __toModule(require("prompts"));
@@ -2076,6 +2118,44 @@ var import_fs_extra8 = __toModule(require("fs-extra"));
 var import_path12 = __toModule(require("path"));
 var import_js_yaml = __toModule(require("js-yaml"));
 var import_zod = __toModule(require("zod"));
+
+// src/cmds/forestry-migrate/util/errorSingleton.ts
+var ErrorSingleton = class {
+  constructor() {
+  }
+  static getInstance() {
+    if (!ErrorSingleton.instance) {
+      ErrorSingleton.instance = new ErrorSingleton();
+      ErrorSingleton.instance.allErrorNames = [];
+    }
+    return ErrorSingleton.instance;
+  }
+  addErrorName(error) {
+    this.allErrorNames.push(error);
+  }
+  printNameErrors() {
+    logger.error(dangerText("ERROR: TinaCMS only supports alphanumeric field names"));
+    logger.error(`If you wish to edit any of the following fields or template names you will have to update your content and code to use the new name. See ${linkText("https://tina.io/docs/forestry/common-errors/#migrating-fields-with-non-alphanumeric-characters")} for more information.`);
+    logger.error("The following template and field names have been renamed:`");
+    this.allErrorNames.forEach((error) => {
+      logger.error(`- Content that uses ${error.template}.yaml: ${error.name} -> ${error.newName}`);
+    });
+  }
+};
+
+// src/cmds/forestry-migrate/util/index.ts
+var errorSingletonInstance = ErrorSingleton.getInstance();
+var stringifyName = (name2, template) => {
+  const testRegex = /^[a-zA-Z0-9_]*$/;
+  const updateRegex = /[^a-zA-Z0-9]/g;
+  if (testRegex.test(name2)) {
+    return name2;
+  } else {
+    const newName = name2.replace(updateRegex, "_");
+    errorSingletonInstance.addErrorName({ name: name2, newName, template });
+    return newName;
+  }
+};
 var forestryConfigSchema = import_zod.default.object({
   sections: import_zod.default.array(import_zod.default.object({
     type: import_zod.default.union([
@@ -2086,13 +2166,13 @@ var forestryConfigSchema = import_zod.default.object({
       import_zod.default.literal("jekyll-posts")
     ]),
     label: import_zod.default.string(),
-    path: import_zod.default.string().optional(),
-    match: import_zod.default.string().optional(),
-    exclude: import_zod.default.string().optional(),
+    path: import_zod.default.string().optional().nullable(),
+    match: import_zod.default.string().optional().nullable(),
+    exclude: import_zod.default.string().optional().nullable(),
     create: import_zod.default.union([import_zod.default.literal("all"), import_zod.default.literal("documents"), import_zod.default.literal("none")]).optional(),
-    templates: import_zod.default.array(import_zod.default.string()).optional(),
-    new_doc_ext: import_zod.default.string().optional(),
-    read_only: import_zod.default.boolean().optional()
+    templates: import_zod.default.array(import_zod.default.string()).optional().nullable(),
+    new_doc_ext: import_zod.default.string().optional().nullable(),
+    read_only: import_zod.default.boolean().optional().nullable()
   }))
 });
 var forestryFieldWithoutField = import_zod.default.object({
@@ -2113,15 +2193,18 @@ var forestryFieldWithoutField = import_zod.default.object({
     import_zod.default.literal("blocks"),
     import_zod.default.literal("color")
   ]),
+  template_types: import_zod.default.array(import_zod.default.string()).optional().nullable(),
   name: import_zod.default.string(),
   label: import_zod.default.string(),
   default: import_zod.default.any().optional(),
   config: import_zod.default.object({
-    required: import_zod.default.boolean().optional(),
-    use_select: import_zod.default.boolean().optional(),
-    date_format: import_zod.default.string().optional(),
-    time_format: import_zod.default.string().optional(),
-    options: import_zod.default.array(import_zod.default.string()).optional(),
+    min: import_zod.default.number().optional().nullable(),
+    max: import_zod.default.number().optional().nullable(),
+    required: import_zod.default.boolean().optional().nullable(),
+    use_select: import_zod.default.boolean().optional().nullable(),
+    date_format: import_zod.default.string().optional().nullable(),
+    time_format: import_zod.default.string().optional().nullable(),
+    options: import_zod.default.array(import_zod.default.string()).optional().nullable(),
     source: import_zod.default.object({
       type: import_zod.default.union([
         import_zod.default.literal("custom"),
@@ -2129,8 +2212,8 @@ var forestryFieldWithoutField = import_zod.default.object({
         import_zod.default.literal("documents"),
         import_zod.default.literal("simple"),
         import_zod.default.string()
-      ]).optional(),
-      section: import_zod.default.string().optional()
+      ]).optional().nullable(),
+      section: import_zod.default.string().optional().nullable()
     }).optional()
   }).optional()
 });
@@ -2144,24 +2227,30 @@ var FrontmatterTemplateSchema = import_zod.default.object({
 });
 var transformForestryFieldsToTinaFields = ({
   fields,
-  collection
+  rootPath: rootPath2,
+  template,
+  skipBlocks = false
 }) => {
   const tinaFields = [];
   fields == null ? void 0 : fields.forEach((forestryField2) => {
     var _a, _b, _c, _d;
+    if (forestryField2.name === "menu") {
+      logger.info(warnText(`skipping menu field template ${template}.yaml since TinaCMS does not support Hugo or Jekyll menu fields`));
+      return;
+    }
     let field;
     switch (forestryField2.type) {
       case "text":
         field = {
           type: "string",
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label
         };
         break;
       case "textarea":
         field = {
           type: "string",
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label,
           ui: {
             component: "textarea"
@@ -2171,28 +2260,28 @@ var transformForestryFieldsToTinaFields = ({
       case "datetime":
         field = {
           type: forestryField2.type,
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label
         };
         break;
       case "number":
         field = {
           type: "number",
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label
         };
         break;
       case "boolean":
         field = {
           type: "boolean",
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label
         };
         break;
       case "color":
         field = {
           type: "string",
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label,
           ui: {
             component: "color"
@@ -2202,7 +2291,7 @@ var transformForestryFieldsToTinaFields = ({
       case "file":
         field = {
           type: "image",
-          name: forestryField2.name || "image",
+          name: stringifyName(forestryField2.name || "image", template),
           label: forestryField2.label
         };
         break;
@@ -2210,18 +2299,18 @@ var transformForestryFieldsToTinaFields = ({
         if ((_a = forestryField2.config) == null ? void 0 : _a.options) {
           field = {
             type: "string",
-            name: forestryField2.name,
+            name: stringifyName(forestryField2.name, template),
             label: forestryField2.label,
             options: ((_b = forestryField2.config) == null ? void 0 : _b.options) || []
           };
         } else {
-          logger.info(`Warning in collection ${collection}. "select" field migration has only been implemented for simple select. Other versions of select have not been implemented yet. To make your \`${forestryField2.name}\` field work, you will need to manually add it to your schema.`);
+          logger.info(warnText(`Warning in template ${template}.yaml . "select" field migration has only been implemented for simple select. Other versions of select have not been implemented yet. To make your \`${forestryField2.name}\` field work, you will need to manually add it to your schema.`));
         }
         break;
       case "list":
         field = {
           type: "string",
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label,
           list: true
         };
@@ -2232,7 +2321,7 @@ var transformForestryFieldsToTinaFields = ({
       case "tag_list":
         field = {
           type: "string",
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label,
           list: true,
           ui: {
@@ -2243,32 +2332,61 @@ var transformForestryFieldsToTinaFields = ({
       case "field_group":
         field = {
           type: "object",
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label,
           fields: transformForestryFieldsToTinaFields({
             fields: forestryField2.fields,
-            collection
+            rootPath: rootPath2,
+            template,
+            skipBlocks
           })
         };
         break;
       case "field_group_list":
         field = {
           type: "object",
-          name: forestryField2.name,
+          name: stringifyName(forestryField2.name, template),
           label: forestryField2.label,
           list: true,
           fields: transformForestryFieldsToTinaFields({
             fields: forestryField2.fields,
-            collection
+            template,
+            rootPath: rootPath2,
+            skipBlocks
           })
         };
         break;
+      case "blocks":
+        if (skipBlocks)
+          break;
+        const templates = [];
+        forestryField2 == null ? void 0 : forestryField2.template_types.forEach((tem) => {
+          const { fields: fields2, template: template2 } = getFieldsFromTemplates({
+            tem,
+            skipBlocks: true,
+            rootPath: process.cwd()
+          });
+          const t = {
+            fields: fields2,
+            label: template2.label,
+            name: stringifyName(tem, tem)
+          };
+          templates.push(t);
+        });
+        field = {
+          type: "object",
+          list: true,
+          label: forestryField2.label,
+          name: stringifyName(forestryField2.name, template),
+          templates
+        };
+        break;
       case "image_gallery":
       case "include":
-        console.log(`Unsupported field type: ${forestryField2.type}, in collection ${collection}. This will not be added to the schema.`);
+        logger.info(warnText(`Unsupported field type: ${forestryField2.type}, in forestry ${template}. This will not be added to the schema.`));
         break;
       default:
-        logger.info(`Warning in collection ${collection}. "${forestryField2.type}" migration has not been implemented yet. To make your \`${forestryField2.name}\` field work, you will need to manually add it to your schema.`);
+        logger.info(warnText(`Warning in template ${template}. "${forestryField2.type}" migration has not been implemented yet. To make your \`${forestryField2.name}\` field work, you will need to manually add it to your schema.`));
     }
     if (field) {
       if ((_d = forestryField2.config) == null ? void 0 : _d.required) {
@@ -2279,11 +2397,7 @@ var transformForestryFieldsToTinaFields = ({
   });
   return tinaFields;
 };
-var getFieldsFromTemplates = ({
-  tem,
-  rootPath: rootPath2,
-  collection
-}) => {
+var getFieldsFromTemplates = ({ tem, rootPath: rootPath2, skipBlocks = false }) => {
   const templatePath = import_path12.default.join(rootPath2, ".forestry", "front_matter", "templates", `${tem}.yml`);
   let templateString = "";
   try {
@@ -2297,9 +2411,11 @@ var getFieldsFromTemplates = ({
   const template = parseTemplates({ val: templateObj });
   const fields = transformForestryFieldsToTinaFields({
     fields: template.fields,
-    collection
+    rootPath: rootPath2,
+    template: tem,
+    skipBlocks
   });
-  return fields;
+  return { fields, templateObj, template };
 };
 var parseTemplates = ({ val }) => {
   const template = FrontmatterTemplateSchema.parse(val);
@@ -2320,44 +2436,94 @@ var parseSections = ({ val }) => {
 
 // src/cmds/forestry-migrate/index.ts
 var import_fs_extra9 = __toModule(require("fs-extra"));
+var import_path13 = __toModule(require("path"));
 var import_js_yaml2 = __toModule(require("js-yaml"));
+var import_minimatch = __toModule(require("minimatch"));
+var import_graphql10 = __toModule(require("@tinacms/graphql"));
+var BODY_FIELD = {
+  type: "rich-text",
+  name: "body",
+  label: "Body of Document",
+  description: "This is the markdown body",
+  isBody: true
+};
 var stringifyLabel = (label) => {
   return label.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
 };
+var generateAllCollections = async ({
+  rootPath: rootPath2
+}) => {
+  const allTemplates = (await import_fs_extra9.default.readdir(import_path13.default.join(rootPath2, ".forestry", "front_matter", "templates"))).map((tem) => import_path13.default.basename(tem, ".yml"));
+  const templateMap = new Map();
+  const proms = allTemplates.map(async (tem) => {
+    try {
+      const { fields, templateObj } = getFieldsFromTemplates({
+        tem,
+        rootPath: rootPath2
+      });
+      templateMap.set(tem, { fields, templateObj });
+    } catch (e) {
+      logger.log(`Error parsing template frontmatter template', tem + '.yml'`);
+      console.error(e);
+      templateMap.set(tem, { fields: [], templateObj: {} });
+    }
+  });
+  await Promise.all(proms);
+  return templateMap;
+};
 var generateCollections = async ({
   forestryPath,
   rootPath: rootPath2
 }) => {
-  var _a;
+  const templateMap = await generateAllCollections({ rootPath: rootPath2 });
   const forestryConfig = await import_fs_extra9.default.readFile(forestryPath);
   const forestryYaml = import_js_yaml2.default.load(forestryConfig.toString());
   const forestrySchema = parseSections({ val: forestryYaml });
   const collections = [];
-  (_a = forestrySchema.sections) == null ? void 0 : _a.forEach((section) => {
-    var _a2, _b;
+  const sections = forestrySchema.sections;
+  for (let index = 0; index < sections.length; index++) {
+    const section = sections[index];
     if (section.read_only)
       return;
     switch (section.type) {
       case "directory":
-        const fields = [
-          {
-            type: "rich-text",
-            name: "body",
-            label: "Body of Document",
-            description: "This is the markdown body",
-            isBody: true
+        const forestryTemplates = (section == null ? void 0 : section.templates) || [];
+        if (forestryTemplates.length === 0 && section.create === "all") {
+          for (let templateKey of templateMap.keys()) {
+            const { templateObj } = templateMap.get(templateKey);
+            const pages = templateObj == null ? void 0 : templateObj.pages;
+            if (pages) {
+              if (pages.some((page) => (0, import_minimatch.default)(page, section.path + "/" + section.match))) {
+                forestryTemplates.push(templateKey);
+              }
+            }
           }
-        ];
-        if ((((_a2 = section.templates) == null ? void 0 : _a2.length) || 0) > 1) {
+        }
+        if (((forestryTemplates == null ? void 0 : forestryTemplates.length) || 0) > 1) {
           const templates = [];
-          section.templates.forEach((tem) => {
+          forestryTemplates.forEach((tem) => {
+            var _a;
             try {
-              const fields2 = getFieldsFromTemplates({
-                tem,
-                collection: stringifyLabel(section.label),
-                rootPath: rootPath2
+              const { fields, templateObj } = templateMap.get(tem);
+              templates.push({
+                fields: [BODY_FIELD, ...fields],
+                label: tem,
+                name: stringifyLabel(tem)
+              });
+              (_a = templateObj == null ? void 0 : templateObj.pages) == null ? void 0 : _a.forEach((page) => {
+                try {
+                  const filePath = import_path13.default.join(rootPath2, page);
+                  const extname2 = import_path13.default.extname(filePath);
+                  const fileContent = import_fs_extra9.default.readFileSync(filePath).toString();
+                  const content2 = (0, import_graphql10.parseFile)(fileContent, extname2, (yup) => yup.object({}));
+                  const newContent = __spreadValues({
+                    _template: stringifyLabel(tem)
+                  }, content2);
+                  import_fs_extra9.default.writeFileSync(filePath, (0, import_graphql10.stringifyFile)(newContent, extname2, true));
+                } catch (error) {
+                  console.log("Error updating file", page);
+                }
               });
-              templates.push({ fields: fields2, label: tem, name: stringifyLabel(tem) });
             } catch (e) {
               console.log("Error parsing template ", tem);
               console.error(e);
@@ -2378,16 +2544,28 @@ var generateCollections = async ({
           }
           collections.push(c);
         } else {
-          (_b = section.templates) == null ? void 0 : _b.forEach((tem) => {
+          const fields = [BODY_FIELD];
+          forestryTemplates == null ? void 0 : forestryTemplates.forEach((tem) => {
+            var _a;
             try {
-              const additionalFields = getFieldsFromTemplates({
-                tem,
-                rootPath: rootPath2,
-                collection: stringifyLabel(section.label)
-              });
+              const { fields: additionalFields, templateObj } = templateMap.get(tem);
               fields.push(...additionalFields);
+              (_a = templateObj == null ? void 0 : templateObj.pages) == null ? void 0 : _a.forEach((page) => {
+                try {
+                  const filePath = import_path13.default.join(rootPath2, page);
+                  const extname2 = import_path13.default.extname(filePath);
+                  const fileContent = import_fs_extra9.default.readFileSync(filePath).toString();
+                  const content2 = (0, import_graphql10.parseFile)(fileContent, extname2, (yup) => yup.object({}));
+                  const newContent = __spreadValues({
+                    _template: stringifyLabel(tem)
+                  }, content2);
+                  import_fs_extra9.default.writeFileSync(filePath, (0, import_graphql10.stringifyFile)(newContent, extname2, true));
+                } catch (error) {
+                  logger.log("Error updating file", page);
+                }
+              });
             } catch (e) {
-              console.log("Error parsing template ", tem);
+              logger.log("Error parsing template ", tem);
               console.error(e);
             }
           });
@@ -2407,8 +2585,11 @@ var generateCollections = async ({
           collections.push(c);
         }
         break;
+      case "document":
+        console.log(warnText(`Single Document are not supported in TinaCMS yet. Skipping section ${section.label} (${section.path})`));
+        break;
     }
-  });
+  }
   return collections;
 };
 
@@ -2556,6 +2737,7 @@ var forestryMigrate = async ({
   rootPath: rootPath2
 }) => {
   logger.info(`It looks like you have a ${focusText(".forestry/settings.yml")} file in your project.`);
+  logger.info(`This migration will update some of your content to match tina.  Please ${focusText("save a backup of your content")} before doing this migration. (This can be done with git)`);
   const option = await (0, import_prompts2.default)({
     name: "selection",
     type: "confirm",
@@ -2567,10 +2749,18 @@ ${logText("Note: This migration will not be perfect, but it will get you started
   if (!option["selection"]) {
     return null;
   }
+  const delay = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+  await spin({
+    waitFor: async () => {
+      await delay(2e3);
+    },
+    text: ""
+  });
   const collections = await generateCollections({
     forestryPath,
     rootPath: rootPath2
   });
+  ErrorSingleton.getInstance().printNameErrors();
   return JSON.stringify(collections, null, 2);
 };
 var reportTelemetry = async ({
@@ -2597,22 +2787,22 @@ var createPackageJSON = async () => {
 };
 var createGitignore = async ({ baseDir }) => {
   logger.info(logText("No .gitignore found, creating one"));
-  await import_fs_extra10.default.outputFileSync(import_path13.default.join(baseDir, ".gitignore"), "node_modules");
+  await import_fs_extra10.default.outputFileSync(import_path14.default.join(baseDir, ".gitignore"), "node_modules");
 };
 var checkGitignoreForNodeModules = async ({
   baseDir
 }) => {
-  const gitignoreContent = await import_fs_extra10.default.readFileSync(import_path13.default.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = await import_fs_extra10.default.readFileSync(import_path14.default.join(baseDir, ".gitignore")).toString();
   return gitignoreContent.split("\n").some((item) => item === "node_modules");
 };
 var addNodeModulesToGitignore = async ({ baseDir }) => {
   logger.info(logText("Adding node_modules to .gitignore"));
-  const gitignoreContent = await import_fs_extra10.default.readFileSync(import_path13.default.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = await import_fs_extra10.default.readFileSync(import_path14.default.join(baseDir, ".gitignore")).toString();
   const newGitignoreContent = [
     ...gitignoreContent.split("\n"),
     "node_modules"
   ].join("\n");
-  await import_fs_extra10.default.writeFileSync(import_path13.default.join(baseDir, ".gitignore"), newGitignoreContent);
+  await import_fs_extra10.default.writeFileSync(import_path14.default.join(baseDir, ".gitignore"), newGitignoreContent);
 };
 var addDependencies = async (packageManager) => {
   logger.info(logText("Adding dependencies, this might take a moment..."));
@@ -2627,8 +2817,8 @@ var addDependencies = async (packageManager) => {
 };
 var addConfigFile = async (args) => {
   const { baseDir, usingTypescript } = args;
-  const configPath = import_path13.default.join(".tina", `config.${usingTypescript ? "ts" : "js"}`);
-  const fullConfigPath = import_path13.default.join(baseDir, configPath);
+  const configPath = import_path14.default.join(".tina", `config.${usingTypescript ? "ts" : "js"}`);
+  const fullConfigPath = import_path14.default.join(baseDir, configPath);
   if (import_fs_extra10.default.pathExistsSync(fullConfigPath)) {
     const override = await (0, import_prompts2.default)({
       name: "selection",
@@ -2647,8 +2837,8 @@ var addConfigFile = async (args) => {
   }
 };
 var addContentFile = async ({ baseDir }) => {
-  const contentPath = import_path13.default.join("content", "posts", "hello-world.md");
-  const fullContentPath = import_path13.default.join(baseDir, contentPath);
+  const contentPath = import_path14.default.join("content", "posts", "hello-world.md");
+  const fullContentPath = import_path14.default.join(baseDir, contentPath);
   if (import_fs_extra10.default.pathExistsSync(fullContentPath)) {
     const override = await (0, import_prompts2.default)({
       name: "selection",
@@ -2717,11 +2907,11 @@ var addReactiveFile = {
     baseDir,
     usingTypescript
   }) => {
-    const usingSrc = !import_fs_extra10.default.pathExistsSync(import_path13.default.join(baseDir, "pages"));
-    const pagesPath = import_path13.default.join(baseDir, usingSrc ? "src" : "", "pages");
-    const packageJSONPath = import_path13.default.join(baseDir, "package.json");
-    const tinaBlogPagePath = import_path13.default.join(pagesPath, "demo", "blog");
-    const tinaBlogPagePathFile = import_path13.default.join(tinaBlogPagePath, `[filename].${usingTypescript ? "tsx" : "js"}`);
+    const usingSrc = !import_fs_extra10.default.pathExistsSync(import_path14.default.join(baseDir, "pages"));
+    const pagesPath = import_path14.default.join(baseDir, usingSrc ? "src" : "", "pages");
+    const packageJSONPath = import_path14.default.join(baseDir, "package.json");
+    const tinaBlogPagePath = import_path14.default.join(pagesPath, "demo", "blog");
+    const tinaBlogPagePathFile = import_path14.default.join(tinaBlogPagePath, `[filename].${usingTypescript ? "tsx" : "js"}`);
     if (!import_fs_extra10.default.pathExistsSync(tinaBlogPagePathFile)) {
       import_fs_extra10.default.mkdirpSync(tinaBlogPagePath);
       import_fs_extra10.default.writeFileSync(tinaBlogPagePathFile, nextPostPage({ usingSrc }));
@@ -2750,27 +2940,21 @@ function execShellCommand(cmd) {
 // src/cmds/statusChecks/checkClientInformation.ts
 var import_progress2 = __toModule(require("progress"));
 async function request(args) {
-  let data = {};
   const headers = new Headers();
   if (args.token) {
     headers.append("X-API-KEY", args.token);
   }
   headers.append("Content-Type", "application/json");
-  const bodyString = JSON.stringify({
-    query: args.query,
-    variables: (args == null ? void 0 : args.variables) || {}
-  });
   const url = args == null ? void 0 : args.url;
   const res = await fetch(url, {
-    method: "POST",
+    method: "GET",
     headers,
-    body: bodyString,
     redirect: "follow"
   });
   const json = await res.json();
   if (!res.ok) {
     let additionalInfo = "";
-    if (res.status === 401) {
+    if (res.status === 401 || res.status === 403) {
       additionalInfo = "Please check that your client ID, URL and read only token are configured properly.";
     }
     if (json) {
@@ -2787,25 +2971,21 @@ Message from server: ${json.message}`;
 	${json.errors.map((error) => error.message).join("\n")}`);
   }
   return {
-    data: json == null ? void 0 : json.data,
-    query: args.query
+    status: json == null ? void 0 : json.status,
+    timestamp: json == null ? void 0 : json.timestamp
   };
 }
 var checkClientInfo = async (ctx, next, _options) => {
   var _a;
   const config2 = (_a = ctx.schema) == null ? void 0 : _a.config;
   const token = config2.token;
-  const url = ctx.apiUrl;
+  const { clientId, branch, host } = parseURL(ctx.apiUrl);
+  const url = `https://${host}/db/${clientId}/status/${branch}`;
   const bar = new import_progress2.default("Checking clientId, token and branch. :prog", 1);
   try {
     await request({
       token,
-      url,
-      query: `query {
-        collections {
-          name
-        }
-      }`
+      url
     });
     bar.tick({
       prog: "\u2705"
@@ -2838,6 +3018,10 @@ var startServerPortOption = {
   name: "--port <port>",
   description: "Specify a port to run the server on. (default 4001)"
 };
+var rootPathOption = {
+  name: "--rootPath <rootPath>",
+  description: "Specify the root directory to run the CLI from (defaults to current working directory)"
+};
 var experimentalDatalayer = {
   name: "--experimentalData",
   description: "Build the server with additional data querying capabilities"
@@ -2938,7 +3122,8 @@ var baseCmds = [
       noSDKCodegenOption,
       noTelemetryOption,
       watchFileOption,
-      verboseOption
+      verboseOption,
+      rootPathOption
     ],
     action: (options) => chain([
       attachPath,
@@ -2958,7 +3143,8 @@ var baseCmds = [
       noTelemetryOption,
       verboseOption,
       developmentOption,
-      localOption
+      localOption,
+      rootPathOption
     ],
     action: (options) => chain([
       attachPath,
@@ -2972,6 +3158,7 @@ var baseCmds = [
   {
     command: INIT,
     options: [
+      rootPathOption,
       experimentalDatalayer,
       isomorphicGitBridge,
       noTelemetryOption,
@@ -2984,6 +3171,7 @@ var baseCmds = [
   },
   {
     options: [
+      rootPathOption,
       cleanOption,
       useDefaultValuesOption,
       noTelemetryOption,

package/dist/server/models/media.d.ts

@@ -27,6 +27,7 @@ interface ListMediaRes {
     error?: string;
 }
 export interface PathConfig {
+    rootPath: string;
     publicFolder: string;
     mediaRoot: string;
 }
@@ -37,9 +38,10 @@ declare type SuccessRecord = {
     message: string;
 };
 export declare class MediaModel {
+    readonly rootPath: string;
     readonly publicFolder: string;
     readonly mediaRoot: string;
-    constructor({ publicFolder, mediaRoot }: PathConfig);
+    constructor({ rootPath, publicFolder, mediaRoot }: PathConfig);
     listMedia(args: MediaArgs): Promise<ListMediaRes>;
     deleteMedia(args: MediaArgs): Promise<SuccessRecord>;
 }

package/dist/utils/spinner.d.ts

@@ -13,4 +13,4 @@ limitations under the License.
 export declare function spin<T>({ waitFor, text, }: {
     waitFor: () => Promise<T>;
     text: string;
-}): Promise<T>;
+}): Promise<any>;

package/dist/utils/theme.d.ts

@@ -32,6 +32,7 @@ export declare const cmdText: import("chalk").Chalk & {
     supportsColor: import("chalk").ColorSupport;
 };
 export declare const indentedCmd: (str: any) => string;
+export declare const indentText: (str: any) => string;
 export declare const logText: import("chalk").Chalk & {
     supportsColor: import("chalk").ColorSupport;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/cli",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -21,7 +21,7 @@
     ]
   },
   "devDependencies": {
-    "@tinacms/scripts": "1.0.0",
+    "@tinacms/scripts": "1.0.1",
     "@types/clear": "0.1.0",
     "@types/cli-spinner": "^0.2.1",
     "@types/cors": "2.8.5",
@@ -52,12 +52,11 @@
     "@graphql-codegen/visitor-plugin-common": "^2.4.0",
     "@graphql-tools/graphql-file-loader": "^7.2.0",
     "@graphql-tools/load": "^7.3.2",
-    "@tinacms/app": "1.0.4",
-    "@tinacms/datalayer": "1.0.0",
-    "@tinacms/graphql": "1.0.4",
+    "@tinacms/app": "1.0.5",
+    "@tinacms/datalayer": "1.0.1",
+    "@tinacms/graphql": "1.1.0",
     "@tinacms/metrics": "1.0.1",
-    "@tinacms/schema-tools": "1.1.0",
-    "add": "^2.0.6",
+    "@tinacms/schema-tools": "1.2.1",
     "ajv": "^6.12.3",
     "altair-express-middleware": "4.0.6",
     "auto-bind": "^4.0.0",
@@ -79,12 +78,13 @@
     "lodash": "^4.17.19",
     "lodash.get": "^4.4.2",
     "log4js": "^6.4.0",
+    "minimatch": "^5.1.2",
     "multer": "1.4.5-lts.1",
     "normalize-path": "^3.0.0",
-    "url-pattern": "^1.0.3",
     "prettier": "^2.2.1",
     "progress": "^2.0.3",
     "prompts": "^2.4.1",
+    "url-pattern": "^1.0.3",
     "yarn": "^1.22.17",
     "yup": "^0.32.9",
     "zod": "^3.14.3"
@@ -101,6 +101,7 @@
     "test": "jest --passWithNoTests",
     "types": "pnpm tsc",
     "test-watch": "jest  --passWithNoTests --watch",
+    "tinacms": "MONOREPO_DEV=true node ./bin/tinacms",
     "generate:schema": "yarn node scripts/generateSchema.js"
   }
 }