gitspace 0.2.0-rc.5 → 0.2.0-rc.6

package/README.md

@@ -208,7 +208,7 @@ fi
 
 Bundles can be loaded from:
 
-1. **In-repo** (automatic): `.gitspace/`, `.gitspace-config/`, `.spaces-config/`, or `.spaces/` in the cloned repository
+1. **In-repo** (automatic): `.gitspace/` directory in the cloned repository
 2. **Local path**: `gssh add project --bundle-path /path/to/bundle/`
 3. **Remote URL**: `gssh add project --bundle-url https://example.com/bundle.zip`
 

package/bun.lock

@@ -33,6 +33,12 @@
         "eslint": "^8.57.0",
         "typescript": "^5.3.3",
       },
+      "optionalDependencies": {
+        "@gitspace/darwin-arm64": "0.2.0-rc.5",
+        "@gitspace/darwin-x64": "0.2.0-rc.5",
+        "@gitspace/linux-arm64": "0.2.0-rc.5",
+        "@gitspace/linux-x64": "0.2.0-rc.5",
+      },
     },
   },
   "packages": {
@@ -46,6 +52,8 @@
 
     "@eslint/js": ["@eslint/js@8.57.1", "", {}, "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q=="],
 
+    "@gitspace/darwin-arm64": ["@gitspace/darwin-arm64@0.2.0-rc.5", "", { "os": "darwin", "cpu": "arm64", "bin": { "gssh-darwin-arm64": "bin/gssh" } }, "sha512-jeFMG2y/Ztvlfc9BHm1M4yyTR1P5bDtdpA40DVNSSdhGv4NpsGPifVBo5GUwEQOAO9QTHFuxkdAl+LK5dYS9yQ=="],
+
     "@graphql-typed-document-node/core": ["@graphql-typed-document-node/core@3.2.0", "", { "peerDependencies": { "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0" } }, "sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ=="],
 
     "@humanwhocodes/config-array": ["@humanwhocodes/config-array@0.13.0", "", { "dependencies": { "@humanwhocodes/object-schema": "^2.0.3", "debug": "^4.3.1", "minimatch": "^3.0.5" } }, "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw=="],

package/docs/SITE_DOCS_FIGMA_MAKE.md

@@ -311,18 +311,18 @@ git status
 
 ### Repo Config Bundles
 
-Bundles allow repository owners to share onboarding configurations. Place in `.gitspace-config/` in your repo:
+Bundles allow repository owners to share onboarding configurations. Place in `.gitspace/` in your repo:
 
 ```
-.gitspace-config/
-├── gitspace-bundle.json    # Bundle manifest with onboarding steps
+.gitspace/
+├── bundle.json           # Bundle manifest with onboarding steps
 ├── pre/                  # Scripts to run before setup
 ├── setup/                # Scripts to run on first workspace creation
 ├── select/               # Scripts to run every time workspace is opened
 └── remove/               # Scripts to run before workspace deletion
 ```
 
-Bundle manifest example (`gitspace-bundle.json`):
+Bundle manifest example (`bundle.json`):
 ```json
 {
   "version": "1.0",
@@ -388,7 +388,7 @@ fi
 ```
 
 Bundle sources:
-- **In-repo** (automatic): `.gitspace-config/`, `gitspace-config/`, or `.gitspace/` in the cloned repository
+- **In-repo** (automatic): `.gitspace/` directory in the cloned repository
 - **Local path**: `gssh add project --bundle-path /path/to/bundle/`
 - **Remote URL**: `gssh add project --bundle-url https://example.com/bundle.zip`
 
@@ -920,11 +920,11 @@ git status
 
 SECTION: Local Workflow - Repo Config Bundles
 
-Bundles allow teams to share onboarding configurations. Place in `.gitspace-config/`:
+Bundles allow teams to share onboarding configurations. Place in `.gitspace/`:
 
 ```
-.gitspace-config/
-├── gitspace-bundle.json    # Manifest
+.gitspace/
+├── bundle.json           # Manifest
 ├── pre/                  # Pre-setup scripts
 ├── setup/                # Setup scripts
 └── select/               # Select scripts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitspace",
-  "version": "0.2.0-rc.5",
+  "version": "0.2.0-rc.6",
   "description": "CLI for managing GitHub workspaces with git worktrees and secure remote terminal access",
   "bin": {
     "gssh": "./bin/gssh"
@@ -17,10 +17,10 @@
     "relay": "bun src/relay/index.ts"
   },
   "optionalDependencies": {
-    "@gitspace/darwin-arm64": "0.2.0-rc.5",
-    "@gitspace/darwin-x64": "0.2.0-rc.5",
-    "@gitspace/linux-x64": "0.2.0-rc.5",
-    "@gitspace/linux-arm64": "0.2.0-rc.5"
+    "@gitspace/darwin-arm64": "0.2.0-rc.6",
+    "@gitspace/darwin-x64": "0.2.0-rc.6",
+    "@gitspace/linux-x64": "0.2.0-rc.6",
+    "@gitspace/linux-arm64": "0.2.0-rc.6"
   },
   "keywords": [
     "cli",

package/src/commands/remove.ts

@@ -3,31 +3,27 @@
  * Handles 'gssh remove workspace' and 'gssh remove project'
  */
 
-import { existsSync, rmSync, readdirSync } from 'fs'
+import { existsSync, readdirSync } from 'fs'
 import { join } from 'path'
 import {
 	getCurrentProject,
 	readProjectConfig,
 	getProjectWorkspacesDir,
-	getProjectBaseDir,
 	getProjectDir,
-	readGlobalConfig,
-	updateGlobalConfig,
 	getAllProjectNames,
-	getScriptsPhaseDir,
 } from '../core/config.js'
+import { getWorktreeInfo } from '../core/git.js'
 import {
-	removeWorktree,
-	deleteLocalBranch,
-	getWorktreeInfo,
-} from '../core/git.js'
+	deleteWorkspaceCore,
+	deleteProjectCore,
+} from '../core/workspace.js'
 import { logger } from '../utils/logger.js'
 import { selectItem, promptConfirm, promptInput } from '../utils/prompts.js'
 import { SpacesError, NoProjectError } from '../types/errors.js'
-import { runScriptsInTerminal } from '../utils/run-scripts.js'
 
 /**
- * Remove a workspace
+ * Remove a workspace (CLI command)
+ * Handles interactive prompts and delegates to core deletion logic
  */
 export async function removeWorkspace(
 	workspaceNameArg?: string,
@@ -42,7 +38,6 @@ export async function removeWorkspace(
 	}
 
 	const workspacesDir = getProjectWorkspacesDir(currentProject)
-	const baseDir = getProjectBaseDir(currentProject)
 
 	if (!existsSync(workspacesDir)) {
 		throw new SpacesError('No workspaces found', 'USER_ERROR', 1)
@@ -82,7 +77,7 @@ export async function removeWorkspace(
 
 	const workspacePath = join(workspacesDir, workspaceName)
 
-	// Get workspace info
+	// Get workspace info for display
 	const info = await getWorktreeInfo(workspacePath)
 
 	if (!info) {
@@ -117,44 +112,37 @@ export async function removeWorkspace(
 		}
 	}
 
-	// Run remove scripts (cleanup before deletion)
-	const projectConfig = readProjectConfig(currentProject)
-	const removeScriptsDir = getScriptsPhaseDir(currentProject, 'remove')
-	await runScriptsInTerminal(
-		removeScriptsDir,
-		workspacePath,
-		workspaceName,
-		projectConfig.repository
-	)
+	// Delegate to core deletion logic (interactive mode for CLI)
+	logger.info('Removing workspace...')
+	const result = await deleteWorkspaceCore(currentProject, workspaceName, {
+		nonInteractive: false, // CLI is interactive
+		keepBranch: options.keepBranch,
+	})
 
-	// Remove worktree
-	logger.info('Removing worktree...')
-	await removeWorktree(baseDir, workspacePath, true)
+	if (!result.success) {
+		throw new SpacesError(
+			result.error || 'Failed to remove workspace',
+			'SYSTEM_ERROR',
+			2
+		)
+	}
 
 	logger.success(`Removed worktree: ${workspaceName}`)
 
-	// Ask about deleting local branch unless --keep-branch
-	if (!options.keepBranch) {
-		// const deleteBranch = await promptConfirm(`Delete local branch "${info.branch}"?`, false);
-		const deleteBranch = true
-
-		if (deleteBranch) {
-			try {
-				await deleteLocalBranch(baseDir, info.branch, true)
-				logger.success(`Deleted branch: ${info.branch}`)
-			} catch (error) {
-				logger.warning(
-					`Could not delete branch: ${
-						error instanceof Error ? error.message : 'Unknown error'
-					}`
-				)
-			}
-		}
+	if (result.sessionsKilled > 0) {
+		logger.info(`Killed ${result.sessionsKilled} active session(s)`)
+	}
+
+	if (result.branchDeleted) {
+		logger.success(`Deleted branch: ${result.branch}`)
+	} else if (result.branch && !options.keepBranch) {
+		logger.warning(`Could not delete branch: ${result.branch}`)
 	}
 }
 
 /**
- * Remove a project
+ * Remove a project (CLI command)
+ * Handles interactive prompts and delegates to core deletion logic
  */
 export async function removeProject(
 	projectNameArg?: string,
@@ -226,16 +214,44 @@ export async function removeProject(
 		}
 	}
 
-	// Remove entire project directory
-	logger.info('Removing project directory...')
-	rmSync(projectDir, { recursive: true, force: true })
+	// Delegate to core deletion logic (interactive mode for CLI)
+	logger.info('Removing project...')
+	const result = await deleteProjectCore(projectName, {
+		nonInteractive: false, // CLI is interactive
+	})
+
+	if (!result.success) {
+		if (result.errors.length > 0) {
+			for (const error of result.errors) {
+				logger.warning(`  ${error}`)
+			}
+		}
+		throw new SpacesError(
+			'Failed to remove project completely',
+			'SYSTEM_ERROR',
+			2
+		)
+	}
+
+	// Log any partial errors that occurred during cleanup (even on success)
+	if (result.errors.length > 0) {
+		logger.warning('Some cleanup operations had issues:')
+		for (const error of result.errors) {
+			logger.warning(`  ${error}`)
+		}
+	}
 
 	logger.success(`Removed project: ${projectName}`)
 
-	// Update global config if this was the current project
-	const globalConfig = readGlobalConfig()
-	if (globalConfig.currentProject === projectName) {
-		updateGlobalConfig({ currentProject: null })
+	if (result.sessionsKilled > 0) {
+		logger.info(`Killed ${result.sessionsKilled} active session(s)`)
+	}
+
+	if (result.workspacesDeleted > 0) {
+		logger.info(`Cleaned up ${result.workspacesDeleted} workspace(s)`)
+	}
+
+	if (result.wasCurrentProject) {
 		logger.info('Cleared current project (was this project)')
 	}
 }

package/src/core/__tests__/workspace.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Tests for workspace.ts core deletion functions
+ *
+ * These tests mock dependencies to test the orchestration logic
+ * without requiring a running tmux-lite server or actual git repos.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
+import { mkdirSync, rmSync, existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// We'll test the module by creating a real file structure
+// but mocking the tmux-lite and git operations
+
+describe('deleteWorkspaceCore', () => {
+  let testDir: string;
+  let projectDir: string;
+  let workspacesDir: string;
+  let baseDir: string;
+
+  // Track mock state
+  let mockSessions: Array<{ id: string; name: string; cwd: string }>;
+  let killedSessions: string[];
+  let removedWorktrees: string[];
+  let deletedBranches: string[];
+  let serverRunning: boolean;
+
+  beforeEach(() => {
+    // Create test directory structure
+    testDir = join(tmpdir(), `workspace-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    projectDir = join(testDir, 'gitspace', 'test-project');
+    workspacesDir = join(projectDir, 'workspaces');
+    baseDir = join(projectDir, 'base');
+
+    mkdirSync(workspacesDir, { recursive: true });
+    mkdirSync(baseDir, { recursive: true });
+
+    // Create a fake workspace
+    mkdirSync(join(workspacesDir, 'my-workspace'));
+
+    // Create project config
+    writeFileSync(join(projectDir, '.config.json'), JSON.stringify({
+      repository: 'owner/test-repo',
+      baseBranch: 'main',
+    }));
+
+    // Reset mock state
+    mockSessions = [];
+    killedSessions = [];
+    removedWorktrees = [];
+    deletedBranches = [];
+    serverRunning = true;
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+    mock.restore();
+  });
+
+  it('should export deleteWorkspaceCore function', async () => {
+    const { deleteWorkspaceCore } = await import('../workspace');
+    expect(typeof deleteWorkspaceCore).toBe('function');
+  });
+
+  it('should export deleteProjectCore function', async () => {
+    const { deleteProjectCore } = await import('../workspace');
+    expect(typeof deleteProjectCore).toBe('function');
+  });
+
+  it('should export DeleteWorkspaceOptions type', async () => {
+    // Type check - if this compiles, the type exists
+    const { deleteWorkspaceCore } = await import('../workspace');
+    const options: Parameters<typeof deleteWorkspaceCore>[2] = {
+      nonInteractive: true,
+      keepBranch: false,
+    };
+    expect(options.nonInteractive).toBe(true);
+  });
+
+  it('should export DeleteWorkspaceResult type', async () => {
+    const { deleteWorkspaceCore } = await import('../workspace');
+    // The return type should have these properties
+    type Result = Awaited<ReturnType<typeof deleteWorkspaceCore>>;
+    const checkType = (r: Result) => {
+      r.success;
+      r.workspaceName;
+      r.branch;
+      r.branchDeleted;
+      r.sessionsKilled;
+      r.error;
+    };
+    expect(typeof checkType).toBe('function');
+  });
+});
+
+describe('deleteProjectCore', () => {
+  it('should export DeleteProjectOptions type', async () => {
+    const { deleteProjectCore } = await import('../workspace');
+    const options: Parameters<typeof deleteProjectCore>[1] = {
+      nonInteractive: true,
+    };
+    expect(options.nonInteractive).toBe(true);
+  });
+
+  it('should export DeleteProjectResult type', async () => {
+    const { deleteProjectCore } = await import('../workspace');
+    type Result = Awaited<ReturnType<typeof deleteProjectCore>>;
+    const checkType = (r: Result) => {
+      r.success;
+      r.projectName;
+      r.workspacesDeleted;
+      r.sessionsKilled;
+      r.wasCurrentProject;
+      r.errors;
+    };
+    expect(typeof checkType).toBe('function');
+  });
+});
+
+describe('integration behavior', () => {
+  it('deleteWorkspaceCore should accept nonInteractive option', async () => {
+    // Verify the function signature accepts nonInteractive option
+    const { deleteWorkspaceCore } = await import('../workspace');
+    expect(typeof deleteWorkspaceCore).toBe('function');
+
+    // Verify the function's third parameter accepts the expected options
+    // This is a compile-time check - if it compiles, the type is correct
+    type Options = Parameters<typeof deleteWorkspaceCore>[2];
+    const options: Options = { nonInteractive: true, keepBranch: false };
+    expect(options.nonInteractive).toBe(true);
+    expect(options.keepBranch).toBe(false);
+
+    // Note: Full integration testing would require mocking many modules
+    // For now, we verify the API shape is correct
+  });
+
+  it('deleteProjectCore should accept nonInteractive option', async () => {
+    const { deleteProjectCore } = await import('../workspace');
+    expect(typeof deleteProjectCore).toBe('function');
+
+    // Verify the function's second parameter accepts the expected options
+    type Options = Parameters<typeof deleteProjectCore>[1];
+    const options: Options = { nonInteractive: true };
+    expect(options.nonInteractive).toBe(true);
+  });
+});

