feat(vscode): replace per-folder workspace entries with single obs://

Replace N file:// workspace folders (one per autoMount entry) with a
single obs://<vault>/ workspace folder using the registered
FileSystemProvider. Mounted entries appear as children under the vault
root, filtered by the provider's readDirectory() at root level.

- Add #autoMount field and setAutoMount() to ObsidianFileSystemProvider
- Filter root readDirectory() to show only autoMount entries
- Fire Created/Deleted events per entry so Explorer refreshes without
  window reload
- Simplify addVaultWorkspaceFolder() to create one obs:// folder
- Avoid removing/re-adding workspace folder on autoMount config changes
- Preserve backward-compat detection of old file:// managed folders

Assisted-by: Claude

Author: otaviof

packages/vscode/README.md

@@ -12,7 +12,7 @@ Browse, search, and edit your [Obsidian](https://obsidian.md) vault directly in
 - **Mount vault folders or individual notes** into the Explorer tree view
 - **Browse and read** Markdown files through the `obs://` virtual file system
 - **Edit existing files** with writes going directly to the vault on disk
-- **Wikilink navigation**, click `[[links]]` in Markdown to jump between notes (resolves to `file://` paths for seamless navigation in workspace folders)
+- **Wikilink navigation**, click `[[links]]` in Markdown to jump between notes
 - **Search notes** via Quick Pick across all vault Markdown files
 - **Open in Obsidian**, jump to the current file in the Obsidian app
 - **Copy path** as `obs://` URI to the clipboard (`Shift+Alt+Cmd+C` on `obs://` files)
@@ -52,19 +52,19 @@ All three toggle settings (`explorer`, `statusBar`, `workspace`) take effect imm
 
 ### Workspace Folder
 
-When `obsidianVFS.workspace` is enabled, the extension adds each `autoMount` folder as a `file://` workspace folder pointing to the actual directory on disk, named **obs://\<folder\>**. Because these are native file-system paths, VS Code's built-in file indexer (`ripgrep`) can index them — so vault files appear in **Quick Open** (`Cmd+P`) and **Search** (`Ctrl+Shift+F`).
+When `obsidianVFS.workspace` is enabled, the extension adds a single **obs://\<vault\>** workspace folder using the `obs://` virtual file system. Mounted `autoMount` entries appear as children under this root — the Explorer shows one vault entry instead of one per folder. VS Code's **Search** (`Ctrl+Shift+F`) and **Quick Open** (`Cmd+P`) work across mounted content through the `FileSystemProvider`.
 
-The `obs://` FileSystemProvider remains registered for internal operations (stat, read, write, file watching). All user-facing navigation — wikilinks, search results, tree view items — resolves to `file://` URIs so they work seamlessly with workspace folders.
+All file operations — stat, read, write, directory listing, and file watching — go through the `obs://` provider, which enforces `allowed`/`blocked` security rules from [`.obsidian/obsidian-vfs.json`](../../README.md#vault-configuration) at every level.
 
 **Requirements:**
 
-- At least one local folder must be open — vault folders are appended to the workspace folder list to avoid triggering an extension host restart.
+- At least one local folder must be open — the vault workspace folder is appended to the list to avoid triggering an extension host restart.
 
 **Notes:**
 
-- `autoMount` entries outside `allowed` or inside `blocked` (from [`.obsidian/obsidian-vfs.json`](../../README.md#vault-configuration)) are silently skipped. However, content *within* a mounted workspace folder is not filtered — because these are native `file://` folders, VS Code browses them directly from disk. Use the **Explorer tree view** for security-enforced browsing; workspace folders are the search and Quick Open surface.
-- The Explorer tree view and the workspace folders both appear in the sidebar. This duplication is an accepted trade-off — the tree view provides custom UI (welcome view, context menus) with `allowed`/`blocked` enforcement, while the workspace folders enable Quick Open and cross-extension visibility.
-- The vault's `.git` repository is automatically added to `git.ignoredRepositories` (user-level setting) when workspace folders are mounted, preventing VS Code's Git extension from listing it in Source Control. The entry is removed when `obsidianVFS.workspace` is disabled.
+- The Explorer tree view and the workspace folder both appear in the sidebar. The tree view provides custom UI (welcome view, context menus), while the workspace folder enables Quick Open and cross-extension visibility. The tree view uses `file://` URIs for opening files, which enables native features like Git integration.
+- `autoMount` entries outside `allowed` or inside `blocked` are filtered from the workspace folder root listing. The core security layer remains as defense-in-depth for navigation into subdirectories.
+- The vault's `.git` repository is automatically added to `git.ignoredRepositories` (user-level setting) when the workspace folder is mounted, preventing VS Code's Git extension from listing it in Source Control. The entry is removed when `obsidianVFS.workspace` is disabled.
 
 ## Related Tools
 

packages/vscode/package.json

@@ -127,7 +127,7 @@
         "obsidianVFS.workspace": {
           "type": "boolean",
           "default": true,
-          "description": "Add the vault as a workspace folder for Explorer browsing. Requires at least one local folder open."
+          "description": "Add the vault as a single obs:// workspace folder for Explorer browsing. Mounted entries appear as children under the vault root. Requires at least one local folder open."
         }
       }
     }

packages/vscode/src/extension.test.ts

@@ -31,6 +31,7 @@ vi.mock("./file-system-provider.js", () => ({
   ObsidianFileSystemProvider: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
     this.watch = vi.fn(() => ({ dispose: vi.fn() }));
     this.dispose = vi.fn();
+    this.setAutoMount = vi.fn();
   }),
 }));
 
