@klyb/cli 0.1.19

package/README.md

@@ -0,0 +1,82 @@
+# @klyb/cli
+
+The official Command Line Interface for building widgets and pages for the **Klyb Community Builder**.
+
+## Installation
+
+```bash
+npm install -g @klyb/cli
+```
+
+## Usage
+
+### 1. Create a new Widget
+
+Scaffold a new widget project with the official React + Vite + TypeScript template.
+
+```bash
+klyb init my-awesome-widget
+cd my-awesome-widget
+npm install
+```
+
+### 2. Develop Locally (Simulator)
+
+Start the local development server. This launches a **Local Simulator** that mimics the Klyb mobile environment (IFrame, SDK communication, etc.), allowing you to test your widget in isolation.
+
+```bash
+npm run dev
+# OR
+klyb dev
+```
+
+The simulator will open at `http://localhost:3000` (or the next available port).
+
+### 3. Deploy
+
+Package your widget and deploy it to the Klyb platform.
+
+```bash
+npm run deploy
+# OR
+klyb deploy
+```
+
+## Project Structure
+
+A standard Klyb widget project looks like this:
+
+```
+my-widget/
+├── src/
+│   ├── App.tsx       # Your main widget code
+│   └── main.tsx      # Entry point
+├── klyb.json        # Widget metadata (name, version, permissions)
+├── package.json
+└── vite.config.ts    # Vite configuration
+```
+
+## SDK Integration
+
+The CLI templates come pre-configured with `@klyb/sdk`. Use it to interact with the host application:
+
+```ts
+import { bridge } from '@klyb/sdk';
+
+// Get user info
+const user = await bridge.getUser();
+
+// Show a native toast
+await bridge.showToast({ message: 'Hello from Widget!', type: 'success' });
+```
+
+## Contributing
+
+This CLI is part of the Klyb monorepo.
+
+### Local Setup
+
+1.  Clone the repository.
+2.  Install dependencies: `npm install`
+3.  Build the CLI: `npm run build`
+4.  Link globally for testing: `npm link`

package/bin/klyb.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// This will require the built source code
+require('../dist/index.js');

