npm - create-brightsy-component-lib - Versions diffs - 0.1.0 - Mend

create-brightsy-component-lib 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1105 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+/**
+ * create-brightsy-component-lib
+ *
+ * CLI tool to scaffold and deploy Brightsy component library projects.
+ *
+ * Usage:
+ *   npx create-brightsy-component-lib my-components
+ *   npx create-brightsy-component-lib my-components --template app
+ *   npx create-brightsy-component-lib login
+ *   npx create-brightsy-component-lib deploy
+ */
+import { program } from 'commander';
+import prompts from 'prompts';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { createServer } from 'http';
+import { randomBytes, createHash } from 'crypto';
+import { URL } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Config file location
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.brightsy');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+// Load saved config
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+        }
+    }
+    catch (e) {
+        // Ignore errors
+    }
+    return {};
+}
+// Save config
+function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    // Set restrictive permissions
+    fs.chmodSync(CONFIG_FILE, 0o600);
+}
+// Generate PKCE code verifier and challenge
+function generatePKCE() {
+    const verifier = randomBytes(32).toString('base64url');
+    const challenge = createHash('sha256').update(verifier).digest('base64url');
+    return { verifier, challenge };
+}
+// OAuth login flow
+async function login(options) {
+    console.log(BANNER);
+    console.log(chalk.cyan('Authenticating with Brightsy...\n'));
+    const endpoint = options.endpoint || 'https://brightsy.ai';
+    const clientId = 'brightsy-cli';
+    const redirectPort = 8976;
+    const redirectUri = `http://localhost:${redirectPort}/callback`;
+    const { verifier, challenge } = generatePKCE();
+    const state = randomBytes(16).toString('hex');
+    // Build authorization URL
+    const authUrl = new URL(`${endpoint}/oauth/authorize`);
+    authUrl.searchParams.set('client_id', clientId);
+    authUrl.searchParams.set('redirect_uri', redirectUri);
+    authUrl.searchParams.set('response_type', 'code');
+    authUrl.searchParams.set('scope', 'openid profile files libraries');
+    authUrl.searchParams.set('code_challenge', challenge);
+    authUrl.searchParams.set('code_challenge_method', 'S256');
+    authUrl.searchParams.set('state', state);
+    console.log(chalk.cyan('Opening browser for authentication...'));
+    console.log(chalk.dim(`If the browser doesn't open, visit:\n${authUrl.toString()}\n`));
+    // Open browser
+    const openCommand = process.platform === 'darwin' ? 'open' :
+        process.platform === 'win32' ? 'start' : 'xdg-open';
+    try {
+        execSync(`${openCommand} "${authUrl.toString()}"`, { stdio: 'ignore' });
+    }
+    catch (e) {
+        // Browser open failed, user will need to copy URL manually
+    }
+    // Start local server to receive callback
+    return new Promise((resolve, reject) => {
+        const server = createServer(async (req, res) => {
+            const url = new URL(req.url || '', `http://localhost:${redirectPort}`);
+            if (url.pathname === '/callback') {
+                const code = url.searchParams.get('code');
+                const returnedState = url.searchParams.get('state');
+                const error = url.searchParams.get('error');
+                if (error) {
+                    res.writeHead(400, { 'Content-Type': 'text/html' });
+                    res.end(`<html><body><h1>Authentication Failed</h1><p>${error}</p><script>window.close()</script></body></html>`);
+                    server.close();
+                    reject(new Error(error));
+                    return;
+                }
+                if (returnedState !== state) {
+                    res.writeHead(400, { 'Content-Type': 'text/html' });
+                    res.end(`<html><body><h1>Authentication Failed</h1><p>State mismatch</p><script>window.close()</script></body></html>`);
+                    server.close();
+                    reject(new Error('State mismatch - possible CSRF attack'));
+                    return;
+                }
+                if (!code) {
+                    res.writeHead(400, { 'Content-Type': 'text/html' });
+                    res.end(`<html><body><h1>Authentication Failed</h1><p>No code received</p><script>window.close()</script></body></html>`);
+                    server.close();
+                    reject(new Error('No authorization code received'));
+                    return;
+                }
+                try {
+                    // Exchange code for tokens
+                    const tokenResponse = await fetch(`${endpoint}/oauth/token`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            grant_type: 'authorization_code',
+                            client_id: clientId,
+                            code,
+                            redirect_uri: redirectUri,
+                            code_verifier: verifier,
+                        })
+                    });
+                    if (!tokenResponse.ok) {
+                        const error = await tokenResponse.json().catch(() => ({}));
+                        throw new Error(error.error_description || error.error || 'Token exchange failed');
+                    }
+                    const tokens = await tokenResponse.json();
+                    // Get user info to find account
+                    const userResponse = await fetch(`${endpoint}/oauth/userinfo`, {
+                        headers: { 'Authorization': `Bearer ${tokens.access_token}` }
+                    });
+                    let accountId = '';
+                    let accountSlug = '';
+                    if (userResponse.ok) {
+                        const userInfo = await userResponse.json();
+                        // If user has accounts, let them select one
+                        if (userInfo.accounts && userInfo.accounts.length > 0) {
+                            if (userInfo.accounts.length === 1) {
+                                accountId = userInfo.accounts[0].id;
+                                accountSlug = userInfo.accounts[0].slug;
+                            }
+                            else {
+                                // Multiple accounts - will prompt after
+                                console.log(chalk.yellow('\nMultiple accounts found. Please select one:'));
+                                const { selectedAccount } = await prompts({
+                                    type: 'select',
+                                    name: 'selectedAccount',
+                                    message: 'Select account:',
+                                    choices: userInfo.accounts.map((acc) => ({
+                                        title: acc.name || acc.slug,
+                                        value: acc,
+                                    }))
+                                });
+                                accountId = selectedAccount.id;
+                                accountSlug = selectedAccount.slug;
+                            }
+                        }
+                    }
+                    // Save config
+                    const config = {
+                        access_token: tokens.access_token,
+                        refresh_token: tokens.refresh_token,
+                        account_id: accountId,
+                        account_slug: accountSlug,
+                        endpoint,
+                        expires_at: Date.now() + (tokens.expires_in * 1000),
+                    };
+                    saveConfig(config);
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(`
+            <html>
+              <body style="font-family: system-ui; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0;">
+                <div style="text-align: center;">
+                  <h1 style="color: #3b82f6;">Authentication Successful!</h1>
+                  <p>You can close this window and return to the terminal.</p>
+                </div>
+                <script>setTimeout(() => window.close(), 2000)</script>
+              </body>
+            </html>
+          `);
+                    server.close();
+                    console.log(chalk.green('\n✓ Authentication successful!'));
+                    console.log(`  Account: ${chalk.bold(accountSlug || accountId)}`);
+                    console.log(`  Config saved to: ${chalk.dim(CONFIG_FILE)}`);
+                    console.log();
+                    resolve();
+                }
+                catch (error) {
+                    res.writeHead(500, { 'Content-Type': 'text/html' });
+                    res.end(`<html><body><h1>Authentication Failed</h1><p>${error.message}</p></body></html>`);
+                    server.close();
+                    reject(error);
+                }
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not found');
+            }
+        });
+        server.listen(redirectPort, () => {
+            console.log(chalk.dim(`Waiting for authentication callback on port ${redirectPort}...`));
+        });
+        // Timeout after 5 minutes
+        setTimeout(() => {
+            server.close();
+            reject(new Error('Authentication timed out'));
+        }, 5 * 60 * 1000);
+    });
+}
+// Logout
+function logout() {
+    console.log(BANNER);
+    if (fs.existsSync(CONFIG_FILE)) {
+        fs.unlinkSync(CONFIG_FILE);
+        console.log(chalk.green('✓ Logged out successfully'));
+    }
+    else {
+        console.log(chalk.yellow('Not logged in'));
+    }
+}
+// Check if logged in and token is valid
+async function ensureLoggedIn(options) {
+    const config = loadConfig();
+    if (!config.access_token) {
+        console.log(chalk.yellow('Not logged in. Starting authentication...\n'));
+        await login(options);
+        return loadConfig();
+    }
+    // Check if token is expired
+    if (config.expires_at && Date.now() > config.expires_at) {
+        if (config.refresh_token) {
+            console.log(chalk.dim('Token expired, refreshing...'));
+            try {
+                const endpoint = config.endpoint || options.endpoint || 'https://brightsy.ai';
+                const response = await fetch(`${endpoint}/oauth/token`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        grant_type: 'refresh_token',
+                        client_id: 'brightsy-cli',
+                        refresh_token: config.refresh_token,
+                    })
+                });
+                if (response.ok) {
+                    const tokens = await response.json();
+                    config.access_token = tokens.access_token;
+                    if (tokens.refresh_token) {
+                        config.refresh_token = tokens.refresh_token;
+                    }
+                    config.expires_at = Date.now() + (tokens.expires_in * 1000);
+                    saveConfig(config);
+                    console.log(chalk.green('✓ Token refreshed'));
+                }
+                else {
+                    throw new Error('Refresh failed');
+                }
+            }
+            catch (e) {
+                console.log(chalk.yellow('Session expired. Please log in again.\n'));
+                await login(options);
+                return loadConfig();
+            }
+        }
+        else {
+            console.log(chalk.yellow('Session expired. Please log in again.\n'));
+            await login(options);
+            return loadConfig();
+        }
+    }
+    return config;
+}
+// ASCII art banner
+const BANNER = `
+${chalk.blue('╔═══════════════════════════════════════════════╗')}
+${chalk.blue('║')}  ${chalk.bold.cyan('Brightsy Component Library Generator')}  ${chalk.blue('║')}
+${chalk.blue('╚═══════════════════════════════════════════════╝')}
+`;
+// Template files for "components" template
+const COMPONENTS_TEMPLATE = {
+    'package.json': (config) => JSON.stringify({
+        name: config.projectName,
+        version: '1.0.0',
+        description: config.description,
+        type: 'module',
+        main: './dist/index.js',
+        module: './dist/index.js',
+        types: './dist/index.d.ts',
+        exports: {
+            '.': {
+                types: './dist/index.d.ts',
+                import: './dist/index.js'
+            }
+        },
+        scripts: {
+            dev: 'vite --port 5180',
+            build: 'vite build',
+            preview: 'vite preview',
+            typecheck: 'tsc --noEmit'
+        },
+        dependencies: {
+            react: '^18.2.0',
+            'react-dom': '^18.2.0'
+        },
+        devDependencies: {
+            '@brightsy/component-dev-kit': '^0.1.0',
+            '@types/react': '^18.2.0',
+            '@types/react-dom': '^18.2.0',
+            '@vitejs/plugin-react': '^4.3.4',
+            typescript: '^5.6.3',
+            vite: '^6.0.1'
+        },
+        peerDependencies: {
+            '@brightsy/page-builder': '*',
+            '@brightsy/client': '*'
+        },
+        author: config.author,
+        license: 'MIT'
+    }, null, 2),
+    'tsconfig.json': () => JSON.stringify({
+        compilerOptions: {
+            target: 'ES2020',
+            useDefineForClassFields: true,
+            lib: ['ES2020', 'DOM', 'DOM.Iterable'],
+            module: 'ESNext',
+            skipLibCheck: true,
+            moduleResolution: 'bundler',
+            allowImportingTsExtensions: true,
+            resolveJsonModule: true,
+            isolatedModules: true,
+            noEmit: true,
+            jsx: 'react-jsx',
+            strict: true,
+            noUnusedLocals: true,
+            noUnusedParameters: true,
+            noFallthroughCasesInSwitch: true,
+            esModuleInterop: true
+        },
+        include: ['src'],
+        references: [{ path: './tsconfig.node.json' }]
+    }, null, 2),
+    'tsconfig.node.json': () => JSON.stringify({
+        compilerOptions: {
+            composite: true,
+            skipLibCheck: true,
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            allowSyntheticDefaultImports: true,
+            strict: true
+        },
+        include: ['vite.config.ts']
+    }, null, 2),
+    'vite.config.ts': (config) => `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { brightsyComponentLibrary } from '@brightsy/component-dev-kit/vite';
+import path from 'path';
+export default defineConfig({
+  plugins: [
+    react({
+      jsxRuntime: 'classic',
+      jsxImportSource: undefined,
+    }),
+    ...brightsyComponentLibrary({
+      name: '${config.projectName}',
+    }),
+  ],
+  build: {
+    outDir: 'dist',
+    emptyOutDir: true,
+    cssCodeSplit: false,
+    lib: {
+      entry: path.resolve(__dirname, 'src/index.tsx'),
+      formats: ['es'],
+      fileName: () => 'index.js',
+    },
+    rollupOptions: {
+      external: ['react', 'react-dom'],
+      output: {
+        globals: {
+          react: 'React',
+          'react-dom': 'ReactDOM',
+        },
+      },
+    },
+    sourcemap: true,
+  },
+  server: {
+    port: 5180,
+    cors: true,
+  },
+});
+`,
+    '.gitignore': () => `node_modules
+dist
+.DS_Store
+*.local
+`,
+    'src/index.tsx': (config) => `/**
+ * ${config.projectName}
+ *
+ * ${config.description}
+ */
+import { createComponentExports } from '@brightsy/component-dev-kit';
+import { HelloWorld, helloWorldConfig, helloWorldLLMInstruction } from './components/HelloWorld';
+// Create the library export
+const library = createComponentExports(
+  // Components
+  {
+    HelloWorld,
+  },
+  // Configs
+  {
+    HelloWorld: helloWorldConfig,
+  },
+  // LLM Instructions
+  {
+    HelloWorld: helloWorldLLMInstruction,
+  }
+);
+// Default export: components for dynamic import
+export default library.default;
+// Named exports for static usage
+export const componentConfigs = library.componentConfigs;
+export const componentLLMInstructions = library.componentLLMInstructions;
+// Re-export individual components
+export { HelloWorld } from './components/HelloWorld';
+`,
+    'src/components/HelloWorld/HelloWorld.tsx': () => `/**
+ * HelloWorld Component
+ *
+ * A simple example component to get you started.
+ */
+import React from 'react';
+export interface HelloWorldProps {
+  /** The name to greet */
+  name: string;
+  /** Custom greeting message */
+  greeting?: string;
+  /** Text color */
+  color?: string;
+}
+export const HelloWorld: React.FC<HelloWorldProps> = ({
+  name,
+  greeting = 'Hello',
+  color = 'var(--color-text, #111827)',
+}) => {
+  return (
+    <div
+      style={{
+        padding: 'var(--spacing-md, 16px)',
+        borderRadius: 'var(--border-radius-md, 8px)',
+        backgroundColor: 'var(--color-surface, #ffffff)',
+        border: '1px solid var(--color-border, #e5e7eb)',
+        fontFamily: 'var(--font-family-primary, system-ui)',
+      }}
+    >
+      <h2
+        style={{
+          margin: 0,
+          color,
+          fontSize: 'var(--font-size-xl, 24px)',
+          fontWeight: 'var(--font-weight-semibold, 600)',
+        }}
+      >
+        {greeting}, {name}!
+      </h2>
+      <p
+        style={{
+          margin: 'var(--spacing-sm, 12px) 0 0',
+          color: 'var(--color-text-muted, #6b7280)',
+        }}
+      >
+        Welcome to your Brightsy component library.
+      </p>
+    </div>
+  );
+};
+export default HelloWorld;
+`,
+    'src/components/HelloWorld/HelloWorld.config.ts': () => `/**
+ * HelloWorld Puck Configuration
+ */
+import type { BrightsyComponentConfig } from '@brightsy/component-dev-kit';
+import type { HelloWorldProps } from './HelloWorld';
+export const helloWorldConfig: BrightsyComponentConfig<HelloWorldProps> = {
+  label: 'Hello World',
+  category: 'Getting Started',
+  icon: '👋',
+  fields: {
+    name: {
+      type: 'text',
+      label: 'Name',
+      description: 'The name to greet',
+      required: true,
+    },
+    greeting: {
+      type: 'text',
+      label: 'Greeting',
+      description: 'Custom greeting message',
+      placeholder: 'Hello',
+    },
+    color: {
+      type: 'text',
+      label: 'Text Color',
+      description: 'CSS color for the greeting',
+      placeholder: '#111827',
+    },
+  },
+  defaultProps: {
+    name: 'World',
+    greeting: 'Hello',
+    color: 'var(--color-text, #111827)',
+  },
+};
+export default helloWorldConfig;
+`,
+    'src/components/HelloWorld/HelloWorld.llm.ts': () => `/**
+ * HelloWorld LLM Instructions
+ */
+import type { LLMInstruction } from '@brightsy/component-dev-kit';
+export const helloWorldLLMInstruction: LLMInstruction = \`
+HelloWorld: A simple greeting component.
+Use this as a template for creating your own components.
+Props:
+- name (string, required): The name to greet
+- greeting (string, default: "Hello"): Custom greeting message
+- color (string): CSS color for the text
+Example:
+{
+  "type": "HelloWorld",
+  "props": {
+    "name": "Developer",
+    "greeting": "Welcome",
+    "color": "#3b82f6"
+  }
+}
+\`;
+export default helloWorldLLMInstruction;
+`,
+    'src/components/HelloWorld/index.ts': () => `export { HelloWorld, type HelloWorldProps } from './HelloWorld';
+export { helloWorldConfig } from './HelloWorld.config';
+export { helloWorldLLMInstruction } from './HelloWorld.llm';
+`,
+    'README.md': (config) => `# ${config.projectName}
+${config.description}
+## Quick Start
+\`\`\`bash
+# Install dependencies
+npm install
+# Start development server
+npm run dev
+# Build for production
+npm run build
+\`\`\`
+## Creating Components
+Each component should have three files:
+1. \`Component.tsx\` - The React component
+2. \`Component.config.ts\` - Puck editor configuration
+3. \`Component.llm.ts\` - LLM instructions for AI assistance
+See \`src/components/HelloWorld\` for an example.
+## Deploying to Brightsy
+1. Build your library: \`npm run build\`
+2. Host the \`dist/\` folder on a CDN
+3. Register the library in Brightsy:
+   - Via the Brightsy dashboard
+   - Via MCP tools
+   - Via the BrightsyClient API
+## Theme Variables
+Use CSS variables for consistent theming:
+\`\`\`css
+/* Colors */
+--color-primary
+--color-text
+--color-text-muted
+--color-surface
+--color-border
+/* Spacing */
+--spacing-xs, --spacing-sm, --spacing-md, --spacing-lg, --spacing-xl
+/* Typography */
+--font-family-primary
+--font-size-sm, --font-size-md, --font-size-lg
+/* Other */
+--border-radius-sm, --border-radius-md, --border-radius-lg
+\`\`\`
+## License
+MIT
+`,
+};
+// Template files for "app" template (single application component)
+const APP_TEMPLATE = {
+    ...COMPONENTS_TEMPLATE,
+    'src/index.tsx': (config) => `/**
+ * ${config.projectName}
+ *
+ * ${config.description}
+ *
+ * This is a custom application built on Brightsy.
+ * The App component is the entire application - it handles routing, state, etc.
+ */
+import { createComponentExports } from '@brightsy/component-dev-kit';
+import { App, appConfig, appLLMInstruction } from './App';
+const library = createComponentExports(
+  { App },
+  { App: appConfig },
+  { App: appLLMInstruction }
+);
+export default library.default;
+export const componentConfigs = library.componentConfigs;
+export const componentLLMInstructions = library.componentLLMInstructions;
+export { App } from './App';
+`,
+    'src/App/App.tsx': (config) => `/**
+ * Main Application Component
+ *
+ * This component IS the entire application.
+ * It handles its own routing, state, and data fetching.
+ */
+import React, { useState } from 'react';
+export interface AppProps {
+  /** Application title */
+  title: string;
+}
+export const App: React.FC<AppProps> = ({ title }) => {
+  const [count, setCount] = useState(0);
+  return (
+    <div
+      style={{
+        minHeight: '100vh',
+        fontFamily: 'var(--font-family-primary, system-ui)',
+        backgroundColor: 'var(--color-surface, #f9fafb)',
+      }}
+    >
+      {/* Header */}
+      <header
+        style={{
+          padding: 'var(--spacing-md, 16px)',
+          backgroundColor: 'var(--color-primary, #3b82f6)',
+          color: 'var(--color-primary-foreground, #ffffff)',
+        }}
+      >
+        <h1 style={{ margin: 0, fontSize: 'var(--font-size-xl, 24px)' }}>
+          {title}
+        </h1>
+      </header>
+      {/* Main Content */}
+      <main
+        style={{
+          padding: 'var(--spacing-lg, 24px)',
+          maxWidth: '800px',
+          margin: '0 auto',
+        }}
+      >
+        <div
+          style={{
+            padding: 'var(--spacing-lg, 24px)',
+            backgroundColor: 'var(--color-surface, #ffffff)',
+            borderRadius: 'var(--border-radius-lg, 12px)',
+            border: '1px solid var(--color-border, #e5e7eb)',
+            textAlign: 'center',
+          }}
+        >
+          <h2 style={{ marginTop: 0 }}>Welcome to your Brightsy App</h2>
+          <p style={{ color: 'var(--color-text-muted, #6b7280)' }}>
+            This is a custom application built on Brightsy.
+          </p>
+          <div style={{ marginTop: 'var(--spacing-lg, 24px)' }}>
+            <p>Count: {count}</p>
+            <button
+              onClick={() => setCount(c => c + 1)}
+              style={{
+                padding: 'var(--spacing-sm, 12px) var(--spacing-md, 16px)',
+                backgroundColor: 'var(--color-primary, #3b82f6)',
+                color: 'var(--color-primary-foreground, #ffffff)',
+                border: 'none',
+                borderRadius: 'var(--border-radius-md, 8px)',
+                cursor: 'pointer',
+                fontSize: 'var(--font-size-sm, 14px)',
+              }}
+            >
+              Increment
+            </button>
+          </div>
+        </div>
+      </main>
+    </div>
+  );
+};
+export default App;
+`,
+    'src/App/App.config.ts': (config) => `/**
+ * App Configuration
+ */
+import type { BrightsyComponentConfig } from '@brightsy/component-dev-kit';
+import type { AppProps } from './App';
+export const appConfig: BrightsyComponentConfig<AppProps> = {
+  label: '${config.projectName} App',
+  category: 'Applications',
+  icon: '📱',
+  fields: {
+    title: {
+      type: 'text',
+      label: 'App Title',
+      description: 'Title shown in the header',
+      required: true,
+    },
+  },
+  defaultProps: {
+    title: '${config.projectName}',
+  },
+};
+export default appConfig;
+`,
+    'src/App/App.llm.ts': () => `/**
+ * App LLM Instructions
+ */
+import type { LLMInstruction } from '@brightsy/component-dev-kit';
+export const appLLMInstruction: LLMInstruction = \`
+App: A custom application component.
+This is not a composable component - it's an entire application
+that handles its own routing, state, and data fetching.
+Props:
+- title (string): Application title
+Deploy on a Brightsy site in "app mode" to use this component
+as the entire site content.
+\`;
+export default appLLMInstruction;
+`,
+    'src/App/index.ts': () => `export { App, type AppProps } from './App';
+export { appConfig } from './App.config';
+export { appLLMInstruction } from './App.llm';
+`,
+};
+// Main scaffolding function
+async function scaffold(projectName, options) {
+    console.log(BANNER);
+    // Validate project name
+    if (fs.existsSync(projectName)) {
+        console.error(chalk.red(`Error: Directory "${projectName}" already exists.`));
+        process.exit(1);
+    }
+    // Prompt for configuration
+    const response = await prompts([
+        {
+            type: options.template ? null : 'select',
+            name: 'template',
+            message: 'Choose a template:',
+            choices: [
+                { title: 'Component Library', value: 'components', description: 'Multiple components for page builder' },
+                { title: 'Custom Application', value: 'app', description: 'Single app component' },
+            ],
+            initial: 0,
+        },
+        {
+            type: 'text',
+            name: 'description',
+            message: 'Project description:',
+            initial: 'A Brightsy component library',
+        },
+        {
+            type: 'text',
+            name: 'author',
+            message: 'Author:',
+            initial: '',
+        },
+    ]);
+    const config = {
+        projectName,
+        template: (options.template || response.template),
+        description: response.description,
+        author: response.author,
+    };
+    console.log();
+    console.log(chalk.cyan(`Creating ${config.template === 'app' ? 'application' : 'component library'}: ${projectName}`));
+    console.log();
+    // Select template
+    const template = config.template === 'app' ? APP_TEMPLATE : COMPONENTS_TEMPLATE;
+    // Create project directory
+    fs.mkdirSync(projectName, { recursive: true });
+    // Create subdirectories
+    if (config.template === 'app') {
+        fs.mkdirSync(path.join(projectName, 'src/App'), { recursive: true });
+    }
+    else {
+        fs.mkdirSync(path.join(projectName, 'src/components/HelloWorld'), { recursive: true });
+    }
+    // Write template files
+    for (const [filePath, generator] of Object.entries(template)) {
+        const fullPath = path.join(projectName, filePath);
+        const dir = path.dirname(fullPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const content = typeof generator === 'function' ? generator(config) : generator;
+        fs.writeFileSync(fullPath, content);
+        console.log(chalk.green('  ✓'), filePath);
+    }
+    console.log();
+    console.log(chalk.bold.green('Done!'));
+    console.log();
+    console.log('Next steps:');
+    console.log(chalk.cyan(`  cd ${projectName}`));
+    console.log(chalk.cyan('  npm install'));
+    console.log(chalk.cyan('  npm run dev'));
+    console.log();
+    console.log('For more info, see:');
+    console.log(chalk.blue('  https://docs.brightsy.ai/component-libraries'));
+}
+async function deploy(options) {
+    console.log(BANNER);
+    console.log(chalk.cyan('Deploying component library to Brightsy...\n'));
+    // Ensure user is logged in
+    const authConfig = await ensureLoggedIn({ endpoint: options.endpoint });
+    if (!authConfig.access_token || !authConfig.account_id) {
+        console.error(chalk.red('Error: Authentication failed. Please run: brightsy login'));
+        process.exit(1);
+    }
+    // Check if we're in a valid project directory
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        console.error(chalk.red('Error: No package.json found. Run this command from your project root.'));
+        process.exit(1);
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    const projectName = packageJson.name;
+    // Check if dist/index.js exists, if not, build first
+    const distPath = path.join(process.cwd(), 'dist', 'index.js');
+    if (!fs.existsSync(distPath)) {
+        console.log(chalk.yellow('No build found. Building project first...\n'));
+        try {
+            execSync('npm run build', { stdio: 'inherit' });
+            console.log();
+        }
+        catch (error) {
+            console.error(chalk.red('Build failed. Please fix the errors and try again.'));
+            process.exit(1);
+        }
+    }
+    if (!fs.existsSync(distPath)) {
+        console.error(chalk.red('Error: dist/index.js not found after build.'));
+        process.exit(1);
+    }
+    // Prompt for missing config
+    const prompts_needed = [];
+    if (!options.envName) {
+        prompts_needed.push({
+            type: 'select',
+            name: 'envName',
+            message: 'Environment:',
+            choices: [
+                { title: 'Production', value: 'production' },
+                { title: 'Development', value: 'development' },
+                { title: 'Staging', value: 'staging' },
+            ]
+        });
+    }
+    if (!options.version) {
+        prompts_needed.push({
+            type: 'text',
+            name: 'version',
+            message: 'Version:',
+            initial: packageJson.version || '1.0.0'
+        });
+    }
+    const answers = prompts_needed.length > 0 ? await prompts(prompts_needed) : {};
+    const deployConfig = {
+        endpoint: authConfig.endpoint || options.endpoint || 'https://brightsy.ai',
+        accountId: authConfig.account_id,
+        accessToken: authConfig.access_token,
+        libId: options.libId,
+        envName: options.envName || answers.envName || 'production',
+        version: options.version || answers.version || packageJson.version || '1.0.0',
+    };
+    const isProduction = deployConfig.envName === 'production';
+    const uploadPath = `libs/${projectName}/${deployConfig.version}`;
+    console.log(chalk.cyan('\nDeployment Configuration:'));
+    console.log(`  Account: ${chalk.bold(authConfig.account_slug || authConfig.account_id)}`);
+    console.log(`  Project: ${chalk.bold(projectName)}`);
+    console.log(`  Version: ${chalk.bold(deployConfig.version)}`);
+    console.log(`  Environment: ${chalk.bold(deployConfig.envName)}`);
+    console.log(`  Upload Path: ${chalk.bold(uploadPath)}`);
+    console.log();
+    try {
+        // Step 1: Get upload URL
+        console.log(chalk.cyan('Step 1/3: Getting upload URL...'));
+        const uploadUrlResponse = await fetch(`${deployConfig.endpoint}/api/v1beta/${deployConfig.accountId}/files/upload-url`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${deployConfig.accessToken}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                path: uploadPath,
+                filename: 'index.js'
+            })
+        });
+        if (!uploadUrlResponse.ok) {
+            const error = await uploadUrlResponse.json().catch(() => ({}));
+            throw new Error(error.message || `HTTP ${uploadUrlResponse.status}`);
+        }
+        const { uploadUrl, fileUrl } = await uploadUrlResponse.json();
+        console.log(chalk.green('  ✓ Upload URL obtained'));
+        // Step 2: Upload the file
+        console.log(chalk.cyan('Step 2/3: Uploading library...'));
+        const fileContent = fs.readFileSync(distPath);
+        const uploadResponse = await fetch(uploadUrl, {
+            method: 'PUT',
+            body: fileContent,
+            headers: {
+                'Content-Type': 'application/javascript'
+            }
+        });
+        if (!uploadResponse.ok) {
+            throw new Error(`Upload failed: HTTP ${uploadResponse.status}`);
+        }
+        console.log(chalk.green('  ✓ Library uploaded'));
+        console.log(chalk.dim(`    URL: ${fileUrl}`));
+        // Step 3: Register/update library environment (if libId provided)
+        if (deployConfig.libId) {
+            console.log(chalk.cyan('Step 3/3: Registering library environment...'));
+            // Try to create/update the environment
+            const envResponse = await fetch(`${deployConfig.endpoint}/api/v1beta/${deployConfig.accountId}/libraries/${deployConfig.libId}/environments`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${deployConfig.accessToken}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    name: deployConfig.envName,
+                    module_url: fileUrl,
+                    is_production: isProduction
+                })
+            });
+            if (envResponse.ok) {
+                console.log(chalk.green('  ✓ Library environment registered'));
+            }
+            else {
+                const error = await envResponse.json().catch(() => ({}));
+                console.log(chalk.yellow(`  ⚠ Could not register environment: ${error.message || 'Unknown error'}`));
+                console.log(chalk.yellow('    You may need to register it manually via MCP or the dashboard.'));
+            }
+        }
+        else {
+            console.log(chalk.dim('Step 3/3: Skipped (no --lib-id provided)'));
+            console.log(chalk.yellow('\nTo complete registration, use MCP tools:'));
+            console.log(chalk.dim(`  create_lib_env --lib_id <your-lib-id> --name ${deployConfig.envName} --module_url ${fileUrl} --is_production ${isProduction}`));
+        }
+        console.log();
+        console.log(chalk.bold.green('Deployment complete!'));
+        console.log();
+        console.log('Library URL:');
+        console.log(chalk.blue(`  ${fileUrl}`));
+        console.log();
+        if (!deployConfig.libId) {
+            console.log('Next steps:');
+            console.log(chalk.cyan('  1. Register the library in Brightsy (if not already):'));
+            console.log(chalk.dim('     MCP: create_lib --name "Your Library Name"'));
+            console.log();
+            console.log(chalk.cyan('  2. Add this environment to the library:'));
+            console.log(chalk.dim(`     MCP: create_lib_env --lib_id <lib-uuid> --name ${deployConfig.envName} --module_url ${fileUrl}`));
+            console.log();
+            console.log(chalk.cyan('  3. Assign the library to a page type:'));
+            console.log(chalk.dim('     MCP: assign_lib_to_page_type --page_type_id <type-uuid> --lib_id <lib-uuid>'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`\nDeployment failed: ${error.message}`));
+        process.exit(1);
+    }
+}
+// CLI setup
+program
+    .name('create-brightsy-component-lib')
+    .description('Scaffold and deploy Brightsy component libraries')
+    .version('0.1.0');
+// Create command (default)
+program
+    .command('create <project-name>', { isDefault: true })
+    .description('Scaffold a new Brightsy component library')
+    .option('-t, --template <type>', 'Template type (components, app)')
+    .action(scaffold);
+// Login command
+program
+    .command('login')
+    .description('Authenticate with Brightsy using OAuth')
+    .option('-e, --endpoint <url>', 'API endpoint (default: https://brightsy.ai)')
+    .action((options) => {
+    login({ endpoint: options.endpoint }).catch((error) => {
+        console.error(chalk.red(`\nLogin failed: ${error.message}`));
+        process.exit(1);
+    });
+});
+// Logout command
+program
+    .command('logout')
+    .description('Log out of Brightsy')
+    .action(logout);
+// Whoami command
+program
+    .command('whoami')
+    .description('Show current authenticated account')
+    .action(() => {
+    console.log(BANNER);
+    const config = loadConfig();
+    if (config.access_token) {
+        console.log(chalk.green('Logged in as:'));
+        console.log(`  Account: ${chalk.bold(config.account_slug || config.account_id || 'Unknown')}`);
+        console.log(`  Endpoint: ${chalk.dim(config.endpoint || 'https://brightsy.ai')}`);
+        if (config.expires_at) {
+            const expiresIn = Math.round((config.expires_at - Date.now()) / 1000 / 60);
+            if (expiresIn > 0) {
+                console.log(`  Token expires in: ${chalk.dim(expiresIn + ' minutes')}`);
+            }
+            else {
+                console.log(`  Token: ${chalk.yellow('Expired (will refresh on next command)')}`);
+            }
+        }
+    }
+    else {
+        console.log(chalk.yellow('Not logged in.'));
+        console.log(chalk.dim('Run: create-brightsy-component-lib login'));
+    }
+});
+// Deploy command
+program
+    .command('deploy')
+    .description('Deploy the library to Brightsy file storage')
+    .option('-e, --endpoint <url>', 'API endpoint (default: https://brightsy.ai)')
+    .option('-l, --lib-id <id>', 'Library ID to register environment for')
+    .option('-n, --env-name <name>', 'Environment name (production, development, staging)')
+    .option('-v, --version <version>', 'Version to deploy (default: from package.json)')
+    .action((options) => {
+    deploy({
+        endpoint: options.endpoint,
+        libId: options.libId,
+        envName: options.envName,
+        version: options.version
+    });
+});
+program.parse();
+//# sourceMappingURL=index.js.map