@ecmaos/coreutils 0.3.1 → 0.4.2

package/src/commands/column.ts

@@ -0,0 +1,273 @@
+import path from 'path'
+import columnify from 'columnify'
+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: column [OPTION]... [FILE]...
+Format input into columns.
+
+  -t, --table              create a table
+  -s, --separator=SEP      specify column separator (default: whitespace)
+  -c, --columns=COLS       specify number of columns
+  --help                   display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'column',
+    description: 'Format input into columns',
+    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 table = false
+      let separator: string | undefined
+      let columns: number | undefined
+      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 === '-t' || arg === '--table') {
+          table = true
+        } else if (arg === '-s' || arg === '--separator') {
+          if (i + 1 < argv.length) {
+            separator = argv[++i]
+          }
+        } else if (arg.startsWith('--separator=')) {
+          separator = arg.slice(12)
+        } else if (arg.startsWith('-s')) {
+          separator = arg.slice(2) || undefined
+        } else if (arg === '-c' || arg === '--columns') {
+          if (i + 1 < argv.length) {
+            const colsStr = argv[++i]
+            if (colsStr !== undefined) {
+              const parsed = parseInt(colsStr, 10)
+              if (!isNaN(parsed) && parsed > 0) {
+                columns = parsed
+              } else {
+                await writelnStderr(process, terminal, `column: invalid column count: ${colsStr}`)
+                return 1
+              }
+            }
+          }
+        } else if (arg.startsWith('--columns=')) {
+          const colsStr = arg.slice(11)
+          const parsed = parseInt(colsStr, 10)
+          if (!isNaN(parsed) && parsed > 0) {
+            columns = parsed
+          } else {
+            await writelnStderr(process, terminal, `column: invalid column count: ${colsStr}`)
+            return 1
+          }
+        } else if (arg.startsWith('-c')) {
+          const colsStr = arg.slice(2)
+          if (colsStr) {
+            const parsed = parseInt(colsStr, 10)
+            if (!isNaN(parsed) && parsed > 0) {
+              columns = parsed
+            } else {
+              await writelnStderr(process, terminal, `column: invalid column count: ${colsStr}`)
+              return 1
+            }
+          }
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        } else {
+          await writelnStderr(process, terminal, `column: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'column --help' for more information.")
+          return 1
+        }
+      }
+
+      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, `column: ${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, `column: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        if (table && separator) {
+          const data: Array<Record<string, string>> = []
+          const headers = new Set<string>()
+
+          for (const line of lines) {
+            if (!line.trim()) continue
+            const parts = line.split(separator)
+            const row: Record<string, string> = {}
+            parts.forEach((part, idx) => {
+              const header = `col${idx + 1}`
+              headers.add(header)
+              row[header] = part.trim()
+            })
+            data.push(row)
+          }
+
+          if (data.length > 0) {
+            const tableOutput = columnify(data, {
+              columns: Array.from(headers),
+              columnSplitter: '  ',
+              showHeaders: true
+            })
+            await writer.write(new TextEncoder().encode(tableOutput))
+          }
+        } else if (table) {
+          const data: Array<Record<string, string>> = []
+          const headers = new Set<string>()
+
+          for (const line of lines) {
+            if (!line.trim()) continue
+            const parts = line.trim().split(/\s+/)
+            const row: Record<string, string> = {}
+            parts.forEach((part, idx) => {
+              const header = `col${idx + 1}`
+              headers.add(header)
+              row[header] = part
+            })
+            data.push(row)
+          }
+
+          if (data.length > 0) {
+            const tableOutput = columnify(data, {
+              columns: Array.from(headers),
+              columnSplitter: '  ',
+              showHeaders: true
+            })
+            await writer.write(new TextEncoder().encode(tableOutput))
+          }
+        } else {
+          const words: string[] = []
+          for (const line of lines) {
+            if (separator) {
+              words.push(...line.split(separator).map(w => w.trim()).filter(w => w))
+            } else {
+              words.push(...line.trim().split(/\s+/).filter(w => w))
+            }
+          }
+
+          if (columns && columns > 0) {
+            const rows: string[][] = []
+            for (let i = 0; i < words.length; i += columns) {
+              rows.push(words.slice(i, i + columns))
+            }
+
+            const data: Array<Record<string, string>> = []
+            for (const row of rows) {
+              const rowObj: Record<string, string> = {}
+              for (let i = 0; i < columns; i++) {
+                rowObj[`col${i + 1}`] = row[i] || ''
+              }
+              data.push(rowObj)
+            }
+
+            if (data.length > 0) {
+              const tableOutput = columnify(data, {
+                columns: Array.from({ length: columns }, (_, i) => `col${i + 1}`),
+                columnSplitter: '  ',
+                showHeaders: false
+              })
+              await writer.write(new TextEncoder().encode(tableOutput))
+            }
+          } else {
+            for (const word of words) {
+              await writer.write(new TextEncoder().encode(word + '\n'))
+            }
+          }
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `column: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/cp.ts

@@ -1,16 +1,52 @@
 import path from 'path'
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
-import { writelnStderr } from '../shared/helpers.js'
+import { writelnStderr, writelnStdout } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: cp [OPTION]... SOURCE... DEST
 Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.
 
-  --help  display this help and exit`
+  -r, -R, --recursive   copy directories recursively
+  -v, --verbose         explain what is being done
+  --help                display this help and exit`
   writelnStderr(process, terminal, usage)
 }
 
+async function copyRecursive(
+  fs: typeof import('@zenfs/core').fs.promises,
+  sourcePath: string,
+  destPath: string,
+  verbose: boolean,
+  process: Process | undefined,
+  terminal: Terminal,
+  relativeSource: string,
+  relativeDest: string
+): Promise<void> {
+  const stats = await fs.stat(sourcePath)
+
+  if (stats.isDirectory()) {
+    try {
+      await fs.mkdir(destPath)
+      if (verbose) await writelnStdout(process, terminal, `'${relativeSource}' -> '${relativeDest}'`)
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error
+    }
+
+    const entries = await fs.readdir(sourcePath)
+    for (const entry of entries) {
+      const srcEntry = path.join(sourcePath, entry)
+      const destEntry = path.join(destPath, entry)
+      const srcRelative = path.join(relativeSource, entry)
+      const destRelative = path.join(relativeDest, entry)
+      await copyRecursive(fs, srcEntry, destEntry, verbose, process, terminal, srcRelative, destRelative)
+    }
+  } else {
+    await fs.copyFile(sourcePath, destPath)
+    if (verbose) await writelnStdout(process, terminal, `'${relativeSource}' -> '${relativeDest}'`)
+  }
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'cp',
@@ -26,9 +62,31 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return 0
       }
 
+      let recursive = false
+      let verbose = false
       const args: string[] = []
+
       for (const arg of argv) {
-        if (arg && !arg.startsWith('-')) {
+        if (arg.startsWith('-') && arg !== '--') {
+          if (arg === '--recursive') {
+            recursive = true
+          } else if (arg === '--verbose') {
+            verbose = true
+          } else if (arg.length > 1) {
+            for (let i = 1; i < arg.length; i++) {
+              const flag = arg[i]
+              if (flag === 'r' || flag === 'R') {
+                recursive = true
+              } else if (flag === 'v') {
+                verbose = true
+              } else {
+                await writelnStderr(process, terminal, `cp: invalid option -- '${flag}'`)
+                await writelnStderr(process, terminal, "Try 'cp --help' for more information.")
+                return 1
+              }
+            }
+          }
+        } else if (arg && !arg.startsWith('-')) {
           args.push(arg)
         }
       }
@@ -67,7 +125,38 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             : path.resolve(shell.cwd, destination)
 
           try {
-            await shell.context.fs.promises.copyFile(sourcePath, finalDestination)
+            const sourceStats = await shell.context.fs.promises.stat(sourcePath)
+
+            if (sourceStats.isDirectory()) {
+              if (!recursive) {
+                await writelnStderr(process, terminal, `cp: -r not specified; omitting directory '${source}'`)
+                hasError = true
+                continue
+              }
+              const relativeSource = source
+              const relativeDest = isDestinationDir 
+                ? path.join(destination, path.basename(source))
+                : destination
+              await copyRecursive(
+                shell.context.fs.promises,
+                sourcePath,
+                finalDestination,
+                verbose,
+                process,
+                terminal,
+                relativeSource,
+                relativeDest
+              )
+            } else {
+              await shell.context.fs.promises.copyFile(sourcePath, finalDestination)
+              if (verbose) {
+                const relativeSource = source
+                const relativeDest = isDestinationDir 
+                  ? path.join(destination, path.basename(source))
+                  : destination
+                await writelnStdout(process, terminal, `'${relativeSource}' -> '${relativeDest}'`)
+              }
+            }
           } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error)
             await writelnStderr(process, terminal, `cp: ${source}: ${errorMessage}`)

package/src/commands/cron.ts

@@ -3,6 +3,7 @@ import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
 import { writelnStdout, writelnStderr } from '../shared/helpers.js'
 import { parseCronExpression } from 'cron-schedule'
+import cronstrue from 'cronstrue'
 
 interface CrontabEntry {
   expression: string
@@ -37,44 +38,46 @@ function parseCrontabLine(line: string): { expression: string, command: string }
   let expression: string
   let command: string
 
-  // If we have exactly 6 parts, it must be 5-field format (5 cron fields + 1 command word)
+  // If we have exactly 6 parts, assume 5-field format (5 cron fields + 1 command word)
+  // This is the most common case
   if (parts.length === 6) {
     // 5-field format: minute hour day month weekday command
     expression = parts.slice(0, 5).join(' ')
     command = parts[5] || ''
   } else {
     // 7+ parts: could be 5-field with multi-word command or 6-field format
-    // Try parsing as 5-field first (more common), then 6-field if that fails
+    // Try 6-field format FIRST (if user wrote 6 fields, they probably meant 6 fields)
+    // Then fall back to 5-field if 6-field is invalid
     const potential5Field = parts.slice(0, 5).join(' ')
     const potential6Field = parts.slice(0, 6).join(' ')
     
     let valid5Field = false
     let valid6Field = false
     
-    // Try to validate 5-field format
+    // Try to validate 6-field format first
     try {
-      parseCronExpression(potential5Field)
-      valid5Field = true
+      parseCronExpression(potential6Field)
+      valid6Field = true
     } catch {
-      // Not a valid 5-field expression
+      // Not a valid 6-field expression
     }
     
-    // Try to validate 6-field format
+    // Try to validate 5-field format
     try {
-      parseCronExpression(potential6Field)
-      valid6Field = true
+      parseCronExpression(potential5Field)
+      valid5Field = true
     } catch {
-      // Not a valid 6-field expression
+      // Not a valid 5-field expression
     }
     
-    // Prefer 5-field format if both are valid (more common)
-    // Only use 6-field if 5-field is invalid but 6-field is valid
-    if (valid5Field) {
-      expression = potential5Field
-      command = parts.slice(5).join(' ')
-    } else if (valid6Field) {
+    // Prefer 6-field format if valid (user wrote 6 fields, so use them)
+    // Only use 5-field if 6-field is invalid
+    if (valid6Field) {
       expression = potential6Field
       command = parts.slice(6).join(' ')
+    } else if (valid5Field) {
+      expression = potential5Field
+      command = parts.slice(5).join(' ')
     } else {
       // Neither format is valid, return null
       return null
@@ -118,11 +121,30 @@ function parseCrontabFile(content: string): CrontabEntry[] {
   return entries
 }
 
+/**
+ * Get human-readable description of a cron expression
+ * @param expression - The cron expression
+ * @returns Human-readable description or null if parsing fails
+ */
+function getHumanReadableDescription(expression: string): string | null {
+  try {
+    return cronstrue.toString(expression, {
+      throwExceptionOnParseError: false,
+      verbose: false
+    })
+  } catch {
+    return null
+    }
+}
+
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: cron [COMMAND] [OPTIONS]
-
+  
 Manage scheduled tasks (crontabs).
 
+Options:
+  --help  display this help and exit
+
 Commands:
   list                    List all active cron jobs
   add <schedule> <cmd>    Add a new cron job to user crontab
@@ -136,6 +158,7 @@ Commands:
 Examples:
   cron list                                    List all cron jobs
   cron add "*/5 * * * *" "echo hello"          Add job to run every 5 minutes
+  cron add "* * * * * *" "echo hello"          Add job to run every second (6-field)
   cron add "0 0 * * *" "echo daily"            Add daily job at midnight
   cron remove cron:user:1                      Remove user cron job #1
   cron validate "*/5 * * * *"                  Validate cron expression
@@ -143,10 +166,14 @@ Examples:
   cron test "*/5 * * * *"                      Test if expression matches now
 
 Crontab format:
-  Standard: minute hour day month weekday command
-  Extended: second minute hour day month weekday command
-
-  --help  display this help and exit`
+  Both 5-field and 6-field cron expressions are supported:
+  
+  5-field (standard): minute hour day month weekday command
+    Example: "*/5 * * * *" runs every 5 minutes
+  
+  6-field (extended): second minute hour day month weekday command
+    Example: "* * * * * *" runs every second
+    Example: "0 */5 * * * *" runs every 5 minutes at :00 seconds`
   writelnStderr(process, terminal, usage)
 }
 
@@ -176,9 +203,57 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
               return 0
             }
 
+            // Build a map of job names to expressions by parsing crontab files
+            const jobExpressions = new Map<string, { expression: string, command: string }>()
+
+            // Load system crontab entries
+            try {
+              const systemCrontabPath = '/etc/crontab'
+              if (await kernel.filesystem.fs.exists(systemCrontabPath)) {
+                const content = await kernel.filesystem.fs.readFile(systemCrontabPath, 'utf-8')
+                const entries = parseCrontabFile(content)
+                for (const entry of entries) {
+                  const jobName = `cron:system:${entry.lineNumber}`
+                  jobExpressions.set(jobName, { expression: entry.expression, command: entry.command })
+                }
+              }
+            } catch {
+              // Ignore errors loading system crontab
+            }
+
+            // Load user crontab entries
+            try {
+              const home = shell.env.get('HOME') ?? '/root'
+              const userCrontabPath = path.join(home, '.config', 'crontab')
+              if (await shell.context.fs.promises.exists(userCrontabPath)) {
+                const content = await shell.context.fs.promises.readFile(userCrontabPath, 'utf-8')
+                const entries = parseCrontabFile(content)
+                for (const entry of entries) {
+                  const jobName = `cron:user:${entry.lineNumber}`
+                  jobExpressions.set(jobName, { expression: entry.expression, command: entry.command })
+                }
+              }
+            } catch {
+              // Ignore errors loading user crontab
+            }
+
             await writelnStdout(process, terminal, 'Active cron jobs:')
             for (const jobName of cronJobs) {
-              await writelnStdout(process, terminal, `  ${jobName}`)
+              const jobInfo = jobExpressions.get(jobName)
+              if (jobInfo) {
+                const description = getHumanReadableDescription(jobInfo.expression)
+                if (description) {
+                  await writelnStdout(process, terminal, `  ${jobName}`)
+                  await writelnStdout(process, terminal, `    Schedule: ${jobInfo.expression} (${description})`)
+                  await writelnStdout(process, terminal, `    Command: ${jobInfo.command}`)
+                } else {
+                  await writelnStdout(process, terminal, `  ${jobName}`)
+                  await writelnStdout(process, terminal, `    Schedule: ${jobInfo.expression}`)
+                  await writelnStdout(process, terminal, `    Command: ${jobInfo.command}`)
+                }
+              } else {
+                await writelnStdout(process, terminal, `  ${jobName}`)
+              }
             }
             return 0
           }
@@ -199,8 +274,10 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             const command = argv.slice(2).join(' ')
 
             // Validate the cron expression
+            let humanReadable: string | null = null
             try {
               parseCronExpression(schedule)
+              humanReadable = getHumanReadableDescription(schedule)
             } catch (error) {
               await writelnStderr(process, terminal, `cron add: invalid cron expression: ${schedule}`)
               return 1
@@ -247,6 +324,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             }
 
             await writelnStdout(process, terminal, `Added cron job: ${schedule} ${command}`)
+            if (humanReadable) {
+              await writelnStdout(process, terminal, `  Schedule: ${humanReadable}`)
+            }
             await writelnStdout(process, terminal, 'Run "cron reload" to activate the new job.')
             return 0
           }
@@ -311,7 +391,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
             // Use view command to edit (or create if doesn't exist)
             const result = await kernel.execute({
-              command: '/bin/view',
+              command: '/usr/bin/edit',
               args: [crontabPath],
               shell,
               terminal
@@ -338,7 +418,11 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             }
             try {
               parseCronExpression(expression)
+              const description = getHumanReadableDescription(expression)
               await writelnStdout(process, terminal, `Valid cron expression: ${expression}`)
+              if (description) {
+                await writelnStdout(process, terminal, `  Description: ${description}`)
+              }
               return 0
             } catch (error) {
               await writelnStderr(process, terminal, `Invalid cron expression: ${expression}`)
@@ -370,8 +454,12 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
               const cron = parseCronExpression(expression)
               const now = new Date()
               const dates = cron.getNextDates(count, now)
+              const description = getHumanReadableDescription(expression)
 
               await writelnStdout(process, terminal, `Next ${count} execution time(s) for "${expression}":`)
+              if (description) {
+                await writelnStdout(process, terminal, `  Schedule: ${description}`)
+              }
               for (let i = 0; i < dates.length; i++) {
                 const date = dates[i]
                 if (date) {
@@ -402,12 +490,16 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
               const cron = parseCronExpression(expression)
               const now = new Date()
               const matches = cron.matchDate(now)
+              const description = getHumanReadableDescription(expression)
 
               if (matches) {
                 await writelnStdout(process, terminal, `Expression "${expression}" matches current time: ${now.toISOString()}`)
               } else {
                 await writelnStdout(process, terminal, `Expression "${expression}" does not match current time: ${now.toISOString()}`)
               }
+              if (description) {
+                await writelnStdout(process, terminal, `  Schedule: ${description}`)
+              }
               return 0
             } catch (error) {
               await writelnStderr(process, terminal, `Invalid cron expression: ${expression}`)