package/src/core/bundle.ts

@@ -23,7 +23,7 @@ import type { SpacesBundle, LoadedBundle } from '../types/bundle.js';
 import { getScriptsPhaseDir } from './config.js';
 
 const BUNDLE_FILENAME = 'bundle.json';
-const BUNDLE_SUBDIRS = ['.gitspace', '.gitspace-config', 'gitspace-config', '.spaces-config', 'spaces-config', '.spaces'];
+const BUNDLE_SUBDIRS = ['.gitspace'];
 const SCRIPT_PHASES = ['pre', 'setup', 'select', 'remove'] as const;
 
 function assertSafeExtractedPaths(rootDir: string): void {

package/src/core/workspace.ts

@@ -0,0 +1,249 @@
+/**
+ * Core workspace and project deletion operations
+ * These functions contain the shared logic used by CLI, TUI, and remote handlers
+ */
+
+import { existsSync, readdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import {
+  readProjectConfig,
+  getProjectWorkspacesDir,
+  getProjectBaseDir,
+  getProjectDir,
+  getScriptsPhaseDir,
+  readGlobalConfig,
+  updateGlobalConfig,
+} from './config.js';
+import {
+  removeWorktree,
+  deleteLocalBranch,
+  getWorktreeInfo,
+} from './git.js';
+import { runScriptsInTerminal } from '../utils/run-scripts.js';
+import { logger } from '../utils/logger.js';
+import {
+  listSessions,
+  killSession,
+  isServerRunning,
+} from '../lib/tmux-lite/cli.js';
+
+/**
+ * Options for workspace deletion
+ */
+export interface DeleteWorkspaceOptions {
+  /**
+   * Run in non-interactive mode (for TUI/daemon/remote contexts).
+   * When true, remove scripts run with stdin closed.
+   */
+  nonInteractive?: boolean;
+  /** Keep the local branch after removing worktree */
+  keepBranch?: boolean;
+}
+
+/**
+ * Result of workspace deletion
+ */
+export interface DeleteWorkspaceResult {
+  success: boolean;
+  workspaceName: string;
+  branch?: string;
+  branchDeleted: boolean;
+  sessionsKilled: number;
+  error?: string;
+}
+
+/**
+ * Core workspace deletion logic
+ * Used by CLI, TUI, and remote session handlers
+ *
+ * @param projectName - Name of the project containing the workspace
+ * @param workspaceName - Name of the workspace to delete
+ * @param options - Deletion options
+ */
+export async function deleteWorkspaceCore(
+  projectName: string,
+  workspaceName: string,
+  options: DeleteWorkspaceOptions = {}
+): Promise<DeleteWorkspaceResult> {
+  const workspacesDir = getProjectWorkspacesDir(projectName);
+  const baseDir = getProjectBaseDir(projectName);
+  const workspacePath = join(workspacesDir, workspaceName);
+
+  const result: DeleteWorkspaceResult = {
+    success: false,
+    workspaceName,
+    branchDeleted: false,
+    sessionsKilled: 0,
+  };
+
+  // Validate workspace exists before attempting deletion
+  if (!existsSync(workspacePath)) {
+    result.error = `Workspace "${workspaceName}" does not exist`;
+    return result;
+  }
+
+  // Get workspace info before deletion
+  const info = await getWorktreeInfo(workspacePath);
+  if (info) {
+    result.branch = info.branch;
+  }
+
+  // Kill any sessions running in this workspace
+  try {
+    if (await isServerRunning()) {
+      const sessions = await listSessions();
+      const workspaceSessions = sessions.filter(s => s.cwd === workspacePath);
+      for (const session of workspaceSessions) {
+        try {
+          await killSession(session.id);
+          result.sessionsKilled++;
+          logger.debug(`Killed session ${session.name} (${session.id})`);
+        } catch (e) {
+          logger.debug(`Failed to kill session ${session.id}: ${e}`);
+        }
+      }
+    }
+  } catch (e) {
+    logger.debug(`Error checking/killing sessions: ${e}`);
+  }
+
+  // Run remove scripts (cleanup before deletion)
+  try {
+    const projectConfig = readProjectConfig(projectName);
+    const removeScriptsDir = getScriptsPhaseDir(projectName, 'remove');
+    await runScriptsInTerminal(
+      removeScriptsDir,
+      workspacePath,
+      workspaceName,
+      projectConfig.repository,
+      { nonInteractive: options.nonInteractive }
+    );
+  } catch (e) {
+    // Scripts are best-effort, log but continue
+    logger.debug(`Remove scripts failed for ${workspaceName}: ${e}`);
+  }
+
+  // Remove worktree
+  try {
+    await removeWorktree(baseDir, workspacePath, true);
+  } catch (e) {
+    result.error = e instanceof Error ? e.message : 'Failed to remove worktree';
+    return result;
+  }
+
+  // Try to delete the local branch
+  if (!options.keepBranch && info?.branch) {
+    try {
+      await deleteLocalBranch(baseDir, info.branch, true);
+      result.branchDeleted = true;
+    } catch (e) {
+      // Branch deletion is best-effort
+      logger.debug(`Could not delete branch ${info.branch}: ${e}`);
+    }
+  }
+
+  result.success = true;
+  return result;
+}
+
+/**
+ * Options for project deletion
+ */
+export interface DeleteProjectOptions {
+  /**
+   * Run in non-interactive mode (for TUI/daemon/remote contexts).
+   * When true, remove scripts run with stdin closed.
+   */
+  nonInteractive?: boolean;
+}
+
+/**
+ * Result of project deletion
+ */
+export interface DeleteProjectResult {
+  success: boolean;
+  projectName: string;
+  workspacesDeleted: number;
+  sessionsKilled: number;
+  wasCurrentProject: boolean;
+  errors: string[];
+}
+
+/**
+ * Core project deletion logic
+ * Tears down sessions, runs remove scripts for all workspaces, then deletes project
+ *
+ * @param projectName - Name of the project to delete
+ * @param options - Deletion options
+ */
+export async function deleteProjectCore(
+  projectName: string,
+  options: DeleteProjectOptions = {}
+): Promise<DeleteProjectResult> {
+  const projectDir = getProjectDir(projectName);
+  const workspacesDir = getProjectWorkspacesDir(projectName);
+
+  const result: DeleteProjectResult = {
+    success: false,
+    projectName,
+    workspacesDeleted: 0,
+    sessionsKilled: 0,
+    wasCurrentProject: false,
+    errors: [],
+  };
+
+  // Validate project directory exists before attempting deletion
+  if (!existsSync(projectDir)) {
+    result.errors.push(`Project "${projectName}" does not exist`);
+    return result;
+  }
+
+  // Get list of workspaces
+  let workspaceNames: string[] = [];
+  if (existsSync(workspacesDir)) {
+    try {
+      workspaceNames = readdirSync(workspacesDir);
+    } catch (e) {
+      logger.debug(`Could not read workspaces dir: ${e}`);
+    }
+  }
+
+  // Delete each workspace (this handles session teardown and remove scripts)
+  for (const workspaceName of workspaceNames) {
+    try {
+      const wsResult = await deleteWorkspaceCore(projectName, workspaceName, {
+        nonInteractive: options.nonInteractive,
+        keepBranch: true, // Don't try to delete branches, we're removing the whole repo
+      });
+      if (wsResult.success) {
+        result.workspacesDeleted++;
+        result.sessionsKilled += wsResult.sessionsKilled;
+      } else if (wsResult.error) {
+        result.errors.push(`${workspaceName}: ${wsResult.error}`);
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      result.errors.push(`${workspaceName}: ${msg}`);
+      logger.debug(`Failed to delete workspace ${workspaceName}: ${e}`);
+    }
+  }
+
+  // Remove entire project directory
+  try {
+    rmSync(projectDir, { recursive: true, force: true });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : 'Failed to remove project directory';
+    result.errors.push(msg);
+    return result;
+  }
+
+  // Update global config if this was the current project
+  const globalConfig = readGlobalConfig();
+  if (globalConfig.currentProject === projectName) {
+    updateGlobalConfig({ currentProject: null });
+    result.wasCurrentProject = true;
+  }
+
+  result.success = true;
+  return result;
+}