feat: remove a partially-scaffolded project when interrupted

Add installGuard: beginInstall records the project directory the moment disk
work starts and registers SIGINT/SIGTERM handlers; completeInstall clears it
once the scaffold is done (so Ctrl+C on the finished project is safe). On
interrupt while a scaffold is in progress, the partial directory is removed.

It only ever removes a directory the installer created this run — both paths
reject a pre-existing directory up front — so user data is never touched. Wired
into the interactive path (CloneRepo begin, FileCleanup complete) and the
non-interactive path (around its operation block).

Author: fernandomg

source/__tests__/operations/installGuard.test.ts

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { beginInstall, completeInstall, removeActiveProject } = await import(
+  '../../operations/installGuard.js'
+)
+
+describe('installGuard', () => {
+  // Clear any active state left over from a previous test (module-level singleton).
+  beforeEach(() => {
+    completeInstall()
+  })
+
+  it('removes the active project folder when an install is in progress', () => {
+    const rm = vi.fn()
+    beginInstall('/tmp/proj')
+
+    removeActiveProject(rm)
+
+    expect(rm).toHaveBeenCalledWith('/tmp/proj', { recursive: true, force: true })
+  })
+
+  it('does nothing when no install is active', () => {
+    const rm = vi.fn()
+
+    removeActiveProject(rm)
+
+    expect(rm).not.toHaveBeenCalled()
+  })
+
+  it('does not remove after completeInstall — a finished project is safe', () => {
+    const rm = vi.fn()
+    beginInstall('/tmp/proj')
+    completeInstall()
+
+    removeActiveProject(rm)
+
+    expect(rm).not.toHaveBeenCalled()
+  })
+
+  it('removes only once, then clears the active folder', () => {
+    const rm = vi.fn()
+    beginInstall('/tmp/proj')
+
+    removeActiveProject(rm)
+    removeActiveProject(rm)
+
+    expect(rm).toHaveBeenCalledTimes(1)
+  })
+
+  it('tracks the most recent project folder', () => {
+    const rm = vi.fn()
+    beginInstall('/tmp/a')
+    beginInstall('/tmp/b')
+
+    removeActiveProject(rm)
+
+    expect(rm).toHaveBeenCalledWith('/tmp/b', { recursive: true, force: true })
+  })
+})

source/components/steps/CloneRepo/CloneRepo.tsx

@@ -2,7 +2,8 @@ import { Text } from 'ink'
 import { type FC, useCallback, useEffect, useState } from 'react'
 import type { Stack } from '../../../constants/config.js'
 import { cloneRepo } from '../../../operations/index.js'
-import { deriveStepDisplay } from '../../../utils/utils.js'
+import { beginInstall } from '../../../operations/installGuard.js'
+import { deriveStepDisplay, getProjectFolder } from '../../../utils/utils.js'
 import Divider from '../../Divider.js'
 
 interface Props {
@@ -21,6 +22,9 @@ const CloneRepo: FC<Props> = ({ stack, projectName, onCompletion }) => {
   }, [])
 
   useEffect(() => {
+    // Disk work starts here, so arm the interrupt guard before cloning.
+    beginInstall(getProjectFolder(projectName))
+
     cloneRepo(stack, projectName, handleProgress)
       .then(() => {
         setStatus('done')

source/components/steps/FileCleanup.tsx

@@ -2,6 +2,7 @@ import { Text } from 'ink'
 import { type FC, useCallback, useEffect, useMemo, useState } from 'react'
 import type { FeatureName, Stack } from '../../constants/config.js'
 import { cleanupFiles } from '../../operations/index.js'
+import { completeInstall } from '../../operations/installGuard.js'
 import type { InstallationType, MultiSelectItem } from '../../types/types.js'
 import { deriveStepDisplay, getProjectFolder } from '../../utils/utils.js'
 import Divider from '../Divider.js'
@@ -32,6 +33,8 @@ const FileCleanup: FC<Props> = ({ stack, onCompletion, installationConfig, proje
 
     cleanupFiles(stack, projectFolder, installationType ?? 'full', features, handleProgress)
       .then(() => {
+        // Scaffold is complete — an interrupt from here on must not delete the finished project.
+        completeInstall()
         setStatus('done')
         onCompletion()
       })

source/nonInteractive.ts

@@ -8,6 +8,7 @@ import {
   stackNames,
 } from './constants/config.js'
 import { cleanupFiles, cloneRepo, createEnvFile, installPackages } from './operations/index.js'
+import { beginInstall, completeInstall } from './operations/installGuard.js'
 import type { InstallationType } from './types/types.js'
 import {
   getPostInstallMessages,
@@ -141,15 +142,19 @@ export async function runNonInteractive(flags: {
 }): Promise<void> {
   const { stack, name, mode, features } = validate(flags)
 
-  try {
-    await cloneRepo(stack, name)
+  const projectFolder = getProjectFolder(name)
 
-    const projectFolder = getProjectFolder(name)
+  try {
+    // From here on a project directory exists on disk; an interrupt removes the partial scaffold.
+    beginInstall(projectFolder)
 
+    await cloneRepo(stack, name)
     await createEnvFile(stack, projectFolder, features)
     await installPackages(stack, projectFolder, mode, features)
     await cleanupFiles(stack, projectFolder, mode, features)
 
+    completeInstall()
+
     const result: SuccessResult = {
       success: true,
       stack,

source/operations/installGuard.ts

@@ -0,0 +1,44 @@
+import { rmSync } from 'node:fs'
+import process from 'node:process'
+
+// Tracks the project folder currently being scaffolded so an interrupt can remove the partial
+// directory. Only ever holds a folder the installer created this run (callers validate that the
+// directory did not exist before starting), so removing it on abort never touches user data.
+let activeProjectFolder: string | undefined
+let signalHandlersRegistered = false
+
+type RemoveDirectory = (path: string, options: { recursive: boolean; force: boolean }) => void
+
+// Removes the in-progress project folder, if any, then clears the active reference so a finished
+// or already-removed project is never deleted. `rm` is injectable for testing.
+export function removeActiveProject(rm: RemoveDirectory = rmSync): void {
+  if (activeProjectFolder === undefined) {
+    return
+  }
+
+  const folder = activeProjectFolder
+  activeProjectFolder = undefined
+  rm(folder, { recursive: true, force: true })
+}
+
+function handleAbort(signal: NodeJS.Signals): void {
+  removeActiveProject()
+  // Conventional exit code for a signal is 128 + signal number (SIGINT 2 → 130, SIGTERM 15 → 143).
+  process.exit(signal === 'SIGTERM' ? 143 : 130)
+}
+
+// Marks the start of disk-writing work. Registers interrupt handlers on first use.
+export function beginInstall(projectFolder: string): void {
+  activeProjectFolder = projectFolder
+
+  if (!signalHandlersRegistered) {
+    process.on('SIGINT', handleAbort)
+    process.on('SIGTERM', handleAbort)
+    signalHandlersRegistered = true
+  }
+}
+
+// Marks the scaffold complete; an interrupt after this point leaves the finished project intact.
+export function completeInstall(): void {
+  activeProjectFolder = undefined
+}