package/dist/commands/deploy.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = deployCommand;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const archiver_1 = __importDefault(require("archiver"));
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const credentials_1 = require("../credentials");
+async function deployCommand() {
+    console.log(chalk_1.default.blue('🚀 Deploying Widget to Klyb...'));
+    const cwd = process.cwd();
+    const configPath = path_1.default.join(cwd, 'klyb.json');
+    // On vérifie qu'on est bien à la racine d'un projet de widget (présence du klyb.json)
+    if (!fs_extra_1.default.existsSync(configPath)) {
+        console.error(chalk_1.default.red('❌ klyb.json not found. Are you in a Klyb project?'));
+        process.exit(1);
+    }
+    const config = await fs_extra_1.default.readJson(configPath);
+    console.log(chalk_1.default.dim(`   Project: ${config.name} v${config.version}`));
+    // On compile le code source du projet (TypeScript, React, etc.)
+    console.log(chalk_1.default.yellow('\n📦 Building project...'));
+    try {
+        (0, child_process_1.execSync)('npm run build', { stdio: 'inherit' });
+    }
+    catch (e) {
+        console.error(chalk_1.default.red('❌ Build failed. Fix errors and try again.'));
+        process.exit(1);
+    }
+    // On prépare l'archive contenant uniquement les fichiers compilés (le dossier dist)
+    console.log(chalk_1.default.yellow('\n🤐 Zipping assets...'));
+    const distDir = path_1.default.join(cwd, 'dist');
+    const zipPath = path_1.default.join(cwd, 'bundle.zip');
+    if (!fs_extra_1.default.existsSync(distDir)) {
+        console.error(chalk_1.default.red('❌ dist/ directory not found after build.'));
+        process.exit(1);
+    }
+    await zipDirectory(distDir, zipPath, { source: configPath, name: 'klyb.json' });
+    console.log(chalk_1.default.green(`   Bundle created: ${getSize(zipPath)}`));
+    // Étape finale : on envoie tout ça vers la plateforme Klyb
+    console.log(chalk_1.default.yellow('\n☁️  Uploading to Klyb Registry...'));
+    // Récupération des accès enregistrés lors du `klyb login`
+    const credentials = (0, credentials_1.getCredentials)();
+    const apiUrl = credentials?.apiUrl || process.env.KLYB_API_URL || 'http://localhost:3000';
+    if (!credentials?.token) {
+        console.error(chalk_1.default.red('❌ Not authenticated.'));
+        console.error(chalk_1.default.yellow('   Run: ') + chalk_1.default.cyan('klyb login'));
+        process.exit(1);
+    }
+    const token = credentials.token;
+    try {
+        const isSubmission = process.argv.includes('--submit');
+        const status = isSubmission ? 'published' : 'draft';
+        const form = new form_data_1.default();
+        form.append('file', fs_extra_1.default.createReadStream(zipPath));
+        form.append('manifest', JSON.stringify(config));
+        // Appel direct à l'API pour lancer la publication
+        const deployUrl = `${apiUrl}/api/widget-library/developer/deploy`;
+        console.log(chalk_1.default.blue(`\n🚀 Deploying to ${deployUrl}...`));
+        const response = await axios_1.default.post(deployUrl, form, {
+            headers: {
+                ...form.getHeaders(),
+                'Authorization': `Bearer ${token}`
+            },
+            maxContentLength: Infinity,
+            maxBodyLength: Infinity
+        });
+        console.log(chalk_1.default.green('\n✅ Deployment Successful!'));
+        console.log(chalk_1.default.cyan(`   Widget ID: ${response.data.widgetId}`));
+        console.log(chalk_1.default.cyan(`   Version: ${response.data.version}`));
+        console.log(chalk_1.default.dim(`   Download URL: ${response.data.url}`));
+        // On s'assure que le projet local garde bien l'identifiant définitif du widget
+        if (config.id !== response.data.widgetId) {
+            config.id = response.data.widgetId;
+            await fs_extra_1.default.writeJson(configPath, config, { spaces: 2 });
+            console.log(chalk_1.default.dim(`   (Updated local klyb.json with new ID)`));
+        }
+        if (isSubmission) {
+            console.log(chalk_1.default.magenta('   🚀 Submitted for validation (Status: Pending)'));
+            console.log(chalk_1.default.dim('   An admin will review your widget shortly.'));
+        }
+        else {
+            console.log(chalk_1.default.dim('   Saved as Draft. PRO TIP: Use --submit to send for validation.'));
+        }
+        console.log(chalk_1.default.dim('   Available in your "Submissions" tab.'));
+        // On supprime le fichier zip qui ne sert plus à rien
+        await fs_extra_1.default.remove(zipPath);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Upload failed'));
+        if (error.response) {
+            console.error(chalk_1.default.red(`   Server Error: ${error.response.status} ${error.response.statusText}`));
+            console.error(chalk_1.default.yellow(`   Response Data: ${JSON.stringify(error.response.data, null, 2)}`));
+        }
+        else if (error.request) {
+            console.error(chalk_1.default.red(`   No response from server`));
+            console.error(chalk_1.default.yellow(`   API URL: ${apiUrl}`));
+            console.error(chalk_1.default.dim(`   Check if the API is running on ${apiUrl}`));
+        }
+        else {
+            console.error(chalk_1.default.red(`   Error: ${error.message}`));
+        }
+        // On n'oublie pas de supprimer le fichier zip même si l'envoi a échoué
+        try {
+            if (await fs_extra_1.default.pathExists(zipPath)) {
+                await fs_extra_1.default.remove(zipPath);
+            }
+        }
+        catch (cleanupError) {
+            // Ignore cleanup errors
+        }
+        process.exit(1);
+    }
+}
+function zipDirectory(source, out, extraFile) {
+    const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+    const stream = fs_extra_1.default.createWriteStream(out);
+    return new Promise((resolve, reject) => {
+        archive
+            .directory(source, false)
+            .on('error', err => reject(err))
+            .pipe(stream);
+        if (extraFile) {
+            archive.file(extraFile.source, { name: extraFile.name });
+        }
+        stream.on('close', () => resolve());
+        archive.finalize();
+    });
+}
+function getSize(filePath) {
+    const stats = fs_extra_1.default.statSync(filePath);
+    const bytes = stats.size;
+    if (bytes < 1024)
+        return bytes + ' B';
+    return (bytes / 1024).toFixed(2) + ' KB';
+}

