start-command 0.20.4 → 0.22.0

package/test/isolation-stacking.test.js

@@ -0,0 +1,366 @@
+/**
+ * Tests for isolation stacking feature (issue #77)
+ */
+
+const { describe, it, expect } = require('bun:test');
+const {
+  parseArgs,
+  validateOptions,
+  hasStackedIsolation,
+  MAX_ISOLATION_DEPTH,
+} = require('../src/lib/args-parser');
+
+describe('Isolation Stacking - Args Parser', () => {
+  describe('parseArgs with stacked --isolated', () => {
+    it('should parse single isolation (backward compatible)', () => {
+      const result = parseArgs(['--isolated', 'docker', '--', 'npm', 'test']);
+      expect(result.wrapperOptions.isolated).toBe('docker');
+      expect(result.wrapperOptions.isolatedStack).toEqual(['docker']);
+      expect(result.command).toBe('npm test');
+    });
+
+    it('should parse multi-level isolation', () => {
+      const result = parseArgs([
+        '--isolated',
+        'screen ssh docker',
+        '--endpoint',
+        '_ user@host _',
+        '--',
+        'npm',
+        'test',
+      ]);
+      expect(result.wrapperOptions.isolated).toBe('screen');
+      expect(result.wrapperOptions.isolatedStack).toEqual([
+        'screen',
+        'ssh',
+        'docker',
+      ]);
+    });
+
+    it('should parse 5-level isolation', () => {
+      const result = parseArgs([
+        '--isolated',
+        'screen ssh tmux ssh docker',
+        '--endpoint',
+        '_ user@server1 _ user@server2 _',
+        '--',
+        'npm',
+        'test',
+      ]);
+      expect(result.wrapperOptions.isolatedStack).toEqual([
+        'screen',
+        'ssh',
+        'tmux',
+        'ssh',
+        'docker',
+      ]);
+      expect(result.wrapperOptions.endpointStack).toEqual([
+        null,
+        'user@server1',
+        null,
+        'user@server2',
+        null,
+      ]);
+    });
+
+    it('should parse --isolated=value syntax', () => {
+      const result = parseArgs(['--isolated=screen tmux', '--', 'ls']);
+      expect(result.wrapperOptions.isolatedStack).toEqual(['screen', 'tmux']);
+    });
+  });
+
+  describe('parseArgs with stacked --image', () => {
+    it('should parse single image (backward compatible)', () => {
+      const result = parseArgs([
+        '--isolated',
+        'docker',
+        '--image',
+        'ubuntu:22.04',
+        '--',
+        'bash',
+      ]);
+      expect(result.wrapperOptions.image).toBe('ubuntu:22.04');
+    });
+
+    it('should parse image sequence with placeholders', () => {
+      const result = parseArgs([
+        '--isolated',
+        'screen docker',
+        '--image',
+        '_ ubuntu:22.04',
+        '--',
+        'bash',
+      ]);
+      expect(result.wrapperOptions.imageStack).toEqual([null, 'ubuntu:22.04']);
+    });
+
+    it('should parse --image=value syntax', () => {
+      const result = parseArgs([
+        '--isolated',
+        'docker',
+        '--image=alpine:latest',
+        '--',
+        'sh',
+      ]);
+      expect(result.wrapperOptions.image).toBe('alpine:latest');
+    });
+  });
+
+  describe('parseArgs with stacked --endpoint', () => {
+    it('should parse single endpoint (backward compatible)', () => {
+      const result = parseArgs([
+        '--isolated',
+        'ssh',
+        '--endpoint',
+        'user@host',
+        '--',
+        'ls',
+      ]);
+      expect(result.wrapperOptions.endpoint).toBe('user@host');
+    });
+
+    it('should parse endpoint sequence with placeholders', () => {
+      const result = parseArgs([
+        '--isolated',
+        'screen ssh ssh docker',
+        '--endpoint',
+        '_ user@host1 user@host2 _',
+        '--',
+        'bash',
+      ]);
+      expect(result.wrapperOptions.endpointStack).toEqual([
+        null,
+        'user@host1',
+        'user@host2',
+        null,
+      ]);
+    });
+  });
+
+  describe('hasStackedIsolation', () => {
+    it('should return true for multi-level', () => {
+      const { wrapperOptions } = parseArgs([
+        '--isolated',
+        'screen docker',
+        '--',
+        'test',
+      ]);
+      expect(hasStackedIsolation(wrapperOptions)).toBe(true);
+    });
+
+    it('should return false for single level', () => {
+      const { wrapperOptions } = parseArgs([
+        '--isolated',
+        'docker',
+        '--',
+        'test',
+      ]);
+      expect(hasStackedIsolation(wrapperOptions)).toBe(false);
+    });
+
+    it('should return false for no isolation', () => {
+      const { wrapperOptions } = parseArgs(['echo', 'hello']);
+      // When no isolation, isolatedStack is null, so hasStackedIsolation returns falsy
+      expect(hasStackedIsolation(wrapperOptions)).toBeFalsy();
+    });
+  });
+});
+
+describe('Isolation Stacking - Validation', () => {
+  describe('validateOptions', () => {
+    it('should validate single backend (backward compatible)', () => {
+      const options = {
+        isolated: 'docker',
+        isolatedStack: ['docker'],
+      };
+      expect(() => validateOptions(options)).not.toThrow();
+      // Should apply default image
+      expect(options.imageStack[0]).toBeDefined();
+    });
+
+    it('should validate multi-level stack', () => {
+      const options = {
+        isolated: 'screen',
+        isolatedStack: ['screen', 'ssh', 'docker'],
+        endpointStack: [null, 'user@host', null],
+      };
+      expect(() => validateOptions(options)).not.toThrow();
+    });
+
+    it('should throw on invalid backend in stack', () => {
+      const options = {
+        isolated: 'screen',
+        isolatedStack: ['screen', 'invalid', 'docker'],
+      };
+      expect(() => validateOptions(options)).toThrow(/Invalid isolation/);
+    });
+
+    it('should throw on missing SSH endpoint', () => {
+      const options = {
+        isolated: 'ssh',
+        isolatedStack: ['ssh'],
+        endpointStack: [null],
+      };
+      expect(() => validateOptions(options)).toThrow(/requires --endpoint/);
+    });
+
+    it('should throw on image/stack length mismatch', () => {
+      const options = {
+        isolated: 'screen',
+        isolatedStack: ['screen', 'ssh', 'docker'],
+        imageStack: [null, 'ubuntu:22.04'], // Only 2, should be 3
+        endpointStack: [null, 'user@host', null],
+      };
+      expect(() => validateOptions(options)).toThrow(/value\(s\)/);
+    });
+
+    it('should throw on depth exceeding limit', () => {
+      const tooDeep = Array(MAX_ISOLATION_DEPTH + 1).fill('screen');
+      const options = {
+        isolated: 'screen',
+        isolatedStack: tooDeep,
+      };
+      expect(() => validateOptions(options)).toThrow(/too deep/);
+    });
+
+    it('should distribute single image to all levels', () => {
+      const options = {
+        isolated: 'screen',
+        isolatedStack: ['screen', 'docker', 'docker'],
+        image: 'ubuntu:22.04',
+      };
+      validateOptions(options);
+      expect(options.imageStack).toEqual([
+        'ubuntu:22.04',
+        'ubuntu:22.04',
+        'ubuntu:22.04',
+      ]);
+    });
+
+    it('should apply default docker image for each docker level', () => {
+      const options = {
+        isolated: 'docker',
+        isolatedStack: ['docker'],
+      };
+      validateOptions(options);
+      expect(options.imageStack[0]).toBeDefined();
+      expect(options.imageStack[0]).toContain(':'); // Should have image:tag format
+    });
+
+    it('should throw if image provided but no docker in stack', () => {
+      const options = {
+        isolated: 'screen',
+        isolatedStack: ['screen', 'tmux'],
+        image: 'ubuntu:22.04',
+      };
+      expect(() => validateOptions(options)).toThrow(/docker/);
+    });
+
+    it('should throw if endpoint provided but no ssh in stack', () => {
+      const options = {
+        isolated: 'screen',
+        isolatedStack: ['screen', 'docker'],
+        endpoint: 'user@host',
+        imageStack: [null, 'ubuntu:22.04'],
+      };
+      expect(() => validateOptions(options)).toThrow(/ssh/);
+    });
+  });
+});
+
+describe('Isolation Stacking - Backward Compatibility', () => {
+  it('should work with existing docker command', () => {
+    const result = parseArgs([
+      '--isolated',
+      'docker',
+      '--image',
+      'node:18',
+      '--',
+      'npm',
+      'test',
+    ]);
+    expect(result.wrapperOptions.isolated).toBe('docker');
+    expect(result.wrapperOptions.image).toBe('node:18');
+    expect(result.wrapperOptions.isolatedStack).toEqual(['docker']);
+    expect(result.command).toBe('npm test');
+  });
+
+  it('should work with existing ssh command', () => {
+    const result = parseArgs([
+      '--isolated',
+      'ssh',
+      '--endpoint',
+      'user@server',
+      '--',
+      'ls',
+      '-la',
+    ]);
+    expect(result.wrapperOptions.isolated).toBe('ssh');
+    expect(result.wrapperOptions.endpoint).toBe('user@server');
+    expect(result.wrapperOptions.isolatedStack).toEqual(['ssh']);
+  });
+
+  it('should work with existing screen command', () => {
+    const result = parseArgs([
+      '--isolated',
+      'screen',
+      '--detached',
+      '--keep-alive',
+      '--',
+      'long-running-task',
+    ]);
+    expect(result.wrapperOptions.isolated).toBe('screen');
+    expect(result.wrapperOptions.detached).toBe(true);
+    expect(result.wrapperOptions.keepAlive).toBe(true);
+    expect(result.wrapperOptions.isolatedStack).toEqual(['screen']);
+  });
+
+  it('should work with -i shorthand', () => {
+    const result = parseArgs(['-i', 'tmux', '--', 'vim']);
+    expect(result.wrapperOptions.isolated).toBe('tmux');
+    expect(result.wrapperOptions.isolatedStack).toEqual(['tmux']);
+  });
+
+  it('should work with attached mode', () => {
+    const result = parseArgs([
+      '--isolated',
+      'docker',
+      '--attached',
+      '--image',
+      'alpine',
+      '--',
+      'sh',
+    ]);
+    expect(result.wrapperOptions.attached).toBe(true);
+    expect(result.wrapperOptions.isolated).toBe('docker');
+  });
+
+  it('should work with session name', () => {
+    const result = parseArgs([
+      '--isolated',
+      'screen',
+      '--session',
+      'my-session',
+      '--',
+      'bash',
+    ]);
+    expect(result.wrapperOptions.session).toBe('my-session');
+  });
+
+  it('should work with session-id', () => {
+    const result = parseArgs([
+      '--isolated',
+      'docker',
+      '--image',
+      'alpine',
+      '--session-id',
+      '12345678-1234-4123-8123-123456789012',
+      '--',
+      'echo',
+      'hi',
+    ]);
+    expect(result.wrapperOptions.sessionId).toBe(
+      '12345678-1234-4123-8123-123456789012'
+    );
+  });
+});

