@ecmaos/coreutils 0.2.1 → 0.3.0

package/src/commands/hash.ts

@@ -0,0 +1,215 @@
+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'
+
+type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512'
+
+const SUPPORTED_ALGORITHMS: Record<string, HashAlgorithm> = {
+  'sha1': 'SHA-1',
+  'sha-1': 'SHA-1',
+  'sha256': 'SHA-256',
+  'sha-256': 'SHA-256',
+  'sha384': 'SHA-384',
+  'sha-384': 'SHA-384',
+  'sha512': 'SHA-512',
+  'sha-512': 'SHA-512'
+}
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: hash [OPTION]... [FILE]...
+Compute and display hash values for files or standard input.
+
+  -a, --algorithm=ALGORITHM  hash algorithm to use (sha1, sha256, sha384, sha512)
+                              default: sha256
+  --help                      display this help and exit
+
+Supported algorithms:
+  sha1, sha-1                 SHA-1 (160 bits)
+  sha256, sha-256            SHA-256 (256 bits) [default]
+  sha384, sha-384            SHA-384 (384 bits)
+  sha512, sha-512            SHA-512 (512 bits)
+
+Examples:
+  hash file.txt              compute SHA-256 hash of file.txt
+  hash -a sha512 file.txt    compute SHA-512 hash of file.txt
+  echo "hello" | hash        compute SHA-256 hash of stdin`
+  writelnStderr(process, terminal, usage)
+}
+
+async function hashData(data: Uint8Array, algorithm: HashAlgorithm): Promise<string> {
+  // Create a new Uint8Array with a proper ArrayBuffer to ensure compatibility
+  const dataCopy = new Uint8Array(data)
+  const hashBuffer = await crypto.subtle.digest(algorithm, dataCopy)
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
+}
+
+async function readStreamToUint8Array(reader: ReadableStreamDefaultReader<Uint8Array>): Promise<Uint8Array> {
+  const chunks: Uint8Array[] = []
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      if (value) {
+        chunks.push(value)
+      }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+
+  // Calculate total length
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
+  
+  // Concatenate all chunks into a single Uint8Array
+  const result = new Uint8Array(totalLength)
+  let offset = 0
+  for (const chunk of chunks) {
+    result.set(chunk, offset)
+    offset += chunk.length
+  }
+  
+  return result
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'hash',
+    description: 'Compute and display hash values for files or standard input',
+    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
+      }
+
+      let algorithm: HashAlgorithm = 'SHA-256'
+      const files: string[] = []
+
+      // Parse arguments
+      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 === '-a' || arg === '--algorithm') {
+          const algoArg = argv[i + 1]
+          if (!algoArg) {
+            await writelnStderr(process, terminal, `hash: option requires an argument -- '${arg === '-a' ? 'a' : 'algorithm'}'`)
+            return 1
+          }
+          const algoLower = algoArg.toLowerCase()
+          const selectedAlgorithm = SUPPORTED_ALGORITHMS[algoLower]
+          if (!selectedAlgorithm) {
+            await writelnStderr(process, terminal, `hash: unsupported algorithm '${algoArg}'\nSupported algorithms: ${Object.keys(SUPPORTED_ALGORITHMS).join(', ')}`)
+            return 1
+          }
+          algorithm = selectedAlgorithm
+          i++ // Skip the next argument as it's the algorithm value
+        } else if (arg.startsWith('--algorithm=')) {
+          const algoArg = arg.split('=')[1]
+          if (!algoArg) {
+            await writelnStderr(process, terminal, `hash: option requires an argument -- 'algorithm'`)
+            return 1
+          }
+          const algoLower = algoArg.toLowerCase()
+          const selectedAlgorithm = SUPPORTED_ALGORITHMS[algoLower]
+          if (!selectedAlgorithm) {
+            await writelnStderr(process, terminal, `hash: unsupported algorithm '${algoArg}'\nSupported algorithms: ${Object.keys(SUPPORTED_ALGORITHMS).join(', ')}`)
+            return 1
+          }
+          algorithm = selectedAlgorithm
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        } else {
+          await writelnStderr(process, terminal, `hash: invalid option -- '${arg.replace(/^-+/, '')}'`)
+          await writelnStderr(process, terminal, `Try 'hash --help' for more information.`)
+          return 1
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        // If no files specified, read from stdin
+        if (files.length === 0) {
+          if (!process.stdin) {
+            await writelnStderr(process, terminal, 'hash: no input specified')
+            return 1
+          }
+
+          const reader = process.stdin.getReader()
+          const data = await readStreamToUint8Array(reader)
+          const hash = await hashData(data, algorithm)
+          await writer.write(new TextEncoder().encode(hash + '\n'))
+          return 0
+        }
+
+        // Process each file
+        let hasError = false
+        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, `hash: ${file}: cannot hash device files`)
+              hasError = true
+              continue
+            }
+
+            const handle = await shell.context.fs.promises.open(fullPath, 'r')
+            const stat = await shell.context.fs.promises.stat(fullPath)
+
+            const chunks: Uint8Array[] = []
+            let bytesRead = 0
+            const chunkSize = 64 * 1024 // 64KB chunks for better performance
+
+            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)
+              chunks.push(data.subarray(0, readSize))
+              bytesRead += readSize
+            }
+
+            // Concatenate all chunks
+            const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
+            const fileData = new Uint8Array(totalLength)
+            let offset = 0
+            for (const chunk of chunks) {
+              fileData.set(chunk, offset)
+              offset += chunk.length
+            }
+
+            const hash = await hashData(fileData, algorithm)
+            await writer.write(new TextEncoder().encode(`${hash}  ${file}\n`))
+          } catch (error) {
+            await writelnStderr(process, terminal, `hash: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            hasError = true
+          } finally {
+            kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+          }
+        }
+
+        return hasError ? 1 : 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/head.ts

