create-claude-workspace 1.1.52 → 1.1.53

package/dist/scripts/autonomous.mjs

@@ -208,18 +208,14 @@ const stoppingRef = { value: false };
 function setupSignals(opts, log, checkpoint) {
     const gracefulStop = (label) => {
         if (forceKilling)
-            return; // CONC-5: ignore rapid signals
-        if (stopping) {
-            forceKilling = true;
-            log.info('Force stopping...');
-            currentChild?.kill();
-            finalCleanup(opts, checkpoint, log);
-            process.exit(1);
-        }
-        log.info(`${label}. Killing child process and stopping (Ctrl+C again to force exit)...`);
+            return; // CONC-5: ignore rapid signals during exit
+        forceKilling = true;
         stopping = true;
         stoppingRef.value = true;
+        log.info(`${label}. Killing child process and exiting...`);
         currentChild?.kill();
+        finalCleanup(opts, checkpoint, log);
+        process.exit(0);
     };
     process.on('SIGINT', () => gracefulStop('SIGINT'));
     process.on('SIGTERM', () => gracefulStop('SIGTERM'));

package/dist/scripts/lib/claude-runner.mjs

@@ -152,17 +152,17 @@ export function killProcessTree(pid, isWin) {
         catch { /* already dead */ }
         return;
     }
-    // Unix: kill process group
+    // Unix: SIGKILL the entire process group immediately (no SIGTERM grace period —
+    // when the user presses Ctrl+C they want it dead NOW, not in 5 seconds)
     try {
-        process.kill(-pid, 'SIGTERM');
+        process.kill(-pid, 'SIGKILL');
     }
     catch { /* no group or already dead */ }
-    setTimeout(() => {
-        try {
-            process.kill(-pid, 'SIGKILL');
-        }
-        catch { /* already dead */ }
-    }, 5000).unref();
+    // Fallback: kill the specific PID if process group kill failed
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch { /* already dead */ }
 }
 // ─── Error signal patterns ───
 const RATE_LIMIT_RE = /rate.?limit|429|overloaded|529|at capacity|capacity reached|503 service unavailable|502 bad gateway/;
