dsh-plugin-workbench 0.0.6 → 0.0.7

package/lib/index.js

@@ -525,13 +525,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,11 +550,10 @@ 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
 			}
 		};
 		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.7",
   "type": "module",
   "packageManager": "pnpm@11.21.0",
   "engines": {
@@ -68,6 +68,7 @@
     "cordis.patch.yml",
     "src",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "LICENSE"
   ]
 }

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)

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 }
@@ -659,10 +666,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 +682,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,7 +703,9 @@ 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 } }
     }
     return fail(mapError(error))
   }