@ecmaos/coreutils 0.1.4 → 0.2.0

package/src/commands/rmdir.ts

@@ -1,7 +1,15 @@
 import path from 'path'
-import type { CommandLineOptions } from 'command-line-args'
-import type { Kernel, Shell, Terminal } from '@ecmaos/types'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: rmdir [OPTION]... DIRECTORY...
+Remove the DIRECTORY(ies), if they are empty.
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
@@ -10,16 +18,37 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, description: 'The path to the directory to remove' }
-    ],
-    run: async (argv: CommandLineOptions) => {
-      const target = (argv.path as string) || shell.cwd
-      const fullPath = target ? path.resolve(shell.cwd, target) : shell.cwd
-      await shell.context.fs.promises.rm(fullPath, { recursive: true, force: true })
-      return 0
+    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
+      }
+
+      if (argv.length === 0) {
+        await writelnStderr(process, terminal, 'rmdir: missing operand')
+        await writelnStderr(process, terminal, "Try 'rmdir --help' for more information.")
+        return 1
+      }
+
+      let hasError = false
+
+      for (const target of argv) {
+        if (!target || target.startsWith('-')) continue
+
+        const fullPath = target ? path.resolve(shell.cwd, target) : shell.cwd
+        
+        try {
+          await shell.context.fs.promises.rm(fullPath, { recursive: true, force: true })
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error)
+          await writelnStderr(process, terminal, `rmdir: ${target}: ${errorMessage}`)
+          hasError = true
+        }
+      }
+
+      return hasError ? 1 : 0
     }
   })
 }
-

package/src/commands/sed.ts

@@ -1,5 +1,4 @@
 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'
@@ -16,6 +15,19 @@ interface SedCommand {
   }
 }
 
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: sed [OPTION]... {script-only-if-no-other-script} [input-file]...
+
+Stream editor for filtering and transforming text.
+
+  -e, --expression=script  add the script to the commands to be executed
+  -f, --file=script-file    add the contents of script-file to the commands
+  -i[SUFFIX], --in-place[=SUFFIX]  edit files in place (makes backup if SUFFIX supplied)
+  -q, --quiet               suppress normal output
+  --help                    display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
 function parseSedExpression(expr: string): SedCommand | null {
   expr = expr.trim()
   
@@ -203,21 +215,21 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     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) => {
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
       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
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      let expressions: string[] = []
+      const files: string[] = []
+      let scriptFile: string | undefined
+      let inplace: string | undefined
+      let quiet = false
 
       const isSedExpression = (arg: string): boolean => {
         if (!arg) return false
@@ -232,34 +244,56 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         )
       }
 
-      const potentialExpressions: string[] = []
-      const potentialFiles: string[] = []
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (!arg) continue
 
-      for (const arg of files) {
-        if (isSedExpression(arg)) {
-          potentialExpressions.push(arg)
-        } else {
-          potentialFiles.push(arg)
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-e' || arg === '--expression') {
+          if (i + 1 < argv.length) {
+            expressions.push(argv[++i] || '')
+          }
+        } else if (arg.startsWith('--expression=')) {
+          expressions.push(arg.slice(13))
+        } else if (arg.startsWith('-e')) {
+          expressions.push(arg.slice(2))
+        } else if (arg === '-f' || arg === '--file') {
+          if (i + 1 < argv.length) {
+            scriptFile = argv[++i]
+          }
+        } else if (arg.startsWith('--file=')) {
+          scriptFile = arg.slice(7)
+        } else if (arg.startsWith('-f')) {
+          scriptFile = arg.slice(2)
+        } else if (arg === '-i' || arg === '--in-place') {
+          inplace = ''
+        } else if (arg.startsWith('--in-place=')) {
+          inplace = arg.slice(12)
+        } else if (arg.startsWith('-i')) {
+          inplace = arg.slice(2) || ''
+        } else if (arg === '-q' || arg === '--quiet') {
+          quiet = true
+        } else if (isSedExpression(arg)) {
+          expressions.push(arg)
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
         }
       }
 
-      if (potentialExpressions.length > 0) {
-        expressions = [...expressions, ...potentialExpressions]
-        files = potentialFiles
-      }
-
-      if (expressions.length === 0 && !argv.file) {
+      if (expressions.length === 0 && !scriptFile) {
         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)
+      if (scriptFile) {
+        const scriptPath = path.resolve(shell.cwd, scriptFile)
         const exists = await shell.context.fs.promises.exists(scriptPath)
         if (!exists) {
-          await writelnStderr(process, terminal, `sed: ${argv.file}: No such file or directory`)
+          await writelnStderr(process, terminal, `sed: ${scriptFile}: No such file or directory`)
           return 1
         }
 

package/src/commands/seq.ts

@@ -0,0 +1,147 @@
+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: seq [OPTION]... LAST
+       seq [OPTION]... FIRST LAST
+       seq [OPTION]... FIRST INCREMENT LAST
+Print numbers from FIRST to LAST, in steps of INCREMENT.
+
+  -s, --separator=STRING   use STRING to separate numbers (default: \\n)
+  --help                    display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'seq',
+    description: 'Print a sequence of numbers',
+    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 separator = '\n'
+      const args: 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 === '-s' || arg === '--separator') {
+          if (i + 1 < argv.length) {
+            const nextArg = argv[++i]
+            if (nextArg !== undefined) {
+              separator = nextArg
+            }
+          } else {
+            await writelnStderr(process, terminal, 'seq: option requires an argument -- \'s\'')
+            return 1
+          }
+        } else if (arg.startsWith('--separator=')) {
+          separator = arg.slice(12)
+        } else if (arg.startsWith('-s')) {
+          separator = arg.slice(2)
+        } else if (!arg.startsWith('-')) {
+          args.push(arg)
+        }
+      }
+
+      if (args.length === 0) {
+        await writelnStderr(process, terminal, 'seq: missing operand')
+        return 1
+      }
+
+      let first = 1
+      let increment = 1
+      let last: number
+
+      if (args.length === 1) {
+        const arg0 = args[0]
+        if (arg0 === undefined) {
+          await writelnStderr(process, terminal, 'seq: missing operand')
+          return 1
+        }
+        last = parseFloat(arg0)
+        if (isNaN(last)) {
+          await writelnStderr(process, terminal, `seq: invalid number: ${arg0}`)
+          return 1
+        }
+      } else if (args.length === 2) {
+        const arg0 = args[0]
+        const arg1 = args[1]
+        if (arg0 === undefined || arg1 === undefined) {
+          await writelnStderr(process, terminal, 'seq: missing operand')
+          return 1
+        }
+        first = parseFloat(arg0)
+        last = parseFloat(arg1)
+        if (isNaN(first) || isNaN(last)) {
+          await writelnStderr(process, terminal, 'seq: invalid number')
+          return 1
+        }
+      } else if (args.length === 3) {
+        const arg0 = args[0]
+        const arg1 = args[1]
+        const arg2 = args[2]
+        if (arg0 === undefined || arg1 === undefined || arg2 === undefined) {
+          await writelnStderr(process, terminal, 'seq: missing operand')
+          return 1
+        }
+        first = parseFloat(arg0)
+        increment = parseFloat(arg1)
+        last = parseFloat(arg2)
+        if (isNaN(first) || isNaN(increment) || isNaN(last)) {
+          await writelnStderr(process, terminal, 'seq: invalid number')
+          return 1
+        }
+      } else {
+        await writelnStderr(process, terminal, 'seq: too many arguments')
+        return 1
+      }
+
+      const writer = process.stdout.getWriter()
+      const numbers: number[] = []
+
+      if (increment > 0) {
+        for (let i = first; i <= last; i += increment) {
+          numbers.push(i)
+        }
+      } else if (increment < 0) {
+        for (let i = first; i >= last; i += increment) {
+          numbers.push(i)
+        }
+      } else {
+        await writelnStderr(process, terminal, 'seq: zero increment')
+        writer.releaseLock()
+        return 1
+      }
+
+      const output = numbers.map(n => {
+        if (Number.isInteger(n)) {
+          return n.toString()
+        } else {
+          return n.toFixed(10).replace(/\.?0+$/, '')
+        }
+      }).join(separator)
+
+      try {
+        await writer.write(new TextEncoder().encode(output + (separator === '\n' ? '' : '\n')))
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/sockets.ts

@@ -0,0 +1,283 @@
+import chalk from 'chalk'
+import columnify from 'columnify'
+import type { Kernel, Process, Shell, Terminal, SocketConnection } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: sockets [COMMAND] [OPTIONS]
+
+Manage socket connections (WebSocket and WebTransport).
+
+Commands:
+  list, ls              List all active connections
+  create, c <url>       Create a new connection
+  close, d <id>         Close a connection by ID
+  show, s <id>          Show detailed information about a connection
+  --help, -h            Display this help and exit
+
+Options:
+  -t, --type <type>     Connection type: websocket or webtransport (for create)
+  -p, --protocols       WebSocket protocols (comma-separated, for create)
+
+Examples:
+  sockets list
+  sockets create wss://echo.websocket.org
+  sockets create https://example.com:443 -t webtransport
+  sockets close abc-123-def-456
+  sockets show abc-123-def-456`
+  writelnStdout(process, terminal, usage)
+}
+
+function findConnectionById(kernel: Kernel, id: string): SocketConnection | undefined {
+  const fullMatch = kernel.sockets.get(id)
+  if (fullMatch) return fullMatch
+
+  const allConnections = kernel.sockets.all()
+  for (const [fullId, conn] of allConnections.entries()) {
+    if (fullId.startsWith(id) || fullId.substring(0, 8) === id) {
+      return conn
+    }
+  }
+  return undefined
+}
+
+async function listConnections(
+  process: Process | undefined,
+  kernel: Kernel,
+  terminal: Terminal
+): Promise<number> {
+  const allConnections = kernel.sockets.all()
+  const connections = Array.from(allConnections.values())
+  
+  if (connections.length === 0) {
+    await writelnStdout(process, terminal, 'No active connections.')
+    return 0
+  }
+
+  const data = connections.map((conn, index) => {
+    const id = conn.id.substring(0, 8)
+    const type = conn.type === 'websocket' ? chalk.cyan('WS') : chalk.magenta('WT')
+    const state = conn.state === 'open' ? chalk.green(conn.state) :
+                  conn.state === 'connecting' ? chalk.yellow(conn.state) :
+                  conn.state === 'closing' ? chalk.yellow(conn.state) :
+                  chalk.gray(conn.state)
+    const age = Math.floor((Date.now() - conn.created) / 1000)
+    const ageStr = age < 60 ? `${age}s` : age < 3600 ? `${Math.floor(age / 60)}m` : `${Math.floor(age / 3600)}h`
+    const url = conn.url.length > 50 ? conn.url.substring(0, 47) + '...' : conn.url
+    
+    return {
+      '#': `${index + 1}`,
+      ID: chalk.bold(id),
+      TYPE: type,
+      STATE: state,
+      AGE: chalk.gray(ageStr),
+      URL: url
+    }
+  })
+
+  const table = columnify(data, {
+    columns: ['#', 'ID', 'TYPE', 'STATE', 'AGE', 'URL'],
+    columnSplitter: '  ',
+    config: {
+      '#': { maxWidth: 4 },
+      ID: { maxWidth: 10 },
+      TYPE: { maxWidth: 4 },
+      STATE: { maxWidth: 10 },
+      AGE: { maxWidth: 4 }
+    }
+  })
+
+  await writelnStdout(process, terminal, table)
+
+  return 0
+}
+
+async function showConnection(
+  process: Process | undefined,
+  kernel: Kernel,
+  terminal: Terminal,
+  id: string
+): Promise<number> {
+  const connection = findConnectionById(kernel, id)
+  
+  if (!connection) {
+    await writelnStderr(process, terminal, `sockets: connection not found: ${id}`)
+    return 1
+  }
+
+  const age = Math.floor((Date.now() - connection.created) / 1000)
+  const ageSeconds = age
+  const ageMinutes = Math.floor(age / 60)
+  const ageHours = Math.floor(age / 3600)
+  const ageStr = age < 60 ? `${ageSeconds} seconds` :
+                 age < 3600 ? `${ageMinutes} minutes, ${ageSeconds % 60} seconds` :
+                 `${ageHours} hours, ${Math.floor((age % 3600) / 60)} minutes`
+
+  writelnStdout(process, terminal, chalk.bold('Connection Details'))
+  writelnStdout(process, terminal, chalk.gray('─'.repeat(40)))
+  writelnStdout(process, terminal, `ID:        ${chalk.bold(connection.id)}`)
+  writelnStdout(process, terminal, `Type:      ${connection.type === 'websocket' ? chalk.cyan('WebSocket') : chalk.magenta('WebTransport')}`)
+  writelnStdout(process, terminal, `State:     ${connection.state === 'open' ? chalk.green(connection.state) :
+                                            connection.state === 'connecting' ? chalk.yellow(connection.state) :
+                                            connection.state === 'closing' ? chalk.yellow(connection.state) :
+                                            chalk.gray(connection.state)}`)
+  writelnStdout(process, terminal, `URL:       ${connection.url}`)
+  writelnStdout(process, terminal, `Created:   ${new Date(connection.created).toISOString()}`)
+  writelnStdout(process, terminal, `Age:       ${ageStr}`)
+
+  if (connection.type === 'websocket') {
+    const ws = connection.socket
+    writelnStdout(process, terminal, `Protocol:  ${ws.protocol || '(none)'}`)
+    writelnStdout(process, terminal, `Extensions: ${ws.extensions || '(none)'}`)
+    writelnStdout(process, terminal, `BinaryType: ${ws.binaryType}`)
+    writelnStdout(process, terminal, `ReadyState: ${ws.readyState} (${connection.state})`)
+  } else {
+    writelnStdout(process, terminal, `State:     ${connection.state}`)
+  }
+
+  return 0
+}
+
+async function createConnection(
+  process: Process | undefined,
+  kernel: Kernel,
+  terminal: Terminal,
+  url: string,
+  type?: string,
+  protocols?: string
+): Promise<number> {
+  try {
+    let connection: SocketConnection
+
+    if (type === 'webtransport' || (!type && url.startsWith('https://'))) {
+      if (!('WebTransport' in globalThis)) {
+        await writelnStderr(process, terminal, 'sockets: WebTransport is not supported in this browser')
+        return 1
+      }
+      connection = await kernel.sockets.createWebTransport(url)
+      await writelnStdout(process, terminal, `Created WebTransport connection: ${chalk.bold(connection.id.substring(0, 8))}`)
+    } else if (type === 'websocket' || url.startsWith('ws://') || url.startsWith('wss://')) {
+      const options = protocols ? { protocols: protocols.split(',') } : undefined
+      connection = await kernel.sockets.createWebSocket(url, options)
+      await writelnStdout(process, terminal, `Created WebSocket connection: ${chalk.bold(connection.id.substring(0, 8))}`)
+    } else {
+      await writelnStderr(process, terminal, 'sockets: unable to determine connection type. Use -t to specify type or use a URL with ws://, wss://, or https:// scheme')
+      return 1
+    }
+
+    await writelnStdout(process, terminal, `URL: ${connection.url}`)
+    await writelnStdout(process, terminal, `State: ${connection.state === 'open' ? chalk.green(connection.state) : chalk.yellow(connection.state)}`)
+    
+    return 0
+  } catch (error) {
+    await writelnStderr(process, terminal, `sockets: failed to create connection: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    return 1
+  }
+}
+
+async function closeConnection(
+  process: Process | undefined,
+  kernel: Kernel,
+  terminal: Terminal,
+  id: string
+): Promise<number> {
+  const connection = findConnectionById(kernel, id)
+  
+  if (!connection) {
+    await writelnStderr(process, terminal, `sockets: connection not found: ${id}`)
+    return 1
+  }
+
+  try {
+    await kernel.sockets.close(connection.id)
+    await writelnStdout(process, terminal, `Closed connection: ${chalk.bold(connection.id.substring(0, 8))}`)
+    return 0
+  } catch (error) {
+    await writelnStderr(process, terminal, `sockets: failed to close connection: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    return 1
+  }
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'sockets',
+    description: 'Manage socket connections (WebSocket and WebTransport)',
+    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
+      }
+
+      if (argv.length === 0 || argv[0] === 'list' || argv[0] === 'ls') {
+        return await listConnections(process, kernel, terminal)
+      }
+
+      const command = argv[0]
+      let type: string | undefined
+      let protocols: string | undefined
+
+      for (let i = 1; i < argv.length; i++) {
+        const arg = argv[i]
+        if (arg === '-t' || arg === '--type') {
+          if (i + 1 < argv.length) {
+            i++
+            type = argv[i]
+          } else {
+            await writelnStderr(process, terminal, 'sockets: --type requires a value')
+            return 1
+          }
+        } else if (arg === '-p' || arg === '--protocols') {
+          if (i + 1 < argv.length) {
+            i++
+            protocols = argv[i]
+          } else {
+            await writelnStderr(process, terminal, 'sockets: --protocols requires a value')
+            return 1
+          }
+        }
+      }
+
+      if (command === 'create' || command === 'c') {
+        if (argv.length < 2 || !argv[1] || argv[1].startsWith('-')) {
+          await writelnStderr(process, terminal, 'sockets: create requires a URL')
+          await writelnStderr(process, terminal, 'Try "sockets --help" for more information.')
+          return 1
+        }
+        const url = argv[1]
+        return await createConnection(process, kernel, terminal, url, type, protocols)
+      }
+
+      if (command === 'close' || command === 'd') {
+        if (argv.length < 2 || !argv[1] || argv[1].startsWith('-')) {
+          await writelnStderr(process, terminal, 'sockets: close requires a connection ID')
+          await writelnStderr(process, terminal, 'Try "sockets --help" for more information.')
+          return 1
+        }
+        const id = argv[1]
+        return await closeConnection(process, kernel, terminal, id)
+      }
+
+      if (command === 'show' || command === 's') {
+        if (argv.length < 2 || !argv[1] || argv[1].startsWith('-')) {
+          await writelnStderr(process, terminal, 'sockets: show requires a connection ID')
+          await writelnStderr(process, terminal, 'Try "sockets --help" for more information.')
+          return 1
+        }
+        const id = argv[1]
+        return await showConnection(process, kernel, terminal, id)
+      }
+
+      await writelnStderr(process, terminal, `sockets: unknown command: ${command}`)
+      await writelnStderr(process, terminal, 'Try "sockets --help" for more information.')
+      return 1
+    }
+  })
+}