@butterbase/cli 0.1.0

package/src/commands/init.ts

@@ -0,0 +1,151 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import prompts from 'prompts';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getMergedConfig } from '../lib/config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface TemplateVariables {
+  PROJECT_NAME: string;
+  APP_ID: string;
+  API_URL: string;
+}
+
+async function replaceVariables(content: string, variables: TemplateVariables): Promise<string> {
+  let result = content;
+  for (const [key, value] of Object.entries(variables)) {
+    result = result.replace(new RegExp(`{{${key}}}`, 'g'), value);
+  }
+  return result;
+}
+
+async function copyTemplate(
+  templateDir: string,
+  targetDir: string,
+  variables: TemplateVariables
+): Promise<void> {
+  const files = await fs.readdir(templateDir, { withFileTypes: true });
+
+  for (const file of files) {
+    const sourcePath = path.join(templateDir, file.name);
+    const targetPath = path.join(targetDir, file.name);
+
+    if (file.isDirectory()) {
+      await fs.ensureDir(targetPath);
+      await copyTemplate(sourcePath, targetPath, variables);
+    } else {
+      const content = await fs.readFile(sourcePath, 'utf-8');
+      const processedContent = await replaceVariables(content, variables);
+      await fs.writeFile(targetPath, processedContent);
+    }
+  }
+}
+
+export async function initCommand(template?: string) {
+  console.log(chalk.blue('🚀 Initialize Butterbase Project\n'));
+
+  // Get project name
+  const { projectName } = await prompts({
+    type: 'text',
+    name: 'projectName',
+    message: 'Project name:',
+    initial: 'my-butterbase-app',
+    validate: (value) => value.length > 0 || 'Project name is required',
+  });
+
+  if (!projectName) {
+    console.log(chalk.yellow('Cancelled'));
+    process.exit(0);
+  }
+
+  // Select template
+  if (!template) {
+    const { selectedTemplate } = await prompts({
+      type: 'select',
+      name: 'selectedTemplate',
+      message: 'Select a template:',
+      choices: [
+        { title: 'React + Vite', value: 'react-vite' },
+        { title: 'Next.js (coming soon)', value: 'nextjs', disabled: true },
+        { title: 'Vue + Vite (coming soon)', value: 'vue-vite', disabled: true },
+      ],
+    });
+
+    if (!selectedTemplate) {
+      console.log(chalk.yellow('Cancelled'));
+      process.exit(0);
+    }
+
+    template = selectedTemplate;
+  }
+
+  // Get Butterbase configuration
+  const config = await getMergedConfig();
+
+  const { appId } = await prompts({
+    type: 'text',
+    name: 'appId',
+    message: 'Butterbase App ID (leave empty to create later):',
+    initial: config.currentApp || '',
+  });
+
+  const apiUrl = config.endpoint || 'http://localhost:4000';
+
+  // Create project directory
+  const targetDir = path.join(process.cwd(), projectName);
+
+  if (await fs.pathExists(targetDir)) {
+    console.log(chalk.red(`✗ Directory "${projectName}" already exists`));
+    process.exit(1);
+  }
+
+  const spinner = ora('Creating project...').start();
+
+  try {
+    // Get template directory
+    const templateDir = path.join(__dirname, '../../templates', template!);
+
+    if (!await fs.pathExists(templateDir)) {
+      throw new Error(`Template "${template}" not found`);
+    }
+
+    // Create target directory
+    await fs.ensureDir(targetDir);
+
+    // Copy template with variable replacement
+    const variables: TemplateVariables = {
+      PROJECT_NAME: projectName,
+      APP_ID: appId || 'your-app-id',
+      API_URL: apiUrl,
+    };
+
+    await copyTemplate(templateDir, targetDir, variables);
+
+    // Create .env from .env.example
+    const envExamplePath = path.join(targetDir, '.env.example');
+    const envPath = path.join(targetDir, '.env');
+    if (await fs.pathExists(envExamplePath)) {
+      await fs.copy(envExamplePath, envPath);
+    }
+
+    spinner.succeed('Project created!');
+
+    console.log(chalk.green('\n✓ Project initialized successfully!\n'));
+    console.log(chalk.gray('Next steps:\n'));
+    console.log(chalk.white(`  cd ${projectName}`));
+    console.log(chalk.white(`  npm install`));
+    console.log(chalk.white(`  npm run dev`));
+
+    if (!appId) {
+      console.log(chalk.yellow('\n⚠ Remember to update .env with your Butterbase App ID'));
+    }
+  } catch (error) {
+    spinner.fail('Failed to create project');
+    console.error(chalk.red((error as Error).message));
+    process.exit(1);
+  }
+}

