deepdebug-local-agent 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "DeepDebug Local Agent - AI-powered code debugging assistant",
   "private": false,
   "type": "module",

package/src/server.js

@@ -850,18 +850,45 @@ app.post("/workspace/open", async (req, res) => {
     res.json({ ok: true, root: abs, workspaceId: wsId, mode: "local", meta, port });
 });
 
+
+
 /**
  * POST /workspace/clone
  * Clones a git repository into the local filesystem, then opens it as workspace.
  * Body: { gitUrl, targetPath, workspaceId? }
  */
 app.post("/workspace/clone", async (req, res) => {
-    const { gitUrl, targetPath, workspaceId } = req.body || {};
-
-    if (!gitUrl)     return res.status(400).json({ ok: false, error: "gitUrl is required" });
-    if (!targetPath) return res.status(400).json({ ok: false, error: "targetPath is required" });
+    const body = req.body || {};
+    // Accept both naming conventions:
+    // - gitUrl + targetPath (local agent format)
+    // - repoUrl + targetDir (cloud format)
+    const gitUrl     = body.gitUrl     || body.repoUrl;
+    const targetPath = body.targetPath || body.targetDir;
+    const workspaceId = body.workspaceId;
+    const gitToken   = body.gitToken;
+    const branch     = body.branch;
+
+    if (!gitUrl) return res.status(400).json({ ok: false, error: "gitUrl is required" });
+
+    // If targetPath not provided, derive from repo name
+    const repoName   = gitUrl.split('/').pop().replace('.git', '');
+    const resolvedTarget = targetPath
+        ? path.resolve(targetPath)
+        : path.join(process.env.HOME || '/home/deepdebug', 'DeepDebug', repoName);
+
+    // If gitToken provided and not already embedded in URL, embed it
+    let authenticatedUrl = gitUrl;
+    if (gitToken && gitUrl.startsWith('https://') && !gitUrl.includes('@')) {
+        if (gitUrl.includes('bitbucket.org')) {
+            authenticatedUrl = gitUrl.replace('https://', `https://x-token-auth:${gitToken}@`);
+        } else if (gitUrl.includes('gitlab.com')) {
+            authenticatedUrl = gitUrl.replace('https://', `https://oauth2:${gitToken}@`);
+        } else {
+            authenticatedUrl = gitUrl.replace('https://', `https://x-access-token:${gitToken}@`);
+        }
+    }
 
-    const absTarget = path.resolve(targetPath);
+    const absTarget = resolvedTarget;
     console.log(` Clone request: ${gitUrl} -> ${absTarget}`);
 
     try {
@@ -878,8 +905,9 @@ app.post("/workspace/clone", async (req, res) => {
             const { stdout } = await execAsync('git pull', { cwd: absTarget, timeout: 120000 });
             console.log(` git pull: ${stdout.trim()}`);
         } else {
-            console.log(` Running: git clone "${gitUrl}" "${absTarget}"`);
-            await execAsync(`git clone "${gitUrl}" "${absTarget}"`, { timeout: 300000 });
+            const safeLog = authenticatedUrl.replace(/x-token-auth:[^@]+@/g, 'x-token-auth:***@').replace(/oauth2:[^@]+@/g, 'oauth2:***@').replace(/x-access-token:[^@]+@/g, 'x-access-token:***@');
+            console.log(` Running: git clone "${safeLog}" "${absTarget}"`);
+            await execAsync(`git clone "${authenticatedUrl}" "${absTarget}"`, { timeout: 300000 });
             console.log(` Clone complete: ${absTarget}`);
         }
 
@@ -5539,8 +5567,166 @@ async function startWebSocketTunnel(port, gatewayUrl, apiKey, tenantId) {
     connect();
 }
 
+// ============================================
+// 🤖 SETUP AGENT ROUTES
+// Supports the AI Assistant chat commands
+// ============================================
+
+/**
+ * POST /setup/run-command
+ * Run any shell command on the user's machine.
+ */
+app.post("/setup/run-command", async (req, res) => {
+    const { command, description, workingDir } = req.body || {};
+    if (!command) return res.status(400).json({ ok: false, error: "command is required" });
+
+    const dangerous = ['rm -rf /', 'mkfs', 'dd if=', 'shutdown', 'reboot', 'format c:', 'del /f /s /q'];
+    if (dangerous.some(d => command.toLowerCase().includes(d))) {
+        return res.status(403).json({ ok: false, error: "Command blocked for safety" });
+    }
+
+    console.log(`🤖 [SetupAgent] Running: ${command.substring(0, 100)}`);
+    const { exec: execCb } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(execCb);
+
+    try {
+        const cwd = workingDir || WORKSPACE_ROOT || process.env.HOME || process.cwd();
+        const result = await execAsync(command, {
+            cwd, timeout: 60000, maxBuffer: 2 * 1024 * 1024,
+            env: { ...process.env, FORCE_COLOR: '0' }, shell: true
+        });
+        res.json({ ok: true, stdout: result.stdout, stderr: result.stderr, exitCode: 0, command });
+    } catch (err) {
+        res.json({ ok: false, stdout: err.stdout || '', stderr: err.stderr || err.message, exitCode: err.code || 1, command });
+    }
+});
+
+/**
+ * POST /setup/check-ports
+ * Check which ports are open/in-use on this machine.
+ */
+app.post("/setup/check-ports", async (req, res) => {
+    const { exec: execCb } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(execCb);
+
+    const cmd = process.platform === 'win32'
+        ? 'netstat -ano | findstr LISTENING'
+        : 'lsof -i -P -n 2>/dev/null | grep LISTEN | head -40 || netstat -tlnp 2>/dev/null | head -40 || ss -tlnp 2>/dev/null | head -40';
+
+    try {
+        const result = await execAsync(cmd, { timeout: 10000, shell: true });
+        res.json({ ok: true, output: result.stdout, ports_raw: result.stdout });
+    } catch (err) {
+        res.json({ ok: false, stdout: err.stdout || '', error: err.message });
+    }
+});
+
+/**
+ * GET /setup/check-tool?name=<tool>
+ * Check if a CLI tool is installed on this machine.
+ */
+app.get("/setup/check-tool", async (req, res) => {
+    const { name } = req.query;
+    if (!name) return res.status(400).json({ error: "name is required" });
+
+    const { exec: execCb } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(execCb);
+
+    const cmd = process.platform === 'win32'
+        ? `where ${name} 2>nul && ${name} --version 2>nul`
+        : `which ${name} 2>/dev/null && ${name} --version 2>&1 | head -1`;
+
+    try {
+        const result = await execAsync(cmd, { timeout: 8000, shell: true });
+        res.json({ installed: true, tool: name, version: result.stdout.trim() });
+    } catch (err) {
+        res.json({ installed: false, tool: name, output: err.stdout || err.message });
+    }
+});
+
+/**
+ * POST /setup/install-tool
+ * Auto-install a CLI tool using the available package manager.
+ */
+app.post("/setup/install-tool", async (req, res) => {
+    const { tool } = req.body || {};
+    if (!tool) return res.status(400).json({ error: "tool is required" });
+
+    const { exec: execCb } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(execCb);
+
+    const brewNames = { 'azure-cli': 'azure-cli', 'github-cli': 'gh', 'aws-cli': 'awscli', 'gcloud': 'google-cloud-sdk' };
+    const brewName = brewNames[tool] || tool;
+    const cmd = process.platform === 'win32'
+        ? `choco install ${tool} -y 2>&1`
+        : `brew install ${brewName} 2>&1 || sudo apt-get install -y ${tool} 2>&1`;
+
+    try {
+        const result = await execAsync(cmd, { timeout: 120000, shell: true });
+        res.json({ ok: true, stdout: result.stdout, tool });
+    } catch (err) {
+        res.json({ ok: false, stdout: err.stdout || '', error: err.message, tool });
+    }
+});
+
+/**
+ * POST /setup/run-auth-command
+ * Run an auth command (gcloud, az login, gh auth) opening browser on user's machine.
+ */
+app.post("/setup/run-auth-command", async (req, res) => {
+    const { command, session_id } = req.body || {};
+    if (!command) return res.status(400).json({ error: "command is required" });
+
+    const { exec: execCb } = await import('child_process');
+    const bgCmd = process.platform === 'win32' ? `start cmd /c "${command}"` : `${command} &`;
+    console.log(`🔐 [SetupAgent] Starting auth: ${command.substring(0, 80)}`);
+
+    execCb(bgCmd, { shell: true }, (err) => {
+        if (err) console.warn(`⚠️ Auth command warning: ${err.message}`);
+    });
+
+    res.json({ ok: true, status: "started", session_id, message: "Auth command started, browser should open" });
+});
+
+/**
+ * GET /setup/auth-status?provider=<provider>
+ * Check if authentication completed for a provider.
+ */
+app.get("/setup/auth-status", async (req, res) => {
+    const { provider } = req.query;
+    const { exec: execCb } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(execCb);
+
+    const checkCmds = {
+        gcp: "gcloud auth list --format='value(account)' 2>&1 | head -1",
+        azure: "az account show --query name -o tsv 2>&1",
+        aws_sso: "aws sts get-caller-identity --query Account -o text 2>&1",
+        github: "gh auth status 2>&1",
+        gitlab: "glab auth status 2>&1"
+    };
+
+    const cmd = checkCmds[provider] || 'echo unknown_provider';
+    try {
+        const result = await execAsync(cmd, { timeout: 10000, shell: true });
+        const output = result.stdout.trim();
+        const success = output && !output.toLowerCase().includes('error') &&
+            !output.toLowerCase().includes('not logged') &&
+            !output.toLowerCase().includes('no account') &&
+            output !== 'unknown_provider';
+        res.json({ status: success ? 'success' : 'pending', provider, output });
+    } catch (err) {
+        res.json({ status: 'pending', provider, output: err.stdout || err.message });
+    }
+});
+
 // ============================================
 // START SERVER
+
 // ============================================
 app.listen(PORT, '0.0.0.0', async () => {
     console.log(`\n DeepDebug Local Agent listening on port ${PORT}`);

package/src/setup-agent-routes.js

@@ -0,0 +1,368 @@
+/**
+ * setup-agent-routes.js
+ *
+ * Local Agent routes for the Setup Agent.
+ * These endpoints are called by SetupAgentToolExecutor (Java backend)
+ * and execute on the user's local machine.
+ *
+ * Routes:
+ *   POST /setup/run-auth-command   — Run OAuth CLI command (opens browser)
+ *   GET  /setup/auth-status        — Poll for OAuth completion
+ *   POST /setup/run-command        — Run a general setup command
+ *   POST /setup/install-tool       — Install a CLI tool (OS-aware)
+ *   GET  /setup/check-tool         — Check if a tool is installed
+ *
+ * Mount in server.js with:
+ *   import { setupAgentRouter } from './setup-agent-routes.js';
+ *   app.use(setupAgentRouter);
+ */
+
+import express from 'express';
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
+
+const execAsync = promisify(exec);
+const router = express.Router();
+
+// Tracks running OAuth sessions: sessionId -> { provider, process, status, startedAt }
+const oauthSessions = new Map();
+
+// ============================================
+// POST /setup/run-auth-command
+// Run an OAuth CLI command asynchronously (opens browser)
+// ============================================
+
+router.post('/setup/run-auth-command', async (req, res) => {
+    const { command, description, session_id, async: isAsync } = req.body;
+
+    if (!command) {
+        return res.status(400).json({ error: 'command is required' });
+    }
+
+    console.log(`[SetupAgent] Running auth command: ${command}`);
+
+    try {
+        // Split command into parts
+        const parts = command.trim().split(/\s+/);
+        const cmd = parts[0];
+        const args = parts.slice(1);
+
+        const child = spawn(cmd, args, {
+            shell: true,
+            detached: false,
+            stdio: ['inherit', 'pipe', 'pipe'], // inherit stdin so browser auth works
+        });
+
+        const session = {
+            provider: detectProviderFromCommand(command),
+            process: child,
+            status: 'pending',
+            output: [],
+            error: [],
+            startedAt: Date.now(),
+            command,
+        };
+
+        if (session_id) {
+            oauthSessions.set(session_id, session);
+        }
+
+        child.stdout.on('data', (data) => {
+            const text = data.toString();
+            session.output.push(text);
+            console.log(`[SetupAgent][auth-stdout] ${text.trim()}`);
+        });
+
+        child.stderr.on('data', (data) => {
+            const text = data.toString();
+            session.error.push(text);
+            console.log(`[SetupAgent][auth-stderr] ${text.trim()}`);
+        });
+
+        child.on('close', (code) => {
+            session.status = code === 0 ? 'success' : 'failed';
+            session.exitCode = code;
+            console.log(`[SetupAgent] Auth command finished: code=${code} session=${session_id}`);
+        });
+
+        child.on('error', (err) => {
+            session.status = 'failed';
+            session.lastError = err.message;
+            console.error(`[SetupAgent] Auth command error: ${err.message}`);
+        });
+
+        // If async, respond immediately — client polls for status
+        if (isAsync) {
+            return res.json({
+                status: 'started',
+                session_id,
+                message: `${description || command} started — browser should open shortly`,
+                pid: child.pid,
+            });
+        }
+
+        // Otherwise wait for completion (not recommended for auth flows)
+        child.on('close', (code) => {
+            res.json({
+                status: code === 0 ? 'success' : 'failed',
+                exit_code: code,
+                output: session.output.join(''),
+                error: session.error.join(''),
+            });
+        });
+
+    } catch (err) {
+        console.error(`[SetupAgent] Failed to start auth command: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// ============================================
+// GET /setup/auth-status
+// Poll for OAuth completion
+// ============================================
+
+router.get('/setup/auth-status', (req, res) => {
+    const { provider, session_id } = req.query;
+
+    if (!session_id || !oauthSessions.has(session_id)) {
+        return res.json({ status: 'unknown', message: 'Session not found' });
+    }
+
+    const session = oauthSessions.get(session_id);
+    const elapsed = Math.round((Date.now() - session.startedAt) / 1000);
+
+    res.json({
+        status: session.status,        // pending | success | failed
+        provider: session.provider || provider,
+        session_id,
+        elapsed_seconds: elapsed,
+        output_preview: session.output.slice(-3).join('').trim().substring(0, 200),
+        message: session.status === 'success'
+            ? 'Authentication completed successfully'
+            : session.status === 'failed'
+                ? `Authentication failed: ${session.lastError || 'unknown error'}`
+                : `Waiting for browser authentication... (${elapsed}s)`,
+    });
+});
+
+// ============================================
+// POST /setup/run-command
+// Run a general setup command and wait for result
+// ============================================
+
+router.post('/setup/run-command', async (req, res) => {
+    const { command, description, working_directory } = req.body;
+
+    if (!command) {
+        return res.status(400).json({ error: 'command is required' });
+    }
+
+    console.log(`[SetupAgent] Running command: ${command}`);
+
+    try {
+        const options = {
+            cwd: working_directory || process.cwd(),
+            timeout: 60000, // 60s timeout
+        };
+
+        const { stdout, stderr } = await execAsync(command, options);
+
+        res.json({
+            status: 'success',
+            stdout: stdout.trim(),
+            stderr: stderr.trim(),
+            exit_code: 0,
+            command,
+            description,
+        });
+
+    } catch (err) {
+        console.error(`[SetupAgent] Command failed: ${command} — ${err.message}`);
+        res.json({
+            status: 'failed',
+            stdout: err.stdout ? err.stdout.trim() : '',
+            stderr: err.stderr ? err.stderr.trim() : err.message,
+            exit_code: err.code || 1,
+            command,
+        });
+    }
+});
+
+// ============================================
+// POST /setup/install-tool
+// Install a CLI tool using the appropriate package manager
+// ============================================
+
+router.post('/setup/install-tool', async (req, res) => {
+    const { tool } = req.body;
+
+    if (!tool) {
+        return res.status(400).json({ error: 'tool is required' });
+    }
+
+    const platform = os.platform(); // 'darwin', 'linux', 'win32'
+    const installCommand = getInstallCommand(tool, platform);
+
+    if (!installCommand) {
+        return res.json({
+            status: 'manual_required',
+            tool,
+            platform,
+            message: `Cannot auto-install ${tool} on ${platform}. Please install it manually.`,
+            install_url: getInstallUrl(tool),
+        });
+    }
+
+    console.log(`[SetupAgent] Installing ${tool} on ${platform}: ${installCommand}`);
+
+    try {
+        // For brew/apt installs that may take time, stream output
+        const { stdout, stderr } = await execAsync(installCommand, { timeout: 300000 }); // 5 min
+
+        res.json({
+            status: 'installed',
+            tool,
+            platform,
+            command_used: installCommand,
+            output: stdout.trim(),
+        });
+
+    } catch (err) {
+        res.json({
+            status: 'failed',
+            tool,
+            platform,
+            error: err.stderr || err.message,
+            install_url: getInstallUrl(tool),
+            message: `Auto-install failed. Please install ${tool} manually.`,
+        });
+    }
+});
+
+// ============================================
+// GET /setup/check-tool
+// Check if a CLI tool is installed
+// ============================================
+
+router.get('/setup/check-tool', async (req, res) => {
+    const { name } = req.query;
+
+    if (!name) {
+        return res.status(400).json({ error: 'name is required' });
+    }
+
+    const checkCommand = getVersionCommand(name);
+
+    try {
+        const { stdout } = await execAsync(checkCommand, { timeout: 5000 });
+        const version = stdout.trim().split('\n')[0]; // first line usually has version
+
+        res.json({
+            installed: true,
+            tool: name,
+            version,
+            message: `${name} is installed: ${version}`,
+        });
+
+    } catch (err) {
+        res.json({
+            installed: false,
+            tool: name,
+            version: null,
+            message: `${name} is not installed`,
+        });
+    }
+});
+
+// ============================================
+// Helpers
+// ============================================
+
+function detectProviderFromCommand(command) {
+    if (command.includes('gcloud')) return 'gcp';
+    if (command.includes('az ')) return 'azure';
+    if (command.includes('aws ')) return 'aws_sso';
+    if (command.includes('gh ')) return 'github';
+    if (command.includes('glab')) return 'gitlab';
+    return 'unknown';
+}
+
+function getVersionCommand(tool) {
+    const commands = {
+        gcloud:      'gcloud --version',
+        'azure-cli': 'az --version',
+        'aws-cli':   'aws --version',
+        'github-cli': 'gh --version',
+        git:         'git --version',
+        node:        'node --version',
+        docker:      'docker --version',
+        brew:        'brew --version',
+        python:      'python3 --version',
+        java:        'java -version',
+        mvn:         'mvn --version',
+    };
+    return commands[tool] || `${tool} --version`;
+}
+
+function getInstallCommand(tool, platform) {
+    const isMac = platform === 'darwin';
+    const isLinux = platform === 'linux';
+    const isWin = platform === 'win32';
+
+    const commands = {
+        gcloud: {
+            darwin: 'brew install --cask google-cloud-sdk',
+            linux: 'curl https://sdk.cloud.google.com | bash',
+            win32: 'winget install Google.CloudSDK',
+        },
+        'azure-cli': {
+            darwin: 'brew install azure-cli',
+            linux: 'curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash',
+            win32: 'winget install Microsoft.AzureCLI',
+        },
+        'aws-cli': {
+            darwin: 'brew install awscli',
+            linux: 'curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o awscliv2.zip && unzip awscliv2.zip && sudo ./aws/install',
+            win32: 'winget install Amazon.AWSCLI',
+        },
+        'github-cli': {
+            darwin: 'brew install gh',
+            linux: 'sudo apt install gh -y',
+            win32: 'winget install GitHub.cli',
+        },
+        git: {
+            darwin: 'brew install git',
+            linux: 'sudo apt install git -y',
+            win32: 'winget install Git.Git',
+        },
+        node: {
+            darwin: 'brew install node',
+            linux: 'curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - && sudo apt-get install -y nodejs',
+            win32: 'winget install OpenJS.NodeJS',
+        },
+        docker: {
+            darwin: 'brew install --cask docker',
+            linux: 'curl -fsSL https://get.docker.com | sh',
+            win32: 'winget install Docker.DockerDesktop',
+        },
+    };
+
+    return commands[tool]?.[platform] || null;
+}
+
+function getInstallUrl(tool) {
+    const urls = {
+        gcloud:       'https://cloud.google.com/sdk/docs/install',
+        'azure-cli':  'https://learn.microsoft.com/en-us/cli/azure/install-azure-cli',
+        'aws-cli':    'https://aws.amazon.com/cli/',
+        'github-cli': 'https://cli.github.com/',
+        git:          'https://git-scm.com/downloads',
+        node:         'https://nodejs.org/',
+        docker:       'https://docs.docker.com/get-docker/',
+    };
+    return urls[tool] || `https://www.google.com/search?q=install+${tool}`;
+}
+
+export { router as setupAgentRouter };