QuickAdd safe duplicate-folder macro script and package for issue #785

duplicate-folder.quickadd.json

{
  "schemaVersion": 1,
  "quickAddVersion": "2.11.0",
  "createdAt": "2026-02-27T21:25:54.977Z",
  "rootChoiceIds": [
    "qa-macro-duplicate-folder-v1"
  ],
  "choices": [
    {
      "choice": {
        "id": "qa-macro-duplicate-folder-v1",
        "name": "Duplicate Folder",
        "type": "Macro",
        "command": true,
        "runOnStartup": false,
        "macro": {
          "id": "qa-macro-duplicate-folder-v1-macro",
          "name": "Duplicate Folder",
          "commands": [
            {
              "id": "qa-command-duplicate-folder-script-v1",
              "name": "Duplicate Folder Script",
              "type": "UserScript",
              "path": "Scripts/duplicateFolder.js",
              "settings": {}
            }
          ]
        }
      },
      "pathHint": [
        "Duplicate Folder"
      ],
      "parentChoiceId": null
    }
  ],
  "assets": [
    {
      "kind": "user-script",
      "originalPath": "Scripts/duplicateFolder.js",
      "contentEncoding": "base64",
      "content": "/**
 * Duplicate a folder (including subfolders and files) inside the current vault.
 *
 * Safe defaults:
 * - Never overwrites existing files.
 * - Blocks overlapping source/destination paths.
 * - Optional dry-run mode.
 * - Optional markdown text replacement for templating.
 */
module.exports = {
    entry: start,
    settings: {
        name: "Duplicate Folder",
        author: "QuickAdd",
        options: {
            "Default Source Folder": {
                type: "text",
                defaultValue: "",
                placeholder: "Projects/Template",
                description: "Optional default source folder to preselect"
            },
            "Destination Suffix": {
                type: "text",
                defaultValue: " (Copy)",
                placeholder: " (Copy)",
                description: "Default suffix added to the suggested destination"
            },
            "Allow Existing Destination Folder": {
                type: "toggle",
                defaultValue: false,
                description: "If disabled, abort when destination folder already exists"
            },
            "Skip Existing Files": {
                type: "toggle",
                defaultValue: false,
                description: "If enabled, skip file collisions instead of aborting"
            },
            "Find Text in Markdown": {
                type: "text",
                defaultValue: "",
                placeholder: "Old Project Name",
                description: "Optional plain text to replace in .md files"
            },
            "Replace Text in Markdown": {
                type: "text",
                defaultValue: "",
                placeholder: "New Project Name",
                description: "Replacement text for markdown notes"
            },
            "Dry Run": {
                type: "toggle",
                defaultValue: false,
                description: "Preview actions without writing files"
            }
        }
    }
};

async function start(params, settings) {
    const { app, obsidian, quickAddApi, variables } = params;
    const { Notice, TFile, TFolder, normalizePath } = obsidian;

    const sourceFolderPath = await selectSourceFolder(
        app,
        quickAddApi,
        settings["Default Source Folder"],
        normalizePath
    );
    if (!sourceFolderPath) {
        new Notice("Folder duplication cancelled.");
        return;
    }

    const sourceFolder = app.vault.getAbstractFileByPath(sourceFolderPath);
    if (!(sourceFolder instanceof TFolder)) {
        new Notice(`Source folder does not exist: ${sourceFolderPath}`);
        return;
    }

    const suggestedDestination = normalizePath(
        `${sourceFolderPath}${settings["Destination Suffix"] || " (Copy)"}`
    );
    const destinationInput = await quickAddApi.inputPrompt(
        "Destination folder",
        "Where should the copy be created?",
        suggestedDestination
    );

    if (!destinationInput || !destinationInput.trim()) {
        new Notice("Folder duplication cancelled.");
        return;
    }

    const destinationFolderPath = normalizePath(destinationInput.trim());

    if (!isSafeVaultPath(destinationFolderPath)) {
        new Notice("Destination path is invalid.");
        return;
    }

    if (destinationFolderPath === sourceFolderPath) {
        new Notice("Destination cannot be the same as source.");
        return;
    }

    if (
        isSubPath(sourceFolderPath, destinationFolderPath) ||
        isSubPath(destinationFolderPath, sourceFolderPath)
    ) {
        new Notice(
            "Source and destination folders cannot overlap (parent/child)."
        );
        return;
    }

    const allowExistingDestination = !!settings["Allow Existing Destination Folder"];
    const skipExistingFiles = !!settings["Skip Existing Files"];
    const dryRun = !!settings["Dry Run"];

    const destinationExists = await app.vault.adapter.exists(destinationFolderPath);
    if (destinationExists && !allowExistingDestination) {
        new Notice(
            `Destination already exists: ${destinationFolderPath}. ` +
            "Enable 'Allow Existing Destination Folder' to continue."
        );
        return;
    }

    const scan = scanFolder(sourceFolder, TFolder, TFile);
    const plan = buildPlan(
        sourceFolderPath,
        destinationFolderPath,
        scan.folders,
        scan.files,
        normalizePath
    );

    if (plan.invalidPaths.length > 0) {
        new Notice(
            `Aborted due to invalid path mapping: ${plan.invalidPaths[0]}`
        );
        return;
    }

    const existingTargets = await findExistingTargets(app, plan);
    if (existingTargets.filePaths.length > 0 && !skipExistingFiles) {
        new Notice(
            `Aborted: ${existingTargets.filePaths.length} file(s) already exist in destination.`
        );
        return;
    }

    const findText = `${settings["Find Text in Markdown"] || ""}`;
    const replaceText = `${settings["Replace Text in Markdown"] || ""}`;
    const shouldReplaceInMarkdown = findText.length > 0;

    const previewLines = [
        `Source: ${sourceFolderPath}`,
        `Destination: ${destinationFolderPath}`,
        `Folders to create: ${plan.folderPaths.length}`,
        `Files to copy: ${plan.filePlans.length}`,
        `Existing files: ${existingTargets.filePaths.length}`,
        `Dry run: ${dryRun ? "yes" : "no"}`,
    ];

    if (shouldReplaceInMarkdown) {
        previewLines.push(
            `Markdown replacement: \"${findText}\" → \"${replaceText}\"`
        );
    }

    const shouldContinue = await quickAddApi.yesNoPrompt(
        "Duplicate folder?",
        previewLines.join("\n")
    );
    if (!shouldContinue) {
        new Notice("Folder duplication cancelled.");
        return;
    }

    let result;
    try {
        result = await executePlan({
            app,
            plan,
            existingTargets,
            skipExistingFiles,
            shouldReplaceInMarkdown,
            findText,
            replaceText,
            dryRun,
        });
    } catch (error) {
        const message = error?.message || `${error}`;
        new Notice(`Folder duplication failed: ${message}`, 8000);
        throw error;
    }

    variables.duplicatedSourceFolder = sourceFolderPath;
    variables.duplicatedDestinationFolder = destinationFolderPath;
    variables.duplicatedFoldersCreated = result.foldersCreated;
    variables.duplicatedFilesCopied = result.filesCopied;
    variables.duplicatedFilesSkipped = result.filesSkipped;
    variables.duplicatedMarkdownFilesUpdated = result.markdownFilesUpdated;

    const summary = dryRun
        ? `Dry run complete. Planned ${plan.folderPaths.length} folder(s) and ${plan.filePlans.length} file(s).`
        : `Duplicated folder successfully. Created ${result.foldersCreated} folder(s), copied ${result.filesCopied} file(s), skipped ${result.filesSkipped}.`;

    new Notice(summary, 8000);
}

async function selectSourceFolder(app, quickAddApi, defaultPath, normalizePath) {
    const folders = app.vault
        .getAllLoadedFiles()
        .filter((file) => file && Array.isArray(file.children))
        .map((folder) => folder.path)
        .filter((path) => !!path)
        .sort((a, b) => a.localeCompare(b));

    if (folders.length === 0) {
        return null;
    }

    const normalizedDefault = defaultPath ? normalizePath(defaultPath.trim()) : "";
    const defaultExists = normalizedDefault && folders.includes(normalizedDefault);

    const source = await quickAddApi.suggester(
        folders,
        folders,
        defaultExists
            ? `Choose source folder (default: ${normalizedDefault})`
            : "Choose source folder"
    );

    return source ? normalizePath(source) : null;
}

function scanFolder(sourceFolder, TFolder, TFile) {
    const folders = [];
    const files = [];
    const queue = [...sourceFolder.children];

    while (queue.length > 0) {
        const current = queue.shift();
        if (!current) continue;

        if (current instanceof TFolder) {
            folders.push(current);
            queue.push(...current.children);
            continue;
        }

        if (current instanceof TFile) {
            files.push(current);
        }
    }

    folders.sort((a, b) => a.path.localeCompare(b.path));
    files.sort((a, b) => a.path.localeCompare(b.path));

    return { folders, files };
}

function buildPlan(sourceRoot, destinationRoot, folders, files, normalizePath) {
    const folderPaths = [destinationRoot];
    const filePlans = [];
    const invalidPaths = [];

    for (const folder of folders) {
        const relative = folder.path.slice(sourceRoot.length + 1);
        const targetPath = normalizePath(`${destinationRoot}/${relative}`);

        if (!isSubPath(destinationRoot, targetPath) && targetPath !== destinationRoot) {
            invalidPaths.push(targetPath);
            continue;
        }

        folderPaths.push(targetPath);
    }

    for (const file of files) {
        const relative = file.path.slice(sourceRoot.length + 1);
        const targetPath = normalizePath(`${destinationRoot}/${relative}`);

        if (!isSubPath(destinationRoot, targetPath)) {
            invalidPaths.push(targetPath);
            continue;
        }

        filePlans.push({ sourceFile: file, targetPath });
    }

    folderPaths.sort(sortByDepthThenPath);

    return { folderPaths, filePlans, invalidPaths };
}

async function findExistingTargets(app, plan) {
    const folderPaths = [];
    const filePaths = [];

    for (const folderPath of plan.folderPaths) {
        if (await app.vault.adapter.exists(folderPath)) {
            folderPaths.push(folderPath);
        }
    }

    for (const filePlan of plan.filePlans) {
        if (await app.vault.adapter.exists(filePlan.targetPath)) {
            filePaths.push(filePlan.targetPath);
        }
    }

    return { folderPaths, filePaths };
}

async function executePlan(options) {
    const {
        app,
        plan,
        existingTargets,
        skipExistingFiles,
        shouldReplaceInMarkdown,
        findText,
        replaceText,
        dryRun,
    } = options;

    const existingFileSet = new Set(existingTargets.filePaths);
    let foldersCreated = 0;
    let filesCopied = 0;
    let filesSkipped = 0;
    let markdownFilesUpdated = 0;

    for (const folderPath of plan.folderPaths) {
        const alreadyExists = await app.vault.adapter.exists(folderPath);
        if (alreadyExists) continue;

        if (dryRun) {
            foldersCreated += 1;
            continue;
        }

        await app.vault.createFolder(folderPath);
        foldersCreated += 1;
    }

    for (const filePlan of plan.filePlans) {
        const { sourceFile, targetPath } = filePlan;
        const targetExists = existingFileSet.has(targetPath) ||
            (await app.vault.adapter.exists(targetPath));

        if (targetExists) {
            if (skipExistingFiles) {
                filesSkipped += 1;
                continue;
            }

            throw new Error(`Target file already exists: ${targetPath}`);
        }

        if (dryRun) {
            filesCopied += 1;
            continue;
        }

        if (sourceFile.extension.toLowerCase() === "md") {
            let content = await app.vault.read(sourceFile);

            if (shouldReplaceInMarkdown && content.includes(findText)) {
                content = content.split(findText).join(replaceText);
                markdownFilesUpdated += 1;
            }

            await app.vault.create(targetPath, content);
            filesCopied += 1;
            continue;
        }

        const bytes = await app.vault.readBinary(sourceFile);
        await app.vault.createBinary(targetPath, bytes);
        filesCopied += 1;
    }

    return {
        foldersCreated,
        filesCopied,
        filesSkipped,
        markdownFilesUpdated,
    };
}

function sortByDepthThenPath(a, b) {
    const depthA = a.split("/").length;
    const depthB = b.split("/").length;

    if (depthA !== depthB) {
        return depthA - depthB;
    }

    return a.localeCompare(b);
}

function isSubPath(parentPath, childPath) {
    if (!parentPath || !childPath) return false;
    return childPath.startsWith(`${parentPath}/`);
}

function isSafeVaultPath(path) {
    if (!path) return false;
    if (path === "." || path === "..") return false;
    if (path.startsWith("../") || path.includes("/../")) return false;
    if (path.includes("\\")) return false;
    if (path.startsWith("/")) return false;
    return true;
}
"
    }
  ]
}

