@hienlh/ppm 0.17.57 → 0.18.1

package/src/web/components/os-explorer/actions/explorer-actions-clipboard.ts

@@ -0,0 +1,186 @@
+/**
+ * Cut / copy / paste against the real filesystem, plus the collision prompt.
+ *
+ * The clipboard itself lives in `file-store` and holds absolute paths, so a cut in the
+ * project tree can be pasted into an explorer window and the other way round. Everything
+ * here goes through `/api/fs/*`; the tree keeps its project-scoped routes for the case
+ * where both ends are inside the same project.
+ */
+
+import { toast } from "sonner";
+import { fsApi, FsError } from "@/lib/fs-api";
+import { useFileStore, type ClipboardState } from "@/stores/file-store";
+import { dirnameOf, errorDescription, joinPath } from "../format-file-meta";
+import { fsChanged } from "../explorer-store";
+import { freeName, runOne } from "./explorer-actions-transfer-helpers";
+
+export type CollisionChoice = "replace" | "keep-both" | "skip";
+
+export interface CollisionRequest {
+  name: string;
+  destination: string;
+}
+
+/** Asks the user what to do about an existing file. Returning "skip" is always safe. */
+export type CollisionResolver = (request: CollisionRequest) => Promise<CollisionChoice>;
+
+export interface TransferContext {
+  sep: string;
+  resolve: CollisionResolver;
+  /**
+   * Asked only when "Replace" cannot trash the existing entry (`NO_TRASH`) — the dialog copy
+   * promises a recoverable trash-first replace, so silently falling back to a permanent
+   * delete would contradict what the user just agreed to. Returning false skips the item.
+   */
+  confirmPermanentOverwrite(name: string): Promise<boolean>;
+}
+
+export interface TransferResult {
+  succeeded: number;
+  skipped: number;
+  failed: number;
+}
+
+/**
+ * Copy or move `sources` into `dstDir`.
+ *
+ * Exported on its own (not just through the clipboard) because drag-and-drop performs the
+ * exact same operation with a different trigger.
+ */
+export async function transfer(
+  sources: string[],
+  dstDir: string,
+  op: "copy" | "move",
+  ctx: TransferContext,
+): Promise<TransferResult> {
+  const result: TransferResult = { succeeded: 0, skipped: 0, failed: 0 };
+  const touched = new Set<string>([dstDir]);
+
+  for (const source of sources) {
+    const name = source.split(/[/\\]/).filter(Boolean).pop() ?? source;
+    const sourceDir = dirnameOf(source, ctx.sep);
+    touched.add(sourceDir);
+    // Moving an entry into the folder it already lives in is a no-op, not an error.
+    if (op === "move" && sourceDir === dstDir) {
+      result.skipped++;
+      continue;
+    }
+
+    let destination = joinPath(dstDir, name, ctx.sep);
+    // A copy into the same folder always collides with itself (destination === source),
+    // which the server refuses as self-nesting (EINVAL), not EEXIST — so the collision
+    // prompt would never open. Every OS instead makes this "name (2)" directly.
+    if (op === "copy" && sourceDir === dstDir) {
+      const alternative = await freeName(dstDir, name, ctx.sep);
+      if (!alternative) {
+        result.failed++;
+        toast.error(`Copy failed: ${name}`, { description: "No free name available" });
+        continue;
+      }
+      destination = joinPath(dstDir, alternative, ctx.sep);
+      try {
+        await runOne(source, destination, op);
+        result.succeeded++;
+      } catch (e) {
+        result.failed++;
+        toast.error(`Copy failed: ${name}`, { description: errorDescription(e) });
+      }
+      continue;
+    }
+
+    try {
+      await runOne(source, destination, op);
+      result.succeeded++;
+      continue;
+    } catch (e) {
+      if (!(e instanceof FsError) || e.code !== "EEXIST") {
+        result.failed++;
+        toast.error(`${op === "copy" ? "Copy" : "Move"} failed: ${name}`, { description: errorDescription(e) });
+        continue;
+      }
+    }
+
+    const choice = await ctx.resolve({ name, destination });
+    if (choice === "skip") {
+      result.skipped++;
+      continue;
+    }
+    if (choice === "keep-both") {
+      try {
+        const alternative = await freeName(dstDir, name, ctx.sep);
+        if (!alternative) throw new Error("No free name available");
+        destination = joinPath(dstDir, alternative, ctx.sep);
+        await runOne(source, destination, op);
+        result.succeeded++;
+      } catch (e) {
+        result.failed++;
+        toast.error(`${op === "copy" ? "Copy" : "Move"} failed: ${name}`, { description: errorDescription(e) });
+      }
+      continue;
+    }
+
+    // Replace: trash the existing entry first so the overwrite stays recoverable, matching
+    // the collision dialog's own copy.
+    try {
+      await fsApi.remove(destination, false);
+    } catch (e) {
+      if (!(e instanceof FsError) || e.code !== "NO_TRASH") {
+        result.failed++;
+        toast.error(`Could not remove existing ${name}`, { description: errorDescription(e) });
+        continue;
+      }
+      // No trash backend on this host — the dialog's "moves to Trash" promise cannot be
+      // kept, so ask explicitly before doing something permanent instead of silently
+      // downgrading to it.
+      const proceed = await ctx.confirmPermanentOverwrite(name);
+      if (!proceed) {
+        result.skipped++;
+        continue;
+      }
+      try {
+        await fsApi.remove(destination, true);
+      } catch (removeErr) {
+        result.failed++;
+        toast.error(`Could not remove existing ${name}`, { description: errorDescription(removeErr) });
+        continue;
+      }
+    }
+    try {
+      await runOne(source, destination, op);
+      result.succeeded++;
+    } catch (e) {
+      result.failed++;
+      // The existing entry is already gone (trashed or deleted above) but the replacement
+      // was never written — say so explicitly rather than a generic "Copy/Move failed".
+      toast.error(`${name} was removed but the replacement could not be written`, { description: errorDescription(e) });
+    }
+  }
+
+  fsChanged(...touched);
+  return result;
+}
+
+/** Put absolute paths on the shared clipboard. `origin` lets the tree keep its own routes. */
+export function setClipboardPaths(
+  paths: string[],
+  operation: "cut" | "copy",
+  origin?: ClipboardState["origin"],
+): void {
+  if (paths.length === 0) return;
+  useFileStore.getState().setClipboard({ paths: [...paths], operation, origin });
+}
+
+/** Paste the shared clipboard into `dstDir`. A cut clipboard is consumed on success. */
+export async function pasteInto(dstDir: string, ctx: TransferContext): Promise<void> {
+  const clipboard = useFileStore.getState().clipboard;
+  if (!clipboard || clipboard.paths.length === 0) return;
+
+  const result = await transfer(clipboard.paths, dstDir, clipboard.operation === "cut" ? "move" : "copy", ctx);
+  if (clipboard.operation === "cut" && result.failed === 0) {
+    useFileStore.getState().setClipboard(null);
+  }
+  if (result.succeeded > 0) {
+    const verb = clipboard.operation === "cut" ? "Moved" : "Copied";
+    toast.success(`${verb} ${result.succeeded} item${result.succeeded === 1 ? "" : "s"}`);
+  }
+}

