command-stream 0.3.0 → 0.3.2

package/src/commands/$.test.mjs

@@ -0,0 +1,59 @@
+import fs from 'fs';
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default async function test({ args }) {
+  if (args.length === 0) {
+    return { stdout: '', code: 1 };
+  }
+
+  const operator = args[0];
+  const operand = args[1];
+
+  try {
+    switch (operator) {
+      case '-e': // File exists
+        try {
+          fs.statSync(operand);
+          return { stdout: '', code: 0 };
+        } catch {
+          return { stdout: '', code: 1 };
+        }
+
+      case '-f': // Regular file
+        try {
+          const stats = fs.statSync(operand);
+          return { stdout: '', code: stats.isFile() ? 0 : 1 };
+        } catch {
+          return { stdout: '', code: 1 };
+        }
+
+      case '-d': // Directory
+        try {
+          const stats = fs.statSync(operand);
+          return { stdout: '', code: stats.isDirectory() ? 0 : 1 };
+        } catch {
+          return { stdout: '', code: 1 };
+        }
+
+      case '-s': // File exists and not empty
+        try {
+          const stats = fs.statSync(operand);
+          return { stdout: '', code: stats.size > 0 ? 0 : 1 };
+        } catch {
+          return { stdout: '', code: 1 };
+        }
+
+      case '-z': // String is empty
+        return { stdout: '', code: (!operand || operand.length === 0) ? 0 : 1 };
+
+      case '-n': // String is not empty
+        return { stdout: '', code: (operand && operand.length > 0) ? 0 : 1 };
+
+      default:
+        // Simple string test (non-empty)
+        return { stdout: '', code: (operator && operator.length > 0) ? 0 : 1 };
+    }
+  } catch (error) {
+    return VirtualUtils.error(`test: ${error.message}`);
+  }
+}

package/src/commands/$.touch.mjs

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function touch({ args, stdin, cwd }) {
+  const argError = VirtualUtils.validateArgs(args, 1, 'touch');
+  if (argError) return VirtualUtils.missingOperandError('touch', 'touch: missing file operand');
+
+  try {
+    for (const file of args) {
+      const resolvedPath = VirtualUtils.resolvePath(file, cwd);
+      trace('VirtualCommand', () => `touch: processing | ${JSON.stringify({ file: resolvedPath }, null, 2)}`);
+      
+      const now = new Date();
+      
+      try {
+        // Try to update existing file's timestamp
+        fs.utimesSync(resolvedPath, now, now);
+        trace('VirtualCommand', () => `touch: updated timestamp | ${JSON.stringify({ file: resolvedPath }, null, 2)}`);
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          // File doesn't exist, create it
+          fs.writeFileSync(resolvedPath, '');
+          trace('VirtualCommand', () => `touch: created file | ${JSON.stringify({ file: resolvedPath }, null, 2)}`);
+        } else {
+          throw error;
+        }
+      }
+    }
+    
+    trace('VirtualCommand', () => `touch: success | ${JSON.stringify({ filesTouched: args.length }, null, 2)}`);
+    return VirtualUtils.success();
+  } catch (error) {
+    trace('VirtualCommand', () => `touch: error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    return VirtualUtils.error(`touch: ${error.message}`);
+  }
+}

package/src/commands/$.true.mjs

@@ -0,0 +1,5 @@
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default async function trueCommand() {
+  return VirtualUtils.success();
+}

package/src/commands/$.which.mjs

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import path from 'path';
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default function createWhichCommand(virtualCommands) {
+  return async function which({ args }) {
+    const argError = VirtualUtils.validateArgs(args, 1, 'which');
+    if (argError) return argError;
+
+    const cmd = args[0];
+
+    if (virtualCommands.has(cmd)) {
+      return VirtualUtils.success(`${cmd}: shell builtin\n`);
+    }
+
+    const paths = (process.env.PATH || '').split(process.platform === 'win32' ? ';' : ':');
+    const extensions = process.platform === 'win32' ? ['', '.exe', '.cmd', '.bat'] : [''];
+
+    for (const pathDir of paths) {
+      for (const ext of extensions) {
+        const fullPath = path.join(pathDir, cmd + ext);
+        try {
+          if (fs.statSync(fullPath).isFile()) {
+            return VirtualUtils.success(fullPath + '\n');
+          }
+        } catch { }
+      }
+    }
+
+    return VirtualUtils.error(`which: no ${cmd} in PATH`);
+  };
+}

package/src/commands/$.yes.mjs

@@ -0,0 +1,34 @@
+import { trace } from '../$.utils.mjs';
+
+export default async function* yes({ args, stdin, isCancelled, signal, ...rest }) {
+  const output = args.length > 0 ? args.join(' ') : 'y';
+  trace('VirtualCommand', () => `yes: starting infinite generator | ${JSON.stringify({ output }, null, 2)}`);
+
+  let iteration = 0;
+  const MAX_ITERATIONS = 1000000; // Safety limit
+
+  while (!isCancelled?.() && iteration < MAX_ITERATIONS) {
+    // Check for abort signal
+    if (signal?.aborted) {
+      trace('VirtualCommand', () => `yes: aborted via signal | ${JSON.stringify({ iteration }, null, 2)}`);
+      break;
+    }
+
+    // Also check rest properties for various cancellation methods
+    if (rest.aborted || rest.cancelled || rest.stop) {
+      trace('VirtualCommand', () => `yes: stopped via property | ${JSON.stringify({ iteration }, null, 2)}`);
+      break;
+    }
+
+    yield output + '\n';
+
+    iteration++;
+
+    // Yield control periodically to prevent blocking
+    if (iteration % 1000 === 0) {
+      await new Promise(resolve => setImmediate(resolve));
+    }
+  }
+
+  trace('VirtualCommand', () => `yes: generator completed | ${JSON.stringify({ iteration }, null, 2)}`);
+}