Merge branch 'r4/host' into ship/core

app/src/components/projects/ClaudeCodeSettingsEditor.test.tsx

@@ -193,4 +193,27 @@ describe("ClaudeCodeSettingsEditor", () => {
       expect(screen.getByRole("switch", { name: label })).toBeChecked();
     });
   });
+
+  /**
+   * A settings object with nothing set at this level arrives as `{}`: the Rust
+   * struct skips serialising a field it has no value for, which is what keeps
+   * an older binary able to parse `projects.json` after a downgrade. It is also
+   * the exact shape a project stored before the fields were widened is read
+   * back as — every one of its `false`s meant "unset" — so reading absent as
+   * "off" would show a switch the user never touched as a deliberate choice.
+   */
+  it("reads an absent field as Global rather than as Off", () => {
+    renderEditor({} as ClaudeCodeSettings, "project");
+    expect((screen.getByLabelText("Env scrub") as HTMLSelectElement).value).toBe("global");
+    expect((screen.getByLabelText("Session recap") as HTMLSelectElement).value).toBe("global");
+  });
+
+  it("still collapses to null when an absent-field object is edited back", () => {
+    const onSave = renderEditor({} as ClaudeCodeSettings, "global");
+    // Off and straight back on: the round trip has to land on `null`, or an
+    // untouched global stops being indistinguishable from one never opened.
+    fireEvent.click(screen.getByRole("switch", { name: "Session recap" }));
+    fireEvent.click(screen.getByRole("switch", { name: "Session recap" }));
+    expect(onSave).toHaveBeenLastCalledWith(null);
+  });
 });

app/src/components/projects/ClaudeCodeSettingsEditor.tsx

