@nimbus-sh/core 0.1.0

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

@@ -0,0 +1,45 @@
+import { parseChownOwnership } from '../../../../shell/unix-accounts.js';
+import type { Command } from '../types.js';
+import { parseArgs } from '../../utils/args.js';
+import { resolve } from '../../utils/path.js';
+
+const spec = {
+  recursive: { type: 'boolean' as const, short: 'R' },
+};
+
+const command: Command = async (ctx) => {
+  const { flags, positional } = parseArgs(ctx.args, spec);
+  if (positional.length < 2) {
+    ctx.stderr.write('chown: missing operand\n');
+    return 1;
+  }
+  const vfs = ctx.vfs;
+
+  let requested: { uid: number | null; gid: number | null };
+  try {
+    requested = parseChownOwnership(vfs, positional[0]);
+  } catch (error) {
+    ctx.stderr.write(`chown: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+
+  const apply = (path: string): void => {
+    if (flags.recursive && vfs.stat(path).type === 'directory') {
+      for (const child of vfs.readdir(path)) apply(resolve(path, child.name));
+    }
+    vfs.chown(path, requested.uid, requested.gid);
+  };
+
+  let exitCode = 0;
+  for (const file of positional.slice(1)) {
+    try {
+      apply(resolve(ctx.cwd, file));
+    } catch (error) {
+      ctx.stderr.write(`chown: ${file}: ${error instanceof Error ? error.message : String(error)}\n`);
+      exitCode = 1;
+    }
+  }
+  return exitCode;
+};
+
+export default command;

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

@@ -0,0 +1,33 @@
+import type { Command } from '../types.js';
+import { resolve, basename } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const command: Command = async (ctx) => {
+  if (ctx.args.length < 2) {
+    ctx.stderr.write('cp: missing operand\n');
+    return 1;
+  }
+
+  const src = resolve(ctx.cwd, ctx.args[0]);
+  let dest = resolve(ctx.cwd, ctx.args[1]);
+
+  try {
+    // If dest is a directory, copy into it
+    if (ctx.vfs.exists(dest)) {
+      const stat = ctx.vfs.stat(dest);
+      if (stat.type === 'directory') {
+        dest = resolve(dest, basename(src));
+      }
+    }
+    ctx.vfs.copyFile(src, dest);
+    return 0;
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`cp: ${e.message}\n`);
+      return 1;
+    }
+    throw e;
+  }
+};
+
+export default command;

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

@@ -0,0 +1,56 @@
+import type { Command } from '../types.js';
+
+function humanSize(bytes: number): string {
+  if (bytes < 1024) return bytes + 'B';
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + 'K';
+  if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + 'M';
+  return (bytes / (1024 * 1024 * 1024)).toFixed(1) + 'G';
+}
+
+const command: Command = async (ctx) => {
+  let human = false;
+
+  for (const arg of ctx.args) {
+    if (arg === '-h') human = true;
+  }
+
+  // Walk the entire VFS to count files and bytes
+  let totalFiles = 0;
+  let totalBytes = 0;
+
+  function walk(dirPath: string): void {
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === '/' ? '/' + entry.name : dirPath + '/' + entry.name;
+        if (entry.type === 'file') {
+          totalFiles++;
+          const st = ctx.vfs.stat(fullPath);
+          totalBytes += st.size;
+        } else {
+          walk(fullPath);
+        }
+      }
+    } catch {
+      // skip
+    }
+  }
+
+  walk('/');
+
+  const totalSpace = 256 * 1024 * 1024; // 256MB virtual space
+  const used = totalBytes;
+  const avail = totalSpace - used;
+
+  if (human) {
+    ctx.stdout.write('Filesystem      Size  Used  Avail  Use%  Mounted on\n');
+    ctx.stdout.write(`vfs             ${humanSize(totalSpace)}  ${humanSize(used)}  ${humanSize(avail)}  ${Math.round((used / totalSpace) * 100)}%    /\n`);
+  } else {
+    ctx.stdout.write('Filesystem      1K-blocks    Used    Available  Use%  Mounted on\n');
+    ctx.stdout.write(`vfs             ${Math.round(totalSpace / 1024)}    ${Math.round(used / 1024)}    ${Math.round(avail / 1024)}  ${Math.round((used / totalSpace) * 100)}%    /\n`);
+  }
+
+  return 0;
+};
+
+export default command;

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

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

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

@@ -0,0 +1,100 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+function humanSize(bytes: number): string {
+  if (bytes < 1024) return bytes + 'B';
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + 'K';
+  if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + 'M';
+  return (bytes / (1024 * 1024 * 1024)).toFixed(1) + 'G';
+}
+
+const command: Command = async (ctx) => {
+  let human = false;
+  let summaryOnly = false;
+  const paths: string[] = [];
+
+  for (const arg of ctx.args) {
+    if (arg === '-h') human = true;
+    else if (arg === '-s') summaryOnly = true;
+    else paths.push(arg);
+  }
+
+  if (paths.length === 0) paths.push('.');
+
+  function calcSize(dirPath: string): number {
+    let total = 0;
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === '/' ? '/' + entry.name : dirPath + '/' + entry.name;
+        if (entry.type === 'file') {
+          const st = ctx.vfs.stat(fullPath);
+          total += st.size;
+        } else {
+          total += calcSize(fullPath);
+        }
+      }
+    } catch {
+      // skip inaccessible
+    }
+    return total;
+  }
+
+  function walkAndPrint(dirPath: string, name: string): number {
+    let total = 0;
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === '/' ? '/' + entry.name : dirPath + '/' + entry.name;
+        const displayPath = name === '/' ? '/' + entry.name : name + '/' + entry.name;
+        if (entry.type === 'file') {
+          const st = ctx.vfs.stat(fullPath);
+          total += st.size;
+        } else {
+          const subSize = walkAndPrint(fullPath, displayPath);
+          total += subSize;
+        }
+      }
+    } catch {
+      // skip
+    }
+    if (!summaryOnly) {
+      const display = human ? humanSize(total) : String(total);
+      ctx.stdout.write(display + '\t' + name + '\n');
+    }
+    return total;
+  }
+
+  let exitCode = 0;
+
+  for (const p of paths) {
+    const absPath = resolve(ctx.cwd, p);
+    try {
+      const st = ctx.vfs.stat(absPath);
+      if (st.type === 'file') {
+        const display = human ? humanSize(st.size) : String(st.size);
+        ctx.stdout.write(display + '\t' + p + '\n');
+      } else {
+        if (summaryOnly) {
+          const total = calcSize(absPath);
+          const display = human ? humanSize(total) : String(total);
+          ctx.stdout.write(display + '\t' + p + '\n');
+        } else {
+          walkAndPrint(absPath, p);
+        }
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`du: ${p}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;

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

@@ -0,0 +1,90 @@
+import type { Command } from '../types.js';
+import { resolve, extname } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const extTypes: Record<string, string> = {
+  '.txt': 'ASCII text',
+  '.md': 'Markdown text',
+  '.js': 'JavaScript source',
+  '.ts': 'TypeScript source',
+  '.json': 'JSON data',
+  '.html': 'HTML document',
+  '.css': 'CSS stylesheet',
+  '.sh': 'Shell script',
+  '.py': 'Python script',
+  '.xml': 'XML document',
+  '.yaml': 'YAML data',
+  '.yml': 'YAML data',
+  '.csv': 'CSV data',
+  '.svg': 'SVG image',
+  '.png': 'PNG image data',
+  '.jpg': 'JPEG image data',
+  '.gif': 'GIF image data',
+};
+
+function isText(data: Uint8Array): boolean {
+  // Check if all bytes are valid UTF-8 / printable ASCII
+  for (let i = 0; i < Math.min(data.length, 512); i++) {
+    const b = data[i];
+    // Allow common text bytes: tab, newline, carriage return, printable ASCII
+    if (b === 9 || b === 10 || b === 13) continue;
+    if (b >= 32 && b <= 126) continue;
+    // Allow UTF-8 continuation bytes
+    if (b >= 128) continue;
+    // Control characters that aren't typical in text
+    return false;
+  }
+  return true;
+}
+
+const command: Command = async (ctx) => {
+  if (ctx.args.length === 0) {
+    ctx.stderr.write('file: missing operand\n');
+    return 1;
+  }
+
+  let exitCode = 0;
+
+  for (const arg of ctx.args) {
+    const path = resolve(ctx.cwd, arg);
+    try {
+      const st = ctx.vfs.stat(path);
+
+      if (st.type === 'directory') {
+        ctx.stdout.write(`${arg}: directory\n`);
+        continue;
+      }
+
+      if (st.size === 0) {
+        ctx.stdout.write(`${arg}: empty\n`);
+        continue;
+      }
+
+      // Check by extension first
+      const ext = extname(arg);
+      if (ext && extTypes[ext]) {
+        ctx.stdout.write(`${arg}: ${extTypes[ext]}\n`);
+        continue;
+      }
+
+      // Check content
+      const data = ctx.vfs.readFile(path);
+      if (isText(data)) {
+        ctx.stdout.write(`${arg}: ASCII text\n`);
+      } else {
+        ctx.stdout.write(`${arg}: data\n`);
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`file: ${arg}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;

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

@@ -0,0 +1,76 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { globMatch } from '../../utils/glob.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const command: Command = async (ctx) => {
+  let searchPath = '.';
+  let namePattern = '';
+  let typeFilter = ''; // 'f' or 'd'
+  let maxDepth = Infinity;
+
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === '-name' && i + 1 < ctx.args.length) {
+      namePattern = ctx.args[++i];
+    } else if (arg === '-type' && i + 1 < ctx.args.length) {
+      typeFilter = ctx.args[++i];
+    } else if (arg === '-maxdepth' && i + 1 < ctx.args.length) {
+      maxDepth = parseInt(ctx.args[++i], 10);
+    } else if (!arg.startsWith('-')) {
+      searchPath = arg;
+    }
+  }
+
+  const absPath = resolve(ctx.cwd, searchPath);
+
+  function walk(dirPath: string, depth: number): void {
+    if (depth > maxDepth) return;
+
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === '/' ? '/' + entry.name : dirPath + '/' + entry.name;
+
+        let matches = true;
+        if (namePattern) {
+          matches = globMatch(namePattern, entry.name);
+        }
+        if (typeFilter) {
+          if (typeFilter === 'f' && entry.type !== 'file') matches = false;
+          if (typeFilter === 'd' && entry.type !== 'directory') matches = false;
+        }
+
+        if (matches) {
+          ctx.stdout.write(fullPath + '\n');
+        }
+
+        if (entry.type === 'directory') {
+          walk(fullPath, depth + 1);
+        }
+      }
+    } catch {
+      // skip inaccessible dirs
+    }
+  }
+
+  try {
+    const stat = ctx.vfs.stat(absPath);
+    if (stat.type !== 'directory') {
+      // If it's a file, just check if it matches
+      ctx.stdout.write(absPath + '\n');
+      return 0;
+    }
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`find: '${searchPath}': ${e.message}\n`);
+      return 1;
+    }
+    throw e;
+  }
+
+  walk(absPath, 1);
+  return 0;
+};
+
+export default command;

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

@@ -0,0 +1,19 @@
+import type { Command } from '../types.js';
+
+const command: Command = async (ctx) => {
+  let symlink = false;
+
+  for (const arg of ctx.args) {
+    if (arg === '-s') symlink = true;
+  }
+
+  if (symlink) {
+    ctx.stderr.write('ln: symbolic links are not supported in Lifo VFS\n');
+  } else {
+    ctx.stderr.write('ln: hard links are not supported in Lifo VFS\n');
+  }
+
+  return 1;
+};
+
+export default command;

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

@@ -0,0 +1,164 @@
+import type { Command } from '../types.js';
+import type { FileType } from '../../kernel/vfs/types.js';
+import { parseArgs } from '../../utils/args.js';
+import { resolve } from '../../utils/path.js';
+import { BOLD, BLUE, RESET } from '../../utils/colors.js';
+import { VFSError, fileTypeChar } from '../../kernel/vfs/index.js';
+
+const spec = {
+  long: { type: 'boolean' as const, short: 'l' },
+  all: { type: 'boolean' as const, short: 'a' },
+  one: { type: 'boolean' as const, short: '1' },
+};
+
+function formatMode(mode: number, isDir: boolean): string {
+  const d = fileTypeChar(mode, isDir ? 'directory' : 'file');
+  const perms = [
+    (mode & 0o400) ? 'r' : '-',
+    (mode & 0o200) ? 'w' : '-',
+    (mode & 0o100) ? 'x' : '-',
+    (mode & 0o040) ? 'r' : '-',
+    (mode & 0o020) ? 'w' : '-',
+    (mode & 0o010) ? 'x' : '-',
+    (mode & 0o004) ? 'r' : '-',
+    (mode & 0o002) ? 'w' : '-',
+    (mode & 0o001) ? 'x' : '-',
+  ].join('');
+  return d + perms;
+}
+
+function formatDate(ts: number): string {
+  const d = new Date(ts);
+  const months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+  const mon = months[d.getMonth()];
+  const day = String(d.getDate()).padStart(2, ' ');
+  const hour = String(d.getHours()).padStart(2, '0');
+  const min = String(d.getMinutes()).padStart(2, '0');
+  return `${mon} ${day} ${hour}:${min}`;
+}
+
+interface LsEntry {
+  name: string;
+  type: FileType;
+  size: number;
+  mtime: number;
+  mode: number;
+}
+
+function formatEntry(entry: LsEntry, long: boolean): string {
+  const displayName = entry.type === 'directory'
+    ? `${BOLD}${BLUE}${entry.name}${RESET}`
+    : entry.name;
+
+  if (long) {
+    const mode = formatMode(entry.mode, entry.type === 'directory');
+    const size = String(entry.size).padStart(6, ' ');
+    const date = formatDate(entry.mtime);
+    return `${mode}  1 user user ${size} ${date} ${displayName}\n`;
+  }
+  return displayName;
+}
+
+function listDirectory(
+  path: string, flags: Record<string, string | boolean>, ctx: import('../types.js').CommandContext,
+): LsEntry[] {
+  const entries = ctx.vfs.readdirStat(path);
+  const filtered = (flags.all as boolean)
+    ? entries
+    : entries.filter((e) => !e.name.startsWith('.'));
+  filtered.sort((a, b) => a.name.localeCompare(b.name));
+  return filtered;
+}
+
+const command: Command = async (ctx) => {
+  const { flags, positional } = parseArgs(ctx.args, spec);
+  const targets = positional.length > 0 ? positional : [ctx.cwd];
+
+  let exitCode = 0;
+  const fileEntries: LsEntry[] = [];
+  const dirTargets: string[] = [];
+
+  // First pass: separate files from directories
+  for (const target of targets) {
+    const targetPath = resolve(ctx.cwd, target);
+    try {
+      const stat = ctx.vfs.stat(targetPath);
+      if (stat.type === 'file') {
+        fileEntries.push({
+          name: target,
+          type: stat.type,
+          size: stat.size,
+          mtime: stat.mtime,
+          mode: stat.mode,
+        });
+      } else {
+        dirTargets.push(target);
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`ls: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  // Display file entries
+  if (fileEntries.length > 0) {
+    if (flags.long) {
+      for (const entry of fileEntries) {
+        ctx.stdout.write(formatEntry(entry, true));
+      }
+    } else if (flags.one) {
+      for (const entry of fileEntries) {
+        ctx.stdout.write(formatEntry(entry, false) + '\n');
+      }
+    } else {
+      const names = fileEntries.map((e) => formatEntry(e, false));
+      ctx.stdout.write(names.join('  ') + '\n');
+    }
+  }
+
+  // Display directory entries
+  for (let i = 0; i < dirTargets.length; i++) {
+    const target = dirTargets[i];
+    const targetPath = resolve(ctx.cwd, target);
+
+    // Print header if multiple targets
+    if (dirTargets.length > 1 || fileEntries.length > 0) {
+      if (fileEntries.length > 0 || i > 0) ctx.stdout.write('\n');
+      ctx.stdout.write(`${target}:\n`);
+    }
+
+    try {
+      const entries = listDirectory(targetPath, flags, ctx);
+
+      if (flags.long) {
+        for (const entry of entries) {
+          ctx.stdout.write(formatEntry(entry, true));
+        }
+      } else if (flags.one) {
+        for (const entry of entries) {
+          ctx.stdout.write(formatEntry(entry, false) + '\n');
+        }
+      } else {
+        const names = entries.map((e) => formatEntry(e, false));
+        if (names.length > 0) {
+          ctx.stdout.write(names.join('  ') + '\n');
+        }
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`ls: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;

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

@@ -0,0 +1,37 @@
+import type { Command } from '../types.js';
+import { parseArgs } from '../../utils/args.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const spec = {
+  parents: { type: 'boolean' as const, short: 'p' },
+};
+
+const command: Command = async (ctx) => {
+  const { flags, positional } = parseArgs(ctx.args, spec);
+
+  if (positional.length === 0) {
+    ctx.stderr.write('mkdir: missing operand\n');
+    return 1;
+  }
+
+  let exitCode = 0;
+
+  for (const arg of positional) {
+    const path = resolve(ctx.cwd, arg);
+    try {
+      ctx.vfs.mkdir(path, { recursive: flags.parents as boolean });
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`mkdir: ${arg}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;

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

@@ -0,0 +1,56 @@
+import type { Command } from '../types.js';
+import { parseArgs } from '../../utils/args.js';
+import { resolve } from '../../utils/path.js';
+
+const spec = {
+  directory: { type: 'boolean' as const, short: 'd' },
+  tmpdir: { type: 'string' as const, short: 'p' },
+};
+
+function randomChars(n: number): string {
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let result = '';
+  for (let i = 0; i < n; i++) {
+    result += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return result;
+}
+
+const command: Command = async (ctx) => {
+  const { flags, positional } = parseArgs(ctx.args, spec);
+
+  const dir = (flags.tmpdir as string) || '/tmp';
+  const template = positional[0] || 'tmp.XXXXXXXXXX';
+
+  // Replace X's at end with random chars
+  const xMatch = template.match(/X+$/);
+  const xCount = xMatch ? xMatch[0].length : 0;
+  const name = xCount > 0
+    ? template.slice(0, -xCount) + randomChars(xCount)
+    : template + '.' + randomChars(10);
+
+  const fullPath = resolve(dir, name);
+
+  try {
+    // Ensure parent dir exists
+    try {
+      ctx.vfs.stat(dir);
+    } catch {
+      ctx.vfs.mkdir(dir, { recursive: true });
+    }
+
+    if (flags.directory) {
+      ctx.vfs.mkdir(fullPath);
+    } else {
+      ctx.vfs.writeFile(fullPath, '');
+    }
+
+    ctx.stdout.write(fullPath + '\n');
+    return 0;
+  } catch (e) {
+    ctx.stderr.write(`mktemp: failed to create ${flags.directory ? 'directory' : 'file'}: ${(e as Error).message}\n`);
+    return 1;
+  }
+};
+
+export default command;