package/dist/commands/dev.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devCommand = devCommand;
+const path_1 = __importDefault(require("path"));
+const express_1 = __importDefault(require("express"));
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const axios_1 = __importDefault(require("axios"));
+async function devCommand() {
+    console.log(chalk_1.default.blue('🚀 Starting Klyb Development Environment...'));
+    // 0. Load Environment Variables from the User's Project
+    const userEnvPath = path_1.default.join(process.cwd(), '.env');
+    if (fs_1.default.existsSync(userEnvPath)) {
+        dotenv_1.default.config({ path: userEnvPath });
+        console.log(chalk_1.default.green('✅ Loaded .env file'));
+    }
+    else {
+        console.log(chalk_1.default.yellow('⚠️  No .env file found. API Key integration will be disabled.'));
+    }
+    // 1. Start User's Widget Server (Vite)
+    const widgetPort = 3001;
+    console.log(chalk_1.default.dim(`   Starting widget server on port ${widgetPort}...`));
+    const widgetProcess = (0, cross_spawn_1.default)('npm', ['run', 'dev', '--', '--port', widgetPort.toString()], {
+        stdio: 'inherit',
+        env: { ...process.env, FORCE_COLOR: 'true' }
+    });
+    widgetProcess.on('error', (err) => {
+        console.error(chalk_1.default.red('❌ Failed to start widget server'), err);
+    });
+    // 2. Start Simulator Server
+    const app = (0, express_1.default)();
+    const simulatorPort = 3002; // Changed from 3000 to avoid conflict with API
+    const realApiUrl = process.env.KLYB_API_URL || 'http://localhost:3000';
+    // API Route for Simulator to get Configuration
+    app.get('/simulator/api/config', async (req, res) => {
+        const apiKey = process.env.KLYB_API_KEY;
+        let user = null;
+        if (apiKey) {
+            try {
+                // Determine if apiKey is a JWT or a special key. 
+                // For now, assuming it's a Bearer Token (Personal Access Token)
+                const response = await axios_1.default.get(`${realApiUrl}/api/auth/me`, {
+                    headers: { Authorization: `Bearer ${apiKey}` }
+                });
+                user = response.data;
+                // Add role/permissions if needed
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('❌ Failed to validate API Key:'), error.message);
+                // Don't fail the request, just return guest mode with error
+            }
+        }
+        res.json({
+            user: user || { id: 'guest', name: 'Guest Developer', role: 'guest' },
+            mode: apiKey ? 'authenticated' : 'guest',
+            apiUrl: realApiUrl
+        });
+    });
+    // Resolve path to built simulator client assets
+    let simulatorDist = path_1.default.join(__dirname, '../../simulator/client');
+    if (!fs_1.default.existsSync(simulatorDist) || !fs_1.default.existsSync(path_1.default.join(simulatorDist, 'index.html'))) {
+        console.warn(chalk_1.default.yellow('⚠️  Simulator build not found. Ensure CLI is built.'));
+        simulatorDist = path_1.default.join(__dirname, '../../../dist/simulator/client');
+    }
+    app.use(express_1.default.static(simulatorDist));
+    app.get('*', (req, res) => {
+        // handle api routes not found
+        if (req.path.startsWith('/simulator/api')) {
+            return res.status(404).json({ error: 'Not Found' });
+        }
+        res.sendFile(path_1.default.join(simulatorDist, 'index.html'));
+    });
+    app.listen(simulatorPort, () => {
+        console.log(chalk_1.default.green(`\n📱 Simulator running at http://localhost:${simulatorPort}`));
+        console.log(chalk_1.default.cyan(`   Widget running at http://localhost:${widgetPort}`));
+        console.log(chalk_1.default.dim('   Press Ctrl+C to stop.'));
+    });
+    process.on('SIGINT', () => {
+        widgetProcess.kill();
+        process.exit();
+    });
+}

