Cut release v0.19.0 (#2206)

Co-authored-by: Kurt Hutten <k.hutten@protonmail.ch>

.github/workflows/build-and-store-wasm.yml

@@ -0,0 +1,35 @@
+name: Build and Store WASM
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build-and-upload:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'yarn'
+      - name: Install dependencies
+        run: yarn
+      - name: Install Playwright Browsers
+        run: yarn playwright install --with-deps
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+      - name: Cache wasm
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: './src/wasm-lib'
+      - name: build wasm
+        run: yarn build:wasm
+
+
+      # Upload the WASM bundle as an artifact
+      - uses: actions/upload-artifact@v2
+        with:
+          name: wasm-bundle
+          path: src/wasm-lib/pkg

.github/workflows/cargo-clippy.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        dir: ['src/wasm-lib']
+        dir: ['src/wasm-lib', 'src-tauri']
     steps:
       - uses: actions/checkout@v4
       - name: Install latest rust
@@ -31,9 +31,22 @@ jobs:
 
       - name: install dependencies
         if: matrix.dir ==  'src-tauri'
+        shell: bash
         run: |
           sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev patchelf
+          sudo apt-get install -y \
+            libgtk-3-dev \
+            libayatana-appindicator3-dev \
+            webkit2gtk-driver \
+            libsoup-3.0-dev \
+            libjavascriptcoregtk-4.1-dev \
+            libwebkit2gtk-4.1-dev \
+            at-spi2-core \
+            xvfb
+          yarn install
+          yarn build:wasm
+          yarn build:local
+
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2.6.1
 

.github/workflows/cargo-test-tauri.yml

@@ -0,0 +1,57 @@
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'src-tauri/**.rs'
+      - '**/Cargo.toml'
+      - '**/Cargo.lock'
+      - '**/rust-toolchain.toml'
+      - .github/workflows/cargo-test-tauri.yml
+  pull_request:
+    paths:
+      - 'src-tauri/**.rs'
+      - '**/Cargo.toml'
+      - '**/Cargo.lock'
+      - '**/rust-toolchain.toml'
+      - .github/workflows/cargo-test-tauri.yml
+  workflow_dispatch:
+permissions: read-all
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+name: cargo test of tauri
+jobs:
+  cargotest:
+    name: cargo test
+    runs-on: ubuntu-latest-8-cores
+    strategy:
+      matrix:
+        dir: ['src-tauri']
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install latest rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+      - name: install dependencies
+        if: matrix.dir ==  'src-tauri'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libgtk-3-dev \
+            libayatana-appindicator3-dev \
+            webkit2gtk-driver \
+            libsoup-3.0-dev \
+            libjavascriptcoregtk-4.1-dev \
+            libwebkit2gtk-4.1-dev \
+            at-spi2-core \
+            xvfb
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2.6.1
+      - name: cargo test
+        shell: bash
+        run: |-
+          cd "${{ matrix.dir }}"
+          cargo test --all

.github/workflows/ci.yml

@@ -50,7 +50,7 @@ jobs:
       - run: yarn tsc
 
 
-  check-typos: 
+  check-typos:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -98,7 +98,7 @@ jobs:
         with:
           node-version-file: '.nvmrc'
           cache: 'yarn'
-          
+
       - name: Set nightly version
         if: github.event_name == 'schedule'
         run: |
@@ -143,21 +143,21 @@ jobs:
           ls -l artifact
           cp artifact/package.json package.json
           cp artifact/src-tauri/tauri.conf.json src-tauri/tauri.conf.json
-          cp artifact/src-tauri/tauri.release.conf.json src-tauri/tauri.release.conf.json 
+          cp artifact/src-tauri/tauri.release.conf.json src-tauri/tauri.release.conf.json
 
       - name: Install ubuntu system dependencies
         if: matrix.os == 'ubuntu-latest'
-        run: >
-          sudo apt-get update &&
-          sudo apt-get install -y
-          libgtk-3-dev
-          libayatana-appindicator3-dev
-          webkit2gtk-driver
-          libsoup-3.0-dev
-          libjavascriptcoregtk-4.1-dev
-          libwebkit2gtk-4.1-dev
-          at-spi2-core
-          xvfb
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libgtk-3-dev \
+            libayatana-appindicator3-dev \
+            webkit2gtk-driver \
+            libsoup-3.0-dev \
+            libjavascriptcoregtk-4.1-dev \
+            libwebkit2gtk-4.1-dev \
+            at-spi2-core \
+            xvfb
 
       - name: Sync node version and setup cache
         uses: actions/setup-node@v4
@@ -383,7 +383,7 @@ jobs:
         uses: softprops/action-gh-release@v2
         with:
           files: 'artifact/*/Zoo*'
-          
+
   announce_release:
     needs: [publish-apps-release]
     runs-on: ubuntu-latest
@@ -391,17 +391,17 @@ jobs:
     steps:
       - name: Check out code
         uses: actions/checkout@v4
-          
+
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
           python-version: '3.x'
-  
+
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
           pip install requests
-  
+
       - name: Announce Release
         env:
           DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}

.github/workflows/playwright.yml

@@ -122,3 +122,8 @@ jobs:
         name: playwright-report
         path: playwright-report/
         retention-days: 30
+    - uses: actions/upload-artifact@v2
+      if: github.ref == 'refs/heads/main'
+      with:
+        name: wasm-bundle
+        path: src/wasm-lib/pkg

e2e/playwright/flow-tests.spec.ts

