@ecmaos/coreutils 0.1.1 → 0.1.3

package/src/commands/ls.ts

@@ -35,8 +35,10 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return type
       }
 
-      const getModeString = (stats: Awaited<ReturnType<typeof shell.context.fs.promises.stat>>) => {
-        return getModeType(stats) + (Number(stats.mode) & parseInt('777', 8)).toString(8).padStart(3, '0')
+      const getModeString = (stats: Awaited<ReturnType<typeof shell.context.fs.promises.stat>>, targetStats?: Awaited<ReturnType<typeof shell.context.fs.promises.stat>>) => {
+        const type = getModeType(stats)
+        const modeStats = targetStats || stats
+        const permissions = (Number(modeStats.mode) & parseInt('777', 8)).toString(8).padStart(3, '0')
           .replace(/0/g, '---')
           .replace(/1/g, '--' + chalk.red('x'))
           .replace(/2/g, '-' + chalk.yellow('w') + '-')
@@ -45,6 +47,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           .replace(/5/g, chalk.green('r') + '-' + chalk.red('x'))
           .replace(/6/g, chalk.green('r') + chalk.yellow('w') + '-')
           .replace(/7/g, chalk.green('r') + chalk.yellow('w') + chalk.red('x'))
+        return type + permissions
       }
 
       const getTimestampString = (timestamp: Date) => {
@@ -65,13 +68,39 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         else return chalk.gray(`${owner?.username || stats.uid}:${owner?.username || stats.gid}`)
       }
 
+      const getLinkInfo = (linkTarget: string | null, linkStats: Awaited<ReturnType<typeof shell.context.fs.promises.stat>> | null, stats: Awaited<ReturnType<typeof shell.context.fs.promises.stat>> | null) => {
+        if (linkTarget || (linkStats && linkStats.isSymbolicLink())) return kernel.i18n.t('Symbolic Link')
+        if (stats && stats.nlink > 1) return kernel.i18n.t('Hard Link')
+        return ''
+      }
+
       const filesMap = await Promise.all(entries
         .map(async entry => {
           const target = path.resolve(fullPath, entry)
           try {
-            return { target, name: entry, stats: await shell.context.fs.promises.stat(target) }
+            let linkTarget: string | null = null
+            let linkStats = null
+            let stats = null
+            
+            try {
+              linkStats = await shell.context.fs.promises.lstat(target)
+              if (linkStats.isSymbolicLink()) {
+                try {
+                  linkTarget = await shell.context.fs.promises.readlink(target)
+                  stats = await shell.context.fs.promises.stat(target)
+                } catch {
+                  stats = linkStats
+                }
+              } else {
+                stats = linkStats
+              }
+            } catch {
+              stats = await shell.context.fs.promises.stat(target)
+            }
+            
+            return { target, name: entry, stats, linkStats, linkTarget }
           } catch {
-            return { target, name: entry, stats: null }
+            return { target, name: entry, stats: null, linkStats: null, linkTarget: null }
           }
         }))
 
@@ -83,9 +112,29 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         .map(async entry => {
           const target = path.resolve(fullPath, entry)
           try {
-            return { target, name: entry, stats: await shell.context.fs.promises.stat(target) }
+            let linkTarget: string | null = null
+            let linkStats = null
+            let stats = null
+            
+            try {
+              linkStats = await shell.context.fs.promises.lstat(target)
+              if (linkStats.isSymbolicLink()) {
+                try {
+                  linkTarget = await shell.context.fs.promises.readlink(target)
+                  stats = await shell.context.fs.promises.stat(target)
+                } catch {
+                  stats = linkStats
+                }
+              } else {
+                stats = linkStats
+              }
+            } catch {
+              stats = await shell.context.fs.promises.stat(target)
+            }
+            
+            return { target, name: entry, stats, linkStats, linkTarget }
           } catch {
-            return { target, name: entry, stats: null }
+            return { target, name: entry, stats: null, linkStats: null, linkTarget: null }
           }
         }))
 
