@eide/foir-cli 0.1.37 → 0.1.39

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { config } from "dotenv";
-import { resolve as resolve6, dirname as dirname6 } from "path";
+import { resolve as resolve7, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire } from "module";
 import { Command } from "commander";
@@ -127,6 +127,22 @@ function getGraphQLEndpoint(apiUrl) {
 
 // src/lib/errors.ts
 import chalk from "chalk";
+function extractErrorMessage(error) {
+  if (!error || typeof error !== "object")
+    return String(error ?? "Unknown error");
+  const err = error;
+  const gqlErrors = err.response?.errors;
+  if (gqlErrors && gqlErrors.length > 0) {
+    return gqlErrors[0].message;
+  }
+  if (err.message && err.message !== "undefined") {
+    return err.message;
+  }
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return "An unknown error occurred. Use --json for details.";
+}
 function withErrorHandler(optsFn, fn) {
   return async (...args) => {
     try {
@@ -145,12 +161,18 @@ function withErrorHandler(optsFn, fn) {
               error: {
                 message: first.message,
                 code: code ?? "GRAPHQL_ERROR",
-                ...validationErrors ? { validationErrors } : {}
+                ...validationErrors ? { validationErrors } : {},
+                ...gqlErrors.length > 1 ? {
+                  additionalErrors: gqlErrors.slice(1).map((e) => e.message)
+                } : {}
               }
             })
           );
         } else {
           console.error(chalk.red("Error:"), first.message);
+          for (const extra of gqlErrors.slice(1)) {
+            console.error(chalk.red("  \u2022"), extra.message);
+          }
           if (validationErrors && Object.keys(validationErrors).length > 0) {
             console.error("");
             console.error(chalk.yellow("Field errors:"));
@@ -162,12 +184,12 @@ function withErrorHandler(optsFn, fn) {
           }
           if (code === "UNAUTHENTICATED") {
             console.error(
-              chalk.gray("Hint: Run `foir login` to authenticate.")
+              chalk.gray("\nHint: Run `foir login` to authenticate.")
             );
           } else if (code === "FORBIDDEN") {
             console.error(
               chalk.gray(
-                "Hint: You may not have permission. Check your API key scopes."
+                "\nHint: You may not have permission. Check your API key scopes."
               )
             );
           }
@@ -190,7 +212,7 @@ function withErrorHandler(optsFn, fn) {
         }
         process.exit(1);
       }
-      const message = error instanceof Error ? error.message : String(error);
+      const message = extractErrorMessage(error);
       if (opts?.json || opts?.jsonl) {
         console.error(JSON.stringify({ error: { message } }));
       } else {
@@ -204,13 +226,13 @@ function withErrorHandler(optsFn, fn) {
 // src/commands/login.ts
 async function findAvailablePort(start, end) {
   for (let port = start; port <= end; port++) {
-    const available = await new Promise((resolve7) => {
+    const available = await new Promise((resolve8) => {
       const server = http.createServer();
       server.listen(port, () => {
         server.close();
-        resolve7(true);
+        resolve8(true);
       });
-      server.on("error", () => resolve7(false));
+      server.on("error", () => resolve8(false));
     });
     if (available) return port;
   }
@@ -248,7 +270,7 @@ async function loginAction(globalOpts) {
   const state = crypto.randomBytes(16).toString("hex");
   const port = await findAvailablePort(9876, 9900);
   const redirectUri = `http://localhost:${port}/callback`;
-  const authCode = await new Promise((resolve7, reject) => {
+  const authCode = await new Promise((resolve8, reject) => {
     const server = http.createServer((req, res) => {
       const url = new URL(req.url, `http://localhost:${port}`);
       if (url.pathname === "/callback") {
@@ -281,7 +303,7 @@ async function loginAction(globalOpts) {
           `<html><head><meta http-equiv="refresh" content="2;url=${mainUrl}"></head><body style="font-family:system-ui;text-align:center;padding:50px"><h1>Authentication successful!</h1><p>You can close this window.</p></body></html>`
         );
         server.close();
-        resolve7(code);
+        resolve8(code);
       }
     });
     server.listen(port);
@@ -604,8 +626,15 @@ function timeAgo(dateStr) {
   if (days < 30) return `${days}d ago`;
   return date.toLocaleDateString();
 }
-function success(message) {
-  console.log(chalk2.green(`\u2713 ${message}`));
+function success(message, data) {
+  let interpolated = message;
+  if (data) {
+    interpolated = message.replace(
+      /\{(\w+)\}/g,
+      (_, field) => String(data[field] ?? `{${field}}`)
+    );
+  }
+  console.log(chalk2.green(`\u2713 ${interpolated}`));
 }
 
 // src/commands/whoami.ts
@@ -5617,10 +5646,215 @@ Media (${data.globalSearch.media.length}):`);
   );
 }
 
+// src/commands/init.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve4, join as join4 } from "path";
+import chalk6 from "chalk";
+import inquirer3 from "inquirer";
+var FIELD_DEFAULTS = {
+  text: "",
+  richtext: "",
+  number: 0,
+  boolean: false,
+  date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+  select: "",
+  image: null,
+  video: null,
+  file: null,
+  json: {},
+  link: { url: "", label: "" },
+  relationship: null,
+  list: []
+};
+function defaultValueForField(field) {
+  return FIELD_DEFAULTS[field.type] ?? null;
+}
+function generateModelTemplate(key) {
+  return {
+    key,
+    name: key.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" "),
+    fields: [
+      {
+        key: "title",
+        type: "text",
+        label: "Title",
+        required: true
+      },
+      {
+        key: "slug",
+        type: "text",
+        label: "Slug",
+        required: true
+      },
+      {
+        key: "description",
+        type: "richtext",
+        label: "Description"
+      },
+      {
+        key: "image",
+        type: "image",
+        label: "Featured Image"
+      }
+    ],
+    config: {
+      versioning: true,
+      publishing: true,
+      variants: false
+    }
+  };
+}
+function generateRecordSeed(model) {
+  const data = {};
+  for (const field of model.fields) {
+    if (["id", "createdAt", "updatedAt", "createdBy", "updatedBy"].includes(
+      field.key
+    )) {
+      continue;
+    }
+    if (field.type === "list" && field.items) {
+      data[field.key] = [
+        defaultValueForField({ key: field.key, type: field.items.type })
+      ];
+    } else {
+      data[field.key] = defaultValueForField(field);
+    }
+  }
+  return {
+    modelKey: model.key,
+    naturalKey: `example-${model.key}`,
+    data
+  };
+}
+function formatAsTypeScript(obj) {
+  const json = JSON.stringify(obj, null, 2);
+  return `export default ${json} as const;
+`;
+}
+function registerInitCommands(program2, globalOpts) {
+  const initGroup = program2.command("init").description("Generate starter config and seed files");
+  initGroup.command("model").description("Generate a starter model definition file").argument("<key>", "Model key (e.g. blog-post)").option("-o, --output <dir>", "Output directory", "models").option("--ts", "Generate TypeScript (.ts) instead of JSON").action(
+    withErrorHandler(
+      globalOpts,
+      async (key, opts) => {
+        const globalFlags = globalOpts();
+        const template = generateModelTemplate(key);
+        const outDir = resolve4(opts.output);
+        if (!existsSync4(outDir)) {
+          mkdirSync2(outDir, { recursive: true });
+        }
+        const ext = opts.ts ? "ts" : "json";
+        const filePath = join4(outDir, `${key}.${ext}`);
+        const content = opts.ts ? formatAsTypeScript(template) : JSON.stringify(template, null, 2) + "\n";
+        await writeFile2(filePath, content, "utf-8");
+        if (!(globalFlags.json || globalFlags.jsonl || globalFlags.quiet)) {
+          success(`Created ${filePath}`);
+          console.log(
+            chalk6.gray(
+              `
+Edit the file, then run:
+  foir models create -f ${filePath}`
+            )
+          );
+        } else {
+          console.log(JSON.stringify({ path: filePath }));
+        }
+      }
+    )
+  );
+  initGroup.command("records").description("Generate seed files for records (interactive model selector)").option("-o, --output <dir>", "Output directory", "seed").option("--ts", "Generate TypeScript (.ts) instead of JSON").option(
+    "--model <keys...>",
+    "Model keys to generate for (skip interactive selector)"
+  ).action(
+    withErrorHandler(
+      globalOpts,
+      async (opts) => {
+        const globalFlags = globalOpts();
+        const client = await createClient(globalFlags);
+        const query = `query { models(limit: 100) { items { key name fields } total } }`;
+        const result = await client.request(query);
+        const models = result.models.items;
+        if (models.length === 0) {
+          console.log(
+            chalk6.yellow(
+              "No models found. Create models first with `foir models create`."
+            )
+          );
+          return;
+        }
+        let selectedModels;
+        if (opts.model && opts.model.length > 0) {
+          selectedModels = [];
+          for (const key of opts.model) {
+            const found = models.find((m) => m.key === key);
+            if (!found) {
+              console.error(
+                chalk6.red(`Model "${key}" not found.`),
+                "Available:",
+                models.map((m) => m.key).join(", ")
+              );
+              return;
+            }
+            selectedModels.push(found);
+          }
+        } else {
+          const { selected } = await inquirer3.prompt([
+            {
+              type: "checkbox",
+              name: "selected",
+              message: "Select models to generate seed files for:",
+              choices: models.map((m) => ({
+                name: `${m.name} (${m.key})`,
+                value: m.key,
+                short: m.key
+              })),
+              validate: (answer) => answer.length > 0 ? true : "Select at least one model."
+            }
+          ]);
+          selectedModels = selected.map((key) => models.find((m) => m.key === key)).filter(Boolean);
+        }
+        if (selectedModels.length === 0) {
+          console.log("No models selected.");
+          return;
+        }
+        const outDir = resolve4(opts.output);
+        if (!existsSync4(outDir)) {
+          mkdirSync2(outDir, { recursive: true });
+        }
+        const createdFiles = [];
+        for (const model of selectedModels) {
+          const seed = generateRecordSeed(model);
+          const ext = opts.ts ? "ts" : "json";
+          const filePath = join4(outDir, `${model.key}.${ext}`);
+          const content = opts.ts ? formatAsTypeScript(seed) : JSON.stringify(seed, null, 2) + "\n";
+          await writeFile2(filePath, content, "utf-8");
+          createdFiles.push(filePath);
+          if (!(globalFlags.json || globalFlags.jsonl || globalFlags.quiet)) {
+            success(`Created ${filePath}`);
+          }
+        }
+        if (!(globalFlags.json || globalFlags.jsonl || globalFlags.quiet)) {
+          console.log(
+            chalk6.gray(
+              `
+Edit the files, then run:
+  foir records create --dir ${outDir} --publish`
+            )
+          );
+        } else {
+          console.log(JSON.stringify({ files: createdFiles }));
+        }
+      }
+    )
+  );
+}
+
 // src/commands/register-commands.ts
-import { readFileSync } from "fs";
-import { resolve as resolve5, dirname as dirname5 } from "path";
+import { readFileSync, readdirSync } from "fs";
+import { resolve as resolve6, dirname as dirname5 } from "path";
 import { fileURLToPath } from "url";
+import chalk7 from "chalk";
 
 // ../command-registry/src/command-map.ts
 var COMMANDS = [
@@ -5655,7 +5889,17 @@ var COMMANDS = [
     operation: "createModel",
     operationType: "mutation",
     acceptsInput: true,
-    successMessage: "Created model {key}"
+    successMessage: "Created model {key}",
+    customFlags: [
+      {
+        flag: "--dir <path>",
+        description: "Create models from all files in directory"
+      },
+      {
+        flag: "--upsert",
+        description: "Update if model key already exists"
+      }
+    ]
   },
   {
     group: "models",
@@ -5725,7 +5969,10 @@ var COMMANDS = [
     operation: "createRecord",
     operationType: "mutation",
     acceptsInput: true,
-    successMessage: "Created record"
+    successMessage: "Created record",
+    customFlags: [
+      { flag: "--publish", description: "Publish the record after creation" }
+    ]
   },
   {
     group: "records",
@@ -5752,9 +5999,21 @@ var COMMANDS = [
     description: "Publish a record version",
     operation: "publishVersion",
     operationType: "mutation",
-    positionalArgs: [{ name: "versionId", graphqlArg: "versionId" }],
+    positionalArgs: [
+      {
+        name: "versionId",
+        graphqlArg: "versionId",
+        description: "Version ID, record ID, or natural key (with --model)"
+      }
+    ],
     scalarResult: true,
-    successMessage: "Published version"
+    successMessage: "Published version",
+    customFlags: [
+      {
+        flag: "--model <key>",
+        description: "Model key (use with natural key instead of version ID)"
+      }
+    ]
   },
   {
     group: "records",
@@ -6999,6 +7258,7 @@ var COMMANDS = [
 import {
   buildSchema,
   isObjectType,
+  isInputObjectType,
   isListType,
   isNonNullType,
   isScalarType,
@@ -7156,6 +7416,21 @@ function createSchemaEngine(sdl) {
     const argPart = fieldArgs ? `(${fieldArgs})` : "";
     return `${opType} ${opName}${varPart} { ${entry.operation}${argPart} ${selectionSet} }`;
   }
+  function getInputFields(operationName, operationType, inputArgName) {
+    const field = getField(operationName, operationType);
+    if (!field) return [];
+    const argName = inputArgName ?? "input";
+    const arg = field.args.find((a) => a.name === argName);
+    if (!arg) return [];
+    const namedType = unwrapType(arg.type);
+    if (!isInputObjectType(namedType)) return [];
+    const fields = namedType.getFields();
+    return Object.entries(fields).map(([name, f]) => ({
+      name,
+      type: typeToString(f.type),
+      required: isNonNullType(f.type)
+    }));
+  }
   function getCompletions(partial, commandNames) {
     return commandNames.filter(
       (name) => name.toLowerCase().startsWith(partial.toLowerCase())
@@ -7165,19 +7440,20 @@ function createSchemaEngine(sdl) {
     buildQuery,
     getOperationArgs,
     coerceArgs,
+    getInputFields,
     getCompletions
   };
 }
 
 // src/lib/input.ts
-import inquirer3 from "inquirer";
+import inquirer4 from "inquirer";
 
 // src/lib/config-loader.ts
 import { readFile } from "fs/promises";
 import { pathToFileURL as pathToFileURL2 } from "url";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 async function loadConfig(filePath) {
-  const absPath = resolve4(filePath);
+  const absPath = resolve5(filePath);
   if (filePath.endsWith(".ts")) {
     const configModule = await import(pathToFileURL2(absPath).href);
     return configModule.default;
@@ -7224,7 +7500,7 @@ function isUUID(value) {
 }
 async function confirmAction(message, opts) {
   if (opts?.confirm) return true;
-  const { confirmed } = await inquirer3.prompt([
+  const { confirmed } = await inquirer4.prompt([
     {
       type: "confirm",
       name: "confirmed",
@@ -7239,11 +7515,11 @@ async function confirmAction(message, opts) {
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname5(__filename);
 function loadSchemaSDL() {
-  const bundledPath = resolve5(__dirname, "schema.graphql");
+  const bundledPath = resolve6(__dirname, "schema.graphql");
   try {
     return readFileSync(bundledPath, "utf-8");
   } catch {
-    const monorepoPath = resolve5(
+    const monorepoPath = resolve6(
       __dirname,
       "../../../graphql-core/schema.graphql"
     );
@@ -7343,6 +7619,26 @@ function registerDynamicCommands(program2, globalOpts) {
       if (entry.acceptsInput) {
         cmd = cmd.option("-d, --data <json>", "Data as JSON");
         cmd = cmd.option("-f, --file <path>", "Read data from file");
+        const inputFields = engine.getInputFields(
+          entry.operation,
+          entry.operationType,
+          entry.inputArgName
+        );
+        if (inputFields.length > 0) {
+          const required = inputFields.filter((f) => f.required);
+          const optional = inputFields.filter((f) => !f.required);
+          let fieldHelp = "\nInput fields:";
+          if (required.length > 0) {
+            fieldHelp += "\n  Required: " + required.map((f) => `${f.name} (${f.type})`).join(", ");
+          }
+          if (optional.length > 0) {
+            fieldHelp += "\n  Optional: " + optional.map((f) => `${f.name} (${f.type})`).join(", ");
+          }
+          cmd = cmd.addHelpText("after", fieldHelp);
+        }
+      }
+      for (const cf of entry.customFlags ?? []) {
+        cmd = cmd.option(cf.flag, cf.description);
       }
       if (entry.requiresConfirmation) {
         cmd = cmd.option("--confirm", "Skip confirmation prompt");
@@ -7361,9 +7657,15 @@ function registerDynamicCommands(program2, globalOpts) {
             }
           }
           const flags = actionArgs[positionals.length] ?? {};
+          const customFlagNames = new Set(
+            (entry.customFlags ?? []).map(
+              (cf) => cf.flag.replace(/ <.*>$/, "").replace(/^--/, "").replace(/-([a-z])/g, (_, c) => c.toUpperCase())
+            )
+          );
           const rawFlags = {};
           for (const [key, val] of Object.entries(flags)) {
             if (key === "data" || key === "file" || key === "confirm") continue;
+            if (customFlagNames.has(key)) continue;
             rawFlags[key] = String(val);
           }
           const coerced = engine.coerceArgs(
@@ -7372,11 +7674,97 @@ function registerDynamicCommands(program2, globalOpts) {
             rawFlags
           );
           Object.assign(variables, coerced);
+          if (flags.dir && entry.acceptsInput) {
+            const dirPath = resolve6(String(flags.dir));
+            const files = readdirSync(dirPath).filter((f) => /\.(json|ts|js|mjs)$/.test(f)).sort();
+            if (files.length === 0) {
+              console.error(
+                chalk7.yellow(`\u26A0 No .json/.ts/.js files found in ${dirPath}`)
+              );
+              return;
+            }
+            let created = 0;
+            let updated = 0;
+            let failed = 0;
+            for (const file of files) {
+              const filePath = resolve6(dirPath, file);
+              const fileData = await parseInputData({ file: filePath });
+              const argName = entry.inputArgName ?? "input";
+              const fileVars = { ...variables, [argName]: fileData };
+              const label = fileData.key ?? fileData.name ?? file;
+              try {
+                const q = engine.buildQuery(entry, fileVars);
+                await client.request(q, fileVars);
+                created++;
+                if (!(opts.json || opts.jsonl || opts.quiet)) {
+                  success(`Created ${label}`);
+                }
+              } catch (err) {
+                if (flags.upsert && fileData.key) {
+                  try {
+                    const updateEntry = COMMANDS.find(
+                      (c) => c.group === entry.group && c.name === "update"
+                    );
+                    if (updateEntry) {
+                      const updateVars = {
+                        ...variables,
+                        [updateEntry.inputArgName ?? "input"]: fileData,
+                        ...updateEntry.positionalArgs?.[0] ? {
+                          [updateEntry.positionalArgs[0].graphqlArg]: fileData.key
+                        } : {}
+                      };
+                      const uq = engine.buildQuery(updateEntry, updateVars);
+                      await client.request(uq, updateVars);
+                      updated++;
+                      if (!(opts.json || opts.jsonl || opts.quiet)) {
+                        success(`Updated ${label}`);
+                      }
+                      continue;
+                    }
+                  } catch (updateErr) {
+                    failed++;
+                    const msg2 = updateErr instanceof Error ? updateErr.message : String(updateErr);
+                    console.error(chalk7.red(`\u2717 ${label}:`), msg2);
+                    continue;
+                  }
+                }
+                failed++;
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(chalk7.red(`\u2717 ${label}:`), msg);
+              }
+            }
+            if (!(opts.json || opts.jsonl || opts.quiet)) {
+              console.log("");
+              console.log(
+                chalk7.bold(
+                  `Done: ${created} created${updated ? `, ${updated} updated` : ""}${failed ? `, ${failed} failed` : ""}`
+                )
+              );
+            }
+            return;
+          }
           if (entry.acceptsInput && (flags.data || flags.file)) {
             const inputData = await parseInputData({
               data: flags.data,
               file: flags.file
             });
+            const inputFields = engine.getInputFields(
+              entry.operation,
+              entry.operationType,
+              entry.inputArgName
+            );
+            const fieldNames = new Set(inputFields.map((f) => f.name));
+            if (fieldNames.has("projectId") && !inputData.projectId || fieldNames.has("tenantId") && !inputData.tenantId) {
+              const project = await getProjectContext();
+              if (project) {
+                if (fieldNames.has("projectId") && !inputData.projectId) {
+                  inputData.projectId = project.id;
+                }
+                if (fieldNames.has("tenantId") && !inputData.tenantId) {
+                  inputData.tenantId = project.tenantId;
+                }
+              }
+            }
             const argName = entry.inputArgName ?? "input";
             variables[argName] = inputData;
           }
@@ -7414,27 +7802,119 @@ function registerDynamicCommands(program2, globalOpts) {
               return;
             }
           }
+          if (entry.group === "records" && entry.name === "publish" && variables.versionId) {
+            const versionIdValue = String(variables.versionId);
+            if (flags.model) {
+              const lookupQuery = `query RecordByKey($naturalKey: String!) { recordByKey(naturalKey: $naturalKey) { id currentVersion { id } } }`;
+              const lookupResult = await client.request(lookupQuery, {
+                naturalKey: versionIdValue
+              });
+              const record = lookupResult.recordByKey;
+              const currentVersion = record?.currentVersion;
+              if (!currentVersion?.id) {
+                throw new Error(
+                  `No current version found for record "${versionIdValue}"`
+                );
+              }
+              variables.versionId = currentVersion.id;
+            } else if (!isUUID(versionIdValue)) {
+              const lookupQuery = `query RecordByKey($naturalKey: String!) { recordByKey(naturalKey: $naturalKey) { id currentVersion { id } } }`;
+              const lookupResult = await client.request(lookupQuery, {
+                naturalKey: versionIdValue
+              });
+              const record = lookupResult.recordByKey;
+              const currentVersion = record?.currentVersion;
+              if (currentVersion?.id) {
+                variables.versionId = currentVersion.id;
+              }
+            } else {
+              try {
+                const lookupQuery = `query Record($id: ID!) { record(id: $id) { id recordType currentVersion { id } } }`;
+                const lookupResult = await client.request(lookupQuery, {
+                  id: versionIdValue
+                });
+                const record = lookupResult.record;
+                if (record?.recordType === "record" && record?.currentVersion) {
+                  const cv = record.currentVersion;
+                  if (cv.id) {
+                    variables.versionId = cv.id;
+                  }
+                }
+              } catch {
+              }
+            }
+          }
           const queryStr = engine.buildQuery(entry, variables);
-          const result = await client.request(queryStr, variables);
-          const { data, total } = extractResult(result, entry.operation);
-          if (entry.scalarResult) {
+          let result;
+          let usedUpdate = false;
+          try {
+            result = await client.request(queryStr, variables);
+          } catch (createErr) {
+            if (flags.upsert && entry.name === "create") {
+              const updateEntry = COMMANDS.find(
+                (c) => c.group === entry.group && c.name === "update"
+              );
+              const inputArgName = entry.inputArgName ?? "input";
+              const inputData = variables[inputArgName];
+              if (updateEntry && inputData?.key) {
+                const updateVars = {
+                  ...variables,
+                  [updateEntry.inputArgName ?? "input"]: inputData,
+                  ...updateEntry.positionalArgs?.[0] ? {
+                    [updateEntry.positionalArgs[0].graphqlArg]: inputData.key
+                  } : {}
+                };
+                const uq = engine.buildQuery(updateEntry, updateVars);
+                result = await client.request(uq, updateVars);
+                usedUpdate = true;
+              } else {
+                throw createErr;
+              }
+            } else {
+              throw createErr;
+            }
+          }
+          const activeEntry = usedUpdate ? COMMANDS.find(
+            (c) => c.group === entry.group && c.name === "update"
+          ) ?? entry : entry;
+          const { data, total } = extractResult(result, activeEntry.operation);
+          const responseData = data && typeof data === "object" && !Array.isArray(data) ? data : void 0;
+          const displayEntry = usedUpdate ? activeEntry : entry;
+          if (displayEntry.scalarResult) {
             if (!(opts.json || opts.jsonl || opts.quiet)) {
-              if (entry.successMessage) {
-                success(entry.successMessage);
+              if (displayEntry.successMessage) {
+                success(displayEntry.successMessage, responseData);
               }
             } else {
               formatOutput(data, opts);
             }
           } else if (Array.isArray(data)) {
-            const cliColumns = toCliColumns(entry.columns);
+            const cliColumns = toCliColumns(displayEntry.columns);
             formatList(data, opts, {
               columns: cliColumns ?? autoColumns(data),
               total
             });
           } else {
             formatOutput(data, opts);
-            if (entry.successMessage && !(opts.json || opts.jsonl || opts.quiet)) {
-              success(entry.successMessage);
+            if (displayEntry.successMessage && !(opts.json || opts.jsonl || opts.quiet)) {
+              success(displayEntry.successMessage, responseData);
+            }
+          }
+          if (flags.publish && entry.group === "records" && entry.name === "create" && responseData) {
+            const version2 = responseData.version;
+            const versionId = version2?.id;
+            if (versionId) {
+              const publishQuery = `mutation PublishVersion($versionId: ID!) { publishVersion(versionId: $versionId) }`;
+              await client.request(publishQuery, { versionId });
+              if (!(opts.json || opts.jsonl || opts.quiet)) {
+                success("Published version {id}", { id: versionId });
+              }
+            } else if (!(opts.json || opts.jsonl || opts.quiet)) {
+              console.error(
+                chalk7.yellow(
+                  "\u26A0 Could not auto-publish: no version found in response"
+                )
+              );
             }
           }
         })
@@ -7455,7 +7935,7 @@ function autoColumns(items) {
 // src/cli.ts
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname6(__filename2);
-config({ path: resolve6(__dirname2, "../.env.local") });
+config({ path: resolve7(__dirname2, "../.env.local") });
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var program = new Command();
@@ -7477,5 +7957,6 @@ registerMediaCommands(program, getGlobalOpts);
 registerSearchCommands(program, getGlobalOpts);
 registerPullCommand(program, getGlobalOpts);
 registerCreateExtensionCommand(program, getGlobalOpts);
+registerInitCommands(program, getGlobalOpts);
 registerDynamicCommands(program, getGlobalOpts);
 program.parse();

package/dist/schema.graphql

@@ -202,6 +202,7 @@ type Query {
   billingCustomPackage(id: ID!): BillingCustomPackage
   billingSubscription: BillingSubscription
   billingUsageSummary(projectId: ID): BillingUsageSummary!
+  billingUsageAlerts: [UsageAlert!]!
   tenantBillingStatus(status: String, limit: Int, offset: Int): TenantBillingStatusResult!
   segments(isActive: Boolean, limit: Int, offset: Int): [Segment!]!
   segment(id: ID!): Segment
@@ -852,8 +853,13 @@ type Mutation {
   assignBillingCustomPackage(tenantId: ID!, customPackageId: ID!): BillingSubscription!
   cancelBillingSubscription(immediate: Boolean): BillingSubscription!
   reactivateBillingSubscription: BillingSubscription!
-  createPaymentMethodSetupIntent: SetupIntentResult!
+
+  """
+  Create a Stripe Checkout Session for paid plan subscription. Returns URL to redirect to.
+  """
+  createCheckoutSession(planSlug: String!, successUrl: String!, cancelUrl: String!): CheckoutSessionResult!
   createBillingPortalSession(returnUrl: String): BillingPortalSession!
+  dismissBillingUsageAlert(id: ID!): Boolean!
   selfServiceSignup(input: SelfServiceSignupInput!): SelfServiceSignupResult!
   createSignupSession(input: CreateSignupSessionInput!): CreateSignupSessionResult!
   createSegment(input: CreateSegmentInput!): Segment!
@@ -1829,6 +1835,11 @@ type SessionContext {
 
   """Current user info"""
   user: AdminUser!
+
+  """
+  Effective role for the current tenant+project context (e.g. PLATFORM_ADMIN, TENANT_OWNER, PROJECT_ADMIN, PROJECT_EDITOR, PROJECT_VIEWER)
+  """
+  effectiveRole: String
 }
 
 type Project {
@@ -2782,6 +2793,9 @@ type BillingPlanLimit {
   maxQuantity: BigInt
   overagePriceCents: Int
   overageUnitSize: Int!
+
+  """Whether this limit is unlimited (no max quantity)"""
+  isUnlimited: Boolean!
 }
 
 type BillingCustomPackage {
@@ -2812,6 +2826,9 @@ type BillingPackageLimit {
   includedQuantity: BigInt
   maxQuantity: BigInt
   overagePriceCents: Int
+
+  """Whether this limit is unlimited (no max quantity)"""
+  isUnlimited: Boolean!
 }
 
 type BillingSubscription {
@@ -2856,8 +2873,8 @@ type UsageLimitStatus {
   percentUsed: Float!
 }
 
-type SetupIntentResult {
-  clientSecret: String!
+type CheckoutSessionResult {
+  url: String!
 }
 
 type BillingPortalSession {
@@ -2936,6 +2953,16 @@ type TenantBillingStatusResult {
   total: Int!
 }
 
+type UsageAlert {
+  id: ID!
+  metric: BillingMetric!
+  threshold: Int!
+  currentUsage: Float!
+  limitValue: Float!
+  percentUsed: Int!
+  createdAt: DateTime!
+}
+
 input CreateCustomPackageInput {
   tenantId: ID!
   projectId: ID
@@ -3204,6 +3231,15 @@ type ExperimentFunnel {
   steps: [FunnelStep!]!
 }
 
+"""Experiment lifecycle action"""
+enum ExperimentAction {
+  start
+  pause
+  resume
+  end
+  declareWinner
+}
+
 """Experiment stored in the dedicated experiments table"""
 type ExperimentRecord {
   id: ID!
@@ -3224,6 +3260,9 @@ type ExperimentRecord {
   funnel: ExperimentFunnel
   targetVariantCatalogId: ID
   isActive: Boolean!
+
+  """Actions available for the current experiment status"""
+  allowedActions: [ExperimentAction!]!
   createdAt: DateTime!
   updatedAt: DateTime!
 }
@@ -4996,6 +5035,18 @@ input UpdateScheduleInput {
   isActive: Boolean
 }
 
+"""Computed capabilities for a model based on its config"""
+type ModelCapabilities {
+  isVersioned: Boolean!
+  isPublishable: Boolean!
+  hasVariants: Boolean!
+  isInlineOnly: Boolean!
+  recordCapable: Boolean!
+  publicApi: Boolean!
+  customerScoped: Boolean!
+  sharingEnabled: Boolean!
+}
+
 type Model {
   id: ID!
   key: String!
@@ -5034,6 +5085,9 @@ type Model {
   """Whether this model's fields can be edited"""
   editable: Boolean!
 
+  """Computed capabilities based on config flags"""
+  capabilities: ModelCapabilities!
+
   """Current schema version"""
   currentVersionId: String
   publishedVersionNumber: Int
@@ -5112,6 +5166,19 @@ type Record {
   scheduledPublishAt: DateTime
   scheduledUnpublishAt: DateTime
   customerId: String
+
+  """
+  Whether this record can be published (has unpublished changes on a publishable model)
+  """
+  canPublish: Boolean!
+
+  """
+  Whether this record can be unpublished (has a published version on a publishable model)
+  """
+  canUnpublish: Boolean!
+
+  """Whether the current version differs from the published version"""
+  hasUnpublishedChanges: Boolean!
   createdAt: DateTime!
   updatedAt: DateTime!
   createdBy: String

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eide/foir-cli",
-  "version": "0.1.37",
-  "description": "Universal platform CLI for EIDE — scriptable, composable resource management",
+  "version": "0.1.39",
+  "description": "Universal platform CLI for Foir platform",
   "type": "module",
   "publishConfig": {
     "access": "public"