start-command 0.26.0 → 0.27.0

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.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 });
+    }
+  });
+});

package/test/release-name.mjs

@@ -0,0 +1,117 @@
+import { describe, expect, it } from 'bun:test';
+import {
+  encodeShieldsStaticBadgeSegment,
+  extractChangelogEntry,
+  normalizeReleaseVersionForBadge,
+  packageVersionBadge,
+  releaseName,
+  releaseTag,
+} from '../../scripts/release-name.mjs';
+
+describe('releaseTag', () => {
+  it('uses plain "v${version}" when no prefix is given', () => {
+    expect(releaseTag('0.25.4')).toBe('v0.25.4');
+    expect(releaseTag('0.25.4', '')).toBe('v0.25.4');
+  });
+
+  it('prepends known language prefixes', () => {
+    expect(releaseTag('0.25.4', 'js-')).toBe('js-v0.25.4');
+    expect(releaseTag('0.14.0', 'rust-')).toBe('rust-v0.14.0');
+  });
+
+  it('passes arbitrary prefixes through', () => {
+    expect(releaseTag('1.0.0', 'api-')).toBe('api-v1.0.0');
+  });
+});
+
+describe('releaseName', () => {
+  it('returns bare version when prefix is empty (preserves pre-issue-108 behaviour)', () => {
+    expect(releaseName('0.25.4')).toBe('0.25.4');
+    expect(releaseName('0.25.4', '')).toBe('0.25.4');
+  });
+
+  it('decorates known language prefixes with human titles', () => {
+    expect(releaseName('0.25.4', 'js-')).toBe('[JavaScript] 0.25.4');
+    expect(releaseName('0.14.0', 'rust-')).toBe('[Rust] 0.14.0');
+  });
+
+  it('falls back to "${prefix}${version}" for unknown prefixes', () => {
+    expect(releaseName('1.0.0', 'api-')).toBe('api-1.0.0');
+  });
+});
+
+describe('release badge helpers', () => {
+  it('strips plain and language-prefixed v tags before building badge versions', () => {
+    expect(normalizeReleaseVersionForBadge('v1.2.3')).toBe('1.2.3');
+    expect(normalizeReleaseVersionForBadge('js-v1.2.3')).toBe('1.2.3');
+    expect(normalizeReleaseVersionForBadge('rust-v0.14.1')).toBe('0.14.1');
+  });
+
+  it('escapes shields.io static badge path delimiters in prerelease versions', () => {
+    expect(encodeShieldsStaticBadgeSegment('1.0.0-alpha_1')).toBe(
+      '1.0.0--alpha__1'
+    );
+  });
+
+  it('builds an exact npm version badge without leaking the js tag prefix', () => {
+    const badge = packageVersionBadge({
+      packageType: 'npm',
+      packageName: 'start-command',
+      releaseVersion: 'js-v1.2.3',
+    });
+
+    expect(badge).toContain('/badge/npm-1.2.3-blue.svg');
+    expect(badge).not.toContain('/badge/npm-js-v1.2.3-blue.svg');
+    expect(badge).toContain('/start-command/v/1.2.3');
+  });
+
+  it('builds an exact crates.io version badge without leaking the rust tag prefix', () => {
+    const badge = packageVersionBadge({
+      packageType: 'crates',
+      packageName: 'start-command',
+      releaseVersion: 'rust-v0.14.1',
+    });
+
+    expect(badge).toContain('/badge/crates.io-0.14.1-orange.svg');
+    expect(badge).not.toContain('/badge/crates.io-rust-v0.14.1-orange.svg');
+    expect(badge).toContain('/crates/start-command/0.14.1');
+  });
+});
+
+describe('extractChangelogEntry', () => {
+  it('extracts a Changesets-style JavaScript entry', () => {
+    const changelog = `# start-command
+
+## 1.2.3
+
+### Patch Changes
+
+- Fix release badges.
+
+## 1.2.2
+
+- Previous change.
+`;
+
+    expect(extractChangelogEntry(changelog, 'js-v1.2.3')).toBe(
+      '### Patch Changes\n\n- Fix release badges.'
+    );
+  });
+
+  it('extracts a Keep-a-Changelog-style Rust entry', () => {
+    const changelog = `# Changelog
+
+## [0.14.1] - 2026-05-02
+
+- Fix Rust release automation.
+
+## [0.14.0] - 2026-04-24
+
+- Previous change.
+`;
+
+    expect(extractChangelogEntry(changelog, 'rust-v0.14.1')).toBe(
+      '- Fix Rust release automation.'
+    );
+  });
+});

