@ecmaos/coreutils 0.5.2 → 0.6.0

package/src/commands/history.ts

@@ -0,0 +1,172 @@
+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: history [OPTION]... [N]
+Display or manipulate the command history.
+
+  N              display the last N entries
+  -c             clear the history list
+  -d N           delete the history entry at position N
+  -r             reload the history file (useful after manual edits)
+  --help         display this help and exit
+
+If N is provided without options, display the last N entries.
+If no arguments are provided, display all history entries.
+
+Note: History is automatically saved on each command execution.`
+  writelnStderr(process, terminal, usage)
+}
+
+async function readHistoryFile(shell: Shell, kernel: Kernel): Promise<string[]> {
+  const home = shell.env.get('HOME') || '/root'
+  const historyPath = path.join(home, '.history')
+
+  try {
+    if (!kernel.filesystem?.fs) {
+      return []
+    }
+
+    const exists = await kernel.filesystem.fs.exists(historyPath)
+    if (!exists) {
+      return []
+    }
+
+    const content = await kernel.filesystem.fs.readFile(historyPath, 'utf-8')
+    const lines = content.split('\n').filter(line => line.length > 0)
+    return lines
+  } catch {
+    return []
+  }
+}
+
+async function writeHistoryFile(shell: Shell, kernel: Kernel, lines: string[]): Promise<void> {
+  const home = shell.env.get('HOME') || '/root'
+  const historyPath = path.join(home, '.history')
+
+  if (!kernel.filesystem?.fs) {
+    throw new Error('Filesystem not available')
+  }
+
+  const content = lines.join('\n')
+  await kernel.filesystem.fs.writeFile(historyPath, content, 'utf-8')
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'history',
+    description: 'Display or manipulate the command history',
+    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 writer = process.stdout.getWriter()
+
+      try {
+        let clearHistory = false
+        let deleteIndex: number | null = null
+        let readHistory = false
+        let numEntries: number | null = null
+
+        for (let i = 0; i < argv.length; i++) {
+          const arg = argv[i]
+          if (!arg) continue
+
+          if (arg === '-c') {
+            clearHistory = true
+          } else if (arg === '-r') {
+            readHistory = true
+          } else if (arg === '-d') {
+            if (i + 1 < argv.length) {
+              i++
+              const nextArg = argv[i]
+              if (nextArg !== undefined) {
+                const index = parseInt(nextArg, 10)
+                if (!isNaN(index)) {
+                  deleteIndex = index
+                } else {
+                  await writelnStderr(process, terminal, `history: invalid history number '${nextArg}'`)
+                  return 1
+                }
+              }
+            } else {
+              await writelnStderr(process, terminal, 'history: -d requires a history number')
+              return 1
+            }
+          } else if (!arg.startsWith('-')) {
+            const num = parseInt(arg, 10)
+            if (!isNaN(num)) {
+              numEntries = num
+            }
+          }
+        }
+
+        if (clearHistory) {
+          const uid = shell.credentials.uid
+          await terminal.clearHistory(uid)
+          return 0
+        }
+
+        if (deleteIndex !== null) {
+          const lines = await readHistoryFile(shell, kernel)
+          if (deleteIndex < 1 || deleteIndex > lines.length) {
+            await writelnStderr(process, terminal, `history: history number '${deleteIndex}' out of range`)
+            return 1
+          }
+          const newLines = lines.filter((_, index) => index !== deleteIndex - 1)
+          await writeHistoryFile(shell, kernel, newLines)
+          
+          const uid = shell.credentials.uid
+          await terminal.reloadHistory(uid).catch(() => {})
+          return 0
+        }
+
+        if (readHistory) {
+          const uid = shell.credentials.uid
+          await terminal.reloadHistory(uid).catch(() => {})
+          return 0
+        }
+
+        const lines = await readHistoryFile(shell, kernel)
+        
+        if (lines.length === 0) {
+          return 0
+        }
+
+        const displayLines = numEntries !== null 
+          ? lines.slice(-numEntries)
+          : lines
+
+        const startIndex = numEntries !== null 
+          ? lines.length - numEntries + 1
+          : 1
+
+        for (let i = 0; i < displayLines.length; i++) {
+          const lineNumber = startIndex + i
+          const line = displayLines[i]
+          const output = `  ${lineNumber}  ${line}\n`
+          await writer.write(new TextEncoder().encode(output))
+        }
+
+        return 0
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        await writelnStderr(process, terminal, `history: ${errorMessage}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/ls.ts

