Merge branch 'main' into feature/shared-packages

apps/ui/src/lib/electron.ts

@@ -1,5 +1,6 @@
 // Type definitions for Electron IPC API
 import type { SessionListItem, Message } from "@/types/electron";
+import { getJSON, setJSON, removeItem } from "./storage";
 
 export interface FileEntry {
   name: string;
@@ -2667,28 +2668,22 @@ export interface TrashedProject extends Project {
 }
 
 export const getStoredProjects = (): Project[] => {
-  if (typeof window === "undefined") return [];
-  const stored = localStorage.getItem(STORAGE_KEYS.PROJECTS);
-  return stored ? JSON.parse(stored) : [];
+  return getJSON<Project[]>(STORAGE_KEYS.PROJECTS) ?? [];
 };
 
 export const saveProjects = (projects: Project[]): void => {
-  if (typeof window === "undefined") return;
-  localStorage.setItem(STORAGE_KEYS.PROJECTS, JSON.stringify(projects));
+  setJSON(STORAGE_KEYS.PROJECTS, projects);
 };
 
 export const getCurrentProject = (): Project | null => {
-  if (typeof window === "undefined") return null;
-  const stored = localStorage.getItem(STORAGE_KEYS.CURRENT_PROJECT);
-  return stored ? JSON.parse(stored) : null;
+  return getJSON<Project>(STORAGE_KEYS.CURRENT_PROJECT);
 };
 
 export const setCurrentProject = (project: Project | null): void => {
-  if (typeof window === "undefined") return;
   if (project) {
-    localStorage.setItem(STORAGE_KEYS.CURRENT_PROJECT, JSON.stringify(project));
+    setJSON(STORAGE_KEYS.CURRENT_PROJECT, project);
   } else {
-    localStorage.removeItem(STORAGE_KEYS.CURRENT_PROJECT);
+    removeItem(STORAGE_KEYS.CURRENT_PROJECT);
   }
 };
 
@@ -2709,12 +2704,9 @@ export const removeProject = (projectId: string): void => {
 };
 
 export const getStoredTrashedProjects = (): TrashedProject[] => {
-  if (typeof window === "undefined") return [];
-  const stored = localStorage.getItem(STORAGE_KEYS.TRASHED_PROJECTS);
-  return stored ? JSON.parse(stored) : [];
+  return getJSON<TrashedProject[]>(STORAGE_KEYS.TRASHED_PROJECTS) ?? [];
 };
 
 export const saveTrashedProjects = (projects: TrashedProject[]): void => {
-  if (typeof window === "undefined") return;
-  localStorage.setItem(STORAGE_KEYS.TRASHED_PROJECTS, JSON.stringify(projects));
+  setJSON(STORAGE_KEYS.TRASHED_PROJECTS, projects);
 };

apps/ui/src/lib/http-api-client.ts

@@ -766,6 +766,7 @@ export class HttpApiClient implements ElectronAPI {
       success: boolean;
       configured: boolean;
       workspaceDir?: string;
+      defaultDir?: string | null;
       error?: string;
     }> => this.get("/api/workspace/config"),
 

apps/ui/src/lib/project-init.ts

@@ -48,6 +48,34 @@ export async function initializeProject(
   const existingFiles: string[] = [];
 
   try {
+    // Validate that the project directory exists and is a directory
+    const projectExists = await api.exists(projectPath);
+    if (!projectExists) {
+      return {
+        success: false,
+        isNewProject: false,
+        error: `Project directory does not exist: ${projectPath}. Create it first before initializing.`,
+      };
+    }
+
+    // Verify it's actually a directory (not a file)
+    const projectStat = await api.stat(projectPath);
+    if (!projectStat.success) {
+      return {
+        success: false,
+        isNewProject: false,
+        error: projectStat.error || `Failed to stat project directory: ${projectPath}`,
+      };
+    }
+
+    if (projectStat.stats && !projectStat.stats.isDirectory) {
+      return {
+        success: false,
+        isNewProject: false,
+        error: `Project path is not a directory: ${projectPath}`,
+      };
+    }
+
     // Initialize git repository if it doesn't exist
     const gitDirExists = await api.exists(`${projectPath}/.git`);
     if (!gitDirExists) {

apps/ui/src/lib/storage.ts

@@ -0,0 +1,100 @@
+/**
+ * Centralized localStorage abstraction module
+ *
+ * Provides type-safe wrappers for all localStorage operations.
+ * All localStorage access should go through this module to ensure
+ * consistent error handling and environment checks.
+ */
+
+/**
+ * Check if localStorage is available in the current environment
+ */
+function isStorageAvailable(): boolean {
+  return typeof window !== "undefined" && window.localStorage !== undefined;
+}
+
+/**
+ * Get an item from localStorage
+ * @param key - The storage key
+ * @returns The stored value or null if not found/unavailable
+ */
+export function getItem(key: string): string | null {
+  if (!isStorageAvailable()) return null;
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Set an item in localStorage
+ * @param key - The storage key
+ * @param value - The value to store
+ * @returns true if successful, false otherwise
+ */
+export function setItem(key: string, value: string): boolean {
+  if (!isStorageAvailable()) return false;
+  try {
+    window.localStorage.setItem(key, value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove an item from localStorage
+ * @param key - The storage key to remove
+ * @returns true if successful, false otherwise
+ */
+export function removeItem(key: string): boolean {
+  if (!isStorageAvailable()) return false;
+  try {
+    window.localStorage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get a JSON-parsed item from localStorage
+ * @param key - The storage key
+ * @returns The parsed value or null if not found/invalid
+ */
+export function getJSON<T>(key: string): T | null {
+  const value = getItem(key);
+  if (!value) return null;
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Set a JSON-stringified item in localStorage
+ * @param key - The storage key
+ * @param value - The value to stringify and store
+ * @returns true if successful, false otherwise
+ */
+export function setJSON<T>(key: string, value: T): boolean {
+  try {
+    return setItem(key, JSON.stringify(value));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Storage module for named exports
+ */
+export const storage = {
+  getItem,
+  setItem,
+  removeItem,
+  getJSON,
+  setJSON,
+  isAvailable: isStorageAvailable,
+};

apps/ui/src/lib/workspace-config.ts

@@ -0,0 +1,107 @@
+/**
+ * Utility functions for determining default workspace directories
+ * Centralizes the logic for determining where projects should be created/opened
+ */
+
+/* eslint-disable no-undef */
+import { getHttpApiClient } from "./http-api-client";
+import { getElectronAPI } from "./electron";
+import { getItem, setItem } from "./storage";
+import path from "path";
+
+const LAST_PROJECT_DIR_KEY = "automaker:lastProjectDir";
+
+/**
+ * Gets the default Documents/Automaker directory path
+ * @returns Promise resolving to Documents/Automaker path, or null if unavailable
+ */
+async function getDefaultDocumentsPath(): Promise<string | null> {
+  try {
+    const api = getElectronAPI();
+    const documentsPath = await api.getPath("documents");
+    return path.join(documentsPath, "Automaker");
+  } catch (error) {
+    if (typeof window !== "undefined" && window.console) {
+      window.console.error("Failed to get documents path:", error);
+    }
+    return null;
+  }
+}
+
+/**
+ * Determines the default directory for project creation/opening
+ * Priority order:
+ * 1. ALLOWED_ROOT_DIRECTORY (if configured)
+ * 2. Last used directory from localStorage (if ALLOWED_ROOT_DIRECTORY is not set)
+ * 3. Documents/Automaker (if ALLOWED_ROOT_DIRECTORY is not set)
+ * 4. DATA_DIR (if ALLOWED_ROOT_DIRECTORY is not set and Documents unavailable)
+ * 5. null (no default)
+ *
+ * @returns Promise resolving to the default directory path, or null if none available
+ */
+export async function getDefaultWorkspaceDirectory(): Promise<string | null> {
+  try {
+    const httpClient = getHttpApiClient();
+    const result = await httpClient.workspace.getConfig();
+
+    if (result.success) {
+      // If ALLOWED_ROOT_DIRECTORY is configured, use it
+      if (result.configured && result.workspaceDir) {
+        return result.workspaceDir;
+      }
+
+      // If ALLOWED_ROOT_DIRECTORY is not set, use priority:
+      // 1. Last used directory
+      // 2. Documents/Automaker
+      // 3. DATA_DIR as fallback
+      const lastUsedDir = getItem(LAST_PROJECT_DIR_KEY);
+
+      if (lastUsedDir) {
+        return lastUsedDir;
+      }
+
+      // Try to get Documents/Automaker
+      const documentsPath = await getDefaultDocumentsPath();
+      if (documentsPath) {
+        return documentsPath;
+      }
+
+      // Fallback to DATA_DIR if available
+      if (result.defaultDir) {
+        return result.defaultDir;
+      }
+    }
+
+    // If API call failed, still try last used dir and Documents
+    const lastUsedDir = getItem(LAST_PROJECT_DIR_KEY);
+
+    if (lastUsedDir) {
+      return lastUsedDir;
+    }
+
+    const documentsPath = await getDefaultDocumentsPath();
+    return documentsPath;
+  } catch (error) {
+    if (typeof window !== "undefined" && window.console) {
+      window.console.error("Failed to get default workspace directory:", error);
+    }
+
+    // On error, try last used dir and Documents
+    const lastUsedDir = getItem(LAST_PROJECT_DIR_KEY);
+
+    if (lastUsedDir) {
+      return lastUsedDir;
+    }
+
+    const documentsPath = await getDefaultDocumentsPath();
+    return documentsPath;
+  }
+}
+
+/**
+ * Saves the last used project directory to localStorage
+ * @param path - The directory path to save
+ */
+export function saveLastProjectDirectory(path: string): void {
+  setItem(LAST_PROJECT_DIR_KEY, path);
+}