package/test/isolation.test.js

@@ -10,6 +10,7 @@ const assert = require('assert');
 const {
   isCommandAvailable,
   hasTTY,
+  detectShellInEnvironment,
   getScreenVersion,
   supportsLogfileOption,
   resetScreenVersionCache,
@@ -761,3 +762,66 @@ describe('Default Docker Image Detection', () => {
     });
   });
 });
+
+describe('detectShellInEnvironment', () => {
+  it('should return the forced shell when shellPreference is not auto', () => {
+    const result = detectShellInEnvironment(
+      'docker',
+      { image: 'alpine:latest' },
+      'bash'
+    );
+    assert.strictEqual(result, 'bash');
+  });
+
+  it('should return zsh when shellPreference is zsh', () => {
+    const result = detectShellInEnvironment(
+      'ssh',
+      { endpoint: 'user@host' },
+      'zsh'
+    );
+    assert.strictEqual(result, 'zsh');
+  });
+
+  it('should return sh when shellPreference is sh', () => {
+    const result = detectShellInEnvironment(
+      'docker',
+      { image: 'alpine:latest' },
+      'sh'
+    );
+    assert.strictEqual(result, 'sh');
+  });
+
+  it('should return sh fallback when docker image is not provided', () => {
+    const result = detectShellInEnvironment('docker', {}, 'auto');
+    assert.strictEqual(result, 'sh');
+  });
+
+  it('should return sh fallback when ssh endpoint is not provided', () => {
+    const result = detectShellInEnvironment('ssh', {}, 'auto');
+    assert.strictEqual(result, 'sh');
+  });
+
+  it('should return sh fallback for unknown environment', () => {
+    const result = detectShellInEnvironment('screen', {}, 'auto');
+    assert.strictEqual(result, 'sh');
+  });
+
+  it('should auto-detect shell in docker if docker is available', () => {
+    if (!isCommandAvailable('docker')) {
+      console.log('  Skipping: docker not installed');
+      return;
+    }
+    // Use alpine:latest which is commonly available and has sh
+    // This test just verifies we get a valid shell back
+    const result = detectShellInEnvironment(
+      'docker',
+      { image: 'alpine:latest' },
+      'auto'
+    );
+    assert.ok(
+      ['bash', 'zsh', 'sh'].includes(result),
+      `Expected a valid shell (bash/zsh/sh), got: ${result}`
+    );
+    console.log(`  Detected shell in alpine:latest: ${result}`);
+  });
+});

