@ecmaos/coreutils 0.3.1 → 0.4.2

package/src/commands/curl.ts

@@ -0,0 +1,231 @@
+import path from 'path'
+import chalk from 'chalk'
+import type { Kernel, Process, Shell, Terminal } 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: curl [OPTION]... URL
+Transfer data from or to a server.
+
+  -o, --output=FILE        write output to FILE instead of stdout
+  -O, --remote-name        write output to a file named like the remote file
+  -X, --request=METHOD     HTTP method to use (default: GET)
+  -d, --data=DATA          send data in POST request
+  -H, --header=HEADER      add custom HTTP header (format: "Name: Value")
+  -s, --silent             silent mode (don't show progress)
+  -v, --verbose            verbose mode (show request/response headers)
+  --help                   display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'curl',
+    description: 'Transfer data from or to a server',
+    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 url: string | undefined
+      let outputFile: string | undefined
+      let remoteName = false
+      let method = 'GET'
+      let body: string | undefined
+      const headers: Record<string, string> = {}
+      let silent = false
+      let verbose = false
+
+      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 === '-o' || arg === '--output') {
+          if (i + 1 < argv.length) {
+            outputFile = argv[++i]
+          }
+        } else if (arg.startsWith('--output=')) {
+          outputFile = arg.slice(9)
+        } else if (arg.startsWith('-o')) {
+          outputFile = arg.slice(2) || undefined
+        } else if (arg === '-O' || arg === '--remote-name') {
+          remoteName = true
+        } else if (arg === '-X' || arg === '--request') {
+          if (i + 1 < argv.length) {
+            method = (argv[++i] || 'GET').toUpperCase()
+          }
+        } else if (arg.startsWith('--request=')) {
+          method = arg.slice(10).toUpperCase()
+        } else if (arg.startsWith('-X')) {
+          method = (arg.slice(2) || 'GET').toUpperCase()
+        } else if (arg === '-d' || arg === '--data') {
+          if (i + 1 < argv.length) {
+            body = argv[++i]
+          }
+        } else if (arg.startsWith('--data=')) {
+          body = arg.slice(7)
+        } else if (arg.startsWith('-d')) {
+          body = arg.slice(2) || undefined
+        } else if (arg === '-H' || arg === '--header') {
+          if (i + 1 < argv.length) {
+            const headerArg = argv[++i]
+            if (headerArg) {
+              const [name, ...valueParts] = headerArg.split(':')
+              if (name && valueParts.length > 0) {
+                headers[name.trim()] = valueParts.join(':').trim()
+              }
+            }
+          }
+        } else if (arg.startsWith('--header=')) {
+          const headerValue = arg.slice(9)
+          const [name, ...valueParts] = headerValue.split(':')
+          if (name && valueParts.length > 0) {
+            headers[name.trim()] = valueParts.join(':').trim()
+          }
+        } else if (arg.startsWith('-H')) {
+          const headerValue = arg.slice(2)
+          if (headerValue) {
+            const [name, ...valueParts] = headerValue.split(':')
+            if (name && valueParts.length > 0) {
+              headers[name.trim()] = valueParts.join(':').trim()
+            }
+          }
+        } else if (arg === '-s' || arg === '--silent') {
+          silent = true
+        } else if (arg === '-v' || arg === '--verbose') {
+          verbose = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('s')) silent = true
+          if (flags.includes('v')) verbose = true
+          if (flags.includes('O')) remoteName = true
+          const invalidFlags = flags.filter(f => !['s', 'v', 'O'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `curl: invalid option -- '${invalidFlags[0]}'`)
+            await writelnStderr(process, terminal, "Try 'curl --help' for more information.")
+            return 1
+          }
+        } else {
+          if (!url) {
+            url = arg
+          } else {
+            await writelnStderr(process, terminal, `curl: unexpected argument: ${arg}`)
+            return 1
+          }
+        }
+      }
+
+      if (!url) {
+        await writelnStderr(process, terminal, 'curl: URL is required')
+        await writelnStderr(process, terminal, "Try 'curl --help' for more information.")
+        return 1
+      }
+
+      if (remoteName && !outputFile) {
+        const urlObj = new URL(url)
+        const pathname = urlObj.pathname
+        outputFile = path.basename(pathname) || 'index.html'
+      }
+
+      try {
+        if (verbose && !silent) {
+          await writelnStderr(process, terminal, `* Connecting to ${url}`)
+          await writelnStderr(process, terminal, `> ${method} ${url} HTTP/1.1`)
+        }
+
+        const fetchOptions: RequestInit = { method }
+        if (body) {
+          fetchOptions.body = body
+          if (!headers['Content-Type']) {
+            headers['Content-Type'] = 'application/x-www-form-urlencoded'
+          }
+        }
+        if (Object.keys(headers).length > 0) {
+          fetchOptions.headers = headers
+        }
+
+        if (verbose && !silent) {
+          for (const [name, value] of Object.entries(headers)) {
+            await writelnStderr(process, terminal, `> ${name}: ${value}`)
+          }
+        }
+
+        const response = await globalThis.fetch(url, fetchOptions)
+
+        if (verbose && !silent) {
+          await writelnStderr(process, terminal, `< HTTP/${response.status} ${response.status} ${response.statusText}`)
+          for (const [name, value] of response.headers.entries()) {
+            await writelnStderr(process, terminal, `< ${name}: ${value}`)
+          }
+        }
+
+        if (!response.ok && !silent) {
+          await writelnStderr(process, terminal, chalk.red(`curl: HTTP error! status: ${response.status}`))
+        }
+
+        const reader = response.body?.getReader()
+        if (!reader) {
+          if (!silent) {
+            await writelnStderr(process, terminal, chalk.red('curl: No response body'))
+          }
+          return response.ok ? 0 : 1
+        }
+
+        let writer: WritableStreamDefaultWriter<Uint8Array> | { write: (chunk: Uint8Array) => Promise<void>, releaseLock: () => Promise<void> } | undefined
+
+        if (outputFile) {
+          const fullPath = path.resolve(shell.cwd, outputFile)
+          const fileHandle = await shell.context.fs.promises.open(fullPath, 'w')
+          writer = {
+            write: async (chunk: Uint8Array) => {
+              await fileHandle.write(chunk)
+            },
+            releaseLock: async () => {
+              await fileHandle.close()
+            }
+          }
+        } else {
+          if (!process.stdout) {
+            await writelnStderr(process, terminal, chalk.red('curl: No stdout available'))
+            return 1
+          }
+          writer = process.stdout.getWriter()
+        }
+
+        try {
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+            if (value && value.length > 0) {
+              await writer.write(value)
+            }
+          }
+        } finally {
+          reader.releaseLock()
+          if (writer && 'releaseLock' in writer) {
+            await writer.releaseLock()
+          }
+        }
+
+        return response.ok ? 0 : 1
+      } catch (error) {
+        if (!silent) {
+          await writelnStderr(process, terminal, chalk.red(`curl: ${error instanceof Error ? error.message : 'Unknown error'}`))
+        }
+        return 1
+      }
+    }
+  })
+}

