start-command 0.26.0 → 0.27.1

package/test/execution-control.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env bun
+/**
+ * Unit tests for detached execution control helpers.
+ */
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  ControlAction,
+  collectProcessIds,
+  controlExecution,
+  getControlCommand,
+  parseScreenPid,
+} = require('../src/lib/execution-control');
+const {
+  ExecutionRecord,
+  ExecutionStatus,
+  ExecutionStore,
+} = require('../src/lib/execution-store');
+
+const TEST_APP_FOLDER = path.join(
+  os.tmpdir(),
+  `execution-control-test-${Date.now()}`
+);
+
+function cleanupTestDir() {
+  if (fs.existsSync(TEST_APP_FOLDER)) {
+    fs.rmSync(TEST_APP_FOLDER, { recursive: true, force: true });
+  }
+}
+
+function createStore() {
+  return new ExecutionStore({
+    appFolder: TEST_APP_FOLDER,
+    useLinks: false,
+  });
+}
+
+function createDetachedRecord(overrides = {}) {
+  return new ExecutionRecord({
+    uuid: 'control-test-uuid',
+    command: 'sleep 100',
+    pid: 12345,
+    logPath: '/tmp/control-test.log',
+    status: ExecutionStatus.EXECUTING,
+    options: {
+      isolated: 'screen',
+      isolationMode: 'detached',
+      sessionName: 'screen-session',
+    },
+    ...overrides,
+  });
+}
+
+function createRunner(responses = {}) {
+  const calls = [];
+  const runner = (command, args) => {
+    calls.push({ command, args });
+    const key = `${command} ${args.join(' ')}`;
+    const response = responses[key] || responses[command];
+    if (typeof response === 'function') {
+      return response(command, args);
+    }
+    return (
+      response || {
+        success: true,
+        stdout: '',
+        stderr: '',
+        status: 0,
+        error: null,
+      }
+    );
+  };
+  runner.calls = calls;
+  return runner;
+}
+
+describe('execution control', () => {
+  beforeEach(cleanupTestDir);
+  afterEach(cleanupTestDir);
+
+  it('should map screen stop to CTRL+C injection', () => {
+    const record = createDetachedRecord();
+    const command = getControlCommand(record, ControlAction.STOP);
+
+    assert.strictEqual(command.command, 'screen');
+    assert.deepStrictEqual(command.args, [
+      '-S',
+      'screen-session',
+      '-X',
+      'stuff',
+      '\x03',
+    ]);
+    assert.strictEqual(command.method, 'CTRL_C');
+  });
+
+  it('should send stop command to a detached screen session', () => {
+    const store = createStore();
+    store.save(createDetachedRecord());
+    const runner = createRunner({
+      'screen -ls': {
+        success: true,
+        stdout: '\t111.screen-session\t(Detached)\n',
+        stderr: '',
+        status: 0,
+        error: null,
+      },
+      'pgrep -P 111': {
+        success: true,
+        stdout: '222\n',
+        stderr: '',
+        status: 0,
+        error: null,
+      },
+    });
+
+    const result = controlExecution(
+      store,
+      'screen-session',
+      ControlAction.STOP,
+      runner
+    );
+
+    assert.strictEqual(result.success, true);
+    assert.match(result.output, /executionControl/);
+    assert.match(result.output, /action stop/);
+    assert.match(result.output, /method CTRL_C/);
+    assert.match(result.output, /screenPid 111/);
+    assert.deepStrictEqual(runner.calls[0], {
+      command: 'screen',
+      args: ['-S', 'screen-session', '-X', 'stuff', '\x03'],
+    });
+  });
+
+  it('should send docker terminate through docker kill', () => {
+    const store = createStore();
+    store.save(
+      createDetachedRecord({
+        uuid: 'docker-control-uuid',
+        options: {
+          isolated: 'docker',
+          isolationMode: 'detached',
+          sessionName: 'docker-session',
+          containerId: 'abc123',
+        },
+      })
+    );
+    const runner = createRunner({
+      'docker inspect -f {{.Id}} {{.State.Pid}} docker-session': {
+        success: true,
+        stdout: 'abcdef 444\n',
+        stderr: '',
+        status: 0,
+        error: null,
+      },
+    });
+
+    const result = controlExecution(
+      store,
+      'docker-control-uuid',
+      ControlAction.TERMINATE,
+      runner
+    );
+
+    assert.strictEqual(result.success, true);
+    assert.match(result.output, /action terminate/);
+    assert.match(result.output, /method SIGKILL/);
+    assert.match(result.output, /containerPid 444/);
+    assert.deepStrictEqual(runner.calls[0], {
+      command: 'docker',
+      args: ['kill', 'docker-session'],
+    });
+  });
+
+  it('should reject non-detached records', () => {
+    const store = createStore();
+    store.save(
+      createDetachedRecord({
+        options: {
+          isolated: 'screen',
+          isolationMode: 'attached',
+          sessionName: 'screen-session',
+        },
+      })
+    );
+
+    const result = controlExecution(
+      store,
+      'screen-session',
+      ControlAction.STOP,
+      createRunner()
+    );
+
+    assert.strictEqual(result.success, false);
+    assert.match(result.error, /Only detached isolated executions/);
+  });
+});
+
+describe('process id collection', () => {
+  it('should parse a GNU Screen process id from screen -ls output', () => {
+    const pid = parseScreenPid(
+      'There is a screen on:\n\t1234.my-session\t(Detached)\n',
+      'my-session'
+    );
+
+    assert.strictEqual(pid, 1234);
+  });
+
+  it('should collect wrapper, screen, and descendant process IDs', () => {
+    const runner = createRunner({
+      'screen -ls': {
+        success: true,
+        stdout: '\t111.screen-session\t(Detached)\n',
+        stderr: '',
+        status: 0,
+        error: null,
+      },
+      'pgrep -P 111': {
+        success: true,
+        stdout: '222\n333\n',
+        stderr: '',
+        status: 0,
+        error: null,
+      },
+      'pgrep -P 222': {
+        success: true,
+        stdout: '',
+        stderr: '',
+        status: 1,
+        error: null,
+      },
+      'pgrep -P 333': {
+        success: true,
+        stdout: '',
+        stderr: '',
+        status: 1,
+        error: null,
+      },
+    });
+
+    const processIds = collectProcessIds(createDetachedRecord(), runner);
+
+    assert.deepStrictEqual(processIds, {
+      wrapperPid: 12345,
+      screenPid: 111,
+      commandPids: [222, 333],
+    });
+  });
+});

