create-claude-workspace 1.1.53 → 1.1.55

package/dist/scripts/autonomous.mjs

@@ -203,32 +203,41 @@ function preflight(opts, log) {
 }
 // ─── Signal handling ───
 let stopping = false;
-let forceKilling = false;
 const stoppingRef = { value: false };
 function setupSignals(opts, log, checkpoint) {
-    const gracefulStop = (label) => {
-        if (forceKilling)
-            return; // CONC-5: ignore rapid signals during exit
-        forceKilling = true;
+    const die = (label, code) => {
         stopping = true;
         stoppingRef.value = true;
-        log.info(`${label}. Killing child process and exiting...`);
-        currentChild?.kill();
-        finalCleanup(opts, checkpoint, log);
-        process.exit(0);
+        try {
+            log.info(`${label}. Killing child process...`);
+        }
+        catch { /* ignore */ }
+        try {
+            currentChild?.kill();
+        }
+        catch { /* ignore */ }
+        try {
+            finalCleanup(opts, checkpoint, log);
+        }
+        catch { /* ignore */ }
+        process.exit(code);
     };
-    process.on('SIGINT', () => gracefulStop('SIGINT'));
-    process.on('SIGTERM', () => gracefulStop('SIGTERM'));
-    process.on('SIGPIPE', () => { }); // CONC-6: ignore
+    process.on('SIGINT', () => die('SIGINT', 0));
+    process.on('SIGTERM', () => die('SIGTERM', 0));
+    process.on('SIGPIPE', () => { }); // ignore
     process.on('uncaughtException', (err) => {
-        log.error(`Uncaught exception: ${err.message}`);
-        finalCleanup(opts, checkpoint, log);
-        process.exit(1);
+        try {
+            log.error(`Uncaught exception: ${err.message}`);
+        }
+        catch { /* ignore */ }
+        die('uncaughtException', 1);
     });
     process.on('unhandledRejection', (reason) => {
-        log.error(`Unhandled rejection: ${reason}`);
-        finalCleanup(opts, checkpoint, log);
-        process.exit(1);
+        try {
+            log.error(`Unhandled rejection: ${reason}`);
+        }
+        catch { /* ignore */ }
+        die('unhandledRejection', 1);
     });
 }
 function finalCleanup(opts, checkpoint, log) {

package/dist/scripts/docker-run.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // ─── Docker-based isolated runner for Claude Starter Kit ───
 // Single cross-platform script. Builds container, sets up auth, runs autonomous loop.
-import { spawnSync } from 'node:child_process';
+import { spawnSync, spawn as spawnAsync } from 'node:child_process';
 import { existsSync, writeFileSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir, platform as osPlatform, tmpdir } from 'node:os';
@@ -62,7 +62,41 @@ function cleanup() {
     }
     catch { /* ignore */ }
 }
+/** Run docker compose asynchronously — returns a promise that resolves on exit.
+ *  Ctrl+C triggers `docker compose kill` to forcefully stop the container. */
+function composeAsync(args) {
+    const files = [];
+    if (existsSync(AUTH_COMPOSE))
+        files.push('-f', 'docker-compose.yml', '-f', AUTH_COMPOSE);
+    const child = spawnAsync('docker', ['compose', ...files, ...args], {
+        cwd: DOCKER_DIR,
+        stdio: 'inherit',
+        env: { ...process.env },
+    });
+    const kill = () => {
+        // Forcefully kill the container — don't rely on Docker's signal forwarding
+        try {
+            spawnSync('docker', ['compose', ...files, 'kill'], {
+                cwd: DOCKER_DIR, stdio: 'ignore', timeout: 10_000,
+            });
+        }
+        catch { /* ignore */ }
+        cleanup();
+        process.exit(130);
+    };
+    process.on('SIGINT', kill);
+    process.on('SIGTERM', kill);
+    return new Promise((resolve) => {
+        child.on('close', (code) => {
+            process.removeListener('SIGINT', kill);
+            process.removeListener('SIGTERM', kill);
+            resolve(code ?? 1);
+        });
+        child.on('error', () => resolve(1));
+    });
+}
 process.on('exit', cleanup);
+// These handlers are overridden by composeAsync when running — fallback for non-async paths
 process.on('SIGINT', () => { cleanup(); process.exit(130); });
 process.on('SIGTERM', () => { cleanup(); process.exit(143); });
 function parseArgs() {
@@ -221,7 +255,7 @@ function startDaemon() {
     process.exit(1);
 }
 // ─── Main ───
-function main() {
+async function main() {
     const opts = parseArgs();
     if (opts.help) {
         printHelp();
@@ -320,6 +354,7 @@ function main() {
         info('  claude                                              # interactive Claude');
         info('  npx create-claude-workspace run                          # autonomous loop');
         console.log('');
+        // Shell mode uses spawnSync (interactive TTY needed)
         compose(['run', '--rm', 'claude']);
     }
     else {
@@ -338,14 +373,19 @@ function main() {
         const escaped = autoArgs.map(a => /^[\w.=/-]+$/.test(a) ? a : `'${a.replace(/'/g, "'\\''")}'`);
         console.log('');
         info('Autonomous mode — isolated in Docker, --skip-permissions is safe.');
-        info('Press Ctrl+C to stop after current iteration.');
+        info('Press Ctrl+C to stop.');
         console.log('');
-        compose(['run', '--rm', '-T', 'claude', '-c', `exec npx create-claude-workspace run ${escaped.join(' ')}`]);
+        // Use async spawn so SIGINT handler can fire and kill the container
+        const code = await composeAsync(['run', '--rm', '-T', 'claude', '-c', `exec npx create-claude-workspace run ${escaped.join(' ')}`]);
+        process.exit(code);
     }
 }
 export { main as runDockerLoop, parseArgs, printHelp };
 // Run only when executed directly, not when imported
 const isDirectRun = process.argv[1]?.replace(/\\/g, '/').endsWith('docker-run.mjs');
 if (isDirectRun) {
-    main();
+    main().catch(err => {
+        console.error('Fatal:', err);
+        process.exit(1);
+    });
 }

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

@@ -152,13 +152,12 @@ export function killProcessTree(pid, isWin) {
         catch { /* already dead */ }
         return;
     }
-    // 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)
+    // Unix: SIGKILL immediately — no SIGTERM grace period.
+    // Try process group first (negative PID), fall back to specific PID.
     try {
         process.kill(-pid, 'SIGKILL');
     }
     catch { /* no group or already dead */ }
-    // Fallback: kill the specific PID if process group kill failed
     try {
         process.kill(pid, 'SIGKILL');
     }
@@ -196,19 +195,19 @@ export function runClaude(opts, log, runOpts = {}) {
             flags.push('--dangerously-skip-permissions');
         // Reset stream state for this invocation
         resetStreamState();
-        // 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().
+        // Spawn WITHOUT detached — child stays in the same process group as parent.
+        // When user presses Ctrl+C, BOTH parent and child receive the signal from the OS.
+        // Parent's SIGINT handler kills child (backup) and calls process.exit().
+        // Child's own SIGINT handler also fires, causing it to exit.
         const child = isWin
             ? spawn(process.env.ComSpec ?? 'cmd.exe', ['/c', 'claude', ...flags], {
                 cwd: opts.projectDir,
                 stdio: ['pipe', 'pipe', 'pipe'],
-                detached: true,
                 windowsHide: true,
             })
             : spawn('claude', [...flags, prompt], {
                 cwd: opts.projectDir,
                 stdio: ['ignore', 'pipe', 'pipe'],
-                detached: true,
             });
         if (isWin && child.stdin) {
             child.stdin.write(prompt);

package/package.json

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