@ecmaos/coreutils 0.4.0 → 0.4.2

package/src/commands/shuf.ts

@@ -0,0 +1,218 @@
+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: shuf [OPTION]... [FILE]
+Write a random permutation of the input lines to standard output.
+
+  -n, --head-count=COUNT    output at most COUNT lines
+  -e, --echo                treat each ARG as an input line
+  -i, --input-range=LO-HI   treat each number LO through HI as an input line
+  --help                    display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function shuffleArray<T>(array: T[]): T[] {
+  const shuffled = [...array]
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [shuffled[i]!, shuffled[j]!] = [shuffled[j]!, shuffled[i]!]
+  }
+  return shuffled
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'shuf',
+    description: 'Write a random permutation of the input lines',
+    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 headCount: number | null = null
+      let echo = false
+      let inputRange: string | undefined
+      const files: string[] = []
+      const echoArgs: 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 === '-n' || arg === '--head-count') {
+          if (i + 1 < argv.length) {
+            const countStr = argv[++i]
+            if (countStr !== undefined) {
+              const parsed = parseInt(countStr, 10)
+              if (!isNaN(parsed) && parsed > 0) {
+                headCount = parsed
+              } else {
+                await writelnStderr(process, terminal, `shuf: invalid line count: ${countStr}`)
+                return 1
+              }
+            }
+          }
+        } else if (arg.startsWith('--head-count=')) {
+          const countStr = arg.slice(13)
+          const parsed = parseInt(countStr, 10)
+          if (!isNaN(parsed) && parsed > 0) {
+            headCount = parsed
+          } else {
+            await writelnStderr(process, terminal, `shuf: invalid line count: ${countStr}`)
+            return 1
+          }
+        } else if (arg.startsWith('-n')) {
+          const countStr = arg.slice(2)
+          if (countStr) {
+            const parsed = parseInt(countStr, 10)
+            if (!isNaN(parsed) && parsed > 0) {
+              headCount = parsed
+            } else {
+              await writelnStderr(process, terminal, `shuf: invalid line count: ${countStr}`)
+              return 1
+            }
+          }
+        } else if (arg === '-e' || arg === '--echo') {
+          echo = true
+        } else if (arg === '-i' || arg === '--input-range') {
+          if (i + 1 < argv.length) {
+            inputRange = argv[++i]
+          }
+        } else if (arg.startsWith('--input-range=')) {
+          inputRange = arg.slice(15)
+        } else if (arg.startsWith('-i')) {
+          inputRange = arg.slice(2)
+        } else if (!arg.startsWith('-')) {
+          if (echo) {
+            echoArgs.push(arg)
+          } else {
+            files.push(arg)
+          }
+        } else {
+          await writelnStderr(process, terminal, `shuf: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'shuf --help' for more information.")
+          return 1
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        let lines: string[] = []
+
+        if (inputRange) {
+          const [loStr, hiStr] = inputRange.split('-')
+          const lo = parseInt(loStr ?? '0', 10)
+          const hi = parseInt(hiStr ?? '0', 10)
+          if (isNaN(lo) || isNaN(hi) || lo > hi) {
+            await writelnStderr(process, terminal, `shuf: invalid input range: ${inputRange}`)
+            return 1
+          }
+          for (let i = lo; i <= hi; i++) {
+            lines.push(i.toString())
+          }
+        } else if (echo && echoArgs.length > 0) {
+          lines = echoArgs
+        } else 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, `shuf: ${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, `shuf: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        const shuffled = shuffleArray(lines)
+        const output = headCount !== null ? shuffled.slice(0, headCount) : shuffled
+
+        for (const line of output) {
+          await writer.write(new TextEncoder().encode(line + '\n'))
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `shuf: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/sleep.ts

@@ -0,0 +1,109 @@
+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: sleep NUMBER[SUFFIX]...
+Pause for NUMBER seconds.  SUFFIX may be 's' for seconds (the default),
+'m' for minutes, 'h' for hours or 'd' for days.
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function parseDuration(value: string): number {
+  const match = value.match(/^([0-9]+(?:\.[0-9]+)?)([smhd]?)$/)
+  if (!match?.[1]) return NaN
+
+  const num = parseFloat(match[1])
+  if (isNaN(num)) return NaN
+
+  const suffix = match[2] || 's'
+  switch (suffix) {
+    case 's':
+      return num * 1000
+    case 'm':
+      return num * 60 * 1000
+    case 'h':
+      return num * 60 * 60 * 1000
+    case 'd':
+      return num * 24 * 60 * 60 * 1000
+    default:
+      return NaN
+  }
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'sleep',
+    description: 'Delay for a specified amount of 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) {
+        await writelnStderr(process, terminal, 'sleep: missing operand')
+        await writelnStderr(process, terminal, "Try 'sleep --help' for more information.")
+        return 1
+      }
+
+      let totalDuration = 0
+
+      for (const arg of argv) {
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg.startsWith('-')) {
+          await writelnStderr(process, terminal, `sleep: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'sleep --help' for more information.")
+          return 1
+        } else {
+          const duration = parseDuration(arg)
+          if (isNaN(duration)) {
+            await writelnStderr(process, terminal, `sleep: invalid time interval '${arg}'`)
+            return 1
+          }
+          totalDuration += duration
+        }
+      }
+
+      if (totalDuration <= 0) return 0
+
+      let interrupted = false
+      const interruptHandler = () => { interrupted = true }
+      terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+      try {
+        await new Promise<void>((resolve) => {
+          const timeoutId = setTimeout(() => resolve(), totalDuration)
+
+          if (interrupted) {
+            clearTimeout(timeoutId)
+            resolve()
+          }
+        })
+      } catch (error) {
+        if (!interrupted) {
+          await writelnStderr(process, terminal, `sleep: ${error instanceof Error ? error.message : 'Unknown error'}`)
+          return 1
+        }
+      } finally {
+        terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+      }
+
+      return interrupted ? 130 : 0
+    }
+  })
+}

package/src/commands/strings.ts

@@ -0,0 +1,176 @@
+import path from 'path'
+import type { Kernel, Process, Shell, Terminal } 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: strings [OPTION]... [FILE]...
+Print the sequences of printable characters in files.
+
+  -n, --bytes=MIN_LEN    print sequences of at least MIN_LEN characters (default: 4)
+  --help                 display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function extractStrings(data: Uint8Array, minLen: number): string[] {
+  const strings: string[] = []
+  let currentString = ''
+  
+  for (let i = 0; i < data.length; i++) {
+    const byte = data[i]
+    if (byte === undefined) continue
+    
+    if (byte >= 32 && byte <= 126) {
+      currentString += String.fromCharCode(byte)
+    } else {
+      if (currentString.length >= minLen) {
+        strings.push(currentString)
+      }
+      currentString = ''
+    }
+  }
+  
+  if (currentString.length >= minLen) {
+    strings.push(currentString)
+  }
+  
+  return strings
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'strings',
+    description: 'Print the sequences of printable characters in files',
+    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 minLen = 4
+      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 === '-n' || arg === '--bytes') {
+          if (i + 1 < argv.length) {
+            const lenStr = argv[++i]
+            if (lenStr !== undefined) {
+              const parsed = parseInt(lenStr, 10)
+              if (!isNaN(parsed) && parsed > 0) {
+                minLen = parsed
+              } else {
+                await writelnStderr(process, terminal, `strings: invalid minimum length: ${lenStr}`)
+                return 1
+              }
+            }
+          }
+        } else if (arg.startsWith('--bytes=')) {
+          const lenStr = arg.slice(8)
+          const parsed = parseInt(lenStr, 10)
+          if (!isNaN(parsed) && parsed > 0) {
+            minLen = parsed
+          } else {
+            await writelnStderr(process, terminal, `strings: invalid minimum length: ${lenStr}`)
+            return 1
+          }
+        } else if (arg.startsWith('-n')) {
+          const lenStr = arg.slice(2)
+          if (lenStr) {
+            const parsed = parseInt(lenStr, 10)
+            if (!isNaN(parsed) && parsed > 0) {
+              minLen = parsed
+            } else {
+              await writelnStderr(process, terminal, `strings: invalid minimum length: ${lenStr}`)
+              return 1
+            }
+          }
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        } else {
+          await writelnStderr(process, terminal, `strings: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'strings --help' for more information.")
+          return 1
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        if (files.length === 0) {
+          if (!process.stdin) {
+            return 0
+          }
+
+          const reader = process.stdin.getReader()
+          const chunks: Uint8Array[] = []
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+              if (value) {
+                chunks.push(value)
+              }
+            }
+          } finally {
+            reader.releaseLock()
+          }
+
+          const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
+          const data = new Uint8Array(totalLength)
+          let offset = 0
+          for (const chunk of chunks) {
+            data.set(chunk, offset)
+            offset += chunk.length
+          }
+
+          const extractedStrings = extractStrings(data, minLen)
+          for (const str of extractedStrings) {
+            await writer.write(new TextEncoder().encode(str + '\n'))
+          }
+
+          return 0
+        }
+
+        for (const file of files) {
+          const fullPath = path.resolve(shell.cwd, file)
+
+          try {
+            if (fullPath.startsWith('/dev')) {
+              await writelnStderr(process, terminal, `strings: ${file}: cannot process device files`)
+              continue
+            }
+
+            const data = await shell.context.fs.promises.readFile(fullPath)
+            const extractedStrings = extractStrings(new Uint8Array(data), minLen)
+            for (const str of extractedStrings) {
+              await writer.write(new TextEncoder().encode(str + '\n'))
+            }
+          } catch (error) {
+            await writelnStderr(process, terminal, `strings: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+          }
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `strings: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/tac.ts

@@ -0,0 +1,138 @@
+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: tac [OPTION]... [FILE]...
+Write each FILE to standard output, last line first.
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'tac',
+    description: 'Write each FILE to standard output, last line first',
+    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
+      }
+
+      const files: string[] = []
+
+      for (const arg of argv) {
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        } else {
+          await writelnStderr(process, terminal, `tac: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'tac --help' for more information.")
+          return 1
+        }
+      }
+
+      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, `tac: ${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, `tac: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        for (let i = lines.length - 1; i >= 0; i--) {
+          await writer.write(new TextEncoder().encode(lines[i] + '\n'))
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `tac: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}