@ecmaos/coreutils 0.3.1 → 0.4.0

package/src/commands/env.ts

@@ -0,0 +1,143 @@
+import chalk from 'chalk'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStderr, writeStdout } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: env [OPTION]... [NAME=VALUE]... [COMMAND [ARG]...]
+Set each NAME to VALUE in the environment and run COMMAND.
+
+  -i, --ignore-environment  start with an empty environment
+  -u, --unset=NAME          remove variable from the environment
+  -0, --null                 end each output line with NUL, not newline
+      --help                 display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'env',
+    description: 'Run a program in a modified environment',
+    kernel,
+    shell,
+    terminal,
+    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
+      }
+
+      let ignoreEnvironment = false
+      const unsetVars: string[] = []
+      let nullTerminated = false
+      const envVars: Record<string, string> = {}
+      let commandStartIndex = -1
+
+      let i = 0
+      while (i < argv.length) {
+        const arg = argv[i]
+        if (!arg) {
+          i++
+          continue
+        }
+
+        if (arg === '-i' || arg === '--ignore-environment') {
+          ignoreEnvironment = true
+        } else if (arg === '-0' || arg === '--null') {
+          nullTerminated = true
+        } else if (arg === '-u' || arg.startsWith('--unset=')) {
+          let varName: string
+          if (arg.startsWith('--unset=')) {
+            varName = arg.slice(8)
+          } else {
+            i++
+            varName = argv[i] || ''
+            if (!varName) {
+              await writelnStderr(process, terminal, chalk.red('env: option requires an argument -- \'u\''))
+              return 1
+            }
+          }
+          if (varName) {
+            unsetVars.push(varName)
+          }
+        } else if (arg.includes('=')) {
+          const [name, ...valueParts] = arg.split('=')
+          if (name && valueParts.length > 0) {
+            envVars[name] = valueParts.join('=')
+          }
+        } else {
+          commandStartIndex = i
+          break
+        }
+        i++
+      }
+
+      const baseEnv = ignoreEnvironment ? {} : Object.fromEntries(shell.env.entries())
+
+      for (const varName of unsetVars) {
+        delete baseEnv[varName]
+      }
+
+      const modifiedEnv = { ...baseEnv, ...envVars }
+
+      if (commandStartIndex === -1) {
+        const entries = Object.entries(modifiedEnv).sort(([a], [b]) => a.localeCompare(b))
+        const separator = nullTerminated ? '\0' : '\n'
+        
+        for (const [key, value] of entries) {
+          const output = `${key}=${value}${separator}`
+          await writeStdout(process, terminal, output)
+        }
+        
+        if (!nullTerminated && entries.length > 0) {
+          await writeStdout(process, terminal, '\n')
+        }
+        
+        return 0
+      }
+
+      const commandArgs = argv.slice(commandStartIndex)
+      const command = commandArgs[0]
+      if (!command) {
+        await writelnStderr(process, terminal, chalk.red('env: missing command'))
+        return 1
+      }
+
+      const originalEnv = new Map(shell.env)
+      const originalProcessEnv = { ...globalThis.process.env }
+      
+      for (const [key, value] of Object.entries(modifiedEnv)) {
+        shell.env.set(key, value)
+        globalThis.process.env[key] = value
+      }
+
+      for (const varName of unsetVars) {
+        shell.env.delete(varName)
+        delete globalThis.process.env[varName]
+      }
+
+      try {
+        const commandLine = commandArgs.join(' ')
+        const exitCode = await shell.execute(commandLine)
+        return exitCode ?? 1
+      } finally {
+        shell.env.clear()
+        for (const [key, value] of originalEnv.entries()) {
+          shell.env.set(key, value)
+        }
+        
+        for (const key in globalThis.process.env) {
+          if (!(key in originalProcessEnv)) {
+            delete globalThis.process.env[key]
+          }
+        }
+        
+        for (const [key, value] of Object.entries(originalProcessEnv)) {
+          globalThis.process.env[key] = value
+        }
+      }
+    }
+  })
+}

package/src/commands/head.ts

