@nimbus-sh/core 0.1.0

package/src/substrate/lifo/UPSTREAM.md

@@ -0,0 +1,14 @@
+# LIFO Source
+
+This directory contains Nimbus-maintained LIFO core source used by the Worker
+runtime substrate.
+
+Imported from `lifo-sh/lifo`, `packages/core/src`, commit
+`03de86c340bbf4b9291575f34c0e9e269ac60180`.
+
+The `packages/core` tree at that commit is identical to
+`origin/feat/merged-network` branch head
+`80a1d20ff99f6d38e3ff42eb7a05785055bcfc86`.
+
+Nimbus compiles this source directly into `@nimbus-sh/worker`; it is not a
+separate public package.

package/src/substrate/lifo/commands/archive/gunzip.ts

@@ -0,0 +1,63 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { decompressGzip } from '../../utils/archive.js';
+import { parseArgs } from '../../utils/args.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const spec = {
+  keep: { type: 'boolean' as const, short: 'k' },
+  force: { type: 'boolean' as const, short: 'f' },
+  quiet: { type: 'boolean' as const, short: 'q' },
+  help: { type: 'boolean' as const },
+};
+
+const command: Command = async (ctx) => {
+  const { flags, positional, unknown } = parseArgs(ctx.args, spec);
+  if (flags.help) {
+    ctx.stdout.write('Usage: gunzip [-kfq] file.gz...\n');
+    ctx.stdout.write('  -k, --keep    keep original file\n');
+    ctx.stdout.write('  -f, --force   overwrite an existing output file\n');
+    ctx.stdout.write('  -q, --quiet   suppress warnings\n');
+    return 0;
+  }
+  if (unknown.length > 0) {
+    ctx.stderr.write(`gunzip: invalid option -- '${unknown[0].replace(/^-+/, '')}'\n`);
+    return 1;
+  }
+  const keep = flags.keep === true;
+  const files = positional;
+
+  if (files.length === 0) {
+    ctx.stderr.write('gunzip: missing file operand\n');
+    return 1;
+  }
+
+  let exitCode = 0;
+
+  for (const file of files) {
+    const path = resolve(ctx.cwd, file);
+    try {
+      if (!path.endsWith('.gz')) {
+        ctx.stderr.write(`gunzip: ${file}: unknown suffix -- ignored\n`);
+        exitCode = 1;
+        continue;
+      }
+      const data = ctx.vfs.readFile(path);
+      const decompressed = await decompressGzip(data);
+      const outPath = path.slice(0, -3);
+      ctx.vfs.writeFile(outPath, decompressed);
+      if (!keep) ctx.vfs.unlink(path);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`gunzip: ${file}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;

package/src/substrate/lifo/commands/archive/gzip.ts

@@ -0,0 +1,76 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { compressGzip, decompressGzip } from '../../utils/archive.js';
+import { parseArgs } from '../../utils/args.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const spec = {
+  keep: { type: 'boolean' as const, short: 'k' },
+  decompress: { type: 'boolean' as const, short: 'd' },
+  force: { type: 'boolean' as const, short: 'f' },
+  quiet: { type: 'boolean' as const, short: 'q' },
+  help: { type: 'boolean' as const },
+};
+
+const command: Command = async (ctx) => {
+  const { flags, positional, unknown } = parseArgs(ctx.args, spec);
+  if (flags.help) {
+    ctx.stdout.write('Usage: gzip [-kdfq] file...\n');
+    ctx.stdout.write('  -k, --keep         keep original file\n');
+    ctx.stdout.write('  -d, --decompress   decompress\n');
+    ctx.stdout.write('  -f, --force        overwrite an existing output file\n');
+    ctx.stdout.write('  -q, --quiet        suppress warnings\n');
+    return 0;
+  }
+  // Compression levels are accepted and ignored: the gzip stream this VFS
+  // writes comes from CompressionStream, which exposes no level control.
+  const rejected = unknown.filter((o) => !/^-[1-9]$/.test(o));
+  if (rejected.length > 0) {
+    ctx.stderr.write(`gzip: invalid option -- '${rejected[0].replace(/^-+/, '')}'\n`);
+    return 1;
+  }
+  const keep = flags.keep === true;
+  const decompress = flags.decompress === true;
+  const files = positional;
+
+  if (files.length === 0) {
+    ctx.stderr.write('gzip: missing file operand\n');
+    return 1;
+  }
+
+  let exitCode = 0;
+
+  for (const file of files) {
+    const path = resolve(ctx.cwd, file);
+    try {
+      if (decompress) {
+        if (!path.endsWith('.gz')) {
+          ctx.stderr.write(`gzip: ${file}: unknown suffix -- ignored\n`);
+          exitCode = 1;
+          continue;
+        }
+        const data = ctx.vfs.readFile(path);
+        const decompressed = await decompressGzip(data);
+        const outPath = path.slice(0, -3);
+        ctx.vfs.writeFile(outPath, decompressed);
+        if (!keep) ctx.vfs.unlink(path);
+      } else {
+        const data = ctx.vfs.readFile(path);
+        const compressed = await compressGzip(data);
+        ctx.vfs.writeFile(path + '.gz', compressed);
+        if (!keep) ctx.vfs.unlink(path);
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`gzip: ${file}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;

package/src/substrate/lifo/commands/archive/tar.ts

@@ -0,0 +1,157 @@
+import type { Command } from '../types.js';
+import { resolve, dirname } from '../../utils/path.js';
+import { createTar, parseTar, compressGzip, decompressGzip, collectFiles } from '../../utils/archive.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const command: Command = async (ctx) => {
+  let create = false;
+  let extract = false;
+  let list = false;
+  let gzipFlag = false;
+  let verbose = false;
+  let archiveFile = '';
+  let changeDir = '';
+  const files: string[] = [];
+
+  // Parse args manually (tar uses combined flags like -czf)
+  let i = 0;
+  while (i < ctx.args.length) {
+    const arg = ctx.args[i];
+
+    if (arg === '--help') {
+      ctx.stdout.write('Usage: tar [-c|-x|-t] [-z] [-v] [-f file] [-C dir] [files...]\n');
+      ctx.stdout.write('  -c   create archive\n');
+      ctx.stdout.write('  -x   extract archive\n');
+      ctx.stdout.write('  -t   list archive contents\n');
+      ctx.stdout.write('  -z   gzip compression\n');
+      ctx.stdout.write('  -v   verbose\n');
+      ctx.stdout.write('  -f   archive file\n');
+      ctx.stdout.write('  -C   change directory\n');
+      return 0;
+    }
+
+    if (arg.startsWith('-') && arg !== '-') {
+      const chars = arg.slice(1);
+      for (let j = 0; j < chars.length; j++) {
+        switch (chars[j]) {
+          case 'c': create = true; break;
+          case 'x': extract = true; break;
+          case 't': list = true; break;
+          case 'z': gzipFlag = true; break;
+          case 'v': verbose = true; break;
+          case 'f': {
+            const rest = chars.slice(j + 1);
+            archiveFile = rest || ctx.args[++i] || '';
+            j = chars.length; // break out of inner loop
+            break;
+          }
+          case 'C': {
+            const rest = chars.slice(j + 1);
+            changeDir = rest || ctx.args[++i] || '';
+            j = chars.length;
+            break;
+          }
+          default:
+            ctx.stderr.write(`tar: unknown option: -${chars[j]}\n`);
+            return 1;
+        }
+      }
+    } else {
+      files.push(arg);
+    }
+    i++;
+  }
+
+  const modeCount = [create, extract, list].filter(Boolean).length;
+  if (modeCount === 0) {
+    ctx.stderr.write('tar: must specify one of -c, -x, -t\n');
+    return 1;
+  }
+  if (modeCount > 1) {
+    ctx.stderr.write('tar: conflicting options\n');
+    return 1;
+  }
+
+  if (!archiveFile) {
+    ctx.stderr.write('tar: -f is required\n');
+    return 1;
+  }
+
+  const archivePath = resolve(ctx.cwd, archiveFile);
+  const targetDir = changeDir ? resolve(ctx.cwd, changeDir) : ctx.cwd;
+
+  try {
+    if (create) {
+      if (files.length === 0) {
+        ctx.stderr.write('tar: no files to archive\n');
+        return 1;
+      }
+
+      const entries = collectFiles(ctx.vfs, targetDir, files);
+      let data = createTar(entries);
+
+      if (gzipFlag) {
+        data = await compressGzip(data);
+      }
+
+      ctx.vfs.writeFile(archivePath, data);
+
+      if (verbose) {
+        for (const entry of entries) {
+          ctx.stdout.write(`${entry.path}\n`);
+        }
+      }
+    } else if (extract) {
+      let data = ctx.vfs.readFile(archivePath);
+
+      if (gzipFlag) {
+        data = await decompressGzip(data);
+      }
+
+      const entries = parseTar(data);
+
+      // Ensure target dir exists
+      if (changeDir) {
+        try { ctx.vfs.mkdir(targetDir, { recursive: true }); } catch { /* exists */ }
+      }
+
+      for (const entry of entries) {
+        const entryPath = resolve(targetDir, entry.path);
+
+        if (entry.type === 'directory') {
+          try { ctx.vfs.mkdir(entryPath, { recursive: true }); } catch { /* exists */ }
+        } else {
+          // Ensure parent dir exists
+          const parent = dirname(entryPath);
+          try { ctx.vfs.mkdir(parent, { recursive: true }); } catch { /* exists */ }
+          ctx.vfs.writeFile(entryPath, entry.data);
+        }
+
+        if (verbose) {
+          ctx.stdout.write(`${entry.path}\n`);
+        }
+      }
+    } else if (list) {
+      let data = ctx.vfs.readFile(archivePath);
+
+      if (gzipFlag) {
+        data = await decompressGzip(data);
+      }
+
+      const entries = parseTar(data);
+      for (const entry of entries) {
+        ctx.stdout.write(`${entry.path}${entry.type === 'directory' ? '/' : ''}\n`);
+      }
+    }
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`tar: ${e.message}\n`);
+      return 2;
+    }
+    throw e;
+  }
+
+  return 0;
+};
+
+export default command;

