pelulu-cli 1.1.0 → 1.2.0

package/src/tools/network.js

@@ -7,46 +7,79 @@ import { exec } from 'child_process';
 import { createWriteStream } from 'fs';
 import { pipeline } from 'stream/promises';
 import { log } from '../core/logger.js';
-
-function httpGet(url, maxChars = 5000) {
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith('https') ? https : http;
-    client.get(url, { timeout: 15000, headers: { 'User-Agent': 'coding-agent/1.0' } }, (res) => {
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        return httpGet(res.headers.location, maxChars).then(resolve, reject);
-      }
-      let d = '';
-      res.on('data', c => { if (d.length < maxChars) d += c; });
-      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: d }));
-    }).on('error', reject);
-  });
-}
+import { request as httpClientRequest } from '../core/http-client.js';
+import { bus } from '../core/event-bus.js';
 
 const ACTIONS = {
   async fetch({ url, method, body, headers }) {
     if (!url) throw new Error('url required');
-    log('network', `[WEB] ${method || 'GET'} ${url}`);
-    const result = await httpGet(url);
-    return { url, status: result.status, body: result.body.slice(0, 5000) };
+    const m = method || 'GET';
+    log('network', `[WEB] ${m} ${url}`);
+    const r = await httpClientRequest(url, { method: m, body, headers: headers || {}, timeout: 15000, followRedirects: true, maxBody: 200000 });
+    return {
+      url: r.finalUrl || url, status: r.status, headers: r.headers,
+      redirects: r.redirectChain, duration_ms: r.duration_ms,
+      body: r.body.slice(0, 8000), body_length: r.bytes,
+    };
   },
 
   async download({ url, path }) {
     if (!url || !path) throw new Error('url and path required');
-    log('network', `📥 Downloading: ${url}`);
+    log('network', `[DL] Downloading: ${url}`);
+    const started = Date.now();
     const client = url.startsWith('https') ? https : http;
+
+    bus.emit('task:progress', {
+      tool: 'network', running: true, phase: 'download',
+      target: url, elapsed: 0, log: 'starting download',
+    });
+
     return new Promise((resolve, reject) => {
-      client.get(url, { timeout: 30000, headers: { 'User-Agent': 'coding-agent/1.0' } }, async (res) => {
+      client.get(url, { timeout: 60000, headers: { 'User-Agent': 'pelulu-cli/1.0' } }, async (res) => {
         if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
           try { resolve(await ACTIONS.download({ url: res.headers.location, path })); } catch (e) { reject(e); }
           return;
         }
-        if (res.statusCode !== 200) return reject(new Error(`HTTP ${res.statusCode}`));
+        if (res.statusCode !== 200) {
+          bus.emit('task:progress', { tool: 'network', running: false, phase: 'error', target: url, log: `HTTP ${res.statusCode}` });
+          return reject(new Error(`HTTP ${res.statusCode}`));
+        }
+        const totalBytes = parseInt(res.headers['content-length'] || '0', 10);
+        let downloaded = 0;
+        let lastReport = 0;
+
+        // Track download progress
+        res.on('data', (chunk) => {
+          downloaded += chunk.length;
+          const now = Date.now();
+          if (now - lastReport > 2000) { // report every 2s
+            lastReport = now;
+            const elapsed = Math.round((now - started) / 1000);
+            const pct = totalBytes ? `${Math.round(downloaded / totalBytes * 100)}%` : `${Math.round(downloaded / 1024)}KB`;
+            bus.emit('task:progress', {
+              tool: 'network', running: true, phase: 'download',
+              target: url, elapsed, log: `${pct} downloaded`,
+            });
+          }
+        });
+
         const ws = createWriteStream(path);
         try {
           await pipeline(res, ws);
-          resolve({ downloaded: true, path, url });
-        } catch (e) { reject(e); }
-      }).on('error', reject);
+          const elapsed = Math.round((Date.now() - started) / 1000);
+          bus.emit('task:progress', {
+            tool: 'network', running: false, phase: 'done',
+            target: url, elapsed, log: `${Math.round(downloaded / 1024)}KB saved`,
+          });
+          resolve({ downloaded: true, path, url, bytes: downloaded, elapsed_s: elapsed });
+        } catch (e) {
+          bus.emit('task:progress', { tool: 'network', running: false, phase: 'error', target: url, log: e.message });
+          reject(e);
+        }
+      }).on('error', (e) => {
+        bus.emit('task:progress', { tool: 'network', running: false, phase: 'error', target: url, log: e.message });
+        reject(e);
+      });
     });
   },
 

