@loomhelix/deptrail 0.1.0

package/dist/scan/scan-session.js

@@ -0,0 +1,127 @@
+import { readRootConfig } from "../config/root-config.js";
+import { findRoots } from "../discovery/find-roots.js";
+import { buildGlobalIndex } from "../graph/global-index.js";
+import { buildRoot, failedRootGraph, messageOf } from "./build-root.js";
+import { cacheKeyOf } from "./scan-cache.js";
+function scanningPlaceholder(root) {
+    return {
+        id: root.id,
+        path: root.path,
+        manager: root.manager,
+        source: root.lockfile ? 'lockfile' : 'manifest-only',
+        status: 'scanning',
+        importers: [],
+        packages: new Map(),
+        warnings: [],
+    };
+}
+export async function startScanSession(options) {
+    const { repoPath, reader, runner, cache, env, userNpmrc, onRootPublished } = options;
+    const allowInstalled = options.useInstalled ?? true;
+    let run = await discover();
+    let index = new Map();
+    let ready = Promise.resolve();
+    async function discover() {
+        const descriptors = await findRoots(reader);
+        const scan = {
+            repoPath,
+            roots: descriptors.map(scanningPlaceholder),
+            scannedAt: new Date().toISOString(),
+            ...(options.skippedSubmodules === undefined ? {} : { skippedSubmodules: [...options.skippedSubmodules] }),
+        };
+        return { scan, descriptors, generations: new Map() };
+    }
+    async function buildWithCache(descriptor) {
+        const lockfileText = descriptor.lockfile && cache ? await reader.readText(descriptor.lockfile) : null;
+        const key = lockfileText === null ? null : cacheKeyOf(repoPath, descriptor.path, lockfileText);
+        const cached = key && cache ? await cache.get(key) : null;
+        if (cached)
+            return { ...cached, id: descriptor.id, path: descriptor.path, manager: descriptor.manager };
+        const graph = await buildRoot(descriptor, { reader, runner, allowResolve: false, allowInstalled });
+        if (key && cache && graph.source === 'lockfile' && graph.status === 'ready')
+            await cache.set(key, graph).catch(() => { });
+        return graph;
+    }
+    async function withConfig(descriptor, graph) {
+        if (graph.status === 'failed')
+            return graph;
+        graph.config = await readRootConfig(reader, descriptor.path, { userNpmrc, env, expandProjectVariables: options.expandNpmrcVariables ?? true });
+        graph.warnings = [...graph.warnings, ...graph.config.warnings];
+        return graph;
+    }
+    function descriptorOf(target, rootId) {
+        const descriptor = target.descriptors.find((candidate) => candidate.id === rootId);
+        if (!descriptor)
+            throw new Error(`Unknown root ${rootId}`);
+        return descriptor;
+    }
+    function beginBuild(target, descriptor) {
+        const generation = (target.generations.get(descriptor.id) ?? 0) + 1;
+        target.generations.set(descriptor.id, generation);
+        return generation;
+    }
+    function publish(target, descriptor, generation, graph) {
+        if (target !== run || target.generations.get(descriptor.id) !== generation)
+            return;
+        const position = target.scan.roots.findIndex((candidate) => candidate.id === descriptor.id);
+        if (position === -1)
+            return;
+        target.scan.roots[position] = graph;
+        index = buildGlobalIndex(target.scan.roots);
+        onRootPublished?.(target.scan.roots);
+    }
+    async function runBuild(target, descriptor, generation, build) {
+        let graph;
+        try {
+            graph = await withConfig(descriptor, await build());
+        }
+        catch (failure) {
+            graph = failedRootGraph(descriptor, messageOf(failure));
+        }
+        publish(target, descriptor, generation, graph);
+    }
+    function buildAll(target) {
+        const builds = target.descriptors.map((descriptor) => {
+            const generation = beginBuild(target, descriptor);
+            return runBuild(target, descriptor, generation, () => buildWithCache(descriptor));
+        });
+        return Promise.all(builds).then(() => undefined);
+    }
+    async function startRun() {
+        index = new Map();
+        ready = buildAll(run);
+        await ready;
+    }
+    ready = buildAll(run);
+    return {
+        get scan() {
+            return run.scan;
+        },
+        get index() {
+            return index;
+        },
+        get ready() {
+            return ready;
+        },
+        root(id) {
+            return run.scan.roots.find((candidate) => candidate.id === id);
+        },
+        async resolve(rootId) {
+            const target = run;
+            const descriptor = descriptorOf(target, rootId);
+            const generation = beginBuild(target, descriptor);
+            publish(target, descriptor, generation, scanningPlaceholder(descriptor));
+            await runBuild(target, descriptor, generation, () => buildRoot(descriptor, { reader, runner, allowResolve: true, allowInstalled }));
+        },
+        async refreshRoot(rootId) {
+            const target = run;
+            const descriptor = descriptorOf(target, rootId);
+            const generation = beginBuild(target, descriptor);
+            await runBuild(target, descriptor, generation, () => buildWithCache(descriptor));
+        },
+        async rescan() {
+            run = await discover();
+            await startRun();
+        },
+    };
+}

