@ecmaos/coreutils 0.1.4 → 0.2.0

package/src/commands/wc.ts

@@ -0,0 +1,181 @@
+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: wc [OPTION]... [FILE]...
+Print newline, word, and byte counts for each FILE.
+
+  -c, --bytes     print the byte counts
+  -l, --lines     print the newline counts
+  -w, --words     print the word counts
+  --help          display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'wc',
+    description: 'Print newline, word, and byte counts for each file',
+    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 showBytes = false
+      let showLines = false
+      let showWords = false
+
+      for (const arg of argv) {
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-c' || arg === '--bytes') {
+          showBytes = true
+        } else if (arg === '-l' || arg === '--lines') {
+          showLines = true
+        } else if (arg === '-w' || arg === '--words') {
+          showWords = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('c')) showBytes = true
+          if (flags.includes('l')) showLines = true
+          if (flags.includes('w')) showWords = true
+          const invalidFlags = flags.filter(f => !['c', 'l', 'w'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `wc: invalid option -- '${invalidFlags[0]}'`)
+            return 1
+          }
+        } else {
+          files.push(arg)
+        }
+      }
+
+      const showAll = !showBytes && !showLines && !showWords
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        if (files.length === 0) {
+          if (!process.stdin) {
+            return 0
+          }
+
+          const reader = process.stdin.getReader()
+          const decoder = new TextDecoder()
+          let content = ''
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+              if (value) {
+                content += decoder.decode(value, { stream: true })
+              }
+            }
+          } finally {
+            reader.releaseLock()
+          }
+
+          const lines = content.split('\n').length - (content.endsWith('\n') ? 0 : 1)
+          const words = content.trim().split(/\s+/).filter(w => w.length > 0).length
+          const bytes = new TextEncoder().encode(content).length
+
+          let output = ''
+          if (showAll || showLines) output += `${lines} `
+          if (showAll || showWords) output += `${words} `
+          if (showAll || showBytes) output += `${bytes} `
+          output = output.trim()
+
+          await writer.write(new TextEncoder().encode(output + '\n'))
+          return 0
+        }
+
+        let totalLines = 0
+        let totalWords = 0
+        let totalBytes = 0
+        const results: Array<{ lines: number, words: number, bytes: number, file: string }> = []
+
+        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, `wc: ${file}: cannot count 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 lines = content.split('\n').length - (content.endsWith('\n') ? 0 : 1)
+            const words = content.trim().split(/\s+/).filter(w => w.length > 0).length
+            const bytes = new TextEncoder().encode(content).length
+
+            totalLines += lines
+            totalWords += words
+            totalBytes += bytes
+
+            results.push({ lines, words, bytes, file })
+          } catch (error) {
+            await writelnStderr(process, terminal, `wc: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+          } finally {
+            kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+          }
+        }
+
+        for (const result of results) {
+          let output = ''
+          if (showAll || showLines) output += `${result.lines} `
+          if (showAll || showWords) output += `${result.words} `
+          if (showAll || showBytes) output += `${result.bytes} `
+          output += result.file
+          await writer.write(new TextEncoder().encode(output + '\n'))
+        }
+
+        if (files.length > 1) {
+          let output = ''
+          if (showAll || showLines) output += `${totalLines} `
+          if (showAll || showWords) output += `${totalWords} `
+          if (showAll || showBytes) output += `${totalBytes} `
+          output += 'total'
+          await writer.write(new TextEncoder().encode(output + '\n'))
+        }
+
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/which.ts

