@ecmaos/coreutils 0.5.1 → 0.5.2

package/src/commands/mkdir.ts

@@ -1,16 +1,31 @@
 import path from 'path'
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
-import { writelnStderr } from '../shared/helpers.js'
+import { writelnStderr, writelnStdout } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: mkdir [OPTION]... DIRECTORY...
 Create the DIRECTORY(ies), if they do not already exist.
 
-  --help  display this help and exit`
+Mandatory arguments to long options are mandatory for short options too.
+  -m, --mode=MODE   set file mode (as in chmod), not a=rwx - umask
+  -p, --parents     no error if existing, make parent directories as needed,
+                    with their file modes unaffected by any -m option.
+  -v, --verbose     print a message for each created directory
+      --help        display this help and exit`
   writelnStderr(process, terminal, usage)
 }
 
+function parseNumericMode(mode: string): number | null {
+  if (/^0?[0-7]{1,4}$/.test(mode)) {
+    return parseInt(mode, 8)
+  }
+  if (/^0o[0-7]{1,4}$/i.test(mode)) {
+    return parseInt(mode.slice(2), 8)
+  }
+  return null
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'mkdir',
@@ -26,7 +41,104 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return 0
       }
 
-      if (argv.length === 0) {
+      let parents = false
+      let verbose = false
+      let mode: number | undefined = undefined
+      const directories: string[] = []
+
+      let i = 0
+      while (i < argv.length) {
+        const arg = argv[i]
+        if (!arg) {
+          i++
+          continue
+        }
+
+        if (arg === '--') {
+          i++
+          while (i < argv.length) {
+            const dirArg = argv[i]
+            if (dirArg) {
+              directories.push(dirArg)
+            }
+            i++
+          }
+          break
+        }
+
+        if (arg.startsWith('--')) {
+          if (arg === '--parents') {
+            parents = true
+          } else if (arg === '--verbose') {
+            verbose = true
+          } else if (arg.startsWith('--mode=')) {
+            const modeStr = arg.slice(7)
+            const parsedMode = parseNumericMode(modeStr)
+            if (parsedMode === null) {
+              await writelnStderr(process, terminal, `mkdir: invalid mode '${modeStr}'`)
+              return 1
+            }
+            mode = parsedMode
+          } else if (arg === '--help' || arg === '-h') {
+            printUsage(process, terminal)
+            return 0
+          } else {
+            await writelnStderr(process, terminal, `mkdir: unrecognized option '${arg}'`)
+            await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
+            return 1
+          }
+        } else if (arg.startsWith('-') && arg.length > 1) {
+          for (let j = 1; j < arg.length; j++) {
+            const flag = arg[j]
+            if (!flag) continue
+
+            if (flag === 'p') {
+              parents = true
+            } else if (flag === 'v') {
+              verbose = true
+            } else if (flag === 'm') {
+              if (j + 1 < arg.length) {
+                const modeStr = arg.slice(j + 1)
+                const parsedMode = parseNumericMode(modeStr)
+                if (parsedMode === null) {
+                  await writelnStderr(process, terminal, `mkdir: invalid mode '${modeStr}'`)
+                  return 1
+                }
+                mode = parsedMode
+                break
+              } else if (i + 1 < argv.length) {
+                const modeStr = argv[i + 1]
+                if (!modeStr) {
+                  await writelnStderr(process, terminal, "mkdir: option requires an argument -- 'm'")
+                  await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
+                  return 1
+                }
+                const parsedMode = parseNumericMode(modeStr)
+                if (parsedMode === null) {
+                  await writelnStderr(process, terminal, `mkdir: invalid mode '${modeStr}'`)
+                  return 1
+                }
+                mode = parsedMode
+                i++
+                break
+              } else {
+                await writelnStderr(process, terminal, "mkdir: option requires an argument -- 'm'")
+                await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
+                return 1
+              }
+            } else {
+              await writelnStderr(process, terminal, `mkdir: invalid option -- '${flag}'`)
+              await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
+              return 1
+            }
+          }
+        } else {
+          directories.push(arg)
+        }
+        i++
+      }
+
+      if (directories.length === 0) {
         await writelnStderr(process, terminal, 'mkdir: missing operand')
         await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
         return 1
@@ -34,17 +146,45 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
       let hasError = false
 
-      for (const target of argv) {
-        if (!target || target.startsWith('-')) continue
+      for (const target of directories) {
+        if (!target) continue
 
-        const fullPath = target ? path.resolve(shell.cwd, target) : shell.cwd
+        const fullPath = path.resolve(shell.cwd, target)
         
         try {
-          await shell.context.fs.promises.mkdir(fullPath)
+          const mkdirOptions: { recursive?: boolean; mode?: number } = {}
+          if (parents) {
+            mkdirOptions.recursive = true
+          }
+          if (mode !== undefined) {
+            mkdirOptions.mode = mode
+          }
+
+          let existedBefore = false
+          if (parents) {
+            try {
+              await shell.context.fs.promises.stat(fullPath)
+              existedBefore = true
+            } catch {
+              existedBefore = false
+            }
+          }
+
+          await shell.context.fs.promises.mkdir(fullPath, mkdirOptions)
+
+          if (verbose && !existedBefore) {
+            const relativePath = path.relative(shell.cwd, fullPath) || target
+            await writelnStdout(process, terminal, `mkdir: created directory '${relativePath}'`)
+          }
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error)
-          await writelnStderr(process, terminal, `mkdir: ${target}: ${errorMessage}`)
-          hasError = true
+          const err = error as { code?: string; message?: string }
+          if (parents && err.code === 'EEXIST') {
+            continue
+          } else {
+            const errorMessage = error instanceof Error ? error.message : String(error)
+            await writelnStderr(process, terminal, `mkdir: ${target}: ${errorMessage}`)
+            hasError = true
+          }
         }
       }
 

package/src/commands/sed.ts

@@ -236,9 +236,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         const trimmed = arg.trim()
         return (
           trimmed.startsWith('s/') ||
-          trimmed.startsWith('/') ||
-          /^\d+[sd]/.test(trimmed) ||
-          /^\d+,\d*[sd]/.test(trimmed) ||
+          /^\/.+?\/[dp]$/.test(trimmed) ||
+          /^\d+[sd]$/.test(trimmed) ||
+          /^\d+,\d*[sd]$/.test(trimmed) ||
           /^\d+s\//.test(trimmed) ||
           /^\d+,\d*s\//.test(trimmed)
         )
@@ -341,73 +341,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           return content.split('\n')
         }
 
-        let inputLines: string[] = []
-
-        if (files.length > 0) {
-          for (const file of files) {
-            const expandedPath = shell.expandTilde(file)
-            const fullPath = path.resolve(shell.cwd, expandedPath)
-            const lines = await processFile(fullPath)
-            inputLines.push(...lines)
-            if (lines.length > 0 && inputLines.length > lines.length) {
-              inputLines.push('')
-            }
-          }
-        } else {
-          if (!process.stdin) {
-            await writelnStderr(process, terminal, 'sed: No input provided')
-            return 1
-          }
-
-          const reader = process.stdin.getReader()
-          const decoder = new TextDecoder()
-          const chunks: string[] = []
-
-          try {
-            while (true) {
-              const { done, value } = await reader.read()
-              if (done) break
-              chunks.push(decoder.decode(value, { stream: true }))
-            }
-            chunks.push(decoder.decode(new Uint8Array(), { stream: false }))
-          } finally {
-            reader.releaseLock()
-          }
-
-          const content = chunks.join('')
-          inputLines = content.split('\n')
-        }
-
-        const outputLines: string[] = []
-        const totalLines = inputLines.length
-
-        for (let i = 0; i < inputLines.length; i++) {
-          let line = inputLines[i] || ''
-          let lineNum = i + 1
-          let shouldPrint = false
-
-          for (const command of commands) {
-            const { result, shouldPrint: print } = applySedCommand(line, lineNum, totalLines, command)
-            if (result === null) {
-              line = null as unknown as string
-              break
-            }
-            line = result
-            if (print) {
-              shouldPrint = true
-            }
-          }
-
-          if (line !== null) {
-            outputLines.push(line)
-            if (shouldPrint && !quiet) {
-              outputLines.push(line)
-            }
-          }
-        }
-
-        const output = outputLines.join('\n')
-
         if (inplace !== undefined && files.length > 0) {
           for (const file of files) {
             const expandedPath = shell.expandTilde(file)
@@ -455,6 +388,72 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             await shell.context.fs.promises.writeFile(fullPath, fileOutput)
           }
         } else {
+          let inputLines: string[] = []
+
+          if (files.length > 0) {
+            for (const file of files) {
+              const expandedPath = shell.expandTilde(file)
+              const fullPath = path.resolve(shell.cwd, expandedPath)
+              const lines = await processFile(fullPath)
+              inputLines.push(...lines)
+              if (lines.length > 0 && inputLines.length > lines.length) {
+                inputLines.push('')
+              }
+            }
+          } else {
+            if (!process.stdin) {
+              await writelnStderr(process, terminal, 'sed: No input provided')
+              return 1
+            }
+
+            const reader = process.stdin.getReader()
+            const decoder = new TextDecoder()
+            const chunks: string[] = []
+
+            try {
+              while (true) {
+                const { done, value } = await reader.read()
+                if (done) break
+                chunks.push(decoder.decode(value, { stream: true }))
+              }
+              chunks.push(decoder.decode(new Uint8Array(), { stream: false }))
+            } finally {
+              reader.releaseLock()
+            }
+
+            const content = chunks.join('')
+            inputLines = content.split('\n')
+          }
+
+          const outputLines: string[] = []
+          const totalLines = inputLines.length
+
+          for (let i = 0; i < inputLines.length; i++) {
+            let line = inputLines[i] || ''
+            let lineNum = i + 1
+            let shouldPrint = false
+
+            for (const command of commands) {
+              const { result, shouldPrint: print } = applySedCommand(line, lineNum, totalLines, command)
+              if (result === null) {
+                line = null as unknown as string
+                break
+              }
+              line = result
+              if (print) {
+                shouldPrint = true
+              }
+            }
+
+            if (line !== null) {
+              outputLines.push(line)
+              if (shouldPrint && !quiet) {
+                outputLines.push(line)
+              }
+            }
+          }
+
+          const output = outputLines.join('\n')
           await writer.write(new TextEncoder().encode(output))
         }
 

package/src/commands/view.ts

@@ -306,7 +306,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           }
 
           // Read file
