bunosh 0.4.14 → 0.5.6

package/src/task.js

@@ -198,6 +198,8 @@ export async function task(name, fn, isSilent = false) {
 
     // Check if result is a TaskResult instance
     if (result && result.constructor && result.constructor.name === 'TaskResult') {
+      printer.cancel();
+      runningTasks.delete(taskInfo.id);
       return result;
     }
 
@@ -246,8 +248,13 @@ export async function task(name, fn, isSilent = false) {
   }
 }
 
-// Add try method to task function
+// Add methods to task function
 task.try = tryTask;
+task.stopOnFailures = stopOnFailures;
+task.ignoreFailures = ignoreFailures;
+task.silence = silence;
+task.prints = prints;
+task.silent = silent;
 
 
 export class SilentTaskWrapper {

package/src/tasks/exec.js

@@ -1,251 +1,7 @@
-import { TaskResult, createTaskInfo, finishTaskInfo, getCurrentTaskId, runningTasks } from '../task.js';
-import Printer from '../printer.js';
-
-const isBun = typeof Bun !== 'undefined';
+// Deprecated: `exec` is now an alias for `shell`.
+// Use `shell` (or `$`) instead. This module is kept for backward compatibility.
+import shell from './shell.js';
 
 export default function exec(strings, ...values) {
-  // Check if called as regular function instead of template literal
-  if (!Array.isArray(strings)) {
-    // If first argument is a string, treat it as the command
-    if (typeof strings === 'string') {
-      strings = [strings];
-      values = [];
-    } else {
-      throw new Error('exec() must be called as a template literal: exec`command` or exec("command")');
-    }
-  }
-
-  const cmd = strings.reduce((accumulator, str, i) => {
-    return accumulator + str + (values[i] || '');
-  }, '');
-
-  let envs = null;
-  let cwd = null;
-
-  const cmdPromise = new Promise(async (resolve, reject) => {
-    // Wait for the next event loop tick to ensure .env() and .cwd() have been called
-    await new Promise(resolve => setTimeout(resolve, 0));
-
-    const currentTaskId = getCurrentTaskId();
-
-    // Check if parent task is silent
-    let isParentSilent = false;
-    if (currentTaskId) {
-      const parentTask = runningTasks.get(currentTaskId);
-      if (parentTask && parentTask.isSilent) {
-        isParentSilent = true;
-      }
-    }
-
-    const extraInfo = {};
-    if (cwd) extraInfo.cwd = cwd;
-    if (envs) extraInfo.env = envs;
-
-    const taskInfo = createTaskInfo(cmd, currentTaskId, isParentSilent);
-    const printer = new Printer('exec', taskInfo.id);
-    printer.start(cmd, extraInfo);
-
-    try {
-      if (global.disableBunForTesting || !isBun) {
-        const result = await nodeExec(cmd, extraInfo, printer, taskInfo);
-        if (result.status === 'success') {
-          finishTaskInfo(taskInfo, true, null, result.output);
-          resolve(result);
-        } else {
-          finishTaskInfo(taskInfo, false, new Error(result.output), result.output);
-          resolve(result);
-        }
-        return;
-      }
-
-      // Bun implementation with real-time streaming
-      const needsShell = cmd.includes('|') || cmd.includes('>') || cmd.includes('<') || cmd.includes('&&') || cmd.includes('||') || cmd.includes("'") || cmd.includes('"') || cmd.includes(';');
-
-      const { spawn } = Bun;
-      const proc = spawn({
-        cmd: needsShell ? ['/bin/sh', '-c', cmd] : cmd.trim().split(/\s+/),
-        cwd: cwd || process.cwd(),
-        env: {
-          ...(envs ? { ...process.env, ...envs } : process.env),
-        },
-        stdout: "pipe",
-        stderr: "pipe",
-        stdin: "ignore"
-      });
-
-      const decoder = new TextDecoder();
-      let output = '';
-      let stdout = '';
-      let stderr = '';
-      let finished = false;
-
-      // Process stdout
-      const readStdout = async () => {
-        const reader = proc.stdout.getReader();
-        let buffer = '';
-
-        try {
-          while (!finished) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            const text = decoder.decode(value, { stream: true });
-            buffer += text;
-
-            const lines = buffer.split('\n');
-            buffer = lines.pop();
-
-            for (const line of lines) {
-              if (line.trim()) {
-                printer.output(line);
-                output += line + '\n';
-                stdout += line + '\n';
-              }
-            }
-          }
-
-          if (buffer.trim()) {
-            printer.output(buffer);
-            output += buffer + '\n';
-            stdout += buffer + '\n';
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      };
-
-      // Process stderr
-      const readStderr = async () => {
-        const reader = proc.stderr.getReader();
-        let buffer = '';
-
-        try {
-          while (!finished) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            const text = decoder.decode(value, { stream: true });
-            buffer += text;
-
-            const lines = buffer.split('\n');
-            buffer = lines.pop();
-
-            for (const line of lines) {
-              if (line.trim()) {
-                printer.output(line, true);
-                output += line + '\n';
-                stderr += line + '\n';
-              }
-            }
-          }
-
-          if (buffer.trim()) {
-            printer.output(buffer, true);
-            output += buffer + '\n';
-            stderr += buffer + '\n';
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      };
-
-      // Start reading both streams
-      const [, , exitResult] = await Promise.all([
-        readStdout(),
-        readStderr(),
-        proc.exited
-      ]);
-
-      finished = true;
-      const exitCode = parseInt(exitResult, 10);
-
-      const metadata = {
-        taskType: 'exec',
-        exitCode,
-        stdout: stdout.trim(),
-        stderr: stderr.trim()
-      };
-
-      if (exitCode === 0) {
-        printer.finish(cmd);
-        finishTaskInfo(taskInfo, true, null, output.trim());
-        resolve(TaskResult.success(output.trim(), metadata));
-      } else {
-        const error = new Error(`Exit code: ${exitCode}`);
-        printer.error(cmd, null, { exitCode });
-        finishTaskInfo(taskInfo, false, error, output.trim());
-        resolve(TaskResult.fail(output.trim(), metadata));
-      }
-    } catch (error) {
-      printer.error(cmd, error);
-      finishTaskInfo(taskInfo, false, error, error.message);
-      resolve(TaskResult.fail(error.message, { taskType: 'exec' }));
-    }
-  });
-
-  cmdPromise.env = (newEnvs) => {
-    envs = newEnvs;
-    return cmdPromise;
-  };
-
-  cmdPromise.cwd = (newCwd) => {
-    cwd = newCwd;
-    return cmdPromise;
-  };
-
-  return cmdPromise;
-}
-
-async function nodeExec(cmd, extraInfo, printer, taskInfo) {
-  // Node.js fallback - simple execution without real-time output
-  const { spawn } = await import('child_process');
-  
-  return new Promise((resolve) => {
-    const proc = spawn('sh', ['-c', cmd], {
-      cwd: extraInfo.cwd || process.cwd(),
-      env: extraInfo.env ? { ...process.env, ...extraInfo.env } : process.env,
-      stdio: ['ignore', 'pipe', 'pipe']
-    });
-    
-    let output = '';
-    let stdout = '';
-    let stderr = '';
-    
-    proc.stdout.on('data', (data) => {
-      const text = data.toString();
-      printer.output(text.trim());
-      output += text;
-      stdout += text;
-    });
-    
-    proc.stderr.on('data', (data) => {
-      const text = data.toString();
-      printer.output(text.trim(), true);
-      output += text;
-      stderr += text;
-    });
-    
-    proc.on('close', (code) => {
-      const combinedOutput = (output).trim();
-      const metadata = {
-        taskType: 'exec',
-        exitCode: code,
-        stdout: stdout.trim(),
-        stderr: stderr.trim()
-      };
-      
-      if (code === 0) {
-        printer.finish(cmd);
-        resolve(TaskResult.success(combinedOutput, metadata));
-      } else {
-        printer.error(cmd, new Error(`Exit code: ${code}`));
-        resolve(TaskResult.fail(combinedOutput, metadata));
-      }
-    });
-    
-    proc.on('error', (error) => {
-      printer.error(cmd, error);
-      resolve(TaskResult.fail(error.message, { taskType: 'exec' }));
-    });
-  });
+  return shell(strings, ...values);
 }

package/src/tasks/fetch.js

@@ -23,6 +23,7 @@ export default async function httpFetch() {
 
   try {
     const response = await fetch(...arguments);
+    const responseForBody = response.clone(); // Clone before streaming consumes the body
     const textDecoder = new TextDecoder();
     let output = '';
 
@@ -40,7 +41,7 @@ export default async function httpFetch() {
 
     const metadata = {
       taskType: 'fetch',
-      response: response.clone(), // Clone to allow json() to be called later
+      response: responseForBody, // Unconsumed clone so json()/text() work later
       status: response.status,
       statusText: response.statusText,
       headers: Object.fromEntries(response.headers.entries())

package/src/tasks/shell.js

@@ -1,66 +1,34 @@
-import { TaskResult, createTaskInfo, finishTaskInfo, getCurrentTaskId, runningTasks } from "../task.js";
-import Printer from "../printer.js";
+import { TaskResult, createTaskInfo, finishTaskInfo, getCurrentTaskId, runningTasks } from '../task.js';
+import Printer from '../printer.js';
 
 const isBun = typeof Bun !== 'undefined' && typeof Bun.spawn === 'function';
 
 export default function shell(strings, ...values) {
-  let envs = null;
-  let cwd = null;
-  
   // Check if called as regular function instead of template literal
   if (!Array.isArray(strings)) {
-    // If first argument is a string, treat it as the command
     if (typeof strings === 'string') {
-      // For Bun shell, we need to create a template literal-like call
-      // But since we can't, fall back to exec
-      console.log('Note: shell() with string argument falls back to exec()');
-      const cmdPromise = (async () => {
-        const { default: exec } = await import("./exec.js");
-        let execPromise = exec(strings);
-        if (envs) execPromise = execPromise.env(envs);
-        if (cwd) execPromise = execPromise.cwd(cwd);
-        return execPromise;
-      })();
-      
-      // Add .env and .cwd methods
-      cmdPromise.env = (newEnvs) => {
-        envs = newEnvs;
-        return cmdPromise;
-      };
-      
-      cmdPromise.cwd = (newCwd) => {
-        cwd = newCwd;
-        return cmdPromise;
-      };
-      
-      return cmdPromise;
+      strings = [strings];
+      values = [];
     } else {
-      throw new Error('shell() must be called as a template literal: shell`command`');
+      throw new Error('shell() must be called as a template literal: shell`command` or shell("command")');
     }
   }
-  
+
   const cmd = strings.reduce((accumulator, str, i) => {
-    return accumulator + str + (values[i] || "");
-  }, "");
+    return accumulator + str + (values[i] || '');
+  }, '');
 
-  const cmdPromise = new Promise(async (resolve, reject) => {
-    const extraInfo = {};
-    if (cwd) extraInfo.cwd = cwd;
-    if (envs) extraInfo.env = envs;
+  let envs = null;
+  let cwd = null;
 
-    if (!isBun) {
-      const { default: exec } = await import("./exec.js");
-      let execPromise = exec([cmd]);
-      if (envs) execPromise = execPromise.env(envs);
-      if (cwd) execPromise = execPromise.cwd(cwd);
-      const result = await execPromise;
-      resolve(result);
-      return;
-    }
+  const cmdPromise = new Promise(async (resolve) => {
+    // Wait for the next event loop tick to ensure .env() and .cwd() have been called
+    await new Promise(resolve => setTimeout(resolve, 0));
+
+    const currentTaskId = getCurrentTaskId();
 
     // Check if parent task is silent
     let isParentSilent = false;
-    const currentTaskId = getCurrentTaskId();
     if (currentTaskId) {
       const parentTask = runningTasks.get(currentTaskId);
       if (parentTask && parentTask.isSilent) {
@@ -68,91 +36,144 @@ export default function shell(strings, ...values) {
       }
     }
 
-    const taskInfo = createTaskInfo(cmd, null, isParentSilent);
-    const printer = new Printer("shell", taskInfo.id);
+    const extraInfo = {};
+    if (cwd) extraInfo.cwd = cwd;
+    if (envs) extraInfo.env = envs;
+
+    const taskInfo = createTaskInfo(cmd, currentTaskId, isParentSilent);
+    const printer = new Printer('shell', taskInfo.id);
     printer.start(cmd, extraInfo);
 
     try {
-      const { $ } = await import("bun");
-      
-      let shell = $;
-      
-      if (cwd) {
-        shell = shell.cwd(cwd);
-      }
-      
-      if (envs) {
-        shell = shell.env(envs);
+      if (global.disableBunForTesting || !isBun) {
+        const result = await nodeShell(cmd, extraInfo, printer);
+        if (result.status === 'success') {
+          finishTaskInfo(taskInfo, true, null, result.output);
+          resolve(result);
+        } else {
+          finishTaskInfo(taskInfo, false, new Error(result.output), result.output);
+          resolve(result);
+        }
+        return;
       }
 
-      let result;
-      try {
-        result = await shell(strings, ...values);
-        
-        const output = await result.text();
-        
-        const metadata = {
-          taskType: 'shell',
-          exitCode: 0,
-          stdout: output.trim(),
-          stderr: ''
-        };
-        
-        printer.finish(cmd);
-        finishTaskInfo(taskInfo, true, null, output.trim());
-        resolve(TaskResult.success(output.trim(), metadata));
-        return;
-        
-      } catch (shellError) {
-        const isCommandNotFound = shellError.stderr && 
-          (shellError.stderr.includes('command not found') || 
-           shellError.stderr.includes('bun: command not found'));
-        
-        if (isCommandNotFound) {
-          printer.finish(cmd);
-          finishTaskInfo(taskInfo, true, null, "fallback to exec");
-          
-          const { default: exec } = await import("./exec.js");
-          let execPromise = exec([cmd]);
-          if (envs) execPromise = execPromise.env(envs);
-          if (cwd) execPromise = execPromise.cwd(cwd);
-          const result = await execPromise;
-          resolve(result);
-          return;
+      // Bun implementation with real-time streaming
+      const needsShell = cmd.includes('|') || cmd.includes('>') || cmd.includes('<') || cmd.includes('&&') || cmd.includes('||') || cmd.includes("'") || cmd.includes('"') || cmd.includes(';') || cmd.includes('$') || cmd.includes('`') || cmd.includes('\n');
+
+      const { spawn } = Bun;
+      const proc = spawn({
+        cmd: needsShell ? ['/bin/sh', '-c', cmd] : cmd.trim().split(/\s+/),
+        cwd: cwd || process.cwd(),
+        env: {
+          ...(envs ? { ...process.env, ...envs } : process.env),
+        },
+        stdout: "pipe",
+        stderr: "pipe",
+        stdin: "ignore"
+      });
+
+      const decoder = new TextDecoder();
+      let output = '';
+      let stdout = '';
+      let stderr = '';
+      let finished = false;
+
+      // Process stdout
+      const readStdout = async () => {
+        const reader = proc.stdout.getReader();
+        let buffer = '';
+
+        try {
+          while (!finished) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            const text = decoder.decode(value, { stream: true });
+            buffer += text;
+
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+
+            for (const line of lines) {
+              if (line.trim()) {
+                printer.output(line);
+                output += line + '\n';
+                stdout += line + '\n';
+              }
+            }
+          }
+
+          if (buffer.trim()) {
+            printer.output(buffer);
+            output += buffer + '\n';
+            stdout += buffer + '\n';
+          }
+        } finally {
+          reader.releaseLock();
         }
-        
-        if (shellError.exitCode !== undefined) {
-          const stderr = shellError.stderr ? Buffer.isBuffer(shellError.stderr) ? shellError.stderr.toString() : shellError.stderr : "";
-          const stdout = shellError.stdout ? Buffer.isBuffer(shellError.stdout) ? shellError.stdout.toString() : shellError.stdout : "";
-          const errorOutput = (stderr + stdout).trim() || `Command failed with exit code ${shellError.exitCode}`;
-          
-          if (errorOutput) {
-            const lines = errorOutput.split('\n');
+      };
+
+      // Process stderr
+      const readStderr = async () => {
+        const reader = proc.stderr.getReader();
+        let buffer = '';
+
+        try {
+          while (!finished) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            const text = decoder.decode(value, { stream: true });
+            buffer += text;
+
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+
             for (const line of lines) {
               if (line.trim()) {
                 printer.output(line, true);
+                output += line + '\n';
+                stderr += line + '\n';
               }
             }
           }
-          
-          const metadata = {
-            taskType: 'shell',
-            exitCode: shellError.exitCode,
-            stdout: stdout.trim(),
-            stderr: stderr.trim()
-          };
-          
-          const error = new Error(`Exit code: ${shellError.exitCode}`);
-          printer.error(cmd, null, { exitCode: shellError.exitCode });
-          finishTaskInfo(taskInfo, false, error, errorOutput);
-          resolve(TaskResult.fail(errorOutput, metadata));
-          return;
-        } else {
-          const errorMessage = shellError.message || shellError.toString();
-          printer.error(cmd, shellError);
-          finishTaskInfo(taskInfo, false, shellError, errorMessage);
-          resolve(TaskResult.fail(errorMessage, { taskType: 'shell' }));
+
+          if (buffer.trim()) {
+            printer.output(buffer, true);
+            output += buffer + '\n';
+            stderr += buffer + '\n';
+          }
+        } finally {
+          reader.releaseLock();
         }
+      };
+
+      // Start reading both streams
+      const [, , exitResult] = await Promise.all([
+        readStdout(),
+        readStderr(),
+        proc.exited
+      ]);
+
+      finished = true;
+      const exitCode = parseInt(exitResult, 10);
+
+      const metadata = {
+        taskType: 'shell',
+        exitCode,
+        stdout: stdout.trim(),
+        stderr: stderr.trim()
+      };
+
+      if (exitCode === 0) {
+        printer.finish(cmd);
+        finishTaskInfo(taskInfo, true, null, output.trim());
+        resolve(TaskResult.success(output.trim(), metadata));
+      } else {
+        const error = new Error(`Exit code: ${exitCode}`);
+        printer.error(cmd, null, { exitCode });
+        finishTaskInfo(taskInfo, false, error, output.trim());
+        resolve(TaskResult.fail(output.trim(), metadata));
       }
     } catch (error) {
       printer.error(cmd, error);
@@ -173,3 +194,57 @@ export default function shell(strings, ...values) {
 
   return cmdPromise;
 }
+
+async function nodeShell(cmd, extraInfo, printer) {
+  // Node.js fallback - simple execution without real-time output
+  const { spawn } = await import('child_process');
+
+  return new Promise((resolve) => {
+    const proc = spawn('sh', ['-c', cmd], {
+      cwd: extraInfo.cwd || process.cwd(),
+      env: extraInfo.env ? { ...process.env, ...extraInfo.env } : process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    let output = '';
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => {
+      const text = data.toString();
+      printer.output(text.trim());
+      output += text;
+      stdout += text;
+    });
+
+    proc.stderr.on('data', (data) => {
+      const text = data.toString();
+      printer.output(text.trim(), true);
+      output += text;
+      stderr += text;
+    });
+
+    proc.on('close', (code) => {
+      const combinedOutput = output.trim();
+      const metadata = {
+        taskType: 'shell',
+        exitCode: code,
+        stdout: stdout.trim(),
+        stderr: stderr.trim()
+      };
+
+      if (code === 0) {
+        printer.finish(cmd);
+        resolve(TaskResult.success(combinedOutput, metadata));
+      } else {
+        printer.error(cmd, new Error(`Exit code: ${code}`));
+        resolve(TaskResult.fail(combinedOutput, metadata));
+      }
+    });
+
+    proc.on('error', (error) => {
+      printer.error(cmd, error);
+      resolve(TaskResult.fail(error.message, { taskType: 'shell' }));
+    });
+  });
+}