package/dist/commands/init.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+// In CommonJS, __dirname is available globally
+async function initCommand(name) {
+    const targetDir = path_1.default.resolve(process.cwd(), name);
+    if (fs_extra_1.default.existsSync(targetDir)) {
+        console.error(chalk_1.default.red(`❌ Directory ${name} already exists.`));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue(`🚀 Creating new Klyb widget project: ${name}`));
+    // 1. Copy Template
+    // In dev (ts-node/src), template is in src/templates
+    // In prod (dist), template is in dist/templates (need to ensure build copies it)
+    // For now we assume we are running from src or built dist where structure is preserved.
+    // Adjust path based on where we are executing.
+    // We need to resolve the template path relative to this file.
+    // If we are in dist/commands/init.js, template should be in ../templates/react-vite-ts relative to this file? 
+    // No, standard is usually to keep templates as assets.
+    // Let's assume we are in src/commands/init.ts for dev flow or dist/commands/init.js
+    // Quick fix for path resolution in both envs: look for templates dir up the tree
+    const templateName = 'react-vite-ts';
+    let templateDir = path_1.default.join(__dirname, '../../templates', templateName); // from dist/commands or src/commands
+    // Fallback if structure is different (e.g. src vs dist) - explicit check
+    if (!fs_extra_1.default.existsSync(templateDir)) {
+        // Try source path if we are running from dist but templates are in src (common in local dev)
+        templateDir = path_1.default.join(__dirname, '../../src/templates', templateName);
+    }
+    if (!fs_extra_1.default.existsSync(templateDir)) {
+        console.error(chalk_1.default.red(`❌ Template not found at ${templateDir}`));
+        process.exit(1);
+    }
+    try {
+        await fs_extra_1.default.copy(templateDir, targetDir);
+        // 2. Customize package.json
+        const pkgPath = path_1.default.join(targetDir, 'package.json');
+        const pkg = await fs_extra_1.default.readJson(pkgPath);
+        pkg.name = name;
+        await fs_extra_1.default.writeJson(pkgPath, pkg, { spaces: 2 });
+        // 3. Rename files starting with _ (to avoid npm stripping them)
+        const gitignorePath = path_1.default.join(targetDir, '_gitignore');
+        if (fs_extra_1.default.existsSync(gitignorePath)) {
+            await fs_extra_1.default.move(gitignorePath, path_1.default.join(targetDir, '.gitignore'));
+        }
+        const envExamplePath = path_1.default.join(targetDir, '_env.example');
+        if (fs_extra_1.default.existsSync(envExamplePath)) {
+            await fs_extra_1.default.move(envExamplePath, path_1.default.join(targetDir, '.env.example'));
+        }
+        console.log(chalk_1.default.green(`✅ Project created in ${targetDir}`));
+        // 4. Prompt for install
+        const { install } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'install',
+                message: 'Install dependencies now?',
+                default: true
+            }]);
+        if (install) {
+            console.log(chalk_1.default.yellow('📦 Installing dependencies...'));
+            (0, child_process_1.execSync)('npm install', { cwd: targetDir, stdio: 'inherit' });
+            console.log(chalk_1.default.green('✅ Dependencies installed'));
+        }
+        console.log('\nNext steps:');
+        console.log(chalk_1.default.cyan(`  cd ${name}`));
+        console.log(chalk_1.default.cyan('  npm run dev'));
+    }
+    catch (e) {
+        console.error(chalk_1.default.red('❌ Failed to create project'), e);
+    }
+}

