@ecmaos/coreutils 0.3.1 → 0.4.2

package/src/commands/time.ts

@@ -0,0 +1,144 @@
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStderr } from '../shared/helpers.js'
+import path from 'path'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: time COMMAND [ARG]...
+Run COMMAND and print a summary of the real, user, and system time used.
+
+  --help  display this help and exit
+
+Note: This is a simplified version that measures real (wall clock) time.`
+  writelnStderr(process, terminal, usage)
+}
+
+function formatTime(seconds: number): string {
+  if (seconds < 1) {
+    return `${(seconds * 1000).toFixed(0)}ms`
+  }
+  if (seconds < 60) {
+    return `${seconds.toFixed(2)}s`
+  }
+  const mins = Math.floor(seconds / 60)
+  const secs = (seconds % 60).toFixed(2)
+  return `${mins}m${secs}s`
+}
+
+async function resolveCommand(shell: Shell, command: string): Promise<string | undefined> {
+  const DefaultShellPath = '$HOME/bin:/bin:/usr/bin:/usr/local/bin:/usr/local/sbin:/usr/sbin:/sbin'
+  
+  if (command.startsWith('./')) {
+    const cwdCommand = path.join(shell.cwd, command.slice(2))
+    if (await shell.context.fs.promises.exists(cwdCommand)) {
+      return cwdCommand
+    }
+    return undefined
+  }
+
+  const paths = shell.env.get('PATH')?.split(':') || DefaultShellPath.split(':')
+  const resolvedCommand = path.resolve(command)
+
+  if (await shell.context.fs.promises.exists(resolvedCommand)) {
+    return resolvedCommand
+  }
+
+  for (const pathDir of paths) {
+    const expandedPath = pathDir.replace(/\$([A-Z_]+)/g, (_, name) => shell.env.get(name) || '')
+    const fullPath = `${expandedPath}/${command}`
+    if (await shell.context.fs.promises.exists(fullPath)) return fullPath
+  }
+
+  return undefined
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'time',
+    description: 'Measure command execution time',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (!process) return 1
+
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      if (argv.length === 0 || !argv[0]) {
+        await writelnStderr(process, terminal, 'time: missing command')
+        await writelnStderr(process, terminal, "Try 'time --help' for more information.")
+        return 1
+      }
+
+      const command = argv[0]
+      const commandArgs = argv.slice(1)
+
+      const resolvedCommand = await resolveCommand(shell, command)
+      if (!resolvedCommand) {
+        await writelnStderr(process, terminal, `time: command not found: ${command}`)
+        return 127
+      }
+
+      const startTime = performance.now()
+
+      const subcommandStdout = new WritableStream<Uint8Array>({
+        write: async (chunk) => {
+          const writer = process.stdout.getWriter()
+          try {
+            await writer.write(chunk)
+          } finally {
+            writer.releaseLock()
+          }
+        }
+      })
+
+      const subcommandStderr = new WritableStream<Uint8Array>({
+        write: async (chunk) => {
+          const writer = process.stderr.getWriter()
+          try {
+            await writer.write(chunk)
+          } finally {
+            writer.releaseLock()
+          }
+        }
+      })
+
+      try {
+        const exitCode = await kernel.execute({
+          command: resolvedCommand,
+          args: commandArgs,
+          shell: shell,
+          terminal: terminal,
+          stdin: process.stdin,
+          stdout: subcommandStdout,
+          stderr: subcommandStderr
+        })
+
+        const endTime = performance.now()
+        const elapsedSeconds = (endTime - startTime) / 1000
+
+        await writelnStderr(process, terminal, `\nreal    ${formatTime(elapsedSeconds)}`)
+        await writelnStderr(process, terminal, `user    ${formatTime(elapsedSeconds)}`)
+        await writelnStderr(process, terminal, `sys     ${formatTime(0)}`)
+
+        return exitCode
+      } catch (error) {
+        const endTime = performance.now()
+        const elapsedSeconds = (endTime - startTime) / 1000
+
+        await writelnStderr(process, terminal, `\nreal    ${formatTime(elapsedSeconds)}`)
+        await writelnStderr(process, terminal, `user    ${formatTime(elapsedSeconds)}`)
+        await writelnStderr(process, terminal, `sys     ${formatTime(0)}`)
+
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        await writelnStderr(process, terminal, `time: ${errorMessage}`)
+        return 1
+      }
+    }
+  })
+}

package/src/commands/umount.ts

@@ -0,0 +1,116 @@
+import path from 'path'
+import chalk from 'chalk'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: umount [OPTIONS] TARGET
+       umount [-a|--all]
+
+Unmount a filesystem.
+
+Options:
+  -a, --all    unmount all filesystems (except root)
+  --help       display this help and exit
+
+Examples:
+  umount /mnt/tmp        unmount filesystem at /mnt/tmp
+  umount -a              unmount all filesystems`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'umount',
+    description: 'Unmount a filesystem',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      let allMode = false
+      const positionalArgs: string[] = []
+
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (arg === '-a' || arg === '--all') {
+          allMode = true
+        } else if (arg && !arg.startsWith('-')) {
+          positionalArgs.push(arg)
+        }
+      }
+
+
+      if (allMode) {
+        const mountList = Array.from(kernel.filesystem.mounts.keys())
+        let unmountedCount = 0
+        let errorCount = 0
+
+        for (const target of mountList) {
+          if (target === '/') continue
+
+          try {
+            kernel.filesystem.fsSync.umount(target)
+            unmountedCount++
+            await writelnStdout(process, terminal, chalk.green(`Unmounted ${target}`))
+          } catch (error) {
+            errorCount++
+            await writelnStderr(process, terminal, chalk.red(`umount: failed to unmount ${target}: ${error instanceof Error ? error.message : 'Unknown error'}`))
+          }
+        }
+
+        if (unmountedCount === 0 && errorCount === 0) {
+          await writelnStdout(process, terminal, 'No filesystems to unmount.')
+        }
+
+        return errorCount > 0 ? 1 : 0
+      }
+
+      if (positionalArgs.length === 0) {
+        await writelnStderr(process, terminal, chalk.red('umount: missing target argument'))
+        await writelnStderr(process, terminal, 'Try \'umount --help\' for more information.')
+        return 1
+      }
+
+      if (positionalArgs.length > 1) {
+        await writelnStderr(process, terminal, chalk.red('umount: too many arguments'))
+        await writelnStderr(process, terminal, 'Try \'umount --help\' for more information.')
+        return 1
+      }
+
+      const targetArg = positionalArgs[0]
+      if (!targetArg) {
+        await writelnStderr(process, terminal, chalk.red('umount: missing target argument'))
+        return 1
+      }
+      const target = path.resolve(shell.cwd, targetArg)
+
+      if (target === '/') {
+        await writelnStderr(process, terminal, chalk.red('umount: cannot unmount root filesystem'))
+        return 1
+      }
+
+      const mountList = Array.from(kernel.filesystem.mounts.keys())
+      if (!mountList.includes(target)) {
+        await writelnStderr(process, terminal, chalk.red(`umount: ${target} is not mounted`))
+        return 1
+      }
+
+      try {
+        kernel.filesystem.fsSync.umount(target)
+        await writelnStdout(process, terminal, chalk.green(`Unmounted ${target}`))
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, chalk.red(`umount: failed to unmount ${target}: ${error instanceof Error ? error.message : 'Unknown error'}`))
+        return 1
+      }
+    }
+  })
+}