package/src/commands/schema.ts

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import { getSchema, applySchema } from '../lib/api-client.js';
+import { getCurrentAppId } from '../lib/config.js';
+
+async function requireAppId(appId?: string): Promise<string> {
+  if (appId) return appId;
+
+  const currentAppId = await getCurrentAppId();
+  if (!currentAppId) {
+    console.log(chalk.red('✗ No app specified and no current app set'));
+    console.log(chalk.gray('Use: butterbase apps use <app-id>'));
+    console.log(chalk.gray('Or: butterbase schema get --app <app-id>'));
+    process.exit(1);
+  }
+
+  return currentAppId;
+}
+
+export async function schemaGetCommand(options: { app?: string; output?: string }) {
+  const appId = await requireAppId(options.app);
+  const spinner = ora('Fetching schema...').start();
+
+  try {
+    const response: any = await getSchema(appId);
+    spinner.stop();
+
+    const schemaJson = JSON.stringify(response.schema, null, 2);
+
+    if (options.output) {
+      await fs.writeFile(options.output, schemaJson);
+      console.log(chalk.green(`✓ Schema saved to ${options.output}`));
+    } else {
+      console.log(schemaJson);
+    }
+  } catch (error) {
+    spinner.fail('Failed to fetch schema');
+    console.error(chalk.red((error as Error).message));
+    process.exit(1);
+  }
+}
+
+export async function schemaApplyCommand(file: string, options: { app?: string; dryRun?: boolean; name?: string }) {
+  const appId = await requireAppId(options.app);
+
+  if (!await fs.pathExists(file)) {
+    console.log(chalk.red(`✗ File not found: ${file}`));
+    process.exit(1);
+  }
+
+  const spinner = ora('Reading schema file...').start();
+
+  try {
+    const schemaContent = await fs.readFile(file, 'utf-8');
+    const schema = JSON.parse(schemaContent);
+
+    spinner.text = options.dryRun ? 'Running dry-run...' : 'Applying schema...';
+
+    const response: any = await applySchema(appId, schema, options.dryRun, options.name);
+
+    spinner.stop();
+
+    if (options.dryRun) {
+      console.log(chalk.blue('\n📋 Dry-run results:\n'));
+      console.log(JSON.stringify(response, null, 2));
+    } else {
+      console.log(chalk.green('\n✓ Schema applied successfully!'));
+      if (response.migration_id) {
+        console.log(chalk.gray(`  Migration ID: ${response.migration_id}`));
+      }
+    }
+  } catch (error) {
+    spinner.fail(options.dryRun ? 'Dry-run failed' : 'Failed to apply schema');
+    console.error(chalk.red((error as Error).message));
+    process.exit(1);
+  }
+}

package/src/commands/storage.ts