@@ -565,7 +565,9 @@ test('Auto complete works', async ({ page }) => {
 
   await page.keyboard.press('Tab')
   await page.keyboard.type('12')
+  await page.waitForTimeout(100)
   await page.keyboard.press('Tab')
+  await page.waitForTimeout(100)
   await page.keyboard.press('Tab')
   await page.keyboard.press('Tab')
   await page.keyboard.press('Enter')
@@ -594,13 +596,12 @@ test('Auto complete works', async ({ page }) => {
 
 test('Stored settings are validated and fall back to defaults', async ({
   page,
-  context,
 }) => {
   const u = getUtils(page)
 
   // Override beforeEach test setup
   // with corrupted settings
-  await context.addInitScript(
+  await page.addInitScript(
     async ({ settingsKey, settings }) => {
       localStorage.setItem(settingsKey, settings)
     },
@@ -617,18 +618,18 @@ test('Stored settings are validated and fall back to defaults', async ({
   // Check the settings were reset
   const storedSettings = TOML.parse(
     await page.evaluate(
-      ({ settingsKey }) => localStorage.getItem(settingsKey) || '{}',
+      ({ settingsKey }) => localStorage.getItem(settingsKey) || '',
       { settingsKey: TEST_SETTINGS_KEY }
     )
   ) as { settings: SaveSettingsPayload }
 
-  expect(storedSettings.settings.app?.theme).toBe('dark')
+  expect(storedSettings.settings?.app?.theme).toBe(undefined)
 
   // Check that the invalid settings were removed
-  expect(storedSettings.settings.modeling?.defaultUnit).toBe(undefined)
-  expect(storedSettings.settings.modeling?.mouseControls).toBe(undefined)
-  expect(storedSettings.settings.app?.projectDirectory).toBe(undefined)
-  expect(storedSettings.settings.projects?.defaultProjectName).toBe(undefined)
+  expect(storedSettings.settings?.modeling?.defaultUnit).toBe(undefined)
+  expect(storedSettings.settings?.modeling?.mouseControls).toBe(undefined)
+  expect(storedSettings.settings?.app?.projectDirectory).toBe(undefined)
+  expect(storedSettings.settings?.projects?.defaultProjectName).toBe(undefined)
 })
 
 test('Project settings can be set and override user settings', async ({
@@ -1033,6 +1034,7 @@ const part001 = startSketchOn('-XZ')
 })
 
 test('Can add multiple sketches', async ({ page }) => {
+  test.skip(process.platform === 'darwin', 'Can add multiple sketches')
   const u = getUtils(page)
   await page.setViewportSize({ width: 1200, height: 500 })
   const PUR = 400 / 37.5 //pixeltoUnitRatio

e2e/playwright/storageStates.ts

@@ -1,12 +1,13 @@
 import { SaveSettingsPayload } from 'lib/settings/settingsTypes'
 import { Themes } from 'lib/theme'
 
-export const TEST_SETTINGS_KEY = '/user.toml'
+export const TEST_SETTINGS_KEY = '/settings.toml'
 export const TEST_SETTINGS = {
   app: {
     theme: Themes.Dark,
     onboardingStatus: 'dismissed',
     projectDirectory: '',
+    enableSSAO: false,
   },
   modeling: {
     defaultUnit: 'in',
@@ -23,7 +24,7 @@ export const TEST_SETTINGS = {
 
 export const TEST_SETTINGS_ONBOARDING = {
   ...TEST_SETTINGS,
-  app: { ...TEST_SETTINGS.app, onboardingStatus: '/export ' },
+  app: { ...TEST_SETTINGS.app, onboardingStatus: '/export' },
 } satisfies Partial<SaveSettingsPayload>
 
 export const TEST_SETTINGS_CORRUPTED = {

e2e/playwright/test-utils.ts

@@ -6,7 +6,7 @@ import { PNG } from 'pngjs'
 
 async function waitForPageLoad(page: Page) {
   // wait for 'Loading stream...' spinner
-  // await page.getByTestId('loading-stream').waitFor()
+  await page.getByTestId('loading-stream').waitFor()
   // wait for all spinners to be gone
   await page.getByTestId('loading').waitFor({ state: 'detached' })
 

e2e/tauri/specs/auth.e2e.ts

@@ -71,7 +71,7 @@ describe('ZMA (Tauri, Linux)', () => {
 
     // Now should be signed in
     const newFileButton = await $('[data-testid="home-new-file"]')
-    expect(await newFileButton.getText()).toEqual('New file')
+    expect(await newFileButton.getText()).toEqual('New project')
   })
 
   it('opens the settings page, checks filesystem settings, and closes the settings page', async () => {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "untitled-app",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "private": true,
   "dependencies": {
     "@codemirror/autocomplete": "^6.16.0",

src-tauri/Cargo.toml

@@ -8,27 +8,26 @@ repository = "https://github.com/KittyCAD/modeling-app"
 default-run = "app"
 edition = "2021"
 rust-version = "1.70"
-
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [build-dependencies]
-tauri-build = { version = "2.0.0-beta.12", features = [] }
+tauri-build = { version = "2.0.0-beta.13", features = [] }
 
 [dependencies]
 anyhow = "1"
-kittycad = "0.2.67"
+kcl-lib = { version = "0.1.51", path = "../src/wasm-lib/kcl" }
+kittycad = "0.3.0"
 oauth2 = "4.4.2"
-serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 tauri = { version = "2.0.0-beta.15", features = [ "devtools", "unstable"] }
-tauri-plugin-dialog = { version = "2.0.0-beta.5" }
-tauri-plugin-fs = { version = "2.0.0-beta.5" }
-tauri-plugin-http = { version = "2.0.0-beta.5" }
+tauri-plugin-dialog = { version = "2.0.0-beta.6" }
+tauri-plugin-fs = { version = "2.0.0-beta.6" }
+tauri-plugin-http = { version = "2.0.0-beta.6" }
 tauri-plugin-os = { version = "2.0.0-beta.2" }
 tauri-plugin-process = { version = "2.0.0-beta.2" }
 tauri-plugin-shell = { version = "2.0.0-beta.2" }
 tauri-plugin-updater = { version = "2.0.0-beta.4" }
-tokio = { version = "1.37.0", features = ["time"] }
+tokio = { version = "1.37.0", features = ["time", "fs"] }
 toml = "0.8.2"
 
 [features]

src-tauri/rustfmt.toml

@@ -0,0 +1,6 @@
+max_width = 120
+edition = "2018"
+format_code_in_doc_comments = true
+format_strings = false
+imports_granularity = "Crate"
+group_imports = "StdExternalCrate"

src-tauri/src/main.rs

@@ -1,91 +1,189 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-use std::env;
-use std::fs;
-use std::io::Read;
-use std::path::Path;
-use std::path::PathBuf;
+use std::{
+    env,
+    path::{Path, PathBuf},
+    process::Command,
+};
 
 use anyhow::Result;
+use kcl_lib::settings::types::{
+    file::{FileEntry, Project},
+    project::ProjectConfiguration,
+    Configuration,
+};
 use oauth2::TokenResponse;
-use serde::Serialize;
-use std::process::Command;
-use tauri::ipc::InvokeError;
+use tauri::{ipc::InvokeError, Manager};
 use tauri_plugin_shell::ShellExt;
-const DEFAULT_HOST: &str = "https://api.kittycad.io";
 
-/// This command returns the a json string parse from a toml file at the path.
+const DEFAULT_HOST: &str = "https://api.zoo.dev";
+const SETTINGS_FILE_NAME: &str = "settings.toml";
+const PROJECT_SETTINGS_FILE_NAME: &str = "project.toml";
+const PROJECT_FOLDER: &str = "zoo-modeling-app-projects";
+
 #[tauri::command]
-fn read_toml(path: &str) -> Result<String, InvokeError> {
-    let mut file = std::fs::File::open(path).map_err(|e| InvokeError::from_anyhow(e.into()))?;
-    let mut contents = String::new();
-    file.read_to_string(&mut contents)
-        .map_err(|e| InvokeError::from_anyhow(e.into()))?;
-    let value =
-        toml::from_str::<toml::Value>(&contents).map_err(|e| InvokeError::from_anyhow(e.into()))?;
-    let value = serde_json::to_string(&value).map_err(|e| InvokeError::from_anyhow(e.into()))?;
-    Ok(value)
+fn get_initial_default_dir(app: tauri::AppHandle) -> Result<PathBuf, InvokeError> {
+    let dir = match app.path().document_dir() {
+        Ok(dir) => dir,
+        Err(_) => {
+            // for headless Linux (eg. Github Actions)
+            let home_dir = app.path().home_dir()?;
+            home_dir.join("Documents")
+        }
+    };
+
+    Ok(dir.join(PROJECT_FOLDER))
 }
 
-/// From https://github.com/tauri-apps/tauri/blob/1.x/core/tauri/src/api/dir.rs#L51
-/// Removed from tauri v2
-#[derive(Debug, Serialize)]
-pub struct DiskEntry {
-    /// The path to the entry.
-    pub path: PathBuf,
-    /// The name of the entry (file name with extension or directory name).
-    pub name: Option<String>,
-    /// The children of this entry if it's a directory.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub children: Option<Vec<DiskEntry>>,
+fn get_app_settings_file_path(app: &tauri::AppHandle) -> Result<PathBuf, InvokeError> {
+    let app_config_dir = app.path().app_config_dir()?;
+    Ok(app_config_dir.join(SETTINGS_FILE_NAME))
 }
 
-/// From https://github.com/tauri-apps/tauri/blob/1.x/core/tauri/src/api/dir.rs#L51
-/// Removed from tauri v2
-fn is_dir<P: AsRef<Path>>(path: P) -> Result<bool> {
-    std::fs::metadata(path)
-        .map(|md| md.is_dir())
-        .map_err(Into::into)
-}
-
-/// From https://github.com/tauri-apps/tauri/blob/1.x/core/tauri/src/api/dir.rs#L51
-/// Removed from tauri v2
 #[tauri::command]
-fn read_dir_recursive(path: &str) -> Result<Vec<DiskEntry>, InvokeError> {
-    let mut files_and_dirs: Vec<DiskEntry> = vec![];
-    // let path = path.as_ref();
-    for entry in fs::read_dir(path).map_err(|e| InvokeError::from_anyhow(e.into()))? {
-        let path = entry
-            .map_err(|e| InvokeError::from_anyhow(e.into()))?
-            .path();
+async fn read_app_settings_file(app: tauri::AppHandle) -> Result<Configuration, InvokeError> {
+    let mut settings_path = get_app_settings_file_path(&app)?;
+    let mut needs_migration = false;
 
-        if let Ok(flag) = is_dir(&path) {
-            files_and_dirs.push(DiskEntry {
-                path: path.clone(),
-                children: if flag {
-                    Some(read_dir_recursive(path.to_str().expect("No path"))?)
-                } else {
-                    None
-                },
-                name: path
-                    .file_name()
-                    .map(|name| name.to_string_lossy())
-                    .map(|name| name.to_string()),
-            });
+    // Check if this file exists.
+    if !settings_path.exists() {
+        // Try the backwards compatible path.
+        // TODO: Remove this after a few releases.
+        let app_config_dir = app.path().app_config_dir()?;
+        settings_path = format!(
+            "{}user.toml",
+            app_config_dir.display().to_string().trim_end_matches('/')
+        )
+        .into();
+        needs_migration = true;
+        // Check if this path exists.
+        if !settings_path.exists() {
+            let mut default = Configuration::default();
+            default.settings.project.directory = get_initial_default_dir(app.clone())?;
+            // Return the default configuration.
+            return Ok(default);
         }
     }
-    Ok(files_and_dirs)
+
+    let contents = tokio::fs::read_to_string(&settings_path)
+        .await
+        .map_err(|e| InvokeError::from_anyhow(e.into()))?;
+    let mut parsed = Configuration::backwards_compatible_toml_parse(&contents).map_err(InvokeError::from_anyhow)?;
+    if parsed.settings.project.directory == PathBuf::new() {
+        parsed.settings.project.directory = get_initial_default_dir(app.clone())?;
+    }
+
+    // TODO: Remove this after a few releases.
+    if needs_migration {
+        write_app_settings_file(app, parsed.clone()).await?;
+        // Delete the old file.
+        tokio::fs::remove_file(settings_path)
+            .await
+            .map_err(|e| InvokeError::from_anyhow(e.into()))?;
+    }
+
+    Ok(parsed)
 }
 
-/// This command returns a string that is the contents of a file at the path.
 #[tauri::command]
-fn read_txt_file(path: &str) -> Result<String, InvokeError> {
-    let mut file = std::fs::File::open(path).map_err(|e| InvokeError::from_anyhow(e.into()))?;
-    let mut contents = String::new();
-    file.read_to_string(&mut contents)
+async fn write_app_settings_file(app: tauri::AppHandle, configuration: Configuration) -> Result<(), InvokeError> {
+    let settings_path = get_app_settings_file_path(&app)?;
+    let contents = toml::to_string_pretty(&configuration).map_err(|e| InvokeError::from_anyhow(e.into()))?;
+    tokio::fs::write(settings_path, contents.as_bytes())
+        .await
         .map_err(|e| InvokeError::from_anyhow(e.into()))?;
-    Ok(contents)
+
+    Ok(())
+}
+
+fn get_project_settings_file_path(app_settings: Configuration, project_name: &str) -> Result<PathBuf, InvokeError> {
+    Ok(app_settings
+        .settings
+        .project
+        .directory
+        .join(project_name)
+        .join(PROJECT_SETTINGS_FILE_NAME))
+}
+
+#[tauri::command]
+async fn read_project_settings_file(
+    app_settings: Configuration,
+    project_name: &str,
+) -> Result<ProjectConfiguration, InvokeError> {
+    let settings_path = get_project_settings_file_path(app_settings, project_name)?;
+
+    // Check if this file exists.
+    if !settings_path.exists() {
+        // Return the default configuration.
+        return Ok(ProjectConfiguration::default());
+    }
+
+    let contents = tokio::fs::read_to_string(&settings_path)
+        .await
+        .map_err(|e| InvokeError::from_anyhow(e.into()))?;
+    let parsed = ProjectConfiguration::backwards_compatible_toml_parse(&contents).map_err(InvokeError::from_anyhow)?;
+
+    Ok(parsed)
+}
+
+#[tauri::command]
+async fn write_project_settings_file(
+    app_settings: Configuration,
+    project_name: &str,
+    configuration: ProjectConfiguration,
+) -> Result<(), InvokeError> {
+    let settings_path = get_project_settings_file_path(app_settings, project_name)?;
+    let contents = toml::to_string_pretty(&configuration).map_err(|e| InvokeError::from_anyhow(e.into()))?;
+    tokio::fs::write(settings_path, contents.as_bytes())
+        .await
+        .map_err(|e| InvokeError::from_anyhow(e.into()))?;
+
+    Ok(())
+}
+
+/// Initialize the directory that holds all the projects.
+#[tauri::command]
+async fn initialize_project_directory(configuration: Configuration) -> Result<PathBuf, InvokeError> {
+    configuration
+        .ensure_project_directory_exists()
+        .await
+        .map_err(InvokeError::from_anyhow)
+}
+
+/// Create a new project directory.
+#[tauri::command]
+async fn create_new_project_directory(
+    configuration: Configuration,
+    project_name: &str,
+    initial_code: Option<&str>,
+) -> Result<Project, InvokeError> {
+    configuration
+        .create_new_project_directory(project_name, initial_code)
+        .await
+        .map_err(InvokeError::from_anyhow)
+}
+
+/// List all the projects in the project directory.
+#[tauri::command]
+async fn list_projects(configuration: Configuration) -> Result<Vec<Project>, InvokeError> {
+    configuration.list_projects().await.map_err(InvokeError::from_anyhow)
+}
+
+/// Get information about a project.
+#[tauri::command]
+async fn get_project_info(configuration: Configuration, project_name: &str) -> Result<Project, InvokeError> {
+    configuration
+        .get_project_info(project_name)
+        .await
+        .map_err(InvokeError::from_anyhow)
+}
+
+#[tauri::command]
+async fn read_dir_recursive(path: &str) -> Result<FileEntry, InvokeError> {
+    kcl_lib::settings::utils::walk_dir(&Path::new(path).to_path_buf())
+        .await
+        .map_err(InvokeError::from_anyhow)
 }
 
 /// This command instantiates a new window with auth.
@@ -103,8 +201,7 @@ async fn login(app: tauri::AppHandle, host: &str) -> Result<String, InvokeError>
     let auth_client = oauth2::basic::BasicClient::new(
         oauth2::ClientId::new(client_id),
         None,
-        oauth2::AuthUrl::new(format!("{host}/authorize"))
-            .map_err(|e| InvokeError::from_anyhow(e.into()))?,
+        oauth2::AuthUrl::new(format!("{host}/authorize")).map_err(|e| InvokeError::from_anyhow(e.into()))?,
         Some(
             oauth2::TokenUrl::new(format!("{host}/oauth2/device/token"))
                 .map_err(|e| InvokeError::from_anyhow(e.into()))?,
@@ -132,12 +229,10 @@ async fn login(app: tauri::AppHandle, host: &str) -> Result<String, InvokeError>
     // and bypass the shell::open call as it fails on GitHub Actions.
     let e2e_tauri_enabled = env::var("E2E_TAURI_ENABLED").is_ok();
     if e2e_tauri_enabled {
-        println!(
-            "E2E_TAURI_ENABLED is set, won't open {} externally",
-            auth_uri.secret()
-        );
-        fs::write("/tmp/kittycad_user_code", details.user_code().secret())
-            .expect("Unable to write /tmp/kittycad_user_code file");
+        println!("E2E_TAURI_ENABLED is set, won't open {} externally", auth_uri.secret());
+        tokio::fs::write("/tmp/kittycad_user_code", details.user_code().secret())
+            .await
+            .map_err(|e| InvokeError::from_anyhow(e.into()))?;
     } else {
         app.shell()
             .open(auth_uri.secret(), None)
@@ -160,10 +255,7 @@ async fn login(app: tauri::AppHandle, host: &str) -> Result<String, InvokeError>
 ///This command returns the KittyCAD user info given a token.
 /// The string returned from this method is the user info as a json string.
 #[tauri::command]
-async fn get_user(
-    token: Option<String>,
-    hostname: &str,
-) -> Result<kittycad::types::User, InvokeError> {
+async fn get_user(token: &str, hostname: &str) -> Result<kittycad::types::User, InvokeError> {
     // Use the host passed in if it's set.
     // Otherwise, use the default host.
     let host = if hostname.is_empty() {
@@ -183,7 +275,7 @@ async fn get_user(
     println!("Getting user info...");
 
     // use kittycad library to fetch the user info from /user/me
-    let mut client = kittycad::Client::new(token.unwrap());
+    let mut client = kittycad::Client::new(token);
 
     if baseurl != DEFAULT_HOST {
         client.set_base_url(&baseurl);
@@ -202,43 +294,53 @@ async fn get_user(
 /// From this GitHub comment: https://github.com/tauri-apps/tauri/issues/4062#issuecomment-1338048169
 /// But with the Linux support removed since we don't need it for now.
 #[tauri::command]
-fn show_in_folder(path: String) {
-    #[cfg(target_os = "windows")]
+fn show_in_folder(path: &str) -> Result<(), InvokeError> {
+    #[cfg(not(unix))]
     {
         Command::new("explorer")
             .args(["/select,", &path]) // The comma after select is not a typo
             .spawn()
-            .unwrap();
+            .map_err(|e| InvokeError::from_anyhow(e.into()))?;
     }
 
-    #[cfg(target_os = "macos")]
+    #[cfg(unix)]
     {
-        Command::new("open").args(["-R", &path]).spawn().unwrap();
+        Command::new("open")
+            .args(["-R", &path])
+            .spawn()
+            .map_err(|e| InvokeError::from_anyhow(e.into()))?;
     }
+
+    Ok(())
 }
 
-fn main() {
+fn main() -> Result<()> {
     tauri::Builder::default()
         .setup(|_app| {
             #[cfg(debug_assertions)]
             {
-                use tauri::Manager;
                 _app.get_webview("main").unwrap().open_devtools();
             }
             #[cfg(not(debug_assertions))]
             {
-                _app.handle()
-                    .plugin(tauri_plugin_updater::Builder::new().build())?;
+                _app.handle().plugin(tauri_plugin_updater::Builder::new().build())?;
             }
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
+            get_initial_default_dir,
+            initialize_project_directory,
+            create_new_project_directory,
+            list_projects,
+            get_project_info,
             get_user,
             login,
-            read_toml,
-            read_txt_file,
             read_dir_recursive,
             show_in_folder,
+            read_app_settings_file,
+            write_app_settings_file,
+            read_project_settings_file,
+            write_project_settings_file,
         ])
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_fs::init())
@@ -246,6 +348,7 @@ fn main() {
         .plugin(tauri_plugin_os::init())
         .plugin(tauri_plugin_process::init())
         .plugin(tauri_plugin_shell::init())
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
+        .run(tauri::generate_context!())?;
+
+    Ok(())
 }

src-tauri/tauri.conf.json

@@ -55,5 +55,5 @@
     }
   },
   "productName": "Zoo Modeling App",
-  "version": "0.18.1"
+  "version": "0.19.0"
 }

src/components/CommandBar/CommandBarSelectionInput.tsx

@@ -3,13 +3,12 @@ import { useCommandsContext } from 'hooks/useCommandsContext'
 import { useKclContext } from 'lang/KclProvider'
 import { CommandArgument } from 'lib/commandTypes'
 import {
-  ResolvedSelectionType,
   canSubmitSelectionArg,
   getSelectionType,
   getSelectionTypeDisplayText,
 } from 'lib/selections'
 import { modelingMachine } from 'machines/modelingMachine'
-import { useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 import { useHotkeys } from 'react-hotkeys-hook'
 import { StateFrom } from 'xstate'
 
@@ -30,13 +29,13 @@ function CommandBarSelectionInput({
   const { commandBarState, commandBarSend } = useCommandsContext()
   const [hasSubmitted, setHasSubmitted] = useState(false)
   const selection = useSelector(arg.machineActor, selectionSelector)
-  const [selectionsByType, setSelectionsByType] = useState<
-    'none' | ResolvedSelectionType[]
-  >(
-    selection.codeBasedSelections[0]?.range[1] === code.length
+  const initSelectionsByType = useCallback(() => {
+    const selectionRangeEnd = selection.codeBasedSelections[0]?.range[1]
+    return !selectionRangeEnd || selectionRangeEnd === code.length
       ? 'none'
       : getSelectionType(selection)
-  )
+  }, [selection, code])
+  const selectionsByType = initSelectionsByType()
   const [canSubmitSelection, setCanSubmitSelection] = useState<boolean>(
     canSubmitSelectionArg(selectionsByType, arg)
   )
@@ -51,17 +50,14 @@ function CommandBarSelectionInput({
     inputRef.current?.focus()
   }, [selection, inputRef])
 
-  useEffect(() => {
-    setSelectionsByType(
-      selection.codeBasedSelections[0]?.range[1] === code.length
-        ? 'none'
-        : getSelectionType(selection)
-    )
-  }, [selection])
-
   // Fast-forward through this arg if it's marked as skippable
   // and we have a valid selection already
   useEffect(() => {
+    console.log('selection input effect', {
+      selectionsByType,
+      canSubmitSelection,
+      arg,
+    })
     setCanSubmitSelection(canSubmitSelectionArg(selectionsByType, arg))
     const argValue = commandBarState.context.argumentsToSubmit[arg.name]
     if (canSubmitSelection && arg.skip && argValue === undefined) {

src/components/FileMachineProvider.tsx

@@ -15,10 +15,10 @@ import {
 import { useCommandsContext } from 'hooks/useCommandsContext'
 import { fileMachine } from 'machines/fileMachine'
 import { mkdir, remove, rename, create } from '@tauri-apps/plugin-fs'
-import { readProject } from 'lib/tauriFS'
 import { isTauri } from 'lib/isTauri'
 import { join, sep } from '@tauri-apps/api/path'
 import { DEFAULT_FILE_NAME, FILE_EXT } from 'lib/constants'
+import { getProjectInfo } from 'lib/tauri'
 
 type MachineContext<T extends AnyStateMachine> = {
   state: StateFrom<T>
@@ -62,7 +62,7 @@ export const FileMachineProvider = ({
     services: {
       readFiles: async (context: ContextFrom<typeof fileMachine>) => {
         const newFiles = isTauri()
-          ? await readProject(context.project.path)
+          ? (await getProjectInfo(context.project.name)).children
           : []
         return {
           ...context.project,

src/components/HelpMenu.tsx

@@ -94,10 +94,7 @@ export function HelpMenu(props: React.PropsWithChildren) {
             if (isInProject) {
               navigate('onboarding')
             } else {
-              createAndOpenNewProject(
-                settings.context.app.projectDirectory.current,
-                navigate
-              )
+              createAndOpenNewProject(navigate)
             }
           }}
         >

src/components/ModelingMachineProvider.tsx

@@ -77,7 +77,7 @@ export const ModelingMachineProvider = ({
     auth,
     settings: {
       context: {
-        app: { theme },
+        app: { theme, enableSSAO },
         modeling: { defaultUnit, highlightEdges },
       },
     },
@@ -87,6 +87,7 @@ export const ModelingMachineProvider = ({
   useSetupEngineManager(streamRef, token, {
     theme: theme.current,
     highlightEdges: highlightEdges.current,
+    enableSSAO: enableSSAO.current,
   })
   const { htmlRef } = useStore((s) => ({
     htmlRef: s.htmlRef,
@@ -267,10 +268,12 @@ export const ModelingMachineProvider = ({
         'has valid extrude selection': ({ selectionRanges }) => {
           // A user can begin extruding if they either have 1+ faces selected or nothing selected
           // TODO: I believe this guard only allows for extruding a single face at a time
-          if (selectionRanges.codeBasedSelections.length < 1) return false
           const isPipe = isSketchPipe(selectionRanges)
 
-          if (isSelectionLastLine(selectionRanges, codeManager.code))
+          if (
+            selectionRanges.codeBasedSelections.length === 0 ||
+            isSelectionLastLine(selectionRanges, codeManager.code)
+          )
             return true
           if (!isPipe) return false
 

src/components/ModelingSidebar/ModelingPanes/KclEditorPane.tsx

@@ -16,7 +16,6 @@ import {
   EditorView,
   dropCursor,
   drawSelection,
-  ViewUpdate,
 } from '@codemirror/view'
 import {
   indentWithTab,
@@ -191,9 +190,6 @@ export const KclEditorPane = () => {
     return extensions
   }, [kclLSP, copilotLSP, textWrapping.current, cursorBlinking.current])
 
-  let debounceTimer: ReturnType<typeof setTimeout> | null = null
-  const updateDelay = 100
-
   return (
     <div
       id="code-mirror-override"
@@ -206,17 +202,6 @@ export const KclEditorPane = () => {
         onCreateEditor={(_editorView) =>
           editorManager.setEditorView(_editorView)
         }
-        onUpdate={(view: ViewUpdate) => {
-          // debounce the view update.
-          // otherwise it is laggy for typing.
-          if (debounceTimer) {
-            clearTimeout(debounceTimer)
-          }
-
-          debounceTimer = setTimeout(() => {
-            editorManager.handleOnViewUpdate(view)
-          }, updateDelay)
-        }}
         indentWithTab={false}
         basicSetup={false}
       />

src/components/ProjectCard.tsx

@@ -1,5 +1,4 @@
 import { FormEvent, useEffect, useRef, useState } from 'react'
-import { type ProjectWithEntryPointMetadata } from 'lib/types'
 import { paths } from 'lib/paths'
 import { Link } from 'react-router-dom'
 import { ActionButton } from './ActionButton'
@@ -9,11 +8,11 @@ import {
   faTrashAlt,
   faX,
 } from '@fortawesome/free-solid-svg-icons'
-import { getPartsCount, readProject } from '../lib/tauriFS'
 import { FILE_EXT } from 'lib/constants'
 import { Dialog } from '@headlessui/react'
 import { useHotkeys } from 'react-hotkeys-hook'
 import Tooltip from './Tooltip'
+import { Project } from 'wasm-lib/kcl/bindings/Project'
 
 function ProjectCard({
   project,
@@ -21,17 +20,17 @@ function ProjectCard({
   handleDeleteProject,
   ...props
 }: {
-  project: ProjectWithEntryPointMetadata
+  project: Project
   handleRenameProject: (
     e: FormEvent<HTMLFormElement>,
-    f: ProjectWithEntryPointMetadata
+    f: Project
   ) => Promise<void>
-  handleDeleteProject: (f: ProjectWithEntryPointMetadata) => Promise<void>
+  handleDeleteProject: (f: Project) => Promise<void>
 }) {
   useHotkeys('esc', () => setIsEditing(false))
   const [isEditing, setIsEditing] = useState(false)
   const [isConfirmingDelete, setIsConfirmingDelete] = useState(false)
-  const [numberOfParts, setNumberOfParts] = useState(1)
+  const [numberOfFiles, setNumberOfFiles] = useState(1)
   const [numberOfFolders, setNumberOfFolders] = useState(0)
 
   let inputRef = useRef<HTMLInputElement>(null)
@@ -41,7 +40,8 @@ function ProjectCard({
     void handleRenameProject(e, project).then(() => setIsEditing(false))
   }
 
-  function getDisplayedTime(date: Date) {
+  function getDisplayedTime(dateStr: string) {
+    const date = new Date(dateStr)
     const startOfToday = new Date()
     startOfToday.setHours(0, 0, 0, 0)
     return date.getTime() < startOfToday.getTime()
@@ -50,15 +50,12 @@ function ProjectCard({
   }
 
   useEffect(() => {
-    async function getNumberOfParts() {
-      const { kclFileCount, kclDirCount } = getPartsCount(
-        await readProject(project.path)
-      )
-      setNumberOfParts(kclFileCount)
-      setNumberOfFolders(kclDirCount)
+    async function getNumberOfFiles() {
+      setNumberOfFiles(project.kcl_file_count)
+      setNumberOfFolders(project.directory_count)
     }
-    void getNumberOfParts()
-  }, [project.path])
+    void getNumberOfFiles()
+  }, [project.kcl_file_count, project.directory_count])
 
   useEffect(() => {
     if (inputRef.current) {
@@ -129,7 +126,7 @@ function ProjectCard({
               {project.name?.replace(FILE_EXT, '')}
             </Link>
             <span className="text-chalkboard-60 text-xs">
-              {numberOfParts} part{numberOfParts === 1 ? '' : 's'}{' '}
+              {numberOfFiles} file{numberOfFiles === 1 ? '' : 's'}{' '}
               {numberOfFolders > 0 &&
                 `/ ${numberOfFolders} folder${
                   numberOfFolders === 1 ? '' : 's'
@@ -137,8 +134,8 @@ function ProjectCard({
             </span>
             <span className="text-chalkboard-60 text-xs">
               Edited{' '}
-              {project.entrypointMetadata.mtime
-                ? getDisplayedTime(project.entrypointMetadata.mtime)
+              {project.metadata && project.metadata?.modified
+                ? getDisplayedTime(project.metadata.modified)
                 : 'never'}
             </span>
             <div className="absolute z-10 bottom-2 right-2 flex gap-1 items-center opacity-0 group-hover:opacity-100 group-focus-within:opacity-100">

src/components/ProjectSidebarMenu.test.tsx

@@ -1,10 +1,10 @@
 import { fireEvent, render, screen } from '@testing-library/react'
 import { BrowserRouter } from 'react-router-dom'
 import ProjectSidebarMenu from './ProjectSidebarMenu'
-import { type ProjectWithEntryPointMetadata } from 'lib/types'
 import { SettingsAuthProviderJest } from './SettingsAuthProvider'
 import { APP_NAME } from 'lib/constants'
 import { CommandBarProvider } from './CommandBar/CommandBarProvider'
+import { Project } from 'wasm-lib/kcl/bindings/Project'
 
 const now = new Date()
 const projectWellFormed = {
@@ -14,29 +14,17 @@ const projectWellFormed = {
     {
       name: 'main.kcl',
       path: '/some/path/Simple Box/main.kcl',
+      children: [],
     },
   ],
-  entrypointMetadata: {
-    atime: now,
-    blksize: 32,
-    blocks: 32,
-    birthtime: now,
-    dev: 1,
-    gid: 1,
-    ino: 1,
-    isDirectory: false,
-    isFile: true,
-    isSymlink: false,
-    mode: 1,
-    mtime: now,
-    nlink: 1,
-    readonly: false,
-    rdev: 1,
+  metadata: {
+    created: now.toISOString(),
+    modified: now.toISOString(),
     size: 32,
-    uid: 1,
-    fileAttributes: null,
   },
-} satisfies ProjectWithEntryPointMetadata
+  kcl_file_count: 1,
+  directory_count: 0,
+} satisfies Project
 
 describe('ProjectSidebarMenu tests', () => {
   test('Renders the project name', () => {

src/components/ProjectSidebarMenu.tsx

@@ -133,13 +133,13 @@ function ProjectMenuPopover({
                   <p className="m-0 text-mono" data-testid="projectName">
                     {project?.name ? project.name : APP_NAME}
                   </p>
-                  {project?.entrypointMetadata && (
+                  {project?.metadata && project.metadata.created && (
                     <p
                       className="m-0 text-xs text-chalkboard-80 dark:text-chalkboard-40"
                       data-testid="createdAt"
                     >
                       Created{' '}
-                      {project.entrypointMetadata.birthtime?.toLocaleDateString()}
+                      {new Date(project.metadata.created).toLocaleDateString()}
                     </p>
                   )}
                 </div>

src/components/SettingsAuthProvider.tsx

@@ -7,7 +7,12 @@ import React, { createContext, useEffect } from 'react'
 import useStateMachineCommands from '../hooks/useStateMachineCommands'
 import { settingsMachine } from 'machines/settingsMachine'
 import { toast } from 'react-hot-toast'
-import { getThemeColorForEngine, setThemeClass, Themes } from 'lib/theme'
+import {
+  getThemeColorForEngine,
+  getOppositeTheme,
+  setThemeClass,
+  Themes,
+} from 'lib/theme'
 import decamelize from 'decamelize'
 import {
   AnyStateMachine,
@@ -99,6 +104,9 @@ export const SettingsAuthProviderBase = ({
     {
       context: loadedSettings,
       actions: {
+        //TODO: batch all these and if that's difficult to do from tsx,
+        // make it easy to do
+
         setClientSideSceneUnits: (context, event) => {
           const newBaseUnit =
             event.type === 'set.modeling.defaultUnit'
@@ -115,6 +123,16 @@ export const SettingsAuthProviderBase = ({
               color: getThemeColorForEngine(context.app.theme.current),
             },
           })
+
+          const opposingTheme = getOppositeTheme(context.app.theme.current)
+          engineCommandManager.sendSceneCommand({
+            cmd_id: uuidv4(),
+            type: 'modeling_cmd_req',
+            cmd: {
+              type: 'set_default_system_properties',
+              color: getThemeColorForEngine(opposingTheme),
+            },
+          })
         },
         setEngineEdges: (context) => {
           engineCommandManager.sendSceneCommand({
@@ -150,7 +168,7 @@ export const SettingsAuthProviderBase = ({
         },
         'Execute AST': () => kclManager.executeCode(true),
         persistSettings: (context) =>
-          saveSettings(context, loadedProject?.project?.path),
+          saveSettings(context, loadedProject?.project?.name),
       },
     }
   )

src/editor/plugins/lsp/plugin.ts

@@ -39,6 +39,8 @@ const CompletionItemKindMap = Object.fromEntries(
 ) as Record<CompletionItemKind, string>
 
 const changesDelay = 600
+let debounceTimer: ReturnType<typeof setTimeout> | null = null
+const updateDelay = 100
 
 export class LanguageServerPlugin implements PluginValue {
   public client: LanguageServerClient
@@ -47,6 +49,7 @@ export class LanguageServerPlugin implements PluginValue {
   public workspaceFolders: LSP.WorkspaceFolder[]
   private documentVersion: number
   private foldingRanges: LSP.FoldingRange[] | null = null
+  private viewUpdate: ViewUpdate | null = null
   private _defferer = deferExecution((code: string) => {
     try {
       // Update the state (not the editor) with the new code.
@@ -57,8 +60,9 @@ export class LanguageServerPlugin implements PluginValue {
         },
         contentChanges: [{ text: code }],
       })
-      if (editorManager.editorView) {
-        //editorManager.handleOnViewUpdate(editorManager.editorView)
+
+      if (this.viewUpdate) {
+        editorManager.handleOnViewUpdate(this.viewUpdate)
       }
     } catch (e) {
       console.error(e)
@@ -83,14 +87,27 @@ export class LanguageServerPlugin implements PluginValue {
     })
   }
 
-  update({ docChanged }: ViewUpdate) {
-    if (!docChanged) return
+  update(viewUpdate: ViewUpdate) {
+    this.viewUpdate = viewUpdate
+    if (!viewUpdate.docChanged) {
+      // debounce the view update.
+      // otherwise it is laggy for typing.
+      if (debounceTimer) {
+        clearTimeout(debounceTimer)
+      }
+
+      debounceTimer = setTimeout(() => {
+        editorManager.handleOnViewUpdate(viewUpdate)
+      }, updateDelay)
+      return
+    }
 
     const newCode = this.view.state.doc.toString()
 
     codeManager.code = newCode
     codeManager.writeToFile()
     kclManager.executeCode()
+
     this.sendChange({
       documentText: newCode,
     })

src/hooks/useSetupEngineManager.ts

@@ -11,9 +11,11 @@ export function useSetupEngineManager(
   settings = {
     theme: Themes.System,
     highlightEdges: true,
+    enableSSAO: true,
   } as {
     theme: Themes
     highlightEdges: boolean
+    enableSSAO: boolean
   }
 ) {
   const {

src/lang/recast.test.ts

@@ -266,9 +266,9 @@ const mySk1 = startSketchAt([0, 0])
 
 
   |> rx(45, %)
-  /*
-  one more for good measure
-  */
+/*
+one more for good measure
+*/
 `
     const { ast } = code2ast(code)
     const recasted = recast(ast)
@@ -285,7 +285,7 @@ const mySk1 = startSketchAt([0, 0])
   // and another with just white space between others below
   |> ry(45, %)
   |> rx(45, %)
-  /* one more for good measure */
+/* one more for good measure */
 `)
   })
 })

src/lang/std/engineConnection.ts

@@ -4,7 +4,7 @@ import { Models } from '@kittycad/lib'
 import { exportSave } from 'lib/exportSave'
 import { uuidv4 } from 'lib/utils'
 import { getNodePathFromSourceRange } from 'lang/queryAst'
-import { Themes, getThemeColorForEngine } from 'lib/theme'
+import { Themes, getThemeColorForEngine, getOppositeTheme } from 'lib/theme'
 import { DefaultPlanes } from 'wasm-lib/kcl/bindings/DefaultPlanes'
 
 let lastMessage = ''
@@ -941,6 +941,7 @@ export class EngineCommandManager {
     settings = {
       theme: Themes.Dark,
       highlightEdges: true,
+      enableSSAO: true,
     },
   }: {
     setMediaStream: (stream: MediaStream) => void
@@ -953,6 +954,7 @@ export class EngineCommandManager {
     settings?: {
       theme: Themes
       highlightEdges: boolean
+      enableSSAO: boolean
     }
   }) {
     this.makeDefaultPlanes = makeDefaultPlanes
@@ -969,7 +971,8 @@ export class EngineCommandManager {
       return
     }
 
-    const url = `${VITE_KC_API_WS_MODELING_URL}?video_res_width=${width}&video_res_height=${height}`
+    const additionalSettings = settings.enableSSAO ? '&post_effect=ssao' : ''
+    const url = `${VITE_KC_API_WS_MODELING_URL}?video_res_width=${width}&video_res_height=${height}${additionalSettings}`
     this.engineConnection = new EngineConnection({
       engineCommandManager: this,
       url,
@@ -989,6 +992,18 @@ export class EngineCommandManager {
             color: getThemeColorForEngine(settings.theme),
           },
         })
+
+        // Sets the default line colors
+        const opposingTheme = getOppositeTheme(settings.theme)
+        this.sendSceneCommand({
+          cmd_id: uuidv4(),
+          type: 'modeling_cmd_req',
+          cmd: {
+            type: 'set_default_system_properties',
+            color: getThemeColorForEngine(opposingTheme),
+          },
+        })
+
         // Set the edge lines visibility
         this.sendSceneCommand({
           type: 'modeling_cmd_req',
@@ -1326,6 +1341,17 @@ export class EngineCommandManager {
     this.lastArtifactMap = this.artifactMap
     this.artifactMap = {}
     await this.initPlanes()
+    await this.sendSceneCommand({
+      type: 'modeling_cmd_req',
+      cmd_id: uuidv4(),
+      cmd: {
+        type: 'make_axes_gizmo',
+        clobber: false,
+        // If true, axes gizmo will be placed in the corner of the screen.
+        // If false, it will be placed at the origin of the scene.
+        gizmo_mode: true,
+      },
+    })
   }
   subscribeTo<T extends ModelTypes>({
     event,

src/lang/std/fileSystemManager.ts

@@ -1,8 +1,7 @@
 import { readFile, exists as tauriExists } from '@tauri-apps/plugin-fs'
 import { isTauri } from 'lib/isTauri'
 import { join } from '@tauri-apps/api/path'
-import { invoke } from '@tauri-apps/api/core'
-import { FileEntry } from 'lib/types'
+import { readDirRecursive } from 'lib/tauri'
 
 /// FileSystemManager is a class that provides a way to read files from the local file system.
 /// It assumes that you are in a project since it is solely used by the std lib
@@ -69,9 +68,7 @@ class FileSystemManager {
         throw new Error(`Error joining dir: ${error}`)
       })
       .then((p) => {
-        invoke<FileEntry[]>('read_dir_recursive', {
-          path: p,
-        })
+        readDirRecursive(p)
           .catch((error) => {
             throw new Error(`Error reading dir: ${error}`)
           })

src/lang/std/sketch.test.ts

@@ -102,7 +102,7 @@ describe('testing changeSketchArguments', () => {
   |> startProfileAt([0, 0], %)
   |> ${line}
   |> lineTo([0.46, -5.82], %)
-  // |> rx(45, %)
+// |> rx(45, %)
 `
     const code = genCode(lineToChange)
     const expectedCode = genCode(lineAfterChange)

src/lang/wasm.ts

@@ -10,7 +10,10 @@ import init, {
   make_default_planes,
   coredump,
   toml_stringify,
-  toml_parse,
+  default_app_settings,
+  parse_app_settings,
+  parse_project_settings,
+  default_project_settings,
 } from '../wasm-lib/pkg/wasm_lib'
 import { KCLError } from './errors'
 import { KclError as RustKclError } from '../wasm-lib/kcl/bindings/KclError'
@@ -26,6 +29,8 @@ import { CoreDumpManager } from 'lib/coredump'
 import openWindow from 'lib/openWindow'
 import { DefaultPlanes } from 'wasm-lib/kcl/bindings/DefaultPlanes'
 import { TEST } from 'env'
+import { Configuration } from 'wasm-lib/kcl/bindings/Configuration'
+import { ProjectConfiguration } from 'wasm-lib/kcl/bindings/ProjectConfiguration'
 
 export type { Program } from '../wasm-lib/kcl/bindings/Program'
 export type { Value } from '../wasm-lib/kcl/bindings/Value'
@@ -349,11 +354,38 @@ export function tomlStringify(toml: any): string {
   }
 }
 
-export function tomlParse(toml: string): any {
+export function defaultAppSettings(): Configuration {
   try {
-    const parsed: any = toml_parse(toml)
-    return parsed
+    const settings: Configuration = default_app_settings()
+    return settings
   } catch (e: any) {
-    throw new Error(`Error parsing toml: ${e}`)
+    throw new Error(`Error getting default app settings: ${e}`)
+  }
+}
+
+export function parseAppSettings(toml: string): Configuration {
+  try {
+    const settings: Configuration = parse_app_settings(toml)
+    return settings
+  } catch (e: any) {
+    throw new Error(`Error parsing app settings: ${e}`)
+  }
+}
+
+export function defaultProjectSettings(): ProjectConfiguration {
+  try {
+    const settings: ProjectConfiguration = default_project_settings()
+    return settings
+  } catch (e: any) {
+    throw new Error(`Error getting default project settings: ${e}`)
+  }
+}
+
+export function parseProjectSettings(toml: string): ProjectConfiguration {
+  try {
+    const settings: ProjectConfiguration = parse_project_settings(toml)
+    return settings
+  } catch (e: any) {
+    throw new Error(`Error parsing project settings: ${e}`)
   }
 }

src/lib/cameraControls.ts

@@ -1,3 +1,5 @@
+import { MouseControlType } from 'wasm-lib/kcl/bindings/MouseControlType'
+
 const noModifiersPressed = (e: React.MouseEvent) =>
   !e.ctrlKey && !e.shiftKey && !e.altKey && !e.metaKey
 
@@ -20,6 +22,29 @@ export const cameraSystems: CameraSystem[] = [
   'AutoCAD',
 ]
 
+export function mouseControlsToCameraSystem(
+  mouseControl: MouseControlType | undefined
+): CameraSystem | undefined {
+  switch (mouseControl) {
+    case 'kitty_cad':
+      return 'KittyCAD'
+    case 'on_shape':
+      return 'OnShape'
+    case 'trackpad_friendly':
+      return 'Trackpad Friendly'
+    case 'solidworks':
+      return 'Solidworks'
+    case 'nx':
+      return 'NX'
+    case 'creo':
+      return 'Creo'
+    case 'auto_cad':
+      return 'AutoCAD'
+    default:
+      return undefined
+  }
+}
+
 interface MouseGuardHandler {
   description: string
   callback: (e: React.MouseEvent) => boolean

src/lib/constants.ts

@@ -8,8 +8,6 @@ export const MAX_PADDING = 7
  * This is available for users to edit as a setting.
  */
 export const DEFAULT_PROJECT_NAME = 'project-$nnn'
-/** The file name for settings files, both at the user and project level */
-export const SETTINGS_FILE_EXT = '.toml'
 /** Name given the temporary "project" in the browser version of the app */
 export const BROWSER_PROJECT_NAME = 'browser'
 /** Name given the temporary file in the browser version of the app */

src/lib/routeLoaders.ts

@@ -1,10 +1,5 @@
 import { ActionFunction, LoaderFunction, redirect } from 'react-router-dom'
-import {
-  FileEntry,
-  FileLoaderData,
-  HomeLoaderData,
-  IndexLoaderData,
-} from './types'
+import { FileLoaderData, HomeLoaderData, IndexLoaderData } from './types'
 import { isTauri } from './isTauri'
 import { getProjectMetaByRouteId, paths } from './paths'
 import { BROWSER_PATH } from 'lib/paths'
@@ -14,24 +9,24 @@ import {
   PROJECT_ENTRYPOINT,
 } from 'lib/constants'
 import { loadAndValidateSettings } from './settings/settingsUtils'
-import {
-  getInitialDefaultDir,
-  getProjectsInDir,
-  initializeProjectDirectory,
-} from './tauriFS'
 import makeUrlPathRelative from './makeUrlPathRelative'
-import { join, sep } from '@tauri-apps/api/path'
-import { readTextFile, stat } from '@tauri-apps/plugin-fs'
+import { sep } from '@tauri-apps/api/path'
+import { readTextFile } from '@tauri-apps/plugin-fs'
 import { codeManager, kclManager } from 'lib/singletons'
 import { fileSystemManager } from 'lang/std/fileSystemManager'
-import { invoke } from '@tauri-apps/api/core'
+import {
+  getProjectInfo,
+  initializeProjectDirectory,
+  listProjects,
+} from './tauri'
+import { createSettings } from './settings/initialSettings'
 
 // The root loader simply resolves the settings and any errors that
 // occurred during the settings load
 export const settingsLoader: LoaderFunction = async ({
   params,
-}): ReturnType<typeof loadAndValidateSettings> => {
-  let settings = await loadAndValidateSettings()
+}): Promise<ReturnType<typeof createSettings>> => {
+  let { settings } = await loadAndValidateSettings()
 
   // I don't love that we have to read the settings again here,
   // but we need to get the project path to load the project settings
@@ -39,8 +34,9 @@ export const settingsLoader: LoaderFunction = async ({
     const defaultDir = settings.app.projectDirectory.current || ''
     const projectPathData = getProjectMetaByRouteId(params.id, defaultDir)
     if (projectPathData) {
-      const { projectPath } = projectPathData
-      settings = await loadAndValidateSettings(projectPath)
+      const { projectName } = projectPathData
+      const { settings: s } = await loadAndValidateSettings(projectName)
+      settings = s
     }
   }
 
@@ -49,7 +45,7 @@ export const settingsLoader: LoaderFunction = async ({
 
 // Redirect users to the appropriate onboarding page if they haven't completed it
 export const onboardingRedirectLoader: ActionFunction = async (args) => {
-  const settings = await loadAndValidateSettings()
+  const { settings } = await loadAndValidateSettings()
   const onboardingStatus = settings.app.onboardingStatus.current || ''
   const notEnRouteToOnboarding = !args.request.url.includes(
     paths.ONBOARDING.INDEX
@@ -73,7 +69,7 @@ export const onboardingRedirectLoader: ActionFunction = async (args) => {
 export const fileLoader: LoaderFunction = async ({
   params,
 }): Promise<FileLoaderData | Response> => {
-  let settings = await loadAndValidateSettings()
+  let { settings } = await loadAndValidateSettings()
 
   const defaultDir = settings.app.projectDirectory.current || '/'
   const projectPathData = getProjectMetaByRouteId(params.id, defaultDir)
@@ -94,12 +90,7 @@ export const fileLoader: LoaderFunction = async ({
     // TODO: PROJECT_ENTRYPOINT is hardcoded
     // until we support setting a project's entrypoint file
     const code = await readTextFile(currentFilePath)
-    const entrypointMetadata = await stat(
-      await join(projectPath, PROJECT_ENTRYPOINT)
-    )
-    const children = await invoke<FileEntry[]>('read_dir_recursive', {
-      path: projectPath,
-    })
+
     // Update both the state and the editor's code.
     // We explicitly do not write to the file here since we are loading from
     // the file system and not the editor.
@@ -113,15 +104,19 @@ export const fileLoader: LoaderFunction = async ({
 
     const projectData: IndexLoaderData = {
       code,
-      project: {
-        name: projectName,
-        path: projectPath,
-        children,
-        entrypointMetadata,
-      },
+      project: isTauri()
+        ? await getProjectInfo(projectName)
+        : {
+            name: projectName,
+            path: projectPath,
+            children: [],
+            kcl_file_count: 0,
+            directory_count: 0,
+          },
       file: {
         name: currentFileName,
         path: currentFilePath,
+        children: [],
       },
     }
 
@@ -140,6 +135,7 @@ export const fileLoader: LoaderFunction = async ({
     file: {
       name: BROWSER_FILE_NAME,
       path: decodeURIComponent(BROWSER_PATH),
+      children: [],
     },
   }
 }
@@ -152,14 +148,12 @@ export const homeLoader: LoaderFunction = async (): Promise<
   if (!isTauri()) {
     return redirect(paths.FILE + '/%2F' + BROWSER_PROJECT_NAME)
   }
-  const settings = await loadAndValidateSettings()
+  const { configuration } = await loadAndValidateSettings()
 
-  const projectDir = await initializeProjectDirectory(
-    settings.app.projectDirectory.current || (await getInitialDefaultDir())
-  )
+  const projectDir = await initializeProjectDirectory(configuration)
 
-  if (projectDir.path) {
-    const projects = await getProjectsInDir(projectDir.path)
+  if (projectDir) {
+    const projects = await listProjects(configuration)
 
     return {
       projects,

src/lib/selections.ts

@@ -420,7 +420,13 @@ export function getSelectionTypeDisplayText(
   const selectionsByType = getSelectionType(selection)
 
   return (selectionsByType as Exclude<typeof selectionsByType, 'none'>)
-    .map(([type, count]) => `${count} ${type}${count > 1 ? 's' : ''}`)
+    .map(
+      // Hack for showing "face" instead of "extrude-wall" in command bar text
+      ([type, count]) =>
+        `${count} ${type.replace('extrude-wall', 'face')}${
+          count > 1 ? 's' : ''
+        }`
+    )
     .join(', ')
 }
 

src/lib/settings/initialSettings.tsx

@@ -156,6 +156,13 @@ export function createSettings() {
           </div>
         ),
       }),
+      enableSSAO: new Setting<boolean>({
+        defaultValue: true,
+        description:
+          'Whether or not Screen Space Ambient Occlusion (SSAO) is enabled',
+        validate: (v) => typeof v === 'boolean',
+        hideOnPlatform: 'both', //for now
+      }),
       onboardingStatus: new Setting<string>({
         defaultValue: '',
         validate: (v) => typeof v === 'string',

src/lib/settings/settingsUtils.ts

@@ -1,100 +1,228 @@
-import {
-  getInitialDefaultDir,
-  getSettingsFilePaths,
-  readSettingsFile,
-} from '../tauriFS'
 import { Setting, createSettings, settings } from 'lib/settings/initialSettings'
 import { SaveSettingsPayload, SettingsLevel } from './settingsTypes'
 import { isTauri } from 'lib/isTauri'
-import { remove, writeTextFile, exists } from '@tauri-apps/plugin-fs'
-import { initPromise, tomlParse, tomlStringify } from 'lang/wasm'
+import {
+  defaultAppSettings,
+  defaultProjectSettings,
+  initPromise,
+  parseAppSettings,
+  parseProjectSettings,
+  tomlStringify,
+} from 'lang/wasm'
+import { Configuration } from 'wasm-lib/kcl/bindings/Configuration'
+import { mouseControlsToCameraSystem } from 'lib/cameraControls'
+import { appThemeToTheme } from 'lib/theme'
+import {
+  readAppSettingsFile,
+  readProjectSettingsFile,
+  writeAppSettingsFile,
+  writeProjectSettingsFile,
+} from 'lib/tauri'
+import { ProjectConfiguration } from 'wasm-lib/kcl/bindings/ProjectConfiguration'
+import { BROWSER_PROJECT_NAME } from 'lib/constants'
 
 /**
- * We expect the settings to be stored in a TOML file
- * or TOML-formatted string in localStorage
- * under a top-level [settings] key.
- * @param path
- * @returns
- */
-function getSettingsFromStorage(path: string) {
-  return isTauri()
-    ? readSettingsFile(path)
-    : (tomlParse(localStorage.getItem(path) ?? '')
-        .settings as Partial<SaveSettingsPayload>)
+ * Convert from a rust settings struct into the JS settings struct.
+ * We do this because the JS settings type has all the fancy shit
+ * for hiding and showing settings.
+ **/
+function configurationToSettingsPayload(
+  configuration: Configuration
+): Partial<SaveSettingsPayload> {
+  return {
+    app: {
+      theme: appThemeToTheme(configuration?.settings?.app?.appearance?.theme),
+      themeColor: configuration?.settings?.app?.appearance?.color
+        ? configuration?.settings?.app?.appearance?.color.toString()
+        : undefined,
+      onboardingStatus: configuration?.settings?.app?.onboarding_status,
+      dismissWebBanner: configuration?.settings?.app?.dismiss_web_banner,
+      projectDirectory: configuration?.settings?.project?.directory,
+      enableSSAO: configuration?.settings?.modeling?.enable_ssao,
+    },
+    modeling: {
+      defaultUnit: configuration?.settings?.modeling?.base_unit,
+      mouseControls: mouseControlsToCameraSystem(
+        configuration?.settings?.modeling?.mouse_controls
+      ),
+      highlightEdges: configuration?.settings?.modeling?.highlight_edges,
+      showDebugPanel: configuration?.settings?.modeling?.show_debug_panel,
+    },
+    textEditor: {
+      textWrapping: configuration?.settings?.text_editor?.text_wrapping,
+      blinkingCursor: configuration?.settings?.text_editor?.blinking_cursor,
+    },
+    projects: {
+      defaultProjectName:
+        configuration?.settings?.project?.default_project_name,
+    },
+    commandBar: {
+      includeSettings: configuration?.settings?.command_bar?.include_settings,
+    },
+  }
 }
 
-export async function loadAndValidateSettings(projectPath?: string) {
-  const settings = createSettings()
-  settings.app.projectDirectory.default = await getInitialDefaultDir()
-  // First, get the settings data at the user and project level
-  const settingsFilePaths = await getSettingsFilePaths(projectPath)
+function projectConfigurationToSettingsPayload(
+  configuration: ProjectConfiguration
+): Partial<SaveSettingsPayload> {
+  return {
+    app: {
+      theme: appThemeToTheme(configuration?.settings?.app?.appearance?.theme),
+      themeColor: configuration?.settings?.app?.appearance?.color
+        ? configuration?.settings?.app?.appearance?.color.toString()
+        : undefined,
+      onboardingStatus: configuration?.settings?.app?.onboarding_status,
+      dismissWebBanner: configuration?.settings?.app?.dismiss_web_banner,
+      enableSSAO: configuration?.settings?.modeling?.enable_ssao,
+    },
+    modeling: {
+      defaultUnit: configuration?.settings?.modeling?.base_unit,
+      mouseControls: mouseControlsToCameraSystem(
+        configuration?.settings?.modeling?.mouse_controls
+      ),
+      highlightEdges: configuration?.settings?.modeling?.highlight_edges,
+      showDebugPanel: configuration?.settings?.modeling?.show_debug_panel,
+    },
+    textEditor: {
+      textWrapping: configuration?.settings?.text_editor?.text_wrapping,
+      blinkingCursor: configuration?.settings?.text_editor?.blinking_cursor,
+    },
+    commandBar: {
+      includeSettings: configuration?.settings?.command_bar?.include_settings,
+    },
+  }
+}
 
-  // Load the settings from the files
-  if (settingsFilePaths.user) {
-    await initPromise
-    const userSettings = await getSettingsFromStorage(settingsFilePaths.user)
-    if (userSettings) {
-      setSettingsAtLevel(settings, 'user', userSettings)
-    }
+function localStorageAppSettingsPath() {
+  return '/settings.toml'
+}
+
+function localStorageProjectSettingsPath() {
+  return '/' + BROWSER_PROJECT_NAME + '/project.toml'
+}
+
+function readLocalStorageAppSettingsFile(): Configuration {
+  // TODO: Remove backwards compatibility after a few releases.
+  let stored =
+    localStorage.getItem(localStorageAppSettingsPath()) ??
+    localStorage.getItem('/user.toml') ??
+    ''
+
+  if (stored === '') {
+    return defaultAppSettings()
   }
 
-  // Load the project settings if they exist
-  if (settingsFilePaths.project) {
-    const projectSettings = await getSettingsFromStorage(
-      settingsFilePaths.project
+  try {
+    return parseAppSettings(stored)
+  } catch (e) {
+    const settings = defaultAppSettings()
+    localStorage.setItem(localStorageAppSettingsPath(), tomlStringify(settings))
+    return settings
+  }
+}
+
+function readLocalStorageProjectSettingsFile(): ProjectConfiguration {
+  // TODO: Remove backwards compatibility after a few releases.
+  let stored = localStorage.getItem(localStorageProjectSettingsPath()) ?? ''
+
+  if (stored === '') {
+    return defaultProjectSettings()
+  }
+
+  try {
+    return parseProjectSettings(stored)
+  } catch (e) {
+    const settings = defaultProjectSettings()
+    localStorage.setItem(
+      localStorageProjectSettingsPath(),
+      tomlStringify(settings)
     )
-    if (projectSettings) {
-      setSettingsAtLevel(settings, 'project', projectSettings)
-    }
+    return settings
+  }
+}
+
+export interface AppSettings {
+  settings: ReturnType<typeof createSettings>
+  configuration: Configuration
+}
+
+export async function loadAndValidateSettings(
+  projectName?: string
+): Promise<AppSettings> {
+  const settings = createSettings()
+  const inTauri = isTauri()
+
+  if (!inTauri) {
+    // Make sure we have wasm initialized.
+    await initPromise
+  }
+
+  // Load the app settings from the file system or localStorage.
+  const appSettings = inTauri
+    ? await readAppSettingsFile()
+    : readLocalStorageAppSettingsFile()
+  // Convert the app settings to the JS settings format.
+  const appSettingsPayload = configurationToSettingsPayload(appSettings)
+  setSettingsAtLevel(settings, 'user', appSettingsPayload)
+
+  // Load the project settings if they exist
+  if (projectName) {
+    const projectSettings = inTauri
+      ? await readProjectSettingsFile(appSettings, projectName)
+      : readLocalStorageProjectSettingsFile()
+
+    const projectSettingsPayload =
+      projectConfigurationToSettingsPayload(projectSettings)
+    setSettingsAtLevel(settings, 'project', projectSettingsPayload)
   }
 
   // Return the settings object
-  return settings
+  return { settings, configuration: appSettings }
 }
 
 export async function saveSettings(
   allSettings: typeof settings,
-  projectPath?: string
-) {
-  const settingsFilePaths = await getSettingsFilePaths(projectPath)
-
-  if (settingsFilePaths.user) {
-    const changedSettings = getChangedSettingsAtLevel(allSettings, 'user')
-
-    await writeOrClearPersistedSettings(settingsFilePaths.user, changedSettings)
-  }
-
-  if (settingsFilePaths.project) {
-    const changedSettings = getChangedSettingsAtLevel(allSettings, 'project')
-
-    await writeOrClearPersistedSettings(
-      settingsFilePaths.project,
-      changedSettings
-    )
-  }
-}
-
-async function writeOrClearPersistedSettings(
-  settingsFilePath: string,
-  changedSettings: Partial<SaveSettingsPayload>
+  projectName?: string
 ) {
+  // Make sure we have wasm initialized.
   await initPromise
-  if (changedSettings && Object.keys(changedSettings).length) {
-    if (isTauri()) {
-      await writeTextFile(
-        settingsFilePath,
-        tomlStringify({ settings: changedSettings })
-      )
-    }
-    localStorage.setItem(
-      settingsFilePath,
-      tomlStringify({ settings: changedSettings })
-    )
+  const inTauri = isTauri()
+
+  // Get the user settings.
+  const jsAppSettings = getChangedSettingsAtLevel(allSettings, 'user')
+  const tomlString = tomlStringify({ settings: jsAppSettings })
+  // Parse this as a Configuration.
+  const appSettings = parseAppSettings(tomlString)
+
+  // Write the app settings.
+  if (inTauri) {
+    await writeAppSettingsFile(appSettings)
   } else {
-    if (isTauri() && (await exists(settingsFilePath))) {
-      await remove(settingsFilePath)
-    }
-    localStorage.removeItem(settingsFilePath)
+    localStorage.setItem(
+      localStorageAppSettingsPath(),
+      tomlStringify(appSettings)
+    )
+  }
+
+  if (!projectName) {
+    // If we're not saving project settings, we're done.
+    return
+  }
+
+  // Get the project settings.
+  const jsProjectSettings = getChangedSettingsAtLevel(allSettings, 'project')
+  const projectTomlString = tomlStringify({ settings: jsProjectSettings })
+  // Parse this as a Configuration.
+  const projectSettings = parseProjectSettings(projectTomlString)
+
+  // Write the project settings.
+  if (inTauri) {
+    await writeProjectSettingsFile(appSettings, projectName, projectSettings)
+  } else {
+    localStorage.setItem(
+      localStorageProjectSettingsPath(),
+      tomlStringify(projectSettings)
+    )
   }
 }
 

src/lib/sorting.ts

@@ -3,7 +3,7 @@ import {
   faArrowUp,
   faCircle,
 } from '@fortawesome/free-solid-svg-icons'
-import { type ProjectWithEntryPointMetadata } from 'lib/types'
+import { Project } from 'wasm-lib/kcl/bindings/Project'
 
 const DESC = ':desc'
 
@@ -27,10 +27,7 @@ export function getNextSearchParams(currentSort: string, newSort: string) {
 }
 
 export function getSortFunction(sortBy: string) {
-  const sortByName = (
-    a: ProjectWithEntryPointMetadata,
-    b: ProjectWithEntryPointMetadata
-  ) => {
+  const sortByName = (a: Project, b: Project) => {
     if (a.name && b.name) {
       return sortBy.includes('desc')
         ? a.name.localeCompare(b.name)
@@ -39,16 +36,13 @@ export function getSortFunction(sortBy: string) {
     return 0
   }
 
-  const sortByModified = (
-    a: ProjectWithEntryPointMetadata,
-    b: ProjectWithEntryPointMetadata
-  ) => {
-    if (a.entrypointMetadata?.mtime && b.entrypointMetadata?.mtime) {
+  const sortByModified = (a: Project, b: Project) => {
+    if (a.metadata?.modified && b.metadata?.modified) {
+      const aDate = new Date(a.metadata.modified)
+      const bDate = new Date(b.metadata.modified)
       return !sortBy || sortBy.includes('desc')
-        ? b.entrypointMetadata.mtime.getTime() -
-            a.entrypointMetadata.mtime.getTime()
-        : a.entrypointMetadata.mtime.getTime() -
-            b.entrypointMetadata.mtime.getTime()
+        ? bDate.getTime() - aDate.getTime()
+        : aDate.getTime() - bDate.getTime()
     }
     return 0
   }

src/lib/tauri.ts

@@ -0,0 +1,128 @@
+// This file contains wrappers around the tauri commands we define in rust code.
+
+import { Models } from '@kittycad/lib/dist/types/src'
+import { invoke } from '@tauri-apps/api/core'
+import { Configuration } from 'wasm-lib/kcl/bindings/Configuration'
+import { ProjectConfiguration } from 'wasm-lib/kcl/bindings/ProjectConfiguration'
+import { Project } from 'wasm-lib/kcl/bindings/Project'
+import { FileEntry } from 'wasm-lib/kcl/bindings/FileEntry'
+
+// Get the initial default dir for holding all projects.
+export async function getInitialDefaultDir(): Promise<string> {
+  return invoke<string>('get_initial_default_dir')
+}
+
+export async function showInFolder(path: string | undefined): Promise<void> {
+  if (!path) {
+    console.error('path is undefined cannot call tauri showInFolder')
+    return
+  }
+  return await invoke('show_in_folder', { path })
+}
+
+export async function initializeProjectDirectory(
+  settings: Configuration
+): Promise<string> {
+  return await invoke<string>('initialize_project_directory', {
+    configuration: settings,
+  })
+}
+
+export async function createNewProjectDirectory(
+  projectName: string,
+  initialCode?: string,
+  configuration?: Configuration
+): Promise<Project> {
+  if (!configuration) {
+    configuration = await readAppSettingsFile()
+  }
+  return await invoke<Project>('create_new_project_directory', {
+    configuration,
+    projectName,
+    initialCode,
+  })
+}
+
+export async function listProjects(
+  configuration?: Configuration
+): Promise<Project[]> {
+  if (!configuration) {
+    configuration = await readAppSettingsFile()
+  }
+  return await invoke<Project[]>('list_projects', { configuration })
+}
+
+export async function getProjectInfo(
+  projectName: string,
+  configuration?: Configuration
+): Promise<Project> {
+  if (!configuration) {
+    configuration = await readAppSettingsFile()
+  }
+  return await invoke<Project>('get_project_info', {
+    configuration,
+    projectName,
+  })
+}
+
+export async function login(host: string): Promise<string> {
+  return await invoke('login', { host })
+}
+
+export async function getUser(
+  token: string | undefined,
+  host: string
+): Promise<Models['User_type'] | Record<'error_code', unknown> | void> {
+  if (!token) {
+    console.error('token is undefined cannot call tauri getUser')
+    return
+  }
+
+  return await invoke<Models['User_type'] | Record<'error_code', unknown>>(
+    'get_user',
+    {
+      token: token,
+      hostname: host,
+    }
+  ).catch((err) => console.error('error from Tauri getUser', err))
+}
+
+export async function readDirRecursive(path: string): Promise<FileEntry[]> {
+  return await invoke<FileEntry[]>('read_dir_recursive', { path })
+}
+
+// Read the contents of the app settings.
+export async function readAppSettingsFile(): Promise<Configuration> {
+  return await invoke<Configuration>('read_app_settings_file')
+}
+
+// Write the contents of the app settings.
+export async function writeAppSettingsFile(
+  settings: Configuration
+): Promise<void> {
+  return await invoke('write_app_settings_file', { configuration: settings })
+}
+
+// Read project settings file.
+export async function readProjectSettingsFile(
+  appSettings: Configuration,
+  projectName: string
+): Promise<ProjectConfiguration> {
+  return await invoke<ProjectConfiguration>('read_project_settings_file', {
+    appSettings,
+    projectName,
+  })
+}
+
+// Write project settings file.
+export async function writeProjectSettingsFile(
+  appSettings: Configuration,
+  projectName: string,
+  settings: ProjectConfiguration
+): Promise<void> {
+  return await invoke('write_project_settings_file', {
+    appSettings,
+    projectName,
+    configuration: settings,
+  })
+}

src/lib/tauriFS.test.ts

@@ -1,11 +1,4 @@
-import {
-  deepFileFilter,
-  getNextProjectIndex,
-  getPartsCount,
-  interpolateProjectNameWithIndex,
-  isRelevantFileOrDir,
-} from './tauriFS'
-import type { FileEntry } from './types'
+import { getNextProjectIndex, interpolateProjectNameWithIndex } from './tauriFS'
 import { MAX_PADDING } from './constants'
 
 describe('Test project name utility functions', () => {
@@ -31,18 +24,22 @@ describe('Test project name utility functions', () => {
     {
       name: 'new-project-04.kcl',
       path: '/projects/new-project-04.kcl',
+      children: [],
     },
     {
       name: 'new-project-007.kcl',
       path: '/projects/new-project-007.kcl',
+      children: [],
     },
     {
       name: 'new-project-05.kcl',
       path: '/projects/new-project-05.kcl',
+      children: [],
     },
     {
       name: 'new-project-0.kcl',
       path: '/projects/new-project-0.kcl',
+      children: [],
     },
   ]
 
@@ -50,101 +47,3 @@ describe('Test project name utility functions', () => {
     expect(getNextProjectIndex('new-project-$n', testFiles)).toBe(8)
   })
 })
-
-describe('Test file tree utility functions', () => {
-  const baseFiles: FileEntry[] = [
-    {
-      name: 'show-me.kcl',
-      path: '/projects/show-me.kcl',
-    },
-    {
-      name: 'hide-me.jpg',
-      path: '/projects/hide-me.jpg',
-    },
-    {
-      name: '.gitignore',
-      path: '/projects/.gitignore',
-    },
-  ]
-
-  const filteredBaseFiles: FileEntry[] = [
-    {
-      name: 'show-me.kcl',
-      path: '/projects/show-me.kcl',
-    },
-  ]
-
-  it('Only includes files relevant to the project in a flat directory', () => {
-    expect(deepFileFilter(baseFiles, isRelevantFileOrDir)).toEqual(
-      filteredBaseFiles
-    )
-  })
-
-  const nestedFiles: FileEntry[] = [
-    ...baseFiles,
-    {
-      name: 'show-me',
-      path: '/projects/show-me',
-      children: [
-        {
-          name: 'show-me-nested',
-          path: '/projects/show-me/show-me-nested',
-          children: baseFiles,
-        },
-        {
-          name: 'hide-me',
-          path: '/projects/show-me/hide-me',
-          children: baseFiles.filter((file) => file.name !== 'show-me.kcl'),
-        },
-      ],
-    },
-    {
-      name: 'hide-me',
-      path: '/projects/hide-me',
-      children: baseFiles.filter((file) => file.name !== 'show-me.kcl'),
-    },
-  ]
-
-  const filteredNestedFiles: FileEntry[] = [
-    ...filteredBaseFiles,
-    {
-      name: 'show-me',
-      path: '/projects/show-me',
-      children: [
-        {
-          name: 'show-me-nested',
-          path: '/projects/show-me/show-me-nested',
-          children: filteredBaseFiles,
-        },
-      ],
-    },
-  ]
-
-  it('Only includes directories that include files relevant to the project in a nested directory', () => {
-    expect(deepFileFilter(nestedFiles, isRelevantFileOrDir)).toEqual(
-      filteredNestedFiles
-    )
-  })
-
-  const withHiddenDir: FileEntry[] = [
-    ...baseFiles,
-    {
-      name: '.hide-me',
-      path: '/projects/.hide-me',
-      children: baseFiles,
-    },
-  ]
-
-  it(`Hides folders that begin with a ".", even if they contain relevant files`, () => {
-    expect(deepFileFilter(withHiddenDir, isRelevantFileOrDir)).toEqual(
-      filteredBaseFiles
-    )
-  })
-
-  it(`Properly counts the number of relevant files and directories in a project`, () => {
-    expect(getPartsCount(nestedFiles)).toEqual({
-      kclFileCount: 2,
-      kclDirCount: 2,
-    })
-  })
-})

src/lib/tauriFS.ts

@@ -1,154 +1,19 @@
-import {
-  mkdir,
-  exists,
-  readTextFile,
-  writeTextFile,
-  stat,
-} from '@tauri-apps/plugin-fs'
-import { invoke } from '@tauri-apps/api/core'
-import {
-  appConfigDir,
-  documentDir,
-  homeDir,
-  join,
-  sep,
-} from '@tauri-apps/api/path'
+import { appConfigDir } from '@tauri-apps/api/path'
 import { isTauri } from './isTauri'
-import type { FileEntry, ProjectWithEntryPointMetadata } from 'lib/types'
+import type { FileEntry } from 'lib/types'
 import {
-  FILE_EXT,
   INDEX_IDENTIFIER,
   MAX_PADDING,
   ONBOARDING_PROJECT_NAME,
   PROJECT_ENTRYPOINT,
-  PROJECT_FOLDER,
-  RELEVANT_FILE_TYPES,
-  SETTINGS_FILE_EXT,
 } from 'lib/constants'
-import { SaveSettingsPayload, SettingsLevel } from './settings/settingsTypes'
-import { initPromise, tomlParse } from 'lang/wasm'
 import { bracket } from './exampleKcl'
 import { paths } from './paths'
-
-type PathWithPossibleError = {
-  path: string | null
-  error: Error | null
-}
-
-export async function getInitialDefaultDir() {
-  if (!isTauri()) return ''
-  let dir
-  try {
-    dir = await documentDir()
-  } catch (e) {
-    dir = await join(await homeDir(), 'Documents') // for headless Linux (eg. Github Actions)
-  }
-
-  return await join(dir, PROJECT_FOLDER)
-}
-
-// Initializes the project directory and returns the path
-// with any Errors that occurred
-export async function initializeProjectDirectory(
-  directory: string
-): Promise<PathWithPossibleError> {
-  let returnValue: PathWithPossibleError = {
-    path: null,
-    error: null,
-  }
-
-  if (!isTauri()) return returnValue
-
-  if (directory) {
-    returnValue = await testAndCreateDir(directory, returnValue)
-  }
-
-  // If the directory from settings does not exist or could not be created,
-  // use the default directory
-  if (returnValue.path === null) {
-    const INITIAL_DEFAULT_DIR = await getInitialDefaultDir()
-    const defaultReturnValue = await testAndCreateDir(
-      INITIAL_DEFAULT_DIR,
-      returnValue,
-      {
-        exists: 'Error checking default directory.',
-        create: 'Error creating default directory.',
-      }
-    )
-    returnValue.path = defaultReturnValue.path
-    returnValue.error =
-      returnValue.error === null ? defaultReturnValue.error : returnValue.error
-  }
-
-  return returnValue
-}
-
-async function testAndCreateDir(
-  directory: string,
-  returnValue = {
-    path: null,
-    error: null,
-  } as PathWithPossibleError,
-  errorMessages = {
-    exists:
-      'Error checking directory at path from saved settings. Using default.',
-    create:
-      'Error creating directory at path from saved settings. Using default.',
-  }
-): Promise<PathWithPossibleError> {
-  const dirExists = await exists(directory).catch((e) => {
-    console.error(`Error checking directory ${directory}. Original error:`, e)
-    return new Error(errorMessages.exists)
-  })
-
-  if (dirExists instanceof Error) {
-    returnValue.error = dirExists
-  } else if (dirExists === false) {
-    const newDirCreated = await mkdir(directory, { recursive: true }).catch(
-      (e) => {
-        console.error(
-          `Error creating directory ${directory}. Original error:`,
-          e
-        )
-        return new Error(errorMessages.create)
-      }
-    )
-
-    if (newDirCreated instanceof Error) {
-      returnValue.error = newDirCreated
-    } else {
-      returnValue.path = directory
-    }
-  } else if (dirExists === true) {
-    returnValue.path = directory
-  }
-
-  return returnValue
-}
-
-export function isProjectDirectory(fileOrDir: Partial<FileEntry>) {
-  return (
-    fileOrDir.children?.length &&
-    fileOrDir.children.some((child) => child.name === PROJECT_ENTRYPOINT)
-  )
-}
-
-// Read the contents of a directory
-// and return the valid projects
-export async function getProjectsInDir(projectDir: string) {
-  const readProjects = (
-    await invoke<FileEntry[]>('read_dir_recursive', { path: projectDir })
-  ).filter(isProjectDirectory)
-
-  const projectsWithMetadata = await Promise.all(
-    readProjects.map(async (p) => ({
-      entrypointMetadata: await stat(await join(p.path, PROJECT_ENTRYPOINT)),
-      ...p,
-    }))
-  )
-
-  return projectsWithMetadata
-}
+import {
+  createNewProjectDirectory,
+  listProjects,
+  readAppSettingsFile,
+} from './tauri'
 
 export const isHidden = (fileOrDir: FileEntry) =>
   !!fileOrDir.name?.startsWith('.')
@@ -156,97 +21,6 @@ export const isHidden = (fileOrDir: FileEntry) =>
 export const isDir = (fileOrDir: FileEntry) =>
   'children' in fileOrDir && fileOrDir.children !== undefined
 
-export function deepFileFilter(
-  entries: FileEntry[],
-  filterFn: (f: FileEntry) => boolean
-): FileEntry[] {
-  const filteredEntries: FileEntry[] = []
-  for (const fileOrDir of entries) {
-    if ('children' in fileOrDir && fileOrDir.children !== undefined) {
-      const filteredChildren = deepFileFilter(fileOrDir.children, filterFn)
-      if (filterFn(fileOrDir)) {
-        filteredEntries.push({
-          ...fileOrDir,
-          children: filteredChildren,
-        })
-      }
-    } else if (filterFn(fileOrDir)) {
-      filteredEntries.push(fileOrDir)
-    }
-  }
-  return filteredEntries
-}
-
-export function deepFileFilterFlat(
-  entries: FileEntry[],
-  filterFn: (f: FileEntry) => boolean
-): FileEntry[] {
-  const filteredEntries: FileEntry[] = []
-  for (const fileOrDir of entries) {
-    if ('children' in fileOrDir && fileOrDir.children !== undefined) {
-      const filteredChildren = deepFileFilterFlat(fileOrDir.children, filterFn)
-      if (filterFn(fileOrDir)) {
-        filteredEntries.push({
-          ...fileOrDir,
-          children: filteredChildren,
-        })
-      }
-      filteredEntries.push(...filteredChildren)
-    } else if (filterFn(fileOrDir)) {
-      filteredEntries.push(fileOrDir)
-    }
-  }
-  return filteredEntries
-}
-
-// Read the contents of a project directory
-// and return all relevant files and sub-directories recursively
-export async function readProject(projectDir: string) {
-  const readFiles = await invoke<FileEntry[]>('read_dir_recursive', {
-    path: projectDir,
-  })
-
-  return deepFileFilter(readFiles, isRelevantFileOrDir)
-}
-
-// Given a read project, return the number of .kcl files,
-// both in the root directory and in sub-directories,
-// and folders that contain at least one .kcl file
-export function getPartsCount(project: FileEntry[]) {
-  const flatProject = deepFileFilterFlat(project, isRelevantFileOrDir)
-
-  const kclFileCount = flatProject.filter((f) =>
-    f.name?.endsWith(FILE_EXT)
-  ).length
-  const kclDirCount = flatProject.filter((f) => f.children !== undefined).length
-
-  return {
-    kclFileCount,
-    kclDirCount,
-  }
-}
-
-// Determines if a file or directory is relevant to the project
-// i.e. not a hidden file or directory, and is a relevant file type
-// or contains at least one relevant file (even if it's nested)
-// or is a completely empty directory
-export function isRelevantFileOrDir(fileOrDir: FileEntry) {
-  let isRelevantDir = false
-  if ('children' in fileOrDir && fileOrDir.children !== undefined) {
-    isRelevantDir =
-      !isHidden(fileOrDir) &&
-      (fileOrDir.children.some(isRelevantFileOrDir) ||
-        fileOrDir.children.length === 0)
-  }
-  const isRelevantFile =
-    !isHidden(fileOrDir) &&
-    RELEVANT_FILE_TYPES.some((ext) => fileOrDir.name?.endsWith(ext))
-
-  return (
-    (isDir(fileOrDir) && isRelevantDir) || (!isDir(fileOrDir) && isRelevantFile)
-  )
-}
-
 // Deeply sort the files and directories in a project like VS Code does:
 // The main.kcl file is always first, then files, then directories
 // Files and directories are sorted alphabetically
@@ -279,47 +53,6 @@ export function sortProject(project: FileEntry[]): FileEntry[] {
   })
 }
 
-// Creates a new file in the default directory with the default project name
-// Returns the path to the new file
-export async function createNewProject(
-  path: string,
-  initCode = ''
-): Promise<ProjectWithEntryPointMetadata> {
-  if (!isTauri) {
-    throw new Error('createNewProject() can only be called from a Tauri app')
-  }
-
-  const dirExists = await exists(path)
-  if (!dirExists) {
-    await mkdir(path, { recursive: true }).catch((err) => {
-      console.error('Error creating new directory:', err)
-      throw err
-    })
-  }
-
-  await writeTextFile(await join(path, PROJECT_ENTRYPOINT), initCode).catch(
-    (err) => {
-      console.error('Error creating new file:', err)
-      throw err
-    }
-  )
-
-  const m = await stat(path)
-
-  return {
-    name: path.slice(path.lastIndexOf(sep()) + 1),
-    path: path,
-    entrypointMetadata: m,
-    children: [
-      {
-        name: PROJECT_ENTRYPOINT,
-        path: await join(path, PROJECT_ENTRYPOINT),
-        children: [],
-      },
-    ],
-  }
-}
-
 // create a regex to match the project name
 // replacing any instances of "$n" with a regex to match any number
 function interpolateProjectName(projectName: string) {
@@ -373,55 +106,6 @@ function getPaddedIdentifierRegExp() {
   return new RegExp(`${escapedIdentifier}(${escapedIdentifier.slice(-1)}*)`)
 }
 
-export async function getUserSettingsFilePath(
-  filename: string = SETTINGS_FILE_EXT
-) {
-  const dir = await appConfigDir()
-  return await join(dir, filename)
-}
-
-export async function readSettingsFile(
-  path: string
-): Promise<Partial<SaveSettingsPayload>> {
-  const dir = path.slice(0, path.lastIndexOf(sep()))
-
-  const dirExists = await exists(dir)
-  if (!dirExists) {
-    await mkdir(dir, { recursive: true })
-  }
-
-  const settingsExist = dirExists ? await exists(path) : false
-
-  if (!settingsExist) {
-    console.log(`Settings file does not exist at ${path}`)
-    return {}
-  }
-
-  try {
-    await initPromise
-    const settings = await readTextFile(path)
-    // We expect the settings to be under a top-level [settings] key
-    return tomlParse(settings).settings as Partial<SaveSettingsPayload>
-  } catch (e) {
-    console.error('Error reading settings file:', e)
-    return {}
-  }
-}
-
-export async function getSettingsFilePaths(
-  projectPath?: string
-): Promise<Partial<Record<SettingsLevel, string>>> {
-  const { user, project } = await getSettingsFolderPaths(projectPath)
-
-  return {
-    user: user + 'user' + SETTINGS_FILE_EXT,
-    project:
-      project !== undefined
-        ? project + (isTauri() ? sep() : '/') + 'project' + SETTINGS_FILE_EXT
-        : undefined,
-  }
-}
-
 export async function getSettingsFolderPaths(projectPath?: string) {
   const user = isTauri() ? await appConfigDir() : '/'
   const project = projectPath !== undefined ? projectPath : undefined
@@ -433,18 +117,15 @@ export async function getSettingsFolderPaths(projectPath?: string) {
 }
 
 export async function createAndOpenNewProject(
-  projectDirectory: string,
   navigate: (path: string) => void
 ) {
-  const projects = await getProjectsInDir(projectDirectory)
-  const nextIndex = await getNextProjectIndex(ONBOARDING_PROJECT_NAME, projects)
+  const configuration = await readAppSettingsFile()
+  const projects = await listProjects(configuration)
+  const nextIndex = getNextProjectIndex(ONBOARDING_PROJECT_NAME, projects)
   const name = interpolateProjectNameWithIndex(
     ONBOARDING_PROJECT_NAME,
     nextIndex
   )
-  const newFile = await createNewProject(
-    await join(projectDirectory, name),
-    bracket
-  )
+  const newFile = await createNewProjectDirectory(name, bracket, configuration)
   navigate(`${paths.FILE}/${encodeURIComponent(newFile.path)}`)
 }

src/lib/theme.ts

@@ -1,9 +1,26 @@
+import { AppTheme } from 'wasm-lib/kcl/bindings/AppTheme'
+
 export enum Themes {
   Light = 'light',
   Dark = 'dark',
   System = 'system',
 }
 
+export function appThemeToTheme(
+  theme: AppTheme | undefined
+): Themes | undefined {
+  switch (theme) {
+    case 'light':
+      return Themes.Light
+    case 'dark':
+      return Themes.Dark
+    case 'system':
+      return Themes.System
+    default:
+      return undefined
+  }
+}
+
 // Get the theme from the system settings manually
 export function getSystemTheme(): Exclude<Themes, 'system'> {
   return typeof globalThis.window !== 'undefined' &&
@@ -23,6 +40,17 @@ export function setThemeClass(theme: Themes) {
   }
 }
 
+// Returns the resolved theme in use (Dark || Light)
+export function getResolvedTheme(theme: Themes) {
+  return theme === Themes.System ? getSystemTheme() : theme
+}
+
+// Returns the opposing theme
+export function getOppositeTheme(theme: Themes) {
+  const resolvedTheme = getResolvedTheme(theme)
+  return resolvedTheme === Themes.Dark ? Themes.Light : Themes.Dark
+}
+
 /**
  * The engine takes RGBA values from 0-1
  * So we convert from the conventional 0-255 found in Figma
@@ -30,7 +58,7 @@ export function setThemeClass(theme: Themes) {
  * @returns { r: number, g: number, b: number, a: number }
  */
 export function getThemeColorForEngine(theme: Themes) {
-  const resolvedTheme = theme === Themes.System ? getSystemTheme() : theme
+  const resolvedTheme = getResolvedTheme(theme)
   const dark = 28 / 255
   const light = 249 / 255
   return resolvedTheme === Themes.Dark