package/src/web/components/os-explorer/actions/explorer-actions-mutate.ts

@@ -0,0 +1,109 @@
+/**
+ * Disk mutations: new file / new folder, rename, and the two delete flavours.
+ *
+ * Deleting goes to the OS trash by default. When the host has no trash backend the server
+ * answers `NO_TRASH` and the caller is told to offer a permanent delete instead of failing
+ * with a message the user cannot act on.
+ */
+
+import { toast } from "sonner";
+import { fsApi, FsError } from "@/lib/fs-api";
+import { dirnameOf, errorDescription, joinPath } from "../format-file-meta";
+import { fsChanged } from "../explorer-store";
+
+/** Characters Windows refuses in a file name. */
+const WINDOWS_ILLEGAL = /[<>:"|?*]/;
+/** Control characters are illegal in a name on every platform. */
+const CONTROL_CHARS = /[\u0000-\u001f]/;
+/** Device names Windows reserves, with or without an extension. */
+const WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i;
+
+/**
+ * Validate a bare entry name. Returns an error message, or null when the name is usable.
+ * The server enforces the same rules; checking here keeps the inline input responsive.
+ */
+export function validateEntryName(name: string, platform: string | undefined): string | null {
+  if (!name) return "Name cannot be empty";
+  if (name === "." || name === "..") return "Reserved name";
+  if (name.includes("/") || name.includes("\\")) return "Name cannot contain path separators";
+  if (CONTROL_CHARS.test(name)) return "Invalid character in name";
+  if (platform === "win32") {
+    if (WINDOWS_ILLEGAL.test(name)) return 'Cannot contain < > : " | ? *';
+    if (WINDOWS_RESERVED.test(name)) return `"${name}" is a reserved Windows name`;
+    // Windows silently strips these, so the created entry would not be the one asked for.
+    if (name.endsWith(".") || name.endsWith(" ")) return "Cannot end with a dot or space";
+  }
+  return null;
+}
+
+export async function createEntry(
+  dir: string,
+  name: string,
+  kind: "file" | "folder",
+  sep: string,
+): Promise<boolean> {
+  const path = joinPath(dir, name, sep);
+  try {
+    // `gitInit: false` — an explorer folder is a folder, not a new repository.
+    if (kind === "folder") await fsApi.mkdir(path, false);
+    else await fsApi.touch(path);
+    fsChanged(dir);
+    return true;
+  } catch (e) {
+    toast.error(kind === "folder" ? "Could not create folder" : "Could not create file", {
+      description: errorDescription(e),
+    });
+    return false;
+  }
+}
+
+export async function renameEntry(path: string, newName: string, sep: string): Promise<boolean> {
+  try {
+    await fsApi.rename(path, newName);
+    fsChanged(dirnameOf(path, sep));
+    return true;
+  } catch (e) {
+    toast.error("Rename failed", { description: errorDescription(e) });
+    return false;
+  }
+}
+
+export interface DeleteOutcome {
+  removed: number;
+  /** Paths the host could not trash — the caller offers a permanent delete for these. */
+  needsPermanent: string[];
+}
+
+/**
+ * Delete `paths`. With `permanent` false this moves them to the OS trash and any path the
+ * host cannot trash is reported back rather than removed behind the user's back.
+ */
+export async function deleteEntries(
+  paths: string[],
+  permanent: boolean,
+  sep: string,
+): Promise<DeleteOutcome> {
+  const outcome: DeleteOutcome = { removed: 0, needsPermanent: [] };
+  const touched = new Set<string>();
+
+  for (const path of paths) {
+    touched.add(dirnameOf(path, sep));
+    try {
+      await fsApi.remove(path, permanent);
+      outcome.removed++;
+    } catch (e) {
+      if (e instanceof FsError && e.code === "NO_TRASH") {
+        outcome.needsPermanent.push(path);
+        continue;
+      }
+      toast.error("Delete failed", { description: errorDescription(e) });
+    }
+  }
+
+  fsChanged(...touched);
+  if (outcome.removed > 0) {
+    const noun = `${outcome.removed} item${outcome.removed === 1 ? "" : "s"}`;
+    toast.success(permanent ? `Deleted ${noun}` : `Moved ${noun} to Trash`);
+  }
+  return outcome;
+}

package/src/web/components/os-explorer/actions/explorer-actions-open.ts

@@ -0,0 +1,67 @@
+/**
+ * Opening entries and the read-only menu commands: open in a PPM tab, open a folder in a
+ * second explorer window, download, copy path / name.
+ */
+
+import { toast } from "sonner";
+import type { FsEntry } from "@/lib/fs-api";
+import { fsApi } from "@/lib/fs-api";
+import { copyToClipboard } from "@/lib/clipboard";
+import { triggerDownload } from "@/lib/file-download";
+import { useTabStore } from "@/stores/tab-store";
+import { useWindowStore } from "@/components/floating-window/window-store";
+import { canOpenInPpm, viewerKindOf } from "../can-open-in-ppm";
+
+/**
+ * Open a file in the tab that can display it.
+ *
+ * `projectName` is deliberately absent: these are absolute host paths, and the viewers
+ * branch on that to reach `/api/fs/*` instead of the project-scoped routes.
+ */
+export function openEntryInPpm(entry: FsEntry): boolean {
+  if (!canOpenInPpm(entry.name)) return false;
+  useTabStore.getState().openTab({
+    type: viewerKindOf(entry.name) === "sqlite" ? "sqlite" : "editor",
+    title: entry.name,
+    projectId: null,
+    metadata: { filePath: entry.path },
+    closable: true,
+  });
+  return true;
+}
+
+/** Spawn another explorer window rooted at `path`. */
+export function openPathInNewWindow(path: string): string {
+  return useWindowStore.getState().open("explorer", { path });
+}
+
+/**
+ * Download files one at a time. Each download needs its own single-use token, and
+ * directories have no zip route outside a project, so folders are reported rather than
+ * silently skipped.
+ */
+export async function downloadEntries(entries: FsEntry[]): Promise<void> {
+  const files = entries.filter((e) => e.type === "file");
+  const skipped = entries.length - files.length;
+  if (skipped > 0) {
+    toast.warning(skipped === 1 ? "Folders cannot be downloaded" : `${skipped} folders skipped`);
+  }
+  for (const file of files) {
+    try {
+      triggerDownload(await fsApi.downloadUrl(file.path), file.name);
+    } catch (e) {
+      toast.error(`Download failed: ${file.name}`, {
+        description: e instanceof Error ? e.message : undefined,
+      });
+    }
+  }
+}
+
+/** Copy plain text to the system clipboard, one value per line, and confirm it. */
+export async function copyTextLines(values: string[], noun: "Path" | "Name"): Promise<void> {
+  if (values.length === 0) return;
+  await copyToClipboard(values.join("\n"));
+  toast.success(
+    values.length === 1 ? `${noun} copied` : `${values.length} ${noun.toLowerCase()}s copied`,
+  );
+}

package/src/web/components/os-explorer/actions/explorer-actions-transfer-helpers.ts

@@ -0,0 +1,35 @@
+/**
+ * Pure helpers shared by `transfer()`: finding a free "name (n)" for Keep-both/same-folder
+ * copy, running one copy/move call, and turning a failure into a toast description. Split
+ * out of `explorer-actions-clipboard.ts` to keep that file under the line cap.
+ */
+
+import { fsApi, FsError } from "@/lib/fs-api";
+import { joinPath, suffixName } from "../format-file-meta";
+
+/** Highest "name (n)" suffix tried before giving up on a free name. */
+const MAX_KEEP_BOTH_ATTEMPTS = 99;
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await fsApi.stat(path);
+    return true;
+  } catch (e) {
+    if (e instanceof FsError && e.code === "ENOENT") return false;
+    // Anything else (permission, protected root) is not a free name either.
+    return true;
+  }
+}
+
+export async function freeName(dir: string, name: string, sep: string): Promise<string | null> {
+  for (let n = 2; n <= MAX_KEEP_BOTH_ATTEMPTS; n++) {
+    const candidate = suffixName(name, n);
+    if (!(await pathExists(joinPath(dir, candidate, sep)))) return candidate;
+  }
+  return null;
+}
+
+export async function runOne(source: string, destination: string, op: "copy" | "move"): Promise<void> {
+  if (op === "copy") await fsApi.copy(source, destination);
+  else await fsApi.move(source, destination);
+}

