@ecmaos/coreutils 0.3.1 → 0.4.2

package/src/commands/chown.ts

@@ -0,0 +1,321 @@
+import path from 'path'
+import chalk from 'chalk'
+import type { Kernel, Process, Shell, Terminal, User } 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: chown [OPTION]... [OWNER][:[GROUP]] FILE...
+   or:  chown [OPTION]... :GROUP FILE...
+   or:  chown [OPTION]... --reference=RFILE FILE...
+Change the owner and/or group of each FILE to OWNER and/or GROUP.
+
+      -R, --recursive     operate on files and directories recursively
+      -v, --verbose       output a diagnostic for every file processed
+      -c, --changes       like verbose but report only when a change is made
+      --help              display this help and exit
+
+OWNER and GROUP can be specified as:
+  - A numeric user ID (UID) or group ID (GID)
+  - A username (resolved to UID)
+  - A group name (resolved to GID, if supported)
+
+The format OWNER:GROUP means set both owner and group.
+The format OWNER: means set owner and set group to owner's primary group.
+The format :GROUP means set group only (keep current owner).
+The format OWNER.GROUP is also accepted (same as OWNER:GROUP).
+
+Examples:
+  chown root file                 Change owner of file to root
+  chown root:root file            Change owner and group to root
+  chown :users file               Change group to users (keep owner)
+  chown root: file                Change owner to root, group to root's primary group
+  chown -R root:root /dir         Recursively change owner and group
+  chown -v user file              Verbose output while changing owner
+  chown -c user file              Report only when changes are made`
+  writelnStderr(process, terminal, usage)
+}
+
+interface OwnershipSpec {
+  owner?: number
+  group?: number
+  ownerOnly: boolean
+  groupOnly: boolean
+  setGroupToOwnerPrimary: boolean
+}
+
+function parseOwnershipSpec(spec: string, kernel: Kernel): OwnershipSpec {
+  const result: OwnershipSpec = {
+    ownerOnly: false,
+    groupOnly: false,
+    setGroupToOwnerPrimary: false
+  }
+
+  if (spec.startsWith(':')) {
+    result.groupOnly = true
+    const groupSpec = spec.slice(1)
+    if (!groupSpec) {
+      throw new Error('Invalid ownership spec: missing group after colon')
+    }
+    result.group = resolveGroup(groupSpec, kernel)
+    return result
+  }
+
+  if (spec.endsWith(':')) {
+    result.ownerOnly = true
+    result.setGroupToOwnerPrimary = true
+    const ownerSpec = spec.slice(0, -1)
+    if (!ownerSpec) {
+      throw new Error('Invalid ownership spec: missing owner before colon')
+    }
+    result.owner = resolveOwner(ownerSpec, kernel)
+    const ownerUser = kernel.users.get(result.owner)
+    if (ownerUser) {
+      result.group = ownerUser.gid
+    }
+    return result
+  }
+
+  const colonIndex = spec.indexOf(':')
+  const dotIndex = spec.indexOf('.')
+
+  if (colonIndex === -1 && dotIndex === -1) {
+    result.owner = resolveOwner(spec, kernel)
+    result.ownerOnly = true
+    return result
+  }
+
+  const separatorIndex = colonIndex !== -1 ? colonIndex : dotIndex
+  const ownerSpec = spec.slice(0, separatorIndex)
+  const groupSpec = spec.slice(separatorIndex + 1)
+
+  if (!ownerSpec && !groupSpec) {
+    throw new Error('Invalid ownership spec: both owner and group are empty')
+  }
+
+  if (ownerSpec) {
+    result.owner = resolveOwner(ownerSpec, kernel)
+  }
+
+  if (groupSpec) {
+    result.group = resolveGroup(groupSpec, kernel)
+  }
+
+  return result
+}
+
+function resolveOwner(ownerSpec: string, kernel: Kernel): number {
+  const numericUid = parseInt(ownerSpec, 10)
+  if (!isNaN(numericUid) && numericUid.toString() === ownerSpec) {
+    return numericUid
+  }
+
+  const user = Array.from(kernel.users.all.values()).find(
+    (u): u is User => (u as User).username === ownerSpec
+  )
+
+  if (!user) {
+    throw new Error(`Invalid user: ${ownerSpec}`)
+  }
+
+  return user.uid
+}
+
+function resolveGroup(groupSpec: string, kernel: Kernel): number {
+  const numericGid = parseInt(groupSpec, 10)
+  if (!isNaN(numericGid) && numericGid.toString() === groupSpec) {
+    return numericGid
+  }
+
+  const user = Array.from(kernel.users.all.values()).find(
+    (u): u is User => (u as User).username === groupSpec
+  )
+
+  if (user) {
+    return user.gid
+  }
+
+  throw new Error(`Invalid group: ${groupSpec}`)
+}
+
+async function getCurrentOwnership(
+  fs: typeof import('@zenfs/core').fs.promises,
+  filePath: string
+): Promise<{ uid: number; gid: number }> {
+  try {
+    const stats = await fs.stat(filePath)
+    return { uid: stats.uid, gid: stats.gid }
+  } catch (error) {
+    throw new Error(`Cannot access ${filePath}: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}
+
+async function changeOwnership(
+  fs: typeof import('@zenfs/core').fs.promises,
+  filePath: string,
+  spec: OwnershipSpec,
+  kernel: Kernel
+): Promise<{ uid: number; gid: number }> {
+  const current = await getCurrentOwnership(fs, filePath)
+  let newUid = current.uid
+  let newGid = current.gid
+
+  if (spec.ownerOnly) {
+    newUid = spec.owner ?? current.uid
+    if (spec.setGroupToOwnerPrimary && spec.owner !== undefined) {
+      const ownerUser = kernel.users.get(spec.owner)
+      if (ownerUser) {
+        newGid = ownerUser.gid
+      }
+    } else if (spec.group !== undefined) {
+      newGid = spec.group
+    }
+  } else if (spec.groupOnly) {
+    newGid = spec.group ?? current.gid
+  } else {
+    if (spec.owner !== undefined) {
+      newUid = spec.owner
+    }
+    if (spec.group !== undefined) {
+      newGid = spec.group
+    }
+  }
+
+  await fs.chown(filePath, newUid, newGid)
+  return { uid: newUid, gid: newGid }
+}
+
+async function processFile(
+  fs: typeof import('@zenfs/core').fs.promises,
+  filePath: string,
+  spec: OwnershipSpec,
+  kernel: Kernel,
+  options: { recursive: boolean; verbose: boolean; changes: boolean },
+  process: Process | undefined,
+  terminal: Terminal,
+  relativePath: string
+): Promise<boolean> {
+  try {
+    const current = await getCurrentOwnership(fs, filePath)
+    const newOwnership = await changeOwnership(fs, filePath, spec, kernel)
+    const changed = current.uid !== newOwnership.uid || current.gid !== newOwnership.gid
+
+    if (options.verbose || (options.changes && changed)) {
+      const changeInfo = changed
+        ? `changed ownership of '${relativePath}' from ${current.uid}:${current.gid} to ${newOwnership.uid}:${newOwnership.gid}`
+        : `ownership of '${relativePath}' retained as ${newOwnership.uid}:${newOwnership.gid}`
+      await writelnStdout(process, terminal, changeInfo)
+    }
+
+    if (options.recursive) {
+      try {
+        const stats = await fs.stat(filePath)
+        if (stats.isDirectory()) {
+          const entries = await fs.readdir(filePath)
+          for (const entry of entries) {
+            const entryPath = path.join(filePath, entry)
+            const entryRelativePath = path.join(relativePath, entry)
+            await processFile(fs, entryPath, spec, kernel, options, process, terminal, entryRelativePath)
+          }
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        await writelnStderr(process, terminal, `chown: ${relativePath}: ${errorMessage}`)
+      }
+    }
+
+    return false
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    await writelnStderr(process, terminal, `chown: ${relativePath}: ${errorMessage}`)
+    return true
+  }
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'chown',
+    description: 'Change file owner and group',
+    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
+      }
+
+      let recursive = false
+      let verbose = false
+      let changes = false
+      const args: string[] = []
+
+      for (const arg of argv) {
+        if (arg === '-R' || arg === '--recursive') {
+          recursive = true
+        } else if (arg === '-v' || arg === '--verbose') {
+          verbose = true
+        } else if (arg === '-c' || arg === '--changes') {
+          changes = true
+        } else if (arg === '--reference') {
+          await writelnStderr(process, terminal, chalk.red('chown: --reference option not yet implemented'))
+          return 1
+        } else if (arg && !arg.startsWith('-')) {
+          args.push(arg)
+        } else if (arg.startsWith('-')) {
+          await writelnStderr(process, terminal, chalk.red(`chown: invalid option '${arg}'`))
+          await writelnStderr(process, terminal, 'Try \'chown --help\' for more information.')
+          return 1
+        }
+      }
+
+      if (args.length === 0) {
+        await writelnStderr(process, terminal, chalk.red('chown: missing operand'))
+        await writelnStderr(process, terminal, 'Try \'chown --help\' for more information.')
+        return 1
+      }
+
+      const ownershipSpec = args[0]
+      const targets = args.slice(1)
+
+      if (!ownershipSpec || targets.length === 0) {
+        await writelnStderr(process, terminal, chalk.red('chown: missing operand'))
+        await writelnStderr(process, terminal, 'Try \'chown --help\' for more information.')
+        return 1
+      }
+
+      let spec: OwnershipSpec
+      try {
+        spec = parseOwnershipSpec(ownershipSpec, kernel)
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        await writelnStderr(process, terminal, chalk.red(`chown: invalid ownership spec '${ownershipSpec}': ${errorMessage}`))
+        return 1
+      }
+
+      let hasError = false
+      const options = { recursive, verbose, changes }
+
+      for (const target of targets) {
+        const fullPath = path.resolve(shell.cwd, target)
+        const error = await processFile(
+          shell.context.fs.promises,
+          fullPath,
+          spec,
+          kernel,
+          options,
+          process,
+          terminal,
+          target
+        )
+        if (error) {
+          hasError = true
+        }
+      }
+
+      return hasError ? 1 : 0
+    }
+  })
+}

