@ecmaos/coreutils 0.1.3 → 0.1.5

package/src/commands/passkey.ts

@@ -0,0 +1,208 @@
+import chalk from 'chalk'
+import type { CommandLineOptions } from 'command-line-args'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'passkey',
+    description: 'Manage passkey credentials for WebAuthn authentication',
+    kernel,
+    shell,
+    terminal,
+    options: [
+      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
+      { name: 'subcommand', type: String, defaultOption: true, description: 'Subcommand: register, list, remove, remove-all' },
+      { name: 'name', type: String, description: 'Name/description for the passkey (used with register)' },
+      { name: 'id', type: String, description: 'Passkey ID to remove (used with remove)' }
+    ],
+    run: async (argv: CommandLineOptions, process?: Process) => {
+      if (!process) return 1
+
+      const currentUid = shell.credentials.uid
+      const user = kernel.users.get(currentUid)
+      if (!user) {
+        await writelnStderr(process, terminal, chalk.red('Error: Current user not found'))
+        return 1
+      }
+
+      const subcommand = (argv.subcommand as string)?.toLowerCase()
+
+      if (!subcommand || subcommand === 'help' || argv.help) {
+        await writelnStdout(process, terminal, 'Usage: passkey <subcommand> [options]')
+        await writelnStdout(process, terminal, '')
+        await writelnStdout(process, terminal, 'Subcommands:')
+        await writelnStdout(process, terminal, '  register [--name <name>]    Register a new passkey')
+        await writelnStdout(process, terminal, '  list                        List all registered passkeys')
+        await writelnStdout(process, terminal, '  remove --id <id>            Remove a specific passkey')
+        await writelnStdout(process, terminal, '  remove-all                  Remove all passkeys')
+        return 0
+      }
+
+      try {
+        switch (subcommand) {
+          case 'register': {
+            if (!kernel.auth.passkey.isSupported()) {
+              await writelnStderr(process, terminal, chalk.red('Error: WebAuthn is not supported in this browser'))
+              return 1
+            }
+
+            const name = (argv.name as string) || undefined
+            const username = user.username
+            const userId = new TextEncoder().encode(username)
+
+            const challenge = crypto.getRandomValues(new Uint8Array(32))
+            const rpId = globalThis.location.hostname || 'localhost'
+
+            const createOptions: PublicKeyCredentialCreationOptions = {
+              challenge,
+              rp: {
+                name: kernel.name || 'ecmaOS',
+                id: rpId
+              },
+              user: {
+                id: userId,
+                name: username,
+                displayName: username
+              },
+              pubKeyCredParams: [
+                { type: 'public-key', alg: -7 },
+                { type: 'public-key', alg: -257 }
+              ],
+              authenticatorSelection: {
+                userVerification: 'preferred'
+              },
+              timeout: 60000
+            }
+
+            await writelnStdout(process, terminal, chalk.yellow('Please interact with your authenticator to register a passkey...'))
+            const credential = await kernel.auth.passkey.create(createOptions)
+
+            if (!credential || !(credential instanceof PublicKeyCredential)) {
+              await writelnStderr(process, terminal, chalk.red('Error: Failed to create passkey. Registration cancelled or failed.'))
+              return 1
+            }
+
+            const publicKeyCredential = credential as PublicKeyCredential
+            const response = publicKeyCredential.response as AuthenticatorAttestationResponse
+
+            const credentialId = btoa(String.fromCharCode(...new Uint8Array(publicKeyCredential.rawId)))
+            
+            let publicKeyArray: Uint8Array
+            
+            try {
+              if (typeof response.getPublicKey === 'function') {
+                try {
+                  const publicKeyCrypto = response.getPublicKey()
+                  
+                  if (publicKeyCrypto && publicKeyCrypto instanceof CryptoKey) {
+                    const publicKeyJwk = await crypto.subtle.exportKey('jwk', publicKeyCrypto)
+                    publicKeyArray = new TextEncoder().encode(JSON.stringify(publicKeyJwk))
+                  } else {
+                    throw new Error('getPublicKey() did not return a valid CryptoKey')
+                  }
+                } catch (exportError) {
+                  await writelnStderr(process, terminal, chalk.yellow(`Warning: Could not extract public key via getPublicKey(): ${exportError instanceof Error ? exportError.message : String(exportError)}. Using attestationObject instead.`))
+                  const attestationObject = response.attestationObject
+                  publicKeyArray = new Uint8Array(attestationObject)
+                }
+              } else {
+                const attestationObject = response.attestationObject
+                publicKeyArray = new Uint8Array(attestationObject)
+              }
+            } catch (error) {
+              await writelnStderr(process, terminal, chalk.red(`Error processing credential data: ${error instanceof Error ? error.message : String(error)}`))
+              return 1
+            }
+
+            const passkey = {
+              id: crypto.randomUUID(),
+              credentialId,
+              publicKey: publicKeyArray,
+              createdAt: Date.now(),
+              name
+            }
+
+            await kernel.users.addPasskey(currentUid, passkey)
+            await writelnStdout(process, terminal, chalk.green(`Passkey registered successfully${name ? `: ${name}` : ''}`))
+            await writelnStdout(process, terminal, `Passkey ID: ${passkey.id}`)
+            return 0
+          }
+
+          case 'list': {
+            const passkeys = await kernel.users.getPasskeys(currentUid)
+            
+            if (passkeys.length === 0) {
+              await writelnStdout(process, terminal, 'No passkeys registered for this user.')
+              return 0
+            }
+
+            await writelnStdout(process, terminal, `Registered passkeys (${passkeys.length}):`)
+            await writelnStdout(process, terminal, '')
+            
+            for (const pk of passkeys) {
+              const createdDate = new Date(pk.createdAt).toLocaleString()
+              const lastUsedDate = pk.lastUsed ? new Date(pk.lastUsed).toLocaleString() : 'Never'
+              await writelnStdout(process, terminal, `  ID: ${pk.id}`)
+              if (pk.name) {
+                await writelnStdout(process, terminal, `    Name: ${pk.name}`)
+              }
+              await writelnStdout(process, terminal, `    Created: ${createdDate}`)
+              await writelnStdout(process, terminal, `    Last used: ${lastUsedDate}`)
+              await writelnStdout(process, terminal, '')
+            }
+            return 0
+          }
+
+          case 'remove': {
+            const id = argv.id as string
+            if (!id) {
+              await writelnStderr(process, terminal, chalk.red('Error: --id is required for remove command'))
+              await writelnStdout(process, terminal, 'Usage: passkey remove --id <id>')
+              return 1
+            }
+
+            const passkeys = await kernel.users.getPasskeys(currentUid)
+            const passkey = passkeys.find(pk => pk.id === id)
+            
+            if (!passkey) {
+              await writelnStderr(process, terminal, chalk.red(`Error: Passkey with ID ${id} not found`))
+              return 1
+            }
+
+            await kernel.users.removePasskey(currentUid, id)
+            await writelnStdout(process, terminal, chalk.green(`Passkey removed successfully${passkey.name ? `: ${passkey.name}` : ''}`))
+            return 0
+          }
+
+          case 'remove-all': {
+            const passkeys = await kernel.users.getPasskeys(currentUid)
+            
+            if (passkeys.length === 0) {
+              await writelnStdout(process, terminal, 'No passkeys to remove.')
+              return 0
+            }
+
+            await kernel.users.savePasskeys(currentUid, [])
+            const passkeysPath = `${user.home}/.passkeys`
+            try {
+              await kernel.filesystem.fs.unlink(passkeysPath)
+            } catch {}
+
+            await writelnStdout(process, terminal, chalk.green(`Removed ${passkeys.length} passkey(s)`))
+            return 0
+          }
+
+          default:
+            await writelnStderr(process, terminal, chalk.red(`Error: Unknown subcommand: ${subcommand}`))
+            await writelnStdout(process, terminal, 'Run "passkey help" for usage information')
+            return 1
+        }
+      } catch (error) {
+        await writelnStderr(process, terminal, chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`))
+        return 1
+      }
+    }
+  })
+}

package/src/commands/tail.ts

@@ -0,0 +1,164 @@
+import path from 'path'
+import type { CommandLineOptions } from 'command-line-args'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalEvents } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'tail',
+    description: 'Print the last lines of files',
+    kernel,
+    shell,
+    terminal,
+    options: [
+      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
+      { name: 'lines', type: Number, alias: 'n', description: 'Print the last NUM lines instead of the last 10' },
+      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, multiple: true, description: 'The path(s) to the file(s) to read' }
+    ],
+    run: async (argv: CommandLineOptions, process?: Process) => {
+      if (!process) return 1
+
+      const writer = process.stdout.getWriter()
+      const numLines = (argv.lines as number) ?? 10
+
+      try {
+        if (!argv.path || !(argv.path as string[])[0]) {
+          if (!process.stdin) {
+            return 0
+          }
+
+          const reader = process.stdin.getReader()
+          const decoder = new TextDecoder()
+          const lines: string[] = []
+          let buffer = ''
+
+          try {
+            while (true) {
+              let readResult
+              try {
+                readResult = await reader.read()
+              } catch (error) {
+                if (error instanceof Error) {
+                  throw error
+                }
+                break
+              }
+
+              const { done, value } = readResult
+              if (done) {
+                buffer += decoder.decode()
+                break
+              }
+              if (value) {
+                buffer += decoder.decode(value, { stream: true })
+                const newLines = buffer.split('\n')
+                buffer = newLines.pop() || ''
+                lines.push(...newLines)
+              }
+            }
+            if (buffer) {
+              lines.push(buffer)
+            }
+          } finally {
+            try {
+              reader.releaseLock()
+            } catch {
+            }
+          }
+
+          const output = lines.slice(-numLines).join('\n')
+          if (output) {
+            await writer.write(new TextEncoder().encode(output + '\n'))
+          }
+
+          return 0
+        }
+
+        const files = (argv.path as string[]) || []
+        const isMultipleFiles = files.length > 1
+
+        for (let i = 0; i < files.length; i++) {
+          const file = files[i]
+          if (!file) continue
+          const fullPath = path.resolve(shell.cwd, file)
+
+          if (isMultipleFiles) {
+            const header = i > 0 ? '\n' : ''
+            await writer.write(new TextEncoder().encode(`${header}==> ${file} <==\n`))
+          }
+
+          let interrupted = false
+          const interruptHandler = () => { interrupted = true }
+          kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+          try {
+            if (!fullPath.startsWith('/dev')) {
+              const handle = await shell.context.fs.promises.open(fullPath, 'r')
+              const stat = await shell.context.fs.promises.stat(fullPath)
+
+              const decoder = new TextDecoder()
+              let buffer = ''
+              let bytesRead = 0
+              const chunkSize = 1024
+
+              while (bytesRead < stat.size) {
+                if (interrupted) break
+                const data = new Uint8Array(chunkSize)
+                const readSize = Math.min(chunkSize, stat.size - bytesRead)
+                await handle.read(data, 0, readSize, bytesRead)
+                const chunk = data.subarray(0, readSize)
+                buffer += decoder.decode(chunk, { stream: true })
+                bytesRead += readSize
+              }
+
+              const lines = buffer.split('\n')
+              if (lines[lines.length - 1] === '') {
+                lines.pop()
+              }
+
+              const output = lines.slice(-numLines).join('\n')
+              if (output) {
+                await writer.write(new TextEncoder().encode(output + '\n'))
+              }
+            } else {
+              const device = await shell.context.fs.promises.open(fullPath)
+              const decoder = new TextDecoder()
+              const lines: string[] = []
+              let buffer = ''
+              const chunkSize = 1024
+              const data = new Uint8Array(chunkSize)
+              let bytesRead = 0
+
+              do {
+                if (interrupted) break
+                const result = await device.read(data)
+                bytesRead = result.bytesRead
+                if (bytesRead > 0) {
+                  buffer += decoder.decode(data.subarray(0, bytesRead), { stream: true })
+                }
+              } while (bytesRead > 0)
+
+              const allLines = buffer.split('\n')
+              if (allLines[allLines.length - 1] === '') {
+                allLines.pop()
+              }
+              lines.push(...allLines)
+
+              const output = lines.slice(-numLines).join('\n')
+              if (output) {
+                await writer.write(new TextEncoder().encode(output + '\n'))
+              }
+            }
+          } finally {
+            kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+          }
+        }
+
+        return 0
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/index.ts

@@ -12,6 +12,8 @@ import { createCommand as createCd } from './commands/cd.js'
 import { createCommand as createChmod } from './commands/chmod.js'
 import { createCommand as createCp } from './commands/cp.js'
 import { createCommand as createEcho } from './commands/echo.js'
+import { createCommand as createGrep } from './commands/grep.js'
+import { createCommand as createHead } from './commands/head.js'
 import { createCommand as createLn } from './commands/ln.js'
 import { createCommand as createLs } from './commands/ls.js'
 import { createCommand as createMkdir } from './commands/mkdir.js'
@@ -23,8 +25,10 @@ import { createCommand as createStat } from './commands/stat.js'
 import { createCommand as createTouch } from './commands/touch.js'
 import { createCommand as createHex } from './commands/hex.js'
 import { createCommand as createLess } from './commands/less.js'
+import { createCommand as createPasskey } from './commands/passkey.js'
 import { createCommand as createSed } from './commands/sed.js'
 import { createCommand as createTee } from './commands/tee.js'
+import { createCommand as createTail } from './commands/tail.js'
 
 // Export individual command factories
 export { createCommand as createCat } from './commands/cat.js'
@@ -32,6 +36,7 @@ export { createCommand as createCd } from './commands/cd.js'
 export { createCommand as createChmod } from './commands/chmod.js'
 export { createCommand as createCp } from './commands/cp.js'
 export { createCommand as createEcho } from './commands/echo.js'
+export { createCommand as createGrep } from './commands/grep.js'
 export { createCommand as createLn } from './commands/ln.js'
 export { createCommand as createLs } from './commands/ls.js'
 export { createCommand as createMkdir } from './commands/mkdir.js'
@@ -45,6 +50,7 @@ export { createCommand as createHex } from './commands/hex.js'
 export { createCommand as createLess } from './commands/less.js'
 export { createCommand as createSed } from './commands/sed.js'
 export { createCommand as createTee } from './commands/tee.js'
+export { createCommand as createTail } from './commands/tail.js'
 
 /**
  * Creates all coreutils commands.
@@ -57,6 +63,8 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     chmod: createChmod(kernel, shell, terminal),
     cp: createCp(kernel, shell, terminal),
     echo: createEcho(kernel, shell, terminal),
+    grep: createGrep(kernel, shell, terminal),
+    head: createHead(kernel, shell, terminal),
     ln: createLn(kernel, shell, terminal),
     ls: createLs(kernel, shell, terminal),
     mkdir: createMkdir(kernel, shell, terminal),
@@ -68,7 +76,9 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     touch: createTouch(kernel, shell, terminal),
     hex: createHex(kernel, shell, terminal),
     less: createLess(kernel, shell, terminal),
+    passkey: createPasskey(kernel, shell, terminal),
     sed: createSed(kernel, shell, terminal),
+    tail: createTail(kernel, shell, terminal),
     tee: createTee(kernel, shell, terminal)
   }
 }