@@ -14,7 +14,7 @@ List information about the FILEs (the current directory by default).
   writelnStderr(process, terminal, usage)
 }
 
-function truncateInfo(text: string, maxWidth: number = 40): string {
+function truncateInfo(text: string, maxWidth: number = 35): string {
   if (!text) return text
   
   // Strip ANSI codes to get visible length

package/src/commands/tty.ts

@@ -0,0 +1,68 @@
+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: tty [TTY_NUMBER]
+Print the current TTY number or switch to a different TTY.
+
+  TTY_NUMBER    switch to the specified TTY (0-9)
+  --help        display this help and exit
+
+If no TTY_NUMBER is provided, prints the current TTY number.
+If TTY_NUMBER is provided, switches to that TTY.`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'tty',
+    description: 'Print the current TTY number or switch to a different TTY',
+    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 writelnStdout(process, terminal, kernel.activeTty.toString())
+        return 0
+      }
+
+      if (argv.length > 1) {
+        await writelnStderr(process, terminal, 'tty: too many arguments')
+        await writelnStderr(process, terminal, "Try 'tty --help' for more information.")
+        return 1
+      }
+
+      const ttyNumber = parseInt(argv[0] ?? '0', 10)
+
+      if (isNaN(ttyNumber)) {
+        await writelnStderr(process, terminal, `tty: invalid TTY number '${argv[0]}'`)
+        await writelnStderr(process, terminal, "Try 'tty --help' for more information.")
+        return 1
+      }
+
+      if (ttyNumber < 0 || ttyNumber > 9) {
+        await writelnStderr(process, terminal, `tty: TTY number must be between 0 and 9`)
+        await writelnStderr(process, terminal, "Try 'tty --help' for more information.")
+        return 1
+      }
+
+      try {
+        await kernel.switchTty(ttyNumber)
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `tty: failed to switch to TTY ${ttyNumber}: ${error instanceof Error ? error.message : String(error)}`)
+        return 1
+      }
+    }
+  })
+}

package/src/commands/vim.ts

@@ -0,0 +1,307 @@
+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: vim [OPTION]... [FILE]...
+Vi IMproved - a text editor.
+
+  FILE                    file(s) to edit
+  --help, -h              display this help and exit
+
+Examples:
+  vim file.txt            edit file.txt
+  vim file1.txt file2.txt edit multiple files`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'vim',
+    description: 'Vi IMproved - a text editor',
+    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
+      }
+
+      try {
+        const { VimWasm, checkBrowserCompatibility } = await import('vim-wasm/vimwasm.js')
+
+        const compatibilityError = checkBrowserCompatibility()
+        if (compatibilityError !== undefined) {
+          await writelnStderr(process, terminal, `vim: ${compatibilityError}`)
+          return 1
+        }
+
+        const files: string[] = []
+        for (const arg of argv) {
+          if (arg && !arg.startsWith('-')) {
+            files.push(arg)
+          }
+        }
+
+        if (files.length === 0) {
+          await writelnStderr(process, terminal, 'vim: no file specified')
+          await writelnStderr(process, terminal, "Try 'vim --help' for more information.")
+          return 1
+        }
+
+        const fileContents: Record<string, string> = {}
+        const dirs = new Set<string>()
+        const cmdArgs: string[] = []
+
+        const cwd = shell.cwd
+        let currentCwd = cwd
+        while (currentCwd !== '/' && currentCwd !== '') {
+          dirs.add(currentCwd)
+          currentCwd = path.dirname(currentCwd)
+        }
+        
+        const homeDir = shell.expandTilde('~')
+        if (homeDir && homeDir !== '~') {
+          let currentDir = homeDir
+          while (currentDir !== '/' && currentDir !== '') {
+            dirs.add(currentDir)
+            currentDir = path.dirname(currentDir)
+          }
+
+          const vimrcPath = path.join(homeDir, '.vim', 'vimrc')
+          const vimrcExists = await shell.context.fs.promises.exists(vimrcPath)
+          if (vimrcExists) {
+            const vimrcContent = await shell.context.fs.promises.readFile(vimrcPath, 'utf-8')
+            const vimrcVirtualPath = '/home/web_user/.vim/vimrc'
+            fileContents[vimrcVirtualPath] = vimrcContent
+          }
+        }
+
+        for (const file of files) {
+          const expandedPath = shell.expandTilde(file)
+          const fullPath = path.resolve(shell.cwd, expandedPath)
+
+          const exists = await shell.context.fs.promises.exists(fullPath)
+
+          if (exists) {
+            const stats = await shell.context.fs.promises.stat(fullPath)
+            if (stats.isDirectory()) {
+              await writelnStderr(process, terminal, `vim: ${file}: Is a directory`)
+              return 1
+            }
+
+            const content = await shell.context.fs.promises.readFile(fullPath, 'utf-8')
+            fileContents[fullPath] = content
+          } else {
+            fileContents[fullPath] = ''
+          }
+
+          const dir = path.dirname(fullPath)
+          let currentDir = dir
+          while (currentDir !== '/' && currentDir !== '') {
+            dirs.add(currentDir)
+            currentDir = path.dirname(currentDir)
+          }
+
+          cmdArgs.push(fullPath)
+        }
+
+        const emscriptenDefaultDirs = new Set(['/', '/tmp', '/home', '/home/web_user', '/home/web_user/.vim', '/dev'])
+        const dirsArray = Array.from(dirs)
+          .filter(d => !emscriptenDefaultDirs.has(d))
+          .sort((a, b) => a.length - b.length)
+
+        const container = document.createElement('div')
+        container.style.width = '100%'
+        container.style.height = '100%'
+        container.style.display = 'flex'
+        container.style.flexDirection = 'column'
+        container.style.background = '#1e1e1e'
+        container.style.overflow = 'hidden'
+
+        const canvas = document.createElement('canvas')
+        canvas.id = 'vim-canvas'
+        canvas.style.width = '100%'
+        canvas.style.height = '100%'
+        canvas.style.flex = '1'
+
+        const input = document.createElement('input')
+        input.id = 'vim-input'
+        input.type = 'text'
+        input.autocomplete = 'off'
+        input.autofocus = true
+        input.style.position = 'absolute'
+        input.style.left = '-9999px'
+        input.style.width = '1px'
+        input.style.height = '1px'
+        input.style.opacity = '0'
+
+        container.appendChild(canvas)
+        container.appendChild(input)
+
+        const firstFile = files.length > 0 ? files[0] : undefined
+        const windowTitle = firstFile ? path.basename(firstFile) : 'vim'
+        const win = kernel.windows.create({
+          title: windowTitle,
+          width: 900,
+          height: 700,
+          max: false
+        })
+
+        win.mount(container)
+
+        let workerScriptPath: string
+        try {
+          workerScriptPath = new URL('vim-wasm/vim.js', import.meta.url).href
+        } catch {
+          await writelnStderr(process, terminal, 'vim: failed to resolve worker script path. Please ensure vim-wasm is properly installed.')
+          win.close()
+          return 1
+        }
+
+        const vim = new VimWasm({
+          canvas,
+          input,
+          workerScriptPath
+        })
+
+        let exitCode = 0
+        let vimExited = false
+        let resizeObserver: ResizeObserver | null = null
+
+        vim.onFileExport = async (fullpath: string, contents: ArrayBuffer) => {
+          try {
+            const text = new TextDecoder().decode(contents)
+            await shell.context.fs.promises.writeFile(fullpath, text, 'utf-8')
+          } catch (error) {
+            await writelnStderr(process, terminal, `vim: error writing file ${fullpath}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+          }
+        }
+
+        vim.onVimExit = (status: number) => {
+          vimExited = true
+          exitCode = status === 0 ? 0 : 1
+          if (resizeObserver) {
+            resizeObserver.disconnect()
+            resizeObserver = null
+          }
+          win.close()
+        }
+
+        vim.onError = async (err: Error) => {
+          console.error('[vim] Error callback triggered:', err)
+          console.error('[vim] Error message:', err.message)
+          console.error('[vim] Error stack:', err.stack)
+          await writelnStderr(process, terminal, `vim: error: ${err.message}`)
+          if (!vimExited) {
+            exitCode = 1
+            if (resizeObserver) {
+              resizeObserver.disconnect()
+              resizeObserver = null
+            }
+            win.close()
+          }
+        }
+
+        vim.onTitleUpdate = (title: string) => {
+          win.setTitle(title || windowTitle)
+        }
+
+        vim.onVimInit = async () => {
+          try {
+            await vim.cmdline('autocmd BufWritePost * :export')
+          } catch (error) {
+            console.error('[vim] Failed to set up auto-export:', error)
+          }
+
+          const handleResize = () => {
+            if (vimExited || !vim.isRunning()) return
+            
+            const rect = container.getBoundingClientRect()
+            const width = Math.floor(rect.width)
+            const height = Math.floor(rect.height)
+            
+            if (width > 0 && height > 0) {
+              const dpr = window.devicePixelRatio || 1
+              canvas.width = width * dpr
+              canvas.height = height * dpr
+              
+              vim.resize(width, height)
+            }
+          }
+
+          resizeObserver = new ResizeObserver(handleResize)
+          resizeObserver.observe(container)
+        }
+
+        for (const filePath of Object.keys(fileContents)) {
+          const parentDir = path.dirname(filePath)
+          if (!dirsArray.includes(parentDir)) {
+            console.warn(`[vim] WARNING: Parent directory ${parentDir} of file ${filePath} is not in dirs array!`)
+          }
+          if (dirsArray.includes(filePath)) {
+            console.error(`[vim] ERROR: File path ${filePath} is also in dirs array! This will cause ENOTDIR error.`)
+          }
+        }
+        
+        for (const dirPath of dirsArray) {
+          if (fileContents[dirPath] !== undefined) {
+            console.error(`[vim] ERROR: Directory path ${dirPath} is also in files object! This will cause ENOTDIR error.`)
+          }
+        }
+        
+        for (let i = 0; i < dirsArray.length; i++) {
+          const dir = dirsArray[i]
+          if (dir) {
+            const parent = path.dirname(dir)
+            if (parent !== dir && !dirsArray.slice(0, i).includes(parent)) {
+              console.warn(`[vim] WARNING: Directory ${dir} has parent ${parent} that comes after it in the array!`)
+            }
+          }
+        }
+
+        try {
+          const startOptions = {
+            files: fileContents,
+            dirs: dirsArray,
+            cmdArgs,
+            debug: false
+          }
+          
+          vim.start(startOptions)
+        } catch (startError) {
+          console.error('[vim] Error calling vim.start():', startError)
+          await writelnStderr(process, terminal, `vim: failed to start: ${startError instanceof Error ? startError.message : 'Unknown error'}`)
+          if (startError instanceof Error && startError.stack) {
+            console.error('[vim] Start error stack:', startError.stack)
+          }
+          win.close()
+          return 1
+        }
+
+        return new Promise<number>((resolve) => {
+          const checkExit = () => {
+            if (vimExited) {
+              resolve(exitCode)
+            } else {
+              setTimeout(checkExit, 100)
+            }
+          }
+          checkExit()
+        })
+      } catch (error) {
+        await writelnStderr(process, terminal, `vim: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        if (error instanceof Error && error.stack) {
+          console.error(error.stack)
+        }
+        return 1
+      }
+    }
+  })
+}

