@ecmaos/coreutils 0.1.5 → 0.2.0

package/src/commands/cd.ts

@@ -1,6 +1,16 @@
 import path from 'path'
-import type { Kernel, Shell, Terminal } from '@ecmaos/types'
+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: cd [DIRECTORY]
+Change the shell working directory.
+
+  DIRECTORY  the directory to change to (default: $HOME)
+  --help     display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
@@ -9,18 +19,36 @@ 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 directory to change to' }
-    ],
-    run: async (argv) => {
-      const destination = (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 destination = argv.length > 0 && argv[0] && !argv[0].startsWith('-') ? argv[0] : shell.cwd
       const fullPath = destination ? path.resolve(shell.cwd, destination) : shell.cwd
-      await shell.context.fs.promises.access(fullPath)
-      shell.cwd = fullPath
-      localStorage.setItem(`cwd:${shell.credentials.uid}`, fullPath)
-      return 0
+      
+      try {
+        await shell.context.fs.promises.access(fullPath)
+        shell.cwd = fullPath
+        localStorage.setItem(`cwd:${shell.credentials.uid}`, fullPath)
+        return 0
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        if (process) {
+          const writer = process.stderr.getWriter()
+          try {
+            await writer.write(new TextEncoder().encode(`cd: ${destination}: ${errorMessage}\n`))
+          } finally {
+            writer.releaseLock()
+          }
+        } else {
+          terminal.write(`cd: ${destination}: ${errorMessage}\n`)
+        }
+        return 1
+      }
     }
   })
 }
-

package/src/commands/chmod.ts

@@ -1,10 +1,17 @@
 import path from 'path'
 import chalk from 'chalk'
-import type { CommandLineOptions } from 'command-line-args'
 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: chmod [OPTION]... MODE[,MODE]... FILE...
+Change the mode of each FILE to MODE.
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'chmod',
@@ -12,12 +19,21 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'args', type: String, multiple: true, defaultOption: true, description: 'The mode and path to the file or directory' }
-    ],
-    run: async (argv: CommandLineOptions, process?: Process) => {
-      const args = (argv.args as string[]) || []
+    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 args: string[] = []
+      for (const arg of argv) {
+        if (arg && !arg.startsWith('-')) {
+          args.push(arg)
+        }
+      }
+
       if (args.length === 0) {
         await writelnStderr(process, terminal, chalk.red('chmod: missing operand'))
         await writelnStderr(process, terminal, 'Try \'chmod --help\' for more information.')
@@ -25,11 +41,21 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
       }
 
       const [mode, target] = args
-      if (!mode || !target) return 1
+      if (!mode || !target) {
+        await writelnStderr(process, terminal, chalk.red('chmod: missing operand'))
+        return 1
+      }
+
       const fullPath = path.resolve(shell.cwd, target)
-      await shell.context.fs.promises.chmod(fullPath, mode)
-      return 0
+      
+      try {
+        await shell.context.fs.promises.chmod(fullPath, mode)
+        return 0
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        await writelnStderr(process, terminal, `chmod: ${target}: ${errorMessage}`)
+        return 1
+      }
     }
   })
 }
-

package/src/commands/comm.ts