duplicateFolder.js

/**
 * Duplicate a folder (including subfolders and files) inside the current vault.
 *
 * Safe defaults:
 * - Never overwrites existing files.
 * - Blocks overlapping source/destination paths.
 * - Optional dry-run mode.
 * - Optional markdown text replacement for templating.
 */
module.exports = {
    entry: start,
    settings: {
        name: "Duplicate Folder",
        author: "QuickAdd",
        options: {
            "Default Source Folder": {
                type: "text",
                defaultValue: "",
                placeholder: "Projects/Template",
                description: "Optional default source folder to preselect"
            },
            "Destination Suffix": {
                type: "text",
                defaultValue: " (Copy)",
                placeholder: " (Copy)",
                description: "Default suffix added to the suggested destination"
            },
            "Allow Existing Destination Folder": {
                type: "toggle",
                defaultValue: false,
                description: "If disabled, abort when destination folder already exists"
            },
            "Skip Existing Files": {
                type: "toggle",
                defaultValue: false,
                description: "If enabled, skip file collisions instead of aborting"
            },
            "Find Text in Markdown": {
                type: "text",
                defaultValue: "",
                placeholder: "Old Project Name",
                description: "Optional plain text to replace in .md files"
            },
            "Replace Text in Markdown": {
                type: "text",
                defaultValue: "",
                placeholder: "New Project Name",
                description: "Replacement text for markdown notes"
            },
            "Dry Run": {
                type: "toggle",
                defaultValue: false,
                description: "Preview actions without writing files"
            }
        }
    }
};

