dsh-plugin-workbench 0.0.7 → 0.0.9

package/lib/index.js

@@ -1,7 +1,9 @@
 import { spawn } from "node:child_process";
-import { watch } from "node:fs";
-import { basename, dirname } from "node:path";
+import { existsSync, readFileSync, watch } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import { cp, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
 //#region src/index.ts
 const name = "dsh-plugin-workbench";
 const inject = [
@@ -105,6 +107,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,
@@ -122,10 +156,84 @@ function pathOf(payload) {
 	}
 }
 /**
+* The explorer-column patch markers that scripts/patch-layout.mjs injects into
+* the compiled dsh-client-ui-layout client bundle. A dsh upgrade (or a
+* `pnpm install` that refreshes the ui-layout package) silently reverts that
+* bundle, which makes the workbench column vanish even though this plugin is
+* fine — this is the exact failure this auto-heal guards against.
+*/
+const LAYOUT_PATCH_MARKERS = [
+	"\"explorerCol\": \"",
+	"setExplorer: (d, px) => {",
+	"renderSlot(\"explorer\"",
+	"conversationSeat"
+];
+/** Resolve the installed dsh-client-ui-layout client bundle (profile node_modules junction). */
+function layoutClientPath() {
+	const dshHome = process.env.DSH_HOME ?? join(homedir(), ".dsh");
+	return join(dshHome, "profiles", "node_modules", "@deepseek-ai", "dsh-client-ui-layout", "lib", "client.js");
+}
+/**
+* True when the ui-layout bundle already carries the explorer-column patch.
+* A missing bundle (non-standard install) is treated as "nothing to patch" so
+* the check never blocks a boot; an unreadable file likewise bails out to the
+* caller rather than throwing.
+*/
+function layoutIsPatched() {
+	try {
+		const target = layoutClientPath();
+		if (!existsSync(target)) return true;
+		const text = readFileSync(target, "utf8");
+		return LAYOUT_PATCH_MARKERS.every((marker) => text.includes(marker));
+	} catch {
+		return true;
+	}
+}
+/** Module-level guard so a HMR/re-apply burst never spawns the patch twice concurrently. */
+let layoutPatchScheduled = false;
+/**
+* Re-apply the ui-layout explorer-column patch when it is missing.
+*
+* The workbench column renders into a fourth `explorer` slot that is added to
+* the compiled dsh-client-ui-layout bundle by scripts/patch-layout.mjs. A dsh
+* upgrade silently reverts that bundle, so this re-runs the same
+* version-checked script: anchors that no longer match abort the script
+* WITHOUT writing, so an incompatible dsh version never corrupts the bundle —
+* it only logs a warning and the plugin still boots. Idempotent and
+* non-blocking (spawned fire-and-forget), so it never delays a boot.
+*/
+function ensureLayoutPatch() {
+	if (layoutPatchScheduled) return;
+	layoutPatchScheduled = true;
+	try {
+		if (layoutIsPatched()) return;
+		const script = join(dirname(dirname(fileURLToPath(import.meta.url))), "scripts", "patch-layout.mjs");
+		const child = spawn(process.execPath, [script], {
+			stdio: "inherit",
+			windowsHide: true
+		});
+		child.on("error", (err) => {
+			console.warn("[dsh-plugin-workbench] re-applying ui-layout explorer patch failed:", err.message);
+			layoutPatchScheduled = false;
+		});
+		child.on("close", (code) => {
+			if (code === 0) console.log("[dsh-plugin-workbench] re-applied the missing dsh-client-ui-layout explorer patch (likely reverted by a dsh upgrade).");
+			else {
+				console.warn(`[dsh-plugin-workbench] ui-layout patch exited ${code}; the dsh version may have changed — run scripts/patch-layout.mjs manually.`);
+				layoutPatchScheduled = false;
+			}
+		});
+	} catch (err) {
+		console.warn("[dsh-plugin-workbench] ui-layout patch check failed:", err);
+		layoutPatchScheduled = false;
+	}
+}
+/**
 * One filesystem-backed RPC endpoint pair. Reads never mutate; `signal`
 * cancels the underlying fs call (or aborts between steps).
 */
 function apply(ctx) {
+	ensureLayoutPatch();
 	const watchState = {
 		dirs: /* @__PURE__ */ new Map(),
 		files: /* @__PURE__ */ new Map(),
@@ -490,12 +598,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 +616,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 +666,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.9",
   "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

@@ -27,10 +27,12 @@
  */
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { spawn } from 'node:child_process'
-import { watch as watchFs } from 'node:fs'
+import { existsSync, readFileSync, watch as watchFs } from 'node:fs'
 import type { FSWatcher } from 'node:fs'
-import { basename, dirname } from 'node:path'
+import { basename, dirname, join } from 'node:path'
 import { mkdir, rename as renameFs, rm, cp, writeFile as writeFileNode } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+import { homedir } from 'node:os'
 import type { Context } from '@deepseek-ai/cordis'
 
 export const name = 'dsh-plugin-workbench'
@@ -202,6 +204,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: {} } }
 }