package/dist/scan/source-registry.js

@@ -0,0 +1,55 @@
+export const COMMIT_SOURCE_LIMIT = 4;
+export function createSourceRegistry(options) {
+    const { working } = options;
+    const limit = options.limit ?? COMMIT_SOURCE_LIMIT;
+    const open = new Map();
+    const opening = new Map();
+    function markUsed(source) {
+        open.delete(source.commit);
+        open.set(source.commit, source);
+        return source;
+    }
+    function allRoots() {
+        return [...working.scan.roots, ...[...open.values()].flatMap((source) => source.session.scan.roots)];
+    }
+    function rootsChanged() {
+        options.onRootsChanged(allRoots());
+    }
+    function dropBeyondLimit() {
+        for (const commit of open.keys()) {
+            if (open.size <= limit)
+                return;
+            open.delete(commit);
+        }
+    }
+    async function startOpening(commit) {
+        const source = markUsed({ commit, session: await options.openSession(commit) });
+        dropBeyondLimit();
+        rootsChanged();
+        return source;
+    }
+    return {
+        working,
+        openCommit(commit) {
+            const known = open.get(commit);
+            if (known !== undefined)
+                return Promise.resolve(markUsed(known));
+            let pending = opening.get(commit);
+            if (pending === undefined) {
+                pending = startOpening(commit).finally(() => opening.delete(commit));
+                opening.set(commit, pending);
+            }
+            return pending;
+        },
+        commit(commit) {
+            const known = open.get(commit);
+            return known === undefined ? undefined : markUsed(known);
+        },
+        allRoots,
+        rootsChanged,
+        close() {
+            open.clear();
+            opening.clear();
+        },
+    };
+}

package/dist/server/auth.js

@@ -0,0 +1,45 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+const TOKEN_COOKIE_PREFIX = 'deptrail_token_';
+export const TOKEN_HEADER = 'x-deptrail-token';
+export function generateToken() {
+    return randomBytes(32).toString('hex');
+}
+export function isAllowedHost(hostHeader, port) {
+    return hostHeader === `127.0.0.1:${port}` || hostHeader === `localhost:${port}`;
+}
+export function isAllowedOrigin(originHeader, port) {
+    return originHeader === `http://127.0.0.1:${port}` || originHeader === `http://localhost:${port}`;
+}
+export function tokensMatch(expected, candidate) {
+    if (candidate === undefined)
+        return false;
+    const expectedBytes = Buffer.from(expected);
+    const candidateBytes = Buffer.from(candidate);
+    if (expectedBytes.length !== candidateBytes.length)
+        return false;
+    return timingSafeEqual(expectedBytes, candidateBytes);
+}
+function cookieValue(cookieHeader, name) {
+    if (!cookieHeader)
+        return undefined;
+    for (const part of cookieHeader.split(';')) {
+        const separator = part.indexOf('=');
+        if (separator === -1)
+            continue;
+        if (part.slice(0, separator).trim() === name)
+            return part.slice(separator + 1).trim();
+    }
+    return undefined;
+}
+export function tokenCookieName(port) {
+    return `${TOKEN_COOKIE_PREFIX}${port}`;
+}
+export function requestToken(request, port) {
+    const header = request.headers[TOKEN_HEADER];
+    if (typeof header === 'string')
+        return header;
+    return cookieValue(request.headers.cookie, tokenCookieName(port));
+}
+export function sessionCookie(token, port) {
+    return `${tokenCookieName(port)}=${token}; HttpOnly; SameSite=Strict; Path=/`;
+}

package/dist/server/branches.js