package/test/{isolation-cleanup.test.js → isolation-cleanup.js}

@@ -241,29 +241,116 @@ describe('Isolation Resource Cleanup Verification', () => {
     // Use the canRunLinuxDockerImages function from isolation module
     // to properly detect if Linux containers can run (handles Windows containers mode)
     const { canRunLinuxDockerImages } = require('../src/lib/isolation');
+    const DOCKER_TEST_TIMEOUT = process.platform === 'win32' ? 30000 : 20000;
+    const DOCKER_STATE_WAIT_TIMEOUT =
+      process.platform === 'win32' ? 20000 : 10000;
+
+    it(
+      'should show docker container as exited after command completes (auto-exit by default)',
+      { timeout: DOCKER_TEST_TIMEOUT },
+      async () => {
+        if (!canRunLinuxDockerImages()) {
+          console.log(
+            '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+          );
+          return;
+        }
 
-    it('should show docker container as exited after command completes (auto-exit by default)', async () => {
-      if (!canRunLinuxDockerImages()) {
-        console.log(
-          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+        const containerName = `test-cleanup-docker-${Date.now()}`;
+
+        // Run a quick command in detached mode
+        const result = await runInDocker('echo "test" && sleep 0.1', {
+          image: 'alpine:latest',
+          session: containerName,
+          detached: true,
+          keepAlive: false,
+        });
+
+        assert.strictEqual(result.success, true);
+
+        // Wait for the container to exit
+        const containerExited = 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;
+          }
+        }, DOCKER_STATE_WAIT_TIMEOUT);
+
+        assert.ok(
+          containerExited,
+          'Docker container should be in exited state after command completes (auto-exit by default)'
         );
-        return;
+
+        // Verify with docker ps -a that container is exited (not running)
+        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'
+          );
+
+          const runningContainers = execSync('docker ps', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          assert.ok(
+            !runningContainers.includes(containerName),
+            'Container should NOT appear in docker ps (not running)'
+          );
+          console.log(
+            '  ✓ Docker container auto-exited and stopped (resources released, filesystem preserved)'
+          );
+        } catch (err) {
+          assert.fail(`Failed to verify container status: ${err.message}`);
+        }
+
+        // Clean up
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore cleanup errors
+        }
       }
+    );
+
+    it(
+      'should keep docker container running when keepAlive is true',
+      { timeout: DOCKER_TEST_TIMEOUT },
+      async () => {
+        if (!canRunLinuxDockerImages()) {
+          console.log(
+            '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+          );
+          return;
+        }
 
-      const containerName = `test-cleanup-docker-${Date.now()}`;
+        const containerName = `test-keepalive-docker-${Date.now()}`;
 
-      // Run a quick command in detached mode
-      const result = await runInDocker('echo "test" && sleep 0.1', {
-        image: 'alpine:latest',
-        session: containerName,
-        detached: true,
-        keepAlive: false,
-      });
+        // Run command with keepAlive enabled
+        const result = await runInDocker('echo "test"', {
+          image: 'alpine:latest',
+          session: containerName,
+          detached: true,
+          keepAlive: true,
+        });
 
-      assert.strictEqual(result.success, true);
+        assert.strictEqual(result.success, true);
+
+        // Wait a bit for the command to complete
+        await new Promise((resolve) => setTimeout(resolve, 1000));
 
-      // Wait for the container to exit
-      const containerExited = await waitFor(() => {
+        // Container should still be running
         try {
           const status = execSync(
             `docker inspect -f '{{.State.Status}}' ${containerName}`,
@@ -272,101 +359,25 @@ describe('Isolation Resource Cleanup Verification', () => {
               stdio: ['pipe', 'pipe', 'pipe'],
             }
           ).trim();
-          return status === 'exited';
-        } catch {
-          return false;
+          assert.strictEqual(
+            status,
+            'running',
+            'Container should still be running with keepAlive=true'
+          );
+          console.log(
+            '  ✓ Docker container kept running as expected with --keep-alive'
+          );
+        } catch (err) {
+          assert.fail(`Failed to verify container is running: ${err.message}`);
         }
-      }, 10000);
-
-      assert.ok(
-        containerExited,
-        'Docker container should be in exited state after command completes (auto-exit by default)'
-      );
-
-      // Verify with docker ps -a that container is exited (not running)
-      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'
-        );
-
-        const runningContainers = execSync('docker ps', {
-          encoding: 'utf8',
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        assert.ok(
-          !runningContainers.includes(containerName),
-          'Container should NOT appear in docker ps (not running)'
-        );
-        console.log(
-          '  ✓ Docker container auto-exited and stopped (resources released, filesystem preserved)'
-        );
-      } catch (err) {
-        assert.fail(`Failed to verify container status: ${err.message}`);
-      }
-
-      // Clean up
-      try {
-        execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
-      } catch {
-        // Ignore cleanup errors
-      }
-    });
-
-    it('should keep docker container running when keepAlive is true', async () => {
-      if (!canRunLinuxDockerImages()) {
-        console.log(
-          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
-        );
-        return;
-      }
-
-      const containerName = `test-keepalive-docker-${Date.now()}`;
-
-      // Run command with keepAlive enabled
-      const result = await runInDocker('echo "test"', {
-        image: 'alpine:latest',
-        session: containerName,
-        detached: true,
-        keepAlive: true,
-      });
-
-      assert.strictEqual(result.success, true);
-
-      // Wait a bit for the command to complete
-      await new Promise((resolve) => setTimeout(resolve, 1000));
 
-      // Container should still be running
-      try {
-        const status = execSync(
-          `docker inspect -f '{{.State.Status}}' ${containerName}`,
-          {
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-          }
-        ).trim();
-        assert.strictEqual(
-          status,
-          'running',
-          'Container should still be running with keepAlive=true'
-        );
-        console.log(
-          '  ✓ Docker container kept running as expected with --keep-alive'
-        );
-      } catch (err) {
-        assert.fail(`Failed to verify container is running: ${err.message}`);
-      }
-
-      // Clean up
-      try {
-        execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
-      } catch {
-        // Ignore cleanup errors
+        // Clean up
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore cleanup errors
+        }
       }
-    });
+    );
   });
 });