package/src/index.ts

@@ -21,6 +21,7 @@ import { createCommand as createGrep } from './commands/grep.js'
 import { createCommand as createGroups } from './commands/groups.js'
 import { createCommand as createHash } from './commands/hash.js'
 import { createCommand as createHead } from './commands/head.js'
+import { createCommand as createHistory } from './commands/history.js'
 import { createCommand as createHostname } from './commands/hostname.js'
 import { createCommand as createLn } from './commands/ln.js'
 import { createCommand as createLs } from './commands/ls.js'
@@ -85,6 +86,7 @@ import { createCommand as createTest } from './commands/test.js'
 import { createCommand as createTime } from './commands/time.js'
 import { createCommand as createTr } from './commands/tr.js'
 import { createCommand as createTrue } from './commands/true.js'
+import { createCommand as createTty } from './commands/tty.js'
 import { createCommand as createUname } from './commands/uname.js'
 import { createCommand as createUmount } from './commands/umount.js'
 import { createCommand as createUnexpand } from './commands/unexpand.js'
@@ -99,6 +101,8 @@ import { createCommand as createZip } from './commands/zip.js'
 import { createCommand as createUnzip } from './commands/unzip.js'
 import { createCommand as createVideo } from './commands/video.js'
 import { createCommand as createView } from './commands/view.js'
