start-command 0.7.6 → 0.10.0

package/test/args-parser.test.js

@@ -219,6 +219,136 @@ describe('parseArgs', () => {
     });
   });
 
+  describe('keep-alive option', () => {
+    it('should parse --keep-alive flag', () => {
+      const result = parseArgs([
+        '--isolated',
+        'tmux',
+        '--keep-alive',
+        '--',
+        'npm',
+        'test',
+      ]);
+      assert.strictEqual(result.wrapperOptions.keepAlive, true);
+    });
+
+    it('should parse -k shorthand', () => {
+      const result = parseArgs(['-i', 'screen', '-k', '--', 'npm', 'start']);
+      assert.strictEqual(result.wrapperOptions.keepAlive, true);
+    });
+
+    it('should default keepAlive to false', () => {
+      const result = parseArgs(['-i', 'tmux', '--', 'npm', 'test']);
+      assert.strictEqual(result.wrapperOptions.keepAlive, false);
+    });
+
+    it('should throw error for keep-alive without isolation', () => {
+      assert.throws(() => {
+        parseArgs(['--keep-alive', '--', 'npm', 'test']);
+      }, /--keep-alive option is only valid with --isolated/);
+    });
+
+    it('should work with detached mode', () => {
+      const result = parseArgs([
+        '-i',
+        'screen',
+        '-d',
+        '-k',
+        '--',
+        'npm',
+        'start',
+      ]);
+      assert.strictEqual(result.wrapperOptions.isolated, 'screen');
+      assert.strictEqual(result.wrapperOptions.detached, true);
+      assert.strictEqual(result.wrapperOptions.keepAlive, true);
+    });
+
+    it('should work with docker', () => {
+      const result = parseArgs([
+        '-i',
+        'docker',
+        '--image',
+        'node:20',
+        '-k',
+        '--',
+        'npm',
+        'test',
+      ]);
+      assert.strictEqual(result.wrapperOptions.isolated, 'docker');
+      assert.strictEqual(result.wrapperOptions.image, 'node:20');
+      assert.strictEqual(result.wrapperOptions.keepAlive, true);
+    });
+  });
+
+  describe('auto-remove-docker-container option', () => {
+    it('should parse --auto-remove-docker-container flag', () => {
+      const result = parseArgs([
+        '--isolated',
+        'docker',
+        '--image',
+        'alpine',
+        '--auto-remove-docker-container',
+        '--',
+        'npm',
+        'test',
+      ]);
+      assert.strictEqual(result.wrapperOptions.autoRemoveDockerContainer, true);
+    });
+
+    it('should default autoRemoveDockerContainer to false', () => {
+      const result = parseArgs([
+        '-i',
+        'docker',
+        '--image',
+        'alpine',
+        '--',
+        'npm',
+        'test',
+      ]);
+      assert.strictEqual(
+        result.wrapperOptions.autoRemoveDockerContainer,
+        false
+      );
+    });
+
+    it('should throw error for auto-remove-docker-container without docker isolation', () => {
+      assert.throws(() => {
+        parseArgs([
+          '-i',
+          'tmux',
+          '--auto-remove-docker-container',
+          '--',
+          'npm',
+          'test',
+        ]);
+      }, /--auto-remove-docker-container option is only valid with --isolated docker/);
+    });
+
+    it('should throw error for auto-remove-docker-container without isolation', () => {
+      assert.throws(() => {
+        parseArgs(['--auto-remove-docker-container', '--', 'npm', 'test']);
+      }, /--auto-remove-docker-container option is only valid with --isolated docker/);
+    });
+
+    it('should work with keep-alive and auto-remove-docker-container', () => {
+      const result = parseArgs([
+        '-i',
+        'docker',
+        '--image',
+        'node:20',
+        '-k',
+        '--auto-remove-docker-container',
+        '--',
+        'npm',
+        'test',
+      ]);
+      assert.strictEqual(result.wrapperOptions.isolated, 'docker');
+      assert.strictEqual(result.wrapperOptions.image, 'node:20');
+      assert.strictEqual(result.wrapperOptions.keepAlive, true);
+      assert.strictEqual(result.wrapperOptions.autoRemoveDockerContainer, true);
+    });
+  });
+
   describe('command without separator', () => {
     it('should parse command after options without separator', () => {
       const result = parseArgs(['-i', 'tmux', '-d', 'npm', 'start']);
@@ -383,3 +513,182 @@ describe('VALID_BACKENDS', () => {
     assert.ok(VALID_BACKENDS.includes('docker'));
   });
 });
+
+describe('user isolation option', () => {
+  it('should parse --isolated-user without value (auto-generated username)', () => {
+    const result = parseArgs(['--isolated-user', '--', 'npm', 'test']);
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.userName, null);
+    assert.strictEqual(result.command, 'npm test');
+  });
+
+  it('should parse --isolated-user with custom username', () => {
+    const result = parseArgs([
+      '--isolated-user',
+      'myrunner',
+      '--',
+      'npm',
+      'test',
+    ]);
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.userName, 'myrunner');
+    assert.strictEqual(result.command, 'npm test');
+  });
+
+  it('should parse -u shorthand', () => {
+    const result = parseArgs(['-u', '--', 'npm', 'start']);
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.userName, null);
+  });
+
+  it('should parse -u with custom username', () => {
+    const result = parseArgs(['-u', 'testuser', '--', 'npm', 'start']);
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.userName, 'testuser');
+  });
+
+  it('should parse --isolated-user=value format', () => {
+    const result = parseArgs([
+      '--isolated-user=myrunner',
+      '--',
+      'npm',
+      'start',
+    ]);
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.userName, 'myrunner');
+  });
+
+  it('should work with isolation options', () => {
+    const result = parseArgs([
+      '--isolated',
+      'screen',
+      '--isolated-user',
+      'testuser',
+      '--',
+      'npm',
+      'start',
+    ]);
+    assert.strictEqual(result.wrapperOptions.isolated, 'screen');
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.userName, 'testuser');
+    assert.strictEqual(result.command, 'npm start');
+  });
+
+  it('should work without isolation (standalone user isolation)', () => {
+    const result = parseArgs(['--isolated-user', '--', 'node', 'server.js']);
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.isolated, null);
+    assert.strictEqual(result.command, 'node server.js');
+  });
+
+  it('should accept valid usernames', () => {
+    const validUsernames = [
+      'john',
+      'www-data',
+      'user123',
+      'john-doe',
+      'user_1',
+    ];
+    for (const username of validUsernames) {
+      assert.doesNotThrow(() => {
+        parseArgs(['--isolated-user', username, '--', 'echo', 'test']);
+      });
+    }
+  });
+
+  it('should reject invalid username formats with --isolated-user=value syntax', () => {
+    const invalidUsernames = ['john@doe', 'user.name', 'user/name'];
+    for (const username of invalidUsernames) {
+      assert.throws(() => {
+        parseArgs([`--isolated-user=${username}`, '--', 'echo', 'test']);
+      }, /Invalid username format/);
+    }
+  });
+
+  it('should not consume invalid username as argument (treats as command)', () => {
+    // When --isolated-user is followed by an invalid username format, it doesn't consume it
+    // The invalid username becomes part of the command instead
+    const result = parseArgs([
+      '--isolated-user',
+      'john@doe',
+      '--',
+      'echo',
+      'test',
+    ]);
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.userName, null);
+    // john@doe is not consumed as username, but the -- separator means it's not in command either
+  });
+
+  it('should throw error for user with docker isolation', () => {
+    assert.throws(() => {
+      parseArgs([
+        '--isolated',
+        'docker',
+        '--image',
+        'node:20',
+        '--isolated-user',
+        '--',
+        'npm',
+        'install',
+      ]);
+    }, /--isolated-user is not supported with Docker isolation/);
+  });
+
+  it('should work with tmux isolation', () => {
+    const result = parseArgs([
+      '-i',
+      'tmux',
+      '--isolated-user',
+      'testuser',
+      '--',
+      'npm',
+      'test',
+    ]);
+    assert.strictEqual(result.wrapperOptions.isolated, 'tmux');
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.userName, 'testuser');
+  });
+});
+
+describe('keep-user option', () => {
+  it('should parse --keep-user flag', () => {
+    const result = parseArgs([
+      '--isolated-user',
+      '--keep-user',
+      '--',
+      'npm',
+      'test',
+    ]);
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.keepUser, true);
+  });
+
+  it('should default keepUser to false', () => {
+    const result = parseArgs(['--isolated-user', '--', 'npm', 'test']);
+    assert.strictEqual(result.wrapperOptions.keepUser, false);
+  });
+
+  it('should throw error for keep-user without user', () => {
+    assert.throws(() => {
+      parseArgs(['--keep-user', '--', 'npm', 'test']);
+    }, /--keep-user option is only valid with --isolated-user/);
+  });
+
+  it('should work with user and isolation options', () => {
+    const result = parseArgs([
+      '-i',
+      'screen',
+      '--isolated-user',
+      'testuser',
+      '--keep-user',
+      '--',
+      'npm',
+      'start',
+    ]);
+    assert.strictEqual(result.wrapperOptions.isolated, 'screen');
+    assert.strictEqual(result.wrapperOptions.user, true);
+    assert.strictEqual(result.wrapperOptions.userName, 'testuser');
+    assert.strictEqual(result.wrapperOptions.keepUser, true);
+  });
+});

