@solaqua/gji 0.12.2 → 0.12.4

package/dist/dir-clone.js

@@ -1,641 +0,0 @@
-import { execFile } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { chmod, cp, lstat, mkdir, mkdtemp, opendir, readdir, readFile, readlink, realpath, rename, rm, rmdir, symlink, unlink, utimes, writeFile, } from "node:fs/promises";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { promisify } from "node:util";
-import { isAlreadyExistsError, isNotFoundError } from "./fs-utils.js";
-import { inspectDestination, openDestinationDirectory, } from "./safe-destination.js";
-const execFileAsync = promisify(execFile);
-const CLONE_LOCK_TTL_MS = 5 * 60 * 1000;
-const CLONE_GUARD_TTL_MS = 30 * 1000;
-const CLONE_LOCK_SUFFIX = ".gji-clone-lock";
-const SIZE_ESTIMATE_MAX_ENTRIES = 1_000_000;
-const SIZE_ESTIMATE_MAX_MS = 5_000;
-export async function cloneDir(source, destination, options = {}) {
-    const platform = options.platform ?? process.platform;
-    if (!isClonePlatformSupported(platform)) {
-        throw new CloneUnsupportedError(`platform ${platform} has no CoW strategy`);
-    }
-    const sourcePath = await realpath(source);
-    const sourceStats = await lstat(sourcePath);
-    if (!sourceStats.isDirectory()) {
-        throw new Error("source is not a directory");
-    }
-    const destinationPath = await resolveProspectivePath(destination);
-    const destinationDistance = relative(sourcePath, destinationPath);
-    if (destinationDistance === "" ||
-        (destinationDistance !== ".." &&
-            !destinationDistance.startsWith(`..${sep}`))) {
-        throw new Error("clone destination must not be inside its source");
-    }
-    const startedAt = Date.now();
-    const parent = dirname(destination);
-    let safeParent;
-    try {
-        if (options.destinationRoot) {
-            const parentInspection = await inspectDestination(options.destinationRoot, parent);
-            if (parentInspection.kind === "unsafe") {
-                throw new Error(parentInspection.reason);
-            }
-            safeParent = await openDestinationDirectory(options.destinationRoot, parent);
-        }
-        else {
-            await mkdir(parent, { recursive: true });
-        }
-        const operationParent = safeParent?.path ?? parent;
-        const operationDestination = join(operationParent, basename(destination));
-        const cloneLock = await acquireCloneLock(`${operationDestination}${CLONE_LOCK_SUFFIX}`, destination);
-        const stopLockHeartbeat = startLockHeartbeat(cloneLock);
-        let temporaryRoot;
-        let reservation;
-        const publishedEntries = [];
-        try {
-            if (await destinationExists(operationDestination)) {
-                throw new CloneDestinationExistsError(destination);
-            }
-            reservation = await reserveDestination(operationDestination);
-            temporaryRoot = await mkdtemp(join(operationParent, `.${basename(destination)}.gji-clone-`));
-            const temporaryDestination = join(temporaryRoot, basename(destination));
-            try {
-                await (options.copyDirectory ??
-                    ((sourcePath, targetPath) => copyDirectoryWithCow(sourcePath, targetPath, platform, options.runLinuxCommand)))(sourcePath, temporaryDestination);
-            }
-            catch (error) {
-                if (error instanceof CloneUnsupportedError)
-                    throw error;
-                if (isUnsupportedCloneError(error)) {
-                    throw new CloneUnsupportedError(toErrorMessage(error));
-                }
-                throw error;
-            }
-            await publishCloneContents(temporaryDestination, operationDestination, reservation.path, (entry) => publishedEntries.push(entry), options.copyFile ?? runForcedCloneFileCopy);
-            reservation = undefined;
-        }
-        finally {
-            stopLockHeartbeat();
-            if (reservation) {
-                await cleanupReservedDestination(operationDestination, reservation, publishedEntries);
-            }
-            if (temporaryRoot) {
-                await rm(temporaryRoot, { force: true, recursive: true }).catch(() => undefined);
-            }
-            await releaseCloneLock(cloneLock).catch(() => undefined);
-        }
-        return cloneResult(sourcePath, startedAt, options.measureBytes);
-    }
-    finally {
-        await safeParent?.close().catch(() => undefined);
-    }
-}
-async function copyDirectoryWithCow(source, destination, platform, runLinuxCommand) {
-    if (platform === "darwin") {
-        await cp(source, destination, {
-            errorOnExist: true,
-            force: false,
-            mode: constants.COPYFILE_FICLONE_FORCE,
-            preserveTimestamps: true,
-            recursive: true,
-        });
-        return;
-    }
-    const strategy = cloneStrategy(platform);
-    if (!strategy) {
-        throw new CloneUnsupportedError(`platform ${platform} has no CoW strategy`);
-    }
-    await (runLinuxCommand ?? runCloneCommand)("cp", strategy(source, destination));
-}
-async function resolveProspectivePath(path) {
-    let current = resolve(path);
-    const missing = [];
-    while (true) {
-        try {
-            return join(await realpath(current), ...missing);
-        }
-        catch (error) {
-            if (!isNotFoundError(error))
-                throw error;
-            const parent = dirname(current);
-            if (parent === current)
-                throw error;
-            missing.unshift(basename(current));
-            current = parent;
-        }
-    }
-}
-async function cloneResult(source, startedAt, measureBytes) {
-    const bytes = measureBytes === false ? undefined : await estimateCloneBytes(source);
-    return { bytes, ms: Date.now() - startedAt };
-}
-export class CloneDestinationExistsError extends Error {
-    code = "GJI_CLONE_DESTINATION_EXISTS";
-    constructor(destination) {
-        super(`destination already exists: ${destination}`);
-        this.name = "CloneDestinationExistsError";
-    }
-}
-export class CloneUnsupportedError extends Error {
-    code = "GJI_CLONE_UNSUPPORTED";
-    constructor(reason) {
-        super(`copy-on-write cloning is not supported: ${reason}`);
-        this.name = "CloneUnsupportedError";
-    }
-}
-export class CloneInProgressError extends Error {
-    code = "GJI_CLONE_IN_PROGRESS";
-    constructor(destination) {
-        super(`copy-on-write clone already in progress: ${destination}`);
-        this.name = "CloneInProgressError";
-    }
-}
-export function isCloneDestinationExistsError(error) {
-    return error instanceof CloneDestinationExistsError;
-}
-export function isCloneUnsupportedError(error) {
-    return error instanceof CloneUnsupportedError;
-}
-export function isCloneInProgressError(error) {
-    return error instanceof CloneInProgressError;
-}
-export async function directorySize(path) {
-    const stats = await lstat(path);
-    if (!stats.isDirectory())
-        return stats.size;
-    const pending = [path];
-    let total = 0;
-    let entryCount = 0;
-    const startedAt = Date.now();
-    while (pending.length > 0) {
-        const current = pending.pop();
-        if (!current)
-            continue;
-        const directory = await opendir(current);
-        try {
-            for await (const entry of directory) {
-                entryCount += 1;
-                if (entryCount > SIZE_ESTIMATE_MAX_ENTRIES ||
-                    Date.now() - startedAt > SIZE_ESTIMATE_MAX_MS) {
-                    throw new Error("directory size estimate exceeded its safety limit");
-                }
-                const entryPath = join(current, entry.name);
-                if (entry.isDirectory())
-                    pending.push(entryPath);
-                else
-                    total += (await lstat(entryPath)).size;
-            }
-        }
-        finally {
-            await directory.close().catch(() => undefined);
-        }
-    }
-    return total;
-}
-function cloneStrategy(platform) {
-    if (platform === "linux") {
-        return (source, destination) => [
-            "-a",
-            "--reflink=always",
-            source,
-            destination,
-        ];
-    }
-    return null;
-}
-function isClonePlatformSupported(platform) {
-    return platform === "darwin" || platform === "linux";
-}
-async function estimateCloneBytes(path) {
-    try {
-        return await directorySize(path);
-    }
-    catch {
-        return undefined;
-    }
-}
-async function runCloneCommand(command, args) {
-    try {
-        await execFileAsync(command, args);
-    }
-    catch (error) {
-        if (isUnsupportedCloneError(error)) {
-            throw new CloneUnsupportedError(toErrorMessage(error));
-        }
-        throw error;
-    }
-}
-async function acquireCloneLock(lockPath, destination) {
-    const releaseGuard = await acquireCloneLockGuard(lockPath, destination);
-    try {
-        return await acquireCloneLockWithGuard(lockPath, destination);
-    }
-    finally {
-        await releaseGuard();
-    }
-}
-async function acquireCloneLockWithGuard(lockPath, destination) {
-    const lockToken = randomUUID();
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-        const published = await publishCloneLock(lockPath, lockToken);
-        if (published)
-            return published;
-        let staleLock;
-        try {
-            staleLock = await inspectCloneLock(lockPath);
-        }
-        catch (error) {
-            if (isNotFoundError(error))
-                continue;
-            throw error;
-        }
-        if (staleLock.kind === "invalid" ||
-            Date.now() - staleLock.mtimeMs < CLONE_LOCK_TTL_MS) {
-            throw new CloneInProgressError(destination);
-        }
-        const stalePath = `${lockPath}.stale-${randomUUID()}`;
-        try {
-            await rename(lockPath, stalePath);
-        }
-        catch (error) {
-            if (isNotFoundError(error))
-                continue;
-            throw error;
-        }
-        try {
-            const replacement = await publishCloneLock(lockPath, lockToken);
-            if (!replacement) {
-                await cleanupStaleCloneLock(stalePath, staleLock);
-                continue;
-            }
-            try {
-                await cleanupStaleCloneLock(stalePath, staleLock);
-            }
-            catch (cleanupError) {
-                await releaseCloneLockWithGuard(replacement).catch(() => undefined);
-                throw cleanupError;
-            }
-            return replacement;
-        }
-        catch (error) {
-            await cleanupStaleCloneLock(stalePath, staleLock).catch(() => undefined);
-            if (isAlreadyExistsError(error))
-                continue;
-            throw error;
-        }
-    }
-    throw new CloneInProgressError(destination);
-}
-async function acquireCloneLockGuard(lockPath, destination) {
-    const guardPath = `${lockPath}.guard`;
-    const deadline = Date.now() + 5_000;
-    while (true) {
-        try {
-            await mkdir(guardPath, { mode: 0o700 });
-            const markerName = `${process.pid}-${randomUUID()}`;
-            const markerPath = join(guardPath, markerName);
-            try {
-                await writeFile(markerPath, `${markerName}\n`, {
-                    flag: "wx",
-                    mode: 0o600,
-                });
-            }
-            catch (error) {
-                await rmdir(guardPath).catch(() => undefined);
-                throw error;
-            }
-            return async () => {
-                await unlink(markerPath).catch((error) => {
-                    if (!isNotFoundError(error))
-                        throw error;
-                });
-                await rmdir(guardPath).catch((error) => {
-                    if (!isNotFoundError(error))
-                        throw error;
-                });
-            };
-        }
-        catch (error) {
-            if (!isAlreadyExistsError(error))
-                throw error;
-            if (await reclaimAbandonedCloneGuard(guardPath))
-                continue;
-            if (Date.now() >= deadline) {
-                throw new CloneInProgressError(destination);
-            }
-            await new Promise((resolve) => setTimeout(resolve, 10));
-        }
-    }
-}
-async function reclaimAbandonedCloneGuard(guardPath) {
-    let expectedMarker;
-    try {
-        const entries = await readdir(guardPath);
-        if (entries.length > 1)
-            return false;
-        expectedMarker = entries[0];
-        const freshnessPath = expectedMarker
-            ? join(guardPath, expectedMarker)
-            : guardPath;
-        const stats = await lstat(freshnessPath);
-        if (Date.now() - stats.mtimeMs < CLONE_GUARD_TTL_MS)
-            return false;
-        if (expectedMarker) {
-            const ownerPid = Number(expectedMarker.split("-", 1)[0]);
-            if (!Number.isSafeInteger(ownerPid) || ownerPid <= 0)
-                return false;
-            if (processIsAlive(ownerPid))
-                return false;
-        }
-    }
-    catch (error) {
-        return isNotFoundError(error);
-    }
-    const stalePath = `${guardPath}.stale-${randomUUID()}`;
-    try {
-        await rename(guardPath, stalePath);
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return true;
-        throw error;
-    }
-    const movedEntries = await readdir(stalePath).catch(() => []);
-    if (movedEntries.length !== (expectedMarker ? 1 : 0) ||
-        (expectedMarker && movedEntries[0] !== expectedMarker)) {
-        await rename(stalePath, guardPath).catch(() => undefined);
-        return false;
-    }
-    if (expectedMarker)
-        await unlink(join(stalePath, expectedMarker));
-    await rmdir(stalePath);
-    return true;
-}
-function processIsAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code === "EPERM";
-    }
-}
-async function publishCloneLock(lockPath, lockToken) {
-    try {
-        await mkdir(lockPath, { mode: 0o700 });
-    }
-    catch (error) {
-        if (isAlreadyExistsError(error))
-            return undefined;
-        throw error;
-    }
-    const markerPath = join(lockPath, lockToken);
-    try {
-        await writeFile(markerPath, `${lockToken}\n`, { flag: "wx", mode: 0o600 });
-        return {
-            lockPath,
-            markerName: lockToken,
-            markerPath,
-            token: lockToken,
-        };
-    }
-    catch (error) {
-        await rmdir(lockPath).catch(() => undefined);
-        throw error;
-    }
-}
-async function inspectCloneLock(lockPath) {
-    try {
-        const stats = await lstat(lockPath);
-        if (!stats.isDirectory() || stats.isSymbolicLink()) {
-            return { kind: "invalid", mtimeMs: stats.mtimeMs };
-        }
-        const entries = await readdir(lockPath);
-        if (entries.length === 0)
-            return { kind: "empty", mtimeMs: stats.mtimeMs };
-        if (entries.length !== 1) {
-            return { kind: "invalid", mtimeMs: stats.mtimeMs };
-        }
-        const markerName = entries[0];
-        const token = markerName?.startsWith("owner-")
-            ? markerName.slice("owner-".length)
-            : markerName;
-        if (!token || !/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu.test(token)) {
-            return { kind: "invalid", mtimeMs: stats.mtimeMs };
-        }
-        const markerPath = join(lockPath, markerName);
-        const markerStats = await lstat(markerPath);
-        if (!markerStats.isFile() || markerStats.isSymbolicLink()) {
-            return { kind: "invalid", mtimeMs: markerStats.mtimeMs };
-        }
-        if ((await readFile(markerPath, "utf8")).trim() !== token) {
-            return { kind: "invalid", mtimeMs: markerStats.mtimeMs };
-        }
-        return {
-            kind: "owned",
-            lockPath,
-            markerName: markerName,
-            markerPath,
-            mtimeMs: markerStats.mtimeMs,
-            token,
-        };
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            throw error;
-        return { kind: "invalid", mtimeMs: Date.now() };
-    }
-}
-async function cleanupStaleCloneLock(lockPath, inspection) {
-    if (inspection.kind === "owned") {
-        await unlink(join(lockPath, inspection.markerName));
-    }
-    await rmdir(lockPath);
-}
-async function publishCloneContents(temporaryDestination, destination, reservationPath, onEntryPublished, copyFileEntry) {
-    const reservationName = basename(reservationPath);
-    const destinationEntries = await readdir(destination);
-    if (destinationEntries.length !== 1 ||
-        destinationEntries[0] !== reservationName) {
-        throw new CloneDestinationExistsError(destination);
-    }
-    const temporaryEntries = await readdir(temporaryDestination);
-    for (const entry of temporaryEntries) {
-        await publishCloneEntry(join(temporaryDestination, entry), join(destination, entry), (entry) => onEntryPublished(entry), copyFileEntry);
-    }
-    await unlink(reservationPath);
-}
-async function publishCloneEntry(source, destination, onCreated, copyFileEntry) {
-    const sourceStats = await lstat(source);
-    if (sourceStats.isDirectory()) {
-        try {
-            await mkdir(destination);
-        }
-        catch (error) {
-            if (isAlreadyExistsError(error)) {
-                throw new CloneDestinationExistsError(destination);
-            }
-            throw error;
-        }
-        onCreated(await inspectOwnedCloneEntry(destination, "directory"));
-        for (const entry of await readdir(source)) {
-            await publishCloneEntry(join(source, entry), join(destination, entry), () => undefined, copyFileEntry);
-        }
-        await copyCloneMetadata(sourceStats, destination);
-        return;
-    }
-    if (sourceStats.isSymbolicLink()) {
-        try {
-            await symlink(await readlink(source), destination);
-        }
-        catch (error) {
-            if (isAlreadyExistsError(error)) {
-                throw new CloneDestinationExistsError(destination);
-            }
-            throw error;
-        }
-        onCreated(await inspectOwnedCloneEntry(destination, "symlink"));
-        return;
-    }
-    if (!sourceStats.isFile()) {
-        throw new Error(`unsupported clone entry type: ${source}`);
-    }
-    try {
-        await copyFileEntry(source, destination);
-    }
-    catch (error) {
-        if (isAlreadyExistsError(error)) {
-            throw new CloneDestinationExistsError(destination);
-        }
-        if (isUnsupportedCloneError(error)) {
-            throw new CloneUnsupportedError(toErrorMessage(error));
-        }
-        throw error;
-    }
-    onCreated(await inspectOwnedCloneEntry(destination, "file"));
-    await copyCloneMetadata(sourceStats, destination);
-}
-async function runForcedCloneFileCopy(source, destination) {
-    await cp(source, destination, {
-        errorOnExist: true,
-        force: false,
-        mode: constants.COPYFILE_FICLONE_FORCE,
-        preserveTimestamps: true,
-    });
-}
-async function copyCloneMetadata(sourceStats, destination) {
-    await chmod(destination, Number(sourceStats.mode) & 0o7777);
-    await utimes(destination, sourceStats.atime, sourceStats.mtime);
-}
-async function reserveDestination(destination) {
-    try {
-        await mkdir(destination);
-    }
-    catch (error) {
-        if (isAlreadyExistsError(error)) {
-            throw new CloneDestinationExistsError(destination);
-        }
-        throw error;
-    }
-    const reservationPath = join(destination, `.gji-clone-reservation-${randomUUID()}`);
-    try {
-        await writeFile(reservationPath, "gji clone reservation\n", {
-            flag: "wx",
-        });
-        return await inspectOwnedCloneEntry(reservationPath, "file");
-    }
-    catch (error) {
-        await rmdir(destination).catch(() => undefined);
-        throw error;
-    }
-}
-async function cleanupReservedDestination(destination, reservation, publishedEntries) {
-    for (const entry of [...publishedEntries, reservation].reverse()) {
-        await removeOwnedCloneEntry(entry);
-    }
-    await rmdir(destination).catch(() => undefined);
-}
-async function inspectOwnedCloneEntry(path, kind) {
-    const stats = await lstat(path, { bigint: true });
-    return { dev: stats.dev, ino: stats.ino, kind, path };
-}
-async function removeOwnedCloneEntry(entry) {
-    try {
-        const current = await lstat(entry.path, { bigint: true });
-        if (current.dev !== entry.dev || current.ino !== entry.ino)
-            return;
-        if (entry.kind === "directory")
-            await rmdir(entry.path);
-        else
-            await unlink(entry.path);
-    }
-    catch {
-        // Missing, replaced, or non-empty entries are no longer exclusively ours.
-    }
-}
-async function destinationExists(path) {
-    try {
-        await lstat(path);
-        return true;
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return false;
-        throw error;
-    }
-}
-function startLockHeartbeat(lock) {
-    const timer = setInterval(() => {
-        void refreshCloneLock(lock);
-    }, CLONE_LOCK_TTL_MS / 3);
-    timer.unref?.();
-    return () => clearInterval(timer);
-}
-async function refreshCloneLock(lock) {
-    try {
-        const now = new Date();
-        await utimes(lock.markerPath, now, now);
-    }
-    catch {
-        // A missing marker means this owner was already fenced out as stale.
-    }
-}
-async function releaseCloneLock(lock) {
-    const releaseGuard = await acquireCloneLockGuard(lock.lockPath, lock.lockPath);
-    try {
-        await releaseCloneLockWithGuard(lock);
-    }
-    finally {
-        await releaseGuard();
-    }
-}
-async function releaseCloneLockWithGuard(lock) {
-    try {
-        await unlink(join(lock.lockPath, lock.token));
-    }
-    catch (error) {
-        if (!isNotFoundError(error))
-            throw error;
-    }
-    try {
-        await rmdir(lock.lockPath);
-    }
-    catch (error) {
-        const code = "code" in error
-            ? error.code
-            : undefined;
-        if (!isNotFoundError(error) && code !== "ENOTEMPTY" && code !== "EEXIST") {
-            throw error;
-        }
-    }
-}
-function isUnsupportedCloneError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const code = "code" in error ? error.code : "";
-    if (["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EXDEV"].includes(code ?? "")) {
-        return true;
-    }
-    return /reflink|unsupported|operation not supported|not supported|invalid cross-device|cross-device/iu.test(error.message);
-}
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/install-prompt.d.ts

@@ -1,12 +0,0 @@
-import { type GjiConfig } from "./config.js";
-import { type PackageManager } from "./package-manager.js";
-export type InstallChoice = "yes" | "no" | "always" | "never";
-export interface InstallPromptDependencies {
-    detectInstallPackageManager?: (root: string) => Promise<PackageManager | null>;
-    promptForInstallChoice?: (pm: PackageManager) => Promise<InstallChoice | null>;
-    runInstallCommand?: (command: string, cwd: string, stderr: (chunk: string) => void) => Promise<void>;
-    writeConfigKey?: (root: string, key: string, value: unknown) => Promise<void>;
-    writeGlobalRepoConfigKey?: (repoRoot: string, key: string, value: unknown) => Promise<void>;
-}
-export declare function maybeRunInstallPrompt(worktreePath: string, repoRoot: string, config: GjiConfig, stderr: (chunk: string) => void, dependencies?: InstallPromptDependencies, nonInteractive?: boolean): Promise<void>;
-export declare const runInstallCommand: import("./command-runner.js").CommandRunner;