@@ -196,9 +196,8 @@ export function runClaude(opts, log, runOpts = {}) {
             flags.push('--dangerously-skip-permissions');
         // Reset stream state for this invocation
         resetStreamState();
-        // Spawn — detached on both platforms to isolate child from CTRL+C.
-        // First CTRL+C sets stopping flag (parent only); child finishes current step.
-        // Second CTRL+C force-kills the child via killProcessTree.
+        // Spawn — detached on both platforms so killProcessTree can target the process group.
+        // CTRL+C kills the child immediately (SIGKILL/taskkill) and exits the parent via process.exit().
         const child = isWin
             ? spawn(process.env.ComSpec ?? 'cmd.exe', ['/c', 'claude', ...flags], {
                 cwd: opts.projectDir,

package/dist/scripts/lib/claude-runner.spec.js

@@ -238,9 +238,20 @@ describe('resetStreamState', () => {
     });
 });
 // ─── killProcessTree integration tests ───
-// Verifies that Ctrl+C (killProcessTree) actually kills child processes.
+// Verifies that killProcessTree actually kills child process trees immediately
+// (SIGKILL on Unix, taskkill /T /F on Windows — no 5s SIGTERM grace period).
 const isWin = process.platform === 'win32';
 function isProcessAlive(pid) {
+    if (isWin) {
+        // process.kill(pid, 0) is unreliable on Windows for detached processes — use tasklist
+        try {
+            const info = execSync(`tasklist /FI "PID eq ${pid}" /NH`, { encoding: 'utf-8', stdio: 'pipe', timeout: 3000 });
+            return info.includes(String(pid));
+        }
+        catch {
+            return false;
+        }
+    }
     try {
         process.kill(pid, 0); // signal 0 = existence check
         return true;
@@ -265,7 +276,6 @@ function spawnLongRunning() {
 }
 /** Spawn a nested process tree: parent node → child node (simulates cmd.exe → claude) */
 function spawnNestedTree() {
-    // Parent spawns a child that also sleeps — simulates cmd.exe → claude process tree
     const innerScript = `
     const { spawn } = require('child_process');
     const child = spawn('node', ['-e', 'setTimeout(()=>{},60000)'], { stdio: 'ignore' });
@@ -285,62 +295,33 @@ function spawnNestedTree() {
     });
 }
 describe('killProcessTree', () => {
-    it('kills a simple child process', async () => {
-        const child = spawnLongRunning();
-        const pid = child.pid;
-        expect(pid).toBeGreaterThan(0);
-        // Give process time to start
-        await new Promise(r => setTimeout(r, 500));
-        expect(isProcessAlive(pid)).toBe(true);
-        // Kill it
-        killProcessTree(pid, isWin);
-        // Wait for process to die
-        await new Promise(r => setTimeout(r, isWin ? 2000 : 1000));
-        expect(isProcessAlive(pid)).toBe(false);
-    }, 10_000);
     it('kills a nested process tree (simulates cmd.exe → claude)', async () => {
         const parent = spawnNestedTree();
         const parentPid = parent.pid;
         expect(parentPid).toBeGreaterThan(0);
-        // Give tree time to start
         await new Promise(r => setTimeout(r, 1500));
         expect(isProcessAlive(parentPid)).toBe(true);
-        // Kill the tree
         killProcessTree(parentPid, isWin);
-        // Wait for tree to die
-        await new Promise(r => setTimeout(r, isWin ? 3000 : 2000));
+        await new Promise(r => setTimeout(r, isWin ? 3000 : 1000));
         expect(isProcessAlive(parentPid)).toBe(false);
-        // On Windows, verify no orphan node.exe children from our tree
-        if (isWin) {
-            // tasklist can't reliably check by parent PID after parent is dead,
-            // but the /T flag in taskkill should have killed all children
-            try {
-                const taskInfo = execSync(`tasklist /FI "PID eq ${parentPid}" /NH`, {
-                    encoding: 'utf-8', stdio: 'pipe', timeout: 3000,
-                });
-                expect(taskInfo).not.toContain(String(parentPid));
-            }
-            catch { /* process dead, expected */ }
-        }
     }, 15_000);
     it('does not throw when killing already-dead process', () => {
-        // PID 999999 is almost certainly not a real process
         expect(() => killProcessTree(999999, isWin)).not.toThrow();
     });
-    it('kills process fast enough for interactive use (< 3s)', async () => {
+    it('kills within 1 second — SIGKILL immediate, no 5s SIGTERM grace', async () => {
         const child = spawnLongRunning();
         const pid = child.pid;
         await new Promise(r => setTimeout(r, 500));
         const start = Date.now();
         killProcessTree(pid, isWin);
-        // Poll until dead or timeout
+        // Poll until dead
         let alive = true;
         while (alive && Date.now() - start < 3000) {
-            await new Promise(r => setTimeout(r, 100));
+            await new Promise(r => setTimeout(r, 50));
             alive = isProcessAlive(pid);
         }
         const elapsed = Date.now() - start;
         expect(alive).toBe(false);
-        expect(elapsed).toBeLessThan(3000);
+        expect(elapsed).toBeLessThan(isWin ? 2000 : 1000);
     }, 10_000);
 });

package/dist/template/.claude/agents/devops-integrator.md

@@ -45,7 +45,9 @@ First detect environment: `echo $CLAUDE_DOCKER` — if `1`, you are in Docker (D
   - macOS: `brew install glab`
   - Linux: `sudo apt install glab` / `sudo dnf install glab`
 
-**Auth in Docker:** If `GH_TOKEN`, `GITLAB_TOKEN`, or `CLICKUP_API_TOKEN` env var is set, it's used automatically (no interactive login needed). Otherwise return `needs_input` with `action: needs_github_token`, `action: needs_gitlab_token`, or `action: needs_clickup_token`.
+**Loading tokens from `.env`:** Before checking env vars, load tokens from `.env` file in the project root (if it exists). Use: `set -a && [ -f .env ] && . ./.env && set +a`. This allows users to store `GITLAB_TOKEN`, `GH_TOKEN`, `CLICKUP_API_TOKEN` in `.env` instead of exporting them in the shell. The `.env` file MUST be in `.gitignore` (check and add if missing).
+
+**Auth in Docker:** If `GH_TOKEN`, `GITLAB_TOKEN`, or `CLICKUP_API_TOKEN` env var is set (directly or via `.env`), it's used automatically (no interactive login needed). Otherwise return `needs_input` with `action: needs_github_token`, `action: needs_gitlab_token`, or `action: needs_clickup_token`.
 
 ## ClickUp API Helpers
 

package/dist/template/.claude/agents/orchestrator.md

@@ -71,6 +71,7 @@ At the beginning of EVERY session (including every Ralph Loop iteration):
 
 ### 1. Read state
 - Read MEMORY.md — find where you left off, what is done, what is next, what phase you're in
+- **Load `.env`**: If `.env` exists in the project root, source it to load tokens (`GITLAB_TOKEN`, `GH_TOKEN`, `CLICKUP_API_TOKEN`, etc.): `set -a && [ -f .env ] && . ./.env && set +a`
 
 ### 2. Resolve app names and package manager
 - Read CLAUDE.md — find app name(s) and package manager from the Architecture/Tech Stack section

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-workspace",
-  "version": "1.1.52",
+  "version": "1.1.53",
   "description": "Scaffold a project with Claude Code agents for autonomous AI-driven development",
   "type": "module",
   "bin": {