@ecmaos/coreutils 0.2.1 → 0.3.1

package/src/commands/mktemp.ts

@@ -0,0 +1,235 @@
+import path from 'path'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
+
+/**
+ * Generate random alphanumeric characters for template replacement
+ */
+function generateRandomChars(count: number): string {
+  const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+  let result = ''
+  const cryptoApi = globalThis.crypto
+  if (!cryptoApi) {
+    throw new Error('Crypto API not available')
+  }
+  const randomValues = cryptoApi.getRandomValues(new Uint8Array(count))
+  for (let i = 0; i < count; i++) {
+    const randomValue = randomValues[i]
+    if (randomValue !== undefined) {
+      result += chars[randomValue % chars.length]
+    }
+  }
+  return result
+}
+
+/**
+ * Replace X's in template with random characters
+ */
+function replaceTemplate(template: string): string {
+  const xCount = (template.match(/X/g) || []).length
+  if (xCount === 0) {
+    // If no X's, append random suffix
+    return template + '.' + generateRandomChars(6)
+  }
+  
+  let result = template
+  const randomChars = generateRandomChars(xCount)
+  let charIndex = 0
+  
+  for (let i = 0; i < template.length; i++) {
+    if (template[i] === 'X') {
+      result = result.substring(0, i) + randomChars[charIndex] + result.substring(i + 1)
+      charIndex++
+    }
+  }
+  
+  return result
+}
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: mktemp [OPTION]... [TEMPLATE]
+Create a temporary file or directory, safely, and print its name.
+
+  -d, --directory     create a directory, not a file
+  -q, --quiet        suppress error messages
+  -u, --dry-run      do not create anything; merely print a name (unsafe)
+  -p DIR, --tmpdir=DIR  interpret TEMPLATE relative to DIR; if DIR is not
+                        specified, use \$TMPDIR if set, else /tmp.  With
+                        this option, TEMPLATE must not be an absolute name;
+                        unlike with -t, TEMPLATE may contain slashes, but
+                        mktemp creates only the final component
+  -t                 interpret TEMPLATE relative to the directory specified by
+                        -p, or \$TMPDIR if -p is not given; if neither is
+                        specified, use /tmp [deprecated]
+  --help             display this help and exit
+
+The TEMPLATE must contain at least 3 consecutive 'X's in last component.
+If TEMPLATE is not specified, use tmp.XXXXXX, and --tmpdir implies -t.
+
+Examples:
+  mktemp                    create a temp file in /tmp
+  mktemp -d                 create a temp directory in /tmp
+  mktemp /tmp/file.XXXXXX   create a temp file with template
+  mktemp -d /tmp/dir.XXXXXX create a temp directory with template`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'mktemp',
+    description: 'Create a temporary file or directory',
+    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 createDirectory = false
+      let quiet = false
+      let dryRun = false
+      let tmpdir: string | undefined
+      let useTmpdir = false
+      let template: string | undefined
+
+      // Parse arguments
+      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 === '-d' || arg === '--directory') {
+          createDirectory = true
+        } else if (arg === '-q' || arg === '--quiet') {
+          quiet = true
+        } else if (arg === '-u' || arg === '--dry-run') {
+          dryRun = true
+        } else if (arg === '-t') {
+          useTmpdir = true
+        } else if (arg === '-p' || arg === '--tmpdir') {
+          useTmpdir = true
+          const dirArg = argv[i + 1]
+          if (dirArg && !dirArg.startsWith('-')) {
+            tmpdir = dirArg
+            i++ // Skip the next argument as it's the directory value
+          }
+        } else if (arg.startsWith('--tmpdir=')) {
+          useTmpdir = true
+          const dirValue = arg.split('=')[1]
+          if (dirValue) {
+            tmpdir = dirValue
+          }
+        } else if (!arg.startsWith('-')) {
+          // Positional argument - should be the template
+          if (!template) {
+            template = arg
+          } else {
+            if (!quiet) {
+              await writelnStderr(process, terminal, `mktemp: too many arguments`)
+            }
+            return 1
+          }
+        } else {
+          if (!quiet) {
+            await writelnStderr(process, terminal, `mktemp: invalid option -- '${arg.replace(/^-+/, '')}'`)
+            await writelnStderr(process, terminal, `Try 'mktemp --help' for more information.`)
+          }
+          return 1
+        }
+      }
+
+      // Determine the temp directory
+      let baseDir = '/tmp'
+      if (useTmpdir) {
+        if (tmpdir) {
+          baseDir = tmpdir
+        } else {
+          // Check TMPDIR environment variable
+          const envTmpdir = shell.env.get('TMPDIR')
+          if (envTmpdir) {
+            baseDir = envTmpdir
+          }
+        }
+      }
+
+      // Resolve base directory
+      const resolvedBaseDir = path.isAbsolute(baseDir) ? baseDir : path.resolve(shell.cwd, baseDir)
+
+      // Determine template
+      if (!template) {
+        template = 'tmp.XXXXXX'
+      }
+
+      // If template is absolute and useTmpdir is set, that's an error
+      if (useTmpdir && path.isAbsolute(template)) {
+        if (!quiet) {
+          await writelnStderr(process, terminal, `mktemp: with -p/--tmpdir, TEMPLATE must not be an absolute name`)
+        }
+        return 1
+      }
+
+      // Build the full path
+      let fullPath: string
+      if (path.isAbsolute(template)) {
+        fullPath = template
+      } else {
+        fullPath = path.join(resolvedBaseDir, template)
+      }
+
+      // Check that template has at least 3 X's in the last component
+      const basename = path.basename(fullPath)
+      const xCount = (basename.match(/X/g) || []).length
+      if (xCount < 3) {
+        if (!quiet) {
+          await writelnStderr(process, terminal, `mktemp: too few X's in template ${template}`)
+        }
+        return 1
+      }
+
+      // Replace template with random characters
+      const finalPath = replaceTemplate(fullPath)
+
+      // If dry-run, just print the name
+      if (dryRun) {
+        await writelnStdout(process, terminal, finalPath)
+        return 0
+      }
+
+      // Create the file or directory
+      try {
+        if (createDirectory) {
+          await shell.context.fs.promises.mkdir(finalPath, { recursive: true })
+        } else {
+          // Create parent directory if needed
+          const parentDir = path.dirname(finalPath)
+          try {
+            await shell.context.fs.promises.mkdir(parentDir, { recursive: true })
+          } catch {
+            // Parent might already exist, ignore
+          }
+          // Create empty file
+          await shell.context.fs.promises.writeFile(finalPath, '')
+        }
+        
+        // Print the created path
+        await writelnStdout(process, terminal, finalPath)
+        return 0
+      } catch (error) {
+        if (!quiet) {
+          const errorMessage = error instanceof Error ? error.message : String(error)
+          await writelnStderr(process, terminal, `mktemp: ${errorMessage}`)
+        }
+        return 1
+      }
+    }
+  })
+}

