agentbuilders 0.6.0

package/README.md

@@ -0,0 +1,93 @@
+# AgentBuilders CLI
+
+Deploy full-stack web apps with one command. Database, file storage, user auth, and RBAC included.
+
+## Install
+
+```bash
+npm install -g agentbuilders
+```
+
+## Quick Start
+
+```bash
+# Set your API key
+export AB_KEY=your_api_key_here
+
+# Deploy current directory
+ab deploy
+
+# Deploy specific directory with name
+ab deploy ./my-app --name cool-app --public
+
+# List your apps
+ab list
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `ab deploy [dir] [--name <n>] [--public]` | Deploy app from directory |
+| `ab list` | List all your apps |
+| `ab get <name>` | Get app details (JSON) |
+| `ab delete <name>` | Delete an app |
+| `ab key <name>` | Get app viewKey |
+| `ab status` | Platform status |
+| `ab health` | API health check |
+| `ab subscription` | Your tier and limits |
+| `ab upgrade <tier>` | Upgrade (opens Stripe checkout) |
+| `ab domains` | List custom domains |
+| `ab domains add <host> <app>` | Add custom domain |
+| `ab domains remove <host>` | Remove custom domain |
+| `ab domains status <host>` | Check domain verification |
+| `ab init [dir]` | Create ab.json config file |
+| `ab whoami` | Show current account info |
+| `ab version` | Show CLI version |
+
+## Configuration (ab.json)
+
+Create an `ab.json` in your project root to configure database, auth, and RBAC:
+
+```json
+{
+  "name": "my-app",
+  "public": false,
+  "storage": {
+    "database": {
+      "tables": {
+        "items": { "name": "TEXT", "value": "TEXT", "created_at": "TEXT" }
+      }
+    },
+    "files": true
+  },
+  "auth": { "enabled": true },
+  "rbac": {
+    "roles": {
+      "admin": { "permissions": ["*"] },
+      "editor": { "permissions": ["data:read", "data:write", "files:read", "files:write"] },
+      "viewer": { "permissions": ["data:read", "files:read"] }
+    },
+    "default_role": "viewer"
+  }
+}
+```
+
+Run `ab init` to generate a starter config.
+
+## Tiers
+
+| Tier | Price | Apps | DB Rows | Storage |
+|------|-------|------|---------|---------|
+| Free | $0 | 3 | 5K | 50MB |
+| Hobby | $9/mo | 10 | 50K | 500MB |
+| Pro | $19/mo | 25 | 500K | 2GB |
+| Studio | $49/mo | 50 | 2M | 5GB |
+| Founder | $99+ | 50 | 2M | 5GB (lifetime) |
+
+## Links
+
+- [Docs](https://agentbuilders.app/docs)
+- [Pricing](https://agentbuilders.app/pricing)
+- [Status](https://agentbuilders.app/status)
+- [API](https://api.agentbuilders.app/openapi.json)

package/index.js

@@ -0,0 +1,576 @@
+#!/usr/bin/env node
+// AgentBuilders CLI v0.6.0 — ab deploy, ab list, ab get, ab delete, ab key, ab status, ab upgrade, ab domains, ab init
+const API = 'https://api.agentbuilders.app';
+const VERSION = '0.6.0';
+
+const args = process.argv.slice(2);
+const cmd = args[0];
+
+async function getConfigPath() {
+  const { homedir } = await import('node:os');
+  const { join } = await import('node:path');
+  return join(homedir(), '.agentbuilders', 'config.json');
+}
+
+async function loadConfig() {
+  try {
+    const { readFile } = await import('node:fs/promises');
+    const data = JSON.parse(await readFile(await getConfigPath(), 'utf-8'));
+    return data;
+  } catch { return {}; }
+}
+
+async function saveConfig(config) {
+  const { writeFile, mkdir } = await import('node:fs/promises');
+  const { dirname } = await import('node:path');
+  const path = await getConfigPath();
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  await writeFile(path, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+}
+
+function getKey() {
+  // Try env var first (for CI/scripts), then check if we have a stored key
+  const k = process.env.AB_KEY || process.env.AGENTBUILDERS_KEY;
+  if (k) return k;
+  // Sync read of config file (loaded async in commands that need it)
+  // For now, require env var — ab login sets it up
+  console.error('Error: No API key found.\n  Run: ab login <your_api_key>\n  Or:  export AB_KEY=your_api_key_here');
+  process.exit(1);
+}
+
+async function getKeyAsync() {
+  const k = process.env.AB_KEY || process.env.AGENTBUILDERS_KEY;
+  if (k) return k;
+  const config = await loadConfig();
+  if (config.api_key) return config.api_key;
+  console.error('Error: No API key found.\n  Run: ab login <your_api_key>\n  Or:  export AB_KEY=your_api_key_here');
+  process.exit(1);
+}
+
+async function apiAsync(method, path, body, opts = {}) {
+  const headers = { 'Content-Type': 'application/json' };
+  if (!opts.noAuth) headers['Authorization'] = `Bearer ${await getKeyAsync()}`;
+  const fetchOpts = { method, headers };
+  if (body) fetchOpts.body = JSON.stringify(body);
+  const res = await fetch(`${API}${path}`, fetchOpts);
+  const data = await res.json();
+  if (!data._ok && data.error && !opts.raw) {
+    console.error(`Error: ${data.error} — ${data.message}`);
+    if (data.fix) console.error(`Fix: ${data.fix}`);
+    process.exit(1);
+  }
+  return data;
+}
+
+function getFlag(name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx === -1) return null;
+  return args[idx + 1] || true;
+}
+
+function hasFlag(name) { return args.includes(`--${name}`); }
+
+// Legacy sync api function — redirects to async version
+async function api(method, path, body, opts = {}) {
+  return apiAsync(method, path, body, opts);
+}
+
+async function readFiles(dir) {
+  const { readdir, readFile } = await import('node:fs/promises');
+  const { join, relative } = await import('node:path');
+  const files = {};
+  async function walk(d) {
+    const entries = await readdir(d, { withFileTypes: true });
+    for (const e of entries) {
+      const p = join(d, e.name);
+      if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === 'ab.json') continue;
+      if (e.isDirectory()) { await walk(p); }
+      else {
+        const rel = relative(dir, p);
+        const buf = await readFile(p);
+        const ext = e.name.split('.').pop()?.toLowerCase();
+        const textExts = new Set(['html','css','js','json','txt','md','svg','xml','yaml','yml','toml','ts','jsx','tsx','mjs','cjs','map','csv']);
+        if (textExts.has(ext || '')) {
+          files[rel] = buf.toString('utf-8');
+        } else {
+          files[rel] = `data:application/octet-stream;base64,${buf.toString('base64')}`;
+        }
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+
+async function main() {
+  if (!cmd || cmd === '--help' || cmd === '-h') {
+    console.log(`AgentBuilders CLI v${VERSION}
+
+Usage:
+  ab login <key>                                Store API key locally
+  ab logout                                     Remove stored key
+  ab deploy [dir] [--name <name>] [--public]   Deploy app from directory
+  ab list                                       List all apps
+  ab get <name>                                 Get app details
+  ab delete <name>                              Delete an app
+  ab key <name>                                 Get app viewKey
+  ab logs [app] [--limit N]                     Recent activity log
+  ab status                                     Platform status
+  ab health                                     API health check
+  ab subscription                               Your subscription & limits
+  ab upgrade <tier>                             Upgrade tier (hobby/pro/studio)
+  ab domains                                    List custom domains
+  ab domains add <hostname> <app>               Add custom domain
+  ab domains remove <hostname>                  Remove custom domain
+  ab domains status <hostname>                  Check domain status
+  ab init [dir]                                 Create ab.json config
+  ab dev [dir] [--port N]                       Local dev server with live reload
+  ab whoami                                     Show current account info
+  ab version                                    Show CLI version
+  ab ai <prompt>                                Run Edge AI inference
+
+Auth:
+  ab login <key>   Store key in ~/.agentbuilders/config.json
+  AB_KEY env var   Alternative (for CI/scripts)
+
+Tiers: free ($0) | hobby ($9/mo) | pro ($19/mo) | studio ($49/mo) | founder (lifetime)
+Docs: https://agentbuilders.app/docs
+`);
+    return;
+  }
+
+  if (cmd === 'version' || cmd === '--version' || cmd === '-v') {
+    console.log(`ab v${VERSION}`);
+    return;
+  }
+
+  if (cmd === 'login') {
+    const key = args[1];
+    if (!key) { console.error('Usage: ab login <your_api_key>'); process.exit(1); }
+    // Validate key by calling /apps
+    try {
+      const res = await fetch(`${API}/apps`, {
+        headers: { 'Authorization': `Bearer ${key}`, 'Content-Type': 'application/json' }
+      });
+      const data = await res.json();
+      if (res.status === 401 || res.status === 403) {
+        console.error('Error: Invalid API key.');
+        process.exit(1);
+      }
+      const config = await loadConfig();
+      config.api_key = key;
+      await saveConfig(config);
+      console.log(`✓ Logged in successfully (${(data.apps || []).length} apps)`);
+      console.log(`  Key stored in ~/.agentbuilders/config.json (600 permissions)`);
+    } catch (e) {
+      console.error(`Error: Could not connect to API: ${e.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (cmd === 'logout') {
+    const config = await loadConfig();
+    delete config.api_key;
+    await saveConfig(config);
+    console.log('✓ Logged out (key removed from local config)');
+    return;
+  }
+
+  if (cmd === 'logs') {
+    // First non-flag arg after 'logs' is app name
+    let appName = null;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--limit') { i++; continue; }
+      if (args[i].startsWith('--')) continue;
+      appName = args[i];
+      break;
+    }
+    const limit = getFlag('limit') || '20';
+    const params = new URLSearchParams({ limit });
+    if (appName) params.set('app', appName);
+    const data = await api('GET', `/v1/logs?${params}`);
+    const logs = data.logs || [];
+    if (!logs.length) { console.log('No recent activity.'); return; }
+    for (const log of logs) {
+      const time = new Date(log.timestamp).toLocaleString();
+      const icon = log.status === 'completed' ? '✓' : log.status === 'failed' ? '✗' : '○';
+      console.log(`  ${icon} ${time}  ${log.operation}  ${log.app_name}  ${log.details || ''}`);
+    }
+    return;
+  }
+
+  if (cmd === 'health') {
+    const res = await fetch(`${API}/health`);
+    const data = await res.json();
+    console.log(`✓ ${data.service} v${data.version} — ${data.status}`);
+    return;
+  }
+
+  if (cmd === 'status') {
+    const res = await fetch('https://agentbuilders.app/status');
+    const data = await res.json();
+    const icon = data.status === 'operational' ? '✓' : '⚠';
+    console.log(`${icon} Platform: ${data.status}`);
+    for (const [name, svc] of Object.entries(data.services || {})) {
+      const s = svc;
+      const si = s.status === 'operational' ? '  ✓' : '  ⚠';
+      console.log(`${si} ${name}: ${s.status}${s.latency_ms ? ` (${s.latency_ms}ms)` : ''}`);
+    }
+    if (data.errors_last_hour > 0) console.log(`  ⚠ ${data.errors_last_hour} errors in last hour`);
+    return;
+  }
+
+  if (cmd === 'whoami') {
+    const data = await api('GET', '/v1/subscription', null, { raw: true });
+    if (data.tier) {
+      console.log(`Tier: ${data.tier}`);
+      console.log(`Status: ${data.subscription_status || 'active'}`);
+      if (data.limits) {
+        console.log(`Limits:`);
+        for (const [k, v] of Object.entries(data.limits)) {
+          console.log(`  ${k}: ${v}`);
+        }
+      }
+    } else {
+      console.log('Authenticated as admin');
+    }
+    return;
+  }
+
+  if (cmd === 'subscription') {
+    const data = await api('GET', '/v1/subscription', null, { raw: true });
+    if (data._ok === false && data.error === 'missing_auth') {
+      // Admin key doesn't work for subscription - show admin info
+      console.log('Admin account (no subscription tier)');
+      return;
+    }
+    if (data.tier) {
+      console.log(`Tier: ${data.tier}`);
+      console.log(`Status: ${data.subscription_status || 'none'}`);
+      console.log(`Billing: ${data.billing_interval || 'N/A'}`);
+      if (data.pending_tier) console.log(`Pending upgrade: ${data.pending_tier}`);
+      console.log(`\nLimits:`);
+      if (data.limits) {
+        const l = data.limits;
+        console.log(`  Apps: ${l.apps}`);
+        console.log(`  DB rows: ${l.db_rows?.toLocaleString()}`);
+        console.log(`  Storage: ${l.storage_mb}MB`);
+        console.log(`  Files: ${l.files}`);
+        console.log(`  Writes: ${l.writes_hourly}/hr, ${l.writes_daily}/day`);
+      }
+      console.log(`\nUpgrade: ab upgrade <hobby|pro|studio>`);
+    }
+    return;
+  }
+
+  if (cmd === 'upgrade') {
+    const tier = args[1];
+    if (!tier || !['hobby', 'pro', 'studio', 'founder'].includes(tier)) {
+      console.error('Usage: ab upgrade <hobby|pro|studio|founder>');
+      console.error('\nTiers:');
+      console.error('  hobby   $9/mo   10 apps, 50K rows, custom subdomains');
+      console.error('  pro     $19/mo  25 apps, 500K rows, custom domains');
+      console.error('  studio  $49/mo  50 apps, 2M rows, priority support');
+      console.error('  founder $99+    Lifetime Studio-equivalent');
+      process.exit(1);
+    }
+    const body = { tier };
+    if (tier === 'founder') {
+      const batchId = getFlag('batch') || 1;
+      body.batch_id = parseInt(batchId);
+    }
+    const data = await api('POST', '/v1/checkout', body, { raw: true });
+    if (data.checkout_url) {
+      console.log(`\nCheckout URL: ${data.checkout_url}`);
+      console.log(`\nOpen this URL in your browser to complete payment.`);
+      console.log(`Your tier will upgrade automatically on successful payment.`);
+      // Try to open in browser
+      try {
+        const { exec } = await import('node:child_process');
+        const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+        exec(`${openCmd} "${data.checkout_url}"`);
+      } catch {}
+    } else if (data.error) {
+      console.error(`Error: ${data.message}`);
+      if (data.fix) console.error(`Fix: ${data.fix}`);
+    }
+    return;
+  }
+
+  if (cmd === 'domains') {
+    const subcmd = args[1];
+
+    if (!subcmd || subcmd === 'list') {
+      const data = await api('GET', '/v1/domains', null, { raw: true });
+      if (data.error) {
+        console.error(`Error: ${data.message}`);
+        if (data.fix) console.error(data.fix);
+        return;
+      }
+      const domains = data.domains || [];
+      if (!domains.length) { console.log('No custom domains configured.'); return; }
+      console.log(`${domains.length} domain(s):\n`);
+      for (const d of domains) {
+        const icon = d.status === 'active' ? '✓' : d.status === 'pending_verification' ? '⏳' : '⚠';
+        console.log(`  ${icon} ${d.hostname} → ${d.app_name} (${d.status})`);
+      }
+      return;
+    }
+
+    if (subcmd === 'add') {
+      const hostname = args[2];
+      const appName = args[3];
+      if (!hostname || !appName) { console.error('Usage: ab domains add <hostname> <app-name>'); process.exit(1); }
+      const data = await api('POST', '/v1/domains', { hostname, app_name: appName });
+      console.log(`✓ Domain ${hostname} added`);
+      if (data.verification) {
+        console.log(`\nVerification required:`);
+        console.log(`  Add TXT record: ${data.verification.name} → ${data.verification.value}`);
+      }
+      return;
+    }
+
+    if (subcmd === 'remove') {
+      const hostname = args[2];
+      if (!hostname) { console.error('Usage: ab domains remove <hostname>'); process.exit(1); }
+      await api('DELETE', `/v1/domains/${hostname}`);
+      console.log(`✓ Domain ${hostname} removed`);
+      return;
+    }
+
+    if (subcmd === 'status') {
+      const hostname = args[2];
+      if (!hostname) { console.error('Usage: ab domains status <hostname>'); process.exit(1); }
+      const data = await api('GET', `/v1/domains/${hostname}/status`);
+      console.log(`Domain: ${hostname}`);
+      console.log(`Status: ${data.status}`);
+      if (data.ssl_status) console.log(`SSL: ${data.ssl_status}`);
+      return;
+    }
+
+    console.error(`Unknown domains subcommand: ${subcmd}`);
+    console.error('Usage: ab domains [list|add|remove|status]');
+    process.exit(1);
+  }
+
+  if (cmd === 'init') {
+    const { writeFile } = await import('node:fs/promises');
+    const { resolve, basename } = await import('node:path');
+    const dir = args[1] || '.';
+    const absDir = resolve(dir);
+    const name = basename(absDir).toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-|-$/g, '') || 'my-app';
+    const config = {
+      name,
+      public: false,
+      storage: {
+        database: {
+          tables: {
+            items: { name: 'TEXT', value: 'TEXT', created_at: 'TEXT' }
+          }
+        },
+        files: true
+      },
+      auth: { enabled: true },
+    };
+    const path = resolve(absDir, 'ab.json');
+    await writeFile(path, JSON.stringify(config, null, 2) + '\n');
+    console.log(`✓ Created ${path}`);
+    console.log(`\nEdit ab.json to configure your app, then run:`);
+    console.log(`  ab deploy ${dir === '.' ? '' : dir}`);
+    return;
+  }
+
+  if (cmd === 'deploy') {
+    const { resolve, basename } = await import('node:path');
+    let dir = '.';
+    let name = getFlag('name') || '';
+    let isPublic = hasFlag('public');
+    // First non-flag arg after 'deploy' is the dir
+    for (let i = 1; i < args.length; i++) {
+      if (args[i].startsWith('--')) { if (args[i] === '--name') i++; continue; }
+      dir = args[i];
+    }
+    const absDir = resolve(dir);
+    if (!name) name = basename(absDir).toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-|-$/g, '') || 'my-app';
+
+    console.log(`Deploying ${name} from ${absDir}...`);
+    const files = await readFiles(absDir);
+    const fileCount = Object.keys(files).length;
+    if (fileCount === 0) { console.error('Error: No files found in directory.'); process.exit(1); }
+
+    const payload = { name, files };
+    if (isPublic) payload.public = true;
+
+    // Check for ab.json config
+    try {
+      const { readFile } = await import('node:fs/promises');
+      const config = JSON.parse(await readFile(resolve(absDir, 'ab.json'), 'utf-8'));
+      if (config.name && !getFlag('name')) payload.name = config.name;
+      if (config.storage) payload.storage = config.storage;
+      if (config.auth) payload.auth = config.auth;
+      if (config.rbac) payload.rbac = config.rbac;
+      if (config.public !== undefined && !isPublic) payload.public = config.public;
+    } catch {}
+
+    const data = await api('POST', '/deploy', payload);
+    console.log(`✓ Deployed ${fileCount} files`);
+    console.log(`  URL: ${data.url}`);
+    if (data.viewKey) console.log(`  viewKey: ${data.viewKey}`);
+    console.log(`  Version: ${data.version}`);
+    return;
+  }
+
+  if (cmd === 'list') {
+    const data = await api('GET', '/apps');
+    if (!data.apps?.length) { console.log('No apps deployed.'); return; }
+    console.log(`${data.apps.length} app(s):\n`);
+    for (const app of data.apps) {
+      const vis = app.visibility === 'public' ? '🌐' : '🔒';
+      const url = `https://${app.name}.agentbuilders.app`;
+      console.log(`  ${vis} ${app.name}  v${app.version}  ${url}`);
+    }
+    return;
+  }
+
+  if (cmd === 'get') {
+    const name = args[1];
+    if (!name) { console.error('Usage: ab get <name>'); process.exit(1); }
+    const data = await api('GET', `/apps/${name}`);
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  if (cmd === 'delete') {
+    const name = args[1];
+    if (!name) { console.error('Usage: ab delete <name>'); process.exit(1); }
+    await api('DELETE', `/apps/${name}`);
+    console.log(`✓ Deleted ${name} (7-day name quarantine)`);
+    return;
+  }
+
+  if (cmd === 'key') {
+    const name = args[1];
+    if (!name) { console.error('Usage: ab key <name>'); process.exit(1); }
+    const data = await api('GET', `/apps/${name}/key`);
+    console.log(data.viewKey || data.view_key);
+    return;
+  }
+
+  if (cmd === 'dev') {
+    const { createServer } = await import('node:http');
+    const { readFile, stat, readdir } = await import('node:fs/promises');
+    const { join, extname } = await import('node:path');
+    const { watch } = await import('node:fs');
+
+    const dir = args[1] && !args[1].startsWith('-') ? args[1] : '.';
+    const port = parseInt(getFlag('port') || '3000');
+
+    const MIME_TYPES = {
+      '.html': 'text/html', '.css': 'text/css', '.js': 'application/javascript',
+      '.json': 'application/json', '.png': 'image/png', '.jpg': 'image/jpeg',
+      '.gif': 'image/gif', '.svg': 'image/svg+xml', '.ico': 'image/x-icon',
+      '.woff2': 'font/woff2', '.woff': 'font/woff', '.ttf': 'font/ttf',
+      '.mp4': 'video/mp4', '.webm': 'video/webm', '.mp3': 'audio/mpeg',
+      '.pdf': 'application/pdf', '.txt': 'text/plain', '.md': 'text/markdown',
+      '.csv': 'text/csv', '.xml': 'text/xml',
+    };
+
+    // SSE clients for live reload
+    const clients = new Set();
+    const RELOAD_SCRIPT = `<script>(function(){var e=new EventSource("/__dev_reload");e.onmessage=function(){location.reload()};e.onerror=function(){setTimeout(function(){location.reload()},1000)}})()</script>`;
+
+    const server = createServer(async (req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      let filePath = url.pathname === '/' ? '/index.html' : url.pathname;
+
+      // SSE endpoint for live reload
+      if (filePath === '/__dev_reload') {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive', 'Access-Control-Allow-Origin': '*',
+        });
+        clients.add(res);
+        req.on('close', () => clients.delete(res));
+        return;
+      }
+
+      const fullPath = join(dir, filePath);
+      try {
+        const s = await stat(fullPath);
+        if (s.isDirectory()) {
+          // Try index.html in directory
+          try {
+            const idx = join(fullPath, 'index.html');
+            await stat(idx);
+            filePath = filePath + '/index.html';
+          } catch {
+            // Generate directory listing
+            const entries = await readdir(fullPath, { withFileTypes: true });
+            const items = entries.map(e => {
+              const name = e.isDirectory() ? e.name + '/' : e.name;
+              return `<li><a href="${filePath}/${e.name}">${name}</a></li>`;
+            }).join('');
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(`<!DOCTYPE html><html><head><title>Directory: ${filePath}</title></head><body><h2>${filePath}</h2><ul>${items}</ul>${RELOAD_SCRIPT}</body></html>`);
+            return;
+          }
+        }
+
+        const actualPath = join(dir, filePath);
+        const content = await readFile(actualPath);
+        const ext = extname(actualPath).toLowerCase();
+        const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+
+        // Inject live reload script into HTML files
+        if (ext === '.html') {
+          const html = content.toString('utf-8').replace('</body>', RELOAD_SCRIPT + '</body>');
+          res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': 'no-cache' });
+          res.end(html);
+        } else {
+          res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': 'no-cache' });
+          res.end(content);
+        }
+      } catch {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Not found');
+      }
+    });
+
+    server.listen(port, () => {
+      console.log(`\n  ⚡ AgentBuilders Dev Server\n`);
+      console.log(`  Local:   http://localhost:${port}`);
+      console.log(`  Dir:     ${join(process.cwd(), dir)}`);
+      console.log(`  Reload:  Watching for file changes...\n`);
+    });
+
+    // Watch for file changes and trigger live reload
+    const watcher = watch(dir, { recursive: true }, (event, filename) => {
+      if (filename && !filename.startsWith('.') && !filename.includes('node_modules')) {
+        console.log(`  ↻ ${filename} changed`);
+        for (const client of clients) {
+          client.write('data: reload\n\n');
+        }
+      }
+    });
+
+    process.on('SIGINT', () => { watcher.close(); server.close(); process.exit(0); });
+    return;
+  }
+
+  if (cmd === 'ai') {
+    const prompt = args.slice(1).join(' ');
+    if (!prompt) { console.error('Usage: ab ai <prompt>'); process.exit(1); }
+    const data = await api('POST', '/v1/ai/run', {
+      model: '@cf/meta/llama-3.1-8b-instruct',
+      prompt,
+    });
+    console.log(data.result?.response || JSON.stringify(data.result, null, 2));
+    return;
+  }
+
+  console.error(`Unknown command: ${cmd}. Run 'ab --help' for usage.`);
+  process.exit(1);
+}
+
+main().catch(e => { console.error(e.message); process.exit(1); });

package/package.json

@@ -0,0 +1 @@
+{"name":"agentbuilders","version":"0.6.0","description":"CLI for AgentBuilders.app","mcpName":"agentbuilders/deploy","bin":{"ab":"./index.js"},"type":"module","license":"MIT","keywords":["agent","ai","deploy","mcp"],"engines":{"node":">=18"},"files":["index.js","README.md"]}