dsh-plugin-workbench 0.0.7 → 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));
 	}
 }
@@ -556,6 +590,7 @@ async function copyEntry(ctx, payload, signal) {
 				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.7",
+  "version": "0.0.8",
   "type": "module",
   "packageManager": "pnpm@11.21.0",
   "engines": {

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

@@ -902,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/index.ts

@@ -202,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: {} } }
 }
@@ -639,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))
   }
 }
@@ -655,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))
   }
 }
@@ -707,6 +752,8 @@ async function copyEntry(ctx: Context, payload: unknown, signal: AbortSignal): P
       // 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))
   }
 }