package/src/substrate/lifo/commands/archive/unzip.ts

@@ -0,0 +1,112 @@
+import type { Command } from '../types.js';
+import { resolve, dirname } from '../../utils/path.js';
+import { parseZip } from '../../utils/archive.js';
+import { parseArgs } from '../../utils/args.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const spec = {
+  list: { type: 'boolean' as const, short: 'l' },
+  overwrite: { type: 'boolean' as const, short: 'o' },
+  'never-overwrite': { type: 'boolean' as const, short: 'n' },
+  quiet: { type: 'boolean' as const, short: 'q' },
+  junk: { type: 'boolean' as const, short: 'j' },
+  pipe: { type: 'boolean' as const, short: 'p' },
+  dir: { type: 'string' as const, short: 'd' },
+  help: { type: 'boolean' as const },
+};
+
+const command: Command = async (ctx) => {
+  const { flags, positional, unknown } = parseArgs(ctx.args, spec);
+  if (flags.help) {
+    ctx.stdout.write('Usage: unzip [-lonqjp] [-d dir] archive.zip\n');
+    ctx.stdout.write('  -l       list contents\n');
+    ctx.stdout.write('  -o       overwrite existing files without prompting\n');
+    ctx.stdout.write('  -n       never overwrite existing files\n');
+    ctx.stdout.write('  -q       quiet\n');
+    ctx.stdout.write('  -j       junk paths, extract every entry into one directory\n');
+    ctx.stdout.write('  -p       extract to stdout\n');
+    ctx.stdout.write('  -d dir   extract to directory\n');
+    return 0;
+  }
+  if (unknown.length > 0) {
+    ctx.stderr.write(`unzip: invalid option: ${unknown[0]}\n`);
+    return 1;
+  }
+
+  const archiveFile = positional[0];
+  if (!archiveFile) {
+    ctx.stderr.write('unzip: missing archive operand\n');
+    return 1;
+  }
+
+  const listOnly = flags.list === true;
+  const toStdout = flags.pipe === true;
+  const quiet = flags.quiet === true || toStdout;
+  const junkPaths = flags.junk === true;
+  const neverOverwrite = flags['never-overwrite'] === true;
+  const destDir = typeof flags.dir === 'string' ? flags.dir : '';
+  const archivePath = resolve(ctx.cwd, archiveFile);
+  const targetDir = destDir ? resolve(ctx.cwd, destDir) : ctx.cwd;
+
+  try {
+    const data = ctx.vfs.readFile(archivePath);
+    const entries = parseZip(data);
+
+    if (listOnly) {
+      ctx.stdout.write('  Length      Name\n');
+      ctx.stdout.write('---------  ----\n');
+      let totalSize = 0;
+      for (const entry of entries) {
+        const size = entry.data.length;
+        totalSize += size;
+        const path = entry.isDirectory ? entry.path + '/' : entry.path;
+        ctx.stdout.write(`${String(size).padStart(9)}  ${path}\n`);
+      }
+      ctx.stdout.write('---------  ----\n');
+      ctx.stdout.write(`${String(totalSize).padStart(9)}  ${entries.length} file(s)\n`);
+      return 0;
+    }
+
+    if (destDir) {
+      try { ctx.vfs.mkdir(targetDir, { recursive: true }); } catch { /* exists */ }
+    }
+
+    for (const entry of entries) {
+      const name = junkPaths ? entry.path.slice(entry.path.lastIndexOf('/') + 1) : entry.path;
+      if (entry.isDirectory) {
+        if (junkPaths) continue;
+        const entryPath = resolve(targetDir, name);
+        try { ctx.vfs.mkdir(entryPath, { recursive: true }); } catch { /* exists */ }
+        if (!quiet) ctx.stdout.write(`  extracting: ${entry.path}/\n`);
+        continue;
+      }
+
+      if (toStdout) {
+        writeBytes(ctx.stdout, entry.data);
+        continue;
+      }
+
+      const entryPath = resolve(targetDir, name);
+      if (neverOverwrite && ctx.vfs.exists(entryPath)) continue;
+      const parent = dirname(entryPath);
+      try { ctx.vfs.mkdir(parent, { recursive: true }); } catch { /* exists */ }
+      ctx.vfs.writeFile(entryPath, entry.data);
+      if (!quiet) ctx.stdout.write(`  extracting: ${entry.path}\n`);
+    }
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`unzip: ${e.message}\n`);
+      return 1;
+    }
+    throw e;
+  }
+
+  return 0;
+};
+
+function writeBytes(stdout: { write(text: string): void; writeBytes?(bytes: Uint8Array): void }, bytes: Uint8Array): void {
+  if (stdout.writeBytes) stdout.writeBytes(bytes);
+  else stdout.write(new TextDecoder().decode(bytes));
+}
+
+export default command;

