@schmadev/cli 0.0.0-stage → 1.0.2

package/.turbo/turbo-build.log

@@ -0,0 +1,10 @@
+$ tsup
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /Users/balajim/Documents/Vibe-CMS/packages/cli/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+ESM Build start
+ESM dist/index.js 11.91 KB
+ESM ⚡️ Build success in 32ms

package/README.md

@@ -1,3 +1,51 @@
-# Temporary Holding Version
+# @schmadev/cli
 
-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.
+The official command-line interface for [Schma](https://schma.dev).
+
+Schma is the flexible headless CMS that lets you Bring Your Own Database (BYOD) and Bring Your Own AI Keys (BYOK). This CLI provides powerful tools to interact with your Schma workspaces directly from your terminal.
+
+## Installation
+
+Normally, you run the CLI via `npx` or include it as a `devDependency` in your project.
+
+```bash
+npm install -D @schmadev/cli
+# or
+pnpm add -D @schmadev/cli
+```
+
+## Commands
+
+### `generate`
+Syncs your remote Schma content types down to your local codebase and generates strict TypeScript definitions. This ensures your SDK calls are completely type-safe.
+
+```bash
+npx @schmadev/cli generate
+```
+
+### `login`
+Authenticates your local development environment with your Schma account.
+
+```bash
+npx @schmadev/cli login
+```
+
+### `link`
+Links your current directory to a specific Schma workspace and generates the necessary configuration files.
+
+```bash
+npx @schmadev/cli link
+```
+
+## Setup
+
+When running commands, the CLI expects a valid `.env` file containing your `SCHMA_API_KEY`, or it will prompt you to log in.
+
+If you haven't started a project yet, we recommend using the initialization wizard instead:
+```bash
+npm create schma@latest
+```
+
+## Documentation
+
+For the full CLI reference, visit [docs.schma.dev](https://docs.schma.dev).

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-api-production.up.railway.app";
+  const client = createClient({
+    baseUrl: 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.2",
+  "description": "Schma Developer CLI",
+  "main": "./dist/index.js",
+  "type": "module",
+  "bin": {
+    "schma": "./dist/index.js"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@schmadev/client": "workspace:*",
+    "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": "workspace:*",
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^20.14.9",
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2"
+  }
+}

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-api-production.up.railway.app";
+  
+  const client = createClient({
+    baseUrl: 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",
+});