package/src/commands/cksum.ts

@@ -0,0 +1,133 @@
+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'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: cksum [FILE]...
+Print CRC checksum and byte count for each FILE.
+
+If no FILE is specified, or if FILE is -, read standard input.
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function calculateCRC32(data: Uint8Array): number {
+  let crc = 0xffffffff
+  const polynomial = 0xedb88320
+
+  for (let i = 0; i < data.length; i++) {
+    const byte = data[i]
+    if (byte === undefined) continue
+    crc ^= byte
+    for (let j = 0; j < 8; j++) {
+      if (crc & 1) {
+        crc = (crc >>> 1) ^ polynomial
+      } else {
+        crc = crc >>> 1
+      }
+    }
+  }
+
+  return (crc ^ 0xffffffff) >>> 0
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'cksum',
+    description: 'Print CRC checksum and byte count',
+    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
+      }
+
+      const files: string[] = []
+
+      for (const arg of argv) {
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        } else {
+          await writelnStderr(process, terminal, `cksum: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'cksum --help' for more information.")
+          return 1
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        if (files.length === 0) {
+          if (!process.stdin) {
+            return 0
+          }
+
+          const reader = process.stdin.getReader()
+          const chunks: Uint8Array[] = []
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+              if (value) {
+                chunks.push(value)
+              }
+            }
+          } finally {
+            reader.releaseLock()
+          }
+
+          const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
+          const data = new Uint8Array(totalLength)
+          let offset = 0
+          for (const chunk of chunks) {
+            data.set(chunk, offset)
+            offset += chunk.length
+          }
+
+          const crc = calculateCRC32(data)
+          await writer.write(new TextEncoder().encode(`${crc} ${data.length}\n`))
+          return 0
+        }
+
+        for (const file of files) {
+          const fullPath = path.resolve(shell.cwd, file)
+
+          try {
+            if (fullPath.startsWith('/dev')) {
+              await writelnStderr(process, terminal, `cksum: ${file}: cannot checksum device files`)
+              continue
+            }
+
+            const data = await shell.context.fs.promises.readFile(fullPath)
+            const bytes = new Uint8Array(data)
+            const crc = calculateCRC32(bytes)
+            await writer.write(new TextEncoder().encode(`${crc} ${bytes.length} ${file}\n`))
+          } catch (error) {
+            await writelnStderr(process, terminal, `cksum: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+          }
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `cksum: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/cmp.ts

@@ -0,0 +1,126 @@
+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'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: cmp [OPTION]... FILE1 FILE2
+Compare two files byte by byte.
+
+  -l, --verbose          print byte number and differing byte values
+  -s, --quiet, --silent  suppress output; return exit status only
+  --help                 display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'cmp',
+    description: 'Compare two files byte by byte',
+    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 verbose = false
+      let quiet = false
+      const files: string[] = []
+
+      for (const arg of argv) {
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-l' || arg === '--verbose') {
+          verbose = true
+        } else if (arg === '-s' || arg === '--quiet' || arg === '--silent') {
+          quiet = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('l')) verbose = true
+          if (flags.includes('s')) quiet = true
+          const invalidFlags = flags.filter(f => !['l', 's'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `cmp: invalid option -- '${invalidFlags[0]}'`)
+            await writelnStderr(process, terminal, "Try 'cmp --help' for more information.")
+            return 1
+          }
+        } else {
+          files.push(arg)
+        }
+      }
+
+      if (files.length !== 2) {
+        await writelnStderr(process, terminal, 'cmp: missing operand after')
+        await writelnStderr(process, terminal, "Try 'cmp --help' for more information.")
+        return 1
+      }
+
+      const file1 = files[0]
+      const file2 = files[1]
+      if (!file1 || !file2) {
+        await writelnStderr(process, terminal, 'cmp: missing operand')
+        return 1
+      }
+
+      const fullPath1 = path.resolve(shell.cwd, file1)
+      const fullPath2 = path.resolve(shell.cwd, file2)
+
+      let interrupted = false
+      const interruptHandler = () => { interrupted = true }
+      kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+      try {
+        if (fullPath1.startsWith('/dev') || fullPath2.startsWith('/dev')) {
+          await writelnStderr(process, terminal, 'cmp: cannot compare device files')
+          return 1
+        }
+
+        const data1 = await shell.context.fs.promises.readFile(fullPath1)
+        const data2 = await shell.context.fs.promises.readFile(fullPath2)
+
+        const bytes1 = new Uint8Array(data1)
+        const bytes2 = new Uint8Array(data2)
+
+        const minLength = Math.min(bytes1.length, bytes2.length)
+
+        for (let i = 0; i < minLength; i++) {
+          if (interrupted) break
+          if (bytes1[i] !== bytes2[i]) {
+            if (verbose) {
+              await writelnStderr(process, terminal, `${i + 1} ${bytes1[i]} ${bytes2[i]}`)
+            } else if (!quiet) {
+              await writelnStderr(process, terminal, `${file1} ${file2} differ: byte ${i + 1}, line ${Math.floor(i / 80) + 1}`)
+            }
+            return 1
+          }
+        }
+
+        if (bytes1.length !== bytes2.length) {
+          if (!quiet) {
+            await writelnStderr(process, terminal, `cmp: EOF on ${bytes1.length < bytes2.length ? file1 : file2}`)
+          }
+          return 1
+        }
+
+        return 0
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        await writelnStderr(process, terminal, `cmp: ${errorMessage}`)
+        return 1
+      } finally {
+        kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+      }
+    }
+  })
+}