@schmadev/cli 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/login.ts
+import prompts from "prompts";
+import pc from "picocolors";
+
+// src/utils/auth.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".schma");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function getConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const data = fs.readFileSync(CONFIG_FILE, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (error) {
+  }
+  return {};
+}
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+function getApiKey() {
+  if (process.env.SCHMA_API_KEY) {
+    return process.env.SCHMA_API_KEY;
+  }
+  const config = getConfig();
+  if (config.apiKey) {
+    return config.apiKey;
+  }
+  return null;
+}
+
+// src/commands/login.ts
+import gradient from "gradient-string";
+var SCHMA_LOGO = `
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 
+\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551
+\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551 \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D
+`;
+var prism = gradient(["#C0C0C0", "#FFFFFF", "#FFD700", "#FF8C00", "#8A2BE2", "#00FFFF"]);
+async function loginCommand() {
+  console.log(prism.multiline(SCHMA_LOGO));
+  console.log(pc.bold(prism("Welcome to the Schma CLI!")));
+  console.log(pc.gray("Authenticate your local machine to interact with the Headless CMS."));
+  console.log("");
+  const response = await prompts({
+    type: "password",
+    name: "apiKey",
+    message: "Enter your Schma API Key (Delivery or Management):",
+    validate: (val) => val.length > 0 || "API Key is required"
+  });
+  const apiKey = response.apiKey;
+  if (!apiKey) {
+    console.error(pc.red("Login cancelled."));
+    process.exit(1);
+  }
+  console.log(pc.cyan("Verifying API Key..."));
+  try {
+    if (!apiKey.startsWith("schma_")) {
+      console.log(pc.yellow("Warning: The API key does not look like a standard Schma API Key."));
+    }
+    const config = getConfig();
+    config.apiKey = apiKey;
+    saveConfig(config);
+    console.log(pc.green("\u2714 Successfully authenticated!"));
+    console.log(pc.gray("Your API key is securely stored in ~/.schma/config.json"));
+    console.log("");
+    console.log(pc.gray("Next step: run ") + pc.cyan("schma generate --tenant <your_tenant_slug>") + pc.gray(" to pull your content types."));
+  } catch (error) {
+    console.error(pc.red("Failed to authenticate."));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/generate.ts
+import pc2 from "picocolors";
+import fs3 from "fs";
+import path3 from "path";
+import { createClient } from "@schmadev/client";
+
+// src/utils/project.ts
+import fs2 from "fs";
+import path2 from "path";
+var LOCAL_CONFIG_DIR = ".schma";
+var LOCAL_CONFIG_FILE = "config.json";
+function getProjectConfigDir() {
+  return path2.join(process.cwd(), LOCAL_CONFIG_DIR);
+}
+function getProjectConfigPath() {
+  return path2.join(getProjectConfigDir(), LOCAL_CONFIG_FILE);
+}
+function getProjectConfig() {
+  try {
+    const configPath = getProjectConfigPath();
+    if (fs2.existsSync(configPath)) {
+      const data = fs2.readFileSync(configPath, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (error) {
+  }
+  return {};
+}
+function saveProjectConfig(config) {
+  const configDir = getProjectConfigDir();
+  const configPath = getProjectConfigPath();
+  if (!fs2.existsSync(configDir)) {
+    fs2.mkdirSync(configDir, { recursive: true });
+  }
+  const gitignorePath = path2.join(configDir, ".gitignore");
+  if (!fs2.existsSync(gitignorePath)) {
+    fs2.writeFileSync(gitignorePath, "# Schma local config can be committed to source control\n# Do NOT add your API keys here\n");
+  }
+  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+// src/commands/generate.ts
+function mapSchemaTypeToTypescript(type, field) {
+  switch (type) {
+    case "text":
+    case "markdown":
+    case "string":
+    case "media":
+    case "richText":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "string | Date";
+    case "number":
+      return "number";
+    case "json":
+    case "image":
+      return "Record<string, unknown>";
+    case "reference":
+      if (field?.targetType) {
+        const refName = field.targetType.charAt(0).toUpperCase() + field.targetType.slice(1).replace(/-./g, (x) => x[1].toUpperCase());
+        return `${refName} | string`;
+      }
+      return "Record<string, unknown> | string";
+    default:
+      return "any";
+  }
+}
+async function generateCommand(options) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error(pc2.red("Error: Unauthenticated."));
+    console.error(`Run ${pc2.cyan("schma login")} first or set the ${pc2.cyan("SCHMA_API_KEY")} environment variable.`);
+    process.exit(1);
+  }
+  const projectConfig = getProjectConfig();
+  const tenantSlug = options.tenant || process.env.SCHMA_TENANT_SLUG || projectConfig.tenantSlug;
+  if (!tenantSlug) {
+    console.error(pc2.red("Error: Tenant Slug not provided."));
+    console.error(`Run ${pc2.cyan("schma link")}, pass ${pc2.cyan("--tenant <slug>")}, or set the ${pc2.cyan("SCHMA_TENANT_SLUG")} environment variable.`);
+    process.exit(1);
+  }
+  console.log(pc2.cyan(`Fetching schemas for tenant '${tenantSlug}'...`));
+  const apiUrl = process.env.SCHMA_API_URL || projectConfig.apiUrl || "https://schma-cms-production.up.railway.app";
+  const client = createClient({
+    apiUrl,
+    tenantSlug,
+    apiKey
+  });
+  try {
+    const res = await client.contentTypes.list();
+    const contentTypes = res.data || [];
+    if (contentTypes.length === 0) {
+      console.log(pc2.yellow("No content types found for this tenant."));
+      return;
+    }
+    console.log(pc2.gray(`Found ${contentTypes.length} content types. Generating types...`));
+    let dtsContent = `// Automatically generated by Schma CLI
+// Do not edit this file manually
+
+`;
+    dtsContent += `import type { SchmaClient } from '@schmadev/client';
+
+`;
+    const modelNames = [];
+    for (const ct of contentTypes) {
+      const interfaceName = ct.slug.charAt(0).toUpperCase() + ct.slug.slice(1).replace(/-./g, (x) => x[1].toUpperCase());
+      modelNames.push(`'${ct.slug}': ${interfaceName}`);
+      dtsContent += `/**
+ * Content Model: ${ct.name}
+ * Description: ${ct.description || "No description"}
+ */
+`;
+      dtsContent += `export interface ${interfaceName} {
+`;
+      dtsContent += `  id: string;
+`;
+      dtsContent += `  createdAt: string;
+`;
+      dtsContent += `  updatedAt: string;
+`;
+      dtsContent += `  publishedAt?: string;
+`;
+      dtsContent += `  locale: string;
+`;
+      dtsContent += `  status: 'draft' | 'published' | 'archived';
+`;
+      const fields = ct.schemaJson.fields || [];
+      for (const field of fields) {
+        const tsType = mapSchemaTypeToTypescript(field.type, field);
+        const optional = field.required ? "" : "?";
+        dtsContent += `  /** ${field.label || field.name} (${field.type}) */
+`;
+        dtsContent += `  ${field.name}${optional}: ${tsType};
+`;
+      }
+      dtsContent += `}
+
+`;
+    }
+    dtsContent += `export interface SchmaModels {
+  ${modelNames.join(";\n  ")}
+}
+
+`;
+    dtsContent += `export type TypedSchmaClient = Omit<SchmaClient, 'delivery'> & {
+  delivery: {
+    getEntry<T extends keyof SchmaModels>(options: { id: string }): Promise<SchmaModels[T]>;
+    listEntries<T extends keyof SchmaModels>(options?: { type?: T; limit?: number; offset?: number; locale?: string; preview?: string }): Promise<{ data: SchmaModels[T][], total: number }>;
+    searchSimilar<T extends keyof SchmaModels>(options: { text: string; limit?: number; preview?: string }): Promise<{ data: SchmaModels[T][], total: number }>;
+  }
+};
+`;
+    const outPath = path3.resolve(process.cwd(), options.out);
+    const outDir = path3.dirname(outPath);
+    if (!fs3.existsSync(outDir)) {
+      fs3.mkdirSync(outDir, { recursive: true });
+    }
+    fs3.writeFileSync(outPath, dtsContent, "utf-8");
+    console.log(pc2.green(`\u2714 Successfully generated types to ${options.out}`));
+  } catch (error) {
+    console.error(pc2.red("Failed to fetch schemas."));
+    if (error.message) {
+      console.error(pc2.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+import dotenv from "dotenv";
+
+// src/commands/link.ts
+import prompts2 from "prompts";
+import pc3 from "picocolors";
+import { createClient as createClient2 } from "@schmadev/client";
+async function linkCommand() {
+  console.log(pc3.bold("Link Project to Schma Tenant"));
+  console.log(pc3.gray("This will create a local .schma/config.json file for this project."));
+  console.log("");
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error(pc3.red("Error: Unauthenticated."));
+    console.error(`Run ${pc3.cyan("schma login")} first or set the ${pc3.cyan("SCHMA_API_KEY")} environment variable.`);
+    process.exit(1);
+  }
+  const response = await prompts2({
+    type: "text",
+    name: "tenantSlug",
+    message: "Enter your Schma Tenant Slug (e.g. my-store):",
+    validate: (val) => val.length > 0 || "Tenant Slug is required"
+  });
+  const tenantSlug = response.tenantSlug;
+  if (!tenantSlug) {
+    console.error(pc3.red("Link cancelled."));
+    process.exit(1);
+  }
+  const apiUrl = process.env.SCHMA_API_URL || "https://schma-cms-production.up.railway.app";
+  console.log(pc3.cyan(`
+Verifying connection to '${tenantSlug}'...`));
+  const client = createClient2({
+    apiUrl,
+    tenantSlug,
+    apiKey
+  });
+  try {
+    await client.contentTypes.list();
+    saveProjectConfig({
+      tenantSlug,
+      apiUrl
+    });
+    console.log(pc3.green("\u2714 Successfully linked project!"));
+    console.log(pc3.gray(`Local configuration saved to .schma/config.json`));
+    console.log("");
+    console.log(pc3.gray("You can now run ") + pc3.cyan("schma generate") + pc3.gray(" without specifying a tenant."));
+  } catch (error) {
+    console.error(pc3.red(`Failed to link to tenant '${tenantSlug}'.`));
+    console.error(pc3.red("Check your tenant slug and API key."));
+    if (error.message) {
+      console.error(pc3.gray(error.message));
+    }
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+dotenv.config();
+var program = new Command();
+program.name("schma").description("Schma Developer CLI for interacting with Headless CMS").version("1.0.0");
+program.command("login").description("Authenticate and store your API key globally").action(loginCommand);
+program.command("link").description("Link the current directory to a Schma project (tenant)").action(linkCommand);
+program.command("generate").description("Pull schemas and generate TypeScript types").option("-t, --tenant <tenantSlug>", "The tenant slug to generate types for (or reads from SCHMA_TENANT_SLUG env var / local config)").option("-o, --out <path>", "Output file path", "schma-types.d.ts").action(generateCommand);
+program.parse(process.argv);

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@schmadev/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Schma Developer CLI",
+  "main": "./dist/index.js",
+  "type": "module",
+  "bin": {
+    "schma": "./dist/index.js"
+  },
+  "dependencies": {
+    "@schmadev/client": "1.0.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "gradient-string": "^3.0.0",
+    "picocolors": "^1.1.0",
+    "prompts": "^2.4.2",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@schmadev/typescript-config": "0.0.0",
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^20.14.9",
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "clean": "rm -rf dist"
+  }
 }

package/src/commands/generate.ts

@@ -0,0 +1,131 @@
+import pc from 'picocolors';
+import fs from 'fs';
+import path from 'path';
+import { getApiKey } from '../utils/auth.js';
+import { createClient } from '@schmadev/client';
+
+import { getProjectConfig } from '../utils/project.js';
+
+function mapSchemaTypeToTypescript(type: string, field?: any): string {
+  switch (type) {
+    case 'text':
+    case 'markdown':
+    case 'string':
+    case 'media':
+    case 'richText':
+      return 'string';
+    case 'boolean':
+      return 'boolean';
+    case 'date':
+      return 'string | Date';
+    case 'number':
+      return 'number';
+    case 'json':
+    case 'image':
+      return 'Record<string, unknown>';
+    case 'reference':
+      if (field?.targetType) {
+        const refName = field.targetType.charAt(0).toUpperCase() + 
+          field.targetType.slice(1).replace(/-./g, (x: string) => x[1].toUpperCase());
+        return `${refName} | string`;
+      }
+      return 'Record<string, unknown> | string';
+    default:
+      return 'any';
+  }
+}
+
+export async function generateCommand(options: { tenant?: string, out: string }) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error(pc.red('Error: Unauthenticated.'));
+    console.error(`Run ${pc.cyan('schma login')} first or set the ${pc.cyan('SCHMA_API_KEY')} environment variable.`);
+    process.exit(1);
+  }
+
+  const projectConfig = getProjectConfig();
+  const tenantSlug = options.tenant || process.env.SCHMA_TENANT_SLUG || projectConfig.tenantSlug;
+  
+  if (!tenantSlug) {
+    console.error(pc.red('Error: Tenant Slug not provided.'));
+    console.error(`Run ${pc.cyan('schma link')}, pass ${pc.cyan('--tenant <slug>')}, or set the ${pc.cyan('SCHMA_TENANT_SLUG')} environment variable.`);
+    process.exit(1);
+  }
+
+  console.log(pc.cyan(`Fetching schemas for tenant '${tenantSlug}'...`));
+
+  const apiUrl = process.env.SCHMA_API_URL || projectConfig.apiUrl || "https://schma-cms-production.up.railway.app";
+  
+  const client = createClient({
+    apiUrl,
+    tenantSlug,
+    apiKey,
+  });
+
+  try {
+    const res = await client.contentTypes.list();
+    const contentTypes = res.data || [];
+
+    if (contentTypes.length === 0) {
+      console.log(pc.yellow('No content types found for this tenant.'));
+      return;
+    }
+
+    console.log(pc.gray(`Found ${contentTypes.length} content types. Generating types...`));
+
+    let dtsContent = `// Automatically generated by Schma CLI\n// Do not edit this file manually\n\n`;
+    dtsContent += `import type { SchmaClient } from '@schmadev/client';\n\n`;
+
+    const modelNames: string[] = [];
+
+    for (const ct of contentTypes) {
+      const interfaceName = ct.slug.charAt(0).toUpperCase() + ct.slug.slice(1).replace(/-./g, (x: string) => x[1].toUpperCase());
+      modelNames.push(`'${ct.slug}': ${interfaceName}`);
+      
+      dtsContent += `/**\n * Content Model: ${ct.name}\n * Description: ${ct.description || 'No description'}\n */\n`;
+      dtsContent += `export interface ${interfaceName} {\n`;
+      dtsContent += `  id: string;\n`;
+      dtsContent += `  createdAt: string;\n`;
+      dtsContent += `  updatedAt: string;\n`;
+      dtsContent += `  publishedAt?: string;\n`;
+      dtsContent += `  locale: string;\n`;
+      dtsContent += `  status: 'draft' | 'published' | 'archived';\n`;
+      
+      const fields = (ct.schemaJson as any).fields || [];
+      for (const field of fields) {
+        const tsType = mapSchemaTypeToTypescript(field.type, field);
+        const optional = field.required ? '' : '?';
+        dtsContent += `  /** ${field.label || field.name} (${field.type}) */\n`;
+        dtsContent += `  ${field.name}${optional}: ${tsType};\n`;
+      }
+      
+      dtsContent += `}\n\n`;
+    }
+
+    dtsContent += `export interface SchmaModels {\n  ${modelNames.join(';\n  ')}\n}\n\n`;
+
+    dtsContent += `export type TypedSchmaClient = Omit<SchmaClient, 'delivery'> & {
+  delivery: {
+    getEntry<T extends keyof SchmaModels>(options: { id: string }): Promise<SchmaModels[T]>;
+    listEntries<T extends keyof SchmaModels>(options?: { type?: T; limit?: number; offset?: number; locale?: string; preview?: string }): Promise<{ data: SchmaModels[T][], total: number }>;
+    searchSimilar<T extends keyof SchmaModels>(options: { text: string; limit?: number; preview?: string }): Promise<{ data: SchmaModels[T][], total: number }>;
+  }
+};\n`;
+
+    const outPath = path.resolve(process.cwd(), options.out);
+    // ensure dir exists
+    const outDir = path.dirname(outPath);
+    if (!fs.existsSync(outDir)) {
+      fs.mkdirSync(outDir, { recursive: true });
+    }
+    fs.writeFileSync(outPath, dtsContent, 'utf-8');
+
+    console.log(pc.green(`✔ Successfully generated types to ${options.out}`));
+  } catch (error: any) {
+    console.error(pc.red('Failed to fetch schemas.'));
+    if (error.message) {
+      console.error(pc.red(error.message));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/link.ts

@@ -0,0 +1,63 @@
+import prompts from 'prompts';
+import pc from 'picocolors';
+import { getApiKey } from '../utils/auth.js';
+import { saveProjectConfig } from '../utils/project.js';
+import { createClient } from '@schmadev/client';
+
+export async function linkCommand() {
+  console.log(pc.bold('Link Project to Schma Tenant'));
+  console.log(pc.gray('This will create a local .schma/config.json file for this project.'));
+  console.log('');
+
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error(pc.red('Error: Unauthenticated.'));
+    console.error(`Run ${pc.cyan('schma login')} first or set the ${pc.cyan('SCHMA_API_KEY')} environment variable.`);
+    process.exit(1);
+  }
+
+  const response = await prompts({
+    type: 'text',
+    name: 'tenantSlug',
+    message: 'Enter your Schma Tenant Slug (e.g. my-store):',
+    validate: (val: string) => val.length > 0 || 'Tenant Slug is required'
+  });
+
+  const tenantSlug = response.tenantSlug;
+  if (!tenantSlug) {
+    console.error(pc.red('Link cancelled.'));
+    process.exit(1);
+  }
+
+  const apiUrl = process.env.SCHMA_API_URL || "https://schma-cms-production.up.railway.app";
+
+  console.log(pc.cyan(`\nVerifying connection to '${tenantSlug}'...`));
+
+  const client = createClient({
+    apiUrl,
+    tenantSlug,
+    apiKey,
+  });
+
+  try {
+    // Attempt to fetch content types to verify access
+    await client.contentTypes.list();
+
+    saveProjectConfig({
+      tenantSlug,
+      apiUrl,
+    });
+
+    console.log(pc.green('✔ Successfully linked project!'));
+    console.log(pc.gray(`Local configuration saved to .schma/config.json`));
+    console.log('');
+    console.log(pc.gray('You can now run ') + pc.cyan('schma generate') + pc.gray(' without specifying a tenant.'));
+  } catch (error: any) {
+    console.error(pc.red(`Failed to link to tenant '${tenantSlug}'.`));
+    console.error(pc.red('Check your tenant slug and API key.'));
+    if (error.message) {
+      console.error(pc.gray(error.message));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/login.ts

@@ -0,0 +1,63 @@
+import prompts from 'prompts';
+import pc from 'picocolors';
+import { saveConfig, getConfig } from '../utils/auth.js';
+import { createClient } from '@schmadev/client';
+import gradient from 'gradient-string';
+
+const SCHMA_LOGO = `
+ ██████╗  ██████╗██╗  ██╗███╗   ███╗ █████╗ 
+██╔════╝ ██╔════╝██║  ██║████╗ ████║██╔══██╗
+███████╗ ██║     ███████║██╔████╔██║███████║
+╚════██║ ██║     ██╔══██║██║╚██╔╝██║██╔══██║
+███████║ ╚██████╗██║  ██║██║ ╚═╝ ██║██║  ██║
+╚══════╝  ╚═════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝
+`;
+
+const prism = gradient(['#C0C0C0', '#FFFFFF', '#FFD700', '#FF8C00', '#8A2BE2', '#00FFFF']);
+
+export async function loginCommand() {
+  console.log(prism.multiline(SCHMA_LOGO));
+  console.log(pc.bold(prism('Welcome to the Schma CLI!')));
+  console.log(pc.gray('Authenticate your local machine to interact with the Headless CMS.'));
+  console.log('');
+
+  const response = await prompts({
+    type: 'password',
+    name: 'apiKey',
+    message: 'Enter your Schma API Key (Delivery or Management):',
+    validate: (val: string) => val.length > 0 || 'API Key is required'
+  });
+
+  const apiKey = response.apiKey;
+  if (!apiKey) {
+    console.error(pc.red('Login cancelled.'));
+    process.exit(1);
+  }
+
+  console.log(pc.cyan('Verifying API Key...'));
+
+  try {
+    // Attempt a lightweight test by configuring a client without a tenant
+    // Since api keys are tenant-bound, we don't necessarily know the tenant yet.
+    // However, the /content-types endpoint requires a tenant.
+    // In our backend, API keys are globally unique strings starting with `schma_`.
+    // Let's just save it. The actual validation happens during `generate`.
+    
+    if (!apiKey.startsWith('schma_')) {
+      console.log(pc.yellow('Warning: The API key does not look like a standard Schma API Key.'));
+    }
+
+    const config = getConfig();
+    config.apiKey = apiKey;
+    saveConfig(config);
+
+    console.log(pc.green('✔ Successfully authenticated!'));
+    console.log(pc.gray('Your API key is securely stored in ~/.schma/config.json'));
+    console.log('');
+    console.log(pc.gray('Next step: run ') + pc.cyan('schma generate --tenant <your_tenant_slug>') + pc.gray(' to pull your content types.'));
+  } catch (error) {
+    console.error(pc.red('Failed to authenticate.'));
+    console.error(error);
+    process.exit(1);
+  }
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { loginCommand } from './commands/login.js';
+import { generateCommand } from './commands/generate.js';
+import dotenv from 'dotenv';
+
+import { linkCommand } from './commands/link.js';
+
+// Load .env files if present (for SCHMA_API_KEY override)
+dotenv.config();
+
+const program = new Command();
+
+program
+  .name('schma')
+  .description('Schma Developer CLI for interacting with Headless CMS')
+  .version('1.0.0');
+
+program
+  .command('login')
+  .description('Authenticate and store your API key globally')
+  .action(loginCommand);
+
+program
+  .command('link')
+  .description('Link the current directory to a Schma project (tenant)')
+  .action(linkCommand);
+
+program
+  .command('generate')
+  .description('Pull schemas and generate TypeScript types')
+  .option('-t, --tenant <tenantSlug>', 'The tenant slug to generate types for (or reads from SCHMA_TENANT_SLUG env var / local config)')
+  .option('-o, --out <path>', 'Output file path', 'schma-types.d.ts')
+  .action(generateCommand);
+
+program.parse(process.argv);

package/src/utils/auth.ts

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.schma');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+export interface SchmaConfig {
+  apiKey?: string;
+}
+
+export function getConfig(): SchmaConfig {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    // Ignore read errors
+  }
+  return {};
+}
+
+export function saveConfig(config: SchmaConfig) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export function getApiKey(): string | null {
+  // 1. Environment variable override (CI/CD)
+  if (process.env.SCHMA_API_KEY) {
+    return process.env.SCHMA_API_KEY;
+  }
+  
+  // 2. Global config
+  const config = getConfig();
+  if (config.apiKey) {
+    return config.apiKey;
+  }
+  
+  return null;
+}

package/src/utils/project.ts

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import path from 'path';
+
+const LOCAL_CONFIG_DIR = '.schma';
+const LOCAL_CONFIG_FILE = 'config.json';
+
+export interface SchmaProjectConfig {
+  tenantSlug?: string;
+  apiUrl?: string;
+}
+
+export function getProjectConfigDir(): string {
+  return path.join(process.cwd(), LOCAL_CONFIG_DIR);
+}
+
+export function getProjectConfigPath(): string {
+  return path.join(getProjectConfigDir(), LOCAL_CONFIG_FILE);
+}
+
+export function getProjectConfig(): SchmaProjectConfig {
+  try {
+    const configPath = getProjectConfigPath();
+    if (fs.existsSync(configPath)) {
+      const data = fs.readFileSync(configPath, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    // Ignore read errors
+  }
+  return {};
+}
+
+export function saveProjectConfig(config: SchmaProjectConfig) {
+  const configDir = getProjectConfigDir();
+  const configPath = getProjectConfigPath();
+  
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  
+  // Add warning to .gitignore
+  const gitignorePath = path.join(configDir, '.gitignore');
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, '# Schma local config can be committed to source control\n# Do NOT add your API keys here\n');
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@schmadev/typescript-config/base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm"],
+  dts: false,
+  clean: true,
+  outDir: "dist",
+});

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.