feat(vscode): support drag-and-drop, file creation, rename, and delete

Fix three regressions introduced when workspace folders switched from
file:// to obs:// scheme:

- File creation via "New File" failed with EntryNotFound because
  validatePath called realpath() on non-existent paths. Add
  validatePathForWrite() that walks up to the nearest existing ancestor
  for the symlink check, and auto-create parent directories in writeFile.

- Drag-and-drop from local folders into the VFS was broken. Implement
  copy() on the FileSystemProvider for Workspace Explorer drops, and add
  VaultTreeDragAndDropController for sidebar tree drops.

- Moving files out of the vault and deleting vault entries threw
  "Not supported on obs:// scheme". Implement rename() with same-scheme
  fs.rename and cross-scheme copy+delete, and implement delete() with
  path-validated rm().

Also add getParent() to VaultTreeDataProvider for proper drop-target
resolution in nested trees.

Assisted-by: Claude

Author: otaviof

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obsidian-vfs/cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "CLI for Obsidian VFS — provision skills/agents, inspect vault resources",
   "license": "Apache-2.0",

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obsidian-vfs/core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "Core library for Obsidian VFS — vault resolution, content processing, path security",
   "license": "Apache-2.0",

packages/core/src/index.ts

@@ -83,6 +83,7 @@ export { EXIT_SUCCESS, EXIT_ERROR, EXIT_USAGE } from "./exit-codes.js";
  */
 export {
   validatePath,
+  validatePathForWrite,
   canonicalizePath,
   isAllowedPath,
   checkBlockedFolder,

packages/core/src/path-security.test.ts

@@ -7,6 +7,7 @@ import {
   checkSymlink,
   isAllowedPath,
   validatePath,
+  validatePathForWrite,
 } from "./path-security.js";
 import { mockFsFunction } from "./test-helpers.js";
 
@@ -320,3 +321,91 @@ describe("validatePath", () => {
     }
   });
 });
+
+describe("validatePathForWrite", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns validated path when file exists", async () => {
+    realpathMock.mockResolvedValue("/vault/notes/foo.md");
+    const result = await validatePathForWrite("notes/foo.md", EMPTY_OPTS);
+    expect(result).toEqual({ ok: true, value: "/vault/notes/foo.md" });
+  });
+
+  it("succeeds for non-existent file in existing directory", async () => {
+    const enoent = new Error("ENOENT") as NodeJS.ErrnoException;
+    enoent.code = "ENOENT";
+    realpathMock
+      .mockRejectedValueOnce(enoent) // /vault/notes/new.md does not exist
+      .mockResolvedValueOnce("/vault/notes"); // /vault/notes exists
+    const result = await validatePathForWrite("notes/new.md", EMPTY_OPTS);
+    expect(result).toEqual({ ok: true, value: "/vault/notes/new.md" });
+  });
+
+  it("succeeds for non-existent nested directories", async () => {
+    const enoent = new Error("ENOENT") as NodeJS.ErrnoException;
+    enoent.code = "ENOENT";
+    realpathMock
+      .mockRejectedValueOnce(enoent) // /vault/a/b/c.md
+      .mockRejectedValueOnce(enoent) // /vault/a/b
+      .mockRejectedValueOnce(enoent) // /vault/a
+      .mockResolvedValueOnce("/vault"); // /vault exists
+    const result = await validatePathForWrite("a/b/c.md", EMPTY_OPTS);
+    expect(result).toEqual({ ok: true, value: "/vault/a/b/c.md" });
+  });
+
+  it("fails on symlink escape in ancestor", async () => {
+    const enoent = new Error("ENOENT") as NodeJS.ErrnoException;
+    enoent.code = "ENOENT";
+    realpathMock
+      .mockRejectedValueOnce(enoent) // /vault/link/new.md
+      .mockResolvedValueOnce("/outside"); // /vault/link resolves outside
+    const result = await validatePathForWrite("link/new.md", EMPTY_OPTS);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe("PERMISSION_DENIED");
+    }
+  });
+
+  it("fails on path traversal", async () => {
+    const result = await validatePathForWrite("../../etc/passwd", EMPTY_OPTS);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe("PERMISSION_DENIED");
+    }
+    expect(realpathMock).not.toHaveBeenCalled();
+  });
+
+  it("fails on blocked folder", async () => {
+    const result = await validatePathForWrite("private/new.md", {
+      ...EMPTY_OPTS,
+      blocked: ["private"],
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe("PERMISSION_DENIED");
+    }
+    expect(realpathMock).not.toHaveBeenCalled();
+  });
+
+  it("fails on allowed folder violation", async () => {
+    const result = await validatePathForWrite("other/new.md", {
+      ...EMPTY_OPTS,
+      allowed: ["notes"],
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe("PERMISSION_DENIED");
+    }
+    expect(realpathMock).not.toHaveBeenCalled();
+  });
+
+  it("returns canonicalized path, not realpath of ancestor", async () => {
+    const enoent = new Error("ENOENT") as NodeJS.ErrnoException;
+    enoent.code = "ENOENT";
+    realpathMock.mockRejectedValueOnce(enoent).mockResolvedValueOnce("/vault/notes");
+    const result = await validatePathForWrite("notes/new.md", EMPTY_OPTS);
+    expect(result).toEqual({ ok: true, value: "/vault/notes/new.md" });
+  });
+});

