start-command 0.26.0 → 0.27.1

package/test/publish-to-crates.mjs

@@ -0,0 +1,194 @@
+import { describe, expect, it } from 'bun:test';
+import { spawn } from 'node:child_process';
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(testDir, '../..');
+const scriptPath = resolve(repoRoot, 'scripts/publish-to-crates.mjs');
+
+function createCargoPackage(tempDir) {
+  const packageDir = join(tempDir, 'crate');
+  const cargoTomlPath = join(packageDir, 'Cargo.toml');
+  mkdirSync(packageDir);
+  writeFileSync(
+    cargoTomlPath,
+    '[package]\nname = "example-crate"\nversion = "1.2.3"\nedition = "2021"\n'
+  );
+  return packageDir;
+}
+
+function createFakeCargoBin(tempDir) {
+  const fakeCargoJs = join(tempDir, 'fake-cargo.cjs');
+  writeFileSync(
+    fakeCargoJs,
+    `
+const fs = require('node:fs');
+fs.writeFileSync(process.env.FAKE_CARGO_ARGS_PATH, JSON.stringify(process.argv.slice(2)));
+process.exit(Number(process.env.FAKE_CARGO_EXIT || 0));
+`
+  );
+
+  return fakeCargoJs;
+}
+
+async function withCratesServer(status, callback) {
+  const requests = [];
+  const server = createServer((request, response) => {
+    requests.push(request.url);
+    response.writeHead(status, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ ok: status === 200 }));
+  });
+
+  await new Promise((resolveListen) =>
+    server.listen(0, '127.0.0.1', resolveListen)
+  );
+  const { port } = server.address();
+
+  try {
+    return await callback(`http://127.0.0.1:${port}/api/v1`, requests);
+  } finally {
+    await new Promise((resolveClose) => server.close(resolveClose));
+  }
+}
+
+function runScript({
+  cargoToken = '',
+  cratesIoBaseUrl,
+  fakeCargo = false,
+  packageDir,
+  tempDir,
+}) {
+  const outputPath = join(tempDir, 'github-output.txt');
+  const cargoArgsPath = join(tempDir, 'cargo-args.json');
+  const fakeCargoJs = fakeCargo ? createFakeCargoBin(tempDir) : '';
+
+  const env = {
+    ...process.env,
+    CARGO_REGISTRY_TOKEN: cargoToken,
+    CRATES_IO_BASE_URL: cratesIoBaseUrl,
+    CRATES_PUBLISH_RETRY_DELAY_MS: '1',
+    FAKE_CARGO_ARGS_PATH: cargoArgsPath,
+    GITHUB_OUTPUT: outputPath,
+  };
+
+  if (fakeCargoJs) {
+    env.START_CARGO_COMMAND = process.execPath;
+    env.START_CARGO_COMMAND_ARGS = JSON.stringify([fakeCargoJs]);
+  }
+
+  return new Promise((resolveRun, rejectRun) => {
+    const child = spawn('node', [scriptPath, '--working-dir', packageDir], {
+      cwd: repoRoot,
+      env,
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk;
+    });
+    child.on('error', rejectRun);
+    child.on('close', (status, signal) => {
+      resolveRun({
+        cargoArgsPath,
+        outputPath,
+        result: {
+          signal,
+          status,
+          stderr,
+          stdout,
+        },
+      });
+    });
+  });
+}
+
+describe('publish-to-crates script', () => {
+  it('reports success without a token when the version is already published', async () => {
+    await withCratesServer(200, async (cratesIoBaseUrl, requests) => {
+      const tempDir = mkdtempSync(join(tmpdir(), 'publish-crates-test-'));
+      const packageDir = createCargoPackage(tempDir);
+
+      try {
+        const { outputPath, result } = await runScript({
+          cratesIoBaseUrl,
+          packageDir,
+          tempDir,
+        });
+
+        expect(result.status).toBe(0);
+        expect(result.stdout).toContain('already_published=true');
+        expect(readFileSync(outputPath, 'utf8')).toContain('published=true');
+        expect(requests).toEqual(['/api/v1/crates/example-crate/1.2.3']);
+      } finally {
+        rmSync(tempDir, { force: true, recursive: true });
+      }
+    });
+  });
+
+  it('fails clearly when a missing version needs a crates token', async () => {
+    await withCratesServer(404, async (cratesIoBaseUrl) => {
+      const tempDir = mkdtempSync(join(tmpdir(), 'publish-crates-test-'));
+      const packageDir = createCargoPackage(tempDir);
+
+      try {
+        const { result } = await runScript({
+          cratesIoBaseUrl,
+          packageDir,
+          tempDir,
+        });
+
+        expect(result.status).not.toBe(0);
+        expect(result.stderr).toContain('Missing crates.io token');
+      } finally {
+        rmSync(tempDir, { force: true, recursive: true });
+      }
+    });
+  });
+
+  it('publishes a missing version with cargo publish', async () => {
+    await withCratesServer(404, async (cratesIoBaseUrl) => {
+      const tempDir = mkdtempSync(join(tmpdir(), 'publish-crates-test-'));
+      const packageDir = createCargoPackage(tempDir);
+
+      try {
+        const { cargoArgsPath, outputPath, result } = await runScript({
+          cargoToken: 'test-token',
+          cratesIoBaseUrl,
+          fakeCargo: true,
+          packageDir,
+          tempDir,
+        });
+
+        expect(result.status).toBe(0);
+        expect(result.stdout).toContain('publish_result=published');
+        expect(readFileSync(outputPath, 'utf8')).toContain('published=true');
+        expect(JSON.parse(readFileSync(cargoArgsPath, 'utf8'))).toEqual([
+          'publish',
+          '--allow-dirty',
+          '--manifest-path',
+          join(packageDir, 'Cargo.toml'),
+          '--token',
+          'test-token',
+        ]);
+      } finally {
+        rmSync(tempDir, { force: true, recursive: 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);
     });
 

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