@ayushporwal/coja 0.0.1

package/dist/git/plumbing.js

@@ -0,0 +1,519 @@
+import { badRequest } from '../routes/http.js';
+import { assertPathspec, assertRevision, GitError, runGit, runGitGlobal, runGitStreaming, } from './run.js';
+/**
+ * Typed wrappers over git plumbing. Every function takes `repo`, a directory
+ * usable with `git -C` (the user's clone or an app-managed bare clone), and
+ * reads objects only: nothing here checks out, writes blobs to disk, or
+ * touches the user's branches. The only writes are `fetch` into the
+ * `refs/coja/*` namespace and `cloneBare` into the app data directory.
+ */
+const MiB = 1024 * 1024;
+/** `gh` supplies the token for https fetches at call time; nothing is written to disk. */
+export const GH_CREDENTIAL_HELPER = '!gh auth git-credential';
+/** git considers a file binary when its first 8000 bytes contain a NUL. */
+const BINARY_PROBE_BYTES = 8000;
+/** Network operations (fetch, clone) are killed after this long. */
+export const DEFAULT_NETWORK_TIMEOUT_MS = 15 * 60 * 1000;
+// ---------------------------------------------------------------------------
+// Toolchain
+// ---------------------------------------------------------------------------
+/** Oldest supported git: `fetch --no-write-fetch-head`, used for every PR fetch, arrived in 2.29. */
+export const MIN_GIT_VERSION = '2.29';
+/** `[major, minor, patch]` from `git --version` output (any build suffix ignored), or null. */
+export function parseGitVersion(output) {
+    const m = /^git version (\d+)\.(\d+)(?:\.(\d+))?/.exec(output.trim());
+    if (!m)
+        return null;
+    return [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)];
+}
+/** Why `git --version` output is unacceptable, phrased for the user; null when it is fine. */
+export function gitVersionProblem(output) {
+    const version = parseGitVersion(output);
+    if (!version) {
+        return `could not understand \`git --version\` output "${output.trim()}"; coja needs git ${MIN_GIT_VERSION} or newer`;
+    }
+    const [min, ...rest] = MIN_GIT_VERSION.split('.').map(Number);
+    const [major, minor, patch] = version;
+    const tooOld = major < (min ?? 0) ||
+        (major === min && minor < (rest[0] ?? 0)) ||
+        (major === min && minor === rest[0] && patch < (rest[1] ?? 0));
+    if (tooOld) {
+        return `git ${major}.${minor}.${patch} is too old: coja needs git ${MIN_GIT_VERSION} or newer (for \`git fetch --no-write-fetch-head\`). Upgrade git and try again`;
+    }
+    return null;
+}
+/** Fail fast at startup unless the `git` on PATH is at least {@link MIN_GIT_VERSION}. */
+export async function assertGitVersion() {
+    let output;
+    try {
+        output = (await runGitGlobal(['--version'])).stdout.toString('utf8');
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new Error(`git is required but could not be run (${reason}). Install git ${MIN_GIT_VERSION} or newer and make sure it is on PATH`);
+    }
+    const problem = gitVersionProblem(output);
+    if (problem)
+        throw new Error(problem);
+}
+// ---------------------------------------------------------------------------
+// Repository facts
+// ---------------------------------------------------------------------------
+/** True when `dir` is inside a git repository (working tree or bare). */
+export async function isGitRepo(dir) {
+    return (await tryGit(dir, ['rev-parse', '--git-dir'])) !== null;
+}
+export async function isBareRepo(dir) {
+    const out = await tryGit(dir, ['rev-parse', '--is-bare-repository']);
+    return out?.trim() === 'true';
+}
+/** Absolute path of the working tree root; null for a bare repository. */
+export async function topLevel(repo) {
+    const out = await tryGit(repo, ['rev-parse', '--show-toplevel']);
+    const top = out?.trim();
+    return top ? top : null;
+}
+/** The configured URL of `remote` (as written in the config, before any insteadOf rewriting). */
+export async function remoteUrl(repo, remote = 'origin') {
+    const res = await runGit(repo, ['config', '--get', `remote.${remote}.url`], { okExitCodes: [1] });
+    if (res.exitCode !== 0)
+        return null;
+    const url = res.stdout.toString('utf8').trim();
+    return url ? url : null;
+}
+/** Resolve `ref` to a commit oid; null when it does not exist or is not a commit. */
+export async function revParse(repo, ref) {
+    assertRevision(ref);
+    const res = await runGit(repo, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], {
+        okExitCodes: [1],
+    });
+    if (res.exitCode !== 0)
+        return null;
+    const oid = res.stdout.toString('utf8').trim();
+    return oid ? oid : null;
+}
+export async function mergeBase(repo, a, b) {
+    assertRevision(a);
+    assertRevision(b);
+    const args = ['merge-base', a, b];
+    const res = await runGit(repo, args, { okExitCodes: [1] });
+    if (res.exitCode !== 0) {
+        throw new GitError(args, 1, res.stderr, `${a} and ${b} have no common ancestor`);
+    }
+    return res.stdout.toString('utf8').trim();
+}
+/**
+ * `git fetch` the given refspecs from `remote`. Callers pass explicit,
+ * namespaced destinations (`+refs/pull/1/head:refs/coja/pull/1/head`), so the
+ * user's branches and FETCH_HEAD are never written; tags and pruning are off so
+ * the fetch touches nothing beyond those refs.
+ */
+export async function fetch(repo, remote, refspecs, opts = {}) {
+    if (refspecs.length === 0)
+        throw new Error('fetch: at least one refspec is required');
+    for (const arg of [remote, ...refspecs]) {
+        if (arg.startsWith('-') || arg.length === 0)
+            throw new Error(`fetch: invalid argument ${arg}`);
+    }
+    await runGit(repo, [
+        'fetch',
+        '--no-tags',
+        '--no-prune',
+        '--no-recurse-submodules',
+        '--no-write-fetch-head',
+        '--quiet',
+        '--',
+        remote,
+        ...refspecs,
+    ], { signal: opts.signal, timeoutMs: opts.timeoutMs ?? DEFAULT_NETWORK_TIMEOUT_MS });
+}
+/**
+ * `git clone --bare` `url` into `dir` (which must not exist yet), with `gh` as
+ * the repository's credential helper — both for the clone itself and for later
+ * fetches of private repositories. No token is ever written to disk.
+ *
+ * The clone is killed after `timeoutMs` (default {@link DEFAULT_NETWORK_TIMEOUT_MS})
+ * or when `signal` aborts, and the promise settles only once git has exited,
+ * so the caller can remove the half-written directory without racing it.
+ */
+export async function cloneBare(url, dir, opts = {}) {
+    if (url.startsWith('-') || dir.startsWith('-'))
+        throw badRequest('invalid clone arguments');
+    await runGitGlobal([
+        'clone',
+        '--bare',
+        '--quiet',
+        // Reset inherited helpers so this repository authenticates through gh only.
+        '-c',
+        'credential.helper=',
+        '-c',
+        `credential.helper=${GH_CREDENTIAL_HELPER}`,
+        '--',
+        url,
+        dir,
+    ], { signal: opts.signal, timeoutMs: opts.timeoutMs ?? DEFAULT_NETWORK_TIMEOUT_MS });
+    // `clone -c` persists the values above; make sure the helper is really there.
+    const helpers = await runGit(dir, ['config', '--get-all', 'credential.helper'], {
+        okExitCodes: [1],
+    });
+    if (!helpers.stdout.toString('utf8').split('\n').includes(GH_CREDENTIAL_HELPER)) {
+        await runGit(dir, ['config', '--add', 'credential.helper', GH_CREDENTIAL_HELPER]);
+    }
+}
+/** Type and size of `<oid>:<path>` via `cat-file --batch-check`; `exists: false` when the path is absent. */
+export async function blobInfo(repo, oid, path) {
+    assertRevision(oid);
+    assertPathspec(path);
+    const res = await runGit(repo, ['cat-file', '--batch-check'], { input: `${oid}:${path}\n` });
+    const line = res.stdout.toString('utf8').split('\n')[0] ?? '';
+    const m = /^([0-9a-f]{40,64}) (blob|tree|commit|tag) (\d+)$/.exec(line);
+    if (!m)
+        return { exists: false, type: null, size: null, oid: null };
+    return { exists: true, type: m[2], size: Number(m[3]), oid: m[1] ?? null };
+}
+/** Content of the blob at `<oid>:<path>` (`git cat-file blob`). Fails with GitError when it is not a blob. */
+export async function showFile(repo, oid, path, opts = {}) {
+    assertRevision(oid);
+    assertPathspec(path);
+    const maxBytes = opts.maxBytes ?? 5 * MiB;
+    const res = await runGit(repo, ['cat-file', 'blob', `${oid}:${path}`], {
+        maxBuffer: maxBytes,
+        truncateStdout: true,
+    });
+    const buf = res.stdout;
+    const binary = buf.subarray(0, BINARY_PROBE_BYTES).includes(0);
+    let size = buf.byteLength;
+    if (res.truncated)
+        size = (await blobInfo(repo, oid, path)).size ?? size;
+    return { text: binary ? '' : buf.toString('utf8'), binary, size, truncated: res.truncated };
+}
+/**
+ * Number of lines in the blob at `<oid>:<path>`, counted while streaming
+ * `git cat-file blob` so a blob of any size costs no memory. Counts the way
+ * the UI splits text: a final line without a trailing newline counts, an empty
+ * blob has none. Fails with GitError when the object is not a blob.
+ */
+export async function countLines(repo, oid, path) {
+    assertRevision(oid);
+    assertPathspec(path);
+    const NEWLINE = 0x0a;
+    let newlines = 0;
+    let bytes = 0;
+    let lastByte = NEWLINE;
+    await runGitStreaming(repo, ['cat-file', 'blob', `${oid}:${path}`], (chunk) => {
+        if (chunk.byteLength === 0)
+            return;
+        bytes += chunk.byteLength;
+        for (let i = chunk.indexOf(NEWLINE); i !== -1; i = chunk.indexOf(NEWLINE, i + 1))
+            newlines++;
+        lastByte = chunk[chunk.byteLength - 1] ?? lastByte;
+    });
+    if (bytes === 0)
+        return 0;
+    return newlines + (lastByte === NEWLINE ? 0 : 1);
+}
+/** List a tree (`ls-tree -z -l`), recursively by default, optionally limited to `path`. */
+export async function lsTree(repo, oid, opts = {}) {
+    assertRevision(oid);
+    const args = ['--literal-pathspecs', 'ls-tree', '-z', '-l', '--full-tree'];
+    if (opts.recursive ?? true)
+        args.push('-r');
+    args.push(oid);
+    if (opts.path !== undefined)
+        args.push('--', assertPathspec(opts.path));
+    const out = (await runGit(repo, args)).stdout.toString('utf8');
+    const entries = [];
+    for (const record of out.split('\0')) {
+        if (!record)
+            continue;
+        const tab = record.indexOf('\t');
+        if (tab === -1)
+            continue;
+        const [mode, type, entryOid, size] = record.slice(0, tab).split(/\s+/);
+        if (!mode || !type || !entryOid)
+            continue;
+        if (type !== 'blob' && type !== 'tree' && type !== 'commit')
+            continue;
+        entries.push({
+            path: record.slice(tab + 1),
+            mode,
+            type,
+            oid: entryOid,
+            size: size === undefined || size === '-' ? null : Number(size),
+        });
+    }
+    return entries;
+}
+/** Search the tree at `oid` (`git grep -n -I`). Binary files are skipped; exit code 1 means no matches. */
+export async function grep(repo, oid, pattern, opts = {}) {
+    assertRevision(oid);
+    if (typeof pattern !== 'string' || pattern.length === 0)
+        throw badRequest('pattern is required');
+    const maxMatches = opts.maxMatches ?? 200;
+    const args = ['grep', '-n', '-I', '--no-color', '-z', '--full-name'];
+    if (opts.ignoreCase)
+        args.push('-i');
+    args.push(opts.fixedStrings ? '-F' : '-E');
+    // The pattern follows `-e`, so a pattern starting with `-` is never an option.
+    args.push('-e', pattern, oid, '--');
+    if (opts.pathspec !== undefined)
+        args.push(assertPathspec(opts.pathspec));
+    const res = await runGit(repo, args, {
+        okExitCodes: [1],
+        maxBuffer: 16 * MiB,
+        truncateStdout: true,
+    });
+    if (res.exitCode === 1)
+        return { matches: [], truncated: false };
+    const prefix = `${oid}:`;
+    const lines = res.stdout.toString('utf8').split('\n');
+    if (res.truncated)
+        lines.pop(); // the last line was cut mid-way
+    const matches = [];
+    let truncated = res.truncated;
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (matches.length >= maxMatches) {
+            truncated = true;
+            break;
+        }
+        // With -z: `<rev>:<path>\0<line>\0<text>`
+        const firstNul = line.indexOf('\0');
+        const secondNul = firstNul === -1 ? -1 : line.indexOf('\0', firstNul + 1);
+        if (firstNul === -1 || secondNul === -1)
+            continue;
+        const name = line.slice(0, firstNul);
+        matches.push({
+            path: name.startsWith(prefix) ? name.slice(prefix.length) : name,
+            line: Number(line.slice(firstNul + 1, secondNul)),
+            text: line.slice(secondNul + 1),
+        });
+    }
+    return { matches, truncated };
+}
+/**
+ * Unified patch between two commits (`git diff <base> <head>`), with standard
+ * `a/` `b/` prefixes regardless of the user's diff.* configuration so the UI's
+ * parser always sees canonical git output.
+ */
+export async function diff(repo, base, head, opts = {}) {
+    assertRevision(base);
+    assertRevision(head);
+    const unified = opts.unified ?? 3;
+    if (!Number.isInteger(unified) || unified < 0)
+        throw badRequest('unified must be a non-negative integer');
+    const args = [
+        '--literal-pathspecs',
+        'diff',
+        '--no-color',
+        '--no-ext-diff',
+        '--no-textconv',
+        '--no-relative',
+        '--find-renames',
+        '--src-prefix=a/',
+        '--dst-prefix=b/',
+        '--submodule=short',
+        `-U${unified}`,
+        base,
+        head,
+    ];
+    if (opts.paths && opts.paths.length > 0)
+        args.push('--', ...opts.paths.map(assertPathspec));
+    const res = await runGit(repo, args, {
+        maxBuffer: opts.maxBytes ?? 2 * MiB,
+        truncateStdout: true,
+    });
+    if (res.truncated)
+        return { patch: '', truncated: true };
+    return { patch: res.stdout.toString('utf8'), truncated: false };
+}
+const CHANGE_STATUSES = new Set(['A', 'D', 'M', 'R', 'C', 'T']);
+/** Changed files between two commits with rename detection (`diff --name-status --find-renames -z`). */
+export async function diffNameStatus(repo, base, head) {
+    assertRevision(base);
+    assertRevision(head);
+    const res = await runGit(repo, [
+        'diff',
+        '--name-status',
+        '--find-renames',
+        '-z',
+        '--no-color',
+        '--no-ext-diff',
+        '--no-relative',
+        base,
+        head,
+    ]);
+    const tokens = res.stdout.toString('utf8').split('\0');
+    const files = [];
+    for (let i = 0; i < tokens.length;) {
+        const rawStatus = tokens[i++];
+        if (!rawStatus)
+            continue;
+        const letter = rawStatus[0] ?? '';
+        // `R100`/`C075` carry a similarity score and are followed by <old>\0<new>.
+        if (letter === 'R' || letter === 'C') {
+            const previousPath = tokens[i++];
+            const path = tokens[i++];
+            if (previousPath === undefined || path === undefined)
+                break;
+            files.push({ path, previousPath, status: letter });
+            continue;
+        }
+        const path = tokens[i++];
+        if (path === undefined)
+            break;
+        files.push({ path, status: CHANGE_STATUSES.has(letter) ? letter : 'M' });
+    }
+    return files;
+}
+const LOG_FIELD = '\x1f';
+const LOG_RECORD = '\x1e';
+const LOG_FORMAT = `${['%H', '%h', '%an', '%ae', '%aI', '%s', '%b'].join('%x1f')}%x1e`;
+/** Commit history (`git log`), newest first, optionally for a range such as `base..head` and a path. */
+export async function log(repo, opts = {}) {
+    const maxCount = opts.maxCount ?? 50;
+    if (!Number.isInteger(maxCount) || maxCount <= 0)
+        throw badRequest('maxCount must be a positive integer');
+    const args = [
+        '--literal-pathspecs',
+        'log',
+        '--no-color',
+        '--no-show-signature',
+        '--date=iso-strict',
+        `--format=${LOG_FORMAT}`,
+        '-n',
+        String(maxCount),
+    ];
+    if (opts.range !== undefined)
+        args.push(assertRevision(opts.range));
+    if (opts.path !== undefined)
+        args.push('--', assertPathspec(opts.path));
+    const out = (await runGit(repo, args)).stdout.toString('utf8');
+    const entries = [];
+    for (const raw of out.split(LOG_RECORD)) {
+        const record = raw.replace(/^\n/, '');
+        if (!record)
+            continue;
+        const fields = splitN(record, LOG_FIELD, 7);
+        const [oid, abbreviatedOid, authorName, authorEmail, authoredAt, subject, body] = fields;
+        if (!oid || abbreviatedOid === undefined)
+            continue;
+        entries.push({
+            oid,
+            abbreviatedOid,
+            authorName: authorName ?? '',
+            authorEmail: authorEmail ?? '',
+            authoredAt: authoredAt ?? '',
+            subject: subject ?? '',
+            body: (body ?? '').trimEnd(),
+        });
+    }
+    return entries;
+}
+/** Split into at most `n` parts; the last part keeps any further separators. */
+function splitN(s, sep, n) {
+    const parts = [];
+    let start = 0;
+    while (parts.length < n - 1) {
+        const idx = s.indexOf(sep, start);
+        if (idx === -1)
+            break;
+        parts.push(s.slice(start, idx));
+        start = idx + sep.length;
+    }
+    parts.push(s.slice(start));
+    return parts;
+}
+/** Per-line authorship (`git blame --porcelain`), optionally limited to an inclusive line range. */
+export async function blame(repo, oid, path, opts = {}) {
+    assertRevision(oid);
+    assertPathspec(path);
+    // Literal pathspecs: `[id]` in a path is a directory name, never a glob.
+    const args = ['--literal-pathspecs', 'blame', '--porcelain'];
+    if (opts.startLine !== undefined || opts.endLine !== undefined) {
+        const start = opts.startLine ?? 1;
+        const end = opts.endLine;
+        if (!Number.isInteger(start) || start < 1)
+            throw badRequest('startLine must be a positive integer');
+        if (end !== undefined && (!Number.isInteger(end) || end < start)) {
+            throw badRequest('endLine must be an integer >= startLine');
+        }
+        args.push('-L', `${start},${end ?? ''}`);
+    }
+    args.push(oid, '--', path);
+    const out = (await runGit(repo, args)).stdout.toString('utf8');
+    return parseBlamePorcelain(out);
+}
+function parseBlamePorcelain(out) {
+    const lines = out.split('\n');
+    const commits = new Map();
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const header = lines[i];
+        if (!header) {
+            i++;
+            continue;
+        }
+        const m = /^([0-9a-f]{40,64}) \d+ (\d+)(?: \d+)?$/.exec(header);
+        if (!m?.[1] || !m[2])
+            throw new Error(`unexpected git blame output: ${header}`);
+        const sha = m[1];
+        const finalLine = Number(m[2]);
+        i++;
+        const info = commits.get(sha) ?? { author: '', authorTime: 0, authorTz: '+0000', summary: '' };
+        // Header key/value lines appear the first time a commit is seen; the content line starts with a tab.
+        while (i < lines.length && !(lines[i] ?? '').startsWith('\t')) {
+            const kv = lines[i] ?? '';
+            const sp = kv.indexOf(' ');
+            const key = sp === -1 ? kv : kv.slice(0, sp);
+            const value = sp === -1 ? '' : kv.slice(sp + 1);
+            if (key === 'author')
+                info.author = value;
+            else if (key === 'author-time')
+                info.authorTime = Number(value);
+            else if (key === 'author-tz')
+                info.authorTz = value;
+            else if (key === 'summary')
+                info.summary = value;
+            i++;
+        }
+        commits.set(sha, info);
+        const content = (lines[i] ?? '').slice(1);
+        i++;
+        result.push({
+            line: finalLine,
+            oid: sha,
+            abbreviatedOid: sha.slice(0, 7),
+            author: info.author,
+            authorTime: epochToIso(info.authorTime, info.authorTz),
+            summary: info.summary,
+            content,
+        });
+    }
+    return result;
+}
+/** `1704164645` + `+0200` → `2024-01-02T05:04:05+02:00`; UTC is written as `Z`, like git's `%aI`. */
+function epochToIso(epochSeconds, tz) {
+    const m = /^([+-])(\d{2})(\d{2})$/.exec(tz);
+    const sign = m?.[1] === '-' ? -1 : 1;
+    const hh = m?.[2] ?? '00';
+    const mm = m?.[3] ?? '00';
+    const offsetSeconds = sign * (Number(hh) * 3600 + Number(mm) * 60);
+    const shifted = new Date((epochSeconds + offsetSeconds) * 1000);
+    const zone = offsetSeconds === 0 ? 'Z' : `${sign < 0 ? '-' : '+'}${hh}:${mm}`;
+    return `${shifted.toISOString().slice(0, 19)}${zone}`;
+}
+// ---------------------------------------------------------------------------
+/** Run a read-only query; null when git exits non-zero (e.g. not a repository). Other failures propagate. */
+async function tryGit(dir, args) {
+    try {
+        return (await runGit(dir, args)).stdout.toString('utf8');
+    }
+    catch (err) {
+        if (err instanceof GitError && err.exitCode !== null)
+            return null;
+        throw err;
+    }
+}

