@ecmaos/coreutils 0.1.5 → 0.2.0

package/src/commands/date.ts

@@ -0,0 +1,97 @@
+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: date [OPTION]... [+FORMAT]
+Print or set the system date and time.
+
+  -I, --iso-8601[=TIMESPEC]  output date/time in ISO 8601 format
+  -R, --rfc-2822              output date and time in RFC 2822 format
+  -f, --format=FORMAT         output date/time in specified format (strftime-like)
+  --help                      display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'date',
+    description: 'Print or set the system date and time',
+    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
+      }
+
+      const now = new Date()
+      let output = ''
+      let iso8601 = false
+      let rfc2822 = false
+      let format: string | undefined
+
+      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 === '-I' || arg === '--iso-8601') {
+          iso8601 = true
+        } else if (arg === '-R' || arg === '--rfc-2822') {
+          rfc2822 = true
+        } else if (arg === '-f' || arg === '--format') {
+          if (i + 1 < argv.length) {
+            format = argv[++i]
+          } else {
+            await writelnStdout(process, terminal, 'date: option requires an argument -- \'f\'')
+            return 1
+          }
+        } else if (arg.startsWith('--format=')) {
+          format = arg.slice(9)
+        } else if (arg.startsWith('--iso-8601=')) {
+          iso8601 = true
+        } else if (arg.startsWith('-f')) {
+          format = arg.slice(2)
+        } else if (arg.startsWith('+')) {
+          format = arg.slice(1)
+        }
+      }
+
+      if (iso8601) {
+        output = now.toISOString()
+      } else if (rfc2822) {
+        output = now.toUTCString()
+      } else if (format) {
+        const year = now.getFullYear()
+        const month = String(now.getMonth() + 1).padStart(2, '0')
+        const day = String(now.getDate()).padStart(2, '0')
+        const hours = String(now.getHours()).padStart(2, '0')
+        const minutes = String(now.getMinutes()).padStart(2, '0')
+        const seconds = String(now.getSeconds()).padStart(2, '0')
+        const milliseconds = String(now.getMilliseconds()).padStart(3, '0')
+        
+        output = format
+          .replace(/%Y/g, String(year))
+          .replace(/%m/g, month)
+          .replace(/%d/g, day)
+          .replace(/%H/g, hours)
+          .replace(/%M/g, minutes)
+          .replace(/%S/g, seconds)
+          .replace(/%s/g, String(Math.floor(now.getTime() / 1000)))
+          .replace(/%f/g, milliseconds)
+          .replace(/%z/g, now.getTimezoneOffset().toString())
+      } else {
+        output = now.toString()
+      }
+
+      await writelnStdout(process, terminal, output)
+      return 0
+    }
+  })
+}

package/src/commands/diff.ts