packages/core/src/path-security.ts

@@ -135,3 +135,29 @@ export async function validatePath(
 
   return checkSymlink(canonical.value, options.vaultRoot);
 }
+
+/**
+ * Like `validatePath` but for write operations where the target may not exist.
+ * Walks up to the nearest existing ancestor for the symlink check instead of
+ * requiring the full path to exist. Returns the canonicalized absolute path.
+ */
+export async function validatePathForWrite(
+  virtualPath: string,
+  options: PathSecurityOptions,
+): Promise<VFSResult<string>> {
+  const canonical = canonicalizePath(virtualPath, options.vaultRoot);
+  if (!canonical.ok) return canonical;
+
+  const allowed = checkAllowedFolder(canonical.value, options);
+  if (!allowed.ok) return allowed;
+
+  let ancestor = canonical.value;
+  for (;;) {
+    const result = await checkSymlink(ancestor, options.vaultRoot);
+    if (result.ok) return { ok: true, value: canonical.value };
+    if (result.error.code !== "FILE_NOT_FOUND") return result;
+    const parent = path.dirname(ancestor);
+    if (parent === ancestor) return result;
+    ancestor = parent;
+  }
+}

packages/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "obsidian-vfs",
   "displayName": "Obsidian VFS",
   "description": "Browse, search, and edit your Obsidian vault directly in VSCode via a virtual file system (obs://)",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "private": true,
   "publisher": "otaviof",
   "engines": {

packages/vscode/src/extension.test.ts

@@ -46,6 +46,10 @@ vi.mock("./vault-tree-provider.js", () => ({
   }),
 }));
 
+vi.mock("./tree-drag-drop.js", () => ({
+  VaultTreeDragAndDropController: vi.fn(),
+}));
+
 vi.mock("./status-bar.js", () => ({
   StatusBarManager: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
     this.show = vi.fn();
@@ -81,6 +85,7 @@ import { FOLDER_NAME_PREFIX } from "./workspace-folder.js";
 import { ObsidianFileSystemProvider } from "./file-system-provider.js";
 import { StatusBarManager } from "./status-bar.js";
 import { VaultTreeDataProvider } from "./vault-tree-provider.js";
+import { VaultTreeDragAndDropController } from "./tree-drag-drop.js";
 import { WikilinkDocumentLinkProvider } from "./wikilink-provider.js";
 import {
   addVaultWorkspaceFolder,
@@ -161,7 +166,11 @@ describe("activate", () => {
       { isCaseSensitive: true, isReadonly: false },
     );
     expect(VaultTreeDataProvider).toHaveBeenCalledWith(fakeTracker);
-    expect(vscode.window.createTreeView).toHaveBeenCalledWith("obsidianVFS", expect.anything());
+    expect(VaultTreeDragAndDropController).toHaveBeenCalledWith("MyVault");
+    expect(vscode.window.createTreeView).toHaveBeenCalledWith(
+      "obsidianVFS",
+      expect.objectContaining({ dragAndDropController: expect.anything() }),
+    );
     const treeView = vi.mocked(vscode.window.createTreeView).mock.results[0].value as {
       title: string;
     };

packages/vscode/src/extension.ts

@@ -5,6 +5,7 @@ import { SCHEME } from "./uri-adapter.js";
 import { registerCommands } from "./commands.js";
 import { ObsidianFileSystemProvider } from "./file-system-provider.js";
 import { StatusBarManager } from "./status-bar.js";
+import { VaultTreeDragAndDropController } from "./tree-drag-drop.js";
 import { VaultTreeDataProvider } from "./vault-tree-provider.js";
 import { WikilinkDocumentLinkProvider } from "./wikilink-provider.js";
 import {
@@ -50,7 +51,11 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
 
   const treeProvider = new VaultTreeDataProvider(tracker);
   context.subscriptions.push(treeProvider);
-  const treeView = vscode.window.createTreeView("obsidianVFS", { treeDataProvider: treeProvider });
+  const dragAndDropController = new VaultTreeDragAndDropController(tracker.context.name);
+  const treeView = vscode.window.createTreeView("obsidianVFS", {
+    treeDataProvider: treeProvider,
+    dragAndDropController,
+  });
   const cfg = vscode.workspace.getConfiguration("obsidianVFS");
   treeView.title =
     cfg.get<string>("treeViewTitle", "") || `${FOLDER_NAME_PREFIX}${tracker.context.name}`;