start-command 0.25.5 → 0.27.0

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 });
     });
   });
 
@@ -168,6 +169,78 @@ describe('--status query functionality', () => {
     });
   });
 
+  describe('--list query functionality', () => {
+    it('should output all tracked executions in links-notation format by default', () => {
+      const executingRecord = new ExecutionRecord({
+        command: 'sleep 100',
+        pid: 99999,
+        logPath: '/tmp/executing.log',
+        startTime: '2026-04-24T10:00:00.000Z',
+      });
+      store.save(executingRecord);
+
+      const result = runCli(['--list']);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toMatch(/^executions\n/);
+      expect(result.stdout).toContain('  count 2');
+      expect(result.stdout).toContain(`    ${testRecord.uuid}`);
+      expect(result.stdout).toContain(`    ${executingRecord.uuid}`);
+      expect(result.stdout).toContain('      command "echo hello world"');
+      expect(result.stdout).toContain('      command "sleep 100"');
+      expect(result.stdout).toContain('      status executed');
+      expect(result.stdout).toContain('      status executing');
+    });
+
+    it('should output all tracked executions in JSON format', () => {
+      const executingRecord = new ExecutionRecord({
+        command: 'sleep 100',
+        pid: 99999,
+        logPath: '/tmp/executing.log',
+      });
+      store.save(executingRecord);
+
+      const result = runCli(['--list', '--output-format', 'json']);
+
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.count).toBe(2);
+      expect(parsed.executions.length).toBe(2);
+      expect(parsed.executions.map((record) => record.uuid)).toContain(
+        testRecord.uuid
+      );
+      expect(parsed.executions.map((record) => record.uuid)).toContain(
+        executingRecord.uuid
+      );
+      const executing = parsed.executions.find(
+        (record) => record.uuid === executingRecord.uuid
+      );
+      expect(executing.status).toBe('executing');
+      expect(executing.processIds).toEqual({ wrapperPid: 99999 });
+      expect(executing.currentTime).toBeDefined();
+    });
+
+    it('should show count zero when no records are stored', () => {
+      cleanupTestDir();
+
+      const result = runCli(['--list']);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toMatch(/^executions\n/);
+      expect(result.stdout).toContain('  count 0');
+      expect(result.stdout).toContain('  records ()');
+    });
+
+    it('should show error when tracking is disabled', () => {
+      const result = runCli(['--list'], {
+        START_DISABLE_TRACKING: '1',
+      });
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain('tracking is disabled');
+    });
+  });
+
   describe('executing status', () => {
     it('should show executing status for ongoing commands', () => {
       // Create an executing (not completed) record

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

package/test/cli.test.js

@@ -1,218 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Unit tests for the CLI
- * Tests version flag and basic CLI behavior
- */
-
-const { describe, it } = require('node:test');
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-// Path to the CLI script
-const CLI_PATH = path.join(__dirname, '../src/bin/cli.js');
-
-// Timeout for CLI operations - longer on Windows due to cold-start latency
-const CLI_TIMEOUT = process.platform === 'win32' ? 30000 : 10000;
-
-// Helper to run CLI with timeout
-function runCLI(args = []) {
-  return spawnSync('bun', [CLI_PATH, ...args], {
-    encoding: 'utf8',
-    timeout: CLI_TIMEOUT,
-    env: {
-      ...process.env,
-      START_DISABLE_AUTO_ISSUE: '1',
-      START_DISABLE_LOG_UPLOAD: '1',
-    },
-  });
-}
-
-describe('CLI version flag', () => {
-  it('should display version with --version', () => {
-    const result = runCLI(['--version']);
-
-    // Check if process was killed (e.g., due to timeout)
-    assert.notStrictEqual(
-      result.status,
-      null,
-      `Process should complete (was killed with signal: ${result.signal})`
-    );
-    assert.strictEqual(result.status, 0, 'Exit code should be 0');
-
-    // Check for key elements in version output
-    assert.ok(
-      result.stdout.includes('start-command version:'),
-      'Should display start-command version'
-    );
-    assert.ok(result.stdout.includes('OS:'), 'Should display OS');
-    assert.ok(
-      result.stdout.includes('OS Version:'),
-      'Should display OS Version'
-    );
-    // Check for either Bun or Node.js version depending on runtime
-    const hasBunVersion = result.stdout.includes('Bun Version:');
-    const hasNodeVersion = result.stdout.includes('Node.js Version:');
-    assert.ok(
-      hasBunVersion || hasNodeVersion,
-      'Should display Bun Version or Node.js Version'
-    );
-    assert.ok(
-      result.stdout.includes('Architecture:'),
-      'Should display Architecture'
-    );
-    assert.ok(
-      result.stdout.includes('Isolation tools:'),
-      'Should display Isolation tools section'
-    );
-    assert.ok(
-      result.stdout.includes('screen:'),
-      'Should check for screen installation'
-    );
-    assert.ok(
-      result.stdout.includes('tmux:'),
-      'Should check for tmux installation'
-    );
-    assert.ok(
-      result.stdout.includes('docker:'),
-      'Should check for docker installation'
-    );
-  });
-
-  it('should display version with -v', () => {
-    const result = runCLI(['-v']);
-
-    assert.strictEqual(result.status, 0, 'Exit code should be 0');
-    assert.ok(
-      result.stdout.includes('start-command version:'),
-      'Should display start-command version'
-    );
-  });
-
-  it('should show correct package version', () => {
-    const result = runCLI(['--version']);
-    const packageJson = JSON.parse(
-      fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8')
-    );
-
-    assert.ok(
-      result.stdout.includes(`start-command version: ${packageJson.version}`),
-      `Should display version ${packageJson.version}`
-    );
-  });
-});
-
-describe('CLI basic behavior', () => {
-  it('should show usage when no arguments provided', () => {
-    const result = runCLI([]);
-
-    assert.strictEqual(result.status, 0, 'Exit code should be 0');
-    assert.ok(result.stdout.includes('Usage:'), 'Should display usage');
-    assert.ok(
-      result.stdout.includes('--version'),
-      'Usage should mention --version flag'
-    );
-  });
-
-  it('should show usage when no command provided after --', () => {
-    const result = runCLI(['--']);
-
-    assert.strictEqual(result.status, 0, 'Exit code should be 0');
-    assert.ok(result.stdout.includes('Usage:'), 'Should display usage');
-  });
-});
-
-describe('CLI isolation output (issue #67)', () => {
-  const { isCommandAvailable } = require('../src/lib/isolation');
-
-  it('should display screen session name when using screen isolation', async () => {
-    if (!isCommandAvailable('screen')) {
-      console.log('  Skipping: screen not installed');
-      return;
-    }
-
-    const result = runCLI(['-i', 'screen', '--', 'echo', 'hello']);
-
-    // The output should contain the screen session name (in format screen-timestamp-random)
-    // Check that the session UUID is displayed
-    assert.ok(
-      result.stdout.includes('│ session'),
-      'Should display session UUID'
-    );
-    // Check that screen isolation info is displayed
-    assert.ok(
-      result.stdout.includes('│ isolation screen'),
-      'Should display screen isolation'
-    );
-    // Check that the actual screen session name is displayed (issue #67 fix)
-    assert.ok(
-      result.stdout.includes('│ screen    screen-'),
-      'Should display actual screen session name for reconnection (issue #67)'
-    );
-  });
-
-  it('should display tmux session name when using tmux isolation', async () => {
-    if (!isCommandAvailable('tmux')) {
-      console.log('  Skipping: tmux not installed');
-      return;
-    }
-
-    const result = runCLI(['-i', 'tmux', '--', 'echo', 'hello']);
-
-    // The output should contain the tmux session name
-    assert.ok(
-      result.stdout.includes('│ session'),
-      'Should display session UUID'
-    );
-    assert.ok(
-      result.stdout.includes('│ isolation tmux'),
-      'Should display tmux isolation'
-    );
-    // Check that the actual tmux session name is displayed (issue #67 fix)
-    assert.ok(
-      result.stdout.includes('│ tmux      tmux-'),
-      'Should display actual tmux session name for reconnection (issue #67)'
-    );
-  });
-
-  it('should display docker container name when using docker isolation', async () => {
-    const { canRunLinuxDockerImages } = require('../src/lib/isolation');
-
-    if (!canRunLinuxDockerImages()) {
-      console.log(
-        '  Skipping: docker not available or cannot run Linux images'
-      );
-      return;
-    }
-
-    const result = runCLI([
-      '-i',
-      'docker',
-      '--image',
-      'alpine:latest',
-      '--',
-      'echo',
-      'hello',
-    ]);
-
-    // The output should contain the docker container name
-    assert.ok(
-      result.stdout.includes('│ session'),
-      'Should display session UUID'
-    );
-    assert.ok(
-      result.stdout.includes('│ isolation docker'),
-      'Should display docker isolation'
-    );
-    assert.ok(
-      result.stdout.includes('│ image     alpine:latest'),
-      'Should display docker image'
-    );
-    // Check that the actual container name is displayed (issue #67 fix)
-    assert.ok(
-      result.stdout.includes('│ container docker-'),
-      'Should display actual container name for reconnection (issue #67)'
-    );
-  });
-});