Merge main into massive-terminal-upgrade

Resolves merge conflicts:
- apps/server/src/routes/terminal/common.ts: Keep randomBytes import, use @automaker/utils for createLogger
- apps/ui/eslint.config.mjs: Use main's explicit globals list with XMLHttpRequest and MediaQueryListEvent additions
- apps/ui/src/components/views/terminal-view.tsx: Keep our terminal improvements (killAllSessions, beforeunload, better error handling)
- apps/ui/src/config/terminal-themes.ts: Keep our search highlight colors for all themes
- apps/ui/src/store/app-store.ts: Keep our terminal settings persistence improvements (merge function)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

libs/platform/tests/paths.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import {
+  getAutomakerDir,
+  getFeaturesDir,
+  getFeatureDir,
+  getFeatureImagesDir,
+  getBoardDir,
+  getImagesDir,
+  getContextDir,
+  getWorktreesDir,
+  getAppSpecPath,
+  getBranchTrackingPath,
+  ensureAutomakerDir,
+  getGlobalSettingsPath,
+  getCredentialsPath,
+  getProjectSettingsPath,
+  ensureDataDir,
+} from '../src/paths';
+
+describe('paths.ts', () => {
+  let tempDir: string;
+  let projectPath: string;
+  let dataDir: string;
+
+  beforeEach(async () => {
+    // Create a temporary directory for testing
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'platform-paths-test-'));
+    projectPath = path.join(tempDir, 'test-project');
+    dataDir = path.join(tempDir, 'user-data');
+    await fs.mkdir(projectPath, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up temporary directory
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('Project-level path construction', () => {
+    it('should return automaker directory path', () => {
+      const result = getAutomakerDir(projectPath);
+      expect(result).toBe(path.join(projectPath, '.automaker'));
+    });
+
+    it('should return features directory path', () => {
+      const result = getFeaturesDir(projectPath);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'features'));
+    });
+
+    it('should return feature directory path', () => {
+      const featureId = 'auth-feature';
+      const result = getFeatureDir(projectPath, featureId);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'features', featureId));
+    });
+
+    it('should return feature images directory path', () => {
+      const featureId = 'auth-feature';
+      const result = getFeatureImagesDir(projectPath, featureId);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'features', featureId, 'images'));
+    });
+
+    it('should return board directory path', () => {
+      const result = getBoardDir(projectPath);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'board'));
+    });
+
+    it('should return images directory path', () => {
+      const result = getImagesDir(projectPath);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'images'));
+    });
+
+    it('should return context directory path', () => {
+      const result = getContextDir(projectPath);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'context'));
+    });
+
+    it('should return worktrees directory path', () => {
+      const result = getWorktreesDir(projectPath);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'worktrees'));
+    });
+
+    it('should return app spec file path', () => {
+      const result = getAppSpecPath(projectPath);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'app_spec.txt'));
+    });
+
+    it('should return branch tracking file path', () => {
+      const result = getBranchTrackingPath(projectPath);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'active-branches.json'));
+    });
+
+    it('should return project settings file path', () => {
+      const result = getProjectSettingsPath(projectPath);
+      expect(result).toBe(path.join(projectPath, '.automaker', 'settings.json'));
+    });
+  });
+
+  describe('Global settings path construction', () => {
+    it('should return global settings path', () => {
+      const result = getGlobalSettingsPath(dataDir);
+      expect(result).toBe(path.join(dataDir, 'settings.json'));
+    });
+
+    it('should return credentials path', () => {
+      const result = getCredentialsPath(dataDir);
+      expect(result).toBe(path.join(dataDir, 'credentials.json'));
+    });
+  });
+
+  describe('Directory creation', () => {
+    it('should create automaker directory', async () => {
+      const automakerDir = await ensureAutomakerDir(projectPath);
+
+      expect(automakerDir).toBe(path.join(projectPath, '.automaker'));
+
+      const stats = await fs.stat(automakerDir);
+      expect(stats.isDirectory()).toBe(true);
+    });
+
+    it('should be idempotent when creating automaker directory', async () => {
+      // Create directory first time
+      const firstResult = await ensureAutomakerDir(projectPath);
+
+      // Create directory second time
+      const secondResult = await ensureAutomakerDir(projectPath);
+
+      expect(firstResult).toBe(secondResult);
+
+      const stats = await fs.stat(firstResult);
+      expect(stats.isDirectory()).toBe(true);
+    });
+
+    it('should create data directory', async () => {
+      const result = await ensureDataDir(dataDir);
+
+      expect(result).toBe(dataDir);
+
+      const stats = await fs.stat(dataDir);
+      expect(stats.isDirectory()).toBe(true);
+    });
+
+    it('should be idempotent when creating data directory', async () => {
+      // Create directory first time
+      const firstResult = await ensureDataDir(dataDir);
+
+      // Create directory second time
+      const secondResult = await ensureDataDir(dataDir);
+
+      expect(firstResult).toBe(secondResult);
+
+      const stats = await fs.stat(firstResult);
+      expect(stats.isDirectory()).toBe(true);
+    });
+
+    it('should create nested directories recursively', async () => {
+      const deepProjectPath = path.join(tempDir, 'nested', 'deep', 'project');
+      await fs.mkdir(deepProjectPath, { recursive: true });
+
+      const automakerDir = await ensureAutomakerDir(deepProjectPath);
+
+      const stats = await fs.stat(automakerDir);
+      expect(stats.isDirectory()).toBe(true);
+    });
+  });
+
+  describe('Path handling with special characters', () => {
+    it('should handle feature IDs with special characters', () => {
+      const featureId = 'feature-with-dashes_and_underscores';
+      const result = getFeatureDir(projectPath, featureId);
+      expect(result).toContain(featureId);
+    });
+
+    it('should handle paths with spaces', () => {
+      const pathWithSpaces = path.join(tempDir, 'path with spaces');
+      const result = getAutomakerDir(pathWithSpaces);
+      expect(result).toBe(path.join(pathWithSpaces, '.automaker'));
+    });
+  });
+
+  describe('Path relationships', () => {
+    it('should have feature dir as child of features dir', () => {
+      const featuresDir = getFeaturesDir(projectPath);
+      const featureDir = getFeatureDir(projectPath, 'test-feature');
+
+      expect(featureDir.startsWith(featuresDir)).toBe(true);
+    });
+
+    it('should have all project paths under automaker dir', () => {
+      const automakerDir = getAutomakerDir(projectPath);
+      const paths = [
+        getFeaturesDir(projectPath),
+        getBoardDir(projectPath),
+        getImagesDir(projectPath),
+        getContextDir(projectPath),
+        getWorktreesDir(projectPath),
+        getAppSpecPath(projectPath),
+        getBranchTrackingPath(projectPath),
+        getProjectSettingsPath(projectPath),
+      ];
+
+      paths.forEach((p) => {
+        expect(p.startsWith(automakerDir)).toBe(true);
+      });
+    });
+  });
+});