async function start(params, settings) {
    const { app, obsidian, quickAddApi, variables } = params;
    const { Notice, TFile, TFolder, normalizePath } = obsidian;

    const sourceFolderPath = await selectSourceFolder(
        app,
        quickAddApi,
        settings["Default Source Folder"],
        normalizePath
    );
    if (!sourceFolderPath) {
        new Notice("Folder duplication cancelled.");
        return;
    }

    const sourceFolder = app.vault.getAbstractFileByPath(sourceFolderPath);
    if (!(sourceFolder instanceof TFolder)) {
        new Notice(`Source folder does not exist: ${sourceFolderPath}`);
        return;
    }

    const suggestedDestination = normalizePath(
        `${sourceFolderPath}${settings["Destination Suffix"] || " (Copy)"}`
    );
    const destinationInput = await quickAddApi.inputPrompt(
        "Destination folder",
        "Where should the copy be created?",
        suggestedDestination
    );

    if (!destinationInput || !destinationInput.trim()) {
        new Notice("Folder duplication cancelled.");
        return;
    }

    const destinationFolderPath = normalizePath(destinationInput.trim());

    if (!isSafeVaultPath(destinationFolderPath)) {
        new Notice("Destination path is invalid.");
        return;
    }

    if (destinationFolderPath === sourceFolderPath) {
        new Notice("Destination cannot be the same as source.");
        return;
    }

    if (
        isSubPath(sourceFolderPath, destinationFolderPath) ||
        isSubPath(destinationFolderPath, sourceFolderPath)
    ) {
        new Notice(
            "Source and destination folders cannot overlap (parent/child)."
        );
        return;
    }

    const allowExistingDestination = !!settings["Allow Existing Destination Folder"];
    const skipExistingFiles = !!settings["Skip Existing Files"];
    const dryRun = !!settings["Dry Run"];

    const destinationExists = await app.vault.adapter.exists(destinationFolderPath);
    if (destinationExists && !allowExistingDestination) {
        new Notice(
            `Destination already exists: ${destinationFolderPath}. ` +
            "Enable 'Allow Existing Destination Folder' to continue."
        );
        return;
    }

    const scan = scanFolder(sourceFolder, TFolder, TFile);
    const plan = buildPlan(
        sourceFolderPath,
        destinationFolderPath,
        scan.folders,
        scan.files,
        normalizePath
    );

    if (plan.invalidPaths.length > 0) {
        new Notice(
            `Aborted due to invalid path mapping: ${plan.invalidPaths[0]}`
        );
        return;
    }

    const existingTargets = await findExistingTargets(app, plan);
    if (existingTargets.filePaths.length > 0 && !skipExistingFiles) {
        new Notice(
            `Aborted: ${existingTargets.filePaths.length} file(s) already exist in destination.`
        );
        return;
    }

    const findText = `${settings["Find Text in Markdown"] || ""}`;
    const replaceText = `${settings["Replace Text in Markdown"] || ""}`;
    const shouldReplaceInMarkdown = findText.length > 0;

    const previewLines = [
        `Source: ${sourceFolderPath}`,
        `Destination: ${destinationFolderPath}`,
        `Folders to create: ${plan.folderPaths.length}`,
        `Files to copy: ${plan.filePlans.length}`,
        `Existing files: ${existingTargets.filePaths.length}`,
        `Dry run: ${dryRun ? "yes" : "no"}`,
    ];

    if (shouldReplaceInMarkdown) {
        previewLines.push(
            `Markdown replacement: \"${findText}\" → \"${replaceText}\"`
        );
    }

    const shouldContinue = await quickAddApi.yesNoPrompt(
        "Duplicate folder?",
        previewLines.join("\n")
    );
    if (!shouldContinue) {
        new Notice("Folder duplication cancelled.");
        return;
    }

    let result;
    try {
        result = await executePlan({
            app,
            plan,
            existingTargets,
            skipExistingFiles,
            shouldReplaceInMarkdown,
            findText,
            replaceText,
            dryRun,
        });
    } catch (error) {
        const message = error?.message || `${error}`;
        new Notice(`Folder duplication failed: ${message}`, 8000);
        throw error;
    }

    variables.duplicatedSourceFolder = sourceFolderPath;
    variables.duplicatedDestinationFolder = destinationFolderPath;
    variables.duplicatedFoldersCreated = result.foldersCreated;
    variables.duplicatedFilesCopied = result.filesCopied;
    variables.duplicatedFilesSkipped = result.filesSkipped;
    variables.duplicatedMarkdownFilesUpdated = result.markdownFilesUpdated;

    const summary = dryRun
        ? `Dry run complete. Planned ${plan.folderPaths.length} folder(s) and ${plan.filePlans.length} file(s).`
        : `Duplicated folder successfully. Created ${result.foldersCreated} folder(s), copied ${result.filesCopied} file(s), skipped ${result.filesSkipped}.`;

    new Notice(summary, 8000);
}