package/src/web/components/os-explorer/actions/use-explorer-actions.ts

@@ -0,0 +1,205 @@
+/**
+ * Binds the action modules to one window's slice and owns the state of the three
+ * interruptions they need: the collision prompt, the permanent-delete confirmation and
+ * the properties dialog.
+ *
+ * Prompts are modelled as promises resolved by the dialog, so the action modules stay
+ * plain async functions with no React inside them.
+ */
+
+import { useCallback, useMemo, useRef, useState } from "react";
+import { toast } from "sonner";
+import type { FsEntry } from "@/lib/fs-api";
+import { useExplorerPinsStore } from "../explorer-pins-store";
+import { useExplorerStore, type ExplorerSlice } from "../explorer-store";
+import type { ExplorerNavigation } from "../use-explorer-navigation";
+import { copyTextLines, downloadEntries, openEntryInPpm, openPathInNewWindow } from "./explorer-actions-open";
+import {
+  pasteInto, setClipboardPaths, transfer,
+  type CollisionChoice, type CollisionRequest,
+} from "./explorer-actions-clipboard";
+import { createEntry, deleteEntries, renameEntry, validateEntryName } from "./explorer-actions-mutate";
+
+export interface ExplorerActions {
+  openEntry(entry: FsEntry): void;
+  openInNewWindow(entry: FsEntry): void;
+  cut(entries: FsEntry[]): void;
+  copy(entries: FsEntry[]): void;
+  paste(targetDir?: string): void;
+  startRename(entry: FsEntry): void;
+  startCreate(kind: "new-file" | "new-folder"): void;
+  commitInline(value: string): Promise<void>;
+  cancelInline(): void;
+  trash(entries: FsEntry[]): void;
+  confirmPermanentDelete(entries: FsEntry[]): void;
+  download(entries: FsEntry[]): void;
+  copyPath(paths: string[]): void;
+  copyName(names: string[]): void;
+  togglePin(path: string, name: string): void;
+  showProperties(entry: FsEntry): void;
+  /** Move or copy arbitrary paths into a directory — also the drag-and-drop entry point. */
+  transferInto(paths: string[], dstDir: string, op: "copy" | "move"): Promise<void>;
+}
+
+export interface ExplorerDialogState {
+  collision: (CollisionRequest & { resolve(choice: CollisionChoice): void }) | null;
+  pendingDelete: { paths: string[]; names: string[] } | null;
+  /** "Replace" hit a host with no trash backend — confirm a permanent overwrite instead. */
+  permanentOverwrite: { name: string; resolve(proceed: boolean): void } | null;
+  properties: FsEntry | null;
+  inlineError: string | null;
+  closeDelete(): void;
+  runPermanentDelete(): void;
+  closeProperties(): void;
+}
+
+export function useExplorerActions(
+  windowId: string,
+  slice: ExplorerSlice | undefined,
+  nav: ExplorerNavigation,
+  platform: string | undefined,
+): { actions: ExplorerActions; dialogs: ExplorerDialogState } {
+  const patch = useExplorerStore((s) => s.patch);
+  const [collision, setCollision] = useState<ExplorerDialogState["collision"]>(null);
+  const [pendingDelete, setPendingDelete] = useState<ExplorerDialogState["pendingDelete"]>(null);
+  const [permanentOverwrite, setPermanentOverwrite] = useState<ExplorerDialogState["permanentOverwrite"]>(null);
+  const [properties, setProperties] = useState<FsEntry | null>(null);
+  const [inlineError, setInlineError] = useState<string | null>(null);
+
+  const sliceRef = useRef(slice);
+  sliceRef.current = slice;
+
+  const context = useMemo(
+    () => ({
+      get sep() {
+        return sliceRef.current?.sep ?? "/";
+      },
+      resolve: (request: CollisionRequest) =>
+        new Promise<CollisionChoice>((resolve) => {
+          setCollision({
+            ...request,
+            resolve: (choice) => {
+              setCollision(null);
+              resolve(choice);
+            },
+          });
+        }),
+      confirmPermanentOverwrite: (name: string) =>
+        new Promise<boolean>((resolve) => {
+          setPermanentOverwrite({
+            name,
+            resolve: (proceed) => {
+              setPermanentOverwrite(null);
+              resolve(proceed);
+            },
+          });
+        }),
+    }),
+    [],
+  );
+
+  const currentDir = () => sliceRef.current?.path ?? "";
+
+  const actions = useMemo<ExplorerActions>(() => ({
+    openEntry: (entry) => {
+      if (entry.type === "directory") nav.go(entry.path);
+      else openEntryInPpm(entry);
+    },
+    openInNewWindow: (entry) => {
+      openPathInNewWindow(entry.type === "directory" ? entry.path : (sliceRef.current?.path ?? entry.path));
+    },
+    cut: (entries) => setClipboardPaths(entries.map((e) => e.path), "cut"),
+    copy: (entries) => setClipboardPaths(entries.map((e) => e.path), "copy"),
+    paste: (targetDir) => void pasteInto(targetDir ?? currentDir(), context),
+    transferInto: async (paths, dstDir, op) => {
+      // Paste toasts its own result; a drag-move/copy silently completing otherwise gives no
+      // feedback at all for a long multi-file drag.
+      const result = await transfer(paths, dstDir, op, context);
+      if (result.succeeded > 0) {
+        const verb = op === "copy" ? "Copied" : "Moved";
+        toast.success(`${verb} ${result.succeeded} item${result.succeeded === 1 ? "" : "s"}`);
+      }
+    },
+
+    startRename: (entry) => {
+      setInlineError(null);
+      patch(windowId, { inlineEdit: { kind: "rename", path: entry.path, initial: entry.name } });
+    },
+    startCreate: (kind) => {
+      setInlineError(null);
+      patch(windowId, { inlineEdit: { kind, initial: "" } });
+    },
+    cancelInline: () => {
+      setInlineError(null);
+      patch(windowId, { inlineEdit: null });
+    },
+    commitInline: async (value) => {
+      const current = sliceRef.current;
+      const edit = current?.inlineEdit;
+      if (!current || !edit) return;
+      const name = value.trim();
+      if (edit.kind === "rename" && name === edit.initial) {
+        patch(windowId, { inlineEdit: null });
+        return;
+      }
+      const problem = validateEntryName(name, platform);
+      if (problem) {
+        setInlineError(problem);
+        return;
+      }
+      setInlineError(null);
+      const done = edit.kind === "rename"
+        ? await renameEntry(edit.path, name, current.sep)
+        : await createEntry(current.path, name, edit.kind === "new-folder" ? "folder" : "file", current.sep);
+      if (done) patch(windowId, { inlineEdit: null });
+    },
+
+    trash: (entries) => {
+      void deleteEntries(entries.map((e) => e.path), false, sliceRef.current?.sep ?? "/").then((outcome) => {
+        // The host has no trash backend for these paths; permanent deletion is the only
+        // remaining option, so offer it instead of leaving the entries in place silently.
+        if (outcome.needsPermanent.length > 0) {
+          setPendingDelete({
+            paths: outcome.needsPermanent,
+            names: outcome.needsPermanent.map((p) => p.split(/[/\\]/).pop() ?? p),
+          });
+        }
+      });
+    },
+    confirmPermanentDelete: (entries) => {
+      if (entries.length === 0) return;
+      setPendingDelete({ paths: entries.map((e) => e.path), names: entries.map((e) => e.name) });
+    },
+
+    download: (entries) => void downloadEntries(entries),
+    copyPath: (paths) => void copyTextLines(paths, "Path"),
+    copyName: (names) => void copyTextLines(names, "Name"),
+    togglePin: (path, name) => {
+      const pins = useExplorerPinsStore.getState();
+      if (pins.isPinned(path)) pins.unpin(path);
+      else pins.pin({ path, name });
+    },
+    showProperties: (entry) => setProperties(entry),
+  }), [windowId, patch, nav, context, platform]);
+
+  const runPermanentDelete = useCallback(() => {
+    const target = pendingDelete;
+    setPendingDelete(null);
+    if (!target) return;
+    void deleteEntries(target.paths, true, sliceRef.current?.sep ?? "/");
+  }, [pendingDelete]);
+
+  return {
+    actions,
+    dialogs: {
+      collision,
+      pendingDelete,
+      permanentOverwrite,
+      properties,
+      inlineError,
+      closeDelete: () => setPendingDelete(null),
+      runPermanentDelete,
+      closeProperties: () => setProperties(null),
+    },
+  };
+}