@ecmaos/coreutils 0.1.4 → 0.2.0

package/src/commands/nl.ts

@@ -0,0 +1,201 @@
+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: nl [OPTION]... [FILE]...
+Number lines of files.
+
+  -v, --starting-line=NUMBER  first line number for each section (default: 1)
+  -i, --increment=NUMBER      line number increment at each line (default: 1)
+  -n, --format=FORMAT         line number format: ln, rn, rz (default: rn)
+  -w, --width=NUMBER          use NUMBER columns for line numbers (default: 6)
+  -s, --separator=STRING      add STRING after (possible) line number (default: TAB)
+  --help                      display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'nl',
+    description: 'Number 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
+      }
+
+      const files: string[] = []
+      let startLine = 1
+      let increment = 1
+      let format = 'rn'
+      let width = 6
+      let separator = '\t'
+
+      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 === '-v' || arg === '--starting-line') {
+          if (i + 1 < argv.length) {
+            const nextArg = argv[++i]
+            if (nextArg !== undefined) {
+              const num = parseInt(nextArg, 10)
+              if (!isNaN(num)) startLine = num
+            }
+          }
+        } else if (arg.startsWith('--starting-line=')) {
+          const num = parseInt(arg.slice(16), 10)
+          if (!isNaN(num)) startLine = num
+        } else if (arg === '-i' || arg === '--increment') {
+          if (i + 1 < argv.length) {
+            const nextArg = argv[++i]
+            if (nextArg !== undefined) {
+              const num = parseInt(nextArg, 10)
+              if (!isNaN(num)) increment = num
+            }
+          }
+        } else if (arg.startsWith('--increment=')) {
+          const num = parseInt(arg.slice(12), 10)
+          if (!isNaN(num)) increment = num
+        } else if (arg === '-n' || arg === '--format') {
+          if (i + 1 < argv.length) {
+            format = argv[++i] || 'rn'
+          }
+        } else if (arg.startsWith('--format=')) {
+          format = arg.slice(9) || 'rn'
+        } else if (arg === '-w' || arg === '--width') {
+          if (i + 1 < argv.length) {
+            const nextArg = argv[++i]
+            if (nextArg !== undefined) {
+              const num = parseInt(nextArg, 10)
+              if (!isNaN(num)) width = num
+            }
+          }
+        } else if (arg.startsWith('--width=')) {
+          const num = parseInt(arg.slice(8), 10)
+          if (!isNaN(num)) width = num
+        } else if (arg === '-s' || arg === '--separator') {
+          if (i + 1 < argv.length) {
+            separator = argv[++i] || '\t'
+          }
+        } else if (arg.startsWith('--separator=')) {
+          separator = arg.slice(12) || '\t'
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      const formatNumber = (num: number): string => {
+        const numStr = num.toString()
+        if (format === 'rz') {
+          return numStr.padStart(width, '0')
+        } else if (format === 'ln') {
+          return numStr.padEnd(width, ' ')
+        } else {
+          return numStr.padStart(width, ' ')
+        }
+      }
+
+      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, `nl: ${file}: cannot number 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, `nl: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        let lineNumber = startLine
+        for (const line of lines) {
+          const formattedNum = formatNumber(lineNumber)
+          await writer.write(new TextEncoder().encode(`${formattedNum}${separator}${line}\n`))
+          lineNumber += increment
+        }
+
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/passkey.ts

@@ -1,9 +1,21 @@
 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 { writelnStdout, writelnStderr } from '../shared/helpers.js'
 
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: passkey <subcommand> [options]
+
+Subcommands:
+  register [--name <name>]    Register a new passkey
+  list                        List all registered passkeys
+  remove --id <id>            Remove a specific passkey
+  remove-all                  Remove all passkeys
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'passkey',
@@ -11,15 +23,16 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'subcommand', type: String, defaultOption: true, description: 'Subcommand: register, list, remove, remove-all' },
-      { name: 'name', type: String, description: 'Name/description for the passkey (used with register)' },
-      { name: 'id', type: String, description: 'Passkey ID to remove (used with remove)' }
-    ],
-    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
 
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
       const currentUid = shell.credentials.uid
       const user = kernel.users.get(currentUid)
       if (!user) {
@@ -27,16 +40,32 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return 1
       }
 
-      const subcommand = (argv.subcommand as string)?.toLowerCase()
+      if (argv.length === 0) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      const subcommand = argv[0]?.toLowerCase()
+      let name: string | undefined
+      let id: string | undefined
+
+      for (let i = 1; i < argv.length; i++) {
+        const arg = argv[i]
+        if (!arg) continue
+
+        if (arg === '--name' && i + 1 < argv.length) {
+          name = argv[++i]
+        } else if (arg.startsWith('--name=')) {
+          name = arg.slice(7)
+        } else if (arg === '--id' && i + 1 < argv.length) {
+          id = argv[++i]
+        } else if (arg.startsWith('--id=')) {
+          id = arg.slice(5)
+        }
+      }
 
-      if (!subcommand || subcommand === 'help' || argv.help) {
-        await writelnStdout(process, terminal, 'Usage: passkey <subcommand> [options]')
-        await writelnStdout(process, terminal, '')
-        await writelnStdout(process, terminal, 'Subcommands:')
-        await writelnStdout(process, terminal, '  register [--name <name>]    Register a new passkey')
-        await writelnStdout(process, terminal, '  list                        List all registered passkeys')
-        await writelnStdout(process, terminal, '  remove --id <id>            Remove a specific passkey')
-        await writelnStdout(process, terminal, '  remove-all                  Remove all passkeys')
+      if (!subcommand || subcommand === 'help') {
+        printUsage(process, terminal)
         return 0
       }
 
@@ -48,7 +77,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
               return 1
             }
 
-            const name = (argv.name as string) || undefined
             const username = user.username
             const userId = new TextEncoder().encode(username)
 
@@ -156,7 +184,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           }
 
           case 'remove': {
-            const id = argv.id as string
             if (!id) {
               await writelnStderr(process, terminal, chalk.red('Error: --id is required for remove command'))
               await writelnStdout(process, terminal, 'Usage: passkey remove --id <id>')

package/src/commands/paste.ts

@@ -0,0 +1,172 @@
+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: paste [OPTION]... [FILE]...
+Merge lines of files.
+
+  -d, --delimiters=LIST  reuse characters from LIST instead of TABs
+  -s, --serial           paste one file at a time instead of in parallel
+  --help                 display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'paste',
+    description: 'Merge 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
+      }
+
+      const files: string[] = []
+      let delimiters = '\t'
+      let serial = false
+
+      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 === '-d' || arg === '--delimiters') {
+          if (i + 1 < argv.length) {
+            delimiters = argv[++i] || '\t'
+          }
+        } else if (arg.startsWith('--delimiters=')) {
+          delimiters = arg.slice(13)
+        } else if (arg.startsWith('-d')) {
+          delimiters = arg.slice(2) || '\t'
+        } else if (arg === '-s' || arg === '--serial') {
+          serial = true
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      const readFileLines = async (filePath: string): Promise<string[]> => {
+        if (filePath.startsWith('/dev')) {
+          throw new Error('cannot paste 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 {
+        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')
+          if (lines[lines.length - 1] === '') {
+            lines.pop()
+          }
+
+          for (const line of lines) {
+            await writer.write(new TextEncoder().encode(line + '\n'))
+          }
+
+          return 0
+        }
+
+        const fileLines: string[][] = []
+
+        for (const file of files) {
+          const fullPath = path.resolve(shell.cwd, file)
+          try {
+            const lines = await readFileLines(fullPath)
+            fileLines.push(lines)
+          } catch (error) {
+            await writelnStderr(process, terminal, `paste: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            return 1
+          }
+        }
+
+        if (serial) {
+          for (const file of fileLines) {
+            for (const line of file) {
+              await writer.write(new TextEncoder().encode(line + '\n'))
+            }
+          }
+        } else {
+          const maxLines = Math.max(...fileLines.map(f => f.length))
+          const delimiter = delimiters[0] || '\t'
+
+          for (let i = 0; i < maxLines; i++) {
+            const parts: string[] = []
+            for (const file of fileLines) {
+              parts.push(file[i] || '')
+            }
+            await writer.write(new TextEncoder().encode(parts.join(delimiter) + '\n'))
+          }
+        }
+
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/pwd.ts

@@ -2,6 +2,14 @@ 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: pwd
+Print the name of the current working directory.
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'pwd',
@@ -9,10 +17,14 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') }
-    ],
-    run: async (_argv, process?: Process) => {
+    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.cwd)
       return 0
     }

package/src/commands/rm.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 { writelnStderr } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: rm [OPTION]... FILE...
+Remove (unlink) the FILE(s).
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
@@ -10,17 +18,114 @@ 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 file or directory to remove' }
-    ],
-    run: async (argv: CommandLineOptions) => {
-      const target = (argv.path as string) || shell.cwd
-      const fullPath = target ? path.resolve(shell.cwd, target) : shell.cwd
-      if ((await shell.context.fs.promises.stat(fullPath)).isDirectory()) await shell.context.fs.promises.rmdir(fullPath)
-      else await shell.context.fs.promises.unlink(fullPath)
-      return 0
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (argv.length === 0) {
+        await writelnStderr(process, terminal, 'rm: missing operand')
+        await writelnStderr(process, terminal, "Try 'rm --help' for more information.")
+        return 1
+      }
+
+      if (argv[0] === '--help' || argv[0] === '-h') {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      const pathArray: string[] = []
+      for (const arg of argv) {
+        if (arg.startsWith('-') && arg !== '--') {
+          if (arg !== '-f' && arg !== '-r' && arg !== '-rf' && arg !== '-fr') {
+            await writelnStderr(process, terminal, `rm: invalid option -- '${arg.slice(1)}'`)
+            await writelnStderr(process, terminal, "Try 'rm --help' for more information.")
+            return 1
+          }
+        } else {
+          pathArray.push(arg)
+        }
+      }
+
+      if (pathArray.length === 0) {
+        await writelnStderr(process, terminal, 'rm: missing operand')
+        await writelnStderr(process, terminal, "Try 'rm --help' for more information.")
+        return 1
+      }
+
+      const expandGlob = async (pattern: string): Promise<string[]> => {
+        if (!pattern.includes('*') && !pattern.includes('?')) {
+          return [pattern]
+        }
+
+        const lastSlashIndex = pattern.lastIndexOf('/')
+        const searchDir = lastSlashIndex !== -1
+          ? path.resolve(shell.cwd, pattern.substring(0, lastSlashIndex + 1))
+          : shell.cwd
+        const globPattern = lastSlashIndex !== -1
+          ? pattern.substring(lastSlashIndex + 1)
+          : pattern
+
+        try {
+          const entries = await shell.context.fs.promises.readdir(searchDir)
+          const regexPattern = globPattern
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.')
+          const regex = new RegExp(`^${regexPattern}$`)
+          
+          const matches = entries.filter(entry => regex.test(entry))
+          
+          if (lastSlashIndex !== -1) {
+            const dirPart = pattern.substring(0, lastSlashIndex + 1)
+            return matches.map(match => dirPart + match)
+          }
+          return matches
+        } catch (error) {
+          return []
+        }
+      }
+
+      const expandedPaths: string[] = []
+      for (const pattern of pathArray) {
+        const expanded = await expandGlob(pattern)
+        if (expanded.length === 0) {
+          expandedPaths.push(pattern)
+        } else {
+          expandedPaths.push(...expanded)
+        }
+      }
+
+      if (expandedPaths.length === 0) {
+        await writelnStderr(process, terminal, 'rm: missing operand')
+        await writelnStderr(process, terminal, "Try 'rm --help' for more information.")
+        return 1
+      }
+
+      let hasError = false
+
+      for (const target of expandedPaths) {
+        if (!target || typeof target !== 'string') {
+          await writelnStderr(process, terminal, `rm: ${String(target)}: No such file or directory`)
+          hasError = true
+          continue
+        }
+
+        const fullPath = path.resolve(shell.cwd, target)
+
+        try {
+          const stat = await shell.context.fs.promises.stat(fullPath)
+          if (stat.isDirectory()) {
+            await shell.context.fs.promises.rmdir(fullPath)
+          } else {
+            await shell.context.fs.promises.unlink(fullPath)
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error)
+          await writelnStderr(process, terminal, `rm: ${target}: ${errorMessage}`)
+          hasError = true
+        }
+      }
+
+      return hasError ? 1 : 0
     }
   })
 }
-