@ecmaos/coreutils 0.1.4 → 0.2.0

package/src/commands/hex.ts

@@ -1,44 +1,111 @@
 import path from 'path'
-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'
 
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: hex [FILE]
+Display file contents or stdin in hexadecimal format.
+
+  FILE    the file to display (if omitted, reads from stdin)
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'hex',
-    description: 'Display file contents in hexadecimal format',
+    description: 'Display file contents or stdin in hexadecimal format',
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, description: 'The path to the file to display' }
-    ],
-    run: async (argv: CommandLineOptions, process?: Process) => {
-      const filePath = argv.path as string | undefined
-
-      if (!filePath) {
-        await writelnStderr(process, terminal, 'Usage: hex <file>')
-        return 1
+    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 fullPath = path.resolve(shell.cwd, filePath)
+      const firstArg = argv.length > 0 ? argv[0] : undefined
+      const filePath = firstArg !== undefined && !firstArg.startsWith('-') ? firstArg : undefined
+      let data: Uint8Array
 
       try {
-        const exists = await shell.context.fs.promises.exists(fullPath)
-        if (!exists) {
-          await writelnStderr(process, terminal, `hex: ${filePath}: No such file or directory`)
-          return 1
-        }
+        if (!filePath) {
+          if (!process.stdin) {
+            await writelnStderr(process, terminal, 'Usage: hex <file>')
+            await writelnStderr(process, terminal, '   or: <command> | hex')
+            return 1
+          }
 
-        const stats = await shell.context.fs.promises.stat(fullPath)
-        if (stats.isDirectory()) {
-          await writelnStderr(process, terminal, `hex: ${filePath}: Is a directory`)
-          return 1
-        }
+          if (process.stdinIsTTY) {
+            await writelnStderr(process, terminal, 'Usage: hex <file>')
+            await writelnStderr(process, terminal, '   or: <command> | hex')
+            return 1
+          }
 
-        const data = await shell.context.fs.promises.readFile(fullPath)
+          const reader = process.stdin.getReader()
+          const chunks: Uint8Array[] = []
+
+          try {
+            const first = await reader.read()
+            
+            if (first.done && !first.value) {
+              await writelnStderr(process, terminal, 'Usage: hex <file>')
+              await writelnStderr(process, terminal, '   or: <command> | hex')
+              return 1
+            }
+            
+            if (first.value) {
+              chunks.push(first.value)
+            }
+            
+            if (!first.done) {
+              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)
+          if (totalLength === 0) {
+            await writelnStderr(process, terminal, 'Usage: hex <file>')
+            await writelnStderr(process, terminal, '   or: <command> | hex')
+            return 1
+          }
+
+          data = new Uint8Array(totalLength)
+          let offset = 0
+          for (const chunk of chunks) {
+            data.set(chunk, offset)
+            offset += chunk.length
+          }
+        } else {
+          const fullPath = path.resolve(shell.cwd, filePath)
+
+          const exists = await shell.context.fs.promises.exists(fullPath)
+          if (!exists) {
+            await writelnStderr(process, terminal, `hex: ${filePath}: No such file or directory`)
+            return 1
+          }
+
+          const stats = await shell.context.fs.promises.stat(fullPath)
+          if (stats.isDirectory()) {
+            await writelnStderr(process, terminal, `hex: ${filePath}: Is a directory`)
+            return 1
+          }
+
+          data = await shell.context.fs.promises.readFile(fullPath)
+        }
         const bytesPerLine = 16
 
         for (let offset = 0; offset < data.length; offset += bytesPerLine) {
@@ -84,7 +151,8 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
         return 0
       } catch (error) {
-        await writelnStderr(process, terminal, `hex: ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        const errorPath = filePath || 'stdin'
+        await writelnStderr(process, terminal, `hex: ${errorPath}: ${error instanceof Error ? error.message : 'Unknown error'}`)
         return 1
       }
     }

package/src/commands/id.ts

@@ -0,0 +1,94 @@
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStdout } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: id [OPTION]...
+Print user and group IDs.
+
+  -u, --user     print only the effective user ID
+  -g, --group    print only the effective group ID
+  -G, --groups   print all group IDs
+  -n, --name     print names instead of numeric IDs
+  --help         display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'id',
+    description: 'Print user and group IDs',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      let userOnly = false
+      let groupOnly = false
+      let groupsOnly = false
+      let nameOnly = false
+
+      for (const arg of argv) {
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-u' || arg === '--user') {
+          userOnly = true
+        } else if (arg === '-g' || arg === '--group') {
+          groupOnly = true
+        } else if (arg === '-G' || arg === '--groups') {
+          groupsOnly = true
+        } else if (arg === '-n' || arg === '--name') {
+          nameOnly = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('u')) userOnly = true
+          if (flags.includes('g')) groupOnly = true
+          if (flags.includes('G')) groupsOnly = true
+          if (flags.includes('n')) nameOnly = true
+          const invalidFlags = flags.filter(f => !['u', 'g', 'G', 'n'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStdout(process, terminal, `id: invalid option -- '${invalidFlags[0]}'`)
+            return 1
+          }
+        }
+      }
+
+      const user = kernel.users.get(shell.credentials.uid)
+      const group = kernel.users.get(shell.credentials.gid)
+      const groups = shell.credentials.groups || []
+
+      let output = ''
+
+      if (userOnly) {
+        output = nameOnly ? (user?.username || shell.credentials.uid.toString()) : shell.credentials.euid.toString()
+      } else if (groupOnly) {
+        output = nameOnly ? (group?.username || shell.credentials.gid.toString()) : shell.credentials.egid.toString()
+      } else if (groupsOnly) {
+        output = groups.map(gid => {
+          if (nameOnly) {
+            const g = kernel.users.get(gid)
+            return g?.username || gid.toString()
+          }
+          return gid.toString()
+        }).join(' ')
+      } else {
+        const uid = nameOnly ? (user?.username || shell.credentials.uid.toString()) : shell.credentials.uid.toString()
+        const gid = nameOnly ? (group?.username || shell.credentials.gid.toString()) : shell.credentials.gid.toString()
+        const groupsStr = groups.map(gid => {
+          if (nameOnly) {
+            const g = kernel.users.get(gid)
+            return g?.username || gid.toString()
+          }
+          return gid.toString()
+        }).join(',')
+        
+        output = `uid=${uid} gid=${gid} groups=${groupsStr}`
+      }
+
+      await writelnStdout(process, terminal, output)
+      return 0
+    }
+  })
+}

package/src/commands/join.ts

@@ -0,0 +1,162 @@
+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: join [OPTION]... FILE1 FILE2
+Join lines of two files on a common field.
+
+  -1 FIELD    join on this FIELD of file 1
+  -2 FIELD    join on this FIELD of file 2
+  -t CHAR     use CHAR as input and output field separator
+  --help      display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'join',
+    description: 'Join lines of two files on a common field',
+    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[] = []
+      let field1 = 1
+      let field2 = 1
+      let delimiter = ' '
+
+      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 === '-1' && i + 1 < argv.length) {
+          const nextArg = argv[++i]
+          if (nextArg !== undefined) {
+            field1 = parseInt(nextArg, 10) || 1
+          }
+        } else if (arg === '-2' && i + 1 < argv.length) {
+          const nextArg = argv[++i]
+          if (nextArg !== undefined) {
+            field2 = parseInt(nextArg, 10) || 1
+          }
+        } else if (arg.startsWith('-t')) {
+          delimiter = arg.slice(2) || ' '
+        } else if (arg === '-t' && i + 1 < argv.length) {
+          const nextArg = argv[++i]
+          if (nextArg !== undefined) {
+            delimiter = nextArg
+          }
+        } else if (!arg.startsWith('-')) {
+          if (files.length < 2) {
+            files.push(arg)
+          }
+        }
+      }
+
+      if (files.length !== 2) {
+        await writelnStderr(process, terminal, 'join: exactly two files must be specified')
+        return 1
+      }
+
+      const file1 = files[0]
+      const file2 = files[1]
+      if (!file1 || !file2) {
+        await writelnStderr(process, terminal, 'join: exactly two files must be specified')
+        return 1
+      }
+
+      const writer = process.stdout.getWriter()
+
+      const readFileLines = async (filePath: string): Promise<string[]> => {
+        if (filePath.startsWith('/dev')) {
+          throw new Error('cannot join device files')
+        }
+
+        let interrupted = false
+        const interruptHandler = () => { interrupted = true }
+        kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+        try {
+          const handle = await shell.context.fs.promises.open(filePath, 'r')
+          const stat = await shell.context.fs.promises.stat(filePath)
+
+          const decoder = new TextDecoder()
+          let content = ''
+          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)
+            content += decoder.decode(chunk, { stream: true })
+            bytesRead += readSize
+          }
+
+          const lines = content.split('\n')
+          if (lines[lines.length - 1] === '') {
+            lines.pop()
+          }
+          return lines
+        } finally {
+          kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+        }
+      }
+
+      try {
+        const fullPath1 = path.resolve(shell.cwd || '/', file1)
+        const fullPath2 = path.resolve(shell.cwd || '/', file2)
+
+        const lines1 = await readFileLines(fullPath1)
+        const lines2 = await readFileLines(fullPath2)
+
+        const map1 = new Map<string, string[]>()
+        for (const line of lines1) {
+          const parts = line.split(delimiter)
+          const key = parts[field1 - 1] || ''
+          if (!map1.has(key)) {
+            map1.set(key, [])
+          }
+          map1.get(key)!.push(line)
+        }
+
+        for (const line of lines2) {
+          const parts = line.split(delimiter)
+          const key = parts[field2 - 1] || ''
+          const matches = map1.get(key)
+          if (matches) {
+            for (const match of matches) {
+              const matchParts = match.split(delimiter)
+              const output = [...matchParts, ...parts.slice(field2)].join(delimiter)
+              await writer.write(new TextEncoder().encode(output + '\n'))
+            }
+          }
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `join: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/less.ts

@@ -1,11 +1,19 @@
 import path from 'path'
 import ansi from 'ansi-escape-sequences'
-import type { CommandLineOptions } from 'command-line-args'
 import type { IDisposable } from '@xterm/xterm'
 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: less [OPTION]... FILE
+View file contents interactively.
+
+  FILE    the file to view (if omitted, reads from stdin)
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'less',
@@ -13,21 +21,25 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, description: 'The path to the file to view' }
-    ],
-    run: async (argv: CommandLineOptions, process?: Process) => {
+    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 lines: string[] = []
       let currentLine = 0
       let keyListener: IDisposable | null = null
       let linesRendered = 0
 
       try {
-        if (argv.path) {
-          const filePath = argv.path as string
+        const filePath = argv.length > 0 && argv[0] !== undefined && !argv[0].startsWith('-') ? argv[0] : undefined
+
+        if (filePath) {
           const expandedPath = shell.expandTilde(filePath)
           const fullPath = path.resolve(shell.cwd, expandedPath)
 

package/src/commands/ln.ts

@@ -1,10 +1,22 @@
 import path from 'path'
 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'
 
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: ln [OPTION]... [-T] TARGET LINK_NAME
+   or:  ln [OPTION]... TARGET
+   or:  ln [OPTION]... TARGET... DIRECTORY
+Create links between files.
+
+  -s, --symbolic  make symbolic links instead of hard links
+  -f, --force     remove existing destination files
+  -v, --verbose   print name of each linked file
+  --help          display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'ln',
@@ -12,18 +24,43 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'symbolic', type: Boolean, alias: 's', description: 'Create symbolic links instead of hard links' },
-      { name: 'force', type: Boolean, alias: 'f', description: 'Remove existing destination files' },
-      { name: 'verbose', type: Boolean, alias: 'v', description: 'Print name of each linked file' },
-      { name: 'args', type: String, multiple: true, defaultOption: true, description: 'The target and optional link name' }
-    ],
-    run: async (argv: CommandLineOptions, process?: Process) => {
-      const args = (argv.args as string[]) || []
-      const symbolic = argv.symbolic as boolean || false
-      const force = argv.force as boolean || false
-      const verbose = argv.verbose as boolean || false
+    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
+      }
+
+      const args: string[] = []
+      let symbolic = false
+      let force = false
+      let verbose = false
+
+      for (const arg of argv) {
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-s' || arg === '--symbolic') {
+          symbolic = true
+        } else if (arg === '-f' || arg === '--force') {
+          force = true
+        } else if (arg === '-v' || arg === '--verbose') {
+          verbose = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('s')) symbolic = true
+          if (flags.includes('f')) force = true
+          if (flags.includes('v')) verbose = true
+          const invalidFlags = flags.filter(f => !['s', 'f', 'v'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `ln: invalid option -- '${invalidFlags[0]}'`)
+            return 1
+          }
+        } else {
+          args.push(arg)
+        }
+      }
 
       if (args.length === 0) {
         await writelnStderr(process, terminal, chalk.red('ln: missing file operand'))

package/src/commands/ls.ts

@@ -1,11 +1,18 @@
 import path from 'path'
 import chalk from 'chalk'
 import humanFormat from 'human-format'
-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 } from '../shared/helpers.js'
 
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: ls [OPTION]... [FILE]...
+List information about the FILEs (the current directory by default).
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'ls',
@@ -13,12 +20,15 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, description: 'The path to the directory to list' }
-    ],
-    run: async (argv: CommandLineOptions, process?: Process) => {
-      const target = (argv.path as string) || shell.cwd
+    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
+      }
+
+      const target = argv.length > 0 && argv[0] !== undefined && !argv[0].startsWith('-') ? argv[0] : shell.cwd
       const fullPath = target ? path.resolve(shell.cwd, target === '' ? '.' : target) : shell.cwd
       const stats = await shell.context.fs.promises.stat(fullPath)
       const entries: string[] = stats.isDirectory() ? await shell.context.fs.promises.readdir(fullPath) : [fullPath]
@@ -186,8 +196,10 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
               if (linkInfo) return linkInfo
               
               if (descriptions.has(path.resolve(fullPath, file.name))) return descriptions.get(path.resolve(fullPath, file.name))
-              const ext = file.name.split('.').pop()
-              if (ext && descriptions.has('.' + ext)) return descriptions.get('.' + ext)
+              if (file.name.includes('.')) {
+                const ext = file.name.split('.').pop()
+                if (ext && descriptions.has('.' + ext)) return descriptions.get('.' + ext)
+              }
               if (!file.stats) return ''
               if (file.stats.isBlockDevice() || file.stats.isCharacterDevice()) {
                 // TODO: zenfs `fs.mounts` is deprecated - use a better way of getting device info
@@ -228,4 +240,3 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     }
   })
 }