package/test/{isolation.test.js → isolation.js}

@@ -7,6 +7,7 @@
 
 const { describe, it } = require('node:test');
 const assert = require('assert');
+const path = require('path');
 const {
   isCommandAvailable,
   hasTTY,
@@ -525,7 +526,7 @@ describe('Isolation Runner with Available Backends', () => {
   } = require('../src/lib/isolation');
   const { execSync } = require('child_process');
 
-  // Screen integration tests moved to screen-integration.test.js
+  // Screen integration tests moved to screen-integration.js
   // to keep file under the 1000-line limit.
 
   describe('runInTmux (if available)', () => {
@@ -668,8 +669,9 @@ describe('detectShellInEnvironment', () => {
       { image: 'alpine:latest' },
       'auto'
     );
+    const shellName = path.basename(result);
     assert.ok(
-      ['bash', 'zsh', 'sh'].includes(result),
+      ['bash', 'zsh', 'sh'].includes(shellName),
       `Expected a valid shell (bash/zsh/sh), got: ${result}`
     );
     console.log(`  Detected shell in alpine:latest: ${result}`);

package/test/merge-changesets.mjs

@@ -0,0 +1,154 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { mergeChangesetsIn } from '../../scripts/merge-changesets.mjs';
+
+function makeTempPackage(packageName) {
+  const dir = mkdtempSync(join(tmpdir(), 'merge-changesets-'));
+  writeFileSync(
+    join(dir, 'package.json'),
+    JSON.stringify({ name: packageName, version: '0.0.0' })
+  );
+  mkdirSync(join(dir, '.changeset'));
+  return dir;
+}
+
+function writeChangeset(dir, fileName, body) {
+  writeFileSync(join(dir, '.changeset', fileName), body);
+}
+
+describe('mergeChangesetsIn', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = makeTempPackage('start-command');
+  });
+
+  afterEach(() => {
+    if (tmpDir && existsSync(tmpDir)) {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('does nothing with zero changesets', () => {
+    const result = mergeChangesetsIn(tmpDir);
+    expect(result.merged).toBe(false);
+    expect(readdirSync(join(tmpDir, '.changeset'))).toEqual([]);
+  });
+
+  it('does nothing with a single changeset', () => {
+    writeChangeset(
+      tmpDir,
+      'lone.md',
+      `---\n'start-command': patch\n---\n\nOnly one\n`
+    );
+    const result = mergeChangesetsIn(tmpDir);
+    expect(result.merged).toBe(false);
+    expect(readdirSync(join(tmpDir, '.changeset'))).toEqual(['lone.md']);
+  });
+
+  it('merges multiple changesets into a single file with the highest bump', () => {
+    writeChangeset(
+      tmpDir,
+      'a.md',
+      `---\n'start-command': patch\n---\n\nFix A\n`
+    );
+    writeChangeset(
+      tmpDir,
+      'b.md',
+      `---\n'start-command': minor\n---\n\nFeature B\n`
+    );
+
+    const result = mergeChangesetsIn(tmpDir);
+    expect(result.merged).toBe(true);
+    expect(result.bumpType).toBe('minor');
+
+    const files = readdirSync(join(tmpDir, '.changeset'));
+    expect(files.length).toBe(1);
+    const mergedFile = files[0];
+    expect(mergedFile.startsWith('merged-')).toBe(true);
+
+    const content = readFileSync(
+      join(tmpDir, '.changeset', mergedFile),
+      'utf8'
+    );
+    expect(content).toContain("'start-command': minor");
+    expect(content).toContain('Fix A');
+    expect(content).toContain('Feature B');
+  });
+
+  it('chooses major over minor and patch', () => {
+    writeChangeset(tmpDir, 'a.md', `---\n'start-command': patch\n---\n\nFix\n`);
+    writeChangeset(
+      tmpDir,
+      'b.md',
+      `---\n'start-command': major\n---\n\nBreaking\n`
+    );
+    writeChangeset(
+      tmpDir,
+      'c.md',
+      `---\n'start-command': minor\n---\n\nFeat\n`
+    );
+
+    const result = mergeChangesetsIn(tmpDir);
+    expect(result.bumpType).toBe('major');
+  });
+
+  it('reads package name from package.json (no hardcoded placeholder)', () => {
+    const otherDir = mkdtempSync(join(tmpdir(), 'merge-changesets-other-'));
+    try {
+      writeFileSync(
+        join(otherDir, 'package.json'),
+        JSON.stringify({ name: 'some-other-pkg', version: '1.0.0' })
+      );
+      mkdirSync(join(otherDir, '.changeset'));
+      writeFileSync(
+        join(otherDir, '.changeset', 'a.md'),
+        `---\n'some-other-pkg': minor\n---\n\nA\n`
+      );
+      writeFileSync(
+        join(otherDir, '.changeset', 'b.md'),
+        `---\n'some-other-pkg': patch\n---\n\nB\n`
+      );
+
+      const result = mergeChangesetsIn(otherDir);
+      expect(result.merged).toBe(true);
+
+      const files = readdirSync(join(otherDir, '.changeset'));
+      const merged = readFileSync(
+        join(otherDir, '.changeset', files[0]),
+        'utf8'
+      );
+      expect(merged).toContain("'some-other-pkg': minor");
+    } finally {
+      rmSync(otherDir, { recursive: true, force: true });
+    }
+  });
+
+  it('throws when .changeset directory is missing', () => {
+    const noChangesetDir = mkdtempSync(
+      join(tmpdir(), 'merge-changesets-empty-')
+    );
+    try {
+      writeFileSync(
+        join(noChangesetDir, 'package.json'),
+        JSON.stringify({ name: 'x', version: '0.0.0' })
+      );
+      expect(() => mergeChangesetsIn(noChangesetDir)).toThrow(
+        /Changeset directory not found/
+      );
+    } finally {
+      rmSync(noChangesetDir, { recursive: true, force: true });
+    }
+  });
+});