start-command 0.3.1

package/test/args-parser.test.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+/**
+ * Unit tests for the argument parser
+ * Tests wrapper options parsing, validation, and command extraction
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const {
+  parseArgs,
+  validateOptions,
+  generateSessionName,
+  hasIsolation,
+  getEffectiveMode,
+  VALID_BACKENDS,
+} = require('../src/lib/args-parser');
+
+describe('parseArgs', () => {
+  describe('basic command parsing', () => {
+    it('should parse simple command without options', () => {
+      const result = parseArgs(['echo', 'hello', 'world']);
+      assert.strictEqual(result.command, 'echo hello world');
+      assert.strictEqual(result.wrapperOptions.isolated, null);
+      assert.strictEqual(result.wrapperOptions.attached, false);
+      assert.strictEqual(result.wrapperOptions.detached, false);
+    });
+
+    it('should parse command with -- separator', () => {
+      const result = parseArgs(['--', 'npm', 'test']);
+      assert.strictEqual(result.command, 'npm test');
+    });
+
+    it('should parse empty command correctly', () => {
+      const result = parseArgs([]);
+      assert.strictEqual(result.command, '');
+    });
+  });
+
+  describe('isolation options', () => {
+    it('should parse --isolated with value', () => {
+      const result = parseArgs(['--isolated', 'tmux', '--', 'npm', 'test']);
+      assert.strictEqual(result.wrapperOptions.isolated, 'tmux');
+      assert.strictEqual(result.command, 'npm test');
+    });
+
+    it('should parse -i shorthand', () => {
+      const result = parseArgs(['-i', 'screen', '--', 'npm', 'start']);
+      assert.strictEqual(result.wrapperOptions.isolated, 'screen');
+      assert.strictEqual(result.command, 'npm start');
+    });
+
+    it('should parse --isolated=value format', () => {
+      const result = parseArgs(['--isolated=tmux', '--', 'ls', '-la']);
+      assert.strictEqual(result.wrapperOptions.isolated, 'tmux');
+    });
+
+    it('should normalize backend to lowercase', () => {
+      const result = parseArgs(['--isolated', 'TMUX', '--', 'echo', 'test']);
+      assert.strictEqual(result.wrapperOptions.isolated, 'tmux');
+    });
+
+    it('should throw error for missing backend argument', () => {
+      assert.throws(() => {
+        parseArgs(['--isolated']);
+      }, /requires a backend argument/);
+    });
+  });
+
+  describe('attached and detached modes', () => {
+    it('should parse --attached flag', () => {
+      const result = parseArgs([
+        '--isolated',
+        'tmux',
+        '--attached',
+        '--',
+        'npm',
+        'test',
+      ]);
+      assert.strictEqual(result.wrapperOptions.attached, true);
+      assert.strictEqual(result.wrapperOptions.detached, false);
+    });
+
+    it('should parse -a shorthand', () => {
+      const result = parseArgs(['-i', 'screen', '-a', '--', 'npm', 'start']);
+      assert.strictEqual(result.wrapperOptions.attached, true);
+    });
+
+    it('should parse --detached flag', () => {
+      const result = parseArgs([
+        '--isolated',
+        'tmux',
+        '--detached',
+        '--',
+        'npm',
+        'start',
+      ]);
+      assert.strictEqual(result.wrapperOptions.detached, true);
+      assert.strictEqual(result.wrapperOptions.attached, false);
+    });
+
+    it('should parse -d shorthand', () => {
+      const result = parseArgs(['-i', 'screen', '-d', '--', 'npm', 'start']);
+      assert.strictEqual(result.wrapperOptions.detached, true);
+    });
+
+    it('should throw error when both --attached and --detached are set', () => {
+      assert.throws(() => {
+        parseArgs([
+          '--isolated',
+          'tmux',
+          '--attached',
+          '--detached',
+          '--',
+          'npm',
+          'test',
+        ]);
+      }, /Cannot use both --attached and --detached/);
+    });
+
+    it('should provide helpful error message for mode conflict', () => {
+      try {
+        parseArgs(['-i', 'screen', '-a', '-d', '--', 'npm', 'test']);
+        assert.fail('Should have thrown an error');
+      } catch (err) {
+        assert.ok(err.message.includes('Please choose only one mode'));
+      }
+    });
+  });
+
+  describe('session option', () => {
+    it('should parse --session with value', () => {
+      const result = parseArgs([
+        '--isolated',
+        'tmux',
+        '--session',
+        'my-session',
+        '--',
+        'npm',
+        'test',
+      ]);
+      assert.strictEqual(result.wrapperOptions.session, 'my-session');
+    });
+
+    it('should parse -s shorthand', () => {
+      const result = parseArgs([
+        '-i',
+        'screen',
+        '-s',
+        'test-session',
+        '--',
+        'npm',
+        'start',
+      ]);
+      assert.strictEqual(result.wrapperOptions.session, 'test-session');
+    });
+
+    it('should parse --session=value format', () => {
+      const result = parseArgs([
+        '--isolated',
+        'tmux',
+        '--session=my-session',
+        '--',
+        'npm',
+        'test',
+      ]);
+      assert.strictEqual(result.wrapperOptions.session, 'my-session');
+    });
+
+    it('should throw error for session without isolation', () => {
+      assert.throws(() => {
+        parseArgs(['--session', 'my-session', '--', 'npm', 'test']);
+      }, /--session option is only valid with --isolated/);
+    });
+  });
+
+  describe('docker image option', () => {
+    it('should parse --image with value', () => {
+      const result = parseArgs([
+        '--isolated',
+        'docker',
+        '--image',
+        'node:20',
+        '--',
+        'npm',
+        'test',
+      ]);
+      assert.strictEqual(result.wrapperOptions.image, 'node:20');
+    });
+
+    it('should parse --image=value format', () => {
+      const result = parseArgs([
+        '--isolated',
+        'docker',
+        '--image=alpine:latest',
+        '--',
+        'ls',
+      ]);
+      assert.strictEqual(result.wrapperOptions.image, 'alpine:latest');
+    });
+
+    it('should throw error for docker without image', () => {
+      assert.throws(() => {
+        parseArgs(['--isolated', 'docker', '--', 'npm', 'test']);
+      }, /Docker isolation requires --image option/);
+    });
+
+    it('should throw error for image with non-docker backend', () => {
+      assert.throws(() => {
+        parseArgs([
+          '--isolated',
+          'tmux',
+          '--image',
+          'node:20',
+          '--',
+          'npm',
+          'test',
+        ]);
+      }, /--image option is only valid with --isolated docker/);
+    });
+  });
+
+  describe('command without separator', () => {
+    it('should parse command after options without separator', () => {
+      const result = parseArgs(['-i', 'tmux', '-d', 'npm', 'start']);
+      assert.strictEqual(result.wrapperOptions.isolated, 'tmux');
+      assert.strictEqual(result.wrapperOptions.detached, true);
+      assert.strictEqual(result.command, 'npm start');
+    });
+
+    it('should handle mixed options and command', () => {
+      const result = parseArgs(['-i', 'screen', 'echo', 'hello']);
+      assert.strictEqual(result.wrapperOptions.isolated, 'screen');
+      assert.strictEqual(result.command, 'echo hello');
+    });
+  });
+
+  describe('backend validation', () => {
+    it('should accept valid backends', () => {
+      for (const backend of VALID_BACKENDS) {
+        // Docker requires image, so handle it separately
+        if (backend === 'docker') {
+          const result = parseArgs([
+            '-i',
+            backend,
+            '--image',
+            'alpine',
+            '--',
+            'echo',
+            'test',
+          ]);
+          assert.strictEqual(result.wrapperOptions.isolated, backend);
+        } else {
+          const result = parseArgs(['-i', backend, '--', 'echo', 'test']);
+          assert.strictEqual(result.wrapperOptions.isolated, backend);
+        }
+      }
+    });
+
+    it('should throw error for invalid backend', () => {
+      assert.throws(() => {
+        parseArgs(['--isolated', 'invalid-backend', '--', 'npm', 'test']);
+      }, /Invalid isolation backend/);
+    });
+
+    it('should list valid backends in error message', () => {
+      try {
+        parseArgs(['--isolated', 'invalid', '--', 'npm', 'test']);
+        assert.fail('Should have thrown an error');
+      } catch (err) {
+        for (const backend of VALID_BACKENDS) {
+          assert.ok(
+            err.message.includes(backend),
+            `Error should mention ${backend}`
+          );
+        }
+      }
+    });
+  });
+});
+
+describe('validateOptions', () => {
+  it('should pass for valid options', () => {
+    assert.doesNotThrow(() => {
+      validateOptions({
+        isolated: 'tmux',
+        attached: false,
+        detached: true,
+        session: 'test',
+        image: null,
+      });
+    });
+  });
+
+  it('should throw for attached and detached together', () => {
+    assert.throws(() => {
+      validateOptions({
+        isolated: 'screen',
+        attached: true,
+        detached: true,
+        session: null,
+        image: null,
+      });
+    }, /Cannot use both --attached and --detached/);
+  });
+
+  it('should pass for docker with image', () => {
+    assert.doesNotThrow(() => {
+      validateOptions({
+        isolated: 'docker',
+        attached: false,
+        detached: false,
+        session: null,
+        image: 'node:20',
+      });
+    });
+  });
+});
+
+describe('generateSessionName', () => {
+  it('should generate unique session names', () => {
+    const name1 = generateSessionName();
+    const name2 = generateSessionName();
+    assert.notStrictEqual(name1, name2);
+  });
+
+  it('should use default prefix', () => {
+    const name = generateSessionName();
+    assert.ok(name.startsWith('start-'));
+  });
+
+  it('should use custom prefix', () => {
+    const name = generateSessionName('custom');
+    assert.ok(name.startsWith('custom-'));
+  });
+
+  it('should contain timestamp-like portion', () => {
+    const name = generateSessionName();
+    // Should have format: prefix-timestamp-random
+    const parts = name.split('-');
+    assert.ok(parts.length >= 3);
+    // Second part should be numeric (timestamp)
+    assert.ok(/^\d+$/.test(parts[1]));
+  });
+});
+
+describe('hasIsolation', () => {
+  it('should return true when isolated is set', () => {
+    assert.strictEqual(hasIsolation({ isolated: 'tmux' }), true);
+  });
+
+  it('should return false when isolated is null', () => {
+    assert.strictEqual(hasIsolation({ isolated: null }), false);
+  });
+});
+
+describe('getEffectiveMode', () => {
+  it('should return attached by default', () => {
+    const mode = getEffectiveMode({ attached: false, detached: false });
+    assert.strictEqual(mode, 'attached');
+  });
+
+  it('should return attached when explicitly set', () => {
+    const mode = getEffectiveMode({ attached: true, detached: false });
+    assert.strictEqual(mode, 'attached');
+  });
+
+  it('should return detached when set', () => {
+    const mode = getEffectiveMode({ attached: false, detached: true });
+    assert.strictEqual(mode, 'detached');
+  });
+});
+
+describe('VALID_BACKENDS', () => {
+  it('should include screen', () => {
+    assert.ok(VALID_BACKENDS.includes('screen'));
+  });
+
+  it('should include tmux', () => {
+    assert.ok(VALID_BACKENDS.includes('tmux'));
+  });
+
+  it('should include docker', () => {
+    assert.ok(VALID_BACKENDS.includes('docker'));
+  });
+
+  it('should include zellij', () => {
+    assert.ok(VALID_BACKENDS.includes('zellij'));
+  });
+});

package/test/isolation.test.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+/**
+ * Unit tests for the isolation module
+ * Tests command availability checking and session name generation
+ * Note: Actual isolation execution tests are integration tests that require the tools to be installed
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { isCommandAvailable } = require('../src/lib/isolation');
+
+describe('Isolation Module', () => {
+  describe('isCommandAvailable', () => {
+    it('should return true for common commands (echo)', () => {
+      // echo is available on all platforms
+      const result = isCommandAvailable('echo');
+      assert.strictEqual(result, true);
+    });
+
+    it('should return true for node', () => {
+      // node should be available since we are running tests with it
+      const result = isCommandAvailable('node');
+      assert.strictEqual(result, true);
+    });
+
+    it('should return false for non-existent command', () => {
+      const result = isCommandAvailable('nonexistent-command-12345');
+      assert.strictEqual(result, false);
+    });
+
+    it('should return false for empty command', () => {
+      const result = isCommandAvailable('');
+      assert.strictEqual(result, false);
+    });
+  });
+
+  describe('isolation backend checks', () => {
+    // These tests check if specific backends are available
+    // They don't fail if not installed, just report status
+
+    it('should check if screen is available', () => {
+      const result = isCommandAvailable('screen');
+      console.log(`  screen available: ${result}`);
+      assert.ok(typeof result === 'boolean');
+    });
+
+    it('should check if tmux is available', () => {
+      const result = isCommandAvailable('tmux');
+      console.log(`  tmux available: ${result}`);
+      assert.ok(typeof result === 'boolean');
+    });
+
+    it('should check if docker is available', () => {
+      const result = isCommandAvailable('docker');
+      console.log(`  docker available: ${result}`);
+      assert.ok(typeof result === 'boolean');
+    });
+
+    it('should check if zellij is available', () => {
+      const result = isCommandAvailable('zellij');
+      console.log(`  zellij available: ${result}`);
+      assert.ok(typeof result === 'boolean');
+    });
+  });
+});
+
+describe('Isolation Runner Error Handling', () => {
+  // These tests verify error messages when backends are not available
+
+  const {
+    runInScreen,
+    runInTmux,
+    runInDocker,
+    runInZellij,
+  } = require('../src/lib/isolation');
+
+  describe('runInScreen', () => {
+    it('should return informative error if screen is not installed', async () => {
+      // Skip if screen is installed
+      if (isCommandAvailable('screen')) {
+        console.log('  Skipping: screen is installed');
+        return;
+      }
+
+      const result = await runInScreen('echo test', { detached: true });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.message.includes('screen is not installed'));
+      assert.ok(
+        result.message.includes('apt-get') || result.message.includes('brew')
+      );
+    });
+  });
+
+  describe('runInTmux', () => {
+    it('should return informative error if tmux is not installed', async () => {
+      // Skip if tmux is installed
+      if (isCommandAvailable('tmux')) {
+        console.log('  Skipping: tmux is installed');
+        return;
+      }
+
+      const result = await runInTmux('echo test', { detached: true });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.message.includes('tmux is not installed'));
+      assert.ok(
+        result.message.includes('apt-get') || result.message.includes('brew')
+      );
+    });
+  });
+
+  describe('runInDocker', () => {
+    it('should return informative error if docker is not installed', async () => {
+      // Skip if docker is installed
+      if (isCommandAvailable('docker')) {
+        console.log('  Skipping: docker is installed');
+        return;
+      }
+
+      const result = await runInDocker('echo test', {
+        image: 'alpine',
+        detached: true,
+      });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.message.includes('docker is not installed'));
+    });
+
+    it('should require image option', async () => {
+      // Skip if docker is not installed - the error will be about docker not being installed
+      if (!isCommandAvailable('docker')) {
+        console.log('  Skipping: docker not installed');
+        return;
+      }
+
+      const result = await runInDocker('echo test', { detached: true });
+      assert.strictEqual(result.success, false);
+      // Message should mention image requirement
+      assert.ok(
+        result.message.includes('image') ||
+          result.message.includes('--image') ||
+          result.message.includes('Docker isolation requires')
+      );
+    });
+  });
+
+  describe('runInZellij', () => {
+    it('should return informative error if zellij is not installed', async () => {
+      // Skip if zellij is installed
+      if (isCommandAvailable('zellij')) {
+        console.log('  Skipping: zellij is installed');
+        return;
+      }
+
+      const result = await runInZellij('echo test', { detached: true });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.message.includes('zellij is not installed'));
+      assert.ok(
+        result.message.includes('cargo') || result.message.includes('brew')
+      );
+    });
+  });
+});
+
+describe('Isolation Runner with Available Backends', () => {
+  // Integration-style tests that run if backends are available
+  // These test actual execution in detached mode (quick and non-blocking)
+
+  const {
+    runInScreen,
+    runInTmux,
+    runIsolated,
+  } = require('../src/lib/isolation');
+  const { execSync } = require('child_process');
+
+  describe('runInScreen (if available)', () => {
+    it('should run command in detached screen session', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen('echo "test from screen"', {
+        session: `test-session-${Date.now()}`,
+        detached: true,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(result.sessionName);
+      assert.ok(result.message.includes('screen'));
+      assert.ok(result.message.includes('Reattach with'));
+
+      // Clean up the session
+      try {
+        execSync(`screen -S ${result.sessionName} -X quit`, {
+          stdio: 'ignore',
+        });
+      } catch {
+        // Session may have already exited
+      }
+    });
+  });
+
+  describe('runInTmux (if available)', () => {
+    it('should run command in detached tmux session', async () => {
+      if (!isCommandAvailable('tmux')) {
+        console.log('  Skipping: tmux not installed');
+        return;
+      }
+
+      const result = await runInTmux('echo "test from tmux"', {
+        session: `test-session-${Date.now()}`,
+        detached: true,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(result.sessionName);
+      assert.ok(result.message.includes('tmux'));
+      assert.ok(result.message.includes('Reattach with'));
+
+      // Clean up the session
+      try {
+        execSync(`tmux kill-session -t ${result.sessionName}`, {
+          stdio: 'ignore',
+        });
+      } catch {
+        // Session may have already exited
+      }
+    });
+  });
+
+  describe('runIsolated dispatcher', () => {
+    it('should dispatch to correct backend', async () => {
+      // Test with a backend that returns predictable error for missing tools
+      const result = await runIsolated('nonexistent-backend', 'echo test', {});
+      assert.strictEqual(result.success, false);
+      assert.ok(result.message.includes('Unknown isolation backend'));
+    });
+
+    it('should pass options to backend', async () => {
+      // Test docker without image - should fail with specific error
+      const result = await runIsolated('docker', 'echo test', {});
+      assert.strictEqual(result.success, false);
+      // Either docker not installed or image required
+      assert.ok(
+        result.message.includes('docker') || result.message.includes('image')
+      );
+    });
+  });
+});