repoburg 1.0.50 → 1.0.51

package/daemon/dist/api/system.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const child_process_1 = require("child_process");
+const checkAuth_1 = require("../middleware/checkAuth");
+const router = (0, express_1.Router)();
+router.post('/update', checkAuth_1.checkAuth, (req, res) => {
+    try {
+        console.log('[DAEMON] Received request to start update process.');
+        // Using `spawn` with `detached: true` and `stdio: 'ignore'` allows the parent (daemon)
+        // to exit while the child (update script) continues running. `unref()` is crucial.
+        const child = (0, child_process_1.spawn)('repoburg', ['update'], {
+            detached: true,
+            stdio: 'ignore',
+            shell: true,
+        });
+        child.unref();
+        res.status(202).json({ message: 'Update process initiated. The daemon and services will restart shortly.' });
+    }
+    catch (error) {
+        console.error('Failed to spawn update process:', error);
+        res.status(500).json({ error: 'Failed to start update process.' });
+    }
+});
+exports.default = router;

package/daemon/dist/index.js

@@ -12,6 +12,7 @@ const serviceManager_1 = require("./serviceManager");
 const services_1 = __importDefault(require("./api/services"));
 const auth_1 = __importDefault(require("./api/auth"));
 const registry_1 = __importDefault(require("./api/registry"));