package/test/docker-autoremove.test.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env bun
+/**
+ * Tests for Docker auto-remove container feature
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { isCommandAvailable } = require('../src/lib/isolation');
+const { runInDocker } = require('../src/lib/isolation');
+const { execSync } = require('child_process');
+
+// Helper to wait for a condition with timeout
+async function waitFor(conditionFn, timeout = 5000, interval = 100) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    if (conditionFn()) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  return false;
+}
+
+// Helper function to check if docker daemon is running
+function isDockerRunning() {
+  if (!isCommandAvailable('docker')) {
+    return false;
+  }
+  try {
+    execSync('docker info', { stdio: 'ignore', timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+describe('Docker Auto-Remove Container Feature', () => {
+  // These tests verify the --auto-remove-docker-container option
+  // which automatically removes the container after exit (disabled by default)
+
+  describe('auto-remove enabled', () => {
+    it('should automatically remove container when autoRemoveDockerContainer is true', async () => {
+      if (!isDockerRunning()) {
+        console.log('  Skipping: docker not available or daemon not running');
+        return;
+      }
+
+      const containerName = `test-autoremove-${Date.now()}`;
+
+      // Run command with autoRemoveDockerContainer enabled
+      const result = await runInDocker('echo "test" && sleep 0.5', {
+        image: 'alpine:latest',
+        session: containerName,
+        detached: true,
+        keepAlive: false,
+        autoRemoveDockerContainer: true,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(
+        result.message.includes('automatically removed'),
+        'Message should indicate auto-removal'
+      );
+
+      // Wait for container to finish and be removed
+      const containerRemoved = await waitFor(() => {
+        try {
+          execSync(`docker inspect -f '{{.State.Status}}' ${containerName}`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          return false; // Container still exists
+        } catch {
+          return true; // Container does not exist (removed)
+        }
+      }, 10000);
+
+      assert.ok(
+        containerRemoved,
+        'Container should be automatically removed after exit with --auto-remove-docker-container'
+      );
+
+      // Double-check with docker ps -a that container is completely removed
+      try {
+        const allContainers = execSync('docker ps -a', {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        assert.ok(
+          !allContainers.includes(containerName),
+          'Container should NOT appear in docker ps -a (completely removed)'
+        );
+        console.log(
+          '  ✓ Docker container auto-removed after exit (filesystem not preserved)'
+        );
+      } catch (err) {
+        assert.fail(`Failed to verify container removal: ${err.message}`);
+      }
+
+      // No cleanup needed - container should already be removed
+    });
+  });
+
+  describe('auto-remove disabled (default)', () => {
+    it('should preserve container filesystem by default (without autoRemoveDockerContainer)', async () => {
+      if (!isDockerRunning()) {
+        console.log('  Skipping: docker not available or daemon not running');
+        return;
+      }
+
+      const containerName = `test-preserve-${Date.now()}`;
+
+      // Run command without autoRemoveDockerContainer
+      const result = await runInDocker('echo "test" && sleep 0.1', {
+        image: 'alpine:latest',
+        session: containerName,
+        detached: true,
+        keepAlive: false,
+        autoRemoveDockerContainer: false,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(
+        result.message.includes('filesystem will be preserved'),
+        'Message should indicate filesystem preservation'
+      );
+
+      // Wait for container to exit
+      await waitFor(() => {
+        try {
+          const status = execSync(
+            `docker inspect -f '{{.State.Status}}' ${containerName}`,
+            {
+              encoding: 'utf8',
+              stdio: ['pipe', 'pipe', 'pipe'],
+            }
+          ).trim();
+          return status === 'exited';
+        } catch {
+          return false;
+        }
+      }, 10000);
+
+      // Container should still exist (in exited state)
+      try {
+        const allContainers = execSync('docker ps -a', {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        assert.ok(
+          allContainers.includes(containerName),
+          'Container should appear in docker ps -a (filesystem preserved)'
+        );
+        console.log(
+          '  ✓ Docker container filesystem preserved by default (can be re-entered)'
+        );
+      } catch (err) {
+        assert.fail(`Failed to verify container preservation: ${err.message}`);
+      }
+
+      // Clean up
+      try {
+        execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+      } catch {
+        // Ignore cleanup errors
+      }
+    });
+  });
+});