@ecmaos/coreutils 0.3.1 → 0.4.2

package/src/commands/fold.ts

@@ -0,0 +1,257 @@
+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: fold [OPTION]... [FILE]...
+Wrap each input line to fit in specified width.
+
+  -w, --width=WIDTH   use WIDTH columns instead of 80
+  -s, --spaces        break at spaces when possible
+  -b, --bytes         count bytes instead of columns
+  --help             display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function wrapLine(line: string, width: number, breakAtSpaces: boolean, countBytes: boolean): string[] {
+  if (!line) return ['']
+  
+  const result: string[] = []
+  
+  if (countBytes) {
+    const encoder = new TextEncoder()
+    let current = ''
+    let currentBytes = 0
+    
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i]
+      const charBytes = encoder.encode(char).length
+      
+      if (currentBytes + charBytes > width && current.length > 0) {
+        if (breakAtSpaces) {
+          const lastSpace = current.lastIndexOf(' ')
+          if (lastSpace > 0) {
+            result.push(current.slice(0, lastSpace))
+            current = current.slice(lastSpace + 1) + char
+            currentBytes = encoder.encode(current).length
+            continue
+          }
+        }
+        result.push(current)
+        current = char || ''
+        currentBytes = charBytes
+      } else {
+        current += char
+        currentBytes += charBytes
+      }
+    }
+    
+    if (current.length > 0) {
+      result.push(current)
+    }
+  } else {
+    let current = ''
+    
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i]
+      
+      if (current.length >= width && current.length > 0) {
+        if (breakAtSpaces) {
+          const lastSpace = current.lastIndexOf(' ')
+          if (lastSpace > 0) {
+            result.push(current.slice(0, lastSpace))
+            current = current.slice(lastSpace + 1) + char
+            continue
+          }
+        }
+        result.push(current)
+        current = char || ''
+      } else {
+        current += char
+      }
+    }
+    
+    if (current.length > 0) {
+      result.push(current)
+    }
+  }
+  
+  return result.length > 0 ? result : ['']
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'fold',
+    description: 'Wrap each input line to fit in specified width',
+    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 width = 80
+      let breakAtSpaces = false
+      let countBytes = false
+      const files: string[] = []
+
+      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 === '-w' || arg === '--width') {
+          if (i + 1 < argv.length) {
+            const widthStr = argv[++i]
+            if (widthStr !== undefined) {
+              const parsed = parseInt(widthStr, 10)
+              if (!isNaN(parsed) && parsed > 0) {
+                width = parsed
+              } else {
+                await writelnStderr(process, terminal, `fold: invalid width: ${widthStr}`)
+                return 1
+              }
+            }
+          }
+        } else if (arg.startsWith('--width=')) {
+          const widthStr = arg.slice(8)
+          const parsed = parseInt(widthStr, 10)
+          if (!isNaN(parsed) && parsed > 0) {
+            width = parsed
+          } else {
+            await writelnStderr(process, terminal, `fold: invalid width: ${widthStr}`)
+            return 1
+          }
+        } else if (arg.startsWith('-w')) {
+          const widthStr = arg.slice(2)
+          if (widthStr) {
+            const parsed = parseInt(widthStr, 10)
+            if (!isNaN(parsed) && parsed > 0) {
+              width = parsed
+            } else {
+              await writelnStderr(process, terminal, `fold: invalid width: ${widthStr}`)
+              return 1
+            }
+          }
+        } else if (arg === '-s' || arg === '--spaces') {
+          breakAtSpaces = true
+        } else if (arg === '-b' || arg === '--bytes') {
+          countBytes = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('s')) breakAtSpaces = true
+          if (flags.includes('b')) countBytes = true
+          const invalidFlags = flags.filter(f => !['s', 'b'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `fold: invalid option -- '${invalidFlags[0]}'`)
+            await writelnStderr(process, terminal, "Try 'fold --help' for more information.")
+            return 1
+          }
+        } else {
+          files.push(arg)
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        let lines: string[] = []
+
+        if (files.length === 0) {
+          if (!process.stdin) {
+            return 0
+          }
+
+          const reader = process.stdin.getReader()
+          const decoder = new TextDecoder()
+          let buffer = ''
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+              if (value) {
+                buffer += decoder.decode(value, { stream: true })
+                const newLines = buffer.split('\n')
+                buffer = newLines.pop() || ''
+                lines.push(...newLines)
+              }
+            }
+            if (buffer) {
+              lines.push(buffer)
+            }
+          } finally {
+            reader.releaseLock()
+          }
+        } else {
+          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, `fold: ${file}: cannot process device files`)
+                continue
+              }
+
+              const handle = await shell.context.fs.promises.open(fullPath, 'r')
+              const stat = await shell.context.fs.promises.stat(fullPath)
+
+              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 fileLines = content.split('\n')
+              if (fileLines[fileLines.length - 1] === '') {
+                fileLines.pop()
+              }
+              lines.push(...fileLines)
+            } catch (error) {
+              await writelnStderr(process, terminal, `fold: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        for (const line of lines) {
+          const wrapped = wrapLine(line, width, breakAtSpaces, countBytes)
+          for (const wrappedLine of wrapped) {
+            await writer.write(new TextEncoder().encode(wrappedLine + '\n'))
+          }
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `fold: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/groups.ts

@@ -0,0 +1,72 @@
+import type { Kernel, Process, Shell, Terminal, User } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStderr, writelnStdout } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: groups [USERNAME]...
+Print the groups a user belongs to.
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'groups',
+    description: 'Print the groups a user belongs to',
+    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 usernames: string[] = []
+
+      for (const arg of argv) {
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (!arg.startsWith('-')) {
+          usernames.push(arg)
+        } else {
+          await writelnStderr(process, terminal, `groups: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'groups --help' for more information.")
+          return 1
+        }
+      }
+
+      const targets = usernames.length > 0 ? usernames : [shell.username]
+
+      for (const username of targets) {
+        const user = Array.from(kernel.users.all.values()).find(
+          (u): u is User => (u as User).username === username
+        )
+
+        if (!user) {
+          await writelnStderr(process, terminal, `groups: '${username}': no such user`)
+          continue
+        }
+
+        const groups = shell.credentials.groups || []
+        const groupNames = groups.map(gid => {
+          const groupUser = kernel.users.get(gid)
+          return groupUser?.username || gid.toString()
+        })
+
+        const output = `${username} : ${groupNames.join(' ')}`
+        await writelnStdout(process, terminal, output)
+      }
+
+      return 0
+    }
+  })
+}

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 {