@@ -0,0 +1,117 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import { generateUploadUrl, listStorageObjects, deleteStorageObject } from '../lib/api-client.js';
+import { getCurrentAppId } from '../lib/config.js';
+
+async function requireAppId(appId?: string): Promise<string> {
+  if (appId) return appId;
+
+  const currentAppId = await getCurrentAppId();
+  if (!currentAppId) {
+    console.log(chalk.red('✗ No app specified and no current app set'));
+    console.log(chalk.gray('Use: butterbase apps use <app-id>'));
+    process.exit(1);
+  }
+
+  return currentAppId;
+}
+
+export async function storageListCommand(options: { app?: string }) {
+  const appId = await requireAppId(options.app);
+  const spinner = ora('Fetching storage objects...').start();
+
+  try {
+    const response: any = await listStorageObjects(appId);
+    spinner.stop();
+
+    if (!response.objects || response.objects.length === 0) {
+      console.log(chalk.yellow('No files found'));
+      return;
+    }
+
+    console.log(chalk.blue('\nStorage objects:\n'));
+    for (const obj of response.objects) {
+      console.log(chalk.bold(obj.filename));
+      console.log(chalk.gray(`  ID: ${obj.id}`));
+      console.log(chalk.gray(`  Size: ${(obj.size_bytes / 1024).toFixed(2)} KB`));
+      console.log(chalk.gray(`  Type: ${obj.content_type}`));
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail('Failed to fetch storage objects');
+    console.error(chalk.red((error as Error).message));
+    process.exit(1);
+  }
+}
+
+export async function storageUploadCommand(file: string, options: { app?: string }) {
+  const appId = await requireAppId(options.app);
+
+  if (!await fs.pathExists(file)) {
+    console.log(chalk.red(`✗ File not found: ${file}`));
+    process.exit(1);
+  }
+
+  const spinner = ora('Uploading file...').start();
+
+  try {
+    const stats = await fs.stat(file);
+    const filename = file.split('/').pop()!;
+
+    // Detect content type (basic implementation)
+    let contentType = 'application/octet-stream';
+    if (filename.endsWith('.png')) contentType = 'image/png';
+    else if (filename.endsWith('.jpg') || filename.endsWith('.jpeg')) contentType = 'image/jpeg';
+    else if (filename.endsWith('.pdf')) contentType = 'application/pdf';
+    else if (filename.endsWith('.txt')) contentType = 'text/plain';
+
+    // Get presigned upload URL
+    const uploadData: any = await generateUploadUrl(appId, filename, contentType, stats.size);
+
+    // Read file and upload to S3
+    const fileBuffer = await fs.readFile(file);
+
+    const uploadResponse = await fetch(uploadData.uploadUrl, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': contentType,
+      },
+      body: fileBuffer,
+    });
+
+    if (!uploadResponse.ok) {
+      throw new Error('Failed to upload file to storage');
+    }
+
+    spinner.succeed('File uploaded');
+    console.log(chalk.green('\n✓ File uploaded successfully!'));
+    console.log(chalk.gray(`  Object ID: ${uploadData.objectId}`));
+    console.log(chalk.gray(`  Object Key: ${uploadData.objectKey}`));
+  } catch (error) {
+    spinner.fail('Failed to upload file');
+    console.error(chalk.red((error as Error).message));
+    process.exit(1);
+  }
+}
+
+export async function storageDeleteCommand(objectId: string, options: { app?: string }) {
+  const appId = await requireAppId(options.app);
+
+  if (!objectId) {
+    console.log(chalk.red('✗ Object ID is required'));
+    console.log(chalk.gray('Usage: butterbase storage delete <object-id>'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Deleting object...').start();
+
+  try {
+    await deleteStorageObject(appId, objectId);
+    spinner.succeed('Object deleted');
+  } catch (error) {
+    spinner.fail('Failed to delete object');
+    console.error(chalk.red((error as Error).message));
+    process.exit(1);
+  }
+}

package/src/lib/api-client.ts

@@ -0,0 +1,176 @@
+import { getMergedConfig } from './config.js';
+
+export interface ApiError {
+  error: string;
+  details?: unknown;
+  hint?: string;
+}
+
+/**
+ * Get authorization headers
+ */
+async function getHeaders(): Promise<HeadersInit> {
+  const config = await getMergedConfig();
+  const headers: HeadersInit = {
+    'Content-Type': 'application/json',
+  };
+
+  if (config.apiKey) {
+    headers['Authorization'] = `Bearer ${config.apiKey}`;
+  }
+
+  return headers;
+}
+
+/**
+ * Get base URL from config
+ */
+async function getBaseUrl(): Promise<string> {
+  const config = await getMergedConfig();
+  return config.endpoint;
+}
+
+/**
+ * Make a GET request
+ */
+export async function apiGet<T>(path: string): Promise<T> {
+  const baseUrl = await getBaseUrl();
+  const headers = await getHeaders();
+
+  const res = await fetch(`${baseUrl}${path}`, { headers });
+  const body: any = await res.json();
+
+  if (!res.ok) {
+    throw new Error(body.error || body.message || 'Request failed');
+  }
+
+  return body as T;
+}
+
+/**
+ * Make a POST request
+ */
+export async function apiPost<T>(path: string, data: unknown): Promise<T> {
+  const baseUrl = await getBaseUrl();
+  const headers = await getHeaders();
+
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(data),
+  });
+
+  const body: any = await res.json();
+
+  if (!res.ok) {
+    throw new Error(body.error || body.message || 'Request failed');
+  }
+
+  return body as T;
+}
+
+/**
+ * Make a PATCH request
+ */
+export async function apiPatch<T>(path: string, data: unknown): Promise<T> {
+  const baseUrl = await getBaseUrl();
+  const headers = await getHeaders();
+
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: 'PATCH',
+    headers,
+    body: JSON.stringify(data),
+  });
+
+  const body: any = await res.json();
+
+  if (!res.ok) {
+    throw new Error(body.error || body.message || 'Request failed');
+  }
+
+  return body as T;
+}
+
+/**
+ * Make a DELETE request
+ */
+export async function apiDelete<T>(path: string): Promise<T> {
+  const baseUrl = await getBaseUrl();
+  const headers = await getHeaders();
+
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: 'DELETE',
+    headers,
+  });
+
+  // Handle 204 No Content
+  if (res.status === 204) {
+    return {} as T;
+  }
+
+  const body: any = await res.json();
+
+  if (!res.ok) {
+    throw new Error(body.error || body.message || 'Request failed');
+  }
+
+  return body as T;
+}
+
+// MCP tool wrappers
+
+export async function initApp(name: string) {
+  return apiPost('/init', { name });
+}
+
+export async function listApps() {
+  return apiGet('/apps');
+}
+
+export async function deleteApp(appId: string) {
+  return apiDelete(`/apps/${appId}`);
+}
+
+export async function getSchema(appId: string) {
+  return apiGet(`/v1/${appId}/schema`);
+}
+
+export async function applySchema(appId: string, schema: any, dryRun?: boolean, name?: string) {
+  return apiPost(`/v1/${appId}/schema/apply`, { schema, dry_run: dryRun, name });
+}
+
+export async function deployFunction(appId: string, data: {
+  name: string;
+  code: string;
+  description?: string;
+  envVars?: Record<string, string>;
+  timeoutMs?: number;
+  memoryLimitMb?: number;
+  trigger: { type: string; config?: any };
+}) {
+  return apiPost(`/v1/${appId}/functions`, data);
+}
+
+export async function listFunctions(appId: string) {
+  return apiGet(`/v1/${appId}/functions`);
+}
+
+export async function getFunctionLogs(appId: string, functionName: string, level?: string, limit?: number) {
+  const params = new URLSearchParams();
+  if (level) params.set('level', level);
+  if (limit) params.set('limit', String(limit));
+  const query = params.toString();
+  return apiGet(`/v1/${appId}/functions/${functionName}/logs${query ? `?${query}` : ''}`);
+}
+
+export async function generateUploadUrl(appId: string, filename: string, contentType: string, sizeBytes: number) {
+  return apiPost(`/storage/${appId}/upload`, { filename, contentType, sizeBytes });
+}
+
+export async function listStorageObjects(appId: string) {
+  return apiGet(`/storage/${appId}/objects`);
+}
+
+export async function deleteStorageObject(appId: string, objectId: string) {
+  return apiDelete(`/storage/${appId}/${objectId}`);
+}