package/test/sequence-parser.test.js

@@ -0,0 +1,237 @@
+/**
+ * Tests for sequence-parser.js
+ * Isolation stacking feature for issue #77
+ */
+
+const { describe, it, expect } = require('bun:test');
+const {
+  parseSequence,
+  formatSequence,
+  shiftSequence,
+  isSequence,
+  distributeOption,
+  getValueAtLevel,
+  formatIsolationChain,
+  buildNextLevelOptions,
+} = require('../src/lib/sequence-parser');
+
+describe('Sequence Parser', () => {
+  describe('parseSequence', () => {
+    it('should parse single value', () => {
+      expect(parseSequence('docker')).toEqual(['docker']);
+    });
+
+    it('should parse space-separated sequence', () => {
+      expect(parseSequence('screen ssh docker')).toEqual([
+        'screen',
+        'ssh',
+        'docker',
+      ]);
+    });
+
+    it('should parse sequence with underscores as null', () => {
+      expect(parseSequence('_ ssh _ docker')).toEqual([
+        null,
+        'ssh',
+        null,
+        'docker',
+      ]);
+    });
+
+    it('should handle all underscores', () => {
+      expect(parseSequence('_ _ _')).toEqual([null, null, null]);
+    });
+
+    it('should handle empty string', () => {
+      expect(parseSequence('')).toEqual([]);
+    });
+
+    it('should handle null/undefined', () => {
+      expect(parseSequence(null)).toEqual([]);
+      expect(parseSequence(undefined)).toEqual([]);
+    });
+
+    it('should trim whitespace', () => {
+      expect(parseSequence('  screen  ssh  ')).toEqual(['screen', 'ssh']);
+    });
+
+    it('should handle multiple spaces between values', () => {
+      expect(parseSequence('screen   ssh   docker')).toEqual([
+        'screen',
+        'ssh',
+        'docker',
+      ]);
+    });
+  });
+
+  describe('formatSequence', () => {
+    it('should format array with values', () => {
+      expect(formatSequence(['screen', 'ssh', 'docker'])).toBe(
+        'screen ssh docker'
+      );
+    });
+
+    it('should format array with nulls as underscores', () => {
+      expect(formatSequence([null, 'ssh', null, 'docker'])).toBe(
+        '_ ssh _ docker'
+      );
+    });
+
+    it('should handle empty array', () => {
+      expect(formatSequence([])).toBe('');
+    });
+
+    it('should handle non-array', () => {
+      expect(formatSequence(null)).toBe('');
+      expect(formatSequence(undefined)).toBe('');
+    });
+  });
+
+  describe('shiftSequence', () => {
+    it('should remove first element', () => {
+      expect(shiftSequence(['screen', 'ssh', 'docker'])).toEqual([
+        'ssh',
+        'docker',
+      ]);
+    });
+
+    it('should handle nulls', () => {
+      expect(shiftSequence([null, 'ssh', null])).toEqual(['ssh', null]);
+    });
+
+    it('should handle single element', () => {
+      expect(shiftSequence(['docker'])).toEqual([]);
+    });
+
+    it('should handle empty array', () => {
+      expect(shiftSequence([])).toEqual([]);
+    });
+  });
+
+  describe('isSequence', () => {
+    it('should return true for space-separated values', () => {
+      expect(isSequence('screen ssh docker')).toBe(true);
+    });
+
+    it('should return false for single value', () => {
+      expect(isSequence('docker')).toBe(false);
+    });
+
+    it('should return false for non-string', () => {
+      expect(isSequence(null)).toBe(false);
+      expect(isSequence(undefined)).toBe(false);
+      expect(isSequence(123)).toBe(false);
+    });
+  });
+
+  describe('distributeOption', () => {
+    it('should replicate single value for all levels', () => {
+      expect(distributeOption('ubuntu:22.04', 3, '--image')).toEqual([
+        'ubuntu:22.04',
+        'ubuntu:22.04',
+        'ubuntu:22.04',
+      ]);
+    });
+
+    it('should parse sequence with matching length', () => {
+      expect(distributeOption('_ _ ubuntu:22.04', 3, '--image')).toEqual([
+        null,
+        null,
+        'ubuntu:22.04',
+      ]);
+    });
+
+    it('should throw on length mismatch', () => {
+      expect(() => distributeOption('_ _', 3, '--image')).toThrow();
+    });
+
+    it('should handle null/undefined value', () => {
+      expect(distributeOption(null, 3, '--image')).toEqual([null, null, null]);
+    });
+  });
+
+  describe('getValueAtLevel', () => {
+    it('should get value at valid index', () => {
+      expect(getValueAtLevel(['a', 'b', 'c'], 1)).toBe('b');
+    });
+
+    it('should handle nulls', () => {
+      expect(getValueAtLevel([null, 'b', null], 0)).toBe(null);
+      expect(getValueAtLevel([null, 'b', null], 1)).toBe('b');
+    });
+
+    it('should return null for out of bounds', () => {
+      expect(getValueAtLevel(['a', 'b'], 5)).toBe(null);
+      expect(getValueAtLevel(['a', 'b'], -1)).toBe(null);
+    });
+
+    it('should handle non-array', () => {
+      expect(getValueAtLevel(null, 0)).toBe(null);
+    });
+  });
+
+  describe('formatIsolationChain', () => {
+    it('should format simple chain', () => {
+      expect(formatIsolationChain(['screen', 'tmux', 'docker'])).toBe(
+        'screen → tmux → docker'
+      );
+    });
+
+    it('should add SSH endpoint', () => {
+      const options = { endpointStack: [null, 'user@host', null] };
+      expect(formatIsolationChain(['screen', 'ssh', 'docker'], options)).toBe(
+        'screen → ssh@user@host → docker'
+      );
+    });
+
+    it('should add Docker image short name', () => {
+      const options = { imageStack: [null, null, 'oven/bun:latest'] };
+      expect(formatIsolationChain(['screen', 'ssh', 'docker'], options)).toBe(
+        'screen → ssh → docker:bun'
+      );
+    });
+
+    it('should handle placeholders', () => {
+      expect(formatIsolationChain([null, 'ssh', null])).toBe('_ → ssh → _');
+    });
+
+    it('should handle empty array', () => {
+      expect(formatIsolationChain([])).toBe('');
+    });
+  });
+
+  describe('buildNextLevelOptions', () => {
+    it('should shift all stacks', () => {
+      const options = {
+        isolated: 'screen',
+        isolatedStack: ['screen', 'ssh', 'docker'],
+        image: null,
+        imageStack: [null, null, 'ubuntu:22.04'],
+        endpoint: null,
+        endpointStack: [null, 'user@host', null],
+      };
+
+      const next = buildNextLevelOptions(options);
+
+      expect(next.isolated).toBe('ssh');
+      expect(next.isolatedStack).toEqual(['ssh', 'docker']);
+      expect(next.image).toBe(null);
+      expect(next.imageStack).toEqual([null, 'ubuntu:22.04']);
+      expect(next.endpoint).toBe('user@host');
+      expect(next.endpointStack).toEqual(['user@host', null]);
+    });
+
+    it('should handle last level', () => {
+      const options = {
+        isolated: 'docker',
+        isolatedStack: ['docker'],
+        imageStack: ['ubuntu:22.04'],
+      };
+
+      const next = buildNextLevelOptions(options);
+
+      expect(next.isolated).toBe(null);
+      expect(next.isolatedStack).toEqual([]);
+    });
+  });
+});

package/test/user-manager.test.js

@@ -217,7 +217,7 @@ describe('args-parser user isolation options', () => {
           'npm',
           'test',
         ]);
-      }, /--isolated-user is not supported with Docker isolation/);
+      }, /--isolated-user is not supported with Docker as the first isolation level/);
     });
 
     it('should validate custom username format', () => {