@@ -97,22 +146,45 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
       const data = [
         ['Name', 'Size', 'Modified', 'Mode', 'Owner', 'Info'],
         ...directories.sort((a, b) => a.name.localeCompare(b.name)).map(directory => {
+          const displayName = directory.linkTarget
+            ? `${directory.name} ${chalk.cyan('⟶')} ${directory.linkTarget}`
+            : directory.name
+          const modeStats = directory.linkStats && directory.linkStats.isSymbolicLink() 
+            ? directory.linkStats 
+            : directory.stats
+          const modeString = modeStats 
+            ? getModeString(modeStats, directory.linkStats?.isSymbolicLink() ? directory.stats : undefined)
+            : ''
+          const linkInfo = getLinkInfo(directory.linkTarget, directory.linkStats, directory.stats)
           return [
-            directory.name,
+            displayName,
             '',
             directory.stats ? getTimestampString(directory.stats.mtime) : '',
-            directory.stats ? getModeString(directory.stats) : '',
+            modeString,
             directory.stats ? getOwnerString(directory.stats) : '',
+            linkInfo
           ]
         }),
         ...files.sort((a, b) => a.name.localeCompare(b.name)).map(file => {
+          const displayName = file.linkTarget
+            ? `${file.name} ${chalk.cyan('⟶')} ${file.linkTarget}`
+            : file.name
+          const modeStats = file.linkStats && file.linkStats.isSymbolicLink() 
+            ? file.linkStats 
+            : file.stats
+          const modeString = modeStats 
+            ? getModeString(modeStats, file.linkStats?.isSymbolicLink() ? file.stats : undefined)
+            : ''
           return [
-            file.name,
+            displayName,
             file.stats ? humanFormat(file.stats.size) : '',
             file.stats ? getTimestampString(file.stats.mtime) : '',
-            file.stats ? getModeString(file.stats) : '',
+            modeString,
             file.stats ? getOwnerString(file.stats) : '',
             (() => {
+              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))
               const ext = file.name.split('.').pop()
               if (ext && descriptions.has('.' + ext)) return descriptions.get('.' + ext)
@@ -142,7 +214,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           .map((cell, index) => {
             const paddedCell = cell.padEnd(columnWidths?.[index] ?? 0)
             if (index === 0 && rowIndex > 0) {
-              return row[3]?.startsWith('d') ? chalk.blue(paddedCell) : chalk.green(paddedCell)
+              if (row[3]?.startsWith('d')) return chalk.blue(paddedCell)
+              else if (row[3]?.startsWith('l')) return chalk.cyan(paddedCell)
+              else return chalk.green(paddedCell)
             } else return rowIndex === 0 ? chalk.bold(paddedCell) : chalk.gray(paddedCell)
           })
           .join('  ')

package/src/commands/sed.ts

@@ -0,0 +1,436 @@
+import path from 'path'
+import type { CommandLineOptions } from 'command-line-args'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStderr } from '../shared/helpers.js'
+
+interface SedCommand {
+  type: 'substitute' | 'delete' | 'print'
+  pattern?: string
+  replacement?: string
+  flags?: string
+  address?: {
+    type: 'line' | 'range' | 'pattern' | 'pattern-range'
+    start?: number | string
+    end?: number | string
+  }
+}
+
+function parseSedExpression(expr: string): SedCommand | null {
+  expr = expr.trim()
+  
+  const substituteMatch = expr.match(/^(\d+)?(,(\d+|\$))?s\/(.+?)\/(.*?)\/([gip]*\d*)$/)
+  if (substituteMatch) {
+    const [, startLine, , endLine, pattern, replacement, flags] = substituteMatch
+    const address = startLine ? {
+      type: (endLine ? 'range' : 'line') as 'range' | 'line',
+      start: parseInt(startLine, 10),
+      ...(endLine && { end: endLine === '$' ? Infinity : parseInt(endLine, 10) })
+    } : undefined
+    
+    return {
+      type: 'substitute',
+      pattern,
+      replacement: replacement || '',
+      flags: flags || '',
+      address
+    }
+  }
+  
+  const simpleSubstituteMatch = expr.match(/^s\/(.+?)\/(.*?)\/([gip]*\d*)$/)
+  if (simpleSubstituteMatch) {
+    const [, pattern, replacement, flags] = simpleSubstituteMatch
+    return {
+      type: 'substitute',
+      pattern,
+      replacement: replacement || '',
+      flags: flags || ''
+    }
+  }
+  
+  const deleteMatch = expr.match(/^(\d+)?(,(\d+|\$))?d$/)
+  if (deleteMatch) {
+    const [, startLine, , endLine] = deleteMatch
+    const address = startLine ? {
+      type: (endLine ? 'range' : 'line') as 'range' | 'line',
+      start: parseInt(startLine, 10),
+      ...(endLine && { end: endLine === '$' ? Infinity : parseInt(endLine, 10) })
+    } : undefined
+    
+    return {
+      type: 'delete',
+      address
+    }
+  }
+  
+  const patternDeleteMatch = expr.match(/^\/(.+?)\/d$/)
+  if (patternDeleteMatch) {
+    return {
+      type: 'delete',
+      address: {
+        type: 'pattern',
+        start: patternDeleteMatch[1]
+      }
+    }
+  }
+  
+  const printMatch = expr.match(/^\/(.+?)\/p$/)
+  if (printMatch) {
+    return {
+      type: 'print',
+      address: {
+        type: 'pattern',
+        start: printMatch[1]
+      }
+    }
+  }
+  
+  return null
+}
+
+function applySedCommand(line: string, lineNum: number, totalLines: number, command: SedCommand): { result: string | null; shouldPrint: boolean } {
+  if (command.type === 'substitute') {
+    if (!command.pattern || command.replacement === undefined) {
+      return { result: line, shouldPrint: false }
+    }
+    
+    let shouldApply = true
+    
+    if (command.address) {
+      switch (command.address.type) {
+        case 'line':
+          shouldApply = lineNum === command.address.start
+          break
+        case 'range':
+          const end = command.address.end === Infinity ? totalLines : (command.address.end as number)
+          shouldApply = lineNum >= (command.address.start as number) && lineNum <= end
+          break
+        case 'pattern':
+          try {
+            const regex = new RegExp(command.address.start as string)
+            shouldApply = regex.test(line)
+          } catch {
+            return { result: line, shouldPrint: false }
+          }
+          break
+      }
+    }
+    
+    if (!shouldApply) {
+      return { result: line, shouldPrint: false }
+    }
+    
+    const flags = command.flags || ''
+    const global = flags.includes('g')
+    const caseInsensitive = flags.includes('i')
+    const nthMatch = flags.match(/^\d+$/) ? parseInt(flags, 10) : null
+    
+    try {
+      let regexFlags = global ? 'g' : ''
+      if (caseInsensitive) regexFlags += 'i'
+      
+      if (nthMatch) {
+        let count = 0
+        const regex = new RegExp(command.pattern, caseInsensitive ? 'gi' : 'g')
+        const result = line.replace(regex, (match) => {
+          count++
+          if (count === nthMatch) {
+            return command.replacement || match
+          }
+          return match
+        })
+        return { result, shouldPrint: false }
+      }
+      
+      const regex = new RegExp(command.pattern, regexFlags || undefined)
+      const result = line.replace(regex, command.replacement)
+      return { result, shouldPrint: false }
+    } catch {
+      return { result: line, shouldPrint: false }
+    }
+  }
+  
+  if (command.type === 'delete') {
+    if (command.address) {
+      switch (command.address.type) {
+        case 'line':
+          if (lineNum === command.address.start) {
+            return { result: null, shouldPrint: false }
+          }
+          break
+        case 'range':
+          const end = command.address.end === Infinity ? totalLines : (command.address.end as number)
+          if (lineNum >= (command.address.start as number) && lineNum <= end) {
+            return { result: null, shouldPrint: false }
+          }
+          break
+        case 'pattern':
+          try {
+            const regex = new RegExp(command.address.start as string)
+            if (regex.test(line)) {
+              return { result: null, shouldPrint: false }
+            }
+          } catch {
+            return { result: line, shouldPrint: false }
+          }
+          break
+      }
+    }
+    return { result: line, shouldPrint: false }
+  }
+  
+  if (command.type === 'print') {
+    if (command.address && command.address.type === 'pattern') {
+      try {
+        const regex = new RegExp(command.address.start as string)
+        if (regex.test(line)) {
+          return { result: line, shouldPrint: true }
+        }
+      } catch {
+        return { result: line, shouldPrint: false }
+      }
+    }
+    return { result: line, shouldPrint: false }
+  }
+  
+  return { result: line, shouldPrint: false }
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'sed',
+    description: 'Stream editor for filtering and transforming text',
+    kernel,
+    shell,
+    terminal,
+    options: [
+      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
+      { name: 'expression', type: String, alias: 'e', multiple: true, description: 'Add the script to the commands to be executed' },
+      { name: 'file', type: String, alias: 'f', description: 'Add the contents of script-file to the commands to be executed' },
+      { name: 'inplace', type: String, alias: 'i', description: 'Edit files in place (makes backup if extension supplied)' },
+      { name: 'quiet', type: Boolean, alias: 'q', description: 'Suppress normal output' },
+      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, multiple: true, description: 'Expression or input file(s)' }
+    ],
+    run: async (argv: CommandLineOptions, process?: Process) => {
+      if (!process) return 1
+
+      let expressions = (argv.expression as string[]) || []
+      let files = (argv.path as string[]) || []
+      const inplace = argv.inplace as string | undefined
+      const quiet = argv.quiet as boolean || false
+
+      const isSedExpression = (arg: string): boolean => {
+        if (!arg) return false
+        const trimmed = arg.trim()
+        return (
+          trimmed.startsWith('s/') ||
+          trimmed.startsWith('/') ||
+          /^\d+[sd]/.test(trimmed) ||
+          /^\d+,\d*[sd]/.test(trimmed) ||
+          /^\d+s\//.test(trimmed) ||
+          /^\d+,\d*s\//.test(trimmed)
+        )
+      }
+
+      const potentialExpressions: string[] = []
+      const potentialFiles: string[] = []
+
+      for (const arg of files) {
+        if (isSedExpression(arg)) {
+          potentialExpressions.push(arg)
+        } else {
+          potentialFiles.push(arg)
+        }
+      }
+
+      if (potentialExpressions.length > 0) {
+        expressions = [...expressions, ...potentialExpressions]
+        files = potentialFiles
+      }
+
+      if (expressions.length === 0 && !argv.file) {
+        await writelnStderr(process, terminal, 'sed: No expression provided')
+        return 1
+      }
+
+      const commands: SedCommand[] = []
+
+      if (argv.file) {
+        const scriptPath = path.resolve(shell.cwd, argv.file as string)
+        const exists = await shell.context.fs.promises.exists(scriptPath)
+        if (!exists) {
+          await writelnStderr(process, terminal, `sed: ${argv.file}: No such file or directory`)
+          return 1
+        }
+
+        const scriptContent = await shell.context.fs.promises.readFile(scriptPath, 'utf-8')
+        const scriptLines = scriptContent.split('\n').filter(line => line.trim() && !line.trim().startsWith('#'))
+        
+        for (const line of scriptLines) {
+          const cmd = parseSedExpression(line.trim())
+          if (cmd) commands.push(cmd)
+        }
+      }
+
+      for (const expr of expressions) {
+        const cmd = parseSedExpression(expr)
+        if (cmd) {
+          commands.push(cmd)
+        } else {
+          await writelnStderr(process, terminal, `sed: Invalid expression: ${expr}`)
+          return 1
+        }
+      }
+
+      if (commands.length === 0) {
+        await writelnStderr(process, terminal, 'sed: No valid commands found')
+        return 1
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        const processFile = async (filePath: string): Promise<string[]> => {
+          const exists = await shell.context.fs.promises.exists(filePath)
+          if (!exists) {
+            await writelnStderr(process, terminal, `sed: ${filePath}: No such file or directory`)
+            return []
+          }
+
+          const stats = await shell.context.fs.promises.stat(filePath)
+          if (stats.isDirectory()) {
+            await writelnStderr(process, terminal, `sed: ${filePath}: Is a directory`)
+            return []
+          }
+
+          const content = await shell.context.fs.promises.readFile(filePath, 'utf-8')
+          return content.split('\n')
+        }
+
+        let inputLines: string[] = []
+
+        if (files.length > 0) {
+          for (const file of files) {
+            const expandedPath = shell.expandTilde(file)
+            const fullPath = path.resolve(shell.cwd, expandedPath)
+            const lines = await processFile(fullPath)
+            inputLines.push(...lines)
+            if (lines.length > 0 && inputLines.length > lines.length) {
+              inputLines.push('')
+            }
+          }
+        } else {
+          if (!process.stdin) {
+            await writelnStderr(process, terminal, 'sed: No input provided')
+            return 1
+          }
+
+          const reader = process.stdin.getReader()
+          const decoder = new TextDecoder()
+          const chunks: string[] = []
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+              chunks.push(decoder.decode(value, { stream: true }))
+            }
+            chunks.push(decoder.decode(new Uint8Array(), { stream: false }))
+          } finally {
+            reader.releaseLock()
+          }
+
+          const content = chunks.join('')
+          inputLines = content.split('\n')
+        }
+
+        const outputLines: string[] = []
+        const totalLines = inputLines.length
+
+        for (let i = 0; i < inputLines.length; i++) {
+          let line = inputLines[i] || ''
+          let lineNum = i + 1
+          let shouldPrint = false
+
+          for (const command of commands) {
+            const { result, shouldPrint: print } = applySedCommand(line, lineNum, totalLines, command)
+            if (result === null) {
+              line = null as unknown as string
+              break
+            }
+            line = result
+            if (print) {
+              shouldPrint = true
+            }
+          }
+
+          if (line !== null) {
+            outputLines.push(line)
+            if (shouldPrint && !quiet) {
+              outputLines.push(line)
+            }
+          }
+        }
+
+        const output = outputLines.join('\n')
+
+        if (inplace !== undefined && files.length > 0) {
+          for (const file of files) {
+            const expandedPath = shell.expandTilde(file)
+            const fullPath = path.resolve(shell.cwd, expandedPath)
+            
+            const fileLines = await processFile(fullPath)
+            if (fileLines.length === 0) continue
+            
+            const fileOutputLines: string[] = []
+            const fileTotalLines = fileLines.length
+
+            for (let i = 0; i < fileLines.length; i++) {
+              let line = fileLines[i] || ''
+              let lineNum = i + 1
+              let shouldPrint = false
+
+              for (const command of commands) {
+                const { result, shouldPrint: print } = applySedCommand(line, lineNum, fileTotalLines, command)
+                if (result === null) {
+                  line = null as unknown as string
+                  break
+                }
+                line = result
+                if (print) {
+                  shouldPrint = true
+                }
+              }
+
+              if (line !== null) {
+                fileOutputLines.push(line)
+                if (shouldPrint && !quiet) {
+                  fileOutputLines.push(line)
+                }
+              }
+            }
+
+            const fileOutput = fileOutputLines.join('\n')
+            
+            if (inplace) {
+              const backupPath = `${fullPath}${inplace}`
+              const originalContent = await shell.context.fs.promises.readFile(fullPath, 'utf-8')
+              await shell.context.fs.promises.writeFile(backupPath, originalContent)
+            }
+            
+            await shell.context.fs.promises.writeFile(fullPath, fileOutput)
+          }
+        } else {
+          await writer.write(new TextEncoder().encode(output))
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `sed: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/tee.ts

@@ -0,0 +1,93 @@
+import path from 'path'
+import type { CommandLineOptions } from 'command-line-args'
+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'
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'tee',
+    description: 'Read from standard input and write to standard output and files',
+    kernel,
+    shell,
+    terminal,
+    options: [
+      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
+      { name: 'append', type: Boolean, alias: 'a', description: 'Append to the given files, do not overwrite' },
+      { name: 'ignore-interrupts', type: Boolean, alias: 'i', description: 'Ignore interrupt signals' },
+      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, multiple: true, description: 'File(s) to write to' }
+    ],
+    run: async (argv: CommandLineOptions, process?: Process) => {
+      if (!process) return 1
+
+      if (!process.stdin) {
+        await writelnStderr(process, terminal, 'tee: No input provided')
+        return 1
+      }
+
+      const files = (argv.path as string[]) || []
+      const append = (argv.append as boolean) || false
+      const ignoreInterrupts = (argv['ignore-interrupts'] as boolean) || false
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        const filePaths: Array<{ path: string; fullPath: string }> = []
+        for (const file of files) {
+          const expandedPath = shell.expandTilde(file)
+          const fullPath = path.resolve(shell.cwd, expandedPath)
+
+          if (!append) {
+            try {
+              await shell.context.fs.promises.writeFile(fullPath, '')
+            } catch (error) {
+              await writelnStderr(process, terminal, `tee: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+              return 1
+            }
+          }
+
+          filePaths.push({ path: file, fullPath })
+        }
+
+        const reader = process.stdin.getReader()
+        let interrupted = false
+
+        const interruptHandler = () => { interrupted = true }
+        if (!ignoreInterrupts) {
+          kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+        }
+
+        try {
+          while (true) {
+            if (interrupted) break
+            const { done, value } = await reader.read()
+            if (done) break
+
+            await writer.write(value)
+
+            for (const fileInfo of filePaths) {
+              try {
+                await shell.context.fs.promises.appendFile(fileInfo.fullPath, value)
+              } catch (error) {
+                await writelnStderr(process, terminal, `tee: ${fileInfo.path}: ${error instanceof Error ? error.message : 'Write error'}`)
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock()
+          if (!ignoreInterrupts) {
+            kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+          }
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `tee: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}