package/dist/git/remote.js

@@ -0,0 +1,47 @@
+/**
+ * Recognise GitHub repositories in the URL forms git stores for remotes and in
+ * the `owner/repo` shorthand users type. Anything that is not clearly a
+ * github.com repository yields null; callers turn that into a 400.
+ */
+/** GitHub owner and repository names: alphanumerics, `-`, `_`, `.`; never `.` or `..`. */
+const NAME = /^[A-Za-z0-9_.-]+$/;
+// scp-like syntax: [user@]github.com:owner/repo(.git)
+const SCP_FORM = /^(?:[\w.-]+@)?github\.com:(.+)$/i;
+// URL syntax: [scheme://][user@]github.com[:port]/owner/repo(.git)(/)
+const URL_FORM = /^(?:(?:ssh|https?|git|git\+ssh|ssh\+git):\/\/)?(?:[^@/\s]+@)?(?:www\.)?github\.com(?::\d+)?\/(.+)$/i;
+/**
+ * Parse a remote URL into `{ owner, repo }` when it points at github.com.
+ *
+ * Accepts `git@github.com:o/r.git`, `ssh://git@github.com/o/r.git`,
+ * `https://github.com/o/r(.git)(/)`, `git://github.com/o/r` and the bare
+ * `github.com/o/r`. Returns null for anything else.
+ */
+export function parseGitHubRemote(url) {
+    const input = url.trim();
+    const scp = SCP_FORM.exec(input);
+    const rest = scp?.[1] ?? URL_FORM.exec(input)?.[1];
+    return rest === undefined ? null : splitOwnerRepo(rest);
+}
+/**
+ * Parse what a user types to add a project by clone: `owner/repo`, or any URL
+ * form {@link parseGitHubRemote} accepts.
+ */
+export function parseRepoSlug(input) {
+    const slug = input.trim();
+    if (/^[^/:@\s]+\/[^/:@\s]+$/.test(slug))
+        return splitOwnerRepo(slug);
+    return parseGitHubRemote(slug);
+}
+function splitOwnerRepo(rest) {
+    let p = rest.replace(/\/+$/, '');
+    if (p.toLowerCase().endsWith('.git'))
+        p = p.slice(0, -'.git'.length);
+    const parts = p.split('/');
+    if (parts.length !== 2)
+        return null;
+    const [owner, repo] = parts;
+    if (!owner || !repo || !isName(owner) || !isName(repo))
+        return null;
+    return { owner, repo };
+}
+const isName = (s) => NAME.test(s) && s !== '.' && s !== '..';