@@ -9,6 +9,7 @@ function printUsage(process: Process | undefined, terminal: Terminal): void {
 Print the first 10 lines of each FILE to standard output.
 
   -n, -nNUMBER        print the first NUMBER lines instead of 10
+  -c, -cNUMBER        print the first NUMBER bytes instead of lines
   --help             display this help and exit`
   writelnStderr(process, terminal, usage)
 }
@@ -31,6 +32,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
       }
 
       let numLines = 10
+      let numBytes: number | null = null
       const files: string[] = []
 
       for (let i = 0; i < argv.length; i++) {
@@ -52,6 +54,18 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             const num = parseInt(arg.slice(2), 10)
             if (!isNaN(num)) numLines = num
           }
+        } else if (arg === '-c' || arg.startsWith('-c')) {
+          if (arg === '-c' && i + 1 < argv.length) {
+            i++
+            const nextArg = argv[i]
+            if (nextArg !== undefined) {
+              const num = parseInt(nextArg, 10)
+              if (!isNaN(num)) numBytes = num
+            }
+          } else if (arg.startsWith('-c') && arg.length > 2) {
+            const num = parseInt(arg.slice(2), 10)
+            if (!isNaN(num)) numBytes = num
+          }
         } else if (!arg.startsWith('-')) {
           files.push(arg)
         }
@@ -66,37 +80,83 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           }
 
           const reader = process.stdin.getReader()
-          const decoder = new TextDecoder()
-          const lines: string[] = []
-          let buffer = ''
 
           try {
-            while (true) {
-              let readResult
-              try {
-                readResult = await reader.read()
-              } catch (error) {
-                if (error instanceof Error) {
-                  throw error
+            if (numBytes !== null) {
+              let bytesRead = 0
+              const chunks: Uint8Array[] = []
+
+              while (bytesRead < numBytes) {
+                let readResult
+                try {
+                  readResult = await reader.read()
+                } catch (error) {
+                  if (error instanceof Error) {
+                    throw error
+                  }
+                  break
                 }
-                break
+
+                const { done, value } = readResult
+                if (done) break
+                if (value) {
+                  const remaining = numBytes - bytesRead
+                  if (value.length <= remaining) {
+                    chunks.push(value)
+                    bytesRead += value.length
+                  } else {
+                    chunks.push(value.subarray(0, remaining))
+                    bytesRead = numBytes
+                  }
+                  if (bytesRead >= numBytes) break
+                }
+              }
+
+              const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
+              const result = new Uint8Array(totalLength)
+              let offset = 0
+              for (const chunk of chunks) {
+                result.set(chunk, offset)
+                offset += chunk.length
               }
+              await writer.write(result)
+            } else {
+              const decoder = new TextDecoder()
+              const lines: string[] = []
+              let buffer = ''
 
-              const { done, value } = readResult
-              if (done) {
-                buffer += decoder.decode()
-                break
+              while (true) {
+                let readResult
+                try {
+                  readResult = await reader.read()
+                } catch (error) {
+                  if (error instanceof Error) {
+                    throw error
+                  }
+                  break
+                }
+
+                const { done, value } = readResult
+                if (done) {
+                  buffer += decoder.decode()
+                  break
+                }
+                if (value) {
+                  buffer += decoder.decode(value, { stream: true })
+                  const newLines = buffer.split('\n')
+                  buffer = newLines.pop() || ''
+                  lines.push(...newLines)
+                  if (lines.length >= numLines) break
+                }
               }
-              if (value) {
-                buffer += decoder.decode(value, { stream: true })
-                const newLines = buffer.split('\n')
-                buffer = newLines.pop() || ''
-                lines.push(...newLines)
-                if (lines.length >= numLines) break
+              if (buffer && lines.length < numLines) {
+                lines.push(buffer)
+              }
+
+              const output = lines.slice(0, numLines).join('\n')
+              if (output) {
+                await writer.write(new TextEncoder().encode(output + '\n'))
               }
-            }
-            if (buffer && lines.length < numLines) {
-              lines.push(buffer)
             }
           } finally {
             try {
@@ -105,11 +165,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             }
           }
 
-          const output = lines.slice(0, numLines).join('\n')
-          if (output) {
-            await writer.write(new TextEncoder().encode(output + '\n'))
-          }
-
           return 0
         }
 
@@ -130,66 +185,110 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
 
           try {
-            if (!fullPath.startsWith('/dev')) {
-              const handle = await shell.context.fs.promises.open(fullPath, 'r')
-              const stat = await shell.context.fs.promises.stat(fullPath)
-
-              const decoder = new TextDecoder()
-              const lines: string[] = []
-              let buffer = ''
-              let bytesRead = 0
-              const chunkSize = 1024
-
-              while (bytesRead < stat.size && lines.length < numLines) {
-                if (interrupted) break
+            if (numBytes !== null) {
+              if (!fullPath.startsWith('/dev')) {
+                const handle = await shell.context.fs.promises.open(fullPath, 'r')
+                const stat = await shell.context.fs.promises.stat(fullPath)
+                const readSize = Math.min(numBytes, stat.size)
+                const data = new Uint8Array(readSize)
+                await handle.read(data, 0, readSize, 0)
+                await writer.write(data)
+              } else {
+                const device = await shell.context.fs.promises.open(fullPath)
+                const chunkSize = 1024
                 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)
-                buffer += decoder.decode(chunk, { stream: true })
-                const newLines = buffer.split('\n')
-                buffer = newLines.pop() || ''
-                lines.push(...newLines)
-                bytesRead += readSize
-                if (lines.length >= numLines) break
-              }
-              if (buffer && lines.length < numLines) {
-                lines.push(buffer)
-              }
+                let totalBytesRead = 0
+                let bytesRead = 0
+                const chunks: Uint8Array[] = []
 
-              const output = lines.slice(0, numLines).join('\n')
-              if (output) {
-                await writer.write(new TextEncoder().encode(output + '\n'))
+                do {
+                  if (interrupted) break
+                  const result = await device.read(data)
+                  bytesRead = result.bytesRead
+                  if (bytesRead > 0) {
+                    const remaining = numBytes - totalBytesRead
+                    if (bytesRead <= remaining) {
+                      chunks.push(data.subarray(0, bytesRead))
+                      totalBytesRead += bytesRead
+                    } else {
+                      chunks.push(data.subarray(0, remaining))
+                      totalBytesRead = numBytes
+                    }
+                    if (totalBytesRead >= numBytes) break
+                  }
+                } while (totalBytesRead < numBytes && bytesRead > 0)
+
+                const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
+                const result = new Uint8Array(totalLength)
+                let offset = 0
+                for (const chunk of chunks) {
+                  result.set(chunk, offset)
+                  offset += chunk.length
+                }
+                await writer.write(result)
               }
             } else {
-              const device = await shell.context.fs.promises.open(fullPath)
-              const decoder = new TextDecoder()
-              const lines: string[] = []
-              let buffer = ''
-              const chunkSize = 1024
-              const data = new Uint8Array(chunkSize)
-              let bytesRead = 0
+              if (!fullPath.startsWith('/dev')) {
+                const handle = await shell.context.fs.promises.open(fullPath, 'r')
+                const stat = await shell.context.fs.promises.stat(fullPath)
 
-              do {
-                if (interrupted) break
-                const result = await device.read(data)
-                bytesRead = result.bytesRead
-                if (bytesRead > 0) {
-                  buffer += decoder.decode(data.subarray(0, bytesRead), { stream: true })
+                const decoder = new TextDecoder()
+                const lines: string[] = []
+                let buffer = ''
+                let bytesRead = 0
+                const chunkSize = 1024
+
+                while (bytesRead < stat.size && lines.length < numLines) {
+                  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)
+                  buffer += decoder.decode(chunk, { stream: true })
                   const newLines = buffer.split('\n')
                   buffer = newLines.pop() || ''
                   lines.push(...newLines)
+                  bytesRead += readSize
                   if (lines.length >= numLines) break
                 }
-              } while (bytesRead > 0 && lines.length < numLines)
+                if (buffer && lines.length < numLines) {
+                  lines.push(buffer)
+                }
 
-              if (buffer && lines.length < numLines) {
-                lines.push(buffer)
-              }
+                const output = lines.slice(0, numLines).join('\n')
+                if (output) {
+                  await writer.write(new TextEncoder().encode(output + '\n'))
+                }
+              } else {
+                const device = await shell.context.fs.promises.open(fullPath)
+                const decoder = new TextDecoder()
+                const lines: string[] = []
+                let buffer = ''
+                const chunkSize = 1024
+                const data = new Uint8Array(chunkSize)
+                let bytesRead = 0
 
-              const output = lines.slice(0, numLines).join('\n')
-              if (output) {
-                await writer.write(new TextEncoder().encode(output + '\n'))
+                do {
+                  if (interrupted) break
+                  const result = await device.read(data)
+                  bytesRead = result.bytesRead
+                  if (bytesRead > 0) {
+                    buffer += decoder.decode(data.subarray(0, bytesRead), { stream: true })
+                    const newLines = buffer.split('\n')
+                    buffer = newLines.pop() || ''
+                    lines.push(...newLines)
+                    if (lines.length >= numLines) break
+                  }
+                } while (bytesRead > 0 && lines.length < numLines)
+
+                if (buffer && lines.length < numLines) {
+                  lines.push(buffer)
+                }
+
+                const output = lines.slice(0, numLines).join('\n')
+                if (output) {
+                  await writer.write(new TextEncoder().encode(output + '\n'))
+                }
               }
             }
           } finally {

package/src/commands/less.ts

@@ -144,6 +144,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
           if (linesRendered > 0) {
             terminal.write(ansi.cursor.up(linesRendered))
+            terminal.write('\r')
           }
 
           const endLine = Math.min(currentLine + displayRows, lines.length)

package/src/commands/man.ts

@@ -409,7 +409,10 @@ async function displayManPage(
     if (horizontalOffset > maxHorizontalOffset) horizontalOffset = maxHorizontalOffset
     if (horizontalOffset < 0) horizontalOffset = 0
 
-    if (linesRendered > 0) terminal.write(ansi.cursor.up(linesRendered))
+    if (linesRendered > 0) {
+      terminal.write(ansi.cursor.up(linesRendered))
+      terminal.write('\r')
+    }
 
     const endLine = Math.min(currentLine + displayRows, lines.length)
     linesRendered = 0