package/src/commands/nc.ts

@@ -1,7 +1,7 @@
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalEvents } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
-import { writelnStderr, writelnStdout } from '../shared/helpers.js'
+import { writelnStderr } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: nc [OPTIONS] <host> [port]
@@ -19,7 +19,7 @@ Examples:
   nc -p 443 echo.websocket.org
   nc -u wss://echo.websocket.org
   nc -u https://example.com:443`
-  writelnStdout(process, terminal, usage)
+  writelnStderr(process, terminal, usage)
 }
 
 interface ConnectionOptions {

package/src/commands/open.ts

@@ -0,0 +1,84 @@
+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: open [FILE|URL]
+Open a file or URL.
+
+  --help                   display this help and exit
+
+Examples:
+  open file.txt                    open a file in the current directory
+  open /path/to/file.txt           open a file by absolute path
+  open sample-1/sample-5 (1).jpg   open a file with spaces in the name
+  open https://example.com         open a URL in a new tab`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'open',
+    description: 'Open a file or URL',
+    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) {
+        await writelnStderr(process, terminal, `open: missing file or URL argument`)
+        await writelnStderr(process, terminal, `Try 'open --help' for more information.`)
+        return 1
+      }
+
+      const filePath = argv.join(' ')
+
+      if (!filePath) {
+        await writelnStderr(process, terminal, `open: missing file or URL argument`)
+        return 1
+      }
+
+      // Check if it's a URL by looking for URL schemes
+      const urlPattern = /^[a-zA-Z][a-zA-Z\d+\-.]*:/
+      const isURL = urlPattern.test(filePath)
+
+      if (isURL) {
+        window.open(filePath, '_blank')
+        return 0
+      }
+
+      // Treat as file path - resolve relative to current working directory
+      const fullPath = path.resolve(shell.cwd, filePath)
+
+      try {
+        if (!(await shell.context.fs.promises.exists(fullPath))) {
+          await writelnStderr(process, terminal, chalk.red(`open: file not found: ${fullPath}`))
+          return 1
+        }
+
+        const file = await shell.context.fs.promises.readFile(fullPath)
+        const blob = new Blob([new Uint8Array(file)], { type: 'application/octet-stream' })
+        const url = window.URL.createObjectURL(blob)
+        const a = document.createElement('a')
+        a.href = url
+        a.download = path.basename(fullPath)
+        a.click()
+        window.URL.revokeObjectURL(url)
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, chalk.red(`open: ${error instanceof Error ? error.message : 'Unknown error'}`))
+        return 1
+      }
+    }
+  })
+}

