bunosh 0.5.0 → 0.5.6

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' }));
+    });
+  });
+}

package/src/upgrade.js

@@ -1,4 +1,4 @@
-import { exec, execSync } from 'child_process';
+import { exec, execSync, spawn } from 'child_process';
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { platform } from 'os';
 import { homedir } from 'os';
@@ -13,18 +13,44 @@ export async function upgradeCommand(options = {}) {
     const installMethod = detectInstallMethod();
     console.log(`Bunosh is installed via: ${color.bold(installMethod)}`);
     
-    if (installMethod === 'bun') {
-      if (!check) {
+    if (installMethod === 'bun' || installMethod === 'npm') {
+      const currentVersion = getCurrentVersion();
+      let latestVersion = null;
+      try {
+        latestVersion = await getLatestNpmVersion();
+      } catch (e) {
+      }
+
+      console.log(`Current version: ${color.bold(currentVersion)}`);
+      if (latestVersion) {
+        console.log(`Latest version:  ${color.bold(latestVersion)}`);
+      }
+
+      if (latestVersion && !force && !isNewerVersion(latestVersion, currentVersion)) {
+        console.log(color.green('You are already on the latest version!'));
+        if (!force) {
+          console.log(`   Use ${color.bold('--force')} to reinstall the current version.`);
+        }
+        return;
+      }
+
+      const upgradeCmd = installMethod === 'bun'
+        ? 'bun add -g bunosh@latest --force'
+        : 'npm install -g bunosh@latest';
+
+      if (check) {
+        console.log('Will upgrade with: ' + color.bold(upgradeCmd));
+        return;
+      }
+
+      if (installMethod === 'bun') {
         await upgradeWithBun();
       } else {
-        console.log('Will upgrade with: ' + color.bold('bun add -g bunosh'));
-      }
-    } else if (installMethod === 'npm') {
-      if (!check) {
         await upgradeWithNpm();
-      } else {
-        console.log('Will upgrade with: ' + color.bold('npm update -g bunosh'));
       }
+
+      console.log();
+      console.log(`Run ${color.bold('bunosh --version')} to verify the new version.`);
     } else if (installMethod === 'executable') {
       await upgradeExecutable({ force, check });
     } else {
@@ -101,36 +127,115 @@ function detectInstallMethod() {
   return 'unknown';
 }
 
-async function upgradeWithBun() {
-  console.log('Upgrading with Bun...');
-  
+function runStreaming(command, args) {
   return new Promise((resolve, reject) => {
-    exec('bun add -g bunosh', (error, stdout, stderr) => {
-      if (error) {
-        reject(new Error(`Bun upgrade failed: ${stderr || error.message}`));
+    const child = spawn(command, args, { stdio: 'inherit' });
+    child.on('error', (error) => reject(new Error(`${command} not available: ${error.message}`)));
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
         return;
       }
-      console.log(stdout);
-      console.log(color.green('Upgrade successful!'));
-      resolve();
+      reject(new Error(`${command} ${args.join(' ')} exited with code ${code}`));
     });
   });
 }
 
+async function upgradeWithBun() {
+  console.log('Upgrading with Bun...');
+
+  try {
+    await runStreaming('bun', ['add', '-g', 'bunosh@latest', '--force']);
+    console.log(color.green('Upgrade successful!'));
+    return;
+  } catch (error) {
+    console.warn(color.yellow(`Bun upgrade failed: ${error.message}`));
+    console.warn(color.yellow('Falling back to npm (a known Bun global-install bug)...'));
+  }
+
+  await upgradeWithNpm();
+}
+
 async function upgradeWithNpm() {
   console.log('Upgrading with npm...');
-  
-  return new Promise((resolve, reject) => {
-    exec('npm update -g bunosh', (error, stdout, stderr) => {
-      if (error) {
-        reject(new Error(`npm upgrade failed: ${stderr || error.message}`));
-        return;
-      }
-      console.log(stdout);
-      console.log(color.green('Upgrade successful!'));
-      resolve();
+
+  await runStreaming('npm', ['install', '-g', 'bunosh@latest']);
+  console.log(color.green('Upgrade successful!'));
+}
+
+export async function getLatestNpmVersion(timeoutMs = 3000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch('https://registry.npmjs.org/bunosh/latest', {
+      headers: { 'User-Agent': 'bunosh' },
+      signal: controller.signal,
     });
-  });
+
+    if (!response.ok) {
+      throw new Error(`npm registry error: ${response.status}`);
+    }
+
+    const data = await response.json();
+    return data.version;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function getCachedLatestNpmVersion() {
+  const cacheDir = join(homedir(), '.bunosh');
+  const cacheFile = join(cacheDir, 'version-check.json');
+  const TTL = 12 * 60 * 60 * 1000;
+
+  try {
+    if (existsSync(cacheFile)) {
+      const cache = JSON.parse(readFileSync(cacheFile, 'utf8'));
+      if (cache.latest && cache.checkedAt && Date.now() - cache.checkedAt < TTL) {
+        return cache.latest;
+      }
+    }
+  } catch (e) {
+  }
+
+  let latest = null;
+  try {
+    latest = await getLatestNpmVersion(2000);
+  } catch (e) {
+    return null;
+  }
+
+  try {
+    await mkdir(cacheDir, { recursive: true });
+    writeFileSync(cacheFile, JSON.stringify({ checkedAt: Date.now(), latest }));
+  } catch (e) {
+  }
+
+  return latest;
+}
+
+export async function printUpgradeNoticeIfAvailable() {
+  if (process.env.NODE_ENV === 'test' || process.env.VITEST_WORKER_ID !== undefined) {
+    return;
+  }
+
+  try {
+    const currentVersion = getCurrentVersion();
+    if (!currentVersion || currentVersion === 'unknown') {
+      return;
+    }
+
+    const latestVersion = await getCachedLatestNpmVersion();
+    if (!latestVersion || !isNewerVersion(latestVersion, currentVersion)) {
+      return;
+    }
+
+    console.log();
+    console.log(color.yellow(`🦾 A new version of Bunosh is available: ${color.bold(currentVersion)} → ${color.bold(latestVersion)}`));
+    console.log(color.dim(`   Run ${color.bold('bunosh upgrade')} to update.`));
+  } catch (e) {
+  }
 }
 
 export async function upgradeExecutable(options = {}) {
@@ -199,7 +304,7 @@ function getCurrentVersion() {
 }
 
 async function getLatestRelease() {
-  const response = await fetch('https://api.github.com/repos/davertmik/bunosh/releases/latest', {
+  const response = await fetch('https://api.github.com/repos/DavertMik/bunosh/releases/latest', {
     headers: {
       'User-Agent': 'bunosh'
     }