package/src/substrate/lifo/commands/archive/zip.ts

@@ -0,0 +1,70 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { createZip, collectFiles } from '../../utils/archive.js';
+import type { ZipEntry } from '../../utils/archive.js';
+import { parseArgs } from '../../utils/args.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const spec = {
+  recursive: { type: 'boolean' as const, short: 'r' },
+  quiet: { type: 'boolean' as const, short: 'q' },
+  junk: { type: 'boolean' as const, short: 'j' },
+  help: { type: 'boolean' as const },
+};
+
+const command: Command = async (ctx) => {
+  const { flags, positional, unknown } = parseArgs(ctx.args, spec);
+  if (flags.help || ctx.args.length === 0) {
+    ctx.stdout.write('Usage: zip [-rqj] archive.zip file1 [file2 ...]\n');
+    ctx.stdout.write('  -r   recurse into directories\n');
+    ctx.stdout.write('  -q   quiet\n');
+    ctx.stdout.write('  -j   junk paths, store each entry by basename\n');
+    return ctx.args.length === 0 ? 1 : 0;
+  }
+  // Compression levels are accepted and ignored: entries are stored, not
+  // deflated, so there is no level to honour.
+  const rejected = unknown.filter((o) => !/^-[0-9]$/.test(o));
+  if (rejected.length > 0) {
+    ctx.stderr.write(`zip: invalid option -- '${rejected[0].replace(/^-+/, '')}'\n`);
+    return 1;
+  }
+
+  const archiveFile = positional[0];
+  const files = positional.slice(1);
+
+  if (!archiveFile || files.length === 0) {
+    ctx.stderr.write('zip: no files to archive\n');
+    return 1;
+  }
+
+  const archivePath = resolve(ctx.cwd, archiveFile);
+
+  try {
+    const tarEntries = collectFiles(ctx.vfs, ctx.cwd, files);
+
+    const zipEntries: ZipEntry[] = tarEntries.map((e) => ({
+      path: flags.junk ? e.path.slice(e.path.lastIndexOf('/') + 1) : e.path,
+      data: e.data,
+      isDirectory: e.type === 'directory',
+    }));
+
+    const data = createZip(zipEntries);
+    ctx.vfs.writeFile(archivePath, data);
+
+    if (!flags.quiet) {
+      for (const entry of zipEntries) {
+        ctx.stdout.write(`  adding: ${entry.path}${entry.isDirectory ? '/' : ''}\n`);
+      }
+    }
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`zip: ${e.message}\n`);
+      return 1;
+    }
+    throw e;
+  }
+
+  return 0;
+};
+
+export default command;

