@ecmaos/coreutils 0.1.4 → 0.2.0

package/src/commands/find.ts

@@ -0,0 +1,184 @@
+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: find [PATH]... [OPTION]...
+Search for files in a directory hierarchy.
+
+  -name PATTERN  file name matches shell pattern PATTERN
+  -type TYPE     file is of type TYPE (f=file, d=directory, l=symlink)
+  --help         display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'find',
+    description: 'Search for files in a directory hierarchy',
+    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, 'find: missing path argument')
+        return 1
+      }
+
+      let startPaths: string[] = []
+      let namePattern: string | undefined
+      let fileType: string | undefined
+
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (arg === undefined) continue
+        
+        if (arg === '-name') {
+          if (i + 1 < argv.length) {
+            i++
+            const nextArg = argv[i]
+            if (nextArg !== undefined && typeof nextArg === 'string' && !nextArg.startsWith('-')) {
+              namePattern = nextArg
+            } else {
+              await writelnStderr(process, terminal, 'find: missing argument to -name')
+              return 1
+            }
+          } else {
+            await writelnStderr(process, terminal, 'find: missing argument to -name')
+            return 1
+          }
+        } else if (arg === '-type') {
+          if (i + 1 < argv.length) {
+            i++
+            const nextArg = argv[i]
+            if (nextArg !== undefined && typeof nextArg === 'string' && !nextArg.startsWith('-')) {
+              fileType = nextArg
+            } else {
+              await writelnStderr(process, terminal, 'find: missing argument to -type')
+              return 1
+            }
+          } else {
+            await writelnStderr(process, terminal, 'find: missing argument to -type')
+            return 1
+          }
+        } else if (typeof arg === 'string' && !arg.startsWith('-')) {
+          startPaths.push(arg)
+        }
+      }
+
+      if (startPaths.length === 0) {
+        startPaths = [shell.cwd]
+      }
+
+      const writer = process.stdout.getWriter()
+
+      const matchesPattern = (filename: string, pattern: string): boolean => {
+        if (!pattern) return false
+        
+        let regexPattern = ''
+        for (let i = 0; i < pattern.length; i++) {
+          const char = pattern[i]
+          if (char === undefined) continue
+          if (char === '*') {
+            regexPattern += '.*'
+          } else if (char === '?') {
+            regexPattern += '.'
+          } else if (char === '.') {
+            regexPattern += '\\.'
+          } else {
+            const needsEscaping = /[+^${}()|[\]\\]/.test(char)
+            regexPattern += needsEscaping ? '\\' + char : char
+          }
+        }
+        try {
+          const regex = new RegExp(`^${regexPattern}$`)
+          return regex.test(filename)
+        } catch {
+          return false
+        }
+      }
+
+      const searchDirectory = async (dirPath: string): Promise<void> => {
+        let interrupted = false
+        const interruptHandler = () => { interrupted = true }
+        kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+        try {
+          if (interrupted) return
+
+          const entries = await shell.context.fs.promises.readdir(dirPath)
+
+          for (const entry of entries) {
+            if (interrupted) break
+
+            const fullPath = path.join(dirPath, entry)
+
+            try {
+              const stat = await shell.context.fs.promises.stat(fullPath)
+
+              let matches = true
+
+              if (namePattern) {
+                const matchesName = matchesPattern(entry, namePattern)
+                if (!matchesName) {
+                  matches = false
+                }
+              }
+
+              if (fileType && matches) {
+                if (fileType === 'f' && !stat.isFile()) matches = false
+                else if (fileType === 'd' && !stat.isDirectory()) matches = false
+                else if (fileType === 'l' && !stat.isSymbolicLink()) matches = false
+              }
+
+              if (matches) {
+                await writer.write(new TextEncoder().encode(fullPath + '\n'))
+              }
+
+              if (stat.isDirectory() && !stat.isSymbolicLink()) {
+                await searchDirectory(fullPath)
+              }
+            } catch {
+            }
+          }
+        } catch {
+        } finally {
+          kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+        }
+      }
+
+      try {
+        for (const startPath of startPaths) {
+          const fullPath = path.resolve(shell.cwd, startPath)
+
+          try {
+            const stat = await shell.context.fs.promises.stat(fullPath)
+            if (!stat.isDirectory()) {
+              await writelnStderr(process, terminal, `find: ${startPath}: not a directory`)
+              continue
+            }
+
+            await searchDirectory(fullPath)
+          } catch (error) {
+            await writelnStderr(process, terminal, `find: ${startPath}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+          }
+        }
+
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/grep.ts

@@ -0,0 +1,187 @@
+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: grep [OPTION]... PATTERN [FILE]...
+Search for PATTERN in each FILE.
+
+  -i, --ignore-case   ignore case distinctions
+  -n, --line-number   print line number with output lines
+  --help              display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'grep',
+    description: 'Search for patterns in files or standard input',
+    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 ignoreCase = false
+      let showLineNumbers = false
+      const args: string[] = []
+
+      for (const arg of argv) {
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-i' || arg === '--ignore-case') {
+          ignoreCase = true
+        } else if (arg === '-n' || arg === '--line-number') {
+          showLineNumbers = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('i')) ignoreCase = true
+          if (flags.includes('n')) showLineNumbers = true
+          const invalidFlags = flags.filter(f => !['i', 'n'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `grep: invalid option -- '${invalidFlags[0]}'`)
+            return 1
+          }
+        } else {
+          args.push(arg)
+        }
+      }
+
+      if (args.length === 0 || !args[0]) {
+        await writelnStderr(process, terminal, 'grep: pattern is required')
+        return 1
+      }
+
+      const pattern = args[0]
+      const files = args.slice(1)
+
+      const flags = ignoreCase ? 'i' : ''
+      let regex: RegExp
+      try {
+        regex = new RegExp(pattern, flags)
+      } catch (error) {
+        await writelnStderr(process, terminal, `grep: invalid pattern: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      }
+
+      const writer = process.stdout.getWriter()
+      let exitCode = 0
+
+      try {
+        if (files.length === 0) {
+          if (!process.stdin) {
+            await writelnStderr(process, terminal, 'grep: No input provided')
+            return 1
+          }
+
+          const reader = process.stdin.getReader()
+          let currentLineNumber = 1
+          let buffer = ''
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+
+              const chunk = new TextDecoder().decode(value, { stream: true })
+              buffer += chunk
+
+              const lines = buffer.split('\n')
+              buffer = lines.pop() || ''
+
+              for (const line of lines) {
+                if (regex.test(line)) {
+                  const output = showLineNumbers ? `${currentLineNumber}:${line}\n` : `${line}\n`
+                  await writer.write(new TextEncoder().encode(output))
+                }
+                currentLineNumber++
+              }
+            }
+
+            if (buffer && regex.test(buffer)) {
+              const output = showLineNumbers ? `${currentLineNumber}:${buffer}\n` : `${buffer}\n`
+              await writer.write(new TextEncoder().encode(output))
+            }
+          } 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, `grep: ${file}: cannot search device files`)
+                exitCode = 1
+                continue
+              }
+
+              const handle = await shell.context.fs.promises.open(fullPath, 'r')
+              const stat = await shell.context.fs.promises.stat(fullPath)
+
+              let bytesRead = 0
+              const chunkSize = 1024
+              let buffer = ''
+              let currentLineNumber = 1
+
+              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)
+                const text = new TextDecoder().decode(chunk, { stream: true })
+                buffer += text
+
+                const lines = buffer.split('\n')
+                buffer = lines.pop() || ''
+
+                for (const line of lines) {
+                  if (regex.test(line)) {
+                    const prefix = files.length > 1 ? `${file}:` : ''
+                    const lineNumPrefix = showLineNumbers ? `${currentLineNumber}:` : ''
+                    const output = `${prefix}${lineNumPrefix}${line}\n`
+                    await writer.write(new TextEncoder().encode(output))
+                  }
+                  currentLineNumber++
+                }
+
+                bytesRead += readSize
+              }
+
+              if (buffer && regex.test(buffer)) {
+                const prefix = files.length > 1 ? `${file}:` : ''
+                const lineNumPrefix = showLineNumbers ? `${currentLineNumber}:` : ''
+                const output = `${prefix}${lineNumPrefix}${buffer}\n`
+                await writer.write(new TextEncoder().encode(output))
+              }
+            } catch (error) {
+              await writelnStderr(process, terminal, `grep: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+              exitCode = 1
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        return exitCode
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/head.ts

@@ -0,0 +1,206 @@
+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: head [OPTION]... [FILE]...
+Print the first 10 lines of each FILE to standard output.
+
+  -n, -nNUMBER        print the first 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: 'head',
+    description: 'Print the first 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 (lines.length >= numLines) break
+              }
+            }
+            if (buffer && lines.length < numLines) {
+              lines.push(buffer)
+            }
+          } finally {
+            try {
+              reader.releaseLock()
+            } catch {
+            }
+          }
+
+          const output = lines.slice(0, 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()
+              const lines: string[] = []
+              let buffer = ''
+              let bytesRead = 0
+              const chunkSize = 1024
+
+              while (bytesRead < stat.size && lines.length < numLines) {
+                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 })
+                const newLines = buffer.split('\n')
+                buffer = newLines.pop() || ''
+                lines.push(...newLines)
+                bytesRead += readSize
+                if (lines.length >= numLines) break
+              }
+              if (buffer && lines.length < numLines) {
+                lines.push(buffer)
+              }
+
+              const output = lines.slice(0, 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 })
+                  const newLines = buffer.split('\n')
+                  buffer = newLines.pop() || ''
+                  lines.push(...newLines)
+                  if (lines.length >= numLines) break
+                }
+              } while (bytesRead > 0 && lines.length < numLines)
+
+              if (buffer && lines.length < numLines) {
+                lines.push(buffer)
+              }
+
+              const output = lines.slice(0, 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()
+      }
+    }
+  })
+}