@portl/cli 0.1.0

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@portl/cli",
+  "version": "0.1.0",
+  "description": "Portl CLI - BYOI orchestration for AI coding agents",
+  "type": "module",
+  "bin": {
+    "portl": "./bin/portl.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "node ./bin/portl.js --help",
+    "pack:check": "npm pack --dry-run"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "portl",
+    "cli",
+    "mcp",
+    "byoi",
+    "ai-agents",
+    "backend-as-a-service"
+  ],
+  "author": "Portl",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/portl-dev/portl.git",
+    "directory": "portl-cli"
+  },
+  "homepage": "https://portl.dev"
+}

package/src/commands/init.js

@@ -0,0 +1,663 @@
+/**
+ * Simplified init command - conversational wizard for Portl setup
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import {
+  showBanner,
+  showSection,
+  showTip,
+  showSuccess,
+  showWarning,
+  showError,
+  showInfo,
+  showSummary,
+  showNextSteps,
+  askYesNo,
+  askNonEmpty,
+  selectOption,
+  Spinner,
+  c,
+  ANSI,
+} from '../utils/prompts.js';
+
+/**
+ * Read existing portl.config.json if it exists
+ */
+async function readExistingConfig(cwd) {
+  try {
+    const configPath = path.join(cwd, 'portl.config.json');
+    const content = await fs.readFile(configPath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect API key from environment or .env file
+ */
+async function detectApiKey(cwd) {
+  // Check environment variable first
+  if (process.env.ACCESS_API_KEY) {
+    return process.env.ACCESS_API_KEY;
+  }
+
+  // Try to read from .env file
+  try {
+    const envPath = path.join(cwd, '.env');
+    const content = await fs.readFile(envPath, 'utf8');
+    const match = content.match(/^ACCESS_API_KEY\s*=\s*(.+)$/m);
+    if (match && match[1]) {
+      return match[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+  } catch {
+    // .env file doesn't exist or can't be read
+  }
+
+  return null;
+}
+
+/**
+ * Collect database configuration
+ */
+async function collectDatabaseConfig(rl, apiKey, apiBaseUrl, projectId) {
+  showSection('DATABASE', '📦');
+  
+  const needsDatabase = await askYesNo(rl, 'Do you need a database?', true);
+  showTip('Portl connects to your existing database (PostgreSQL, MySQL, MongoDB, Supabase, Neon)');
+  console.log('');
+  
+  if (!needsDatabase) {
+    showInfo('Skipping database configuration');
+    return null;
+  }
+
+  const provider = await selectOption(rl, 'Choose your database provider', [
+    { label: 'Supabase', value: 'supabase', description: 'PostgreSQL + Auth + Storage' },
+    { label: 'Neon', value: 'neon', description: 'Serverless PostgreSQL' },
+    { label: 'PostgreSQL', value: 'postgres.generic', description: 'Self-hosted or managed' },
+    { label: 'MySQL', value: 'mysql', description: 'Self-hosted or managed' },
+    { label: 'MongoDB', value: 'mongodb', description: 'Document database' },
+    { label: 'PlanetScale', value: 'planetscale', description: 'Serverless MySQL' },
+  ]);
+
+  console.log('');
+
+  if (provider.value === 'supabase') {
+    const useOAuth = await askYesNo(rl, '🔐 Connect via OAuth?', true);
+    console.log('');
+
+    if (useOAuth) {
+      if (apiKey) {
+        // Execute OAuth flow immediately
+        showInfo('Opening browser for Supabase authentication...');
+        
+        try {
+          // Import OAuth functions from main portl.js
+          const { startSupabaseOAuthRequest, waitForSupabaseOAuthConnection } = await import('../../bin/portl.js');
+          
+          const resolvedApiBaseUrl = apiBaseUrl || 'http://localhost:7130/api';
+          const oauthStart = await startSupabaseOAuthRequest({
+            apiBaseUrl: resolvedApiBaseUrl,
+            apiKey,
+            projectId: projectId || 'local',
+            redirectUri: process.env.PORTL_OAUTH_CLI_REDIRECT_URI || `${resolvedApiBaseUrl.replace('/api', '')}/api/providers/oauth/cli/result`,
+          });
+
+          if (oauthStart.authorizeUrl) {
+            console.log('');
+            console.log(c('🔗 OAuth URL:', ANSI.cyan));
+            console.log(c(oauthStart.authorizeUrl, ANSI.dim));
+            console.log('');
+            
+            // Try to open browser
+            const { tryOpenBrowser } = await import('../../bin/portl.js');
+            const openResult = await tryOpenBrowser(oauthStart.authorizeUrl);
+            
+            if (openResult.opened) {
+              showSuccess('Browser opened automatically');
+            } else {
+              showWarning('Could not open browser automatically');
+              showInfo('Please open the URL above in your browser');
+            }
+
+            // Wait for OAuth callback
+            const spinner = new Spinner('Waiting for OAuth callback...');
+            spinner.start();
+            
+            try {
+              const connection = await waitForSupabaseOAuthConnection({
+                apiBaseUrl: resolvedApiBaseUrl,
+                apiKey,
+                projectId: projectId || 'local',
+                startedAt: Date.now(),
+                timeoutMs: 120000, // 2 minutes
+                pollMs: 2000,
+              });
+
+              if (connection?.externalProjectRef) {
+                spinner.success(`Connected to Supabase project: ${connection.externalProjectRef}`);
+                
+                return {
+                  providerId: 'supabase',
+                  category: 'database',
+                  connectable: true,
+                  config: { 
+                    setupMode: 'oauth',
+                    projectRef: connection.externalProjectRef,
+                  },
+                  envTemplate: {
+                    PORTL_DB_SUPABASE_SETUP_MODE: 'oauth',
+                    PORTL_DB_SUPABASE_PROJECT_REF: connection.externalProjectRef,
+                  },
+                };
+              } else {
+                spinner.fail('OAuth completed but no project found');
+                showWarning('You may need to manually configure Supabase');
+              }
+            } catch (error) {
+              spinner.fail('OAuth timeout or failed');
+              showWarning('OAuth did not complete in time. Run "portl connect supabase" to retry');
+            }
+          }
+        } catch (error) {
+          showError(`OAuth setup failed: ${error.message}`);
+          showInfo('Falling back to manual configuration');
+        }
+      } else {
+        // No API key - can't do OAuth now
+        showInfo('OAuth requires API key - will complete after init');
+        showTip('Run "portl connect supabase" after init to complete OAuth');
+      }
+      
+      return {
+        providerId: 'supabase',
+        category: 'database',
+        connectable: true,
+        config: { setupMode: 'oauth' },
+        envTemplate: {
+          PORTL_DB_SUPABASE_SETUP_MODE: 'oauth',
+        },
+      };
+    } else {
+      // Manual setup
+      const url = await askNonEmpty(rl, 'Supabase URL', 'https://YOUR-PROJECT.supabase.co');
+      const serviceRoleKey = await askNonEmpty(rl, 'Service role key');
+
+      return {
+        providerId: 'supabase',
+        category: 'database',
+        connectable: true,
+        config: { setupMode: 'manual', url, serviceRoleKey },
+        envTemplate: {
+          PORTL_DB_SUPABASE_SETUP_MODE: 'manual',
+          PORTL_DB_SUPABASE_URL: url,
+          PORTL_DB_SUPABASE_SERVICE_ROLE_KEY: serviceRoleKey,
+        },
+      };
+    }
+  } else if (provider.value === 'neon') {
+    const connectionString = await askNonEmpty(rl, 'Neon connection string');
+
+    return {
+      providerId: 'neon',
+      category: 'database',
+      connectable: true,
+      config: { connectionString },
+      envTemplate: {
+        PORTL_DB_NEON_CONNECTION_STRING: connectionString,
+      },
+    };
+  } else if (provider.value === 'mysql') {
+    const host = await askNonEmpty(rl, 'MySQL host', 'localhost');
+    const port = await askNonEmpty(rl, 'MySQL port', '3306');
+    const database = await askNonEmpty(rl, 'Database name');
+    const user = await askNonEmpty(rl, 'Database user');
+    const password = await askNonEmpty(rl, 'Database password');
+
+    return {
+      providerId: 'mysql',
+      category: 'database',
+      connectable: false,
+      config: { host, port, database, user, password },
+      envTemplate: {
+        PORTL_DB_MYSQL_HOST: host,
+        PORTL_DB_MYSQL_PORT: port,
+        PORTL_DB_MYSQL_DATABASE: database,
+        PORTL_DB_MYSQL_USER: user,
+        PORTL_DB_MYSQL_PASSWORD: password,
+      },
+    };
+  } else if (provider.value === 'mongodb') {
+    const connectionString = await askNonEmpty(rl, 'MongoDB connection string', 'mongodb://localhost:27017/mydb');
+
+    return {
+      providerId: 'mongodb',
+      category: 'database',
+      connectable: false,
+      config: { connectionString },
+      envTemplate: {
+        PORTL_DB_MONGODB_CONNECTION_STRING: connectionString,
+      },
+    };
+  } else if (provider.value === 'planetscale') {
+    const host = await askNonEmpty(rl, 'PlanetScale host', 'aws.connect.psdb.cloud');
+    const database = await askNonEmpty(rl, 'Database name');
+    const username = await askNonEmpty(rl, 'Username');
+    const password = await askNonEmpty(rl, 'Password');
+
+    return {
+      providerId: 'planetscale',
+      category: 'database',
+      connectable: false,
+      config: { host, database, username, password },
+      envTemplate: {
+        PORTL_DB_PLANETSCALE_HOST: host,
+        PORTL_DB_PLANETSCALE_DATABASE: database,
+        PORTL_DB_PLANETSCALE_USERNAME: username,
+        PORTL_DB_PLANETSCALE_PASSWORD: password,
+      },
+    };
+  } else {
+    // Generic PostgreSQL
+    const host = await askNonEmpty(rl, 'PostgreSQL host', 'localhost');
+    const port = await askNonEmpty(rl, 'PostgreSQL port', '5432');
+    const database = await askNonEmpty(rl, 'Database name');
+    const user = await askNonEmpty(rl, 'Database user');
+    const password = await askNonEmpty(rl, 'Database password');
+
+    return {
+      providerId: 'postgres.generic',
+      category: 'database',
+      connectable: true,
+      config: { host, port, database, user, password },
+      envTemplate: {
+        PORTL_DB_PG_HOST: host,
+        PORTL_DB_PG_PORT: port,
+        PORTL_DB_PG_DATABASE: database,
+        PORTL_DB_PG_USER: user,
+        PORTL_DB_PG_PASSWORD: password,
+      },
+    };
+  }
+}
+
+/**
+ * Collect storage configuration
+ */
+async function collectStorageConfig(rl) {
+  showSection('STORAGE', '💾');
+  
+  const needsStorage = await askYesNo(rl, 'Do you need file storage?', false);
+  showTip('Portl supports S3, Cloudflare R2, and compatible providers');
+  console.log('');
+  
+  if (!needsStorage) {
+    showInfo('Skipping storage configuration');
+    return null;
+  }
+
+  const provider = await selectOption(rl, 'Choose your storage provider', [
+    { label: 'Cloudflare R2', value: 'r2', description: 'S3-compatible, zero egress fees' },
+    { label: 'Generic S3', value: 's3.generic', description: 'AWS S3 or compatible' },
+  ]);
+
+  console.log('');
+
+  if (provider.value === 'r2') {
+    const accountId = await askNonEmpty(rl, 'Cloudflare account ID');
+    const endpoint = `https://${accountId}.r2.cloudflarestorage.com`;
+    const accessKeyId = await askNonEmpty(rl, 'R2 access key ID');
+    const secretAccessKey = await askNonEmpty(rl, 'R2 secret access key');
+    const bucket = await askNonEmpty(rl, 'Bucket name');
+
+    showTip(`Auto-configured endpoint: ${endpoint}`);
+
+    return {
+      providerId: 'r2',
+      category: 'storage',
+      connectable: true,
+      config: { endpoint, accessKeyId, secretAccessKey, bucket, accountId },
+      envTemplate: {
+        PORTL_STORAGE_R2_ACCOUNT_ID: accountId,
+        PORTL_STORAGE_R2_ENDPOINT: endpoint,
+        PORTL_STORAGE_R2_ACCESS_KEY_ID: accessKeyId,
+        PORTL_STORAGE_R2_SECRET_ACCESS_KEY: secretAccessKey,
+        PORTL_STORAGE_R2_BUCKET: bucket,
+      },
+    };
+  } else {
+    // Generic S3
+    const endpoint = await askNonEmpty(rl, 'S3 endpoint', 'https://s3.amazonaws.com');
+    const accessKeyId = await askNonEmpty(rl, 'Access key ID');
+    const secretAccessKey = await askNonEmpty(rl, 'Secret access key');
+    const bucket = await askNonEmpty(rl, 'Bucket name');
+    const region = await askNonEmpty(rl, 'Region', 'us-east-1');
+
+    return {
+      providerId: 's3.generic',
+      category: 'storage',
+      connectable: true,
+      config: { endpoint, accessKeyId, secretAccessKey, bucket, region },
+      envTemplate: {
+        PORTL_STORAGE_S3_ENDPOINT: endpoint,
+        PORTL_STORAGE_S3_ACCESS_KEY_ID: accessKeyId,
+        PORTL_STORAGE_S3_SECRET_ACCESS_KEY: secretAccessKey,
+        PORTL_STORAGE_S3_BUCKET: bucket,
+        PORTL_STORAGE_S3_REGION: region,
+      },
+    };
+  }
+}
+
+/**
+ * Collect payments configuration
+ */
+async function collectPaymentsConfig(rl) {
+  showSection('PAYMENTS', '💳');
+  
+  const needsPayments = await askYesNo(rl, 'Do you need payments?', false);
+  showTip('Portl supports Stripe and Mercado Pago');
+  console.log('');
+  
+  if (!needsPayments) {
+    showInfo('Skipping payments configuration');
+    return null;
+  }
+
+  const provider = await selectOption(rl, 'Choose your payment provider', [
+    { label: 'Stripe', value: 'stripe' },
+    { label: 'Mercado Pago', value: 'mercadopago' },
+  ]);
+
+  console.log('');
+
+  if (provider.value === 'stripe') {
+    const secretKey = await askNonEmpty(rl, 'Stripe secret key (sk_...)');
+    const publishableKey = await askNonEmpty(rl, 'Stripe publishable key (pk_...)');
+
+    return {
+      providerId: 'stripe',
+      category: 'payments',
+      connectable: false,
+      config: { secretKey, publishableKey },
+      envTemplate: {
+        PORTL_PAYMENTS_STRIPE_SECRET_KEY: secretKey,
+        PORTL_PAYMENTS_STRIPE_PUBLISHABLE_KEY: publishableKey,
+      },
+    };
+  } else {
+    const accessToken = await askNonEmpty(rl, 'Mercado Pago access token');
+    const publicKey = await askNonEmpty(rl, 'Mercado Pago public key');
+
+    return {
+      providerId: 'mercadopago',
+      category: 'payments',
+      connectable: false,
+      config: { accessToken, publicKey },
+      envTemplate: {
+        PORTL_PAYMENTS_MP_ACCESS_TOKEN: accessToken,
+        PORTL_PAYMENTS_MP_PUBLIC_KEY: publicKey,
+      },
+    };
+  }
+}
+
+/**
+ * Collect CI/CD configuration
+ */
+async function collectCicdConfig(rl) {
+  showSection('CI/CD', '🔄');
+  
+  const needsCicd = await askYesNo(rl, 'Do you need CI/CD integration?', false);
+  showTip('Portl supports GitHub Actions');
+  console.log('');
+  
+  if (!needsCicd) {
+    showInfo('Skipping CI/CD configuration');
+    return null;
+  }
+
+  const repository = await askNonEmpty(rl, 'GitHub repository (owner/repo)', 'yourusername/yourrepo');
+
+  return {
+    providerId: 'github.actions',
+    category: 'cicd',
+    connectable: false,
+    config: { repository },
+    envTemplate: {
+      PORTL_CICD_GITHUB_REPOSITORY: repository,
+    },
+  };
+}
+
+/**
+ * Write portl.config.json
+ */
+async function writeConfigFile(cwd, projectId, integrations) {
+  const config = {
+    projectId,
+    integrations: integrations.map(integration => ({
+      providerId: integration.providerId,
+      category: integration.category,
+      config: integration.config,
+    })),
+  };
+
+  const configPath = path.join(cwd, 'portl.config.json');
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+  
+  return configPath;
+}
+
+/**
+ * Write .env.portl template
+ */
+async function writeEnvTemplate(cwd, integrations) {
+  const envLines = ['# Portl Environment Variables', '# Generated by: portl init', ''];
+
+  for (const integration of integrations) {
+    if (integration.envTemplate && Object.keys(integration.envTemplate).length > 0) {
+      envLines.push(`# ${integration.providerId} (${integration.category})`);
+      
+      for (const [key, value] of Object.entries(integration.envTemplate)) {
+        envLines.push(`${key}=${value}`);
+      }
+      
+      envLines.push('');
+    }
+  }
+
+  const envPath = path.join(cwd, '.env.portl');
+  await fs.writeFile(envPath, envLines.join('\n'), 'utf8');
+  
+  return envPath;
+}
+
+/**
+ * Setup MCP configuration for AI agents
+ */
+async function setupMcpConfig(cwd, rl) {
+  showSection('MCP SETUP', '🤖');
+  
+  const setupMcp = await askYesNo(rl, 'Configure MCP for AI agents?', true);
+  showTip('MCP lets Claude/Cursor/Copilot access your infrastructure directly');
+  console.log('');
+  
+  if (!setupMcp) {
+    showInfo('Skipping MCP configuration');
+    return;
+  }
+
+  // Read API key from .env.portl if exists
+  let apiKey = '';
+  let apiBaseUrl = 'http://localhost:7130';
+  try {
+    const envContent = await fs.readFile(path.join(cwd, '.env.portl'), 'utf8');
+    const keyMatch = envContent.match(/ACCESS_API_KEY=(.+)/);
+    if (keyMatch) apiKey = keyMatch[1].trim();
+    const urlMatch = envContent.match(/API_BASE_URL=(.+)/);
+    if (urlMatch) apiBaseUrl = urlMatch[1].trim();
+  } catch {
+    // No .env.portl yet
+  }
+
+  // MCP server config
+  const mcpServerConfig = {
+    command: 'npx',
+    args: ['-y', '@portl/mcp@latest'],
+    env: {
+      API_BASE_URL: apiBaseUrl,
+      ...(apiKey && { API_KEY: apiKey }),
+    },
+  };
+
+  // Detect Claude Desktop config path
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  const claudeConfigPaths = [
+    path.join(homeDir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'), // macOS
+    path.join(homeDir, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json'), // Windows
+    path.join(homeDir, '.config', 'claude', 'claude_desktop_config.json'), // Linux
+  ];
+
+  let claudeConfigPath = null;
+  for (const p of claudeConfigPaths) {
+    try {
+      await fs.access(path.dirname(p));
+      claudeConfigPath = p;
+      break;
+    } catch {
+      // Path doesn't exist
+    }
+  }
+
+  if (claudeConfigPath) {
+    try {
+      // Read existing config or create new
+      let config = { mcpServers: {} };
+      try {
+        const existing = await fs.readFile(claudeConfigPath, 'utf8');
+        config = JSON.parse(existing);
+        if (!config.mcpServers) config.mcpServers = {};
+      } catch {
+        // File doesn't exist, use default
+      }
+
+      // Add Portl MCP server
+      config.mcpServers.portl = mcpServerConfig;
+
+      // Ensure directory exists
+      await fs.mkdir(path.dirname(claudeConfigPath), { recursive: true });
+      await fs.writeFile(claudeConfigPath, JSON.stringify(config, null, 2), 'utf8');
+      
+      showSuccess('Claude Desktop MCP configured');
+      showTip('Restart Claude Desktop to activate');
+    } catch (error) {
+      showWarning(`Could not configure Claude Desktop: ${error.message}`);
+    }
+  } else {
+    showInfo('Claude Desktop not detected');
+  }
+
+  // Create local .mcp.json for other tools (Cursor, etc)
+  const localMcpConfig = {
+    mcpServers: {
+      portl: mcpServerConfig,
+    },
+  };
+
+  await fs.writeFile(
+    path.join(cwd, '.mcp.json'),
+    JSON.stringify(localMcpConfig, null, 2),
+    'utf8'
+  );
+  
+  showSuccess('Local MCP config created (.mcp.json)');
+}
+
+/**
+ * Main init command
+ */
+export async function runInit(rl) {
+  const cwd = process.cwd();
+
+  showBanner();
+
+  // Get project name
+  const projectId = await askNonEmpty(rl, 'Project name', 'my-app');
+  console.log('');
+
+  // Detect API key automatically
+  const apiKey = await detectApiKey(cwd);
+  const apiBaseUrl = 'http://localhost:7130/api'; // Default for now
+  
+  if (apiKey) {
+    showSuccess('API key detected from environment');
+    showTip('OAuth connections will be completed automatically');
+  } else {
+    showInfo('No API key found - generating config files only');
+    showTip('Add ACCESS_API_KEY to your .env to enable OAuth');
+  }
+
+  // Collect integrations
+  const integrations = [];
+
+  // Database
+  const dbConfig = await collectDatabaseConfig(rl, apiKey, apiBaseUrl, projectId);
+  if (dbConfig) integrations.push(dbConfig);
+
+  // Storage
+  const storageConfig = await collectStorageConfig(rl);
+  if (storageConfig) integrations.push(storageConfig);
+
+  // Payments
+  const paymentsConfig = await collectPaymentsConfig(rl);
+  if (paymentsConfig) integrations.push(paymentsConfig);
+
+  // CI/CD
+  const cicdConfig = await collectCicdConfig(rl);
+  if (cicdConfig) integrations.push(cicdConfig);
+
+  // Summary
+  const summaryItems = integrations.map(i => {
+    const status = i.connectable && apiKey ? c('(connected)', ANSI.green) : c('(configured)', ANSI.dim);
+    return `${i.category}: ${c(i.providerId, ANSI.bold)} ${status}`;
+  });
+
+  showSummary('SUMMARY', summaryItems);
+
+  // Write files
+  const spinner = new Spinner('Generating configuration files...');
+  spinner.start();
+
+  try {
+    await writeConfigFile(cwd, projectId, integrations);
+    await writeEnvTemplate(cwd, integrations);
+    spinner.success('Configuration files generated');
+  } catch (error) {
+    spinner.fail('Failed to write configuration files');
+    throw error;
+  }
+
+  // Setup MCP
+  await setupMcpConfig(cwd, rl);
+
+  // Next steps
+  console.log('');
+  console.log(c('Files created:', ANSI.bold));
+  console.log(`  ${c('📄', ANSI.green)} portl.config.json`);
+  console.log(`  ${c('📄', ANSI.green)} .env.portl`);
+  console.log('');
+
+  const nextSteps = [
+    'Restart Claude Desktop / Cursor to load MCP',
+    'Start coding with AI - your infra is ready!',
+  ];
+
+  showNextSteps(nextSteps);
+
+  console.log(c('Done! 🚀', ANSI.green));
+  console.log('');
+}