fix workspace bug

Author: whoiskatrin

packages/sandbox-container/src/session.ts

@@ -25,7 +25,7 @@
 
 import { randomUUID } from 'node:crypto';
 import { watch } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
+import { mkdir, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import type { ExecEvent, Logger } from '@repo/shared';
@@ -137,10 +137,29 @@ export class Session {
     this.sessionDir = join(tmpdir(), `session-${this.id}-${Date.now()}`);
     await mkdir(this.sessionDir, { recursive: true });
 
+    // Determine working directory and verify it exists to avoid spawn failures
+    // If /workspace or specified cwd doesn't exist, fall back to /
+    // This handles the case where /workspace is deleted
+    let cwd = this.options.cwd || CONFIG.DEFAULT_CWD;
+    try {
+      await stat(cwd);
+    } catch {
+      // Directory doesn't exist, fall back to root
+      this.logger.warn(
+        `Working directory '${cwd}' does not exist, falling back to '/'`,
+        {
+          sessionId: this.id,
+          requestedCwd: cwd,
+          fallbackCwd: '/'
+        }
+      );
+      cwd = '/';
+    }
+
     // Spawn persistent bash with stdin pipe - no IPC or wrapper needed!
     this.shell = Bun.spawn({
       cmd: ['bash', '--norc'],
-      cwd: this.options.cwd || CONFIG.DEFAULT_CWD,
+      cwd,
       env: {
         ...process.env,
         ...this.options.env,

packages/sandbox-container/tests/session.test.ts

@@ -75,6 +75,52 @@ describe('Session', () => {
       // Session directory should be created (we can't easily check without accessing private fields)
       expect(session.isReady()).toBe(true);
     });
+
+    it('should initialize with non-existent cwd by falling back to / (issue #288)', async () => {
+      // This tests the fix for issue #288 where session creation failed
+      // if /workspace was deleted before a new session was created
+      session = new Session({
+        id: 'test-session-nonexistent-cwd',
+        cwd: '/nonexistent/path/that/does/not/exist'
+      });
+
+      // This should NOT throw - instead it should fall back to /
+      await session.initialize();
+
+      expect(session.isReady()).toBe(true);
+
+      // Verify we can execute commands
+      const result = await session.exec('pwd');
+      expect(result.exitCode).toBe(0);
+      // The shell should have started in / since the requested cwd doesn't exist
+      expect(result.stdout.trim()).toBe('/');
+    });
+
+    it('should initialize with missing /workspace by falling back to / (issue #288)', async () => {
+      // Simulate the exact scenario from issue #288
+      // Create a workspace, then delete it, then try to create a session with it
+      const workspaceDir = join(testDir, 'workspace');
+      await mkdir(workspaceDir, { recursive: true });
+
+      // Delete the workspace
+      await rm(workspaceDir, { recursive: true, force: true });
+
+      // Now try to create a session with the deleted workspace as cwd
+      session = new Session({
+        id: 'test-session-deleted-workspace',
+        cwd: workspaceDir
+      });
+
+      // This should NOT throw - instead it should fall back to /
+      await session.initialize();
+
+      expect(session.isReady()).toBe(true);
+
+      // Verify we can execute commands
+      const result = await session.exec('echo "session works"');
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.trim()).toBe('session works');
+    });
   });
 
   describe('exec', () => {
@@ -496,6 +542,92 @@ describe('Session', () => {
       expect(result.exitCode).toBe(1);
       expect(result.stderr).toContain('Failed to change directory');
     });
+
+    it('should continue working after session cwd is deleted (issue #288)', async () => {
+      // Create a working directory for the session
+      const workspaceDir = join(testDir, 'workspace');
+      await mkdir(workspaceDir, { recursive: true });
+
+      session = new Session({
+        id: 'test-cwd-deletion',
+        cwd: workspaceDir
+      });
+
+      await session.initialize();
+
+      // Verify baseline works
+      const baseline = await session.exec('echo "baseline"');
+      expect(baseline.exitCode).toBe(0);
+      expect(baseline.stdout.trim()).toBe('baseline');
+
+      // Delete the workspace directory (this is the bug scenario)
+      await session.exec(`rm -rf ${workspaceDir}`);
+
+      // Try a subsequent command - this should NOT fail with an obscure error
+      // It should either work (falling back to /) or give a clear error message
+      const afterRemoval = await session.exec('echo "after removal"');
+
+      // The command should succeed - bash can still run commands even if cwd is deleted
+      // It will use the deleted directory's inode until a cd happens
+      expect(afterRemoval.exitCode).toBe(0);
+      expect(afterRemoval.stdout.trim()).toBe('after removal');
+    });
+
+    it('should handle cwd being replaced with symlink (issue #288)', async () => {
+      // Create directories for the test
+      const workspaceDir = join(testDir, 'workspace');
+      const backupDir = join(testDir, 'backup');
+      await mkdir(workspaceDir, { recursive: true });
+      await mkdir(backupDir, { recursive: true });
+
+      session = new Session({
+        id: 'test-cwd-symlink',
+        cwd: workspaceDir
+      });
+
+      await session.initialize();
+
+      // Verify baseline works
+      const baseline = await session.exec('echo "baseline"');
+      expect(baseline.exitCode).toBe(0);
+      expect(baseline.stdout.trim()).toBe('baseline');
+
+      // Replace workspace with a symlink to backup directory
+      await session.exec(
+        `rm -rf ${workspaceDir} && ln -sf ${backupDir} ${workspaceDir}`
+      );
+
+      // Try a subsequent command - should continue working
+      const afterSymlink = await session.exec('echo "after symlink"');
+      expect(afterSymlink.exitCode).toBe(0);
+      expect(afterSymlink.stdout.trim()).toBe('after symlink');
+    });
+
+    it('should be recoverable by cd-ing to valid directory after cwd deletion', async () => {
+      // Create a working directory for the session
+      const workspaceDir = join(testDir, 'workspace');
+      await mkdir(workspaceDir, { recursive: true });
+
+      session = new Session({
+        id: 'test-cwd-recovery',
+        cwd: workspaceDir
+      });
+
+      await session.initialize();
+
+      // Delete the workspace directory
+      await session.exec(`rm -rf ${workspaceDir}`);
+
+      // Change to a valid directory - this should work and recover the session
+      const cdResult = await session.exec('cd /tmp && pwd');
+      expect(cdResult.exitCode).toBe(0);
+      expect(cdResult.stdout.trim()).toBe('/tmp');
+
+      // Subsequent commands should work
+      const afterCd = await session.exec('echo "recovered"');
+      expect(afterCd.exitCode).toBe(0);
+      expect(afterCd.stdout.trim()).toBe('recovered');
+    });
   });
 
   describe('FIFO cleanup', () => {