@@ -0,0 +1,105 @@
+import { isObjectId } from "../git/git-commands.js";
+import { isGitRepository } from "../git/git-repository.js";
+import { WORKING_KEY } from "./source-key.js";
+export { WORKING_KEY };
+export const COMMIT_ACTIONS_REASON = 'Actions apply to the working tree. Switch to it to change files.';
+export const COMMIT_RESOLVE_REASON = "Resolve versions runs the package manager with the branch's own configuration, so it is available only in the working tree.";
+export class BranchError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = 'BranchError';
+        this.status = status;
+    }
+}
+const HEAD_REF = 'HEAD';
+const REF_PREFIX = 'refs/';
+const OPTION_PREFIX = '-';
+function messageOf(failure) {
+    return failure instanceof Error ? failure.message : String(failure);
+}
+function isAcceptableRefName(ref) {
+    return !ref.startsWith(OPTION_PREFIX) && (ref === HEAD_REF || ref.startsWith(REF_PREFIX));
+}
+export function createBranches(git, sources) {
+    function requireRepository() {
+        if (!isGitRepository(git))
+            throw new BranchError(409, git.unavailable);
+        return git;
+    }
+    async function headCommit(repository) {
+        const head = await repository.head();
+        if (head === undefined)
+            throw new BranchError(409, 'The repository has no commits yet');
+        return head.commit;
+    }
+    async function openCommit(commit) {
+        let source;
+        try {
+            source = await sources.openCommit(commit);
+        }
+        catch (failure) {
+            throw new BranchError(409, messageOf(failure));
+        }
+        const skipped = source.session.scan.skippedSubmodules ?? [];
+        return skipped.length === 0 ? {} : { skippedSubmodules: [...skipped] };
+    }
+    async function openRef(repository, ref) {
+        if (!isAcceptableRefName(ref))
+            throw new BranchError(400, 'Invalid ref');
+        if (ref === HEAD_REF) {
+            const commit = await headCommit(repository);
+            return { key: commit, commit, ref, ...(await openCommit(commit)) };
+        }
+        const listed = (await repository.refs()).refs.find((candidate) => candidate.name === ref);
+        if (listed === undefined)
+            throw new BranchError(404, `Unknown ref ${ref}`);
+        const skipped = await openCommit(listed.commit);
+        return { key: listed.commit, commit: listed.commit, ref, committedAt: listed.committedAt, ...skipped };
+    }
+    async function commitOfKey(repository, key) {
+        if (key === WORKING_KEY)
+            return headCommit(repository);
+        if (isObjectId(key) && sources.commit(key) !== undefined)
+            return key;
+        throw new BranchError(404, `Unknown source ${key}`);
+    }
+    async function openMergeBase(repository, base, target) {
+        const baseCommit = await commitOfKey(repository, base);
+        const targetCommit = await commitOfKey(repository, target);
+        const commit = await repository.mergeBase(baseCommit, targetCommit);
+        if (commit === undefined)
+            throw new BranchError(409, 'No merge base');
+        await openCommit(commit);
+        return { key: commit, commit };
+    }
+    return {
+        async info() {
+            if (!isGitRepository(git))
+                return { available: false, reason: git.unavailable, quiet: git.quiet };
+            try {
+                const [head, listing] = await Promise.all([git.head(), git.refs()]);
+                return {
+                    available: true,
+                    ...(head === undefined ? {} : { head }),
+                    ...(listing.defaultBranch === undefined ? {} : { defaultBranch: listing.defaultBranch }),
+                    refs: listing.refs,
+                };
+            }
+            catch (failure) {
+                return { available: false, reason: messageOf(failure), quiet: false };
+            }
+        },
+        async open(request) {
+            const repository = requireRepository();
+            if ('ref' in request)
+                return openRef(repository, request.ref);
+            return openMergeBase(repository, request.mergeBase.base, request.mergeBase.target);
+        },
+        sessionOf(key) {
+            if (key === WORKING_KEY)
+                return sources.working;
+            return isObjectId(key) ? sources.commit(key)?.session : undefined;
+        },
+    };
+}

package/dist/server/error-log.js

@@ -0,0 +1,9 @@
+import { processSecrets } from "../config/secrets.js";
+const LINE_BREAKS = /\s*[\r\n]+\s*/g;
+export function createErrorLog(stream) {
+    return (context, failure) => {
+        const message = failure instanceof Error ? failure.message : String(failure);
+        const line = processSecrets.redact(`${context} failed: ${message}`).replace(LINE_BREAKS, ' ').trim();
+        stream.write(`deptrail: ${line}\n`);
+    };
+}

package/dist/server/root-segment.js

@@ -0,0 +1,13 @@
+const DOT_ROOT_SEGMENT = '~';
+export function encodeRootSegment(id) {
+    if (id === '.')
+        return DOT_ROOT_SEGMENT;
+    if (id === DOT_ROOT_SEGMENT)
+        return '%7E';
+    return encodeURIComponent(id);
+}
+export function decodeRootSegment(rawSegment) {
+    if (rawSegment === DOT_ROOT_SEGMENT)
+        return '.';
+    return decodeURIComponent(rawSegment);
+}