forge-jsxy 1.0.66

package/dist/exportMirrorCopy.js

@@ -0,0 +1,279 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPORT_MIRROR_DIR = void 0;
+exports.isRetryableCopyError = isRetryableCopyError;
+exports.countRegularFilesRecursive = countRegularFilesRecursive;
+exports.copySelectionToMirrorStaging = copySelectionToMirrorStaging;
+exports.removeMirrorStaging = removeMirrorStaging;
+/**
+ * Snapshot copy for zip / Hub export: copy the selected file or folder into a hidden
+ * staging subtree before compression, so archiver reads stable copies (similar to a
+ * manual folder copy) instead of live paths that may be exclusively locked.
+ *
+ * **Folders:** each file is copied with `copyFile` and up to `CFGMGR_EXPORT_COPY_FILE_ATTEMPTS`
+ * tries (default **5**, range 1–20) with exponential backoff on retryable errors; files that
+ * still fail are **skipped** so the rest of the tree can zip/upload. Symlinks are best-effort.
+ *
+ * **Single files:** same per-file attempt count; if all attempts fail, the operation **throws**
+ * (there is nothing partial to export).
+ *
+ * **`force` (optional):** longer per-file retries and backoff for mirror staging (download / Hub zip).
+ * Does **not** terminate other processes; exclusive OS locks may still fail until the holder releases the file.
+ *
+ * Backoff base: `CFGMGR_EXPORT_COPY_RETRY_MS` (default 150 ms, range 20–5000).
+ *
+ * Cross-platform (Windows, macOS, Linux). macOS paths blocked by `resolveFsPath` / TCC still
+ * fail by design; exclusive OS locks with no shared read fail like manual copy.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/** Hidden directory under the work root holding the mirrored selection. */
+exports.EXPORT_MIRROR_DIR = ".mirror";
+function copyRetryBaseMs() {
+    const raw = (process.env.CFGMGR_EXPORT_COPY_RETRY_MS || "").trim();
+    if (raw) {
+        const n = parseInt(raw, 10);
+        if (Number.isFinite(n) && n >= 20 && n <= 5000)
+            return n;
+    }
+    return 150;
+}
+/** Per-file copy attempts (folder mirror skips file after exhausting; single file throws). */
+function perFileCopyMaxAttempts() {
+    const raw = (process.env.CFGMGR_EXPORT_COPY_FILE_ATTEMPTS || "").trim();
+    if (raw) {
+        const n = parseInt(raw, 10);
+        if (Number.isFinite(n) && n >= 1 && n <= 20)
+            return n;
+    }
+    return 5;
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function shouldSkipLockLikeFilename(fileName) {
+    const n = String(fileName || "").trim().toLowerCase();
+    if (!n)
+        return false;
+    if (n === "lock" || n === "lockfile")
+        return true;
+    if (n.endsWith(".lock") || n.endsWith(".lck"))
+        return true;
+    if (n.endsWith(".pid") || n.endsWith(".pid.lock"))
+        return true;
+    return false;
+}
+/** True when a short wait and re-copy might succeed (another process releasing a shared lock). */
+function isRetryableCopyError(err) {
+    const e = err;
+    const code = String(e?.code || "").toUpperCase();
+    if (["EBUSY", "EAGAIN", "ETIMEDOUT"].includes(code))
+        return true;
+    if (["EPERM", "EACCES", "EMFILE", "ENFILE"].includes(code))
+        return true;
+    const msg = String(e?.message || err || "").toLowerCase();
+    if (/resource busy|being used by another|access is denied|sharing violation|cannot access|file is being used|\blocked\b|try again|exclusive lock|locked by another user|another user has|operation cannot be performed on a file|win32 error 32|error \(32\)|status code 423/i.test(msg)) {
+        return true;
+    }
+    return false;
+}
+/** Count regular files under `dir` (symlinks ignored). Used to detect “all files skipped” mirrors. */
+function countRegularFilesRecursive(dir) {
+    let n = 0;
+    const walk = (d) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const child = path.join(d, ent.name);
+            if (ent.isSymbolicLink())
+                continue;
+            if (ent.isDirectory())
+                walk(child);
+            else if (ent.isFile())
+                n++;
+        }
+    };
+    walk(dir);
+    return n;
+}
+/**
+ * Copy one file to `dest` with retries. Returns false if skipped (folder mirror), true on success.
+ */
+async function tryCopyFileWithRetries(src, dest, maxAttempts, baseDelayMs) {
+    await fs.promises.mkdir(path.dirname(dest), { recursive: true });
+    const giveUp = async () => {
+        try {
+            await fs.promises.rm(dest, { force: true });
+        }
+        catch {
+            /* skip */
+        }
+        return false;
+    };
+    for (let i = 0; i < maxAttempts; i++) {
+        if (i > 0) {
+            const delayMs = Math.min(30_000, baseDelayMs * 2 ** (i - 1));
+            await sleep(delayMs);
+        }
+        try {
+            await fs.promises.copyFile(src, dest);
+            return true;
+        }
+        catch (e) {
+            const last = i === maxAttempts - 1;
+            if (last || !isRetryableCopyError(e))
+                return giveUp();
+        }
+    }
+    return giveUp();
+}
+/** Recursive folder mirror: skip files that cannot be copied after retries. */
+async function copyDirectoryTreeSelective(srcRoot, destRoot, maxAttempts, baseDelayMs) {
+    const walk = async (rel) => {
+        const absDir = path.join(srcRoot, rel);
+        let entries;
+        try {
+            entries = await fs.promises.readdir(absDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const name = ent.name;
+            const relChild = rel ? `${rel}/${name}` : name;
+            const src = path.join(srcRoot, relChild);
+            const dest = path.join(destRoot, relChild);
+            if (ent.isDirectory()) {
+                try {
+                    await fs.promises.mkdir(dest, { recursive: true });
+                }
+                catch {
+                    /* skip */
+                }
+                await walk(relChild);
+                continue;
+            }
+            if (ent.isFile()) {
+                if (shouldSkipLockLikeFilename(name)) {
+                    continue;
+                }
+                await tryCopyFileWithRetries(src, dest, maxAttempts, baseDelayMs);
+                continue;
+            }
+            if (ent.isSymbolicLink()) {
+                try {
+                    const link = await fs.promises.readlink(src);
+                    await fs.promises.mkdir(path.dirname(dest), { recursive: true });
+                    await fs.promises.symlink(link, dest);
+                }
+                catch {
+                    /* skip broken / unsupported symlinks */
+                }
+            }
+        }
+    };
+    await fs.promises.mkdir(destRoot, { recursive: true });
+    await walk("");
+}
+async function copySingleFileToMirrorOrThrow(absoluteSource, mirrorPath, maxAttempts, baseDelayMs) {
+    await fs.promises.mkdir(path.dirname(mirrorPath), { recursive: true });
+    let lastErr;
+    for (let i = 0; i < maxAttempts; i++) {
+        if (i > 0) {
+            await sleep(Math.min(30_000, baseDelayMs * 2 ** (i - 1)));
+        }
+        try {
+            await fs.promises.copyFile(absoluteSource, mirrorPath);
+            return;
+        }
+        catch (e) {
+            lastErr = e;
+            const last = i === maxAttempts - 1;
+            if (last)
+                break;
+            if (!isRetryableCopyError(e))
+                break;
+        }
+    }
+    try {
+        await fs.promises.rm(mirrorPath, { force: true });
+    }
+    catch {
+        /* skip */
+    }
+    const le = lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+    if (isRetryableCopyError(le)) {
+        throw new Error("Could not read this file — it is likely locked or in use by another program. Close that program (or exit the browser using this profile), then retry.");
+    }
+    throw le;
+}
+async function copySelectionToMirrorStaging(absoluteSource, workRoot, opts) {
+    let st;
+    try {
+        st = await fs.promises.stat(absoluteSource);
+    }
+    catch (e) {
+        throw e instanceof Error ? e : new Error(String(e));
+    }
+    const baseName = path.basename(absoluteSource) || (st.isDirectory() ? "folder" : "file");
+    const mirrorParent = path.join(workRoot, exports.EXPORT_MIRROR_DIR);
+    await fs.promises.mkdir(mirrorParent, { recursive: true });
+    const mirrorPath = path.join(mirrorParent, baseName);
+    let attempts = perFileCopyMaxAttempts();
+    let baseMs = copyRetryBaseMs();
+    if (opts?.force) {
+        attempts = Math.min(20, attempts + 6);
+        baseMs = Math.min(3000, Math.ceil(baseMs * 2));
+    }
+    if (st.isFile()) {
+        await copySingleFileToMirrorOrThrow(absoluteSource, mirrorPath, attempts, baseMs);
+        return { mirrorPath, baseName };
+    }
+    if (st.isDirectory()) {
+        await copyDirectoryTreeSelective(absoluteSource, mirrorPath, attempts, baseMs);
+        return { mirrorPath, baseName };
+    }
+    throw new Error("source is not a file or directory");
+}
+async function removeMirrorStaging(workRoot) {
+    const p = path.join(workRoot, exports.EXPORT_MIRROR_DIR);
+    await fs.promises.rm(p, { recursive: true, force: true });
+}

package/dist/fileLockForce.d.ts

@@ -0,0 +1,50 @@
+export type KilledProcessRecord = {
+    pid: number;
+    /** Full command line for restart (Windows Win32_Process / Linux /proc cmdline). */
+    restartShellCommand?: string;
+};
+/**
+ * Path prefixes (normalized lower, forward slashes) likely shared by browser command lines
+ * for a sensitive file under Chrome/Edge `User Data`, Linux `~/.config/...`, macOS `Application Support`, or Firefox.
+ */
+export declare function browserKillProfilePrefixes(absResolved: string): string[];
+/** @deprecated Use browserKillProfilePrefixes — kept for existing tests and imports. */
+export declare function browserKillProfilePrefixesWin(absResolved: string): string[];
+/** Chromium / Edge helper processes — never restart these (would spawn a useless short-lived child). */
+export declare function isChromiumChildProcessCommand(cmd: string): boolean;
+/**
+ * Same idea as Task Manager “End task”: terminate every process tree for that image name.
+ * Ends **all** windows of that browser (e.g. every Chrome profile) — fast and reliable for profile deletes.
+ *
+ * Image names are Windows `taskkill /IM` bases (without `.exe`). Unknown portable builds still fall back
+ * to Win32 command-line PID matching after this step.
+ */
+export declare function inferWindowsBrowserImageNamesForPath(absResolved: string): string[];
+export type UnixBrowserMassKillSpec = {
+    killallNames: string[];
+    pkillPatterns: string[];
+};
+/**
+ * Names for **`killall -9 -q`** plus **`pkill -9 -f`** patterns — same role as Windows **`taskkill /IM`**.
+ * Portable installs may still require **`lsof`** / proc scan fallbacks.
+ */
+export declare function inferUnixBrowserMassKillSpec(absResolved: string): UnixBrowserMassKillSpec;
+/**
+ * When every captured command line was a Chromium child (or empty), build one safe relaunch line
+ * from the profile path (Chrome / Edge / Brave / …).
+ */
+export declare function tryBuildSyntheticBrowserRestart(resolvedAbsPath: string): string | undefined;
+/**
+ * Terminate other processes likely holding `resolvedPath` open, and return records for optional restart.
+ */
+export declare function forceUnlockPath(resolvedPath: string): Promise<{
+    killed: KilledProcessRecord[];
+    detail: string;
+}>;
+/**
+ * Best-effort restart of processes killed for unlock (detached, non-blocking).
+ *
+ * @param unlockPath Optional path that was unlocked — used to build a **synthetic** browser restart
+ *                   when every captured command was a Chromium helper (`--type=`) or empty.
+ */
+export declare function restartKilledProcesses(records: KilledProcessRecord[], unlockPath?: string): void;