@ecmaos/coreutils 0.3.1 → 0.4.2

package/src/commands/printf.ts

@@ -0,0 +1,271 @@
+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: printf FORMAT [ARGUMENT]...
+Format and print ARGUMENT(s) according to FORMAT.
+
+FORMAT controls the output as in C printf.  Interpreted sequences:
+
+  \\\\     backslash
+  \\a      alert (BEL)
+  \\b      backspace
+  \\c      produce no further output
+  \\e      escape
+  \\f      form feed
+  \\n      new line
+  \\r      carriage return
+  \\t      horizontal tab
+  \\v      vertical tab
+  \\0NNN   byte with octal value NNN (1 to 3 digits)
+  \\xHH    byte with hexadecimal value HH (1 to 2 digits)
+
+Conversion specifiers:
+
+  %b      ARGUMENT as a string with '\\' escapes interpreted
+  %c      ARGUMENT as a single character
+  %d      ARGUMENT as a signed decimal integer
+  %i      ARGUMENT as a signed decimal integer
+  %o      ARGUMENT as an unsigned octal number
+  %s      ARGUMENT as a string
+  %u      ARGUMENT as an unsigned decimal integer
+  %x      ARGUMENT as an unsigned hexadecimal number (lowercase)
+  %X      ARGUMENT as an unsigned hexadecimal number (uppercase)
+  %%      a single %
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function interpretEscapes(text: string): string {
+  let result = ''
+  let i = 0
+  
+  while (i < text.length) {
+    if (text[i] === '\\' && i + 1 < text.length) {
+      const next = text[i + 1]
+      switch (next) {
+        case '\\':
+          result += '\\'
+          i += 2
+          break
+        case 'a':
+          result += '\x07'
+          i += 2
+          break
+        case 'b':
+          result += '\b'
+          i += 2
+          break
+        case 'c':
+          return result
+        case 'e':
+        case 'E':
+          result += '\x1b'
+          i += 2
+          break
+        case 'f':
+          result += '\f'
+          i += 2
+          break
+        case 'n':
+          result += '\n'
+          i += 2
+          break
+        case 'r':
+          result += '\r'
+          i += 2
+          break
+        case 't':
+          result += '\t'
+          i += 2
+          break
+        case 'v':
+          result += '\v'
+          i += 2
+          break
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7': {
+          let octal = ''
+          let j = i + 1
+          while (j < text.length && j < i + 4) {
+            const char = text[j]
+            if (char && /[0-7]/.test(char)) {
+              octal += char
+              j++
+            } else {
+              break
+            }
+          }
+          if (octal) {
+            result += String.fromCharCode(parseInt(octal, 8))
+            i = j
+          } else {
+            result += text[i]
+            i++
+          }
+          break
+        }
+        case 'x': {
+          let hex = ''
+          let j = i + 2
+          while (j < text.length && j < i + 4) {
+            const char = text[j]
+            if (char && /[0-9a-fA-F]/.test(char)) {
+              hex += char
+              j++
+            } else {
+              break
+            }
+          }
+          if (hex) {
+            result += String.fromCharCode(parseInt(hex, 16))
+            i = j
+          } else {
+            result += text[i]
+            i++
+          }
+          break
+        }
+        default:
+          result += text[i]
+          i++
+          break
+      }
+    } else {
+      result += text[i]
+      i++
+    }
+  }
+  
+  return result
+}
+
+function formatValue(format: string, value: string): string {
+  switch (format) {
+    case '%b':
+      return interpretEscapes(value)
+    case '%c': {
+      const num = parseInt(value, 10)
+      if (!isNaN(num)) {
+        return String.fromCharCode(num)
+      }
+      return value[0] || ''
+    }
+    case '%d':
+    case '%i': {
+      const num = parseInt(value, 10)
+      return isNaN(num) ? '0' : num.toString()
+    }
+    case '%o': {
+      const num = parseInt(value, 10)
+      return isNaN(num) ? '0' : num.toString(8)
+    }
+    case '%s':
+      return value
+    case '%u': {
+      const num = parseInt(value, 10)
+      if (isNaN(num)) return '0'
+      const unsigned = num >>> 0
+      return unsigned.toString()
+    }
+    case '%x': {
+      const num = parseInt(value, 10)
+      return isNaN(num) ? '0' : (num >>> 0).toString(16)
+    }
+    case '%X': {
+      const num = parseInt(value, 10)
+      return isNaN(num) ? '0' : (num >>> 0).toString(16).toUpperCase()
+    }
+    case '%%':
+      return '%'
+    default:
+      return format
+  }
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'printf',
+    description: 'Format and print data',
+    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, 'printf: missing format string')
+        await writelnStderr(process, terminal, "Try 'printf --help' for more information.")
+        return 1
+      }
+
+      const format = argv[0] || ''
+      const args = argv.slice(1)
+
+      let result = ''
+      let argIndex = 0
+      let i = 0
+
+      while (i < format.length) {
+        if (format[i] === '%' && i + 1 < format.length) {
+          const next = format[i + 1]
+          if (next === '%') {
+            result += '%'
+            i += 2
+          } else {
+            const specifier = `%${next}`
+            if (argIndex < args.length) {
+              result += formatValue(specifier, args[argIndex] || '')
+              argIndex++
+            } else {
+              result += specifier
+            }
+            i += 2
+          }
+        } else if (format[i] === '\\' && i + 1 < format.length) {
+          const escapeSeq = format.slice(i)
+          const match = escapeSeq.match(/^\\([\\abceEfnrtv]|x[0-9a-fA-F]{1,2}|0[0-7]{1,3})/)
+          if (match) {
+            const escaped = interpretEscapes(match[0])
+            result += escaped
+            i += match[0].length
+          } else {
+            result += format[i]
+            i++
+          }
+        } else {
+          result += format[i]
+          i++
+        }
+      }
+
+      if (process.stdout) {
+        const writer = process.stdout.getWriter()
+        try {
+          await writer.write(new TextEncoder().encode(result))
+        } finally {
+          writer.releaseLock()
+        }
+      } else {
+        terminal.write(result)
+      }
+
+      return 0
+    }
+  })
+}

