repoburg 0.1.6 → 0.1.8

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "repoburg",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Binary distribution for repoburg",
   "main": "index.js",
   "bin": {
-    "repoburg": "release/daemon/repoburg-daemon",
+    "repoburg": "platform-cli.js",
+    "repoburg-daemon": "release/daemon/repoburg-daemon",
     "repoburg-backend": "release/backend/repoburg-backend"
   },
   "files": [
     "release/daemon/repoburg-daemon",
     "release/backend/repoburg-backend",
     "index.js",
+    "platform-cli.js",
     "README.md"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
     "publish:patch": "npm version patch && npm publish"
   },
   "repository": {

package/platform-cli.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+require('dotenv').config();
+
+const { Command } = require('commander');
+const axios = require('axios');
+const path = require('path');
+const fs = require('fs/promises');
+const packageJson = require('./package.json');
+
+const DAEMON_BASE_URL = 'http://localhost:9998';
+
+// Uncomment the next line to use localhost for development
+// const FRONTEND_BASE_URL ='http://localhost:3001';
+const FRONTEND_BASE_URL = 'https://app.repoburg.com';
+
+
+const program = new Command();
+
+
+const handleApiError = async (error) => {
+    const { default: chalk } = await import('chalk');
+    if (error.response) {
+        console.error(chalk.red(`Error: ${error.response.status} - ${error.response.statusText}`));
+        if (error.response.data && error.response.data.error) {
+            console.error(chalk.red.bold('Daemon Error:'), chalk.red(error.response.data.message || error.response.data.error));
+        }
+    } else if (error.request) {
+        console.error(chalk.red('Daemon not reachable. Is it running?'));
+        console.error(chalk.yellow(`Attempted to connect to ${DAEMON_BASE_URL}`));
+    } else {
+        console.error(chalk.red('An unexpected error occurred:'), error.message);
+    }
+    process.exit(1);
+};
+
+
+program
+  .name('repoburg-platform')
+  .description('CLI to manage the Repoburg Platform Daemon and services.')
+  .version(packageJson.version);
+
+program
+    .command('list')
+    .alias('ls')
+    .description('List all managed repoburg-backend services.')
+    .action(async () => {
+        const Table = require('cli-table3');
+        const { default: chalk } = await import('chalk');
+        try {
+            const response = await axios.get(`${DAEMON_BASE_URL}/services`);
+            const services = response.data;
+
+            const table = new Table({
+                head: ['NAME', 'STATUS', 'PORT', 'PID', 'PATH'].map(h => chalk.cyan(h)),
+                colWidths: [20, 12, 8, 8, 60]
+            });
+
+            if (services.length === 0) {
+                console.log(chalk.yellow('No services are currently being managed.'));
+                return;
+            }
+
+            services.forEach(service => {
+                const statusColor = service.status === 'running' ? chalk.green : chalk.yellow;
+                table.push([
+                    service.name,
+                    statusColor(service.status),
+                    service.port || '-',
+                    service.pid || '-',
+                    service.path
+                ]);
+            });
+
+            console.log(table.toString());
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
+program
+    .command('start [projectPath]')
+    .description('Start a new repoburg-backend instance for a project.')
+    .action(async (projectPath) => {
+        const { default: chalk } = await import('chalk');
+        const { default: open } = await import('open');
+
+        const pollForAuth = (timeout = 300000) => { // 5 minutes timeout
+            process.stdout.write(chalk.yellow('Waiting for authorization...'));
+            const spinner = setInterval(() => process.stdout.write('.'), 1000);
+
+            return new Promise((resolve, reject) => {
+                const startTime = Date.now();
+                const pollInterval = setInterval(async () => {
+                    if (Date.now() - startTime > timeout) {
+                        clearInterval(pollInterval);
+                        clearInterval(spinner);
+                        process.stdout.write('\n');
+                        return reject(new Error('Login timed out. Please run `repoburg-platform login` and try again.'));
+                    }
+
+                    try {
+                        const statusResponse = await axios.get(`${DAEMON_BASE_URL}/auth/status`);
+                        if (statusResponse.data.status === 'authorized') {
+                            clearInterval(pollInterval);
+                            clearInterval(spinner);
+                            process.stdout.write('\n');
+                            console.log(chalk.green('✓ Authorization successful!'));
+                            resolve();
+                        }
+                    } catch (e) {
+                        // ignore connection errors during polling
+                    }
+                }, 2000);
+            });
+        };
+
+        const pollForServiceHealth = (port, timeout = 30000) => {
+            process.stdout.write(chalk.yellow(`Waiting for backend on port ${port} to be healthy...`));
+            const spinner = setInterval(() => process.stdout.write('.'), 1000);
+
+            return new Promise((resolve, reject) => {
+                const startTime = Date.now();
+                const pollInterval = setInterval(async () => {
+                     if (Date.now() - startTime > timeout) {
+                        clearInterval(pollInterval);
+                        clearInterval(spinner);
+                        process.stdout.write('\n');
+                        return reject(new Error('Backend health check timed out. Check logs with `repoburg-platform logs <name>`.'));
+                    }
+                    try {
+                        await axios.get(`http://localhost:${port}/health`);
+                        clearInterval(pollInterval);
+                        clearInterval(spinner);
+                        process.stdout.write('\n');
+                        console.log(chalk.green(`✓ Backend is healthy.`));
+                        resolve();
+                    } catch (e) {
+                        // ignore until timeout
+                    }
+                }, 1000)
+            });
+        };
+
+        try {
+            // 1. Check auth status
+            let authResponse;
+            try {
+                authResponse = await axios.get(`${DAEMON_BASE_URL}/auth/status`);
+            } catch (error) {
+                 if (error.request && !error.response) {
+                    console.error(chalk.red('Daemon not reachable. Is it running?'));
+                    console.error(chalk.yellow(`Attempted to connect to ${DAEMON_BASE_URL}`));
+                    console.log(chalk.cyan('You can typically start the daemon by running `npm run start:daemon` from the project root, or via the launchd service if installed.'));
+                    process.exit(1);
+                }
+                return handleApiError(error);
+            }
+
+            if (authResponse.data.status !== 'authorized') {
+                console.log(chalk.yellow(`Authentication required. Status: ${authResponse.data.status}.`));
+
+                // 2. Initiate login
+                console.log(chalk.yellow('Opening your browser to log in...'));
+                const initiateResponse = await axios.post(`${DAEMON_BASE_URL}/auth/initiate`);
+                const { loginUrl } = initiateResponse.data;
+
+                if (loginUrl) {
+                    await open(loginUrl);
+                    console.log(chalk.green('✓ Please complete the authentication in your browser.'));
+                    await pollForAuth();
+                } else {
+                    console.error(chalk.red('Could not retrieve login URL from the daemon.'));
+                    process.exit(1);
+                }
+            }
+
+            // 4. Start the service
+            console.log(chalk.cyan('Starting backend service...'));
+            const targetPath = path.resolve(projectPath || '.');
+            const startResponse = await axios.post(`${DAEMON_BASE_URL}/services/start`, { path: targetPath });
+            const service = startResponse.data;
+            console.log(chalk.green(`✓ Repoburg backend for '${service.name}' started on port ${service.port}.`));
+
+            // 5. Wait for service to be healthy
+            await pollForServiceHealth(service.port);
+
+            // 6. Open frontend in browser
+
+            const frontendUrl = `${FRONTEND_BASE_URL}?bport=${service.port}`;
+            console.log(chalk.cyan(`Opening frontend at ${frontendUrl}`));
+            await open(frontendUrl);
+
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
+program
+    .command('stop <name>')
+    .description('Stop a running repoburg-backend instance.')
+    .action(async (name) => {
+        const { default: chalk } = await import('chalk');
+        try {
+            await axios.post(`${DAEMON_BASE_URL}/services/${name}/stop`);
+            console.log(chalk.green(`✓ Service '${name}' stopped successfully.`));
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
+program
+    .command('restart <name>')
+    .description('Restart a repoburg-backend instance.')
+    .action(async (name) => {
+        const { default: chalk } = await import('chalk');
+        try {
+            await axios.post(`${DAEMON_BASE_URL}/services/${name}/restart`);
+            console.log(chalk.green(`✓ Service '${name}' restarted successfully.`));
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
+program
+    .command('remove <name>')
+    .alias('rm')
+    .description('Stop and remove a service from management.')
+    .action(async (name) => {
+        const { default: chalk } = await import('chalk');
+        try {
+            const response = await axios.delete(`${DAEMON_BASE_URL}/services/${name}`);
+            console.log(chalk.green(`✓ ${response.data.message}`));
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
+program
+    .command('logs <name>')
+    .description('Display logs for a specific backend instance.')
+    .action(async (name) => {
+        const { default: chalk } = await import('chalk');
+        try {
+            const response = await axios.get(`${DAEMON_BASE_URL}/services/${name}/logs`);
+            const { out: outLogPath, err: errLogPath } = response.data;
+
+            console.log(chalk.cyan(`--- Logs for ${name} ---`));
+
+            const readAndPrint = async (filePath, logType) => {
+                try {
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    console.log(chalk.bold.yellow(`\n--- ${logType} Log (${filePath}) ---\n`));
+                    console.log(content || chalk.gray('(empty)'));
+                } catch (e) {
+                    if (e.code !== 'ENOENT') {
+                        throw e;
+                    }
+                    console.log(chalk.bold.yellow(`\n--- ${logType} Log (${filePath}) ---\n`));
+                    console.log(chalk.gray('(not found)'));
+                }
+            };
+
+            await readAndPrint(outLogPath, 'Output');
+            await readAndPrint(errLogPath, 'Error');
+
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
+program
+    .command('login')
+    .description('Initiate the web-based authentication flow.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        const { default: open } = await import('open');
+        try {
+            console.log(chalk.yellow('Opening your browser to log in...'));
+            const response = await axios.post(`${DAEMON_BASE_URL}/auth/initiate`);
+            const { loginUrl } = response.data;
+
+            if (loginUrl) {
+                await open(loginUrl);
+                console.log(chalk.green('✓ Please complete the authentication in your browser.'));
+            } else {
+                console.error(chalk.red('Could not retrieve login URL from the daemon.'));
+            }
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
+program
+    .command('logout')
+    .description('Remove local authentication credentials.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        try {
+            await axios.post(`${DAEMON_BASE_URL}/auth/logout`);
+            console.log(chalk.green('✓ Credentials removed. You have been logged out.'));
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
+
+program.parse(process.argv);