@ecmaos/coreutils 0.5.0 → 0.5.2

package/src/commands/ls.ts

@@ -14,6 +14,33 @@ List information about the FILEs (the current directory by default).
   writelnStderr(process, terminal, usage)
 }
 
+function truncateInfo(text: string, maxWidth: number = 40): string {
+  if (!text) return text
+  
+  // Strip ANSI codes to get visible length
+  const ansiRegex = /\x1b\[[0-9;]*m/g
+  const plainText = text.replace(ansiRegex, '')
+  
+  if (plainText.length <= maxWidth) return text
+  
+  // Extract all ANSI codes from the original text
+  const codes: string[] = []
+  let match
+  const codeRegex = /\x1b\[[0-9;]*m/g
+  while ((match = codeRegex.exec(text)) !== null) {
+    codes.push(match[0])
+  }
+  
+  // Truncate plain text and add ellipsis
+  const truncated = plainText.substring(0, maxWidth - 3)
+  
+  // Reconstruct with original color codes at the start
+  const prefixCodes = codes.length > 0 ? codes[0] : ''
+  const resetCode = '\x1b[0m'
+  
+  return `${prefixCodes}${truncated}...${resetCode}`
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'ls',
@@ -36,8 +63,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
       if (targets.length === 0) targets.push(shell.cwd)
 
-      const descriptions = kernel.filesystem.descriptions(kernel.i18n.t)
-
       // Process each target and collect all entries
       // We'll determine if each entry is a directory when we stat it later
       const allEntries: Array<{ fullPath: string, entry: string }> = []
@@ -110,6 +135,8 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return ''
       }
 
+      const descriptions = kernel.filesystem.descriptions(kernel.i18n.ns.filesystem)
+
       const filesMap = await Promise.all(allEntries
         .map(async ({ fullPath: entryFullPath, entry }) => {
           const target = path.resolve(entryFullPath, entry)
@@ -181,7 +208,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
       // Check if any entry is in /dev directory
       const isDevDirectory = allEntries.some(e => e.fullPath.startsWith('/dev'))
-      const columns = isDevDirectory ? ['Name', 'Mode', 'Owner', 'Info'] : ['Name', 'Size', 'Modified', 'Mode', 'Owner', 'Info']
+      const columns = isDevDirectory
+        ? [kernel.i18n.ns.common('Name'), kernel.i18n.ns.common('Mode'), kernel.i18n.ns.common('Owner'), kernel.i18n.ns.common('Info')]
+        : [kernel.i18n.ns.common('Name'), kernel.i18n.ns.common('Size'), kernel.i18n.ns.common('Modified'), kernel.i18n.ns.common('Mode'), kernel.i18n.ns.common('Owner'), kernel.i18n.ns.common('Info')]
 
       const directoryRows = directories.sort((a, b) => a.name.localeCompare(b.name)).map(directory => {
         const displayName = directory.linkTarget
@@ -201,15 +230,15 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           : chalk.green(displayName)
 
         const row: Record<string, string> = {
-          Name: coloredName,
-          Mode: chalk.gray(modeString),
-          Owner: directory.stats ? chalk.gray(getOwnerString(directory.stats)) : '',
-          Info: chalk.gray(linkInfo)
+          [kernel.i18n.ns.common('Name')]: coloredName,
+          [kernel.i18n.ns.common('Mode')]: chalk.gray(modeString),
+          [kernel.i18n.ns.common('Owner')]: directory.stats ? chalk.gray(getOwnerString(directory.stats)) : '',
+          [kernel.i18n.ns.common('Info')]: truncateInfo(chalk.gray(linkInfo))
         }
 
         if (!isDevDirectory) {
-          row.Size = ''
-          row.Modified = directory.stats ? chalk.gray(getTimestampString(directory.stats.mtime)) : ''
+          row[kernel.i18n.ns.common('Size')] = ''
+          row[kernel.i18n.ns.common('Modified')] = directory.stats ? chalk.gray(getTimestampString(directory.stats.mtime)) : ''
         }
 
         return row
@@ -235,6 +264,16 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           const linkInfo = getLinkInfo(file.linkTarget, file.linkStats, file.stats)
           if (linkInfo) return linkInfo
           
+          // Check if this is a command in /bin/ and use coreutils translations
+          if (file.target.startsWith('/bin/')) {
+            const commandName = path.basename(file.target)
+            const translatedDescription = kernel.i18n.ns.coreutils(commandName)
+            // Only use translation if it exists (i18next returns the key if translation is missing)
+            if (translatedDescription !== commandName) {
+              return translatedDescription
+            }
+          }
+          
           if (descriptions.has(file.target)) return descriptions.get(file.target) || ''
           if (file.name.includes('.')) {
             const ext = file.name.split('.').pop()
@@ -242,22 +281,25 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           }
           if (!file.stats) return ''
           if (file.stats.isBlockDevice() || file.stats.isCharacterDevice()) {
-            // TODO: zenfs `fs.mounts` is deprecated - use a better way of getting device info
+            const devicePackage = kernel.devices.get(path.basename(file.target))
+            const description = devicePackage?.device?.pkg?.description || ''
+            const hasCLI = devicePackage?.device?.cli !== undefined
+            return `${description}${hasCLI ? ' ' + `${chalk.bold(`(${kernel.i18n.t('CLI')})`)}${chalk.reset()}` : ''}`
           }
 
           return ''
         })()
 
         const row: Record<string, string> = {
-          Name: coloredName,
-          Mode: chalk.gray(modeString),
-          Owner: file.stats ? chalk.gray(getOwnerString(file.stats)) : '',
-          Info: chalk.gray(info)
+          [kernel.i18n.ns.common('Name')]: coloredName,
+          [kernel.i18n.ns.common('Mode')]: chalk.gray(modeString),
+          [kernel.i18n.ns.common('Owner')]: file.stats ? chalk.gray(getOwnerString(file.stats)) : '',
+          [kernel.i18n.ns.common('Info')]: truncateInfo(chalk.gray(info))
         }
 
         if (!isDevDirectory) {
-          row.Size = file.stats ? chalk.gray(humanFormat(file.stats.size)) : ''
-          row.Modified = file.stats ? chalk.gray(getTimestampString(file.stats.mtime)) : ''
+          row[kernel.i18n.ns.common('Size')] = file.stats ? chalk.gray(humanFormat(file.stats.size)) : ''
+          row[kernel.i18n.ns.common('Modified')] = file.stats ? chalk.gray(getTimestampString(file.stats.mtime)) : ''
         }
 
         return row

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,4 +278,3 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
 
 // For backward compatibility, export as TerminalCommands
 export { createAllCommands as TerminalCommands }
-