Files
Netcatty/application/state/sftp/transferConflictOps.ts
T
f83b5f6693 fix(sftp): allow copy and paste within the same pane (#3318)
* fix(#3317): automated AI fix

* fix: address Codex review on PR #3318

* fix: address Codex review on PR #3318

* fix: address Codex review on PR #3318

* fix: address Codex review on PR #3318

* fix: address Codex review on PR #3318

* fix: address Codex review on PR #3318

* fix: address Codex review on PR #3318

* fix(sftp): preserve source links during same-pane replacement

* fix(sftp): leave self-directory merge and replace unchanged

* fix(sftp): scope local traversal limits to same-pane copies

* refactor(sftp): centralize same-pane paste filesystem checks

* fix(sftp): preserve source links through bind-mounted parents

---------

Co-authored-by: netcatty-bot <308658023+netcatty-bot@users.noreply.github.com>
Co-authored-by: bincxz <16399091+binaricat@users.noreply.github.com>
2026-09-12 12:25:18 +08:00

154 lines
6.1 KiB
TypeScript

import { useCallback } from "react";
import type { SftpFilenameEncoding, TransferTask } from "../../../domain/models";
import { netcattyBridge } from "../../../infrastructure/services/netcattyBridge";
import { isMissingStatError } from "./errors";
import type { SftpPane } from "./types";
import { getFileName, getParentPath, isSameSftpPath, joinPath } from "./utils";
export function useSftpTransferConflictOps() {
const splitNameForDuplicate = useCallback((fileName: string, isDirectory: boolean) => {
if (isDirectory) return { baseName: fileName, ext: "" };
const lastDot = fileName.lastIndexOf(".");
if (lastDot <= 0) return { baseName: fileName, ext: "" };
return {
baseName: fileName.slice(0, lastDot),
ext: fileName.slice(lastDot),
};
}, []);
const statTargetPath = useCallback(
async (
targetPane: SftpPane,
targetSftpId: string | null,
targetPath: string,
targetEncoding: SftpFilenameEncoding,
): Promise<{ type?: "file" | "directory" | "symlink"; size: number; mtime: number } | null> => {
if (!targetPane.connection) return null;
try {
if (targetPane.connection.isLocal) {
const bridge = netcattyBridge.get();
const stat = await (bridge?.lstatLocal ?? bridge?.statLocal)?.(targetPath);
if (!stat) return null;
return {
type: stat.type as "file" | "directory" | "symlink" | undefined,
size: stat.size,
mtime: stat.lastModified || Date.now(),
};
}
if (!targetSftpId) return null;
const bridge = netcattyBridge.get();
const stat = await (bridge?.lstatSftp ?? bridge?.statSftp)?.(
targetSftpId,
targetPath,
targetEncoding,
);
if (!stat) return null;
return {
type: stat.type as "file" | "directory" | "symlink" | undefined,
size: stat.size,
mtime: stat.lastModified || Date.now(),
};
} catch (error) {
// Missing path = no conflict. ENOTSUP / unknown type must fail closed.
if (isMissingStatError(error)) return null;
throw error;
}
},
[],
);
const getDuplicateTarget = useCallback(
async (
task: TransferTask,
targetPane: SftpPane,
targetSftpId: string | null,
targetEncoding: SftpFilenameEncoding,
) => {
const parentPath = getParentPath(task.targetPath);
const { baseName, ext } = splitNameForDuplicate(task.fileName, task.isDirectory);
for (let index = 1; index < 1000; index++) {
const suffix = index === 1 ? " (copy)" : ` (copy ${index})`;
const fileName = `${baseName}${suffix}${ext}`;
const targetPath = joinPath(parentPath, fileName);
// Unsupported LSTAT must propagate — do not treat as a free name.
const existing = await statTargetPath(targetPane, targetSftpId, targetPath, targetEncoding);
if (!existing) return { fileName, targetPath };
}
const fallbackName = `${baseName} (copy ${Date.now()})${ext}`;
return { fileName: fallbackName, targetPath: joinPath(parentPath, fallbackName) };
},
[splitNameForDuplicate, statTargetPath],
);
const isSameSourceEntry = useCallback(async (
task: TransferTask,
targetPane: SftpPane,
targetSftpId: string | null,
targetEncoding: SftpFilenameEncoding,
): Promise<boolean> => {
if (!targetPane.connection || task.sourceConnectionId !== task.targetConnectionId) return false;
if (isSameSftpPath(task.sourcePath, task.targetPath)) return true;
const bridge = netcattyBridge.get();
const resolve = targetPane.connection.isLocal
? bridge?.realpathLocal
: targetSftpId && bridge?.realpathSftp
? (value: string) => bridge.realpathSftp!(targetSftpId, value, targetEncoding)
: undefined;
const [sourceParent, targetParent] = await Promise.all(
[getParentPath(task.sourcePath), getParentPath(task.targetPath)].map(
(value) => resolve ? resolve(value) : Promise.resolve(value),
),
);
if (isSameSftpPath(
joinPath(sourceParent, getFileName(task.sourcePath)),
joinPath(targetParent, getFileName(task.targetPath)),
)) return true;
// Bind mounts keep distinct realpaths while naming the same directory.
// Compare parents so a symlink is identified as an entry, not its referent.
if (targetPane.connection.isLocal && bridge?.statLocal
&& getFileName(task.sourcePath) === getFileName(task.targetPath)) {
const [sourceStat, targetStat] = await Promise.all([
bridge.statLocal(sourceParent), bridge.statLocal(targetParent),
]);
return sourceStat.dev !== undefined && sourceStat.ino !== undefined
&& sourceStat.dev === targetStat.dev && sourceStat.ino === targetStat.ino;
}
return false;
}, []);
const deleteTargetPath = useCallback(
async (
task: TransferTask,
targetPane: SftpPane,
targetSftpId: string | null,
targetEncoding: SftpFilenameEncoding,
expectedType?: "file" | "directory" | "symlink",
) => {
if (!targetPane.connection) return;
// Replace unlinks symlinks before copying. Never unlink the source entry
// when a clipboard copy is pasted back into its own directory.
if (expectedType === "symlink" && await isSameSourceEntry(task, targetPane, targetSftpId, targetEncoding)) {
throw new Error("Cannot replace the source link with itself. Choose Duplicate or Skip.");
}
if (targetPane.connection.isLocal) {
const deleteLocalFile = netcattyBridge.get()?.deleteLocalFile;
if (!deleteLocalFile) throw new Error("Local delete unavailable");
await deleteLocalFile(task.targetPath, expectedType);
return;
}
if (!targetSftpId) throw new Error("Target SFTP session not found");
const deleteSftp = netcattyBridge.get()?.deleteSftp;
if (!deleteSftp) throw new Error("SFTP delete unavailable");
await deleteSftp(targetSftpId, task.targetPath, targetEncoding, expectedType);
},
[isSameSourceEntry],
);
return { statTargetPath, getDuplicateTarget, deleteTargetPath, isSameSourceEntry };
}