@@ -84,6 +85,7 @@ import { WikilinkDocumentLinkProvider } from "./wikilink-provider.js";
 import {
   addVaultWorkspaceFolder,
   excludeVaultFromGitDetection,
+  hasVaultWorkspaceFolder,
   includeVaultInGitDetection,
   removeVaultWorkspaceFolders,
 } from "./workspace-folder.js";
@@ -92,6 +94,7 @@ const mockBootstrap = vi.mocked(bootstrapFromConfig);
 const mockReadConfig = vi.mocked(readConfig);
 const mockAddWF = vi.mocked(addVaultWorkspaceFolder);
 const mockRemoveWF = vi.mocked(removeVaultWorkspaceFolders);
+const mockHasWF = vi.mocked(hasVaultWorkspaceFolder);
 const mockExcludeGit = vi.mocked(excludeVaultFromGitDetection);
 const mockIncludeGit = vi.mocked(includeVaultInGitDetection);
 
@@ -151,7 +154,7 @@ describe("activate", () => {
     const ctx = fakeContext();
     await activate(ctx as never);
 
-    expect(ObsidianFileSystemProvider).toHaveBeenCalledWith(fakeTracker);
+    expect(ObsidianFileSystemProvider).toHaveBeenCalledWith(fakeTracker, []);
     expect(vscode.workspace.registerFileSystemProvider).toHaveBeenCalledWith(
       SCHEME,
       expect.anything(),
@@ -210,11 +213,7 @@ describe("activate", () => {
 
     await activate(fakeContext() as never);
 
-    expect(mockAddWF).toHaveBeenCalledWith("/vault", ["Notes"], {
-      vaultRoot: "/vault",
-      allowed: [],
-      blocked: [],
-    });
+    expect(mockAddWF).toHaveBeenCalledWith("/vault", "MyVault", 1);
     expect(mockExcludeGit).toHaveBeenCalledWith("/vault");
   });
 
@@ -669,11 +668,7 @@ describe("configuration change listener", () => {
     configChangeListener!({ affectsConfiguration: (key) => key === "obsidianVFS.workspace" });
 
     expect(mockRemoveWF).toHaveBeenCalledWith("/vault");
-    expect(mockAddWF).toHaveBeenCalledWith("/vault", ["Notes"], {
-      vaultRoot: "/vault",
-      allowed: [],
-      blocked: [],
-    });
+    expect(mockAddWF).toHaveBeenCalledWith("/vault", "MyVault", 1);
     expect(mockExcludeGit).toHaveBeenCalledWith("/vault");
   });
 
@@ -720,7 +715,7 @@ describe("configuration change listener", () => {
     expect(mockIncludeGit).toHaveBeenCalledWith("/vault");
   });
 
-  it("refreshes workspace folders when autoMount config changes", async () => {
+  it("updates provider without removing workspace folder when autoMount changes", async () => {
     const fakeTracker = {
       context: {
         name: "MyVault",
@@ -745,8 +740,13 @@ describe("configuration change listener", () => {
 
     await activate(fakeContext() as never);
 
+    const providerInstance = vi.mocked(ObsidianFileSystemProvider).mock.results[0].value as {
+      setAutoMount: ReturnType<typeof vi.fn>;
+    };
+
     vi.clearAllMocks();
 
+    mockHasWF.mockReturnValueOnce(true);
     mockReadConfig.mockReturnValueOnce({
       cliPath: "obsidian",
       timeoutMs: 10_000,
@@ -755,16 +755,99 @@ describe("configuration change listener", () => {
       statusBar: true,
       workspace: true,
     });
+
+    configChangeListener!({ affectsConfiguration: (key) => key === "obsidianVFS.autoMount" });
+
+    expect(providerInstance.setAutoMount).toHaveBeenCalledWith(["Notes", "Projects"]);
+    expect(mockRemoveWF).not.toHaveBeenCalled();
+    expect(mockAddWF).not.toHaveBeenCalled();
+  });
+
+  it("adds workspace folder when autoMount goes from empty to non-empty", async () => {
+    const fakeTracker = {
+      context: {
+        name: "MyVault",
+        physicalPath: "/vault",
+        mode: "full",
+        vfsConfig: { agents: [], skills: [], allowed: [], blocked: [] },
+      },
+    } as unknown as LocalIndexTracker;
+
+    mockBootstrap.mockResolvedValueOnce({
+      ok: true,
+      value: { tracker: fakeTracker, initMs: 42 },
+    });
+
+    let configChangeListener:
+      | ((e: { affectsConfiguration: (key: string) => boolean }) => void)
+      | null = null;
+    vi.mocked(vscode.workspace.onDidChangeConfiguration).mockImplementation((callback) => {
+      configChangeListener = callback as typeof configChangeListener;
+      return { dispose: vi.fn() };
+    });
+
+    await activate(fakeContext() as never);
+
+    vi.clearAllMocks();
+
+    mockHasWF.mockReturnValueOnce(false);
     mockAddWF.mockReturnValueOnce({ status: "added" });
+    mockReadConfig.mockReturnValueOnce({
+      cliPath: "obsidian",
+      timeoutMs: 10_000,
+      autoMount: ["Notes"],
+      explorer: true,
+      statusBar: true,
+      workspace: true,
+    });
 
     configChangeListener!({ affectsConfiguration: (key) => key === "obsidianVFS.autoMount" });
 
-    expect(mockRemoveWF).toHaveBeenCalledWith("/vault");
-    expect(mockAddWF).toHaveBeenCalledWith("/vault", ["Notes", "Projects"], {
-      vaultRoot: "/vault",
-      allowed: [],
-      blocked: [],
+    expect(mockAddWF).toHaveBeenCalledWith("/vault", "MyVault", 1);
+    expect(mockExcludeGit).toHaveBeenCalledWith("/vault");
+    expect(mockRemoveWF).not.toHaveBeenCalled();
+  });
+
+  it("removes workspace folder when autoMount becomes empty", async () => {
+    const fakeTracker = {
+      context: {
+        name: "MyVault",
+        physicalPath: "/vault",
+        mode: "full",
+        vfsConfig: { agents: [], skills: [], allowed: [], blocked: [] },
+      },
+    } as unknown as LocalIndexTracker;
+
+    mockBootstrap.mockResolvedValueOnce({
+      ok: true,
+      value: { tracker: fakeTracker, initMs: 42 },
     });
+
+    let configChangeListener:
+      | ((e: { affectsConfiguration: (key: string) => boolean }) => void)
+      | null = null;
+    vi.mocked(vscode.workspace.onDidChangeConfiguration).mockImplementation((callback) => {
+      configChangeListener = callback as typeof configChangeListener;
+      return { dispose: vi.fn() };
+    });
+
+    await activate(fakeContext() as never);
+
+    vi.clearAllMocks();
+
+    mockReadConfig.mockReturnValueOnce({
+      cliPath: "obsidian",
+      timeoutMs: 10_000,
+      autoMount: [],
+      explorer: true,
+      statusBar: true,
+      workspace: true,
+    });
+
+    configChangeListener!({ affectsConfiguration: (key) => key === "obsidianVFS.autoMount" });
+
+    expect(mockRemoveWF).toHaveBeenCalledWith("/vault");
+    expect(mockAddWF).not.toHaveBeenCalled();
   });
 });
 

packages/vscode/src/extension.ts

@@ -1,7 +1,5 @@
 import * as vscode from "vscode";
 
-import type { PathSecurityOptions } from "@obsidian-vfs/core";
-
 import { bootstrapFromConfig, readConfig } from "./bootstrap.js";
 import { SCHEME } from "./uri-adapter.js";
 import { registerCommands } from "./commands.js";
@@ -13,6 +11,7 @@ import {
   FOLDER_NAME_PREFIX,
   addVaultWorkspaceFolder,
   excludeVaultFromGitDetection,
+  hasVaultWorkspaceFolder,
   includeVaultInGitDetection,
   removeVaultWorkspaceFolders,
 } from "./workspace-folder.js";
@@ -34,7 +33,9 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     `Obsidian VFS: vault "${tracker.context.name}" loaded in ${initMs.toFixed(0)}ms`,
   );
 
-  const provider = new ObsidianFileSystemProvider(tracker);
+  const config = readConfig();
+
+  const provider = new ObsidianFileSystemProvider(tracker, config.autoMount);
   context.subscriptions.push(provider);
 
   context.subscriptions.push(
@@ -73,23 +74,16 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     ),
   );
 
-  const config = readConfig();
-
   await vscode.commands.executeCommand("setContext", "obsidianVFS.explorerEnabled", config.explorer);
   if (config.statusBar) {
     statusBar.show();
   }
-  const securityOptions: PathSecurityOptions = {
-    vaultRoot: tracker.context.physicalPath,
-    allowed: tracker.context.vfsConfig.allowed,
-    blocked: tracker.context.vfsConfig.blocked,
-  };
 
   if (config.workspace) {
     const wfResult = addVaultWorkspaceFolder(
       tracker.context.physicalPath,
-      config.autoMount,
-      securityOptions,
+      tracker.context.name,
+      config.autoMount.length,
     );
     const detail = "reason" in wfResult ? ` — ${wfResult.reason}` : "";
     outputChannel.appendLine(`Workspace folder: ${wfResult.status}${detail}`);
@@ -113,17 +107,32 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
           statusBar.hide();
         }
       }
-      if (
-        e.affectsConfiguration("obsidianVFS.workspace") ||
-        e.affectsConfiguration("obsidianVFS.autoMount")
-      ) {
+      if (e.affectsConfiguration("obsidianVFS.autoMount")) {
+        provider.setAutoMount(updated.autoMount);
+      }
+      if (e.affectsConfiguration("obsidianVFS.workspace")) {
         removeVaultWorkspaceFolders(tracker.context.physicalPath);
         if (updated.workspace) {
-          addVaultWorkspaceFolder(tracker.context.physicalPath, updated.autoMount, securityOptions);
+          addVaultWorkspaceFolder(
+            tracker.context.physicalPath,
+            tracker.context.name,
+            updated.autoMount.length,
+          );
           void excludeVaultFromGitDetection(tracker.context.physicalPath);
         } else {
           void includeVaultInGitDetection(tracker.context.physicalPath);
         }
+      } else if (e.affectsConfiguration("obsidianVFS.autoMount") && updated.workspace) {
+        if (updated.autoMount.length === 0) {
+          removeVaultWorkspaceFolders(tracker.context.physicalPath);
+        } else if (!hasVaultWorkspaceFolder(tracker.context.physicalPath)) {
+          addVaultWorkspaceFolder(
+            tracker.context.physicalPath,
+            tracker.context.name,
+            updated.autoMount.length,
+          );
+          void excludeVaultFromGitDetection(tracker.context.physicalPath);
+        }
       }
     }),
   );