package/src/tools/project.js

@@ -1,6 +1,9 @@
 /**
  * Project Tool — project lifecycle operations (1 MCP tool, 6 actions)
  * Actions: init, build, test, lint, deps, info
+ *
+ * Long-running operations (build, test, deps) stream progress via task:progress
+ * so the TUI shows live feedback instead of appearing stuck.
  */
 import { exec } from 'child_process';
 import { readFile } from 'fs/promises';
@@ -8,6 +11,7 @@ import { existsSync } from 'fs';
 import { join } from 'path';
 import { log } from '../core/logger.js';
 import { getConfig } from '../core/config.js';
+import { bus } from '../core/event-bus.js';
 
 function run(cmd, cwd, timeout = 120000) {
   return new Promise((resolve, reject) => {
@@ -18,6 +22,35 @@ function run(cmd, cwd, timeout = 120000) {
   });
 }
 
+/**
+ * Run a command with progress reporting for long operations.
+ */
+async function runWithProgress(cmd, dir, { label, timeout = 120000 } = {}) {
+  const started = Date.now();
+  bus.emit('task:progress', {
+    tool: 'project', running: true, phase: 'exec',
+    target: label || cmd.split(' ')[0], elapsed: 0, log: `running: ${cmd}`,
+  });
+
+  try {
+    const result = await run(cmd, dir, timeout);
+    const elapsed = Math.round((Date.now() - started) / 1000);
+    bus.emit('task:progress', {
+      tool: 'project', running: false, phase: 'done',
+      target: label || cmd.split(' ')[0], elapsed,
+      log: result.code === 0 ? 'completed' : `exit ${result.code}`,
+    });
+    return result;
+  } catch (err) {
+    bus.emit('task:progress', {
+      tool: 'project', running: false, phase: 'error',
+      target: label || cmd.split(' ')[0],
+      elapsed: Math.round((Date.now() - started) / 1000), log: err.message,
+    });
+    throw err;
+  }
+}
+
 function cwd(p) { return p || getConfig().agent?.workspace || process.cwd(); }
 
 async function detectProject(dir) {
@@ -58,7 +91,7 @@ const ACTIONS = {
       const cmd = BUILD_CMD[type];
       if (!cmd) throw new Error(`No build for ${type}`);
       log('project', `[BUILD] Building (${type})...`);
-      const r = await run(cmd, dir);
+      const r = await runWithProgress(cmd, dir, { label: `build (${type})`, timeout: 180000 });
       return { success: r.code === 0, type, exitCode: r.code, output: r.stdout.slice(-500) || r.stderr.slice(-500) };
     },
   },
@@ -71,7 +104,7 @@ const ACTIONS = {
       const cmd = TEST_CMD[type];
       if (!cmd) throw new Error(`No test for ${type}`);
       log('project', `[TEST] Testing (${type})...`);
-      const r = await run(cmd, dir);
+      const r = await runWithProgress(cmd, dir, { label: `test (${type})`, timeout: 180000 });
       return { passed: r.code === 0, type, exitCode: r.code, output: r.stdout.slice(-1000) || r.stderr.slice(-1000) };
     },
   },