package/src/commands/uname.ts

@@ -0,0 +1,130 @@
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStderr, writelnStdout } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: uname [OPTION]...
+Print system information.
+
+  -a, --all                print all information
+  -s, --kernel-name        print the kernel name
+  -n, --nodename           print the network node hostname
+  -r, --kernel-release     print the kernel release
+  -v, --kernel-version     print the kernel version
+  -m, --machine            print the machine hardware name
+  -p, --processor          print the processor type
+  -i, --hardware-platform  print the hardware platform
+  -o, --operating-system   print the operating system
+  --help                   display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'uname',
+    description: 'Print system information',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (!process) return 1
+
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      let showAll = false
+      let showKernelName = false
+      let showNodename = false
+      let showKernelRelease = false
+      let showKernelVersion = false
+      let showMachine = false
+      let showProcessor = false
+      let showHardwarePlatform = false
+      let showOperatingSystem = false
+
+      for (const arg of argv) {
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-a' || arg === '--all') {
+          showAll = true
+        } else if (arg === '-s' || arg === '--kernel-name') {
+          showKernelName = true
+        } else if (arg === '-n' || arg === '--nodename') {
+          showNodename = true
+        } else if (arg === '-r' || arg === '--kernel-release') {
+          showKernelRelease = true
+        } else if (arg === '-v' || arg === '--kernel-version') {
+          showKernelVersion = true
+        } else if (arg === '-m' || arg === '--machine') {
+          showMachine = true
+        } else if (arg === '-p' || arg === '--processor') {
+          showProcessor = true
+        } else if (arg === '-i' || arg === '--hardware-platform') {
+          showHardwarePlatform = true
+        } else if (arg === '-o' || arg === '--operating-system') {
+          showOperatingSystem = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('a')) showAll = true
+          if (flags.includes('s')) showKernelName = true
+          if (flags.includes('n')) showNodename = true
+          if (flags.includes('r')) showKernelRelease = true
+          if (flags.includes('v')) showKernelVersion = true
+          if (flags.includes('m')) showMachine = true
+          if (flags.includes('p')) showProcessor = true
+          if (flags.includes('i')) showHardwarePlatform = true
+          if (flags.includes('o')) showOperatingSystem = true
+          const invalidFlags = flags.filter(f => !['a', 's', 'n', 'r', 'v', 'm', 'p', 'i', 'o'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `uname: invalid option -- '${invalidFlags[0]}'`)
+            await writelnStderr(process, terminal, "Try 'uname --help' for more information.")
+            return 1
+          }
+        }
+      }
+
+      const highEntropyValues = await navigator.userAgentData?.getHighEntropyValues([
+        "architecture",
+        "bitness",
+        "formFactor",
+        "fullVersionList",
+        "model",
+        "platformVersion",
+        "wow64"
+      ]) ?? {}
+
+      const kernelName = kernel.name
+      const kernelVersion = kernel.version
+      const nodename = typeof window !== 'undefined' ? window.location.hostname : 'localhost'
+      const machine = navigator.userAgentData?.platform || navigator.platform || 'unknown'
+      const processor = highEntropyValues.architecture || 'unknown'
+      const hardwarePlatform = highEntropyValues.model || 'unknown'
+      const operatingSystem = kernelName
+
+      if (showAll || (!showKernelName && !showNodename && !showKernelRelease && !showKernelVersion && !showMachine && !showProcessor && !showHardwarePlatform && !showOperatingSystem)) {
+        const output = `${kernelName} ${nodename} ${kernelVersion} ${machine} ${processor} ${hardwarePlatform} ${operatingSystem}`
+        await writelnStdout(process, terminal, output)
+      } else {
+        const parts: string[] = []
+        if (showAll || showKernelName) parts.push(kernelName)
+        if (showAll || showNodename) parts.push(nodename)
+        if (showAll || showKernelRelease) parts.push(kernelVersion)
+        if (showAll || showKernelVersion) parts.push(kernelVersion)
+        if (showAll || showMachine) parts.push(machine)
+        if (showAll || showProcessor) parts.push(processor)
+        if (showAll || showHardwarePlatform) parts.push(hardwarePlatform)
+        if (showAll || showOperatingSystem) parts.push(operatingSystem)
+        await writelnStdout(process, terminal, parts.join(' '))
+      }
+
+      return 0
+    }
+  })
+}

