@ecmaos/coreutils 0.2.1 → 0.3.1

package/src/commands/fetch.ts

@@ -0,0 +1,205 @@
+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: fetch [OPTION]... URL
+Fetch a resource from the network.
+
+  -o, --output=FILE        write output to FILE instead of stdout
+  -X, --method=METHOD      HTTP method to use (default: GET)
+  -d, --data=DATA          request body data to send
+  -H, --header=HEADER      add custom HTTP header (format: "Name: Value")
+  --help                   display this help and exit
+
+Examples:
+  fetch https://example.com              fetch and output to stdout
+  fetch -o file.txt https://example.com  fetch and save to file.txt
+  fetch -X POST -d "data" https://api.example.com  POST request with body`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'fetch',
+    description: 'Fetch a resource from the network',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (!process) return 1
+
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      let url: string | undefined
+      let outputFile: string | undefined
+      let method = 'GET'
+      let body: string | undefined
+      const headers: Record<string, string> = {}
+
+      // Parse arguments
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (arg === undefined) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-o' || arg === '--output') {
+          const fileArg = argv[i + 1]
+          if (!fileArg) {
+            await writelnStderr(process, terminal, `fetch: option requires an argument -- '${arg === '-o' ? 'o' : 'output'}'`)
+            return 1
+          }
+          outputFile = fileArg
+          i++ // Skip the next argument as it's the file value
+        } else if (arg.startsWith('--output=')) {
+          const outputValue = arg.split('=')[1]
+          if (!outputValue) {
+            await writelnStderr(process, terminal, `fetch: option requires an argument -- 'output'`)
+            return 1
+          }
+          outputFile = outputValue
+        } else if (arg === '-X' || arg === '--method') {
+          const methodArg = argv[i + 1]
+          if (!methodArg) {
+            await writelnStderr(process, terminal, `fetch: option requires an argument -- '${arg === '-X' ? 'X' : 'method'}'`)
+            return 1
+          }
+          method = methodArg.toUpperCase()
+          i++ // Skip the next argument as it's the method value
+        } else if (arg.startsWith('--method=')) {
+          const methodValue = arg.split('=')[1]
+          if (!methodValue) {
+            await writelnStderr(process, terminal, `fetch: option requires an argument -- 'method'`)
+            return 1
+          }
+          method = methodValue.toUpperCase()
+        } else if (arg === '-d' || arg === '--data') {
+          const dataArg = argv[i + 1]
+          if (!dataArg) {
+            await writelnStderr(process, terminal, `fetch: option requires an argument -- '${arg === '-d' ? 'd' : 'data'}'`)
+            return 1
+          }
+          body = dataArg
+          i++ // Skip the next argument as it's the data value
+        } else if (arg.startsWith('--data=')) {
+          const dataValue = arg.split('=')[1]
+          if (!dataValue) {
+            await writelnStderr(process, terminal, `fetch: option requires an argument -- 'data'`)
+            return 1
+          }
+          body = dataValue
+        } else if (arg === '-H' || arg === '--header') {
+          const headerArg = argv[i + 1]
+          if (!headerArg) {
+            await writelnStderr(process, terminal, `fetch: option requires an argument -- '${arg === '-H' ? 'H' : 'header'}'`)
+            return 1
+          }
+          const [name, ...valueParts] = headerArg.split(':')
+          if (!name || valueParts.length === 0) {
+            await writelnStderr(process, terminal, `fetch: invalid header format. Expected "Name: Value"`)
+            return 1
+          }
+          headers[name.trim()] = valueParts.join(':').trim()
+          i++ // Skip the next argument as it's the header value
+        } else if (arg.startsWith('--header=')) {
+          const headerValue = arg.split('=')[1]
+          if (!headerValue) {
+            await writelnStderr(process, terminal, `fetch: option requires an argument -- 'header'`)
+            return 1
+          }
+          const [name, ...valueParts] = headerValue.split(':')
+          if (!name || valueParts.length === 0) {
+            await writelnStderr(process, terminal, `fetch: invalid header format. Expected "Name: Value"`)
+            return 1
+          }
+          headers[name.trim()] = valueParts.join(':').trim()
+        } else if (!arg.startsWith('-')) {
+          // Positional argument - should be the URL
+          if (!url) {
+            url = arg
+          } else {
+            await writelnStderr(process, terminal, `fetch: unexpected argument: ${arg}`)
+            return 1
+          }
+        } else {
+          await writelnStderr(process, terminal, `fetch: invalid option -- '${arg.replace(/^-+/, '')}'`)
+          await writelnStderr(process, terminal, `Try 'fetch --help' for more information.`)
+          return 1
+        }
+      }
+
+      if (!url) {
+        await writelnStderr(process, terminal, `fetch: URL is required`)
+        await writelnStderr(process, terminal, `Try 'fetch --help' for more information.`)
+        return 1
+      }
+
+      try {
+        const fetchOptions: RequestInit = { method }
+        if (body) fetchOptions.body = body
+        if (Object.keys(headers).length > 0) fetchOptions.headers = headers
+        
+        const response = await globalThis.fetch(url, fetchOptions)
+        
+        if (!response.ok) {
+          await writelnStderr(process, terminal, chalk.red(`fetch: HTTP error! status: ${response.status} ${response.statusText}`))
+          return 1
+        }
+
+        const reader = response.body?.getReader()
+        if (!reader) {
+          await writelnStderr(process, terminal, chalk.red(`fetch: No response body`))
+          return 1
+        }
+
+        let writer: WritableStreamDefaultWriter<Uint8Array> | { write: (chunk: Uint8Array) => Promise<void>, releaseLock: () => Promise<void> } | undefined
+
+        if (outputFile) {
+          // Write to file
+          const fullPath = path.resolve(shell.cwd, outputFile)
+          const fileHandle = await shell.context.fs.promises.open(fullPath, 'w')
+          writer = {
+            write: async (chunk: Uint8Array) => {
+              await fileHandle.write(chunk)
+            },
+            releaseLock: async () => {
+              await fileHandle.close()
+            }
+          }
+        } else {
+          // Write to stdout
+          if (!process.stdout) {
+            await writelnStderr(process, terminal, chalk.red(`fetch: No stdout available`))
+            return 1
+          }
+          writer = process.stdout.getWriter()
+        }
+
+        try {
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+            if (value && value.length > 0) await writer.write(value)
+          }
+        } finally {
+          reader.releaseLock()
+          if (writer && 'releaseLock' in writer) await writer.releaseLock()
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, chalk.red(`fetch: ${error instanceof Error ? error.message : 'Unknown error'}`))
+        return 1
+      }
+    }
+  })
+}

