@ecmaos/coreutils 0.1.4 → 0.2.0

package/src/commands/sort.ts

@@ -0,0 +1,175 @@
+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: sort [OPTION]... [FILE]...
+Sort lines of text files.
+
+  -r, --reverse  reverse the result of comparisons
+  -n, --numeric   compare according to string numerical value
+  -u, --unique    output only the first of an equal run
+  --help          display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'sort',
+    description: 'Sort lines of text 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
+      }
+
+      const files: string[] = []
+      let reverse = false
+      let numeric = false
+      let unique = false
+
+      for (const arg of argv) {
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-r' || arg === '--reverse') {
+          reverse = true
+        } else if (arg === '-n' || arg === '--numeric') {
+          numeric = true
+        } else if (arg === '-u' || arg === '--unique') {
+          unique = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('r')) reverse = true
+          if (flags.includes('n')) numeric = true
+          if (flags.includes('u')) unique = true
+          const invalidFlags = flags.filter(f => !['r', 'n', 'u'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `sort: invalid option -- '${invalidFlags[0]}'`)
+            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, `sort: ${file}: cannot sort 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, `sort: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        if (numeric) {
+          lines.sort((a, b) => {
+            const numA = parseFloat(a.trim())
+            const numB = parseFloat(b.trim())
+            if (isNaN(numA) && isNaN(numB)) return a.localeCompare(b)
+            if (isNaN(numA)) return 1
+            if (isNaN(numB)) return -1
+            return reverse ? numB - numA : numA - numB
+          })
+        } else {
+          lines.sort((a, b) => {
+            return reverse ? b.localeCompare(a) : a.localeCompare(b)
+          })
+        }
+
+        if (unique) {
+          const seen = new Set<string>()
+          lines = lines.filter(line => {
+            if (seen.has(line)) return false
+            seen.add(line)
+            return true
+          })
+        }
+
+        for (const line of lines) {
+          await writer.write(new TextEncoder().encode(line + '\n'))
+        }
+
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/split.ts

@@ -0,0 +1,154 @@
+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: split [OPTION]... [INPUT [PREFIX]]
+Split INPUT into fixed-size pieces.
+
+  -l, -lNUMBER        put NUMBER lines per output file
+  -b, -bSIZE            put SIZE bytes per output file
+  --help                 display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'split',
+    description: 'Split a file into pieces',
+    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 file = ''
+      let lines: number | undefined
+      let bytes: number | undefined
+      let prefix = 'x'
+
+      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 === '-l' || arg.startsWith('-l')) {
+          if (arg === '-l' && i + 1 < argv.length) {
+            i++
+            const nextArg = argv[i]
+            if (nextArg !== undefined) {
+              lines = parseInt(nextArg, 10)
+            }
+          } else if (arg.startsWith('-l') && arg.length > 2) {
+            lines = parseInt(arg.slice(2), 10)
+          }
+        } else if (arg === '-b' || arg.startsWith('-b')) {
+          if (arg === '-b' && i + 1 < argv.length) {
+            i++
+            const nextArg = argv[i]
+            if (nextArg !== undefined) {
+              bytes = parseInt(nextArg, 10)
+            }
+          } else if (arg.startsWith('-b') && arg.length > 2) {
+            bytes = parseInt(arg.slice(2), 10)
+          }
+        } else if (!arg.startsWith('-')) {
+          if (!file) {
+            file = arg
+          } else if (prefix === 'x') {
+            prefix = arg
+          }
+        }
+      }
+
+      if (!file) {
+        await writelnStderr(process, terminal, 'split: missing file operand')
+        return 1
+      }
+
+      if (!lines && !bytes) {
+        await writelnStderr(process, terminal, 'split: you must specify -l or -b')
+        return 1
+      }
+
+      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, `split: ${file}: cannot split device files`)
+          return 1
+        }
+
+        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 dir = path.dirname(fullPath)
+        let fileIndex = 0
+
+        const getSuffix = (index: number): string => {
+          const first = Math.floor(index / 26)
+          const second = index % 26
+          return String.fromCharCode(97 + first) + String.fromCharCode(97 + second)
+        }
+
+        if (lines) {
+          const allLines = content.split('\n')
+          for (let i = 0; i < allLines.length; i += lines) {
+            const chunk = allLines.slice(i, i + lines).join('\n')
+            const suffix = getSuffix(fileIndex)
+            const outputPath = path.join(dir, `${prefix}${suffix}`)
+            await shell.context.fs.promises.writeFile(outputPath, chunk, 'utf-8')
+            fileIndex++
+          }
+        } else if (bytes) {
+          const encoder = new TextEncoder()
+          const contentBytes = encoder.encode(content)
+          for (let i = 0; i < contentBytes.length; i += bytes) {
+            const chunk = contentBytes.slice(i, i + bytes)
+            const suffix = getSuffix(fileIndex)
+            const outputPath = path.join(dir, `${prefix}${suffix}`)
+            await shell.context.fs.promises.writeFile(outputPath, chunk)
+            fileIndex++
+          }
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `split: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+      }
+    }
+  })
+}

package/src/commands/stat.ts

@@ -1,11 +1,18 @@
 import path from 'path'
 import chalk from 'chalk'
 import * as zipjs from '@zip.js/zip.js'
-import type { CommandLineOptions } from 'command-line-args'
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
 import { writelnStdout } from '../shared/helpers.js'
 
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: stat [OPTION]... FILE...
+Display file or file system status.
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'stat',
@@ -13,12 +20,15 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, description: 'The path to the file or directory to display' }
-    ],
-    run: async (argv: CommandLineOptions, process?: Process) => {
-      const argPath = (argv.path as string) || shell.cwd
+    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
+      }
+
+      const argPath = argv.length > 0 && argv[0] && !argv[0].startsWith('-') ? argv[0] : shell.cwd
       const fullPath = argPath ? path.resolve(shell.cwd, argPath) : shell.cwd
       const stats = await shell.context.fs.promises.stat(fullPath)
       await writelnStdout(process, terminal, JSON.stringify(stats, null, 2))
@@ -37,4 +47,3 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     }
   })
 }
-

package/src/commands/tail.ts

@@ -0,0 +1,200 @@
+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 { writelnStdout } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: tail [OPTION]... [FILE]...
+Print the last 10 lines of each FILE to standard output.
+
+  -n, -nNUMBER        print the last NUMBER lines instead of 10
+  --help             display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'tail',
+    description: 'Print the last lines of 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 numLines = 10
+      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.startsWith('-n')) {
+          if (arg === '-n' && i + 1 < argv.length) {
+            i++
+            const nextArg = argv[i]
+            if (nextArg !== undefined) {
+              const num = parseInt(nextArg, 10)
+              if (!isNaN(num)) numLines = num
+            }
+          } else if (arg.startsWith('-n') && arg.length > 2) {
+            const num = parseInt(arg.slice(2), 10)
+            if (!isNaN(num)) numLines = num
+          }
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        if (files.length === 0) {
+          if (!process.stdin) {
+            return 0
+          }
+
+          const reader = process.stdin.getReader()
+          const decoder = new TextDecoder()
+          const lines: string[] = []
+          let buffer = ''
+
+          try {
+            while (true) {
+              let readResult
+              try {
+                readResult = await reader.read()
+              } catch (error) {
+                if (error instanceof Error) {
+                  throw error
+                }
+                break
+              }
+
+              const { done, value } = readResult
+              if (done) {
+                buffer += decoder.decode()
+                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 {
+            try {
+              reader.releaseLock()
+            } catch {
+            }
+          }
+
+          const output = lines.slice(-numLines).join('\n')
+          if (output) {
+            await writer.write(new TextEncoder().encode(output + '\n'))
+          }
+
+          return 0
+        }
+
+        const isMultipleFiles = files.length > 1
+
+        for (let i = 0; i < files.length; i++) {
+          const file = files[i]
+          if (!file) continue
+          const fullPath = path.resolve(shell.cwd, file)
+
+          if (isMultipleFiles) {
+            const header = i > 0 ? '\n' : ''
+            await writer.write(new TextEncoder().encode(`${header}==> ${file} <==\n`))
+          }
+
+          let interrupted = false
+          const interruptHandler = () => { interrupted = true }
+          kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+          try {
+            if (!fullPath.startsWith('/dev')) {
+              const handle = await shell.context.fs.promises.open(fullPath, 'r')
+              const stat = await shell.context.fs.promises.stat(fullPath)
+
+              const decoder = new TextDecoder()
+              let buffer = ''
+              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)
+                buffer += decoder.decode(chunk, { stream: true })
+                bytesRead += readSize
+              }
+
+              const lines = buffer.split('\n')
+              if (lines[lines.length - 1] === '') {
+                lines.pop()
+              }
+
+              const output = lines.slice(-numLines).join('\n')
+              if (output) {
+                await writer.write(new TextEncoder().encode(output + '\n'))
+              }
+            } else {
+              const device = await shell.context.fs.promises.open(fullPath)
+              const decoder = new TextDecoder()
+              const lines: string[] = []
+              let buffer = ''
+              const chunkSize = 1024
+              const data = new Uint8Array(chunkSize)
+              let bytesRead = 0
+
+              do {
+                if (interrupted) break
+                const result = await device.read(data)
+                bytesRead = result.bytesRead
+                if (bytesRead > 0) {
+                  buffer += decoder.decode(data.subarray(0, bytesRead), { stream: true })
+                }
+              } while (bytesRead > 0)
+
+              const allLines = buffer.split('\n')
+              if (allLines[allLines.length - 1] === '') {
+                allLines.pop()
+              }
+              lines.push(...allLines)
+
+              const output = lines.slice(-numLines).join('\n')
+              if (output) {
+                await writer.write(new TextEncoder().encode(output + '\n'))
+              }
+            }
+          } finally {
+            kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+          }
+        }
+
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/tee.ts

@@ -1,10 +1,19 @@
 import path from 'path'
-import type { CommandLineOptions } from 'command-line-args'
 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: tee [OPTION]... [FILE]...
+Read from standard input and write to standard output and files.
+
+  -a, --append            append to the given files, do not overwrite
+  -i, --ignore-interrupts ignore interrupt signals
+  --help                  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'tee',
@@ -12,23 +21,46 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'append', type: Boolean, alias: 'a', description: 'Append to the given files, do not overwrite' },
-      { name: 'ignore-interrupts', type: Boolean, alias: 'i', description: 'Ignore interrupt signals' },
-      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, multiple: true, description: 'File(s) to write to' }
-    ],
-    run: async (argv: CommandLineOptions, process?: Process) => {
+    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 (!process.stdin) {
         await writelnStderr(process, terminal, 'tee: No input provided')
         return 1
       }
 
-      const files = (argv.path as string[]) || []
-      const append = (argv.append as boolean) || false
-      const ignoreInterrupts = (argv['ignore-interrupts'] as boolean) || false
+      const files: string[] = []
+      let append = false
+      let ignoreInterrupts = false
+
+      for (const arg of argv) {
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-a' || arg === '--append') {
+          append = true
+        } else if (arg === '-i' || arg === '--ignore-interrupts') {
+          ignoreInterrupts = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('a')) append = true
+          if (flags.includes('i')) ignoreInterrupts = true
+          const invalidFlags = flags.filter(f => !['a', 'i'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `tee: invalid option -- '${invalidFlags[0]}'`)
+            return 1
+          }
+        } else {
+          files.push(arg)
+        }
+      }
 
       const writer = process.stdout.getWriter()