-

package/src/commands/mkdir.ts

@@ -1,7 +1,15 @@
 import path from 'path'
-import type { CommandLineOptions } from 'command-line-args'
-import type { Kernel, Shell, Terminal } from '@ecmaos/types'
+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: mkdir [OPTION]... DIRECTORY...
+Create the DIRECTORY(ies), if they do not already exist.
+
+  --help  display this help and exit`
+  writelnStdout(process, terminal, usage)
+}
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
@@ -10,16 +18,37 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
     kernel,
     shell,
     terminal,
-    options: [
-      { name: 'help', type: Boolean, description: kernel.i18n.t('Display help') },
-      { name: 'path', type: String, typeLabel: '{underline path}', defaultOption: true, description: 'The path to the directory to create' }
-    ],
-    run: async (argv: CommandLineOptions) => {
-      const target = (argv.path as string) || shell.cwd
-      const fullPath = target ? path.resolve(shell.cwd, target) : shell.cwd
-      await shell.context.fs.promises.mkdir(fullPath)
-      return 0
+    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 (argv.length === 0) {
+        await writelnStderr(process, terminal, 'mkdir: missing operand')
+        await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
+        return 1
+      }
+
+      let hasError = false
+
+      for (const target of argv) {
+        if (!target || target.startsWith('-')) continue
+
+        const fullPath = target ? path.resolve(shell.cwd, target) : shell.cwd
+        
+        try {
+          await shell.context.fs.promises.mkdir(fullPath)
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error)
+          await writelnStderr(process, terminal, `mkdir: ${target}: ${errorMessage}`)
+          hasError = true
+        }
+      }
+
+      return hasError ? 1 : 0
     }
   })
 }
-