-          await writelnStdout(process, terminal, chalk.blue(`Loading: ${file}...`))
           const fileData = await shell.context.fs.promises.readFile(fullPath)
           const fileType = detectFileType(fullPath)
           const mimeType = getMimeType(fullPath, fileType)
@@ -374,8 +373,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             })
             
             win.mount(container)
-
-            await writelnStdout(process, terminal, chalk.green(`Viewing: ${file}`))
           } else if (fileType === 'json') {
             // Read and parse JSON file
             const jsonText = new TextDecoder().decode(fileData)

package/src/index.ts

@@ -61,6 +61,7 @@ import { createCommand as createColumn } from './commands/column.js'
 import { createCommand as createComm } from './commands/comm.js'
 import { createCommand as createCurl } from './commands/curl.js'
 import { createCommand as createCut } from './commands/cut.js'
+import { createCommand as createDd } from './commands/dd.js'
 import { createCommand as createDate } from './commands/date.js'
 import { createCommand as createDiff } from './commands/diff.js'
 import { createCommand as createDirname } from './commands/dirname.js'
@@ -147,6 +148,7 @@ export { createCommand as createCmp } from './commands/cmp.js'
 export { createCommand as createColumn } from './commands/column.js'
 export { createCommand as createCurl } from './commands/curl.js'
 export { createCommand as createCut } from './commands/cut.js'
+export { createCommand as createDd } from './commands/dd.js'
 export { createCommand as createDate } from './commands/date.js'
 export { createCommand as createDiff } from './commands/diff.js'
 export { createCommand as createDirname } from './commands/dirname.js'
@@ -233,6 +235,7 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     comm: createComm(kernel, shell, terminal),
     curl: createCurl(kernel, shell, terminal),
     cut: createCut(kernel, shell, terminal),
+    dd: createDd(kernel, shell, terminal),
     date: createDate(kernel, shell, terminal),
     diff: createDiff(kernel, shell, terminal),
     dirname: createDirname(kernel, shell, terminal),
@@ -275,97 +278,3 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
 
 // For backward compatibility, export as TerminalCommands
 export { createAllCommands as TerminalCommands }
-
-export const CoreutilsDescriptions = {
-  awk: 'Pattern scanning and text processing language',
-  basename: 'Strip directory and suffix from filenames',
-  cal: 'Display a calendar',
-  cat: 'Concatenate files and print on the standard output',
-  cd: 'Change the shell working directory',
-  chmod: 'Change file mode bits',
-  chown: 'Change file owner and group',
-  cksum: 'Print CRC checksum and byte count',
-  cmp: 'Compare two files byte by byte',
-  column: 'Format input into columns',
-  comm: 'Compare two sorted files line by line',
-  cp: 'Copy files',
-  cron: 'Manage scheduled tasks (crontabs)',
-  curl: 'Transfer data from or to a server',
-  cut: 'Remove sections from each line of files',
-  date: 'Print or set the system date and time',
-  diff: 'Compare files line by line',
-  dirname: 'Strip last component from file path',
-  echo: 'Print arguments to the standard output',
-  env: 'Run a program in a modified environment',
-  expand: 'Convert tabs to spaces',
-  factor: 'Print prime factors of numbers',
-  false: 'Return an unsuccessful exit status',
-  fetch: 'Fetch a resource from the network',
-  find: 'Search for files in a directory hierarchy',
-  fmt: 'Reformat paragraph text',
-  fold: 'Wrap each input line to fit in specified width',
-  format: 'Delete all IndexedDB and localStorage data',
-  grep: 'Search for patterns in files or standard input',
-  groups: 'Print the groups a user belongs to',
-  hash: 'Compute and display hash values for files or standard input',
-  head: 'Print the first lines of files',
-  hostname: 'Print the system hostname',
-  id: 'Print user and group IDs',
-  join: 'Join lines of two files on a common field',
-  less: 'View file contents interactively',
-  ln: 'Create links between files',
-  ls: 'List directory contents',
-  man: 'Display manual pages',
-  mkdir: 'Create a directory',
-  mktemp: 'Create a temporary file or directory',
-  mount: 'Mount a filesystem',
-  mv: 'Move or rename files',
-  nc: 'Network utilities',
-  nl: 'Number lines of files',
-  od: 'Dump files in octal and other formats',
-  open: 'Open a file or URL',
-  passkey: 'Manage passkey credentials for WebAuthn authentication',
-  paste: 'Merge lines of files',
-  play: 'Play an audio file',
-  pr: 'Paginate or columnate files for printing',
-  printf: 'Format and print data',
-  pwd: 'Print the shell working directory',
-  readlink: 'Print value of a symbolic link or canonical file name',
-  realpath: 'Print the resolved absolute file name',
-  rev: 'Reverse the characters of each line',
-  rm: 'Remove files or directories',
-  rmdir: 'Remove a directory',
-  sed: 'Stream editor for filtering and transforming text',
-  seq: 'Print a sequence of numbers',
-  shuf: 'Write a random permutation of the input lines',
-  sleep: 'Delay for a specified amount of time',
-  sockets: 'Manage socket connections (WebSocket and WebTransport)',
-  sort: 'Sort lines of text files',
-  split: 'Split a file into pieces',
-  stat: 'Display information about a file or directory',
-  strings: 'Print the sequences of printable characters in files',
-  tac: 'Write FILE in reverse line order',
-  tail: 'Print the last lines of files',
-  tar: 'Create, extract, or list tar archives',
-  tee: 'Read from standard input and write to standard output and files',
-  test: 'Check file types and compare values',
-  time: 'Measure command execution time',
-  touch: 'Create an empty file',
-  tr: 'Translate or delete characters',
-  true: 'Return a successful exit status',
-  umount: 'Unmount a filesystem',
-  uname: 'Print system information',
-  unexpand: 'Convert spaces to tabs',
-  uniq: 'Report or omit repeated lines',
-  unzip: 'Extract zip archives',
-  uptime: 'Print how long the system has been running',
-  user: 'Manage users on the system',
-  video: 'Play a video file',
-  view: 'View files in a new window (PDF, images, audio, video)',
-  wc: 'Print newline, word, and byte counts for each file',
-  web: 'Open a URL in a browser window',
-  which: 'Locate a command',
-  whoami: 'Print effective user ID',
-  xxd: 'Display file contents or stdin in hexadecimal format',
-  zip: 'Create zip archives'
-}