@@ -0,0 +1,89 @@
+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: which [COMMAND]...
+Locate a command.
+
+  COMMAND  the command(s) to locate
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'which',
+    description: 'Locate a command',
+    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 commands: string[] = []
+      for (const arg of argv) {
+        if (arg !== '--help' && arg !== '-h' && !arg.startsWith('-')) {
+          commands.push(arg)
+        }
+      }
+
+      if (commands.length === 0) {
+        await writelnStderr(process, terminal, 'which: missing command name')
+        return 1
+      }
+
+      const writer = process.stdout.getWriter()
+      let exitCode = 0
+
+      const resolveCommand = async (command: string): Promise<string | undefined> => {
+        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(':') || ['/bin', '/usr/bin', '/usr/local/bin']
+        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
+      }
+
+      try {
+        for (const cmd of commands) {
+          const commandPath = await resolveCommand(cmd)
+          
+          if (commandPath) {
+            await writer.write(new TextEncoder().encode(commandPath + '\n'))
+          } else {
+            exitCode = 1
+          }
+        }
+
+        return exitCode
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/whoami.ts

@@ -0,0 +1,32 @@
+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: whoami
+Print effective user ID.
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'whoami',
+    description: 'Print effective user ID',
+    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
+      }
+
+      await writelnStdout(process, terminal, shell.username)
+      return 0
+    }
+  })
+}

package/src/index.ts

@@ -12,11 +12,15 @@ import { createCommand as createCd } from './commands/cd.js'
 import { createCommand as createChmod } from './commands/chmod.js'
 import { createCommand as createCp } from './commands/cp.js'
 import { createCommand as createEcho } from './commands/echo.js'
+import { createCommand as createGrep } from './commands/grep.js'
+import { createCommand as createHead } from './commands/head.js'
 import { createCommand as createLn } from './commands/ln.js'
 import { createCommand as createLs } from './commands/ls.js'
 import { createCommand as createMkdir } from './commands/mkdir.js'
 import { createCommand as createMv } from './commands/mv.js'
+import { createCommand as createNc } from './commands/nc.js'
 import { createCommand as createPwd } from './commands/pwd.js'
+import { createCommand as createSockets } from './commands/sockets.js'
 import { createCommand as createRm } from './commands/rm.js'
 import { createCommand as createRmdir } from './commands/rmdir.js'
 import { createCommand as createStat } from './commands/stat.js'
@@ -26,6 +30,30 @@ import { createCommand as createLess } from './commands/less.js'
 import { createCommand as createPasskey } from './commands/passkey.js'
 import { createCommand as createSed } from './commands/sed.js'
 import { createCommand as createTee } from './commands/tee.js'
+import { createCommand as createTail } from './commands/tail.js'
+import { createCommand as createBasename } from './commands/basename.js'
+import { createCommand as createCal } from './commands/cal.js'
+import { createCommand as createComm } from './commands/comm.js'
+import { createCommand as createCut } from './commands/cut.js'
+import { createCommand as createDate } from './commands/date.js'
+import { createCommand as createDiff } from './commands/diff.js'
+import { createCommand as createDirname } from './commands/dirname.js'
+import { createCommand as createFalse } from './commands/false.js'
+import { createCommand as createFind } from './commands/find.js'
+import { createCommand as createId } from './commands/id.js'
+import { createCommand as createJoin } from './commands/join.js'
+import { createCommand as createNl } from './commands/nl.js'
+import { createCommand as createPaste } from './commands/paste.js'
+import { createCommand as createSeq } from './commands/seq.js'
+import { createCommand as createSort } from './commands/sort.js'
+import { createCommand as createSplit } from './commands/split.js'
+import { createCommand as createTest } from './commands/test.js'
+import { createCommand as createTr } from './commands/tr.js'
+import { createCommand as createTrue } from './commands/true.js'
+import { createCommand as createUniq } from './commands/uniq.js'
+import { createCommand as createWc } from './commands/wc.js'
+import { createCommand as createWhich } from './commands/which.js'
+import { createCommand as createWhoami } from './commands/whoami.js'
 
 // Export individual command factories
 export { createCommand as createCat } from './commands/cat.js'