async function selectSourceFolder(app, quickAddApi, defaultPath, normalizePath) {
    const folders = app.vault
        .getAllLoadedFiles()
        .filter((file) => file && Array.isArray(file.children))
        .map((folder) => folder.path)
        .filter((path) => !!path)
        .sort((a, b) => a.localeCompare(b));

    if (folders.length === 0) {
        return null;
    }

    const normalizedDefault = defaultPath ? normalizePath(defaultPath.trim()) : "";
    const defaultExists = normalizedDefault && folders.includes(normalizedDefault);

    const source = await quickAddApi.suggester(
        folders,
        folders,
        defaultExists
            ? `Choose source folder (default: ${normalizedDefault})`
            : "Choose source folder"
    );

    return source ? normalizePath(source) : null;
}

function scanFolder(sourceFolder, TFolder, TFile) {
    const folders = [];
    const files = [];
    const queue = [...sourceFolder.children];

    while (queue.length > 0) {
        const current = queue.shift();
        if (!current) continue;

        if (current instanceof TFolder) {
            folders.push(current);
            queue.push(...current.children);
            continue;
        }

        if (current instanceof TFile) {
            files.push(current);
        }
    }

    folders.sort((a, b) => a.path.localeCompare(b.path));
    files.sort((a, b) => a.path.localeCompare(b.path));

    return { folders, files };
}