@@ -83,7 +116,7 @@ const ACTIONS = {
       const type = await detectProject(dir);
       const cmd = LINT_CMD[type];
       if (!cmd) throw new Error(`No lint for ${type}`);
-      const r = await run(cmd, dir);
+      const r = await runWithProgress(cmd, dir, { label: `lint (${type})` });
       return { type, issues: r.stdout.slice(-2000) };
     },
   },
@@ -96,7 +129,8 @@ const ACTIONS = {
       if (params.install) {
         const cmd = INSTALL_CMD[type];
         if (!cmd) throw new Error(`No install for ${type}`);
-        await run(cmd, dir, 180000);
+        log('project', `[DEPS] Installing (${type})...`);
+        await runWithProgress(cmd, dir, { label: `deps install (${type})`, timeout: 180000 });
         return { installed: true, type };
       }
       try {

package/src/tools/search.js

@@ -3,9 +3,9 @@
  * Actions: grep, find, web
  */
 import { exec } from 'child_process';
-import https from 'https';
-import http from 'http';
 import { log } from '../core/logger.js';
+import { request as httpClientRequest } from '../core/http-client.js';
+import { bus } from '../core/event-bus.js';
 
 function runCmd(cmd, timeout = 10000) {
   return new Promise((resolve) => {
@@ -15,18 +15,10 @@ function runCmd(cmd, timeout = 10000) {
   });
 }
 
-function httpGet(url, maxChars = 8000) {
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith('https') ? https : http;
-    client.get(url, { timeout: 15000, headers: { 'User-Agent': 'coding-agent/1.0' } }, (res) => {
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        return httpGet(res.headers.location, maxChars).then(resolve, reject);
-      }
-      let d = '';
-      res.on('data', c => { if (d.length < maxChars) d += c; });
-      res.on('end', () => resolve({ status: res.statusCode, body: d }));
-    }).on('error', reject);
-  });
+// Delegates to the shared HTTP engine (gzip-aware, follows redirects).
+async function httpGet(url, maxChars = 8000) {
+  const r = await httpClientRequest(url, { timeout: 15000, followRedirects: true, maxBody: Math.max(maxChars, 8000) });
+  return { status: r.status, body: r.body.slice(0, maxChars) };
 }
 
 const ACTIONS = {
@@ -40,7 +32,9 @@ const ACTIONS = {
       const inc = include ? `--include="*.${include}"` : '';
       const ctx = context ? `-C ${context}` : '';
       const cmd = `grep ${flags}${ic} ${inc} ${ctx} "${pattern}" "${path || '.'}" 2>/dev/null | head -100`;
+      bus.emit('task:progress', { tool: 'search', running: true, phase: 'grep', target: path || '.', log: `searching: ${pattern}` });
       const r = await runCmd(cmd);
+      bus.emit('task:progress', { tool: 'search', running: false, phase: 'done', target: path || '.' });
       const lines = r.stdout.split('\n').filter(Boolean);
       return { pattern, matches: lines.length, results: lines };
     },
@@ -52,7 +46,9 @@ const ACTIONS = {
       log('search', `[FIND] find: ${name}`);
       const t = type ? `-type ${type}` : '';
       const cmd = `find "${path || '.'}" ${t} -name "${name}" 2>/dev/null | head -50`;
+      bus.emit('task:progress', { tool: 'search', running: true, phase: 'find', target: path || '.', log: `finding: ${name}` });
       const r = await runCmd(cmd);
+      bus.emit('task:progress', { tool: 'search', running: false, phase: 'done', target: path || '.' });
       return { pattern: name, matches: r.stdout.split('\n').filter(Boolean).length, files: r.stdout.split('\n').filter(Boolean) };
     },
   },

package/src/tools/shell.js

@@ -1,15 +1,76 @@
 /**
  * Shell Tool — consolidated shell operations (1 MCP tool, 4 actions)
  * Actions: exec, bg, ps, kill
+ *
+ * Long-running commands are streamable: stdout/stderr are captured in chunks
+ * and reported via task:progress so the TUI can show live output. The job
+ * layer (core/job-manager.js) auto-backgrounds anything > 8s.
  */
 import { exec, spawn } from 'child_process';
 import { log } from '../core/logger.js';
 import { getConfig } from '../core/config.js';
+import { bus } from '../core/event-bus.js';
+import { jobManager } from '../core/job-manager.js';
 
 const BLOCKED = [/rm\s+-rf\s+\//, /mkfs/, /dd\s+if=.*of=\/dev/, /chmod\s+777\s+\//];
 
 function isBlocked(cmd) { return BLOCKED.some(re => re.test(cmd)); }
 
+/**
+ * Run a command with streaming progress. Emits task:progress on each chunk
+ * so the TUI shows live output instead of waiting for the full result.
+ */
+function runStreaming(cmd, timeout, { label } = {}) {
+  return new Promise((resolve, reject) => {
+    if (isBlocked(cmd)) return reject(new Error('Blocked: dangerous command'));
+    const cfg = getConfig();
+    const t = timeout || cfg.tools?.shell_timeout || 30000;
+    const started = Date.now();
+    let stdout = '';
+    let stderr = '';
+    let chunkCount = 0;
+
+    const child = spawn('bash', ['-c', cmd], {
+      timeout: t,
+      maxBuffer: 1024 * 1024,
+      env: { ...process.env, FORCE_COLOR: '0' },
+    });
+
+    child.stdout?.on('data', (d) => {
+      stdout += d;
+      chunkCount++;
+      if (chunkCount % 5 === 0) {
+        bus.emit('task:progress', {
+          tool: 'shell', running: true,
+          phase: 'exec', target: label || cmd.slice(0, 60),
+          elapsed: Math.round((Date.now() - started) / 1000),
+          log: `${stdout.length + stderr.length} bytes captured`,
+        });
+      }
+    });
+
+    child.stderr?.on('data', (d) => {
+      stderr += d;
+    });
+
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0 && !stdout && stderr) {
+        reject(new Error(stderr.trim().slice(0, 500)));
+      } else {
+        resolve({ stdout: stdout.trim(), stderr: stderr.trim(), code: code ?? 0 });
+      }
+    });
+
+    // Timeout guard
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      reject(new Error(`Timed out after ${t}ms`));
+    }, t);
+    child.on('close', () => clearTimeout(timer));
+  });
+}
+
 function run(cmd, timeout) {
   return new Promise((resolve, reject) => {
     if (isBlocked(cmd)) return reject(new Error('Blocked: dangerous command'));
@@ -26,9 +87,14 @@ const ACTIONS = {
   exec: {
     required: ['command'],
     handler: async ({ command, timeout }) => {
-      log('shell', `[CFG] $ ${command}`);
-      const result = await run(command, timeout);
-      const maxLen = getConfig().tools?.max_output || 10000;
+      log('shell', `[EXEC] $ ${command}`);
+      // Use streaming for commands that might take a while
+      const cfg = getConfig();
+      const t = timeout || cfg.tools?.shell_timeout || 30000;
+      const result = t > 10000
+        ? await runStreaming(command, timeout, { label: command.slice(0, 60) })
+        : await run(command, timeout);
+      const maxLen = cfg.tools?.max_output || 10000;
       return { stdout: result.stdout.slice(0, maxLen), stderr: result.stderr.slice(0, 2000), exitCode: result.code };
     },
   },
@@ -36,7 +102,7 @@ const ACTIONS = {
   bg: {
     required: ['command'],
     handler: async ({ command }) => {
-      log('shell', `[CFG] [bg] $ ${command}`);
+      log('shell', `[BG] $ ${command}`);
       const child = spawn('bash', ['-c', command], { detached: true, stdio: 'ignore' });
       child.unref();
       return { pid: child.pid, background: true, command };