@@ -37,15 +37,20 @@ export const CLAUDE_CODE_DEFAULTS: ClaudeCodeSettings = {
  * overrides a global on, so a settings object holding one has to be persisted.
  */
 function isAllDefaults(s: ClaudeCodeSettings): boolean {
+  // `== null`, not `===`: an unset field is *absent* on the wire, not null.
+  // The Rust struct skips serialising one it has no value for, so a project
+  // whose stored settings were all "unset" arrives here as `{}` — and reading
+  // that as "off" is exactly the mistake the three-state control exists to
+  // avoid. See the note on `ClaudeCodeSettings` in `lib/types.ts`.
   return (
-    s.tui_mode === null &&
-    s.effort === null &&
-    s.auto_scroll_disabled === null &&
-    s.focus_mode === null &&
-    s.show_thinking_summaries === null &&
-    s.session_recap_disabled === null &&
-    s.env_scrub === null &&
-    s.prompt_caching_1h === null
+    s.tui_mode == null &&
+    s.effort == null &&
+    s.auto_scroll_disabled == null &&
+    s.focus_mode == null &&
+    s.show_thinking_summaries == null &&
+    s.session_recap_disabled == null &&
+    s.env_scrub == null &&
+    s.prompt_caching_1h == null
   );
 }
 
@@ -204,7 +209,7 @@ export default function ClaudeCodeSettingsEditor({
         // `stored` holds the deviation from Claude Code's default, so an
         // inverted field reads back the other way round — see BOOLEAN_FIELDS.
         const selected =
-          stored === null ? "global" : (invert ? !stored : stored) ? "on" : "off";
+          stored == null ? "global" : (invert ? !stored : stored) ? "on" : "off";
 
         return (
           <SwitchRow

app/src/components/projects/home/config/WorkspaceSection.test.tsx

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, fireEvent, act } from "@testing-library/react";
+import WorkspaceSection from "./WorkspaceSection";
+import type { Project } from "../../../../lib/types";
+
+// The Browse button is the OS folder picker.
+const open = vi.fn();
+vi.mock("@tauri-apps/plugin-dialog", () => ({
+  open: (...args: unknown[]) => open(...args),
+}));
+
+const baseProject: Project = {
+  id: "p1",
+  name: "api-server",
+  paths: [{ host_path: "/src/api", mount_name: "api" }],
+  container_id: null,
+  status: "stopped",
+  backend: "anthropic",
+  bedrock_config: null,
+  ollama_config: null,
+  llamacpp_config: null,
+  openai_compatible_config: null,
+  allow_docker_access: false,
+  sandbox_mode_enabled: true,
+  mission_control_enabled: false,
+  auth_bridge_enabled: false,
+  browser_view_enabled: false,
+  vpn_support_enabled: false,
+  use_shared_auth_token: true,
+  full_permissions: false,
+  permission_mode: null,
+  ssh_key_path: null,
+  ca_cert_path: null,
+  git_token: null,
+  git_user_name: null,
+  git_user_email: null,
+  custom_env_vars: [],
+  port_mappings: [],
+  claude_instructions: null,
+  claude_code_settings: null,
+  renamed_session_names: {},
+  created_at: "2026-01-01T00:00:00Z",
+  updated_at: "2026-01-01T00:00:00Z",
+};
+
+const save = vi.fn().mockResolvedValue(true);
+
+function renderSection(over: Partial<Project> = {}, disabled = false) {
+  return render(
+    <WorkspaceSection
+      project={{ ...baseProject, ...over }}
+      save={save}
+      disabled={disabled}
+    />,
+  );
+}
+
+/** Every folder list this component has sent to `update_project`. */
+function savedLists() {
+  return save.mock.calls
+    .filter(([patch]) => "paths" in patch)
+    .map(([patch]) => patch.paths);
+}
+
+describe("WorkspaceSection — the blank row is never stored", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  /**
+   * The bug this file exists for. `create_container` mounts every stored row
+   * unfiltered, so a persisted `{host_path: "", mount_name: ""}` becomes
+   * `{"Target": "/workspace/", "Source": ""}` and the daemon refuses the whole
+   * container with `field Source must not be empty` — the project can never be
+   * started or recreated again. Click "+ Add folder", blur a field, and it is
+   * bricked.
+   */
+  it("drops the placeholder row when a real edit is saved", () => {
+    renderSection();
+    fireEvent.click(screen.getByRole("button", { name: "+ Add folder" }));
+
+    const hostPath = screen.getByLabelText("Folder 1 host path");
+    fireEvent.change(hostPath, { target: { value: "/src/api-v2" } });
+    fireEvent.blur(hostPath);
+
+    expect(save).toHaveBeenCalledTimes(1);
+    expect(savedLists()[0]).toEqual([{ host_path: "/src/api-v2", mount_name: "api" }]);
+  });
+
+  it("drops it when Browse fills a different row in", async () => {
+    open.mockResolvedValueOnce("/src/api-v2");
+    renderSection();
+    fireEvent.click(screen.getByRole("button", { name: "+ Add folder" }));
+
+    // The picker is awaited inside the handler, so the state update that
+    // follows it lands outside the click.
+    await act(async () => {
+      fireEvent.click(screen.getAllByRole("button", { name: "Browse" })[0]);
+    });
+
+    expect(savedLists()[0]).toEqual([{ host_path: "/src/api-v2", mount_name: "api" }]);
+  });
+
+  it("drops it when a row is removed", () => {
+    renderSection({
+      paths: [
+        { host_path: "/src/api", mount_name: "api" },
+        { host_path: "/src/web", mount_name: "web" },
+      ],
+    });
+    fireEvent.click(screen.getByRole("button", { name: "+ Add folder" }));
+    fireEvent.click(screen.getByRole("button", { name: "Remove folder 2" }));
+
+    expect(savedLists()[0]).toEqual([{ host_path: "/src/api", mount_name: "api" }]);
+  });
+
+  it("never sends a row with an empty host path, whatever the route", () => {
+    renderSection();
+    fireEvent.click(screen.getByRole("button", { name: "+ Add folder" }));
+    const hostPath = screen.getByLabelText("Folder 1 host path");
+    fireEvent.change(hostPath, { target: { value: "/src/api-v2" } });
+    fireEvent.blur(hostPath);
+
+    for (const list of savedLists()) {
+      for (const row of list) {
+        expect(row.host_path).not.toBe("");
+        expect(row.mount_name).not.toBe("");
+      }
+    }
+  });
+});
+
+describe("WorkspaceSection — what a blur is allowed to save", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  /**
+   * Both inputs save on blur, so tabbing from the host path to the mount name
+   * fires a save with the name still empty — which `update_project` refuses,
+   * turning an ordinary keystroke into an error toast.
+   */
+  it("holds a half-filled row back until it is complete", () => {
+    renderSection();
+    fireEvent.click(screen.getByRole("button", { name: "+ Add folder" }));
+
+    const newHostPath = screen.getByLabelText("Folder 2 host path");
+    fireEvent.change(newHostPath, { target: { value: "/src/web" } });
+    fireEvent.blur(newHostPath);
+    expect(save).not.toHaveBeenCalled();
+
+    const newMountName = screen.getByLabelText("Folder 2 mount name");
+    fireEvent.change(newMountName, { target: { value: "web" } });
+    fireEvent.blur(newMountName);
+    expect(savedLists()[0]).toEqual([
+      { host_path: "/src/api", mount_name: "api" },
+      { host_path: "/src/web", mount_name: "web" },
+    ]);
+  });
+
+  /**
+   * Blurring out of an untouched field is not an edit. Saving anyway would
+   * round-trip the filtered list through `project` and take the empty row away
+   * while the user was still filling it in.
+   */
+  it("saves nothing when the blur changed nothing", () => {
+    renderSection();
+    fireEvent.click(screen.getByRole("button", { name: "+ Add folder" }));
+    fireEvent.blur(screen.getByLabelText("Folder 1 mount name"));
+    expect(save).not.toHaveBeenCalled();
+    expect(screen.getByLabelText("Folder 2 host path")).toBeTruthy();
+  });
+
+  it("still saves a rename, which does not go through the folder list", () => {
+    renderSection();
+    const name = screen.getByDisplayValue("api-server");
+    fireEvent.change(name, { target: { value: "api-v2" } });
+    fireEvent.blur(name);
+    expect(save).toHaveBeenCalledWith({ name: "api-v2" });
+  });
+});

app/src/components/projects/home/config/WorkspaceSection.tsx

@@ -10,6 +10,14 @@ interface Props {
   disabled: boolean;
 }
 
+/** Whether two folder lists are the same rows in the same order. */
+function sameRows(a: ProjectPath[], b: ProjectPath[]): boolean {
+  return (
+    a.length === b.length &&
+    a.every((row, i) => row.host_path === b[i].host_path && row.mount_name === b[i].mount_name)
+  );
+}
+
 export default function WorkspaceSection({ project, save, disabled }: Props) {
   const [name, setName] = useState(project.name);
   const [paths, setPaths] = useState<ProjectPath[]>(project.paths ?? []);
@@ -19,6 +27,27 @@ export default function WorkspaceSection({ project, save, disabled }: Props) {
     setPaths(project.paths ?? []);
   }, [project]);
 
+  /**
+   * Persist a folder list, minus the rows that are only in it because the UI
+   * put them there.
+   *
+   * **The blank row must never reach the store.** "+ Add folder" inserts
+   * `{host_path: "", mount_name: ""}` deliberately, and `create_container`
+   * mounts every stored row unfiltered — a stored blank one becomes
+   * `{"Target": "/workspace/", "Source": ""}`, which the daemon rejects with
+   * `field Source must not be empty`. The project then cannot be started or
+   * recreated at all, from a click and a blur. `AddProjectDialog` has always
+   * filtered this; this section computed the filtered list and then saved the
+   * unfiltered one.
+   *
+   * Every save goes through here for that reason — Browse and Remove write the
+   * list too, and either can be holding a blank row from an earlier click.
+   */
+  const persist = (rows: ProjectPath[]) => {
+    const filled = rows.filter((p) => p.host_path.trim() || p.mount_name.trim());
+    return save({ paths: filled });
+  };
+
   /**
    * Save only when every row is fully filled in.
    *
@@ -27,12 +56,18 @@ export default function WorkspaceSection({ project, save, disabled }: Props) {
    * a half-filled row is refused — so the unconditional save turned an ordinary
    * keystroke into an error toast. A blank row is *not* incomplete: the
    * "+ Add folder" button adds one deliberately, and it is dropped on save.
+   *
+   * A blur that changed nothing saves nothing, which is what keeps the blank
+   * row on screen while it is being filled in: persisting the filtered list
+   * would round-trip through `project` and take the empty row away under the
+   * cursor.
    */
   const saveIfComplete = () => {
     const filled = paths.filter((p) => p.host_path.trim() || p.mount_name.trim());
     const halfFilled = filled.some((p) => !p.host_path.trim() || !p.mount_name.trim());
     if (halfFilled) return;
-    return save({ paths });
+    if (sameRows(filled, project.paths ?? [])) return;
+    return persist(paths);
   };
 
   return (
@@ -106,7 +141,7 @@ export default function WorkspaceSection({ project, save, disabled }: Props) {
                         mount_name: updated[i].mount_name || basename,
                       };
                       setPaths(updated);
-                      save({ paths: updated });
+                      persist(updated);
                     }
                   }}
                 >