+const system_1 = __importDefault(require("./api/system"));
 const PORT = 9998;
 async function main() {
     await serviceManager_1.serviceManager.connect();
@@ -28,6 +29,7 @@ async function main() {
     app.use('/services', services_1.default);
     app.use('/auth', (0, auth_1.default)(wss));
     app.use('/registry', registry_1.default);
+    app.use('/system', system_1.default);
     app.get('/health', (req, res) => {
         res.status(200).json({ status: 'ok' });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repoburg",
-  "version": "1.0.50",
+  "version": "1.0.51",
   "description": "A local AI-powered software developer assistant that runs on your own machine.",
   "author": "Celal Ertug",
   "license": "SEE LICENSE IN LICENSE",
@@ -16,8 +16,7 @@
   ],
   "bin": {
     "repoburg": "./platform-cli.js",
-    "repoburg-daemon": "daemon/dist/index.js",
-    "repoburg-backend": "backend/dist/main.js"
+    "repoburg-daemon": "daemon/dist/index.js"
   },
   "scripts": {
     "postinstall": "node postinstall.js",
@@ -59,6 +58,7 @@
     "libphonenumber-js": "^1.12.10",
     "mermaid": "^11.10.1",
     "open": "^10.1.0",
+    "ora": "^8.0.1",
     "pm2": "^6.0.8",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.1",

package/platform-cli.js

@@ -5,8 +5,11 @@ const axios = require('axios');
 const path = require('path');
 const fs = require('fs/promises');
 const packageJson = require('./package.json');
+const pm2 = require('pm2');
+const { spawn } = require('child_process');
 
 const DAEMON_BASE_URL = 'http://localhost:9998';
+const DAEMON_PM2_NAME = 'repoburg-daemon';
 
 // Uncomment the next line to use localhost for development
 // const FRONTEND_BASE_URL ='http://localhost:3001';
@@ -32,6 +35,37 @@ const handleApiError = async (error) => {
     process.exit(1);
 };
 
+const connectToPm2 = () => new Promise((resolve, reject) => {
+    pm2.connect(err => {
+        if (err) return reject(new Error(`Could not connect to pm2: ${err.message}`));
+        resolve();
+    });
+});
+
+const startDaemon = async () => {
+    const { default: ora } = await import('ora');
+    const spinner = ora('Starting daemon process...').start();
+    try {
+        await connectToPm2();
+        await new Promise((resolve, reject) => {
+            pm2.start({
+                name: DAEMON_PM2_NAME,
+                script: 'repoburg-daemon',
+            }, (err) => {
+                pm2.disconnect();
+                if (err) {
+                    const errMsg = err.message || err.msg;
+                    return reject(new Error(`Error starting daemon with pm2: ${errMsg || err}`));
+                }
+                resolve();
+            });
+        });
+        spinner.succeed('Daemon process started via pm2.');
+    } catch (error) {
+        spinner.fail('Failed to start daemon.');
+        throw error;
+    }
+};
 
 program
   .name('repoburg')
@@ -83,6 +117,7 @@ program
     .action(async (projectPath) => {
         const { default: chalk } = await import('chalk');
         const { default: open } = await import('open');
+        const { default: ora } = await import('ora');
 
         const pollForAuth = (timeout = 300000) => { // 5 minutes timeout
             process.stdout.write(chalk.yellow('Waiting for authorization...'));
@@ -115,24 +150,19 @@ program
         };
 
         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);
-
+            const spinner = ora(`Waiting for backend on port ${port} to be healthy...`).start();
             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');
+                        spinner.fail('Backend health check timed out.');
                         return reject(new Error('Backend health check timed out. Check logs with `repoburg 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.`));
+                        spinner.succeed(`Backend is healthy.`);
                         resolve();
                     } catch (e) {
                         // ignore until timeout
@@ -142,18 +172,49 @@ program
         };
 
         try {
-            // 1. Check auth status
+            // 1. Check daemon status and start if not running
             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);
+                    console.log(chalk.yellow('Daemon not reachable. Attempting to start it now...'));
+                    
+                    await startDaemon();
+                    
+                    const pollForDaemonHealth = (timeout = 30000) => {
+                        const spinner = ora('Waiting for daemon to become healthy...').start();
+                        return new Promise((resolve, reject) => {
+                            const startTime = Date.now();
+                            const pollInterval = setInterval(async () => {
+                                 if (Date.now() - startTime > timeout) {
+                                    clearInterval(pollInterval);
+                                    spinner.fail('Daemon health check timed out.');
+                                    return reject(new Error('Daemon health check timed out. Check logs with `repoburg daemon logs`.'));
+                                }
+                                try {
+                                    await axios.get(`${DAEMON_BASE_URL}/health`);
+                                    clearInterval(pollInterval);
+                                    spinner.succeed('Daemon is healthy.');
+                                    resolve();
+                                } catch (e) {
+                                    // ignore until timeout
+                                }
+                            }, 1000)
+                        });
+                    };
+
+                    await pollForDaemonHealth();
+
+                    try {
+                        authResponse = await axios.get(`${DAEMON_BASE_URL}/auth/status`);
+                    } catch (retryError) {
+                        console.error(chalk.red('Daemon started but is not responding correctly.'));
+                        return handleApiError(retryError);
+                    }
+                } else {
+                    return handleApiError(error);
                 }
-                return handleApiError(error);
             }
 
             if (authResponse.data.status !== 'authorized') {
@@ -338,5 +399,344 @@ program
         }
     });
 
+program
+    .command('update')
+    .description('Update the Repoburg platform to the latest version.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        const { default: ora } = await import('ora');
+        
+        const runCommand = (command, args) => {
+            return new Promise((resolve, reject) => {
+                const spinner = ora(`Running \`${command} ${args.join(' ')}\`...`).start();
+                const child = spawn(command, args, { stdio: 'pipe', shell: true });
+                let output = '';
+
+                child.stdout.on('data', (data) => {
+                    output += data.toString();
+                });
+                child.stderr.on('data', (data) => {
+                    output += data.toString();
+                });
+
+                child.on('close', (code) => {
+                    if (code === 0) {
+                        spinner.succeed(`Command \`${command} ${args.join(' ')}\` finished.`);
+                        resolve();
+                    } else {
+                        spinner.fail(`Command \`${command} ${args.join(' ')}\` failed with code ${code}.`);
+                        console.error(chalk.gray(output));
+                        reject(new Error(`Command failed`));
+                    }
+                });
+                child.on('error', (err) => {
+                    spinner.fail(`Failed to execute command.`);
+                    reject(err);
+                });
+            });
+        };
+
+        const pollForDaemonHealth = (timeout = 30000) => {
+            const spinner = ora('Waiting for daemon to become healthy...').start();
+            return new Promise((resolve, reject) => {
+                const startTime = Date.now();
+                const pollInterval = setInterval(async () => {
+                     if (Date.now() - startTime > timeout) {
+                        clearInterval(pollInterval);
+                        spinner.fail('Daemon health check timed out.');
+                        return reject(new Error('Daemon health check timed out.'));
+                    }
+                    try {
+                        await axios.get(`${DAEMON_BASE_URL}/health`);
+                        clearInterval(pollInterval);
+                        spinner.succeed('Daemon is healthy.');
+                        resolve();
+                    } catch (e) {
+                        // ignore until timeout
+                    }
+                }, 1000)
+            });
+        };
+
+        let runningServices = [];
+
+        try {
+            // 1. Get list of running services
+            const listSpinner = ora('Fetching list of running services...').start();
+            try {
+                const response = await axios.get(`${DAEMON_BASE_URL}/services`);
+                runningServices = response.data.filter(s => s.status === 'running').map(s => s.name);
+                listSpinner.succeed(`Found ${runningServices.length} running services to restart later.`);
+            } catch (error) {
+                if (error.request && !error.response) { // Daemon not running
+                    listSpinner.warn('Daemon not reachable, assuming no services are running.');
+                } else {
+                    listSpinner.fail('Failed to fetch services.');
+                    throw error;
+                }
+            }
+
+            // 2. Stop all running services
+            if (runningServices.length > 0) {
+                const stopSpinner = ora('Stopping running backend services...').start();
+                for (const name of runningServices) {
+                    stopSpinner.text = `Stopping ${name}...`;
+                    await axios.post(`${DAEMON_BASE_URL}/services/${name}/stop`);
+                }
+                stopSpinner.succeed('All backend services stopped.');
+            }
+
+            // 3. Stop the daemon
+            const stopDaemonSpinner = ora('Stopping daemon...').start();
+            await new Promise((resolve, reject) => {
+                pm2.connect(err => {
+                    if (err) return reject(err);
+                    pm2.stop(DAEMON_PM2_NAME, (err) => {
+                        pm2.disconnect();
+                        const errMsg = err ? (err.message || err.msg) : null;
+                        if (err && !(errMsg && errMsg.includes('not found'))) {
+                           return reject(err);
+                        }
+                        resolve();
+                    });
+                });
+            });
+            stopDaemonSpinner.succeed('Daemon stopped.');
+
+            // 4. Run update
+            await runCommand('npm', ['i', '-g', 'repoburg@latest']);
+
+            // 5. Start the daemon
+            const startDaemonSpinner = ora('Starting daemon...').start();
+            await new Promise((resolve, reject) => {
+                pm2.connect(err => {
+                    if (err) return reject(err);
+                    pm2.start({ name: DAEMON_PM2_NAME, script: 'repoburg-daemon' }, (err) => {
+                        pm2.disconnect();
+                        if (err) return reject(err);
+                        resolve();
+                    });
+                });
+            });
+            startDaemonSpinner.succeed('Daemon process started.');
+            await pollForDaemonHealth();
+
+            // 6. Restart services
+            if (runningServices.length > 0) {
+                const restartSpinner = ora('Restarting backend services...').start();
+                for (const name of runningServices) {
+                    restartSpinner.text = `Restarting ${name}...`;
+                    await axios.post(`${DAEMON_BASE_URL}/services/${name}/restart`);
+                }
+                restartSpinner.succeed('All backend services restarted.');
+            }
+
+            console.log(chalk.green.bold('\n✓ Repoburg update complete!'));
+
+        } catch (error) {
+            console.error(chalk.red('\nUpdate process failed:'), error.message);
+            console.error(chalk.yellow('Your services might be in a stopped state. Please check with `repoburg list` and `repoburg daemon status`.'));
+            process.exit(1);
+        }
+    });
+
+// --- Daemon Management ---
+const daemon = program.command('daemon')
+  .description('Manage the Repoburg Platform Daemon process (the service running on port 9998).');
+
+daemon
+    .command('start')
+    .description('Start the daemon process in the background using pm2.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        try {
+            await startDaemon();
+            console.log(chalk.cyan(`Run 'repoburg daemon status' to check its state.`));
+        } catch (error) {
+            console.error(chalk.red('An error occurred:'), error.message);
+            process.exit(1);
+        }
+    });
+
+daemon
+    .command('status')
+    .description('Show the status of the daemon process.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        const Table = require('cli-table3');
+        try {
+            await connectToPm2();
+            pm2.list((err, list) => {
+                if (err) {
+                    console.error(chalk.red('Error listing pm2 processes:'), err.message || err);
+                    pm2.disconnect();
+                    process.exit(1);
+                }
+                
+                const daemonProcess = list.find(p => p.name === DAEMON_PM2_NAME);
+                if (!daemonProcess) {
+                    console.log(chalk.yellow(`Daemon process "${DAEMON_PM2_NAME}" is not running or not managed by pm2.`));
+                } else {
+                    const table = new Table({
+                        head: ['NAME', 'STATUS', 'PID', 'CPU', 'MEMORY'].map(h => chalk.cyan(h)),
+                        colWidths: [20, 12, 8, 8, 15]
+                    });
+                    const status = daemonProcess.pm2_env.status;
+                    const statusColor = status === 'online' ? chalk.green : chalk.yellow;
+                    table.push([
+                        daemonProcess.name,
+                        statusColor(status),
+                        daemonProcess.pid,
+                        `${daemonProcess.monit.cpu || 0}%`,
+                        `${(daemonProcess.monit.memory / 1024 / 1024).toFixed(1)} MB`
+                    ]);
+                    console.log(table.toString());
+                }
+                pm2.disconnect();
+            });
+        } catch (error) {
+            console.error(chalk.red('An error occurred:'), error.message);
+            process.exit(1);
+        }
+    });
+
+daemon
+    .command('stop')
+    .description('Stop the daemon process.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        try {
+            await connectToPm2();
+            console.log(chalk.cyan(`Stopping daemon process "${DAEMON_PM2_NAME}"...`));
+            pm2.stop(DAEMON_PM2_NAME, (err) => {
+                const errMsg = err ? (err.message || err.msg) : null;
+                if (err) {
+                    if (errMsg && errMsg.includes('not found')) {
+                        console.log(chalk.yellow(`Daemon process "${DAEMON_PM2_NAME}" not found or not running.`));
+                    } else {
+                        console.error(chalk.red('Error stopping daemon:'), errMsg || err);
+                        pm2.disconnect();
+                        process.exit(1);
+                    }
+                } else {
+                    console.log(chalk.green('✓ Daemon stopped.'));
+                }
+                pm2.disconnect();
+            });
+        } catch (error) {
+            console.error(chalk.red('An error occurred:'), error.message);
+            process.exit(1);
+        }
+    });
+
+daemon
+    .command('restart')
+    .description('Restart the daemon process.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        try {
+            await connectToPm2();
+            console.log(chalk.cyan(`Restarting daemon process "${DAEMON_PM2_NAME}"...`));
+            pm2.restart(DAEMON_PM2_NAME, (err) => {
+                const errMsg = err ? (err.message || err.msg) : null;
+                if (err) {
+                    if (errMsg && errMsg.includes('not found')) {
+                        console.log(chalk.yellow(`Daemon process "${DAEMON_PM2_NAME}" not found. Use 'repoburg daemon start' instead.`));
+                    } else {
+                        console.error(chalk.red('Error restarting daemon:'), errMsg || err);
+                        pm2.disconnect();
+                        process.exit(1);
+                    }
+                } else {
+                    console.log(chalk.green('✓ Daemon restarted.'));
+                }
+                pm2.disconnect();
+            });
+        } catch (error) {
+            console.error(chalk.red('An error occurred:'), error.message);
+            process.exit(1);
+        }
+    });
+    
+daemon
+    .command('delete')
+    .alias('rm')
+    .description('Stop and delete the daemon process from pm2.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        try {
+            await connectToPm2();
+            console.log(chalk.cyan(`Deleting daemon process "${DAEMON_PM2_NAME}" from pm2...`));
+            pm2.delete(DAEMON_PM2_NAME, (err) => {
+                const errMsg = err ? (err.message || err.msg) : null;
+                if (err) {
+                    if (errMsg && errMsg.includes('not found')) {
+                        console.log(chalk.yellow(`Daemon process "${DAEMON_PM2_NAME}" not found.`));
+                    } else {
+                        console.error(chalk.red('Error deleting daemon:'), errMsg || err);
+                        pm2.disconnect();
+                        process.exit(1);
+                    }
+                } else {
+                    console.log(chalk.green('✓ Daemon process deleted from pm2.'));
+                }
+                pm2.disconnect();
+            });
+        } catch (error) {
+            console.error(chalk.red('An error occurred:'), error.message);
+            process.exit(1);
+        }
+    });
+
+daemon
+    .command('logs')
+    .description('Display logs for the daemon process.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        try {
+            await connectToPm2();
+            pm2.describe(DAEMON_PM2_NAME, async (err, description) => {
+                if (err) {
+                    console.error(chalk.red('Error describing daemon process:'), err.message || err);
+                    pm2.disconnect();
+                    process.exit(1);
+                }
+
+                if (!description || description.length === 0) {
+                    console.log(chalk.yellow(`Daemon process "${DAEMON_PM2_NAME}" not found.`));
+                    pm2.disconnect();
+                    return;
+                }
+
+                const proc = description[0];
+                const outLogPath = proc.pm2_env.pm_out_log_path;
+                const errLogPath = proc.pm2_env.pm_err_log_path;
+
+                console.log(chalk.cyan(`--- Logs for ${DAEMON_PM2_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');
+                
+                pm2.disconnect();
+            });
+        } catch (error) {
+            console.error(chalk.red('An error occurred:'), error.message);
+            process.exit(1);
+        }
+    });
 
 program.parse(process.argv);