@loomhelix/deptrail 0.1.0

package/dist/actions/action-service.js

@@ -0,0 +1,268 @@
+import path from 'node:path';
+import { findNode } from "../query/lookup.js";
+import { ActionError } from "./action-error.js";
+import { applyJob, checkPreviewSources, checkWrittenFiles, collectJob, currentPreview, currentRevert, previewJob, revertJob } from "./action-jobs.js";
+import { SCANNING_REASON, createAvailability } from "./availability.js";
+import { createChangeSets } from "./change-sets.js";
+import { createJobRegistry } from "./job-registry.js";
+import { actionsOfNode, kindFilterOf, requestedItem } from "./node-actions.js";
+import { REPOSITORY_ROOT_ID } from "./labels.js";
+import { pathExists, rootDirOf } from "./root-files.js";
+import { removeActionSandboxes } from "./sandbox.js";
+import { sharesWorkspacePackage } from "./shared-packages.js";
+export { ActionError };
+const EMPTY_CHANGE_SET = 'There are no changes to preview';
+const NO_PREVIEW = 'No preview';
+const NOT_CANCELABLE = 'This job cannot be canceled now';
+const NODE_MODULES = 'node_modules';
+const WRITING_KINDS = ['apply', 'revert'];
+const WITHOUT_LOG_LINES = Number.MAX_SAFE_INTEGER;
+function unknownJob(jobId) {
+    return new ActionError(404, `Unknown job ${jobId}`);
+}
+function summaryJob(job) {
+    return { id: job.id, kind: job.kind, state: job.state, ...(job.phase === undefined ? {} : { phase: job.phase }) };
+}
+function revertSummary(record) {
+    const sharedRoots = record.sharedRoots ?? [];
+    return { files: [...record.files.hashes.keys()], itemCount: record.items.length, ...(sharedRoots.length > 0 ? { sharedRoots } : {}) };
+}
+function isCancellable(job) {
+    if (job.state !== 'running')
+        return false;
+    return job.kind === 'preview' || (job.kind === 'apply' && job.phase === 'installing');
+}
+export function createActionService(options) {
+    const { session } = options;
+    const jobs = createJobRegistry(options.secrets);
+    const availability = createAvailability(options);
+    const changeSets = createChangeSets((rootId) => session.root(rootId));
+    const deps = { options, changes: changeSets };
+    const jobRoots = new Set();
+    const activeRuns = new Set();
+    let closed = false;
+    function requireRoot(rootId) {
+        const root = session.root(rootId);
+        if (root === undefined)
+            throw new ActionError(404, `Unknown root ${rootId}`);
+        return root;
+    }
+    function requireAvailable(root) {
+        const check = availability.check(root);
+        if ('reason' in check)
+            throw new ActionError(409, check.reason);
+        return check.manager;
+    }
+    async function availableRoot(rootId) {
+        const root = requireRoot(rootId);
+        await availability.probe(root);
+        return { root, manager: requireAvailable(root) };
+    }
+    function requireIdle(rootId) {
+        if (jobs.running(rootId) !== undefined)
+            throw new ActionError(409, `A job is already running for ${rootId}`);
+    }
+    function requireNoSharedWrite(root) {
+        for (const other of session.scan.roots) {
+            if (!sharesWorkspacePackage(root, other))
+                continue;
+            const running = jobs.running(other.id);
+            if (running === undefined || !WRITING_KINDS.includes(running.kind))
+                continue;
+            throw new ActionError(409, `An apply or revert is running in ${other.id === REPOSITORY_ROOT_ID ? 'the repository root' : other.id}, which shares workspace packages with this root`);
+        }
+    }
+    function launch(rootId, kind, run) {
+        jobRoots.add(rootId);
+        return jobs.start(rootId, kind, (context) => {
+            const running = run(context);
+            activeRuns.add(running);
+            const forget = () => {
+                activeRuns.delete(running);
+            };
+            running.then(forget, forget);
+            return running;
+        });
+    }
+    function nodeOf(root, nodeId) {
+        const node = findNode(root, nodeId);
+        if (node === undefined)
+            throw new ActionError(404, `Unknown node ${nodeId}`);
+        return node;
+    }
+    async function requestedChange(rootId, request) {
+        const { root, manager } = await availableRoot(rootId);
+        const node = nodeOf(root, request.nodeId);
+        const kinds = kindFilterOf(request.kinds);
+        const actions = await actionsOfNode({ repoPath: options.repoPath, enrichment: options.enrichment, root, manager, kinds }, node);
+        return requestedItem(root, node, actions, request);
+    }
+    return {
+        track(roots) {
+            if (closed)
+                return;
+            for (const root of roots)
+                void availability.retryFailedProbe(root);
+        },
+        summary(root) {
+            const check = availability.check(root);
+            const changes = changeSets.of(root.id);
+            const job = jobs.latest(root.id);
+            return {
+                available: !('reason' in check),
+                ...('reason' in check ? { reason: check.reason } : {}),
+                changeCount: changes.items.length,
+                ...(job === undefined ? {} : { job: summaryJob(job) }),
+                revertable: changes.revert !== undefined,
+            };
+        },
+        isBusy(rootId) {
+            return jobs.running(rootId) !== undefined;
+        },
+        anyBusy() {
+            return [...jobRoots].some((rootId) => jobs.running(rootId) !== undefined);
+        },
+        async nodeActions(rootId, nodeId, kinds) {
+            const root = requireRoot(rootId);
+            await availability.probe(root);
+            const check = availability.check(root);
+            if ('reason' in check)
+                return { unavailable: check.reason };
+            return actionsOfNode({ repoPath: options.repoPath, enrichment: options.enrichment, root, manager: check.manager, kinds }, nodeOf(root, nodeId));
+        },
+        async changes(rootId) {
+            const root = requireRoot(rootId);
+            void availability.probe(root);
+            const installByDefault = await pathExists(path.join(rootDirOf(options.repoPath, root), NODE_MODULES));
+            const changes = changeSets.of(rootId);
+            const preview = changeSets.preview(rootId);
+            const job = jobs.latest(rootId);
+            return {
+                items: [...changes.items],
+                ...(preview === undefined ? {} : { preview }),
+                ...(job === undefined ? {} : { job }),
+                revertable: changes.revert !== undefined,
+                ...(changes.revert === undefined ? {} : { revert: revertSummary(changes.revert) }),
+                installByDefault,
+            };
+        },
+        async addChange(rootId, request) {
+            return changeSets.add(rootId, await requestedChange(rootId, request));
+        },
+        async replaceChange(rootId, itemId, request) {
+            return changeSets.replace(rootId, itemId, await requestedChange(rootId, request));
+        },
+        removeChange(rootId, itemId) {
+            requireRoot(rootId);
+            changeSets.remove(rootId, itemId);
+        },
+        clearChanges(rootId) {
+            requireRoot(rootId);
+            changeSets.clear(rootId);
+        },
+        restoreCleared(rootId) {
+            requireRoot(rootId);
+            return changeSets.restoreCleared(rootId);
+        },
+        startCollect(rootId, kinds) {
+            const root = requireRoot(rootId);
+            const manager = requireAvailable(root);
+            requireIdle(rootId);
+            return launch(rootId, 'collect', collectJob(deps, { root, manager, kinds }));
+        },
+        startPreview(rootId) {
+            const root = requireRoot(rootId);
+            const manager = requireAvailable(root);
+            requireIdle(rootId);
+            const changes = changeSets.of(rootId);
+            if (changes.items.length === 0)
+                throw new ActionError(409, EMPTY_CHANGE_SET);
+            return launch(rootId, 'preview', previewJob(deps, { root, manager, items: [...changes.items], changeRevision: changes.revision }));
+        },
+        previewFileDiff(rootId, index) {
+            requireRoot(rootId);
+            const record = changeSets.of(rootId).preview;
+            if (record === undefined)
+                throw new ActionError(404, NO_PREVIEW);
+            const file = record.preview.files[index];
+            if (file === undefined)
+                throw new ActionError(404, `Unknown file ${index}`);
+            return file.path === record.lockfile ? { ...record.lockfileDiff } : { diff: file.diff ?? '', truncated: false };
+        },
+        async startApply(rootId, previewId, install) {
+            const { root, manager } = await availableRoot(rootId);
+            requireIdle(rootId);
+            requireNoSharedWrite(root);
+            await checkPreviewSources(currentPreview(changeSets, rootId, previewId));
+            requireIdle(rootId);
+            requireNoSharedWrite(root);
+            const record = currentPreview(changeSets, rootId, previewId);
+            return launch(rootId, 'apply', applyJob(deps, { record, manager, install }));
+        },
+        async startRevert(rootId) {
+            const root = requireRoot(rootId);
+            if (root.status === 'scanning')
+                throw new ActionError(409, SCANNING_REASON);
+            requireIdle(rootId);
+            requireNoSharedWrite(root);
+            await checkWrittenFiles(currentRevert(changeSets, rootId));
+            requireIdle(rootId);
+            requireNoSharedWrite(root);
+            return launch(rootId, 'revert', revertJob(deps, rootId, currentRevert(changeSets, rootId)));
+        },
+        job(jobId, since) {
+            const job = jobs.get(jobId, since);
+            if (job === undefined)
+                throw unknownJob(jobId);
+            return job;
+        },
+        cancelJob(jobId) {
+            const job = jobs.get(jobId, WITHOUT_LOG_LINES);
+            if (job === undefined)
+                throw unknownJob(jobId);
+            if (!isCancellable(job))
+                throw new ActionError(409, NOT_CANCELABLE);
+            jobs.cancel(jobId);
+        },
+        async close() {
+            closed = true;
+            jobs.cancelAll();
+            options.runner.killRunning();
+            await Promise.allSettled([...activeRuns]);
+            await availability.settled();
+            await removeActionSandboxes();
+        },
+    };
+}
+export function disabledActions(reason) {
+    const refuse = () => {
+        throw new ActionError(409, reason);
+    };
+    return {
+        track() { },
+        summary: () => ({ available: false, reason, changeCount: 0, revertable: false }),
+        isBusy: () => false,
+        anyBusy: () => false,
+        nodeActions: async () => ({ unavailable: reason }),
+        changes: async () => ({ items: [], revertable: false, installByDefault: false }),
+        addChange: async () => refuse(),
+        replaceChange: async () => refuse(),
+        removeChange: refuse,
+        clearChanges: refuse,
+        restoreCleared: refuse,
+        startCollect: refuse,
+        startPreview: refuse,
+        previewFileDiff: () => {
+            throw new ActionError(404, NO_PREVIEW);
+        },
+        startApply: async () => refuse(),
+        startRevert: async () => refuse(),
+        job: (jobId) => {
+            throw unknownJob(jobId);
+        },
+        cancelJob: (jobId) => {
+            throw unknownJob(jobId);
+        },
+        close: async () => { },
+    };
+}

