agen-vektor 0.3.19 → 0.3.20

package/dist/tools/shell.js

@@ -7,39 +7,94 @@ exports.createShellTool = createShellTool;
  * Every command is classified by the command policy and gated by permissions.
  */
 const node_child_process_1 = require("node:child_process");
+// After the shell itself exits, wait this long for the stdio pipes to drain
+// (normal commands flush and close within milliseconds) before giving up.
+// A command that ORPHANS a child holding the pipes (background job, server,
+// watcher …) would otherwise keep the tool — and the whole agent loop —
+// hanging until the grandchild dies ("sering nyangkut di shell", 2026-09-10).
+const ORPHAN_GRACE_MS = 500;
 function runShell(command, cwd, opts = {}) {
     return new Promise((resolve) => {
         const timeoutMs = opts.timeoutMs || 120_000;
+        // Own process group (detached) → the timeout / orphan guard can kill the
+        // whole tree (shell AND grandchildren), same policy as background.ts.
         const child = (0, node_child_process_1.spawn)(command, {
             cwd,
             shell: '/bin/sh',
             env: { ...process.env, ...opts.env },
             stdio: ['ignore', 'pipe', 'pipe'],
+            detached: true,
         });
         let stdout = '';
         let stderr = '';
         let timedOut = false;
+        let settled = false;
+        let graceTimer = null;
+        const killTree = () => {
+            if (child.pid != null) {
+                try {
+                    process.kill(-child.pid, 'SIGKILL'); // detached spawn ⇒ own process group
+                }
+                catch {
+                    /* group already gone */
+                }
+            }
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                /* already gone */
+            }
+        };
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            resolve({ stdout, stderr, exitCode: code, timedOut });
+        };
         const timer = setTimeout(() => {
             timedOut = true;
-            child.kill('SIGKILL');
+            killTree(); // was: child.kill() only — orphaned children kept the pipe open and the promise hanging past the timeout
+            // 'exit' fires once the shell dies and resolves immediately.
         }, timeoutMs);
         child.stdout.on('data', (d) => {
             stdout += d.toString();
             if (stdout.length > 2_000_000)
-                child.kill('SIGKILL');
+                killTree();
         });
         child.stderr.on('data', (d) => {
             stderr += d.toString();
             if (stderr.length > 2_000_000)
-                child.kill('SIGKILL');
+                killTree();
+        });
+        // 'exit' = the shell itself died; 'close' = shell AND stdio pipes closed.
+        // Resolve on whichever happens first with a small grace window after
+        // 'exit': a normal command flushes and closes well inside the window, so
+        // full output still arrives — but an orphaned grandchild holding the
+        // pipes can no longer hang the tool past it.
+        child.on('exit', (code) => {
+            if (timedOut) {
+                finish(code);
+                return;
+            }
+            if (graceTimer)
+                return;
+            graceTimer = setTimeout(() => {
+                killTree(); // stop the orphan so its output stops too
+                finish(code);
+            }, ORPHAN_GRACE_MS);
         });
         child.on('close', (code) => {
-            clearTimeout(timer);
-            resolve({ stdout, stderr, exitCode: code, timedOut });
+            finish(code);
         });
         child.on('error', (e) => {
-            clearTimeout(timer);
-            resolve({ stdout, stderr: `spawn error: ${e.message}`, exitCode: -1, timedOut });
+            // set stderr BEFORE finish — the resolved object snapshots these strings
+            if (!stdout && !stderr)
+                stderr = `spawn error: ${e.message}`;
+            finish(-1);
         });
     });
 }
@@ -52,7 +107,7 @@ function createShellTool() {
     return {
         definition: {
             name: 'shell',
-            description: 'Run a shell command in the project directory. The command is classified for safety; risky commands require permission. Use for building, testing, installing, git, or any command execution. Long output is truncated. For git commits prefer the dedicated `git` tool and follow its commit-attribution guidance.',
+            description: 'Run a shell command in the project directory. The command is classified for safety; risky commands require permission. Use for building, testing, installing, git, or any command execution. Long output is truncated. Commands that keep running (dev servers, watchers, polling loops) must use run_in_background instead — a foreground shell is killed after its timeout. For git commits prefer the dedicated `git` tool and follow its commit-attribution guidance.',
             parameters: {
                 type: 'object',
                 properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agen-vektor",
-  "version": "0.3.19",
+  "version": "0.3.20",
   "description": "VectorHead (agen-vektor) — AI Coding Agent CLI/TUI for Linux & Termux. Multi-provider, tool calling, session, permission system.",
   "type": "commonjs",
   "bin": {