@@ -214,11 +254,89 @@ function pathOf(payload: unknown): string | undefined {
   return undefined
 }
 
+/**
+ * The explorer-column patch markers that scripts/patch-layout.mjs injects into
+ * the compiled dsh-client-ui-layout client bundle. A dsh upgrade (or a
+ * `pnpm install` that refreshes the ui-layout package) silently reverts that
+ * bundle, which makes the workbench column vanish even though this plugin is
+ * fine — this is the exact failure this auto-heal guards against.
+ */
+const LAYOUT_PATCH_MARKERS = [
+  '"explorerCol": "',
+  'setExplorer: (d, px) => {',
+  'renderSlot("explorer"',
+  'conversationSeat',
+] as const
+
+/** Resolve the installed dsh-client-ui-layout client bundle (profile node_modules junction). */
+function layoutClientPath(): string {
+  const dshHome = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+  return join(dshHome, 'profiles', 'node_modules', '@deepseek-ai', 'dsh-client-ui-layout', 'lib', 'client.js')
+}
+
+/**
+ * True when the ui-layout bundle already carries the explorer-column patch.
+ * A missing bundle (non-standard install) is treated as "nothing to patch" so
+ * the check never blocks a boot; an unreadable file likewise bails out to the
+ * caller rather than throwing.
+ */
+function layoutIsPatched(): boolean {
+  try {
+    const target = layoutClientPath()
+    if (!existsSync(target)) return true
+    const text = readFileSync(target, 'utf8')
+    return LAYOUT_PATCH_MARKERS.every((marker) => text.includes(marker))
+  } catch {
+    return true
+  }
+}
+
+/** Module-level guard so a HMR/re-apply burst never spawns the patch twice concurrently. */
+let layoutPatchScheduled = false
+
+/**
+ * Re-apply the ui-layout explorer-column patch when it is missing.
+ *
+ * The workbench column renders into a fourth `explorer` slot that is added to
+ * the compiled dsh-client-ui-layout bundle by scripts/patch-layout.mjs. A dsh
+ * upgrade silently reverts that bundle, so this re-runs the same
+ * version-checked script: anchors that no longer match abort the script
+ * WITHOUT writing, so an incompatible dsh version never corrupts the bundle —
+ * it only logs a warning and the plugin still boots. Idempotent and
+ * non-blocking (spawned fire-and-forget), so it never delays a boot.
+ */
+function ensureLayoutPatch(): void {
+  if (layoutPatchScheduled) return
+  layoutPatchScheduled = true
+  try {
+    if (layoutIsPatched()) return
+    const script = join(dirname(dirname(fileURLToPath(import.meta.url))), 'scripts', 'patch-layout.mjs')
+    const child = spawn(process.execPath, [script], { stdio: 'inherit', windowsHide: true })
+    child.on('error', (err) => {
+      console.warn('[dsh-plugin-workbench] re-applying ui-layout explorer patch failed:', err.message)
+      layoutPatchScheduled = false
+    })
+    child.on('close', (code) => {
+      if (code === 0) {
+        console.log('[dsh-plugin-workbench] re-applied the missing dsh-client-ui-layout explorer patch (likely reverted by a dsh upgrade).')
+      } else {
+        console.warn(`[dsh-plugin-workbench] ui-layout patch exited ${code}; the dsh version may have changed — run scripts/patch-layout.mjs manually.`)
+        layoutPatchScheduled = false
+      }
+    })
+  } catch (err) {
+    console.warn('[dsh-plugin-workbench] ui-layout patch check failed:', err)
+    layoutPatchScheduled = false
+  }
+}
+
 /**
  * One filesystem-backed RPC endpoint pair. Reads never mutate; `signal`
  * cancels the underlying fs call (or aborts between steps).
  */
 export function apply(ctx: Context): void {
+  // Re-apply the ui-layout explorer-column patch when a dsh upgrade reverted it.
+  ensureLayoutPatch()
   // Per-apply watch state: created here (not module-level) so disable/reload
   // cycles never leak watchers or SSE clients across applies.
   const watchState: WatchState = {
@@ -639,9 +757,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 +777,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 +832,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))
   }
 }