+import { createCommand as createVim } from './commands/vim.js'
+import { createCommand as createGit } from './commands/git.js'
 
 // Export individual command factories
 export { createCommand as createCat } from './commands/cat.js'
@@ -113,6 +117,7 @@ export { createCommand as createFetch } from './commands/fetch.js'
 export { createCommand as createGrep } from './commands/grep.js'
 export { createCommand as createGroups } from './commands/groups.js'
 export { createCommand as createHash } from './commands/hash.js'
+export { createCommand as createHistory } from './commands/history.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'
@@ -161,6 +166,7 @@ export { createCommand as createSleep } from './commands/sleep.js'
 export { createCommand as createSort } from './commands/sort.js'
 export { createCommand as createTest } from './commands/test.js'
 export { createCommand as createTr } from './commands/tr.js'
+export { createCommand as createTty } from './commands/tty.js'
 export { createCommand as createUname } from './commands/uname.js'
 export { createCommand as createUmount } from './commands/umount.js'
 export { createCommand as createUptime } from './commands/uptime.js'
@@ -174,6 +180,8 @@ export { createCommand as createZip } from './commands/zip.js'
 export { createCommand as createUnzip } from './commands/unzip.js'
 export { createCommand as createVideo } from './commands/video.js'
 export { createCommand as createView } from './commands/view.js'