package/src/commands/passkey.ts

@@ -13,7 +13,7 @@ Subcommands:
   remove-all                  Remove all passkeys
 
   --help  display this help and exit`
-  writelnStdout(process, terminal, usage)
+  writelnStderr(process, terminal, usage)
 }
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
@@ -186,7 +186,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           case 'remove': {
             if (!id) {
               await writelnStderr(process, terminal, chalk.red('Error: --id is required for remove command'))
-              await writelnStdout(process, terminal, 'Usage: passkey remove --id <id>')
+              await writelnStderr(process, terminal, 'Usage: passkey remove --id <id>')
               return 1
             }
 
@@ -223,7 +223,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
           default:
             await writelnStderr(process, terminal, chalk.red(`Error: Unknown subcommand: ${subcommand}`))
-            await writelnStdout(process, terminal, 'Run "passkey help" for usage information')
+            await writelnStderr(process, terminal, 'Run "passkey help" for usage information')
             return 1
         }
       } catch (error) {

package/src/commands/play.ts

@@ -0,0 +1,249 @@
+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, writelnStdout } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: play [OPTIONS] [FILE...]
+Play an audio file.
+
+  --help                   display this help and exit
+  --no-autoplay            don't start playing automatically
+  --loop                   loop the audio
+  --muted                  start muted
+  --volume <0-100>         set volume (0-100, default: 100)
+  --quiet                  play without opening a window (background playback)
+
+Examples:
+  play song.mp3                    play an audio file
+  play --loop music.mp3           play audio in a loop
+  play --no-autoplay audio.mp3    load audio without auto-playing
+  play --volume 50 track.mp3      play at 50% volume
+  play --quiet background.mp3      play audio in background
+  play song1.mp3 song2.mp3        play multiple audio files`
+  writelnStderr(process, terminal, usage)
+}
+
+function getMimeType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase()
+  const mimeTypes: Record<string, string> = {
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.oga': 'audio/ogg',
+    '.opus': 'audio/opus',
+    '.m4a': 'audio/mp4',
+    '.aac': 'audio/aac',
+    '.flac': 'audio/flac',
+    '.webm': 'audio/webm',
+    '.wma': 'audio/x-ms-wma',
+    '.aiff': 'audio/aiff',
+    '.aif': 'audio/aiff',
+    '.3gp': 'audio/3gpp',
+    '.amr': 'audio/amr'
+  }
+  return mimeTypes[ext] || 'audio/mpeg'
+}
+
+async function loadAudioMetadata(audioElement: HTMLAudioElement): Promise<{ duration: number }> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Timeout loading audio metadata'))
+    }, 10000)
+
+    audioElement.onloadedmetadata = () => {
+      clearTimeout(timeout)
+      resolve({
+        duration: audioElement.duration
+      })
+    }
+
+    audioElement.onerror = () => {
+      clearTimeout(timeout)
+      reject(new Error('Failed to load audio metadata'))
+    }
+  })
+}
+
+function formatDuration(seconds: number): string {
+  if (!isFinite(seconds) || isNaN(seconds)) return '?:??'
+  const hours = Math.floor(seconds / 3600)
+  const minutes = Math.floor((seconds % 3600) / 60)
+  const secs = Math.floor(seconds % 60)
+  
+  if (hours > 0) {
+    return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
+  }
+  return `${minutes}:${secs.toString().padStart(2, '0')}`
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'play',
+    description: 'Play an audio file',
+    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
+      }
+
+      // Parse options
+      const options: {
+        autoplay: boolean
+        loop: boolean
+        muted: boolean
+        volume: number
+        quiet: boolean
+      } = {
+        autoplay: true,
+        loop: false,
+        muted: false,
+        volume: 100,
+        quiet: false
+      }
+
+      const files: string[] = []
+
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (arg === '--no-autoplay') {
+          options.autoplay = false
+        } else if (arg === '--loop') {
+          options.loop = true
+        } else if (arg === '--muted') {
+          options.muted = true
+        } else if (arg === '--quiet') {
+          options.quiet = true
+        } else if (arg === '--volume' && i + 1 < argv.length) {
+          const volumeArg = argv[i + 1]
+          if (!volumeArg) {
+            await writelnStderr(process, terminal, chalk.red(`play: missing volume value`))
+            return 1
+          }
+          const volume = parseFloat(volumeArg)
+          if (isNaN(volume) || volume < 0 || volume > 100) {
+            await writelnStderr(process, terminal, chalk.red(`play: invalid volume: ${volumeArg} (must be 0-100)`))
+            return 1
+          }
+          options.volume = volume
+          i++ // Skip next argument
+        } else if (arg && !arg.startsWith('--')) {
+          files.push(arg)
+        }
+      }
+
+      if (files.length === 0) {
+        await writelnStderr(process, terminal, `play: missing file argument`)
+        await writelnStderr(process, terminal, `Try 'play --help' for more information.`)
+        return 1
+      }
+
+      // Process each audio file
+      for (const file of files) {
+        const fullPath = path.resolve(shell.cwd, file)
+
+        try {
+          // Check if file exists
+          if (!(await shell.context.fs.promises.exists(fullPath))) {
+            await writelnStderr(process, terminal, chalk.red(`play: file not found: ${fullPath}`))
+            continue
+          }
+
+          // Read file
+          await writelnStdout(process, terminal, chalk.blue(`Loading audio: ${file}...`))
+          const fileData = await shell.context.fs.promises.readFile(fullPath)
+          const mimeType = getMimeType(fullPath)
+          const blob = new Blob([new Uint8Array(fileData)], { type: mimeType })
+          const url = URL.createObjectURL(blob)
+
+          // Load audio metadata
+          const audioElement = document.createElement('audio')
+          audioElement.src = url
+          audioElement.preload = 'metadata'
+
+          let duration = 0
+
+          try {
+            const metadata = await loadAudioMetadata(audioElement)
+            duration = metadata.duration
+          } catch (error) {
+            await writelnStderr(process, terminal, chalk.yellow(`play: warning: could not load metadata for ${file}`))
+          }
+
+          // Set audio properties
+          audioElement.volume = options.volume / 100
+          if (options.autoplay) audioElement.autoplay = true
+          if (options.loop) audioElement.loop = true
+          if (options.muted) audioElement.muted = true
+
+          if (options.quiet) {
+            // Background playback - no window
+            audioElement.play().catch((error) => {
+              // Autoplay may be blocked by browser, but that's okay for quiet mode
+              console.warn('Autoplay blocked:', error)
+            })
+            
+            if (duration > 0) {
+              const durationStr = formatDuration(duration)
+              await writelnStdout(process, terminal, chalk.green(`Playing in background: ${file} (${durationStr})`))
+            } else {
+              await writelnStdout(process, terminal, chalk.green(`Playing in background: ${file}`))
+            }
+          } else {
+            // Create a simple audio player window
+            const windowTitle = files.length > 1
+              ? `${path.basename(file)} (${files.indexOf(file) + 1}/${files.length})`
+              : path.basename(file)
+
+            // Create audio player HTML with controls
+            const audioId = `audio-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+            const audioHtml = `
+              <div style="width:100%;height:100%;display:flex;flex-direction:column;align-items:center;justify-content:center;background:#1e1e1e;color:#fff;font-family:monospace;padding:20px;box-sizing:border-box;">
+                <div style="font-size:18px;margin-bottom:20px;text-align:center;word-break:break-word;">${path.basename(file)}</div>
+                <audio id="${audioId}" src="${url}" ${options.autoplay ? 'autoplay' : ''} ${options.loop ? 'loop' : ''} ${options.muted ? 'muted' : ''} controls style="width:100%;max-width:600px;"></audio>
+              </div>
+              <script>
+                (function() {
+                  const audio = document.getElementById('${audioId}');
+                  if (audio) {
+                    audio.volume = ${options.volume / 100};
+                    audio.addEventListener('play', () => console.log('Playing: ${file}'));
+                    audio.addEventListener('ended', () => console.log('Finished: ${file}'));
+                  }
+                })();
+              </script>
+            `
+
+            kernel.windows.create({
+              title: windowTitle,
+              html: audioHtml,
+              width: 500,
+              height: 200,
+              max: false
+            })
+
+            if (duration > 0) {
+              const durationStr = formatDuration(duration)
+              await writelnStdout(process, terminal, chalk.green(`Playing: ${file} (${durationStr})`))
+            } else {
+              await writelnStdout(process, terminal, chalk.green(`Playing: ${file}`))
+            }
+          }
+        } catch (error) {
+          await writelnStderr(process, terminal, chalk.red(`play: error playing ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`))
+          return 1
+        }
+      }
+
+      return 0
+    }
+  })
+}

package/src/commands/pwd.ts

@@ -1,13 +1,13 @@
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
-import { writelnStdout } from '../shared/helpers.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: pwd
 Print the name of the current working directory.
 
   --help  display this help and exit`
-  writelnStdout(process, terminal, usage)
+  writelnStderr(process, terminal, usage)
 }
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {