dsh-plugin-workbench 0.0.6 → 0.0.8

package/lib/index.js

@@ -105,6 +105,38 @@ function mapError(error) {
 function isFsErrorCode(error, code) {
 	return error instanceof Error && error.code === code;
 }
+/**
+* EPERM / EBUSY from a move or remove almost always means the path — or, on
+* Windows, a file INSIDE a directory being moved/deleted — is open elsewhere
+* (an editor, Explorer, a terminal sitting inside it, an antivirus scan).
+* EACCES is left alone: that usually means read-only/ACL, not a lock.
+*/
+function isInUseError(error) {
+	if (!(error instanceof Error)) return false;
+	const code = error.code;
+	return code === "EPERM" || code === "EBUSY";
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Retry a mutation a bounded number of times while it fails with a transient
+* Windows lock (indexer/antivirus handles usually clear within milliseconds).
+* Genuine "permission denied" / "in use" errors surface after the retries.
+*/
+async function withLockRetry(op, attempts = 3, gapMs = 150) {
+	for (let attempt = 1;; attempt += 1) try {
+		await op();
+		return;
+	} catch (error) {
+		if (!isInUseError(error) || attempt >= attempts) throw error;
+		await sleep(gapMs * attempt);
+	}
+}
+/** Actionable replacement for a bare "permission denied" when a folder is locked. */
+function lockMessage(path) {
+	return `"${basename(path)}" is in use by another program — close any editor/Explorer view of it (or a terminal inside it) and retry`;
+}
 function fail(message) {
 	return {
 		ok: false,
@@ -490,12 +522,13 @@ async function renameEntry(ctx, payload, signal) {
 		const toTarget = await ctx.fs.resolve(to, { signal });
 		const toOsPath = ctx.fs.processPath(toTarget);
 		if (await ctx.fs.stat(toTarget, signal) !== void 0) return fail("rename: destination already exists");
-		await rename(osPath, toOsPath);
+		await withLockRetry(() => rename(osPath, toOsPath));
 		return {
 			ok: true,
 			value: { path: toOsPath }
 		};
 	} catch (error) {
+		if (isInUseError(error)) return fail(lockMessage(path));
 		return fail(mapError(error));
 	}
 }
@@ -507,15 +540,16 @@ async function deleteEntry(ctx, payload, signal) {
 		const osPath = ctx.fs.processPath(target);
 		const info = await ctx.fs.stat(target, signal);
 		if (info === void 0) return fail(`path not found: ${path}`);
-		await rm(osPath, {
+		await withLockRetry(() => rm(osPath, {
 			recursive: info.type === "directory",
 			force: true
-		});
+		}));
 		return {
 			ok: true,
 			value: { path: osPath }
 		};
 	} catch (error) {
+		if (isInUseError(error)) return fail(lockMessage(path));
 		return fail(mapError(error));
 	}
 }
@@ -525,13 +559,14 @@ async function copyEntry(ctx, payload, signal) {
 	const overwrite = typeof payload === "object" && payload !== null && payload.overwrite === true;
 	if (typeof from !== "string" || from.trim().length === 0) return fail("copy: payload.from must be a non-empty string");
 	if (typeof to !== "string" || to.trim().length === 0) return fail("copy: payload.to must be a non-empty string");
+	let toOs = "";
 	try {
 		const fromTarget = await ctx.fs.resolve(from, { signal });
 		const fromOs = ctx.fs.processPath(fromTarget);
 		const info = await ctx.fs.stat(fromTarget, signal);
 		if (info === void 0) return fail(`path not found: ${from}`);
 		const toTarget = await ctx.fs.resolve(to, { signal });
-		const toOs = ctx.fs.processPath(toTarget);
+		toOs = ctx.fs.processPath(toTarget);
 		if (fromOs.toLowerCase() === toOs.toLowerCase()) return fail("copy: source and destination are the same path");
 		if (info.type === "directory") {
 			const sep = fromOs.includes("\\") ? "\\" : "/";
@@ -549,13 +584,13 @@ async function copyEntry(ctx, payload, signal) {
 		};
 	} catch (error) {
 		if (isFsErrorCode(error, "ERR_FS_CP_EEXIST")) return {
-			ok: false,
-			error: {
-				code: "exists",
-				message: "destination already exists",
-				details: {}
+			ok: true,
+			value: {
+				path: toOs,
+				exists: true
 			}
 		};
+		if (isInUseError(error)) return fail(lockMessage(from));
 		return fail(mapError(error));
 	}
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-plugin-workbench",
   "description": "VS Code-style workspace file explorer + editable preview for the dsh web GUI",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "packageManager": "pnpm@11.21.0",
   "engines": {
@@ -68,6 +68,7 @@
     "cordis.patch.yml",
     "src",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "LICENSE"
   ]
 }

package/scripts/selfcheck.mjs

@@ -0,0 +1,30 @@
+// 最小自检：发布前验证结构完整（离线、零依赖）。node scripts/selfcheck.mjs
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const failures = [];
+
+const pkgPath = join(root, "package.json");
+if (!existsSync(pkgPath)) failures.push("缺 package.json");
+else {
+  let pkg;
+  try { pkg = JSON.parse(readFileSync(pkgPath, "utf8")); }
+  catch { failures.push("package.json 解析失败"); pkg = {}; }
+  if (pkg.name && pkg.main && !existsSync(join(root, pkg.main)))
+    failures.push(`入口不存在: ${pkg.main}`);
+  if (pkg.dsh?.bundle?.patch && !existsSync(join(root, pkg.dsh.bundle.patch)))
+    failures.push(`bundle patch 不存在: ${pkg.dsh.bundle.patch}`);
+}
+
+for (const f of ["README.md", "LICENSE"]) {
+  if (!existsSync(join(root, f))) failures.push(`缺 ${f}`);
+}
+
+if (failures.length) {
+  for (const f of failures) console.error(`[FAIL] ${f}`);
+  console.error(`${failures.length} 项失败`);
+  process.exit(1);
+}
+console.log("[PASS] 结构完整，可发布");

package/src/client/FileExplorer.tsx

@@ -34,6 +34,8 @@ export interface FsReadResult {
 /** Result of a context-menu mutation (create/rename/delete). */
 export interface FsMutationResult {
   path: string
+  /** Copy-only: `true` when the destination existed and the copy was skipped (client may ask about overwrite). */
+  exists?: boolean
 }
 
 interface SessionSummary {
@@ -588,10 +590,9 @@ export function FileExplorer({
       if (sameDest) dest = joinPath(targetDir, copyName(item.name))
       let overwritten = false
       try {
-        try {
-          await copyPath(item.path, dest, false)
-        } catch (error) {
-          if ((error as { code?: string }).code !== 'exists') throw error
+        const copied = await copyPath(item.path, dest, false)
+        if (copied.exists === true) {
+          // Collision: ask before overwriting, like the OS file manager.
           if (!window.confirm(t('confirm.overwrite', { name: item.name }))) continue
           overwritten = true
           await copyPath(item.path, dest, true)
@@ -901,6 +902,17 @@ export function FileExplorer({
   const onTreeKeyDown = useCallback((e: ReactKeyboardEvent) => {
     const mod = e.ctrlKey || e.metaKey
     const key = e.key.toLowerCase()
+    // Never hijack Ctrl/Cmd+C/X while the user is copying an actual text
+    // selection (e.g. an inline error message rendered inside the tree): the
+    // browser must get the key so the selected text is copied instead of the
+    // selected files. Also let editable elements (if any ever live in the
+    // tree) keep their native copy/cut behavior.
+    if (mod && (key === 'c' || key === 'x')) {
+      const target = e.target as HTMLElement | null
+      if (target !== null && (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable)) return
+      const selection = window.getSelection()
+      if (selection !== null && !selection.isCollapsed && selection.toString().length > 0) return
+    }
     if (mod && key === 'c') {
       const items = selectedItems()
       if (items.length === 0) return

package/src/client/index.ts

@@ -52,7 +52,7 @@ interface RpcFailure {
   error: { code: string; message: string }
 }
 
-/** Error carrying the host's machine-readable `code` (e.g. 'exists' on copy collision). */
+/** Error carrying the host's machine-readable `code` (always a core union code; copy collisions are reported in the value instead). */
 export interface RpcError extends Error {
   code?: string
 }

package/src/index.ts

@@ -114,6 +114,13 @@ export interface FsWriteResult {
 /** Result of a context-menu mutation (create/rename/delete). */
 export interface FsMutationResult {
   path: string
+  /**
+   * Copy-only: `true` when the destination already existed and the copy was
+   * skipped (overwrite was false). Reported in the SUCCESS value — the generic
+   * RPC channel validates error bodies against the core's closed error-code
+   * union, so a custom error code like 'exists' would fail client-side parsing.
+   */
+  exists?: boolean
 }
 
 export type FilesRpcOk = { ok: true; value: FsListResult | FsReadResult | FsWriteResult | FsMutationResult }
@@ -195,6 +202,44 @@ function isFsErrorCode(error: unknown, code: string): boolean {
   return error instanceof Error && (error as { code?: unknown }).code === code
 }
 
+/**
+ * EPERM / EBUSY from a move or remove almost always means the path — or, on
+ * Windows, a file INSIDE a directory being moved/deleted — is open elsewhere
+ * (an editor, Explorer, a terminal sitting inside it, an antivirus scan).
+ * EACCES is left alone: that usually means read-only/ACL, not a lock.
+ */
+function isInUseError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false
+  const code = (error as { code?: unknown }).code
+  return code === 'EPERM' || code === 'EBUSY'
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/**
+ * Retry a mutation a bounded number of times while it fails with a transient
+ * Windows lock (indexer/antivirus handles usually clear within milliseconds).
+ * Genuine "permission denied" / "in use" errors surface after the retries.
+ */
+async function withLockRetry(op: () => Promise<void>, attempts = 3, gapMs = 150): Promise<void> {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      await op()
+      return
+    } catch (error) {
+      if (!isInUseError(error) || attempt >= attempts) throw error
+      await sleep(gapMs * attempt)
+    }
+  }
+}
+
+/** Actionable replacement for a bare "permission denied" when a folder is locked. */
+function lockMessage(path: string): string {
+  return `"${basename(path)}" is in use by another program — close any editor/Explorer view of it (or a terminal inside it) and retry`
+}
+
 function fail(message: string): FilesRpcErr {
   return { ok: false, error: { code: 'internal', message, details: {} } }
 }
@@ -632,9 +677,13 @@ async function renameEntry(ctx: Context, payload: unknown, signal: AbortSignal):
     // fs.rename overwrites silently on POSIX; refuse when the destination exists.
     const existing = await ctx.fs.stat(toTarget, signal)
     if (existing !== undefined) return fail('rename: destination already exists')
-    await renameFs(osPath, toOsPath)
+    // Windows refuses to move a directory while it (or a file inside it) is
+    // open elsewhere; transient locks clear quickly, so retry briefly before
+    // reporting the actionable "in use" message.
+    await withLockRetry(() => renameFs(osPath, toOsPath))
     return { ok: true, value: { path: toOsPath } }
   } catch (error) {
+    if (isInUseError(error)) return fail(lockMessage(path))
     return fail(mapError(error))
   }
 }
@@ -648,9 +697,12 @@ async function deleteEntry(ctx: Context, payload: unknown, signal: AbortSignal):
     const info = await ctx.fs.stat(target, signal)
     if (info === undefined) return fail(`path not found: ${path}`)
     // Folders are removed recursively (the client confirms before calling).
-    await rm(osPath, { recursive: info.type === 'directory', force: true })
+    // Like rename, a folder with an open inner file fails on Windows; retry
+    // transient locks, then report the actionable "in use" message.
+    await withLockRetry(() => rm(osPath, { recursive: info.type === 'directory', force: true }))
     return { ok: true, value: { path: osPath } }
   } catch (error) {
+    if (isInUseError(error)) return fail(lockMessage(path))
     return fail(mapError(error))
   }
 }
@@ -659,10 +711,13 @@ async function deleteEntry(ctx: Context, payload: unknown, signal: AbortSignal):
 // Copy (the explorer's Copy / Cut + Paste)
 //
 // `fs.cp` handles files and (recursively) folders; `errorOnExist` turns a
-// colliding destination into a distinct `exists` error so the client can ask
-// the user whether to overwrite, exactly like the OS file manager. The same
-// `ctx.fs.resolve` → `processPath` resolution as every other endpoint applies,
-// so sandbox containment and error mapping stay uniform.
+// colliding destination into an `ERR_FS_CP_EEXIST` throw, which is reported as
+// a SUCCESS with `exists: true` so the client can ask the user whether to
+// overwrite, exactly like the OS file manager. The same `ctx.fs.resolve` →
+// `processPath` resolution as every other endpoint applies, so sandbox
+// containment and error mapping stay uniform. (Reported in the value, never as
+// an error body: generic-channel errors must use the core's closed error-code
+// union, and a custom code there would fail the client-side response parse.)
 // ---------------------------------------------------------------------------
 
 async function copyEntry(ctx: Context, payload: unknown, signal: AbortSignal): Promise<FilesRpcResult> {
@@ -672,13 +727,14 @@ async function copyEntry(ctx: Context, payload: unknown, signal: AbortSignal): P
   const overwrite = typeof payload === 'object' && payload !== null && (payload as { overwrite?: unknown }).overwrite === true
   if (typeof from !== 'string' || from.trim().length === 0) return fail('copy: payload.from must be a non-empty string')
   if (typeof to !== 'string' || to.trim().length === 0) return fail('copy: payload.to must be a non-empty string')
+  let toOs = ''
   try {
     const fromTarget = await ctx.fs.resolve(from, { signal })
     const fromOs = ctx.fs.processPath(fromTarget)
     const info = await ctx.fs.stat(fromTarget, signal)
     if (info === undefined) return fail(`path not found: ${from}`)
     const toTarget = await ctx.fs.resolve(to, { signal })
-    const toOs = ctx.fs.processPath(toTarget)
+    toOs = ctx.fs.processPath(toTarget)
     // Refuse trivial self-copies and copying a folder into itself or one of
     // its own descendants (comparisons case-insensitive — Windows).
     const samePath = fromOs.toLowerCase() === toOs.toLowerCase()
@@ -692,8 +748,12 @@ async function copyEntry(ctx: Context, payload: unknown, signal: AbortSignal): P
     return { ok: true, value: { path: toOs } }
   } catch (error) {
     if (isFsErrorCode(error, 'ERR_FS_CP_EEXIST')) {
-      return { ok: false, error: { code: 'exists', message: 'destination already exists', details: {} } }
+      // Destination already exists and overwrite was not requested: report the
+      // collision as a successful no-op so the client can ask about overwrite.
+      return { ok: true, value: { path: toOs, exists: true } }
     }
+    // Copying a folder with an open inner file fails like move/delete do.
+    if (isInUseError(error)) return fail(lockMessage(from))
     return fail(mapError(error))
   }
 }