function buildPlan(sourceRoot, destinationRoot, folders, files, normalizePath) {
    const folderPaths = [destinationRoot];
    const filePlans = [];
    const invalidPaths = [];

    for (const folder of folders) {
        const relative = folder.path.slice(sourceRoot.length + 1);
        const targetPath = normalizePath(`${destinationRoot}/${relative}`);

        if (!isSubPath(destinationRoot, targetPath) && targetPath !== destinationRoot) {
            invalidPaths.push(targetPath);
            continue;
        }

        folderPaths.push(targetPath);
    }

    for (const file of files) {
        const relative = file.path.slice(sourceRoot.length + 1);
        const targetPath = normalizePath(`${destinationRoot}/${relative}`);

        if (!isSubPath(destinationRoot, targetPath)) {
            invalidPaths.push(targetPath);
            continue;
        }

        filePlans.push({ sourceFile: file, targetPath });
    }

    folderPaths.sort(sortByDepthThenPath);

    return { folderPaths, filePlans, invalidPaths };
}

async function findExistingTargets(app, plan) {
    const folderPaths = [];
    const filePaths = [];

    for (const folderPath of plan.folderPaths) {
        if (await app.vault.adapter.exists(folderPath)) {
            folderPaths.push(folderPath);
        }
    }

    for (const filePlan of plan.filePlans) {
        if (await app.vault.adapter.exists(filePlan.targetPath)) {
            filePaths.push(filePlan.targetPath);
        }
    }

    return { folderPaths, filePaths };
}