package/dist/actions/apply.js

@@ -0,0 +1,120 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, rename, rm, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { messageOf } from "../scan/build-root.js";
+import { OutsideScopeError, hashSources, leavesRoot, resolveInScope, sha256Hex } from "./file-scope.js";
+export class RevertConflictError extends Error {
+    paths;
+    constructor(paths) {
+        super(`Files changed since deptrail wrote them: ${paths.join(', ')}`);
+        this.paths = paths;
+    }
+}
+export class PartialWriteError extends Error {
+    unrestored;
+    constructor(message, unrestored) {
+        super(message);
+        this.name = 'PartialWriteError';
+        this.unrestored = unrestored;
+    }
+}
+const NEW_FILE_MODE = 0o644;
+function isMissing(failure) {
+    return failure.code === 'ENOENT';
+}
+export async function changedSources(scope, sources) {
+    const current = await hashSources(scope, [...sources.keys()]);
+    return [...sources].filter(([relative, hash]) => current.get(relative) !== hash).map(([relative]) => relative);
+}
+async function existingMode(target) {
+    try {
+        return (await stat(target)).mode & 0o7777;
+    }
+    catch (failure) {
+        if (isMissing(failure))
+            return NEW_FILE_MODE;
+        throw failure;
+    }
+}
+async function replaceFile(target, text) {
+    const mode = await existingMode(target);
+    const temporary = path.join(path.dirname(target), `${path.basename(target)}.deptrail-${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, text, { mode });
+        await chmod(temporary, mode);
+        await rename(temporary, target);
+    }
+    catch (failure) {
+        await rm(temporary, { force: true });
+        throw failure;
+    }
+}
+async function restoreFile(target, original) {
+    if (original === null)
+        await rm(target, { force: true });
+    else
+        await replaceFile(target, original);
+}
+function partialWriteMessage(failedPath, failure, unrestored) {
+    return `could not write ${failedPath}: ${messageOf(failure)}; could not restore ${unrestored.join(', ')}`;
+}
+function requireOutsideOriginals(paths, originals) {
+    for (const relative of paths) {
+        if (leavesRoot(relative) && (originals.get(relative) ?? null) === null) {
+            throw new OutsideScopeError(`${relative} does not exist; deptrail never creates a file outside the root directory`);
+        }
+    }
+}
+function writeOrder(paths, lockfile) {
+    const all = [...paths];
+    return [...all.filter((relative) => relative !== lockfile).sort(), ...all.filter((relative) => relative === lockfile)];
+}
+export async function writePreviewFiles(scope, written, lockfile, originals) {
+    const order = writeOrder(written.keys(), lockfile);
+    requireOutsideOriginals(order, originals);
+    const targets = new Map();
+    for (const relative of order)
+        targets.set(relative, await resolveInScope(scope, relative));
+    const done = [];
+    let writing;
+    try {
+        for (const relative of order) {
+            writing = relative;
+            await replaceFile(targets.get(relative), written.get(relative));
+            done.push(relative);
+        }
+    }
+    catch (failure) {
+        const failedRestores = new Map();
+        for (const relative of [...done].reverse()) {
+            const original = originals.get(relative) ?? null;
+            await restoreFile(targets.get(relative), original).catch(() => failedRestores.set(relative, original));
+        }
+        if (failedRestores.size === 0)
+            throw failure;
+        const unrestoredPaths = done.filter((relative) => failedRestores.has(relative));
+        const unrestored = {
+            originals: new Map(unrestoredPaths.map((relative) => [relative, failedRestores.get(relative) ?? null])),
+            hashes: new Map(unrestoredPaths.map((relative) => [relative, sha256Hex(written.get(relative))])),
+        };
+        throw new PartialWriteError(partialWriteMessage(writing, failure, unrestoredPaths), unrestored);
+    }
+    return {
+        originals: new Map(originals),
+        hashes: new Map(order.map((relative) => [relative, sha256Hex(written.get(relative))])),
+    };
+}
+export async function changedSinceWrite(scope, files) {
+    const current = await hashSources(scope, [...files.hashes.keys()]);
+    return [...files.hashes].filter(([relative, hash]) => current.get(relative) !== hash).map(([relative]) => relative);
+}
+export async function revertWrittenFiles(scope, files) {
+    const targets = new Map();
+    for (const relative of files.hashes.keys())
+        targets.set(relative, await resolveInScope(scope, relative));
+    const conflicts = await changedSinceWrite(scope, files);
+    if (conflicts.length > 0)
+        throw new RevertConflictError(conflicts);
+    for (const [relative, target] of targets)
+        await restoreFile(target, files.originals.get(relative) ?? null);
+}

package/dist/actions/availability.js

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import { outsideImporters } from "./file-scope.js";
+import { probeManager } from "./recipes.js";
+export const SCANNING_REASON = 'Waiting for the scan';
+const FAILED_REASON = 'The root failed to scan';
+const LOCKFILE_REASON = 'Actions require a pnpm or npm lockfile';
+const OFFLINE_REASON = 'Actions are unavailable with --offline';
+function managerNameOf(root) {
+    return root.manager === 'pnpm' || root.manager === 'npm' ? root.manager : undefined;
+}
+function outsideImporterReason(problem) {
+    if (problem.kind === 'outside-repository')
+        return `Actions do not support workspace packages outside the repository (${problem.path})`;
+    if (problem.kind === 'npm')
+        return `Actions do not support workspace packages outside the root (${problem.path})`;
+    return `The lockfile lists ${problem.path}, which pnpm-workspace.yaml does not declare`;
+}
+function blockingReason(root, offline) {
+    if (root.status === 'scanning')
+        return SCANNING_REASON;
+    if (root.status === 'failed')
+        return FAILED_REASON;
+    if (root.source !== 'lockfile' || managerNameOf(root) === undefined)
+        return LOCKFILE_REASON;
+    if (offline)
+        return OFFLINE_REASON;
+    const { problem } = outsideImporters(root);
+    return problem === undefined ? undefined : outsideImporterReason(problem);
+}
+function probeKey(root, manager) {
+    return `${manager}\0${root.path}`;
+}
+export function createAvailability(options) {
+    const probes = new Map();
+    function startProbe(root, manager) {
+        const probe = { current: { state: 'pending' }, done: Promise.resolve() };
+        const cwd = path.join(options.repoPath, root.path);
+        probe.done = probeManager(options.runner, manager, cwd, options.env, options.secrets).then((result) => {
+            probe.current = result.ok ? { state: 'ok', version: result.version } : { state: 'failed', reason: result.reason };
+        });
+        return probe;
+    }
+    function probe(root) {
+        const manager = managerNameOf(root);
+        if (manager === undefined || blockingReason(root, options.offline) !== undefined)
+            return Promise.resolve();
+        const key = probeKey(root, manager);
+        let existing = probes.get(key);
+        if (existing === undefined) {
+            existing = startProbe(root, manager);
+            probes.set(key, existing);
+        }
+        return existing.done;
+    }
+    return {
+        probe,
+        retryFailedProbe(root) {
+            const manager = managerNameOf(root);
+            if (manager !== undefined && probes.get(probeKey(root, manager))?.current.state === 'failed')
+                probes.delete(probeKey(root, manager));
+            return probe(root);
+        },
+        check(root) {
+            const manager = managerNameOf(root);
+            const blocking = blockingReason(root, options.offline);
+            if (manager === undefined || blocking !== undefined)
+                return { reason: blocking ?? LOCKFILE_REASON };
+            const current = probes.get(probeKey(root, manager))?.current;
+            if (current === undefined || current.state === 'pending')
+                return { reason: `Checking ${manager}…` };
+            if (current.state === 'failed')
+                return { reason: current.reason };
+            return { manager: { name: manager, version: current.version } };
+        },
+        async settled() {
+            await Promise.all([...probes.values()].map((probe) => probe.done));
+        },
+    };
+}

package/dist/actions/change-sets.js

@@ -0,0 +1,117 @@
+import { ActionError } from "./action-error.js";
+import { findConflict, sameGoal } from "./edit-plan.js";
+import { goalText, rootLabel } from "./labels.js";
+function unknownChange(itemId) {
+    return new ActionError(404, `Unknown change ${itemId}`);
+}
+function rejectionOf(rootId, items, item) {
+    const duplicate = items.find((existing) => sameGoal(existing.goal, item.goal));
+    if (duplicate !== undefined)
+        return new ActionError(409, `${goalText(duplicate.goal)} is already in the changes of ${rootLabel(rootId)}`);
+    const conflict = findConflict(items, item);
+    if (conflict !== undefined)
+        return new ActionError(409, `Conflicts with "${goalText(conflict.item.goal)}": ${conflict.reason}`, conflict.item.id);
+    return undefined;
+}
+export function createChangeSets(currentGraph) {
+    const roots = new Map();
+    function of(rootId) {
+        let changes = roots.get(rootId);
+        if (changes === undefined) {
+            changes = { items: [], revision: 0, cleared: [] };
+            roots.set(rootId, changes);
+        }
+        return changes;
+    }
+    function edited(changes, items) {
+        changes.items = items;
+        changes.revision++;
+    }
+    function editedByUser(changes, items) {
+        edited(changes, items);
+        changes.cleared = [];
+    }
+    function restore(rootId, items) {
+        const changes = of(rootId);
+        const kept = [...changes.items];
+        const skipped = [];
+        for (const item of items) {
+            const rejection = rejectionOf(rootId, kept, item);
+            if (rejection === undefined)
+                kept.push(item);
+            else
+                skipped.push({ name: goalText(item.goal), reason: rejection.message });
+        }
+        const restored = kept.length - changes.items.length;
+        if (restored > 0)
+            edited(changes, kept);
+        return { restored, skipped };
+    }
+    function isStale(rootId, record) {
+        return of(rootId).revision !== record.changeRevision || currentGraph(rootId) !== record.graph;
+    }
+    return {
+        of,
+        add(rootId, item) {
+            const changes = of(rootId);
+            const rejection = rejectionOf(rootId, changes.items, item);
+            if (rejection !== undefined)
+                throw rejection;
+            editedByUser(changes, [...changes.items, item]);
+            return item;
+        },
+        remove(rootId, itemId) {
+            const changes = of(rootId);
+            if (!changes.items.some((item) => item.id === itemId))
+                throw unknownChange(itemId);
+            editedByUser(changes, changes.items.filter((item) => item.id !== itemId));
+        },
+        replace(rootId, itemId, item) {
+            const changes = of(rootId);
+            if (!changes.items.some((existing) => existing.id === itemId))
+                throw unknownChange(itemId);
+            const rejection = rejectionOf(rootId, changes.items.filter((existing) => existing.id !== itemId), item);
+            if (rejection !== undefined)
+                throw rejection;
+            editedByUser(changes, changes.items.map((existing) => (existing.id === itemId ? item : existing)));
+            return item;
+        },
+        clear(rootId) {
+            const changes = of(rootId);
+            changes.cleared = changes.items;
+            edited(changes, []);
+        },
+        restore,
+        restoreCleared(rootId) {
+            const changes = of(rootId);
+            const cleared = changes.cleared;
+            changes.cleared = [];
+            return restore(rootId, cleared);
+        },
+        storePreview(rootId, record) {
+            of(rootId).preview = record;
+        },
+        storeRevert(rootId, revert) {
+            of(rootId).revert = revert;
+        },
+        applied(rootId, record, written) {
+            const changes = of(rootId);
+            const previewed = new Set(record.itemIds);
+            const revert = { ...written, items: changes.items.filter((item) => previewed.has(item.id)), sharedRoots: record.sharedRoots };
+            edited(changes, changes.items.filter((item) => !previewed.has(item.id)));
+            changes.preview = undefined;
+            changes.revert = revert;
+            return revert;
+        },
+        reverted(rootId, record) {
+            const changes = of(rootId);
+            if (changes.revert === record)
+                changes.revert = undefined;
+        },
+        isStale,
+        preview(rootId) {
+            const record = roots.get(rootId)?.preview;
+            return record === undefined ? undefined : { ...record.preview, stale: isStale(rootId, record) };
+        },
+    };
+}