package/src/lib/config.ts

@@ -0,0 +1,112 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+
+export interface ButterbaseConfig {
+  endpoint: string;
+  apiKey?: string;
+  currentApp?: string;
+  apps?: Record<string, {
+    id: string;
+    name: string;
+    apiUrl: string;
+  }>;
+}
+
+const CONFIG_DIR = path.join(os.homedir(), '.butterbase');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const PROJECT_CONFIG_FILE = '.butterbase/config.json';
+
+/**
+ * Get the global config file path
+ */
+export function getConfigPath(): string {
+  return CONFIG_FILE;
+}
+
+/**
+ * Ensure config directory exists
+ */
+async function ensureConfigDir(): Promise<void> {
+  await fs.ensureDir(CONFIG_DIR);
+}
+
+/**
+ * Load global configuration
+ */
+export async function loadConfig(): Promise<ButterbaseConfig> {
+  await ensureConfigDir();
+
+  if (await fs.pathExists(CONFIG_FILE)) {
+    return await fs.readJson(CONFIG_FILE);
+  }
+
+  // Return default config
+  return {
+    endpoint: 'http://localhost:4000',
+  };
+}
+
+/**
+ * Save global configuration
+ */
+export async function saveConfig(config: ButterbaseConfig): Promise<void> {
+  await ensureConfigDir();
+  await fs.writeJson(CONFIG_FILE, config, { spaces: 2 });
+}
+
+/**
+ * Update a specific config value
+ */
+export async function updateConfig(key: keyof ButterbaseConfig, value: any): Promise<void> {
+  const config = await loadConfig();
+  config[key] = value;
+  await saveConfig(config);
+}
+
+/**
+ * Load project-level configuration (from current directory)
+ */
+export async function loadProjectConfig(): Promise<Partial<ButterbaseConfig> | null> {
+  if (await fs.pathExists(PROJECT_CONFIG_FILE)) {
+    return await fs.readJson(PROJECT_CONFIG_FILE);
+  }
+  return null;
+}
+
+/**
+ * Save project-level configuration
+ */
+export async function saveProjectConfig(config: Partial<ButterbaseConfig>): Promise<void> {
+  await fs.ensureDir(path.dirname(PROJECT_CONFIG_FILE));
+  await fs.writeJson(PROJECT_CONFIG_FILE, config, { spaces: 2 });
+}
+
+/**
+ * Get merged configuration (project overrides global)
+ */
+export async function getMergedConfig(): Promise<ButterbaseConfig> {
+  const globalConfig = await loadConfig();
+  const projectConfig = await loadProjectConfig();
+
+  if (projectConfig) {
+    return { ...globalConfig, ...projectConfig };
+  }
+
+  return globalConfig;
+}
+
+/**
+ * Get the current app ID from config
+ */
+export async function getCurrentAppId(): Promise<string | undefined> {
+  const config = await getMergedConfig();
+  return config.currentApp;
+}
+
+/**
+ * Set the current app ID
+ */
+export async function setCurrentAppId(appId: string): Promise<void> {
+  await updateConfig('currentApp', appId);
+}

package/templates/react-vite/.env.example

@@ -0,0 +1,2 @@
+VITE_API_URL={{API_URL}}
+VITE_APP_ID={{APP_ID}}

package/templates/react-vite/README.md

@@ -0,0 +1,38 @@
+# {{PROJECT_NAME}}
+
+A Butterbase-powered React application.
+
+## Setup
+
+1. Install dependencies:
+```bash
+npm install
+```
+
+2. Copy `.env.example` to `.env` and configure:
+```bash
+cp .env.example .env
+```
+
+3. Start development server:
+```bash
+npm run dev
+```
+
+## Butterbase Configuration
+
+This project is connected to Butterbase app: `{{APP_ID}}`
+
+- API URL: `{{API_URL}}` (all endpoints including auth)
+
+## Available Scripts
+
+- `npm run dev` - Start development server
+- `npm run build` - Build for production
+- `npm run preview` - Preview production build
+
+## Learn More
+
+- [Butterbase Documentation](https://docs.butterbase.com)
+- [React Documentation](https://react.dev)
+- [Vite Documentation](https://vitejs.dev)

package/templates/react-vite/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{PROJECT_NAME}}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>