package/src/substrate/lifo/commands/fs/basename.ts

@@ -0,0 +1,16 @@
+import type { Command } from '../types.js';
+import { basename as pathBasename } from '../../utils/path.js';
+
+const command: Command = async (ctx) => {
+  if (ctx.args.length === 0) {
+    ctx.stderr.write('basename: missing operand\n');
+    return 1;
+  }
+
+  const name = ctx.args[0];
+  const suffix = ctx.args[1];
+  ctx.stdout.write(pathBasename(name, suffix) + '\n');
+  return 0;
+};
+
+export default command;

package/src/substrate/lifo/commands/fs/cat.ts

@@ -0,0 +1,54 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { SinkWriter, streamRange } from '../../../../_shared/byte-stream.js';
+
+const command: Command = async (ctx) => {
+  if (ctx.args.length === 0) {
+    // Read from stdin if available (enables piping: echo hi | cat)
+    if (ctx.stdin) {
+      const content = await ctx.stdin.readAll();
+      ctx.stdout.write(content);
+      return 0;
+    }
+    ctx.stderr.write('cat: missing operand\n');
+    return 1;
+  }
+
+  let exitCode = 0;
+  // One writer across all operands: cat concatenates byte streams, so a
+  // multi-byte character split across an operand boundary stays one character.
+  const writer = new SinkWriter(ctx.stdout);
+
+  for (const arg of ctx.args) {
+    const path = resolve(ctx.cwd, arg);
+    try {
+      const stat = ctx.vfs.stat(path);
+      if (stat.type === 'directory') throw new VFSError('EISDIR', `'${arg}': is a directory`);
+      if (stat.size > 0) {
+        // A regular file's size is its exact extent — copy precisely that, in
+        // bounded steps, so a large file never becomes a large buffer.
+        streamRange((offset, length) => ctx.vfs.readRange(path, offset, length), writer, {
+          length: stat.size,
+          signal: ctx.signal,
+        });
+      } else {
+        // Empty files, /dev/null and synthesised /proc entries. Character
+        // devices with no end reject this unbounded read by design.
+        writer.write(ctx.vfs.readFile(path));
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`cat: ${arg}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  writer.end();
+  return exitCode;
+};
+
+export default command;

package/src/substrate/lifo/commands/fs/chmod.ts

@@ -0,0 +1,110 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+interface SymbolicClause {
+  who: string;        // subset of 'ugoa'; '' means 'a'
+  op: '+' | '-' | '=';
+  perms: string;      // subset of 'rwxX'
+}
+
+export type ModeSpec =
+  | { kind: 'absolute'; mode: number }
+  | { kind: 'symbolic'; clauses: SymbolicClause[] };
+
+/** Parse an octal (755, 0644) or symbolic (+x, u+x, go-w, a=rx, a+rX) mode spec. */
+export function parseModeSpec(spec: string): ModeSpec | null {
+  if (/^[0-7]{1,4}$/.test(spec)) {
+    return { kind: 'absolute', mode: parseInt(spec, 8) };
+  }
+  const clauses: SymbolicClause[] = [];
+  for (const clause of spec.split(',')) {
+    const match = clause.match(/^([ugoa]*)([+\-=])([rwxX]*)$/);
+    if (!match) return null;
+    clauses.push({ who: match[1], op: match[2] as SymbolicClause['op'], perms: match[3] });
+  }
+  return clauses.length > 0 ? { kind: 'symbolic', clauses } : null;
+}
+
+const PERM_BITS: Record<string, number> = { r: 4, w: 2, x: 1 };
+const WHO_SHIFTS: Record<string, number> = { u: 6, g: 3, o: 0 };
+
+/**
+ * Apply a parsed mode spec to the current permission bits. `isDir`
+ * feeds the conditional-execute perm: 'X' grants x only to directories
+ * and files that already have some exec bit (chmod(1) semantics —
+ * `chmod -R a+rX` is a staple of npm postinstall scripts).
+ */
+export function applyModeSpec(spec: ModeSpec, currentMode: number, isDir = false): number {
+  if (spec.kind === 'absolute') return spec.mode & 0o7777;
+  let mode = currentMode & 0o7777;
+  for (const { who, op, perms } of spec.clauses) {
+    const targets = who === '' || who.includes('a') ? 'ugo' : who;
+    let bits = 0;
+    for (const p of perms) bits |= PERM_BITS[p] ?? 0;
+    if (perms.includes('X') && (isDir || (currentMode & 0o111) !== 0)) bits |= 1;
+    let mask = 0;
+    let selected = 0;
+    for (const w of targets) {
+      mask |= 7 << WHO_SHIFTS[w];
+      selected |= bits << WHO_SHIFTS[w];
+    }
+    if (op === '+') mode |= selected;
+    else if (op === '-') mode &= ~selected;
+    else mode = (mode & ~mask) | selected;
+  }
+  return mode;
+}
+
+const command: Command = async (ctx) => {
+  let recursive = false;
+  let modeStr = '';
+  const files: string[] = [];
+
+  for (const arg of ctx.args) {
+    if (!modeStr && (arg === '-R' || arg === '-r' || arg === '--recursive')) {
+      recursive = true;
+    } else if (!modeStr) {
+      modeStr = arg;
+    } else {
+      files.push(arg);
+    }
+  }
+
+  if (!modeStr || files.length === 0) {
+    ctx.stderr.write('chmod: missing operand\n');
+    return 1;
+  }
+
+  const spec = parseModeSpec(modeStr);
+  if (!spec) {
+    ctx.stderr.write(`chmod: invalid mode: '${modeStr}'\n`);
+    return 1;
+  }
+
+  let exitCode = 0;
+
+  function applyChmod(filePath: string): void {
+    const st = ctx.vfs.stat(filePath);
+    ctx.vfs.chmod(filePath, applyModeSpec(spec!, st.mode, st.type === 'directory'));
+    if (recursive && st.type === 'directory') {
+      for (const entry of ctx.vfs.readdir(filePath)) {
+        applyChmod(filePath === '/' ? '/' + entry.name : filePath + '/' + entry.name);
+      }
+    }
+  }
+
+  for (const file of files) {
+    try {
+      applyChmod(resolve(ctx.cwd, file));
+    } catch (e) {
+      const message = e instanceof VFSError || e instanceof Error ? e.message : String(e);
+      ctx.stderr.write(`chmod: cannot access '${file}': ${message}\n`);
+      exitCode = 1;
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;