@@ -2,7 +2,7 @@ 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 { writelnStdout } from '../shared/helpers.js'
+import { writelnStderr } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: head [OPTION]... [FILE]...
@@ -10,7 +10,7 @@ Print the first 10 lines of each FILE to standard output.
 
   -n, -nNUMBER        print the first NUMBER lines instead of 10
   --help             display this help and exit`
-  writelnStdout(process, terminal, usage)
+  writelnStderr(process, terminal, usage)
 }
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {

package/src/commands/id.ts

@@ -1,6 +1,6 @@
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
-import { writelnStdout } from '../shared/helpers.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: id [OPTION]...
@@ -11,7 +11,7 @@ Print user and group IDs.
   -G, --groups   print all group IDs
   -n, --name     print names instead of numeric IDs
   --help         display this help and exit`
-  writelnStdout(process, terminal, usage)
+  writelnStderr(process, terminal, usage)
 }
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {

package/src/commands/less.ts

@@ -33,6 +33,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
       let lines: string[] = []
       let currentLine = 0
+      let horizontalOffset = 0
       let keyListener: IDisposable | null = null
       let linesRendered = 0
 
@@ -94,6 +95,40 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         const displayRows = rows - 1
 
         const render = () => {
+          const cols = terminal.cols
+          const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+          
+          const getVisibleSlice = (line: string, offset: number): string => {
+            const visibleLen = stripAnsi(line).length
+            
+            if (offset < 0) offset = 0
+            if (offset > visibleLen) offset = visibleLen
+            
+            let visible = 0
+            let result = ''
+            let inEscape = false
+            let charsSkipped = 0
+            
+            for (const char of line) {
+              if (char === '\x1b') inEscape = true
+              if (inEscape) {
+                if (charsSkipped >= offset) {
+                  result += char
+                }
+                if (/[a-zA-Z]/.test(char)) inEscape = false
+              } else {
+                if (charsSkipped < offset) {
+                  charsSkipped++
+                } else {
+                  if (visible >= cols) break
+                  result += char
+                  visible++
+                }
+              }
+            }
+            return result
+          }
+
           const maxLine = Math.max(0, lines.length - displayRows)
           if (currentLine > maxLine) {
             currentLine = maxLine
@@ -102,6 +137,11 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             currentLine = 0
           }
 
+          const maxLineLength = Math.max(...lines.map(l => stripAnsi(l).length), 0)
+          const maxHorizontalOffset = Math.max(0, maxLineLength - cols)
+          if (horizontalOffset > maxHorizontalOffset) horizontalOffset = maxHorizontalOffset
+          if (horizontalOffset < 0) horizontalOffset = 0
+
           if (linesRendered > 0) {
             terminal.write(ansi.cursor.up(linesRendered))
           }
@@ -111,7 +151,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           
           for (let i = currentLine; i < endLine; i++) {
             terminal.write(ansi.erase.inLine(2))
-            const line = lines[i] || ''
+            const line = getVisibleSlice(lines[i] || '', horizontalOffset)
             terminal.write(line)
             linesRendered++
             if (i < endLine - 1) {
@@ -129,7 +169,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           const statusLine = `-- ${currentLine + 1}-${endLine} / ${lines.length} (${percentage}%)`
           terminal.write('\n')
           terminal.write(ansi.erase.inLine(2))
-          terminal.write(statusLine)
+          terminal.write(getVisibleSlice(statusLine, 0))
           linesRendered++
         }
 
@@ -163,6 +203,14 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
                 currentLine++
                 render()
                 break
+              case 'ArrowLeft':
+                horizontalOffset = Math.max(0, horizontalOffset - Math.floor(terminal.cols / 2))
+                render()
+                break
+              case 'ArrowRight':
+                horizontalOffset += Math.floor(terminal.cols / 2)
+                render()
+                break
               case 'PageDown':
               case ' ':
                 currentLine = Math.min(currentLine + displayRows, Math.max(0, lines.length - displayRows))

package/src/commands/ls.ts

@@ -4,14 +4,14 @@ import columnify from 'columnify'
 import humanFormat from 'human-format'
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
-import { writelnStdout } from '../shared/helpers.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: ls [OPTION]... [FILE]...
 List information about the FILEs (the current directory by default).
 
   --help  display this help and exit`
-  writelnStdout(process, terminal, usage)
+  writelnStderr(process, terminal, usage)
 }
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
@@ -29,12 +29,37 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return 0
       }
 
-      const target = argv.length > 0 && argv[0] !== undefined && !argv[0].startsWith('-') ? argv[0] : shell.cwd
-      const fullPath = target ? path.resolve(shell.cwd, target === '' ? '.' : target) : shell.cwd
-      const stats = await shell.context.fs.promises.stat(fullPath)
-      const entries: string[] = stats.isDirectory() ? await shell.context.fs.promises.readdir(fullPath) : [fullPath]
+      // Filter out options/flags and get target paths
+      const targets = argv.length > 0 
+        ? argv.filter(arg => !arg.startsWith('-'))
+        : [shell.cwd]
+
+      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 }> = []
+      
+      for (const target of targets) {
+        const fullPath = path.resolve(shell.cwd, target === '' ? '.' : target)
+        try {
+          const stats = await shell.context.fs.promises.stat(fullPath)
+          if (stats.isDirectory()) {
+            // For directories, list all contents
+            const dirEntries = await shell.context.fs.promises.readdir(fullPath)
+            for (const entry of dirEntries) allEntries.push({ fullPath, entry })
+          } else {
+            // For files, add the file itself
+            allEntries.push({ fullPath: path.dirname(fullPath), entry: path.basename(fullPath) })
+          }
+        } catch {
+          // If target doesn't exist, skip it (standard ls behavior)
+          continue
+        }
+      }
+
       const getModeType = (stats: Awaited<ReturnType<typeof shell.context.fs.promises.stat>>) => {
         let type = '-'
         if (stats.isDirectory()) type = 'd'
@@ -85,9 +110,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return ''
       }
 
-      const filesMap = await Promise.all(entries
-        .map(async entry => {
-          const target = path.resolve(fullPath, entry)
+      const filesMap = await Promise.all(allEntries
+        .map(async ({ fullPath: entryFullPath, entry }) => {
+          const target = path.resolve(entryFullPath, entry)
           try {
             let linkTarget: string | null = null
             let linkStats = null
@@ -119,9 +144,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         .filter(entry => entry && entry.stats && !entry.stats.isDirectory())
         .filter((entry): entry is NonNullable<typeof entry> => entry !== null && entry !== undefined)
 
-      const directoryMap = await Promise.all(entries
-        .map(async entry => {
-          const target = path.resolve(fullPath, entry)
+      const directoryMap = await Promise.all(allEntries
+        .map(async ({ fullPath: entryFullPath, entry }) => {
+          const target = path.resolve(entryFullPath, entry)
           try {
             let linkTarget: string | null = null
             let linkStats = null
@@ -154,7 +179,8 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         .filter((entry, index, self) => self.findIndex(e => e?.name === entry?.name) === index)
         .filter((entry): entry is NonNullable<typeof entry> => entry !== null && entry !== undefined)
 
-      const isDevDirectory = fullPath.startsWith('/dev')
+      // 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 directoryRows = directories.sort((a, b) => a.name.localeCompare(b.name)).map(directory => {
@@ -209,7 +235,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           const linkInfo = getLinkInfo(file.linkTarget, file.linkStats, file.stats)
           if (linkInfo) return linkInfo
           
-          if (descriptions.has(path.resolve(fullPath, file.name))) return descriptions.get(path.resolve(fullPath, file.name)) || ''
+          if (descriptions.has(file.target)) return descriptions.get(file.target) || ''
           if (file.name.includes('.')) {
             const ext = file.name.split('.').pop()
             if (ext && descriptions.has('.' + ext)) return descriptions.get('.' + ext) || ''