package/src/commands/unexpand.ts

@@ -0,0 +1,305 @@
+import path from 'path'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalEvents } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStderr } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: unexpand [OPTION]... [FILE]...
+Convert spaces to tabs in each FILE.
+
+  -t, --tabs=NUMBER     have tabs NUMBER characters apart, not 8
+  -t, --tabs=LIST      use comma separated list of tab positions
+  -a, --all            convert all spaces, not just leading spaces
+  --help               display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function parseTabStops(tabStr: string): number[] {
+  if (tabStr.includes(',')) {
+    const stops = tabStr.split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n) && n > 0)
+    return stops.length > 0 ? stops : [8]
+  }
+  const single = parseInt(tabStr, 10)
+  return !isNaN(single) && single > 0 ? [single] : [8]
+}
+
+function unexpandTabs(line: string, tabStops: number[], all: boolean): string {
+  if (all) {
+    return unexpandAllSpaces(line, tabStops)
+  } else {
+    return unexpandLeadingSpaces(line, tabStops)
+  }
+}
+
+function getNextTabStop(column: number, tabStops: number[]): number {
+  if (tabStops.length === 1) {
+    const interval = tabStops[0] ?? 8
+    return Math.ceil((column + 1) / interval) * interval
+  }
+
+  for (const stop of tabStops) {
+    if (stop > column) {
+      return stop
+    }
+  }
+
+  const lastStop = tabStops[tabStops.length - 1]
+  let nextStop = lastStop ?? 8
+  while (nextStop <= column) {
+    nextStop += lastStop ?? 8
+  }
+  return nextStop
+}
+
+function unexpandLeadingSpaces(line: string, tabStops: number[]): string {
+  let leadingSpaces = 0
+  let i = 0
+
+  while (i < line.length && line[i] === ' ') {
+    leadingSpaces++
+    i++
+  }
+
+  if (leadingSpaces === 0) {
+    return line
+  }
+
+  let result = ''
+  let column = 0
+  let spaceIdx = 0
+
+  while (spaceIdx < leadingSpaces) {
+    const nextStop = getNextTabStop(column, tabStops)
+    const spacesToNextStop = nextStop - column
+    const remainingSpaces = leadingSpaces - spaceIdx
+
+    if (spacesToNextStop <= remainingSpaces) {
+      result += '\t'
+      column = nextStop
+      spaceIdx += spacesToNextStop
+    } else {
+      result += ' '
+      column++
+      spaceIdx++
+    }
+  }
+
+  return result + line.slice(leadingSpaces)
+}
+
+function unexpandAllSpaces(line: string, tabStops: number[]): string {
+  let result = ''
+  let column = 0
+  let spaceCount = 0
+  let spaceStartColumn = 0
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i]
+
+    if (char === ' ') {
+      if (spaceCount === 0) {
+        spaceStartColumn = column
+      }
+      spaceCount++
+      column++
+    } else {
+      if (spaceCount > 0) {
+        result += convertSpacesToTabs(spaceStartColumn, spaceCount, tabStops)
+        spaceCount = 0
+      }
+
+      result += char
+      if (char === '\n' || char === '\r') {
+        column = 0
+      } else {
+        column++
+      }
+    }
+  }
+
+  if (spaceCount > 0) {
+    result += ' '.repeat(spaceCount)
+  }
+
+  return result
+}
+
+function convertSpacesToTabs(startColumn: number, spaceCount: number, tabStops: number[]): string {
+  let result = ''
+  let column = startColumn
+  let spaceIdx = 0
+
+  while (spaceIdx < spaceCount) {
+    const nextStop = getNextTabStop(column, tabStops)
+    const spacesToNextStop = nextStop - column
+    const remainingSpaces = spaceCount - spaceIdx
+
+    if (spacesToNextStop <= remainingSpaces && spacesToNextStop > 1) {
+      result += '\t'
+      column = nextStop
+      spaceIdx += spacesToNextStop
+    } else if (spacesToNextStop === 1 && remainingSpaces >= 1) {
+      result += '\t'
+      column = nextStop
+      spaceIdx += 1
+    } else {
+      result += ' '
+      column++
+      spaceIdx++
+    }
+  }
+
+  return result
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'unexpand',
+    description: 'Convert spaces to tabs',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (!process) return 1
+
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      let tabStops: number[] = [8]
+      let all = false
+      const files: string[] = []
+
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-t' || arg === '--tabs') {
+          if (i + 1 < argv.length) {
+            const tabStr = argv[++i]
+            if (tabStr !== undefined) {
+              tabStops = parseTabStops(tabStr)
+            }
+          }
+        } else if (arg.startsWith('--tabs=')) {
+          const tabStr = arg.slice(7)
+          tabStops = parseTabStops(tabStr)
+        } else if (arg.startsWith('-t')) {
+          const tabStr = arg.slice(2)
+          if (tabStr) {
+            tabStops = parseTabStops(tabStr)
+          }
+        } else if (arg === '-a' || arg === '--all') {
+          all = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('a')) all = true
+          const invalidFlags = flags.filter(f => f !== 'a')
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `unexpand: invalid option -- '${invalidFlags[0]}'`)
+            await writelnStderr(process, terminal, "Try 'unexpand --help' for more information.")
+            return 1
+          }
+        } else {
+          files.push(arg)
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        let lines: string[] = []
+
+        if (files.length === 0) {
+          if (!process.stdin) {
+            return 0
+          }
+
+          const reader = process.stdin.getReader()
+          const decoder = new TextDecoder()
+          let buffer = ''
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+              if (value) {
+                buffer += decoder.decode(value, { stream: true })
+                const newLines = buffer.split('\n')
+                buffer = newLines.pop() || ''
+                lines.push(...newLines)
+              }
+            }
+            if (buffer) {
+              lines.push(buffer)
+            }
+          } finally {
+            reader.releaseLock()
+          }
+        } else {
+          for (const file of files) {
+            const fullPath = path.resolve(shell.cwd, file)
+
+            let interrupted = false
+            const interruptHandler = () => { interrupted = true }
+            kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+            try {
+              if (fullPath.startsWith('/dev')) {
+                await writelnStderr(process, terminal, `unexpand: ${file}: cannot process device files`)
+                continue
+              }
+
+              const handle = await shell.context.fs.promises.open(fullPath, 'r')
+              const stat = await shell.context.fs.promises.stat(fullPath)
+
+              const decoder = new TextDecoder()
+              let content = ''
+              let bytesRead = 0
+              const chunkSize = 1024
+
+              while (bytesRead < stat.size) {
+                if (interrupted) break
+                const data = new Uint8Array(chunkSize)
+                const readSize = Math.min(chunkSize, stat.size - bytesRead)
+                await handle.read(data, 0, readSize, bytesRead)
+                const chunk = data.subarray(0, readSize)
+                content += decoder.decode(chunk, { stream: true })
+                bytesRead += readSize
+              }
+
+              const fileLines = content.split('\n')
+              if (fileLines[fileLines.length - 1] === '') {
+                fileLines.pop()
+              }
+              lines.push(...fileLines)
+            } catch (error) {
+              await writelnStderr(process, terminal, `unexpand: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        for (const line of lines) {
+          const unexpanded = unexpandTabs(line, tabStops, all)
+          await writer.write(new TextEncoder().encode(unexpanded + '\n'))
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `unexpand: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}