package/src/commands/echo.ts

@@ -6,11 +6,122 @@ function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: echo [OPTION]... [STRING]...
 Echo the STRING(s) to standard output.
 
+  -e     enable interpretation of backslash escapes
   -n     do not output the trailing newline
   --help display this help and exit`
   writelnStderr(process, terminal, usage)
 }
 
+function interpretEscapes(text: string): string {
+  let result = ''
+  let i = 0
+  
+  while (i < text.length) {
+    if (text[i] === '\\' && i + 1 < text.length) {
+      const next = text[i + 1]
+      switch (next) {
+        case '\\':
+          result += '\\'
+          i += 2
+          break
+        case 'a':
+          result += '\x07'
+          i += 2
+          break
+        case 'b':
+          result += '\b'
+          i += 2
+          break
+        case 'c':
+          return result
+        case 'e':
+        case 'E':
+          result += '\x1b'
+          i += 2
+          break
+        case 'f':
+          result += '\f'
+          i += 2
+          break
+        case 'n':
+          result += '\n'
+          i += 2
+          break
+        case 'r':
+          result += '\r'
+          i += 2
+          break
+        case 't':
+          result += '\t'
+          i += 2
+          break
+        case 'v':
+          result += '\v'
+          i += 2
+          break
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7': {
+          let octal = ''
+          let j = i + 1
+          while (j < text.length && j < i + 4) {
+            const char = text[j]
+            if (char && /[0-7]/.test(char)) {
+              octal += char
+              j++
+            } else {
+              break
+            }
+          }
+          if (octal) {
+            result += String.fromCharCode(parseInt(octal, 8))
+            i = j
+          } else {
+            result += text[i]
+            i++
+          }
+          break
+        }
+        case 'x': {
+          let hex = ''
+          let j = i + 2
+          while (j < text.length && j < i + 4) {
+            const char = text[j]
+            if (char && /[0-9a-fA-F]/.test(char)) {
+              hex += char
+              j++
+            } else {
+              break
+            }
+          }
+          if (hex) {
+            result += String.fromCharCode(parseInt(hex, 16))
+            i = j
+          } else {
+            result += text[i]
+            i++
+          }
+          break
+        }
+        default:
+          result += text[i]
+          i++
+          break
+      }
+    } else {
+      result += text[i]
+      i++
+    }
+  }
+  
+  return result
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'echo',
@@ -27,6 +138,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
       }
 
       let noNewline = false
+      let enableEscapes = false
       const textParts: string[] = []
       let i = 0
 
@@ -41,12 +153,17 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           return 0
         } else if (arg === '-n') {
           noNewline = true
+        } else if (arg === '-e') {
+          enableEscapes = true
         } else if (arg.startsWith('-') && arg.length > 1 && arg !== '--') {
           const flags = arg.slice(1).split('')
           if (flags.includes('n')) {
             noNewline = true
           }
-          const invalidFlag = flags.find(f => f !== 'n')
+          if (flags.includes('e')) {
+            enableEscapes = true
+          }
+          const invalidFlag = flags.find(f => f !== 'n' && f !== 'e')
           if (invalidFlag) {
             await writelnStdout(process, terminal, `echo: invalid option -- '${invalidFlag}'`)
             return 1
@@ -57,7 +174,10 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         i++
       }
 
-      const text = textParts.join(' ')
+      let text = textParts.join(' ')
+      if (enableEscapes) {
+        text = interpretEscapes(text)
+      }
       const output = noNewline ? text : text + '\n'
 
       if (process) {

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
+        }
+      }
+    }
+  })
+}