package/test/{screen-integration.test.js → screen-integration.js}

@@ -2,7 +2,7 @@
 /**
  * Integration tests for screen isolation
  * Tests actual screen session behavior including output capture, exit codes, and edge cases.
- * Extracted from isolation.test.js to keep file sizes under the 1000-line limit.
+ * Extracted from isolation.js to keep file sizes under the 1000-line limit.
  */
 
 const { describe, it } = require('node:test');

package/test/{ssh-integration.test.js → ssh-integration.js}

@@ -9,7 +9,7 @@
  * To run locally:
  * 1. Ensure SSH server is running
  * 2. Set up passwordless SSH to localhost (ssh-keygen, ssh-copy-id localhost)
- * 3. Run: bun test test/ssh-integration.test.js
+ * 3. Run: bun run test test/ssh-integration.js
  */
 
 const { describe, it, before } = require('node:test');

package/test/{status-query.test.js → status-query.js}

@@ -123,6 +123,7 @@ describe('--status query functionality', () => {
       expect(parsed.status).toBe('executed');
       expect(parsed.exitCode).toBe(0);
       expect(parsed.pid).toBe(12345);
+      expect(parsed.processIds).toEqual({ wrapperPid: 12345 });
     });
   });
 
@@ -215,6 +216,7 @@ describe('--status query functionality', () => {
         (record) => record.uuid === executingRecord.uuid
       );
       expect(executing.status).toBe('executing');
+      expect(executing.processIds).toEqual({ wrapperPid: 99999 });
       expect(executing.currentTime).toBeDefined();
     });
 

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

@@ -225,11 +225,10 @@ function runTests() {
       console.log(`    Expected: "${test.expected}"`);
       console.log(`    Got:      "${actual}"`);
     });
-    process.exit(1);
+    throw new Error(`${failed} substitution tests failed`);
   }
 
   console.log('\n✓ All tests passed!\n');
-  process.exit(0);
 }
 
 // Run tests

package/test/{user-manager.test.js → user-manager.js}

@@ -17,6 +17,8 @@ const {
   getUserInfo,
 } = require('../src/lib/user-manager');
 
+const isWindows = process.platform === 'win32';
+
 describe('user-manager', () => {
   describe('getCurrentUser', () => {
     it('should return a non-empty string', () => {
@@ -27,6 +29,11 @@ describe('user-manager', () => {
 
     it('should return a valid username format', () => {
       const user = getCurrentUser();
+      if (isWindows) {
+        assert.ok(!/[\r\n]/.test(user));
+        return;
+      }
+
       // Username should contain only valid characters
       assert.ok(/^[a-zA-Z0-9_-]+$/.test(user));
     });
@@ -55,6 +62,11 @@ describe('user-manager', () => {
   describe('userExists', () => {
     it('should return true for current user', () => {
       const currentUser = getCurrentUser();
+      if (isWindows) {
+        assert.strictEqual(typeof userExists(currentUser), 'boolean');
+        return;
+      }
+
       assert.strictEqual(userExists(currentUser), true);
     });
 
@@ -130,6 +142,11 @@ describe('user-manager', () => {
     it('should return user info for current user', () => {
       const currentUser = getCurrentUser();
       const info = getUserInfo(currentUser);
+      if (isWindows) {
+        assert.strictEqual(typeof info.exists, 'boolean');
+        return;
+      }
+
       assert.strictEqual(info.exists, true);
     });