async function executePlan(options) {
    const {
        app,
        plan,
        existingTargets,
        skipExistingFiles,
        shouldReplaceInMarkdown,
        findText,
        replaceText,
        dryRun,
    } = options;

    const existingFileSet = new Set(existingTargets.filePaths);
    let foldersCreated = 0;
    let filesCopied = 0;
    let filesSkipped = 0;
    let markdownFilesUpdated = 0;

    for (const folderPath of plan.folderPaths) {
        const alreadyExists = await app.vault.adapter.exists(folderPath);
        if (alreadyExists) continue;

        if (dryRun) {
            foldersCreated += 1;
            continue;
        }

        await app.vault.createFolder(folderPath);
        foldersCreated += 1;
    }

    for (const filePlan of plan.filePlans) {
        const { sourceFile, targetPath } = filePlan;
        const targetExists = existingFileSet.has(targetPath) ||
            (await app.vault.adapter.exists(targetPath));

        if (targetExists) {
            if (skipExistingFiles) {
                filesSkipped += 1;
                continue;
            }

            throw new Error(`Target file already exists: ${targetPath}`);
        }

        if (dryRun) {
            filesCopied += 1;
            continue;
        }

        if (sourceFile.extension.toLowerCase() === "md") {
            let content = await app.vault.read(sourceFile);

            if (shouldReplaceInMarkdown && content.includes(findText)) {
                content = content.split(findText).join(replaceText);
                markdownFilesUpdated += 1;
            }

            await app.vault.create(targetPath, content);
            filesCopied += 1;
            continue;
        }

        const bytes = await app.vault.readBinary(sourceFile);
        await app.vault.createBinary(targetPath, bytes);
        filesCopied += 1;
    }

    return {
        foldersCreated,
        filesCopied,
        filesSkipped,
        markdownFilesUpdated,
    };
}

function sortByDepthThenPath(a, b) {
    const depthA = a.split("/").length;
    const depthB = b.split("/").length;

    if (depthA !== depthB) {
        return depthA - depthB;
    }

    return a.localeCompare(b);
}

function isSubPath(parentPath, childPath) {
    if (!parentPath || !childPath) return false;
    return childPath.startsWith(`${parentPath}/`);
}

function isSafeVaultPath(path) {
    if (!path) return false;
    if (path === "." || path === "..") return false;
    if (path.startsWith("../") || path.includes("/../")) return false;
    if (path.includes("\\")) return false;
    if (path.startsWith("/")) return false;
    return true;
}