@@ -33,6 +61,7 @@ export { createCommand as createCd } from './commands/cd.js'
 export { createCommand as createChmod } from './commands/chmod.js'
 export { createCommand as createCp } from './commands/cp.js'
 export { createCommand as createEcho } from './commands/echo.js'
+export { createCommand as createGrep } from './commands/grep.js'
 export { createCommand as createLn } from './commands/ln.js'
 export { createCommand as createLs } from './commands/ls.js'
 export { createCommand as createMkdir } from './commands/mkdir.js'
@@ -46,6 +75,20 @@ export { createCommand as createHex } from './commands/hex.js'
 export { createCommand as createLess } from './commands/less.js'
 export { createCommand as createSed } from './commands/sed.js'
 export { createCommand as createTee } from './commands/tee.js'
+export { createCommand as createTail } from './commands/tail.js'
+export { createCommand as createBasename } from './commands/basename.js'
+export { createCommand as createCut } from './commands/cut.js'
+export { createCommand as createDate } from './commands/date.js'
+export { createCommand as createDiff } from './commands/diff.js'
+export { createCommand as createDirname } from './commands/dirname.js'
+export { createCommand as createFind } from './commands/find.js'
+export { createCommand as createSort } from './commands/sort.js'
+export { createCommand as createTest } from './commands/test.js'
+export { createCommand as createTr } from './commands/tr.js'
+export { createCommand as createUniq } from './commands/uniq.js'
+export { createCommand as createWc } from './commands/wc.js'
+export { createCommand as createWhich } from './commands/which.js'
+export { createCommand as createSockets } from './commands/sockets.js'
 
 /**
  * Creates all coreutils commands.
@@ -58,11 +101,15 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     chmod: createChmod(kernel, shell, terminal),
     cp: createCp(kernel, shell, terminal),
     echo: createEcho(kernel, shell, terminal),
+    grep: createGrep(kernel, shell, terminal),
+    head: createHead(kernel, shell, terminal),
     ln: createLn(kernel, shell, terminal),
     ls: createLs(kernel, shell, terminal),
     mkdir: createMkdir(kernel, shell, terminal),
     mv: createMv(kernel, shell, terminal),
     pwd: createPwd(kernel, shell, terminal),
+    nc: createNc(kernel, shell, terminal),
+    sockets: createSockets(kernel, shell, terminal),
     rm: createRm(kernel, shell, terminal),
     rmdir: createRmdir(kernel, shell, terminal),
     stat: createStat(kernel, shell, terminal),
@@ -71,7 +118,31 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     less: createLess(kernel, shell, terminal),
     passkey: createPasskey(kernel, shell, terminal),
     sed: createSed(kernel, shell, terminal),
-    tee: createTee(kernel, shell, terminal)
+    tail: createTail(kernel, shell, terminal),
+    tee: createTee(kernel, shell, terminal),
+    basename: createBasename(kernel, shell, terminal),
+    cal: createCal(kernel, shell, terminal),
+    comm: createComm(kernel, shell, terminal),
+    cut: createCut(kernel, shell, terminal),
+    date: createDate(kernel, shell, terminal),
+    diff: createDiff(kernel, shell, terminal),
+    dirname: createDirname(kernel, shell, terminal),
+    false: createFalse(kernel, shell, terminal),
+    find: createFind(kernel, shell, terminal),
+    id: createId(kernel, shell, terminal),
+    join: createJoin(kernel, shell, terminal),
+    nl: createNl(kernel, shell, terminal),
+    paste: createPaste(kernel, shell, terminal),
+    seq: createSeq(kernel, shell, terminal),
+    sort: createSort(kernel, shell, terminal),
+    split: createSplit(kernel, shell, terminal),
+    test: createTest(kernel, shell, terminal),
+    tr: createTr(kernel, shell, terminal),
+    true: createTrue(kernel, shell, terminal),
+    uniq: createUniq(kernel, shell, terminal),
+    wc: createWc(kernel, shell, terminal),
+    which: createWhich(kernel, shell, terminal),
+    whoami: createWhoami(kernel, shell, terminal)
   }
 }
 

package/src/shared/terminal-command.ts

@@ -5,8 +5,14 @@ import type { TerminalCommand as ITerminalCommand } from '@ecmaos/types'
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { writelnStdout, writelnStderr } from './helpers.js'
 
+type UnifiedParserRun = (argv: CommandLineOptions, process?: Process, rawArgv?: string[]) => Promise<number | void>
+type RawArgvRun = (pid: number, argv: string[]) => Promise<number | void>
+
 /**
  * The TerminalCommand class sets up a common interface for builtin terminal commands
+ * Supports two modes:
+ * - Unified parser mode: When options are provided, uses command-line-args (for kernel commands)
+ * - Raw argv mode: When options are not provided, passes raw argv directly (for coreutils commands)
  */
 export class TerminalCommand implements ITerminalCommand {
   command: string = ''
@@ -24,8 +30,8 @@ export class TerminalCommand implements ITerminalCommand {
     command: string
     description: string
     kernel: Kernel
-    options: parseUsage.OptionDefinition[]
-    run: (argv: CommandLineOptions, process?: Process) => Promise<number | void>
+    options?: parseUsage.OptionDefinition[]
+    run: UnifiedParserRun | RawArgvRun
     shell: Shell
     terminal: Terminal
     stdin?: ReadableStream<Uint8Array>
@@ -35,32 +41,50 @@ export class TerminalCommand implements ITerminalCommand {
     this.command = command
     this.description = description
     this.kernel = kernel
-    this.options = options
+    this.options = options || []
     this.shell = shell
     this.terminal = terminal
     this.stdin = stdin
     this.stdout = stdout
     this.stderr = stderr
 
-    this.run = async (pid: number, argv: string[]) => {
-      if (argv === null) return 1
-      const process = this.kernel.processes.get(pid) as Process | undefined
-      try {
-        const parsed = parseArgs(this.options, { argv })
-        if (parsed.help) {
-          await writelnStdout(process, this.terminal, this.usage)
-          return 0
-        }
+    const useUnifiedParser = this.options.length > 0
 
-        return await run(parsed, process)
-      } catch (error) {
-        await writelnStderr(process, this.terminal, chalk.red(String(error)))
-        return 1
+    if (useUnifiedParser) {
+      const unifiedRun = run as UnifiedParserRun
+      this.run = async (pid: number, argv: string[]) => {
+        if (argv === null) return 1
+        const process = this.kernel.processes.get(pid) as Process | undefined
+        try {
+          const parsed = parseArgs(this.options, { argv, stopAtFirstUnknown: true })
+          if (parsed.help) {
+            await writelnStdout(process, this.terminal, this.usage)
+            return 0
+          }
+
+          return await unifiedRun(parsed, process, argv)
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error)
+          if (errorMessage.includes('UNKNOWN_OPTION') || errorMessage.includes('Unknown option')) {
+            return await unifiedRun({} as CommandLineOptions, process, argv)
+          }
+          await writelnStderr(process, this.terminal, chalk.red(errorMessage))
+          return 1
+        }
+      }
+    } else {
+      const rawRun = run as RawArgvRun
+      this.run = async (pid: number, argv: string[]) => {
+        if (argv === null) return 1
+        return await rawRun(pid, argv)
       }
     }
   }
 
   get usage() {
+    if (this.options.length === 0) {
+      return ''
+    }
     return parseUsage([
       { header: this.command, content: this.description },
       { header: 'Usage', content: this.usageContent },
@@ -69,6 +93,9 @@ export class TerminalCommand implements ITerminalCommand {
   }
 
   get usageContent() {
+    if (this.options.length === 0) {
+      return ''
+    }
     return `${this.command} ${this.options.map(option => {
       let optionStr = option.name
       if (option.type === Boolean) optionStr = `[--${option.name}]`