+export { createCommand as createVim } from './commands/vim.js'
+export { createCommand as createGit } from './commands/git.js'
 
 /**
  * Creates all coreutils commands.
@@ -195,6 +203,7 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     groups: createGroups(kernel, shell, terminal),
     hash: createHash(kernel, shell, terminal),
     head: createHead(kernel, shell, terminal),
+    history: createHistory(kernel, shell, terminal),
     hostname: createHostname(kernel, shell, terminal),
     ln: createLn(kernel, shell, terminal),
     ls: createLs(kernel, shell, terminal),
@@ -259,6 +268,7 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     time: createTime(kernel, shell, terminal),
     tr: createTr(kernel, shell, terminal),
     true: createTrue(kernel, shell, terminal),
+    tty: createTty(kernel, shell, terminal),
     uname: createUname(kernel, shell, terminal),
     umount: createUmount(kernel, shell, terminal),
     unexpand: createUnexpand(kernel, shell, terminal),
@@ -272,7 +282,9 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     zip: createZip(kernel, shell, terminal),
     unzip: createUnzip(kernel, shell, terminal),
     video: createVideo(kernel, shell, terminal),
-    view: createView(kernel, shell, terminal)
+    view: createView(kernel, shell, terminal),
+    vim: createVim(kernel, shell, terminal),
+    git: createGit(kernel, shell, terminal)
   }
 }