package/src/commands/readlink.ts

@@ -0,0 +1,102 @@
+import path from 'path'
+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: readlink [OPTION]... FILE...
+Print value of a symbolic link or canonical file name.
+
+  -f, --canonicalize      canonicalize by following every symlink in every component
+  -e, --canonicalize-existing  canonicalize by following every symlink in every component that exists
+  -m, --canonicalize-missing   canonicalize by following every symlink in every component, without requirements on components existence
+  --help                  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'readlink',
+    description: 'Print value of a symbolic link or canonical file name',
+    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 canonicalize = false
+      let canonicalizeExisting = false
+      let canonicalizeMissing = false
+      const files: string[] = []
+
+      for (const arg of argv) {
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-f' || arg === '--canonicalize') {
+          canonicalize = true
+        } else if (arg === '-e' || arg === '--canonicalize-existing') {
+          canonicalizeExisting = true
+        } else if (arg === '-m' || arg === '--canonicalize-missing') {
+          canonicalizeMissing = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('f')) canonicalize = true
+          if (flags.includes('e')) canonicalizeExisting = true
+          if (flags.includes('m')) canonicalizeMissing = true
+          const invalidFlags = flags.filter(f => !['f', 'e', 'm'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `readlink: invalid option -- '${invalidFlags[0]}'`)
+            await writelnStderr(process, terminal, "Try 'readlink --help' for more information.")
+            return 1
+          }
+        } else {
+          files.push(arg)
+        }
+      }
+
+      if (files.length === 0) {
+        await writelnStderr(process, terminal, 'readlink: missing operand')
+        await writelnStderr(process, terminal, "Try 'readlink --help' for more information.")
+        return 1
+      }
+
+      let hasError = false
+
+      for (const file of files) {
+        const fullPath = path.resolve(shell.cwd, file)
+
+        try {
+          if (canonicalize || canonicalizeExisting || canonicalizeMissing) {
+            const resolved = path.resolve(fullPath)
+            await writelnStdout(process, terminal, resolved)
+          } else {
+            const linkTarget = await shell.context.fs.promises.readlink(fullPath)
+            await writelnStdout(process, terminal, linkTarget)
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error)
+          if (errorMessage.includes('not a symlink') || errorMessage.includes('EINVAL')) {
+            await writelnStderr(process, terminal, `readlink: ${file}: invalid symlink`)
+          } else if (errorMessage.includes('ENOENT') || errorMessage.includes('not found')) {
+            await writelnStderr(process, terminal, `readlink: ${file}: No such file or directory`)
+          } else {
+            await writelnStderr(process, terminal, `readlink: ${file}: ${errorMessage}`)
+          }
+          hasError = true
+        }
+      }
+
+      return hasError ? 1 : 0
+    }
+  })
+}

package/src/commands/realpath.ts

@@ -0,0 +1,126 @@
+import path from 'path'
+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: realpath [OPTION]... FILE...
+Print the resolved absolute file name.
+
+  -e, --canonicalize-existing  all components of the path must exist
+  -q, --quiet                  suppress most error messages
+  --help                       display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+async function resolveRealPath(
+  fs: typeof import('@zenfs/core').fs.promises,
+  filePath: string,
+  canonicalizeExisting: boolean,
+  quiet: boolean
+): Promise<string | null> {
+  try {
+    const resolved = path.resolve(filePath)
+    
+    if (canonicalizeExisting) {
+      const exists = await fs.exists(resolved)
+      if (!exists) {
+        if (!quiet) {
+          throw new Error('No such file or directory')
+        }
+        return null
+      }
+    }
+    
+    return resolved
+  } catch (error) {
+    if (!quiet) {
+      throw error
+    }
+    return null
+  }
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'realpath',
+    description: 'Print the resolved absolute file name',
+    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 canonicalizeExisting = false
+      let quiet = false
+      const files: string[] = []
+
+      for (const arg of argv) {
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-e' || arg === '--canonicalize-existing') {
+          canonicalizeExisting = true
+        } else if (arg === '-q' || arg === '--quiet') {
+          quiet = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('e')) canonicalizeExisting = true
+          if (flags.includes('q')) quiet = true
+          const invalidFlags = flags.filter(f => !['e', 'q'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `realpath: invalid option -- '${invalidFlags[0]}'`)
+            await writelnStderr(process, terminal, "Try 'realpath --help' for more information.")
+            return 1
+          }
+        } else {
+          files.push(arg)
+        }
+      }
+
+      if (files.length === 0) {
+        await writelnStderr(process, terminal, 'realpath: missing operand')
+        await writelnStderr(process, terminal, "Try 'realpath --help' for more information.")
+        return 1
+      }
+
+      let hasError = false
+
+      for (const file of files) {
+        const fullPath = path.resolve(shell.cwd, file)
+
+        try {
+          const resolved = await resolveRealPath(
+            shell.context.fs.promises,
+            fullPath,
+            canonicalizeExisting,
+            quiet
+          )
+          
+          if (resolved !== null) {
+            await writelnStdout(process, terminal, resolved)
+          } else {
+            hasError = true
+          }
+        } catch (error) {
+          if (!quiet) {
+            const errorMessage = error instanceof Error ? error.message : String(error)
+            await writelnStderr(process, terminal, `realpath: ${file}: ${errorMessage}`)
+          }
+          hasError = true
+        }
+      }
+
+      return hasError ? 1 : 0
+    }
+  })
+}

package/src/commands/rev.ts

@@ -0,0 +1,143 @@
+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: rev [FILE]...
+Reverse the characters of each line.
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function reverseLine(line: string): string {
+  return line.split('').reverse().join('')
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'rev',
+    description: 'Reverse the characters of each line',
+    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, `rev: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'rev --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, `rev: ${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, `rev: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        for (const line of lines) {
+          const reversed = reverseLine(line)
+          await writer.write(new TextEncoder().encode(reversed + '\n'))
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `rev: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}