bunosh 0.1.4 → 0.2.2

package/src/upgrade.js

@@ -0,0 +1,255 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+
+/**
+ * Detects if bunosh is running as a single executable or npm package
+ */
+export function isExecutable() {
+  try {
+    // Check if we're running from a compiled executable
+    // In Bun compiled binaries, process.execPath points to the executable
+    const execPath = process.execPath;
+    const isCompiledBinary = !execPath.includes('node_modules') && 
+                            !execPath.includes('.bun') &&
+                            (execPath.includes('bunosh') || path.basename(execPath).startsWith('bunosh'));
+    
+    return isCompiledBinary;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Gets the current executable path
+ */
+export function getExecutablePath() {
+  if (!isExecutable()) {
+    throw new Error('Not running as executable');
+  }
+  return process.execPath;
+}
+
+/**
+ * Detects the platform and architecture for download
+ */
+export function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+  
+  // Map to GitHub release asset names
+  switch (platform) {
+    case 'linux':
+      if (arch === 'x64' || arch === 'x86_64') {
+        return { platform: 'linux', arch: 'x64', asset: 'bunosh-linux-x64.tar.gz' };
+      }
+      break;
+    case 'darwin':
+      if (arch === 'arm64') {
+        return { platform: 'darwin', arch: 'arm64', asset: 'bunosh-darwin-arm64.tar.gz' };
+      }
+      if (arch === 'x64' || arch === 'x86_64') {
+        return { platform: 'darwin', arch: 'x64', asset: 'bunosh-darwin-x64.tar.gz' };
+      }
+      break;
+    case 'win32':
+      if (arch === 'x64' || arch === 'x86_64') {
+        return { platform: 'windows', arch: 'x64', asset: 'bunosh-windows-x64.exe.zip' };
+      }
+      break;
+  }
+  
+  throw new Error(`Unsupported platform: ${platform} ${arch}`);
+}
+
+/**
+ * Fetches the latest release info from GitHub
+ */
+export async function getLatestRelease() {
+  try {
+    const response = await fetch('https://api.github.com/repos/davertmik/bunosh/releases/latest');
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status}`);
+    }
+    return await response.json();
+  } catch (error) {
+    throw new Error(`Failed to fetch release info: ${error.message}`);
+  }
+}
+
+/**
+ * Gets current version from package.json or executable
+ */
+export function getCurrentVersion() {
+  try {
+    // Try to read from package.json first
+    const packagePath = path.join(process.cwd(), 'package.json');
+    if (fs.existsSync(packagePath)) {
+      const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+      if (pkg.name === 'bunosh') {
+        return pkg.version;
+      }
+    }
+    
+    // For executable, version might be embedded or we can try --version
+    try {
+      const version = execSync('bunosh --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
+      return version;
+    } catch (error) {
+      // Fallback to unknown
+      return 'unknown';
+    }
+  } catch (error) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Compares version strings (simple semantic version comparison)
+ */
+export function isNewerVersion(latest, current) {
+  if (current === 'unknown') return true;
+  
+  // Remove 'v' prefix if present
+  const latestClean = latest.replace(/^v/, '');
+  const currentClean = current.replace(/^v/, '');
+  
+  const latestParts = latestClean.split('.').map(n => parseInt(n) || 0);
+  const currentParts = currentClean.split('.').map(n => parseInt(n) || 0);
+  
+  // Pad arrays to same length
+  const maxLength = Math.max(latestParts.length, currentParts.length);
+  while (latestParts.length < maxLength) latestParts.push(0);
+  while (currentParts.length < maxLength) currentParts.push(0);
+  
+  // Compare each part
+  for (let i = 0; i < maxLength; i++) {
+    if (latestParts[i] > currentParts[i]) return true;
+    if (latestParts[i] < currentParts[i]) return false;
+  }
+  
+  return false; // Versions are equal
+}
+
+/**
+ * Downloads and extracts the new binary
+ */
+export async function downloadAndInstall(release, platformInfo, executablePath, onProgress) {
+  const asset = release.assets.find(a => a.name === platformInfo.asset);
+  if (!asset) {
+    throw new Error(`No asset found for platform: ${platformInfo.asset}`);
+  }
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bunosh-upgrade-'));
+  const downloadPath = path.join(tempDir, asset.name);
+  
+  try {
+    // Download with progress
+    onProgress?.('Downloading latest release...');
+    const response = await fetch(asset.browser_download_url);
+    if (!response.ok) {
+      throw new Error(`Download failed: ${response.status}`);
+    }
+
+    const buffer = await response.arrayBuffer();
+    fs.writeFileSync(downloadPath, Buffer.from(buffer));
+    onProgress?.('Download complete');
+
+    // Extract and replace
+    onProgress?.('Extracting and installing...');
+    
+    // Create backup of current executable
+    const backupPath = executablePath + '.backup';
+    fs.copyFileSync(executablePath, backupPath);
+
+    if (platformInfo.platform === 'windows') {
+      // Handle ZIP extraction for Windows
+      execSync(`powershell -command "Expand-Archive -Path '${downloadPath}' -DestinationPath '${tempDir}' -Force"`);
+      const extractedExe = path.join(tempDir, 'bunosh-windows-x64.exe');
+      fs.copyFileSync(extractedExe, executablePath);
+    } else {
+      // Handle tar.gz extraction for Unix
+      const extractDir = path.join(tempDir, 'extracted');
+      fs.mkdirSync(extractDir);
+      
+      execSync(`tar -xzf "${downloadPath}" -C "${extractDir}"`);
+      
+      // Find the executable in extracted files
+      const extractedFiles = fs.readdirSync(extractDir);
+      const executableName = extractedFiles.find(f => f.startsWith('bunosh-'));
+      
+      if (!executableName) {
+        throw new Error('Could not find executable in downloaded archive');
+      }
+      
+      const extractedPath = path.join(extractDir, executableName);
+      fs.copyFileSync(extractedPath, executablePath);
+      fs.chmodSync(executablePath, 0o755);
+    }
+
+    onProgress?.('Installation complete');
+    
+    // Clean up
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    fs.unlinkSync(backupPath);
+    
+    return true;
+  } catch (error) {
+    // Restore backup if something went wrong
+    const backupPath = executablePath + '.backup';
+    if (fs.existsSync(backupPath)) {
+      try {
+        fs.copyFileSync(backupPath, executablePath);
+        fs.unlinkSync(backupPath);
+      } catch (restoreError) {
+        console.error('Failed to restore backup:', restoreError.message);
+      }
+    }
+    
+    // Clean up temp directory
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    
+    throw error;
+  }
+}
+
+/**
+ * Main upgrade function
+ */
+export async function upgradeExecutable(options = {}) {
+  const { force = false, onProgress } = options;
+  
+  if (!isExecutable()) {
+    throw new Error('Upgrade is only available for single executable installations. Use "npm update -g bunosh" for npm installations.');
+  }
+
+  onProgress?.('Checking for updates...');
+  
+  const currentVersion = getCurrentVersion();
+  const release = await getLatestRelease();
+  const latestVersion = release.tag_name;
+  
+  if (!force && !isNewerVersion(latestVersion, currentVersion)) {
+    return {
+      updated: false,
+      currentVersion,
+      latestVersion,
+      message: `Already on latest version: ${currentVersion}`
+    };
+  }
+
+  const platformInfo = getPlatformInfo();
+  const executablePath = getExecutablePath();
+  
+  await downloadAndInstall(release, platformInfo, executablePath, onProgress);
+  
+  return {
+    updated: true,
+    currentVersion,
+    latestVersion,
+    message: `Successfully upgraded from ${currentVersion} to ${latestVersion}`
+  };
+}

package/types.d.ts

@@ -0,0 +1,44 @@
+interface FileLine {
+  (strings: TemplateStringsArray | string, ...values: any[]): void;
+  fromFile(file: string): void;
+  currentFile(): void;
+}
+
+type TaskStatus = {
+  RUNNING: string;
+  FAIL: string;
+  SUCCESS: string;
+};
+
+declare function exec(cmd: TemplateStringsArray, ...values: any[]): {
+  env: (newEnvs: Record<string, string>) => Promise<void>;
+  cwd: (newCwd: string) => Promise<void>;
+};
+
+declare global {
+  namespace NodeJS {
+    interface Global {
+      bunosh: {
+        io: {
+          say(...args: any[]): void;
+          ask(question: string, opts?: Record<string, any>): Promise<any>;
+          yell(text: string): void;
+        }
+        fetch: typeof import('node-fetch');
+        exec: typeof exec;
+        $: typeof exec;
+        writeToFile(
+          fileName: string,
+          lineBuilderFn: ((fileLine: FileLine) => void) | string
+        ): void;
+        copyFile(src: string, dst: string): void;
+        stopOnFail(enable?: boolean): void;
+        ignoreFail(enable?: boolean): void;
+        buildCmd(cmd: string): (args: string) => Promise<any>;       
+        task(name: string | Function, fn?: Function): Promise<any>;
+      };
+    }
+  }
+}
+
+export {};

package/run.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env bun
-import program, { BUNOSHFILE, banner }  from "./src/program";
-import { existsSync, readFileSync } from "fs";
-import init from "./src/init";
-import path from "path";
-import { say, yell } from './src/io';
-
-const tasksFile = path.join(process.cwd(), BUNOSHFILE);
-
-if (!existsSync(tasksFile)) {
-  console.log(banner);
-
-  if (process.argv.includes('init')) {
-    init();
-    process.exit(0);
-  }
-
-  console.log();
-  console.error(`Bunosh file not found: ${tasksFile}`);
-  console.log("Run `bunosh init` to create a new bunosh tasks file here")
-  console.log();
-  process.ar
-  process.exit(1);
-}
-
-global.say = say;
-global.yell = yell;
-
-import(tasksFile).then((tasks) => {
-  program(tasks, readFileSync(tasksFile, "utf-8"));
-});

package/src/io.jsx

@@ -1,47 +0,0 @@
-import React, {useState, useEffect} from 'react';
-import { Box, Text } from 'ink';
-import { renderOnce, isStaticOutput} from './output';
-import Gradient from 'ink-gradient';
-import BigText from 'ink-big-text';
-import inquirer from 'inquirer';
-
-export function say(...args) {
-  if (isStaticOutput) {
-    console.log(...args);
-    return;
-  };
-
-  const colors = ['yellow', 'magenta', 'cyan', 'blue', 'blueBright', 'magentaBright', 'cyanBright', 'whiteBright'];
-
-  renderOnce(
-    <Box gap={1} height={20} overflow='hidden' >
-      <Text color='white'>!</Text>
-      {args.map((arg, i) => <Text color={colors[i]} key={i}>{arg}</Text>)}
-    </Box>
-  );
-}
-
-export async function ask(question, opts = {}) {
-
-  const answers = await inquirer.prompt({ name: question, message: question, ...opts })
-
-  return Object.values(answers)[0];
-}
-
-export function yell(text) {
-  if (isStaticOutput) {
-    console.log();
-    console.log(text.toUpperCase());
-    console.log();
-    return;
-  };
-
-  renderOnce(
-    <Box gap={1} marginLeft={1}>
-      <Gradient name="teen">
-        <BigText text={text}/>
-      </Gradient>
-
-    </Box>
-  );
-}

package/src/output.js

@@ -1,37 +0,0 @@
-import { render as inkRender } from 'ink';
-import debug from 'debug';
-
-export const isStaticOutput = process.env.CI || process.env.DEBUG || !process.stdout.isTTY;
-
-if (isStaticOutput) debug.enable('bunosh:*');
-
-let renderer = null;
-
-export function render(comp = <></>) {
-  
-  if (!renderer) {
-    renderer = inkRender(comp);
-    return renderer;
-  }
-
-  renderer.rerender(comp);
-  return renderer;
-}
-
-export async function renderOnce(comp) {
-  if (renderer) await renderer.waitUntilExit();
-  render(comp);
-  clearRenderer();
-}
-
-export function clearRenderer() {
-  if (!renderer) return;
-  renderer.unmount();
-  renderer = null;
-}
-
-
-export function debugTask(task, line) {
-  const ns = `bunosh:${task}`;
-  debug(ns)(line);
-}

package/src/task.jsx

@@ -1,209 +0,0 @@
-import React, {useState, useEffect} from 'react';
-import { Text, Box } from 'ink';
-import Spinner from 'ink-spinner';
-import { Timer } from 'timer-node';
-import { render, clearRenderer, renderOnce } from './output';
-
-export const TaskStatus = {  
-  RUNNING: 'running',
-  FAIL: 'fail',
-  SUCCESS: 'success'
-};
-
-export const tasksExecuted = [];
-
-
-let activeComponents = [];
-let activeTasks = [];
-
-let stopFailToggle = true;
-
-export function stopOnFail(enable = true) {
-  stopFailToggle = enable;
-}
-
-export function ignoreFail(enable = true) {
-  stopFailToggle = !enable;
-}
-
-const globalTimer = new Timer({ label: 'global', precision: 'ms'});
-globalTimer.start();
-process.on('exit', (code) => {
-  // we don't need this banner if no tasks were executed
-  if (!process.env.BUNOSH_COMMAND_STARTED) return;
-
-  globalTimer.stop();
-  const success = code === 0;
-  const tasksFailed = tasksExecuted.filter(ti => ti.result?.status === TaskStatus.FAIL).length;
-  renderOnce(<Box flexDirection='row' gap={2}>
-    <Text bold backgroundColor={!success && 'red'}>🍲
-      {success ? '' : 'FAIL '}
-    </Text>
-    <Text dimColor >Exit Code: <Text bold color={code === 0 ? 'green' : 'red'}>{code}</Text></Text>
-    <Text dimColor>Tasks executed: <Text bold>{tasksExecuted.length}</Text></Text>
-    {!!tasksFailed && <Text dimColor>Tasks failed: <Text bold color="red">{tasksFailed}</Text></Text>}
-    <Text dimColor>Time: <Text bold>{globalTimer.ms()}</Text>ms</Text>
-  </Box>);
-});
-
-export async function task(name, fn) {
-  let fnResult = null;
-
-  if (!fn) {
-    fn = name;
-    name = fn.toString().slice(0, 50).replace(/\s+/g, ' ').trim();
-  }
-
-  const promise = Promise.resolve(fn()).then((ret) => {
-    fnResult = ret;
-    return TaskResult.success(ret);
-  }).catch((err) => {    
-    return TaskResult.fail(err);
-  });
-  const taskInfo = new TaskInfo({ promise, kind: 'task', text: name });
-
-  const TaskOutput = () => {
-    const [output, setOutput] = useState(null);
-    useEffect(() => {
-      if (!fnResult?.toString) return;
-      promise.then(_ => setOutput(fnResult.toString()));
-    });
-
-    return <Box overflow='hidden' height={10} borderStyle="round" >
-      <Text dimColor={true}>{output}</Text>
-    </Box>
-  }
-  renderTask(taskInfo, <TaskOutput />);
-
-  await promise;
-  return fnResult;
-}
-
-function addToRender(comp) {
-  activeComponents.push(comp);
-  activeTasks.push(comp.props.taskInfo);
-    
-  if (activeComponents.length < 2) {
-    render(comp);
-    return;
-  }
-  render(<Box flexDirection='row' gap={1}>
-    {activeComponents}
-  </Box>);
-}
-
-function removeFromRender(taskInfo) {
-  activeTasks = activeTasks.filter((ti) => ti?.id !== taskInfo?.id);
-
-  if (activeTasks.length === 0) {
-    clearRenderer();
-    activeComponents = [];
-    return;
-  }
-}
-
-export const renderTask = async (taskInfo, children) => {
-  if (tasksExecuted.map(t => t.id).includes(taskInfo.id)) return; // alraday executed
-
-  tasksExecuted.push(taskInfo);
-  addToRender(<Task key={`${tasksExecuted.length}_${taskInfo}`} taskInfo={taskInfo}>{children}</Task>);
-};
-
-
-function Status({ taskStatus }) {
-  if (!taskStatus) return <Text dimColor>-</Text>;
-  if (taskStatus == TaskStatus.SUCCESS) return <Text color='green' bold>✓</Text>;
-  if (taskStatus == TaskStatus.FAIL) return <Text color='red' bold>×</Text>;
-}
-
-export const Task = ({ taskInfo, children }) => {
-  const timer = new Timer({ label: taskInfo.text, precision: 'ms'});
-
-  const [time, setTime] = useState(null);
-  const [status, setStatus] = useState(null);
-  
-  const { promise } = taskInfo;
-  timer.start();
-  
-  function updateTaskInfo(result) {
-    timer.stop();
-    taskInfo.result = result;
-    taskInfo.time = timer.ms();
-    setStatus(result.status);
-    setTime(timer.ms());
-    removeFromRender(taskInfo);
-
-    // hard exit, task has failed
-    if (result.status === TaskStatus.FAIL && stopFailToggle) {
-      process.exit(1);
-
-    }
-  }
-
-  useEffect(() => {    
-    promise.then((result) => {
-      updateTaskInfo(result)
-    }).catch((err) => {
-      updateTaskInfo(TaskResult.fail(err.toString()));
-    });
-  }, []);
-
-  return (<Box flexGrow={1} flexBasis="50%" flexDirection='column'>
-      <Box gap={1} flexDirection='row' alignItems='flex-start' justifyContent="flex-start">
-        <Status taskStatus={status} />
-
-        {taskInfo.titleComponent}
-
-        {taskInfo.extraText && <Text color='cyan' dimColor>{taskInfo.extraText}</Text>}
-
-        {time === null && <Spinner />}
-        {time !== null && <Text dimColor={true}>{time}ms</Text>}
-        
-      </Box>
-
-      {children}
-      </Box>
-  );
-};
-
-export class TaskInfo {
-  constructor({ promise, kind, text, extraText }) {
-    if (!kind) throw new Error('TaskInfo: kind is required');
-    if (!text) throw new Error('TaskInfo: text is required');
-
-    this.id = `${kind}-${text.slice(0,30).replace(/\s/g, '-')}-${Math.random().toString(36).substring(7)}`;
-    this.kind = kind;
-    this.text = text;
-    this.extraText = extraText;
-    this.promise = promise;
-    this.result = null;
-    this.time = null;
-  }
-
-  get titleComponent() {
-    return <>  
-      <Text bold>{this.kind}</Text>
-      <Text color='yellow'>{this.text}</Text>
-    </>;
-  }
-
-  toString() {
-    return `${this.kind} ${this.text}`;
-  }
-}
-
-export class TaskResult {
-  constructor({ status, output }) {
-    this.status = status;
-    this.output = output;
-  }
-
-  static fail(output = null) {
-    return new TaskResult({ status: TaskStatus.FAIL, output });
-  }
-
-  static success(output = null) {
-    return new TaskResult({ status: TaskStatus.SUCCESS, output });
-
-  }
-}

package/src/tasks/copyFile.jsx

@@ -1,14 +0,0 @@
-const { copySync } = require('fs-extra');
-import { task } from '../task.jsx';
-
-export default function copyFile(src, dst) {
-
-  task(`copy ${src} ⇒ ${dst}`, () => {
-    copySync(src, dst);
-  });
-
-}
-
-
-
-