package/src/commands/format.ts

@@ -0,0 +1,204 @@
+import chalk from 'chalk'
+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: format [OPTION]...
+Delete all IndexedDB and localStorage data.
+
+  -i, --indexeddb        Delete only IndexedDB databases
+  -l, --localstorage     Delete only localStorage
+  -k, --keep <name>      Preserve specific IndexedDB database(s) (can be used multiple times)
+  --help                 Display this help and exit
+
+By default, deletes all IndexedDB databases and localStorage.
+Requires root privileges and interactive confirmation.`
+  writelnStderr(process, terminal, usage)
+}
+
+async function emptyIndexedDBDatabases(
+  keepDatabases: string[],
+  _kernel: Kernel,
+  process: Process | undefined,
+  terminal: Terminal
+): Promise<boolean> {
+  try {
+    if (!globalThis.indexedDB) {
+      await writelnStderr(process, terminal, chalk.yellow('format: IndexedDB is not available'))
+      return false
+    }
+
+    await writelnStdout(process, terminal, chalk.yellow('format: Emptying filesystem...'))
+
+    let databases: Array<{ name: string; version: number }> = []
+
+    if (typeof indexedDB.databases === 'function') {
+      const dbList = await indexedDB.databases()
+      databases = dbList
+        .filter((db): db is { name: string; version: number } => typeof db.name === 'string')
+        .map(db => ({ name: db.name, version: db.version }))
+    } else {
+      await writelnStdout(process, terminal, chalk.yellow('format: indexedDB.databases() not supported, assuming filesystem will be emptied on reboot'))
+      return true
+    }
+
+    const databasesToEmpty = databases.filter(db => !keepDatabases.includes(db.name))
+
+    if (databasesToEmpty.length === 0) {
+      await writelnStdout(process, terminal, chalk.green('format: All databases are preserved, nothing to empty'))
+      return true
+    }
+
+    if (keepDatabases.length > 0) {
+      const preserved = databases.filter(db => keepDatabases.includes(db.name))
+      if (preserved.length > 0) {
+        await writelnStdout(process, terminal, chalk.cyan(`format: Preserving databases: ${preserved.map(db => db.name).join(', ')}`))
+      }
+    }
+
+    await writelnStdout(process, terminal, chalk.green(`format: Will empty ${databasesToEmpty.length} IndexedDB database(s) on reboot`))
+    return true
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    await writelnStderr(process, terminal, chalk.red(`format: Error preparing IndexedDB databases: ${errorMessage}`))
+    return false
+  }
+}
+
+async function deleteLocalStorage(
+  process: Process | undefined,
+  terminal: Terminal,
+  storage: Storage
+): Promise<boolean> {
+  try {
+    const keysCount = storage.length
+    if (keysCount === 0) {
+      await writelnStdout(process, terminal, chalk.green('format: localStorage is already empty'))
+      return true
+    }
+
+    storage.clear()
+    await writelnStdout(process, terminal, chalk.green(`format: Successfully cleared localStorage (${keysCount} item(s))`))
+    return true
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    await writelnStderr(process, terminal, chalk.red(`format: Error clearing localStorage: ${errorMessage}`))
+    return false
+  }
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'format',
+    description: 'Delete all IndexedDB and localStorage data',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      if (shell.credentials.suid !== 0) {
+        await writelnStderr(process, terminal, chalk.red('format: permission denied (requires root)'))
+        return 1
+      }
+
+      let onlyIndexedDB = false
+      let onlyLocalStorage = false
+      const keepDatabases: string[] = []
+
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (!arg || typeof arg !== 'string') continue
+
+        if (arg === '-i' || arg === '--indexeddb') {
+          onlyIndexedDB = true
+        } else if (arg === '-l' || arg === '--localstorage') {
+          onlyLocalStorage = true
+        } else if (arg === '-k' || arg === '--keep') {
+          if (i + 1 < argv.length) {
+            const dbName = argv[++i]
+            if (dbName && !dbName.startsWith('-')) {
+              keepDatabases.push(dbName)
+            } else {
+              await writelnStderr(process, terminal, chalk.red('format: --keep requires a database name'))
+              return 1
+            }
+          } else {
+            await writelnStderr(process, terminal, chalk.red('format: --keep requires a database name'))
+            return 1
+          }
+        } else if (arg.startsWith('-')) {
+          await writelnStderr(process, terminal, chalk.red(`format: invalid option -- '${arg.replace(/^-+/, '')}'`))
+          await writelnStdout(process, terminal, "Try 'format --help' for more information.")
+          return 1
+        }
+      }
+
+      if (onlyIndexedDB && onlyLocalStorage) {
+        await writelnStderr(process, terminal, chalk.red('format: cannot specify both --indexeddb and --localstorage'))
+        return 1
+      }
+
+      const deleteIndexedDB = !onlyLocalStorage
+      const deleteLocal = !onlyIndexedDB
+
+      let actionDescription = 'This will delete '
+      if (deleteIndexedDB && deleteLocal) {
+        actionDescription += 'ALL IndexedDB databases and localStorage data'
+      } else if (deleteIndexedDB) {
+        actionDescription += 'ALL IndexedDB databases'
+      } else {
+        actionDescription += 'ALL localStorage data'
+      }
+
+      if (keepDatabases.length > 0) {
+        actionDescription += ` (preserving: ${keepDatabases.join(', ')})`
+      }
+
+      actionDescription += '. This action cannot be undone!'
+
+      await writelnStderr(process, terminal, chalk.red.bold(`⚠️  WARNING: ${actionDescription}`))
+      await writelnStdout(process, terminal, chalk.yellow('Type "yes" to continue, or anything else to cancel: '))
+
+      const confirmation = await terminal.readline()
+      if (confirmation.trim().toLowerCase() !== 'yes') {
+        await writelnStdout(process, terminal, chalk.yellow('format: Operation cancelled'))
+        return 0
+      }
+
+      if (kernel.storage.db) {
+        kernel.storage.db.close()
+      }
+
+      let success = true
+
+      if (deleteIndexedDB) {
+        const indexedDBSuccess = await emptyIndexedDBDatabases(keepDatabases, kernel, process, terminal)
+        success = success && indexedDBSuccess
+      }
+
+      if (deleteLocal) {
+        const localStorageSuccess = await deleteLocalStorage(process, terminal, kernel.storage.local)
+        success = success && localStorageSuccess
+      }
+
+      if (success) {
+        await writelnStdout(process, terminal, chalk.green.bold('format: Format operation completed successfully'))
+        await writelnStdout(process, terminal, chalk.yellow('format: Rebooting system to complete format...'))
+        setTimeout(() => {
+          kernel.reboot()
+        }, 500)
+        return 0
+      } else {
+        await writelnStderr(process, terminal, chalk.red.bold('format: Format operation completed with errors'))
+        return 1
+      }
+    }
+  })
+}

package/src/commands/hash.ts

@@ -0,0 +1,215 @@
+import path from 'path'
+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'
+
+type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512'
+
+const SUPPORTED_ALGORITHMS: Record<string, HashAlgorithm> = {
+  'sha1': 'SHA-1',
+  'sha-1': 'SHA-1',
+  'sha256': 'SHA-256',
+  'sha-256': 'SHA-256',
+  'sha384': 'SHA-384',
+  'sha-384': 'SHA-384',
+  'sha512': 'SHA-512',
+  'sha-512': 'SHA-512'
+}
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: hash [OPTION]... [FILE]...
+Compute and display hash values for files or standard input.
+
+  -a, --algorithm=ALGORITHM  hash algorithm to use (sha1, sha256, sha384, sha512)
+                              default: sha256
+  --help                      display this help and exit
+
+Supported algorithms:
+  sha1, sha-1                 SHA-1 (160 bits)
+  sha256, sha-256            SHA-256 (256 bits) [default]
+  sha384, sha-384            SHA-384 (384 bits)
+  sha512, sha-512            SHA-512 (512 bits)
+
+Examples:
+  hash file.txt              compute SHA-256 hash of file.txt
+  hash -a sha512 file.txt    compute SHA-512 hash of file.txt
+  echo "hello" | hash        compute SHA-256 hash of stdin`
+  writelnStderr(process, terminal, usage)
+}
+
+async function hashData(data: Uint8Array, algorithm: HashAlgorithm): Promise<string> {
+  // Create a new Uint8Array with a proper ArrayBuffer to ensure compatibility
+  const dataCopy = new Uint8Array(data)
+  const hashBuffer = await crypto.subtle.digest(algorithm, dataCopy)
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
+}
+
+async function readStreamToUint8Array(reader: ReadableStreamDefaultReader<Uint8Array>): Promise<Uint8Array> {
+  const chunks: Uint8Array[] = []
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      if (value) {
+        chunks.push(value)
+      }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+
+  // Calculate total length
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
+  
+  // Concatenate all chunks into a single Uint8Array
+  const result = new Uint8Array(totalLength)
+  let offset = 0
+  for (const chunk of chunks) {
+    result.set(chunk, offset)
+    offset += chunk.length
+  }
+  
+  return result
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'hash',
+    description: 'Compute and display hash values for files or standard input',
+    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 algorithm: HashAlgorithm = 'SHA-256'
+      const files: string[] = []
+
+      // Parse arguments
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (arg === undefined) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-a' || arg === '--algorithm') {
+          const algoArg = argv[i + 1]
+          if (!algoArg) {
+            await writelnStderr(process, terminal, `hash: option requires an argument -- '${arg === '-a' ? 'a' : 'algorithm'}'`)
+            return 1
+          }
+          const algoLower = algoArg.toLowerCase()
+          const selectedAlgorithm = SUPPORTED_ALGORITHMS[algoLower]
+          if (!selectedAlgorithm) {
+            await writelnStderr(process, terminal, `hash: unsupported algorithm '${algoArg}'\nSupported algorithms: ${Object.keys(SUPPORTED_ALGORITHMS).join(', ')}`)
+            return 1
+          }
+          algorithm = selectedAlgorithm
+          i++ // Skip the next argument as it's the algorithm value
+        } else if (arg.startsWith('--algorithm=')) {
+          const algoArg = arg.split('=')[1]
+          if (!algoArg) {
+            await writelnStderr(process, terminal, `hash: option requires an argument -- 'algorithm'`)
+            return 1
+          }
+          const algoLower = algoArg.toLowerCase()
+          const selectedAlgorithm = SUPPORTED_ALGORITHMS[algoLower]
+          if (!selectedAlgorithm) {
+            await writelnStderr(process, terminal, `hash: unsupported algorithm '${algoArg}'\nSupported algorithms: ${Object.keys(SUPPORTED_ALGORITHMS).join(', ')}`)
+            return 1
+          }
+          algorithm = selectedAlgorithm
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        } else {
+          await writelnStderr(process, terminal, `hash: invalid option -- '${arg.replace(/^-+/, '')}'`)
+          await writelnStderr(process, terminal, `Try 'hash --help' for more information.`)
+          return 1
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        // If no files specified, read from stdin
+        if (files.length === 0) {
+          if (!process.stdin) {
+            await writelnStderr(process, terminal, 'hash: no input specified')
+            return 1
+          }
+
+          const reader = process.stdin.getReader()
+          const data = await readStreamToUint8Array(reader)
+          const hash = await hashData(data, algorithm)
+          await writer.write(new TextEncoder().encode(hash + '\n'))
+          return 0
+        }
+
+        // Process each file
+        let hasError = false
+        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, `hash: ${file}: cannot hash device files`)
+              hasError = true
+              continue
+            }
+
+            const handle = await shell.context.fs.promises.open(fullPath, 'r')
+            const stat = await shell.context.fs.promises.stat(fullPath)
+
+            const chunks: Uint8Array[] = []
+            let bytesRead = 0
+            const chunkSize = 64 * 1024 // 64KB chunks for better performance
+
+            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)
+              chunks.push(data.subarray(0, readSize))
+              bytesRead += readSize
+            }
+
+            // Concatenate all chunks
+            const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
+            const fileData = new Uint8Array(totalLength)
+            let offset = 0
+            for (const chunk of chunks) {
+              fileData.set(chunk, offset)
+              offset += chunk.length
+            }
+
+            const hash = await hashData(fileData, algorithm)
+            await writer.write(new TextEncoder().encode(`${hash}  ${file}\n`))
+          } catch (error) {
+            await writelnStderr(process, terminal, `hash: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            hasError = true
+          } finally {
+            kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+          }
+        }
+
+        return hasError ? 1 : 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/head.ts

@@ -2,7 +2,7 @@ import path from 'path'
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalEvents } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
-import { writelnStdout } from '../shared/helpers.js'
+import { writelnStderr } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: head [OPTION]... [FILE]...
@@ -10,7 +10,7 @@ Print the first 10 lines of each FILE to standard output.
 
   -n, -nNUMBER        print the first NUMBER lines instead of 10
   --help             display this help and exit`
-  writelnStdout(process, terminal, usage)
+  writelnStderr(process, terminal, usage)
 }
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {

package/src/commands/id.ts

@@ -1,6 +1,6 @@
 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: id [OPTION]...
@@ -11,7 +11,7 @@ Print user and group IDs.
   -G, --groups   print all group IDs
   -n, --name     print names instead of numeric IDs
   --help         display this help and exit`
-  writelnStdout(process, terminal, usage)
+  writelnStderr(process, terminal, usage)
 }
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {