@ecmaos/coreutils 0.1.5 → 0.2.1

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

package/src/commands/rmdir.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: rmdir [OPTION]... DIRECTORY...
+Remove the DIRECTORY(ies), if they are empty.
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
@@ -10,16 +18,37 @@ 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 remove' }
-    ],
-    run: async (argv: CommandLineOptions) => {
-      const target = (argv.path as string) || shell.cwd
-      const fullPath = target ? path.resolve(shell.cwd, target) : shell.cwd
-      await shell.context.fs.promises.rm(fullPath, { recursive: true, force: true })
-      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
+      }
+
+      if (argv.length === 0) {
+        await writelnStderr(process, terminal, 'rmdir: missing operand')
+        await writelnStderr(process, terminal, "Try 'rmdir --help' for more information.")
+        return 1
+      }
+
+      let hasError = false
+
+      for (const target of argv) {
+        if (!target || target.startsWith('-')) continue
+
+        const fullPath = target ? path.resolve(shell.cwd, target) : shell.cwd
+        
+        try {
+          await shell.context.fs.promises.rm(fullPath, { recursive: true, force: true })
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error)
+          await writelnStderr(process, terminal, `rmdir: ${target}: ${errorMessage}`)
+          hasError = true
+        }
+      }
+
+      return hasError ? 1 : 0
     }
   })
 }
-

package/src/commands/sed.ts

@@ -1,5 +1,4 @@
 import path from 'path'
-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'
@@ -16,6 +15,19 @@ interface SedCommand {
   }
 }
 
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: sed [OPTION]... {script-only-if-no-other-script} [input-file]...
+
+Stream editor for filtering and transforming text.
+
+  -e, --expression=script  add the script to the commands to be executed
+  -f, --file=script-file    add the contents of script-file to the commands
+  -i[SUFFIX], --in-place[=SUFFIX]  edit files in place (makes backup if SUFFIX supplied)
+  -q, --quiet               suppress normal output
+  --help                    display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
 function parseSedExpression(expr: string): SedCommand | null {
   expr = expr.trim()
   
@@ -203,21 +215,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: 'expression', type: String, alias: 'e', multiple: true, description: 'Add the script to the commands to be executed' },
-      { name: 'file', type: String, alias: 'f', description: 'Add the contents of script-file to the commands to be executed' },
-      { name: 'inplace', type: String, alias: 'i', description: 'Edit files in place (makes backup if extension supplied)' },
-      { name: 'quiet', type: Boolean, alias: 'q', description: 'Suppress normal output' },
-      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, multiple: true, description: 'Expression or input file(s)' }
-    ],
-    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
 
-      let expressions = (argv.expression as string[]) || []
-      let files = (argv.path as string[]) || []
-      const inplace = argv.inplace as string | undefined
-      const quiet = argv.quiet as boolean || false
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      let expressions: string[] = []
+      const files: string[] = []
+      let scriptFile: string | undefined
+      let inplace: string | undefined
+      let quiet = false
 
       const isSedExpression = (arg: string): boolean => {
         if (!arg) return false
@@ -232,34 +244,56 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         )
       }
 
-      const potentialExpressions: string[] = []
-      const potentialFiles: string[] = []
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (!arg) continue
 
-      for (const arg of files) {
-        if (isSedExpression(arg)) {
-          potentialExpressions.push(arg)
-        } else {
-          potentialFiles.push(arg)
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-e' || arg === '--expression') {
+          if (i + 1 < argv.length) {
+            expressions.push(argv[++i] || '')
+          }
+        } else if (arg.startsWith('--expression=')) {
+          expressions.push(arg.slice(13))
+        } else if (arg.startsWith('-e')) {
+          expressions.push(arg.slice(2))
+        } else if (arg === '-f' || arg === '--file') {
+          if (i + 1 < argv.length) {
+            scriptFile = argv[++i]
+          }
+        } else if (arg.startsWith('--file=')) {
+          scriptFile = arg.slice(7)
+        } else if (arg.startsWith('-f')) {
+          scriptFile = arg.slice(2)
+        } else if (arg === '-i' || arg === '--in-place') {
+          inplace = ''
+        } else if (arg.startsWith('--in-place=')) {
+          inplace = arg.slice(12)
+        } else if (arg.startsWith('-i')) {
+          inplace = arg.slice(2) || ''
+        } else if (arg === '-q' || arg === '--quiet') {
+          quiet = true
+        } else if (isSedExpression(arg)) {
+          expressions.push(arg)
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
         }
       }
 
-      if (potentialExpressions.length > 0) {
-        expressions = [...expressions, ...potentialExpressions]
-        files = potentialFiles
-      }
-
-      if (expressions.length === 0 && !argv.file) {
+      if (expressions.length === 0 && !scriptFile) {
         await writelnStderr(process, terminal, 'sed: No expression provided')
         return 1
       }
 
       const commands: SedCommand[] = []
 
-      if (argv.file) {
-        const scriptPath = path.resolve(shell.cwd, argv.file as string)
+      if (scriptFile) {
+        const scriptPath = path.resolve(shell.cwd, scriptFile)
         const exists = await shell.context.fs.promises.exists(scriptPath)
         if (!exists) {
-          await writelnStderr(process, terminal, `sed: ${argv.file}: No such file or directory`)
+          await writelnStderr(process, terminal, `sed: ${scriptFile}: No such file or directory`)
           return 1
         }