@@ -0,0 +1,204 @@
+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: diff [OPTION]... FILE1 FILE2
+Compare files line by line.
+
+  -u, --unified=NUM   output NUM (default 3) lines of unified context
+  -c, --context=NUM   output NUM (default 3) lines of copied context
+  --help              display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'diff',
+    description: 'Compare files line by 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[] = []
+      // TODO: Implement unified and context options in diff output
+      // @ts-ignore - reserved for future implementation
+      let _unified = 3
+      // @ts-ignore - reserved for future implementation
+      let _context = 3
+
+      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 === '-u' || arg === '--unified') {
+          if (i + 1 < argv.length) {
+            const nextArg = argv[++i]
+            if (nextArg !== undefined) {
+              const num = parseInt(nextArg, 10)
+              if (!isNaN(num)) _unified = num
+            }
+          }
+        } else if (arg.startsWith('--unified=')) {
+          const num = parseInt(arg.slice(10), 10)
+          if (!isNaN(num)) _unified = num
+        } else if (arg === '-c' || arg === '--context') {
+          if (i + 1 < argv.length) {
+            const nextArg = argv[++i]
+            if (nextArg !== undefined) {
+              const num = parseInt(nextArg, 10)
+              if (!isNaN(num)) _context = num
+            }
+          }
+        } else if (arg.startsWith('--context=')) {
+          const num = parseInt(arg.slice(10), 10)
+          if (!isNaN(num)) _context = num
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        }
+      }
+
+      if (files.length !== 2) {
+        await writelnStderr(process, terminal, 'diff: exactly two files must be specified')
+        return 1
+      }
+
+      const file1 = files[0]
+      const file2 = files[1]
+      if (!file1 || !file2) {
+        await writelnStderr(process, terminal, 'diff: exactly two files must be specified')
+        return 1
+      }
+      const fullPath1 = path.resolve(shell.cwd || '/', file1)
+      const fullPath2 = path.resolve(shell.cwd || '/', file2)
+
+      const writer = process.stdout.getWriter()
+
+      const readFile = async (filePath: string): Promise<string> => {
+        if (filePath.startsWith('/dev')) {
+          throw new Error('cannot diff device files')
+        }
+
+        let interrupted = false
+        const interruptHandler = () => { interrupted = true }
+        kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+        try {
+          const handle = await shell.context.fs.promises.open(filePath, 'r')
+          const stat = await shell.context.fs.promises.stat(filePath)
+
+          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
+          }
+
+          return content
+        } finally {
+          kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+        }
+      }
+
+      try {
+        const content1 = await readFile(fullPath1)
+        const content2 = await readFile(fullPath2)
+
+        const lines1 = content1.split('\n')
+        const lines2 = content2.split('\n')
+
+        if (lines1[lines1.length - 1] === '') lines1.pop()
+        if (lines2[lines2.length - 1] === '') lines2.pop()
+
+        const lcs = (a: string[], b: string[]): number[][] => {
+          const m = a.length
+          const n = b.length
+          const dp: number[][] = []
+          for (let i = 0; i <= m; i++) {
+            dp[i] = Array(n + 1).fill(0)
+          }
+
+          for (let i = 1; i <= m; i++) {
+            const row = dp[i]!
+            for (let j = 1; j <= n; j++) {
+              if (a[i - 1] === b[j - 1]) {
+                const prev = dp[i - 1]?.[j - 1] ?? 0
+                row[j] = prev + 1
+              } else {
+                const left = dp[i - 1]?.[j] ?? 0
+                const up = row[j - 1] ?? 0
+                row[j] = Math.max(left, up)
+              }
+            }
+          }
+
+          return dp
+        }
+
+        const diff = (a: string[], b: string[]): string[] => {
+          const dp = lcs(a, b)
+          const result: string[] = []
+          let i = a.length
+          let j = b.length
+
+          while (i > 0 || j > 0) {
+            if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+              result.unshift(`  ${a[i - 1]}`)
+              i--
+              j--
+            } else if (j > 0 && (i === 0 || (dp[i]?.[j - 1] ?? 0) >= (dp[i - 1]?.[j] ?? 0))) {
+              result.unshift(`+ ${b[j - 1]}`)
+              j--
+            } else if (i > 0) {
+              result.unshift(`- ${a[i - 1]}`)
+              i--
+            }
+          }
+
+          return result
+        }
+
+        const diffLines = diff(lines1, lines2)
+
+        if (diffLines.length === 0 || diffLines.every(line => line.startsWith('  '))) {
+          return 0
+        }
+
+        await writer.write(new TextEncoder().encode(`--- ${file1}\n+++ ${file2}\n`))
+        
+        for (const line of diffLines) {
+          await writer.write(new TextEncoder().encode(line + '\n'))
+        }
+
+        return 1
+      } catch (error) {
+        await writelnStderr(process, terminal, `diff: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/dirname.ts

@@ -0,0 +1,57 @@
+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: dirname [OPTION] NAME...
+Output each NAME with its last non-slash component and trailing slashes removed.
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'dirname',
+    description: 'Strip last component from file path',
+    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 paths: string[] = []
+      for (const arg of argv) {
+        if (arg !== '--help' && arg !== '-h' && !arg.startsWith('-')) {
+          paths.push(arg)
+        }
+      }
+
+      if (paths.length === 0) {
+        await writelnStderr(process, terminal, 'dirname: missing operand')
+        return 1
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        for (const filePath of paths) {
+          const dir = path.dirname(filePath)
+          await writer.write(new TextEncoder().encode(dir + '\n'))
+        }
+
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/echo.ts

@@ -1,6 +1,15 @@
-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: echo [OPTION]... [STRING]...
+Echo the STRING(s) to standard output.
+
+  -n     do not output the trailing newline
+  --help display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
@@ -9,21 +18,52 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'n', type: Boolean, alias: 'n', description: 'Do not output the trailing newline' },
-      { name: 'text', type: String, typeLabel: '{underline text}', defaultOption: true, multiple: true, description: 'The text to print' }
-    ],
-    run: async (argv: CommandLineOptions, process?: Process) => {
-      const noNewline = (argv.n as boolean) || false
-      const text = ((argv.text as string[]) || []).join(' ')
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (argv.length === 0) {
+        await writelnStdout(process, terminal, '')
+        return 0
+      }
+
+      let noNewline = false
+      const textParts: string[] = []
+      let i = 0
+
+      while (i < argv.length) {
+        const arg = argv[i]
+        if (!arg) {
+          i++
+          continue
+        }
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-n') {
+          noNewline = true
+        } else if (arg.startsWith('-') && arg.length > 1 && arg !== '--') {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('n')) {
+            noNewline = true
+          }
+          const invalidFlag = flags.find(f => f !== 'n')
+          if (invalidFlag) {
+            await writelnStdout(process, terminal, `echo: invalid option -- '${invalidFlag}'`)
+            return 1
+          }
+        } else {
+          textParts.push(arg)
+        }
+        i++
+      }
+
+      const text = textParts.join(' ')
       const output = noNewline ? text : text + '\n'
-      const data = new TextEncoder().encode(output)
 
       if (process) {
         const writer = process.stdout.getWriter()
         try {
-          await writer.write(data)
+          await writer.write(new TextEncoder().encode(output))
         } finally {
           writer.releaseLock()
         }

package/src/commands/false.ts

@@ -0,0 +1,31 @@
+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: false
+Return an unsuccessful exit 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: 'false',
+    description: 'Return an unsuccessful exit status',
+    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
+      }
+
+      return 1
+    }
+  })
+}

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()
+      }
+    }
+  })
+}