start-command 0.27.0 → 0.27.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # start-command
 
+## 0.27.1
+
+### Patch Changes
+
+- fe362a6: Fix CI release automation by making Docker cleanup tests tolerate Windows Docker startup latency and by hardening GitHub release creation.
+
 ## 0.27.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {

package/test/create-github-release.mjs

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'bun:test';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+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/create-github-release.mjs');
+
+function createFakeGhBin(tempDir) {
+  const fakeGhJs = join(tempDir, 'fake-gh.cjs');
+  writeFileSync(
+    fakeGhJs,
+    `
+const fs = require('node:fs');
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  input += chunk;
+});
+process.stdin.on('end', () => {
+  fs.writeFileSync(process.env.FAKE_GH_PAYLOAD_PATH, input);
+
+  if (process.env.FAKE_GH_MODE === 'already_exists') {
+    console.error('gh: Validation Failed (HTTP 422)');
+    console.error(JSON.stringify({
+      message: 'Validation Failed',
+      errors: [{ resource: 'Release', code: 'already_exists', field: 'tag_name' }],
+    }));
+    process.exit(1);
+  }
+
+  if (process.env.FAKE_GH_MODE === 'failure') {
+    console.error('gh: server exploded');
+    process.exit(1);
+  }
+
+  console.log(JSON.stringify({ html_url: 'https://github.test/release' }));
+  process.exit(0);
+});
+`
+  );
+
+  return fakeGhJs;
+}
+
+function runScript(mode) {
+  const tempDir = mkdtempSync(join(tmpdir(), 'create-release-test-'));
+  const payloadPath = join(tempDir, 'payload.json');
+  const changelogPath = join(tempDir, 'CHANGELOG.md');
+  writeFileSync(
+    changelogPath,
+    '# Changelog\n\n## [1.2.3] - 2026-05-03\n\n- Release automation fix.\n'
+  );
+  const fakeGhJs = createFakeGhBin(tempDir);
+
+  const result = spawnSync(
+    'node',
+    [
+      scriptPath,
+      '--release-version',
+      '1.2.3',
+      '--repository',
+      'owner/repo',
+      '--prefix',
+      'rust-',
+      '--changelog-file',
+      changelogPath,
+      '--badge-type',
+      'crates',
+      '--package-name',
+      'start-command',
+    ],
+    {
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        FAKE_GH_MODE: mode,
+        FAKE_GH_PAYLOAD_PATH: payloadPath,
+        START_GH_COMMAND: process.execPath,
+        START_GH_COMMAND_ARGS: JSON.stringify([fakeGhJs]),
+      },
+    }
+  );
+
+  const payload = JSON.parse(readFileSync(payloadPath, 'utf8'));
+  rmSync(tempDir, { force: true, recursive: true });
+  return { result, payload };
+}
+
+describe('create-github-release script', () => {
+  it('treats an existing GitHub release as an idempotent skip', () => {
+    const { result, payload } = runScript('already_exists');
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain(
+      'GitHub release already exists: rust-v1.2.3'
+    );
+    expect(result.stdout).not.toContain('Created GitHub release');
+    expect(payload).toMatchObject({
+      tag_name: 'rust-v1.2.3',
+      name: '[Rust] 1.2.3',
+    });
+    expect(payload.body).toContain('Release automation fix.');
+    expect(payload.body).toContain('crates.io');
+  });
+
+  it('fails when gh api returns an unexpected error', () => {
+    const { result } = runScript('failure');
+
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toContain('server exploded');
+    expect(result.stderr).toContain('GitHub release creation failed');
+  });
+});

package/test/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/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 });
+      }
+    });
+  });
+});