@ecmaos/coreutils 0.3.1 → 0.4.2

package/src/commands/awk.ts

@@ -0,0 +1,340 @@
+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: awk [OPTION]... 'program' [FILE]...
+Pattern scanning and text processing language.
+
+  -F, --field-separator=FS   set field separator (default: whitespace)
+  -v, --assign=VAR=VAL        assign variable VAR to value VAL
+  --help                     display this help and exit
+
+Basic usage:
+  awk '{ print $1 }' file              Print first field of each line
+  awk '/pattern/ { print }' file        Print lines matching pattern
+  awk 'BEGIN { print "start" } { print } END { print "end" }' file
+
+Variables:
+  $0    whole line
+  $1, $2, ...  field numbers
+  NR    record number (line number)
+  NF    number of fields`
+  writelnStderr(process, terminal, usage)
+}
+
+interface AwkProgram {
+  begin?: string[]
+  pattern?: string
+  action?: string
+  end?: string[]
+}
+
+function parseAwkProgram(program: string): AwkProgram | null {
+  const result: AwkProgram = {}
+  
+  let beginMatch = program.match(/BEGIN\s*\{([^}]*)\}/)
+  if (beginMatch) {
+    result.begin = beginMatch[1]?.split(';').map(s => s.trim()).filter(s => s) ?? []
+  }
+  
+  let endMatch = program.match(/END\s*\{([^}]*)\}/)
+  if (endMatch) {
+    result.end = endMatch[1]?.split(';').map(s => s.trim()).filter(s => s) ?? []
+  }
+  
+  let mainMatch = program.match(/(?:BEGIN\s*\{[^}]*\})?\s*([^}]*?)\s*(?:\{([^}]*)\})?\s*(?:END\s*\{[^}]*\})?/)
+  if (!mainMatch) {
+    const simpleMatch = program.match(/\{([^}]*)\}/)
+    if (simpleMatch) {
+      result.action = simpleMatch[1]?.trim() ?? ''
+    } else {
+      return null
+    }
+  } else {
+    const patternPart = mainMatch[1]?.trim()
+    const actionPart = mainMatch[2]?.trim()
+    
+    if (patternPart && !patternPart.startsWith('{')) {
+      if (patternPart.startsWith('/') && patternPart.endsWith('/')) {
+        result.pattern = patternPart.slice(1, -1)
+      } else {
+        result.pattern = patternPart
+      }
+    }
+    
+    if (actionPart) {
+      result.action = actionPart
+    } else if (!patternPart) {
+      result.action = 'print'
+    }
+  }
+  
+  if (!result.action && !result.begin && !result.end) {
+    return null
+  }
+  
+  return result
+}
+
+function splitFields(line: string, fs: string): string[] {
+  if (fs === ' ') {
+    return line.trim().split(/\s+/)
+  }
+  return line.split(fs)
+}
+
+function executeAction(action: string, fields: string[], line: string, NR: number, NF: number): string {
+  if (!action || action.trim() === 'print' || action.trim() === '') {
+    return line
+  }
+  
+  const printMatch = action.match(/print\s+(.+)/)
+  if (printMatch) {
+    const args = printMatch[1]?.trim() ?? ''
+    const parts = args.split(',').map(s => s.trim())
+    const output: string[] = []
+    
+    for (const part of parts) {
+      if (part === '$0') {
+        output.push(line)
+      } else if (part.match(/^\$\d+$/)) {
+        const fieldNum = parseInt(part.slice(1), 10)
+        if (fieldNum >= 1 && fieldNum <= fields.length) {
+          output.push(fields[fieldNum - 1] || '')
+        }
+      } else if (part === 'NR') {
+        output.push(String(NR))
+      } else if (part === 'NF') {
+        output.push(String(NF))
+      } else if (part.startsWith('"') && part.endsWith('"')) {
+        output.push(part.slice(1, -1))
+      } else if (part.startsWith("'") && part.endsWith("'")) {
+        output.push(part.slice(1, -1))
+      } else {
+        output.push(part)
+      }
+    }
+    
+    return output.join(' ')
+  }
+  
+  return line
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'awk',
+    description: 'Pattern scanning and text processing language',
+    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 fieldSeparator = ' '
+      const variables: Record<string, string> = {}
+      const args: string[] = []
+      let program: string | undefined
+
+      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 === '-F' || arg === '--field-separator') {
+          if (i + 1 < argv.length) {
+            fieldSeparator = argv[++i] || ' '
+          }
+        } else if (arg.startsWith('--field-separator=')) {
+          fieldSeparator = arg.slice(18)
+        } else if (arg.startsWith('-F')) {
+          fieldSeparator = arg.slice(2) || ' '
+        } else if (arg === '-v' || arg === '--assign') {
+          if (i + 1 < argv.length) {
+            const assign = argv[++i] || ''
+            const [key, ...valueParts] = assign.split('=')
+            if (key) {
+              variables[key] = valueParts.join('=')
+            }
+          }
+        } else if (arg.startsWith('--assign=')) {
+          const assign = arg.slice(9)
+          const [key, ...valueParts] = assign.split('=')
+          if (key) {
+            variables[key] = valueParts.join('=')
+          }
+        } else if (arg.startsWith('-v')) {
+          const assign = arg.slice(2)
+          const [key, ...valueParts] = assign.split('=')
+          if (key) {
+            variables[key] = valueParts.join('=')
+          }
+        } else if (!arg.startsWith('-')) {
+          if (!program && (arg.startsWith("'") || arg.startsWith('"'))) {
+            program = arg.slice(1, -1)
+          } else if (!program) {
+            program = arg
+          } else {
+            args.push(arg)
+          }
+        }
+      }
+
+      if (!program) {
+        await writelnStderr(process, terminal, 'awk: program is required')
+        await writelnStderr(process, terminal, "Try 'awk --help' for more information.")
+        return 1
+      }
+
+      const parsedProgram = parseAwkProgram(program)
+      if (!parsedProgram) {
+        await writelnStderr(process, terminal, 'awk: invalid program')
+        return 1
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        let lines: string[] = []
+
+        if (args.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 args) {
+            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, `awk: ${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, `awk: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        if (parsedProgram.begin) {
+          for (const stmt of parsedProgram.begin) {
+            if (stmt.trim() === 'print' || stmt.trim().startsWith('print ')) {
+              const output = executeAction(stmt, [], '', 0, 0)
+              if (output) {
+                await writer.write(new TextEncoder().encode(output + '\n'))
+              }
+            }
+          }
+        }
+
+        let NR = 0
+        for (const line of lines) {
+          NR++
+          const fields = splitFields(line, fieldSeparator)
+          const NF = fields.length
+
+          let shouldProcess = true
+          if (parsedProgram.pattern) {
+            try {
+              const regex = new RegExp(parsedProgram.pattern)
+              shouldProcess = regex.test(line)
+            } catch {
+              shouldProcess = false
+            }
+          }
+
+          if (shouldProcess && parsedProgram.action) {
+            const output = executeAction(parsedProgram.action, fields, line, NR, NF)
+            if (output !== null) {
+              await writer.write(new TextEncoder().encode(output + '\n'))
+            }
+          } else if (shouldProcess && !parsedProgram.action && !parsedProgram.pattern) {
+            await writer.write(new TextEncoder().encode(line + '\n'))
+          }
+        }
+
+        if (parsedProgram.end) {
+          for (const stmt of parsedProgram.end) {
+            if (stmt.trim() === 'print' || stmt.trim().startsWith('print ')) {
+              const output = executeAction(stmt, [], '', NR + 1, 0)
+              if (output) {
+                await writer.write(new TextEncoder().encode(output + '\n'))
+              }
+            }
+          }
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `awk: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/chmod.ts

@@ -6,12 +6,150 @@ import { writelnStderr } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: chmod [OPTION]... MODE[,MODE]... FILE...
+   or:  chmod [OPTION]... OCTAL-MODE FILE...
 Change the mode of each FILE to MODE.
 
-  --help  display this help and exit`
+      --help         display this help and exit
+
+Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=][0-7]+'.
+
+MODE can be specified in two ways:
+
+Numeric mode (octal):
+  MODE is an octal number representing the permissions:
+  4 = read (r)
+  2 = write (w)
+  1 = execute (x)
+  
+  The three digits represent user, group, and other permissions.
+  Each digit is the sum of the desired permissions:
+  - 7 = 4+2+1 = read + write + execute (rwx)
+  - 6 = 4+2   = read + write (rw-)
+  - 5 = 4+1   = read + execute (r-x)
+  - 4 = 4     = read only (r--)
+  
+  Examples:
+    755 = rwxr-xr-x (user: rwx, group: r-x, other: r-x)
+    644 = rw-r--r-- (user: rw-, group: r--, other: r--)
+    600 = rw------- (user: rw-, group: ---, other: ---)
+
+Symbolic mode:
+  [ugoa]*[-+=][rwxXst]*
+  
+  The format is: [who][operator][permissions]
+  
+  'who' (optional, defaults to 'a' if omitted):
+    u   user (owner)
+    g   group
+    o   other
+    a   all (user, group, and other)
+  
+  'operator':
+    +   add the specified permissions
+    -   remove the specified permissions
+    =   set the exact permissions (clears others)
+  
+  'permissions' (one or more):
+    r   read
+    w   write
+    x   execute
+    X   execute only if file is a directory or already has execute
+    s   setuid/setgid
+    t   sticky bit
+
+Examples:
+  chmod 755 file              Set file to rwxr-xr-x
+  chmod +x file               Add execute permission for all
+  chmod u+x file              Add execute permission for user
+  chmod g-w file              Remove write permission for group
+  chmod o=r file              Set other permissions to read-only
+  chmod u=rwx,g=rx,o=r file   Set specific permissions for each class
+  chmod a-w file              Remove write permission for all
+  chmod u+x,g+x file          Add execute for user and group
+
+Multiple modes can be specified separated by commas:
+  chmod u+x,g-w file          Add execute for user, remove write for group`
   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
+}
+
+function parseSymbolicMode(mode: string, currentMode: number): number {
+  const parts = mode.split(',')
+  let newMode = currentMode
+
+  for (const part of parts) {
+    const match = part.match(/^([ugoa]*)([+\-=])([rwxXst]*)$/)
+    if (!match) {
+      throw new Error(`Invalid mode: ${part}`)
+    }
+
+    const [, who, op, perms = ''] = match
+    const whoSet = who || 'a'
+
+    if ((op === '+' || op === '-') && !perms) {
+      throw new Error(`Invalid mode: ${part} (missing permissions)`)
+    }
+
+    const userBits = 0o400 | 0o200 | 0o100
+    const groupBits = 0o040 | 0o020 | 0o010
+    const otherBits = 0o004 | 0o002 | 0o001
+
+    let permBits = 0
+    if (perms.includes('r')) permBits |= 0o444
+    if (perms.includes('w')) permBits |= 0o222
+    if (perms.includes('x')) permBits |= 0o111
+    if (perms.includes('X')) {
+      if (currentMode & 0o111) permBits |= 0o111
+    }
+    if (perms.includes('s')) permBits |= 0o6000
+    if (perms.includes('t')) permBits |= 0o1000
+
+    let targetBits = 0
+    if (whoSet.includes('u') || whoSet.includes('a')) targetBits |= userBits
+    if (whoSet.includes('g') || whoSet.includes('a')) targetBits |= groupBits
+    if (whoSet.includes('o') || whoSet.includes('a')) targetBits |= otherBits
+
+    switch (op) {
+      case '+':
+        newMode |= (permBits & targetBits)
+        break
+      case '-':
+        newMode &= ~(permBits & targetBits)
+        break
+      case '=':
+        newMode &= ~targetBits
+        newMode |= (permBits & targetBits)
+        break
+    }
+  }
+
+  return newMode
+}
+
+async function parseMode(mode: string, fs: typeof import('@zenfs/core').fs.promises, filePath: string): Promise<number> {
+  const numericMode = parseNumericMode(mode)
+  if (numericMode !== null) {
+    return numericMode
+  }
+
+  try {
+    const stats = await fs.stat(filePath)
+    const currentMode = stats.mode & 0o7777
+    return parseSymbolicMode(mode, currentMode)
+  } catch (error) {
+    throw new Error(`Cannot access ${filePath}: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'chmod',
@@ -55,7 +193,8 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         const fullPath = path.resolve(shell.cwd, target)
         
         try {
-          await shell.context.fs.promises.chmod(fullPath, mode)
+          const numericMode = await parseMode(mode, shell.context.fs.promises, fullPath)
+          await shell.context.fs.promises.chmod(fullPath, numericMode)
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error)
           await writelnStderr(process, terminal, `chmod: ${target}: ${errorMessage}`)