package/dist/commands/login.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginCommand = loginCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const http_1 = __importDefault(require("http"));
+const credentials_1 = require("../credentials");
+const DEFAULT_API_URL = process.env.KLYB_API_URL || 'http://localhost:3000';
+/**
+ * `klyb login`
+ *
+ * 1. Starts a one-shot local HTTP server on a random port
+ * 2. Opens the browser to the backend's CLI login page
+ * 3. After the user logs in, the backend redirects back with the JWT
+ * 4. CLI saves the token to ~/.klyb/credentials.json
+ */
+async function loginCommand() {
+    const apiUrl = DEFAULT_API_URL;
+    console.log(chalk_1.default.blue('🔑 Logging in to Klyb...'));
+    console.log(chalk_1.default.dim(`   API: ${apiUrl}\n`));
+    const token = await waitForToken(apiUrl);
+    // Persist credentials
+    (0, credentials_1.saveCredentials)({
+        token,
+        apiUrl,
+        savedAt: new Date().toISOString(),
+    });
+    console.log(chalk_1.default.green('\n✅ Logged in successfully!'));
+    console.log(chalk_1.default.dim(`   Credentials saved to: ${(0, credentials_1.credentialsPath)()}`));
+    console.log(chalk_1.default.dim('   You can now run: klyb deploy'));
+}
+function waitForToken(apiUrl) {
+    return new Promise((resolve, reject) => {
+        // One-shot HTTP server to receive the callback
+        const server = http_1.default.createServer((req, res) => {
+            const url = new URL(req.url, `http://localhost`);
+            if (url.pathname === '/callback') {
+                const token = url.searchParams.get('token');
+                const error = url.searchParams.get('error');
+                if (token) {
+                    // Success — show a nice page to the user
+                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(`
+                        <!DOCTYPE html>
+                        <html>
+                        <head><title>Klyb CLI</title></head>
+                        <body style="font-family:sans-serif;text-align:center;padding:4rem;background:#0f172a;color:white">
+                            <h1 style="color:#22d3ee">✅ Logged in!</h1>
+                            <p style="color:#94a3b8">You can close this window and return to your terminal.</p>
+                        </body>
+                        </html>
+                    `);
+                    server.close();
+                    resolve(token);
+                }
+                else {
+                    res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(`<p>Error: ${error || 'unknown'}</p>`);
+                    server.close();
+                    reject(new Error(error || 'Login failed'));
+                }
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        // Listen on a random available port
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const callbackUrl = `http://127.0.0.1:${address.port}/callback`;
+            const loginUrl = `${apiUrl}/api/auth/cli-login?redirect=${encodeURIComponent(callbackUrl)}`;
+            console.log(chalk_1.default.cyan('   Opening browser for authentication...'));
+            console.log(chalk_1.default.dim(`   If the browser doesn't open, visit:\n   ${loginUrl}\n`));
+            // Dynamic import to handle ESM-only open package
+            Promise.resolve().then(() => __importStar(require('open'))).then(({ default: openBrowser }) => openBrowser(loginUrl)).catch(() => { });
+        });
+        // Timeout after 5 minutes
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('Login timed out. Please try again.'));
+        }, 5 * 60 * 1000);
+        server.on('close', () => clearTimeout(timeout));
+        server.on('error', reject);
+    });
+}

package/dist/credentials.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCredentials = getCredentials;
+exports.saveCredentials = saveCredentials;
+exports.clearCredentials = clearCredentials;
+exports.credentialsPath = credentialsPath;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const CREDENTIALS_PATH = path_1.default.join(os_1.default.homedir(), '.klyb', 'credentials.json');
+function getCredentials() {
+    try {
+        if (!fs_extra_1.default.existsSync(CREDENTIALS_PATH))
+            return null;
+        return fs_extra_1.default.readJsonSync(CREDENTIALS_PATH);
+    }
+    catch {
+        return null;
+    }
+}
+function saveCredentials(creds) {
+    fs_extra_1.default.ensureDirSync(path_1.default.dirname(CREDENTIALS_PATH));
+    fs_extra_1.default.writeJsonSync(CREDENTIALS_PATH, creds, { spaces: 2 });
+}
+function clearCredentials() {
+    if (fs_extra_1.default.existsSync(CREDENTIALS_PATH)) {
+        fs_extra_1.default.removeSync(CREDENTIALS_PATH);
+    }
+}
+function credentialsPath() {
+    return CREDENTIALS_PATH;
+}

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const dev_1 = require("./commands/dev");
+const deploy_1 = require("./commands/deploy");
+const login_1 = require("./commands/login");
+const program = new commander_1.Command();
+program
+    .name('klyb')
+    .description('Klyb Developer CLI')
+    .version('0.1.0');
+program
+    .command('login')
+    .description('Authenticate with Klyb (opens browser)')
+    .action(login_1.loginCommand);
+program
+    .command('init')
+    .description('Initialize a new Klyb widget project')
+    .argument('<name>', 'Project name')
+    .action(init_1.initCommand);
+program
+    .command('dev')
+    .description('Start development server with Simulator')
+    .action(dev_1.devCommand);
+program
+    .command('deploy')
+    .description('Build and deploy widget to Klyb')
+    .option('--submit', 'Submit for validation immediately')
+    .action(deploy_1.deployCommand);
+program.parse();