@ecmaos/coreutils 0.1.4 → 0.2.0

package/src/commands/cal.ts

@@ -0,0 +1,111 @@
+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: cal [MONTH] [YEAR]
+Display a calendar.
+
+  MONTH   month (1-12)
+  YEAR    year
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'cal',
+    description: 'Display a calendar',
+    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 month: number | undefined
+      let year: number | undefined
+
+      if (argv.length === 1) {
+        const argStr = argv[0]
+        if (!argStr) {
+          month = now.getMonth() + 1
+          year = now.getFullYear()
+        } else {
+          const arg = parseInt(argStr, 10)
+          if (isNaN(arg)) {
+            await writelnStdout(process, terminal, 'cal: invalid argument')
+            return 1
+          }
+          if (arg >= 1 && arg <= 12) {
+            month = arg
+            year = now.getFullYear()
+          } else {
+            year = arg
+            month = now.getMonth() + 1
+          }
+        }
+      } else if (argv.length === 2) {
+        const monthStr = argv[0]
+        const yearStr = argv[1]
+        if (!monthStr || !yearStr) {
+          await writelnStdout(process, terminal, 'cal: invalid arguments')
+          return 1
+        }
+        month = parseInt(monthStr, 10)
+        year = parseInt(yearStr, 10)
+        if (isNaN(month) || isNaN(year)) {
+          await writelnStdout(process, terminal, 'cal: invalid arguments')
+          return 1
+        }
+      } else {
+        month = now.getMonth() + 1
+        year = now.getFullYear()
+      }
+
+      if (month < 1 || month > 12) {
+        await writelnStdout(process, terminal, 'cal: invalid month')
+        return 1
+      }
+
+      const monthNames = ['January', 'February', 'March', 'April', 'May', 'June',
+        'July', 'August', 'September', 'October', 'November', 'December']
+      const dayNames = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa']
+
+      const firstDay = new Date(year, month - 1, 1)
+      const lastDay = new Date(year, month, 0)
+      const daysInMonth = lastDay.getDate()
+      const startDayOfWeek = firstDay.getDay()
+
+      let output = `     ${monthNames[month - 1]} ${year}\n`
+      output += dayNames.join(' ') + '\n'
+
+      let day = 1
+      let isFirstWeek = true
+
+      while (day <= daysInMonth) {
+        let line = ''
+        for (let i = 0; i < 7; i++) {
+          if (isFirstWeek && i < startDayOfWeek) {
+            line += '   '
+          } else if (day <= daysInMonth) {
+            line += day.toString().padStart(2) + ' '
+            day++
+          } else {
+            line += '   '
+          }
+        }
+        output += line.trimEnd() + '\n'
+        isFirstWeek = false
+      }
+
+      await writelnStdout(process, terminal, output)
+      return 0
+    }
+  })
+}

package/src/commands/cat.ts

@@ -1,9 +1,16 @@
 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 { writeStdout } from '../shared/helpers.js'
+import { writelnStdout } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: cat [OPTION]... [FILE]...
+Concatenate files and print on the standard output.
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
@@ -12,38 +19,58 @@ 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, multiple: true, description: 'The path(s) to the file(s) to concatenate' },
-      { name: 'bytes', type: Number, description: 'The number of bytes to read from the file' }
-    ],
-    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
 
-      // Get a single writer for the entire operation
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      const files: string[] = []
+
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (arg === undefined) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        }
+      }
+
       const writer = process.stdout.getWriter()
+      const isTTY = process.stdoutIsTTY ?? false
+      let lastByte: number | undefined
 
       try {
-        // If no files specified, read from stdin
-        if (!argv.path || !(argv.path as string[])[0]) {
+        if (files.length === 0) {
           const reader = process.stdin!.getReader()
 
           try {
             while (true) {
               const { done, value } = await reader.read()
               if (done) break
+              if (value.length > 0) {
+                lastByte = value[value.length - 1]
+              }
               await writer.write(value)
             }
           } finally {
             reader.releaseLock()
           }
 
+          if (isTTY && lastByte !== undefined && lastByte !== 0x0A) {
+            await writer.write(new Uint8Array([0x0A]))
+          }
+
           return 0
         }
 
-        // Otherwise process files
-        const files = (argv.path as string[]) || []
-        const bytes = argv.bytes as string | undefined
         for (const file of files) {
           const fullPath = path.resolve(shell.cwd, file)
 
@@ -64,13 +91,15 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
                 const data = new Uint8Array(chunkSize)
                 const readSize = Math.min(chunkSize, stat.size - bytesRead)
                 await handle.read(data, 0, readSize, bytesRead)
-                await writer.write(data.subarray(0, readSize))
+                const chunk = data.subarray(0, readSize)
+                if (chunk.length > 0) {
+                  lastByte = chunk[chunk.length - 1]
+                }
+                await writer.write(chunk)
                 bytesRead += readSize
               }
             } else {
               const device = await shell.context.fs.promises.open(fullPath)
-              const maxBytes = bytes ? parseInt(bytes) : undefined
-              let totalBytesRead = 0
               const chunkSize = 1024
               const data = new Uint8Array(chunkSize)
               let bytesRead = 0
@@ -80,25 +109,27 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
                 const result = await device.read(data)
                 bytesRead = result.bytesRead
                 if (bytesRead > 0) {
-                  const bytesToWrite = maxBytes ? Math.min(bytesRead, maxBytes - totalBytesRead) : bytesRead
-                  if (bytesToWrite > 0) {
-                    await writer.write(data.subarray(0, bytesToWrite))
-                    totalBytesRead += bytesToWrite
+                  const chunk = data.subarray(0, bytesRead)
+                  if (chunk.length > 0) {
+                    lastByte = chunk[chunk.length - 1]
                   }
+                  await writer.write(chunk)
                 }
-              } while (bytesRead > 0 && (!maxBytes || totalBytesRead < maxBytes))
+              } while (bytesRead > 0)
             }
           } finally {
             kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
           }
         }
 
+        if (isTTY && lastByte !== undefined && lastByte !== 0x0A) {
+          await writer.write(new Uint8Array([0x0A]))
+        }
+
         return 0
       } finally {
         writer.releaseLock()
-        await writeStdout(process, terminal, '\n')
       }
     }
   })
 }
-

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