@@ -137,7 +172,7 @@ export default function WorkspaceSection({ project, save, disabled }: Props) {
                     onClick={() => {
                       const updated = paths.filter((_, j) => j !== i);
                       setPaths(updated);
-                      save({ paths: updated });
+                      persist(updated);
                     }}
                   >
                     Remove

app/src/lib/types.ts

@@ -162,23 +162,28 @@ export interface OpenAiCompatibleConfig {
  * project that is "inherit the global value", and on the global settings it is
  * "leave Claude Code's own default alone". `false` is a deliberate off, which
  * is what lets a project turn a globally-enabled setting back off.
+ *
+ * Every field is optional as well as nullable: the Rust struct skips
+ * serialising a field it has no value for, so an object with nothing set at
+ * this level arrives as `{}`. Absent and `null` mean the same thing, which is
+ * why every read of one of these has to use `== null` rather than `=== null`.
  */
 export interface ClaudeCodeSettings {
   /** `null` = let Claude Code choose the renderer; `"default"` = classic, `"fullscreen"` = alt-screen. */
-  tui_mode: string | null;
+  tui_mode?: string | null;
   /** `null` = unset, else `"low" | "medium" | "high" | "xhigh"`. Written as `effortLevel`. */
-  effort: string | null;
-  auto_scroll_disabled: boolean | null;
+  effort?: string | null;
+  auto_scroll_disabled?: boolean | null;
   /** Written as `viewMode: "focus"`. */
-  focus_mode: boolean | null;
-  show_thinking_summaries: boolean | null;
+  focus_mode?: boolean | null;
+  show_thinking_summaries?: boolean | null;
   /**
    * Turns the session recap **off**. Held in the disabled sense because Claude
    * Code's recap is on by default — see the Rust doc on `ClaudeCodeSettings`.
    */
-  session_recap_disabled: boolean | null;
-  env_scrub: boolean | null;
-  prompt_caching_1h: boolean | null;
+  session_recap_disabled?: boolean | null;
+  env_scrub?: boolean | null;
+  prompt_caching_1h?: boolean | null;
 }
 
 export interface ContainerInfo {