@@ -0,0 +1,169 @@
+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: comm [OPTION]... FILE1 FILE2
+Compare two sorted files line by line.
+
+  -1     suppress lines unique to FILE1
+  -2     suppress lines unique to FILE2
+  -3     suppress lines that appear in both files
+  --help display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'comm',
+    description: 'Compare two sorted 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[] = []
+      let suppress1 = false
+      let suppress2 = false
+      let suppress3 = false
+
+      for (const arg of argv) {
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-1') {
+          suppress1 = true
+        } else if (arg === '-2') {
+          suppress2 = true
+        } else if (arg === '-3') {
+          suppress3 = true
+        } else if (!arg.startsWith('-')) {
+          if (files.length < 2) {
+            files.push(arg)
+          }
+        }
+      }
+
+      if (files.length !== 2) {
+        await writelnStderr(process, terminal, 'comm: exactly two files must be specified')
+        return 1
+      }
+
+      const file1 = files[0]
+      const file2 = files[1]
+      if (!file1 || !file2) {
+        await writelnStderr(process, terminal, 'comm: exactly two files must be specified')
+        return 1
+      }
+
+      const writer = process.stdout.getWriter()
+
+      const readFileLines = async (filePath: string): Promise<string[]> => {
+        if (filePath.startsWith('/dev')) {
+          throw new Error('cannot comm 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
+          }
+
+          const lines = content.split('\n')
+          if (lines[lines.length - 1] === '') {
+            lines.pop()
+          }
+          return lines
+        } finally {
+          kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+        }
+      }
+
+      try {
+        const fullPath1 = path.resolve(shell.cwd || '/', file1)
+        const fullPath2 = path.resolve(shell.cwd || '/', file2)
+
+        const lines1 = await readFileLines(fullPath1)
+        const lines2 = await readFileLines(fullPath2)
+
+        let i = 0
+        let j = 0
+
+        while (i < lines1.length || j < lines2.length) {
+          if (i >= lines1.length) {
+            if (!suppress2) {
+              const prefix = suppress1 ? '' : '\t'
+              await writer.write(new TextEncoder().encode(prefix + lines2[j] + '\n'))
+            }
+            j++
+          } else if (j >= lines2.length) {
+            if (!suppress1) {
+              await writer.write(new TextEncoder().encode(lines1[i] + '\n'))
+            }
+            i++
+          } else {
+            const line1 = lines1[i]
+            const line2 = lines2[j]
+            if (!line1 || !line2) {
+              break
+            }
+            const cmp = line1.localeCompare(line2)
+            if (cmp < 0) {
+              if (!suppress1) {
+                await writer.write(new TextEncoder().encode(lines1[i] + '\n'))
+              }
+              i++
+            } else if (cmp > 0) {
+              if (!suppress2) {
+                const prefix = suppress1 ? '' : '\t'
+                await writer.write(new TextEncoder().encode(prefix + lines2[j] + '\n'))
+              }
+              j++
+            } else {
+              if (!suppress3) {
+                const prefix = suppress1 && suppress2 ? '' : suppress1 ? '\t' : suppress2 ? '' : '\t\t'
+                await writer.write(new TextEncoder().encode(prefix + lines1[i] + '\n'))
+              }
+              i++
+              j++
+            }
+          }
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `comm: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/cp.ts

@@ -1,7 +1,15 @@
 import path from 'path'
-import type { CommandLineOptions } from 'command-line-args'
-import type { Kernel, Shell, Terminal } from '@ecmaos/types'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: cp [OPTION]... SOURCE... DEST
+Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
@@ -10,19 +18,69 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'args', type: String, multiple: true, defaultOption: true, description: 'The source and destination paths' }
-    ],
-    run: async (argv: CommandLineOptions) => {
-      const args = (argv.args as string[]) || []
-      const [source, destination] = args.map(arg => path.resolve(shell.cwd, arg))
-      if (!source || !destination) return 1
-      const destinationStats = await shell.context.fs.promises.stat(destination).catch(() => null)
-      const finalDestination = destinationStats?.isDirectory() ? path.join(destination, path.basename(source)) : destination
-      await shell.context.fs.promises.copyFile(source, finalDestination)
-      return 0
+    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 args: string[] = []
+      for (const arg of argv) {
+        if (arg && !arg.startsWith('-')) {
+          args.push(arg)
+        }
+      }
+
+      if (args.length < 2) {
+        await writelnStderr(process, terminal, 'cp: missing file operand')
+        await writelnStderr(process, terminal, "Try 'cp --help' for more information.")
+        return 1
+      }
+
+      const sources = args.slice(0, -1)
+      const destination = args[args.length - 1]
+
+      if (!destination) {
+        await writelnStderr(process, terminal, 'cp: missing destination file operand')
+        return 1
+      }
+
+      let hasError = false
+
+      try {
+        const destinationStats = await shell.context.fs.promises.stat(path.resolve(shell.cwd, destination)).catch(() => null)
+        const isDestinationDir = destinationStats?.isDirectory()
+
+        if (sources.length > 1 && !isDestinationDir) {
+          await writelnStderr(process, terminal, `cp: target '${destination}' is not a directory`)
+          return 1
+        }
+
+        for (const source of sources) {
+          if (!source) continue
+
+          const sourcePath = path.resolve(shell.cwd, source)
+          const finalDestination = isDestinationDir 
+            ? path.join(path.resolve(shell.cwd, destination), path.basename(source))
+            : path.resolve(shell.cwd, destination)
+
+          try {
+            await shell.context.fs.promises.copyFile(sourcePath, finalDestination)
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error)
+            await writelnStderr(process, terminal, `cp: ${source}: ${errorMessage}`)
+            hasError = true
+          }
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        await writelnStderr(process, terminal, `cp: ${errorMessage}`)
+        hasError = true
+      }
+
+      return hasError ? 1 : 0
     }
   })
 }
-

package/src/commands/cut.ts

@@ -0,0 +1,214 @@
+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: cut OPTION... [FILE]...
+Remove sections from each line of files.
+
+  -f, --fields=LIST       select only these fields
+  -d, --delimiter=DELIM   use DELIM instead of TAB for field delimiter
+  -c, --characters=LIST    select only these characters
+  --help                  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'cut',
+    description: 'Remove sections from each line 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 fields: string | undefined
+      let delimiter: string = '\t'
+      let characters: string | undefined
+      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 === '-f' || arg.startsWith('-f')) {
+          if (arg === '-f' && i + 1 < argv.length) {
+            i++
+            const nextArg = argv[i]
+            if (nextArg !== undefined) {
+              fields = nextArg
+            }
+          } else if (arg.startsWith('-f') && arg.length > 2) {
+            fields = arg.slice(2)
+          } else if (arg.startsWith('--fields=')) {
+            fields = arg.slice(9)
+          }
+        } else if (arg === '-c' || arg.startsWith('-c')) {
+          if (arg === '-c' && i + 1 < argv.length) {
+            i++
+            const nextArg = argv[i]
+            if (nextArg !== undefined) {
+              characters = nextArg
+            }
+          } else if (arg.startsWith('-c') && arg.length > 2) {
+            characters = arg.slice(2)
+          } else if (arg.startsWith('--characters=')) {
+            characters = arg.slice(13)
+          }
+        } else if (arg === '-d' || arg.startsWith('-d')) {
+          if (arg === '-d' && i + 1 < argv.length) {
+            i++
+            const nextArg = argv[i]
+            if (nextArg !== undefined) {
+              delimiter = nextArg
+            }
+          } else if (arg.startsWith('-d') && arg.length > 2) {
+            delimiter = arg.slice(2)
+          } else if (arg.startsWith('--delimiter=')) {
+            delimiter = arg.slice(12)
+          }
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        }
+      }
+
+      if (!fields && !characters) {
+        await writelnStderr(process, terminal, 'cut: you must specify a list of bytes, characters, or fields')
+        return 1
+      }
+
+      const writer = process.stdout.getWriter()
+
+      const parseRange = (range: string): number[] => {
+        const result: number[] = []
+        const parts = range.split(',')
+        
+        for (const part of parts) {
+          if (part.includes('-')) {
+            const splitParts = part.split('-')
+            const start = splitParts[0]
+            const end = splitParts[1]
+            const startNum = (start === '' || start === undefined) ? 1 : parseInt(start, 10)
+            const endNum = (end === '' || end === undefined) ? Infinity : parseInt(end, 10)
+            
+            for (let i = startNum; i <= endNum; i++) {
+              result.push(i)
+            }
+          } else {
+            result.push(parseInt(part, 10))
+          }
+        }
+        
+        return result.sort((a, b) => a - b)
+      }
+
+      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, `cut: ${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, `cut: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        for (const line of lines) {
+          let output = ''
+
+          if (characters) {
+            const indices = parseRange(characters)
+            const chars = line.split('')
+            output = indices.map(i => chars[i - 1] || '').join('')
+          } else if (fields) {
+            const indices = parseRange(fields)
+            const parts = line.split(delimiter)
+            output = indices.map(i => (parts[i - 1] || '')).join(delimiter)
+          }
+
+          await writer.write(new TextEncoder().encode(output + '\n'))
+        }
+
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}