@junctionpanel/server 0.1.28 → 0.1.29

package/dist/server/utils/checkout-git.js

@@ -12,10 +12,16 @@ const READ_ONLY_GIT_ENV = {
     ...process.env,
     GIT_OPTIONAL_LOCKS: "0",
 };
+const SAFE_GIT_REMOTE_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
 const SMALL_OUTPUT_MAX_BUFFER = 20 * 1024 * 1024; // 20MB
 async function execGit(command, options) {
     return execAsync(command, { ...options, maxBuffer: SMALL_OUTPUT_MAX_BUFFER });
 }
+function assertSafeRemoteName(remoteName) {
+    if (!SAFE_GIT_REMOTE_NAME_PATTERN.test(remoteName)) {
+        throw new Error(`Invalid remote name: ${remoteName}`);
+    }
+}
 async function spawnLimitedText(params) {
     const accept = new Set(params.acceptExitCodes ?? [0]);
     return new Promise((resolvePromise, rejectPromise) => {
@@ -72,7 +78,7 @@ async function spawnLimitedText(params) {
         });
     });
 }
-function normalizeBranchSuggestionName(raw) {
+function normalizeBranchSuggestionName(raw, source) {
     const trimmed = raw.trim();
     if (!trimmed) {
         return null;
@@ -84,8 +90,12 @@ function normalizeBranchSuggestionName(raw) {
     else if (normalized.startsWith("refs/remotes/")) {
         normalized = normalized.slice("refs/remotes/".length);
     }
-    if (normalized.startsWith("origin/")) {
-        normalized = normalized.slice("origin/".length);
+    if (source === "remote") {
+        const slashIndex = normalized.indexOf("/");
+        if (slashIndex <= 0) {
+            return null;
+        }
+        normalized = normalized.slice(slashIndex + 1);
     }
     if (!normalized || normalized === "HEAD") {
         return null;
@@ -128,13 +138,19 @@ export async function listBranchSuggestions(cwd, options) {
     const requestedLimit = options?.limit ?? 50;
     const limit = Math.max(1, Math.min(200, requestedLimit));
     const query = options?.query?.trim().toLowerCase() ?? "";
+    if (options?.remoteName?.trim()) {
+        assertSafeRemoteName(options.remoteName.trim());
+    }
+    const remoteRefPrefix = options?.remoteName?.trim()
+        ? `refs/remotes/${options.remoteName.trim()}`
+        : "refs/remotes";
     const [localRefs, remoteRefs] = await Promise.all([
         listGitRefs(cwd, "refs/heads"),
-        listGitRefs(cwd, "refs/remotes/origin"),
+        listGitRefs(cwd, remoteRefPrefix),
     ]);
     const merged = new Map();
     for (const localRef of localRefs) {
-        const normalized = normalizeBranchSuggestionName(localRef);
+        const normalized = normalizeBranchSuggestionName(localRef, "local");
         if (!normalized) {
             continue;
         }
@@ -143,7 +159,7 @@ export async function listBranchSuggestions(cwd, options) {
         merged.set(normalized, origins);
     }
     for (const remoteRef of remoteRefs) {
-        const normalized = normalizeBranchSuggestionName(remoteRef);
+        const normalized = normalizeBranchSuggestionName(remoteRef, "remote");
         if (!normalized) {
             continue;
         }
@@ -482,9 +498,10 @@ async function isWorkingTreeDirty(cwd) {
     });
     return stdout.trim().length > 0;
 }
-async function getOriginRemoteUrl(cwd) {
+async function getRemoteUrl(cwd, remoteName) {
+    assertSafeRemoteName(remoteName);
     try {
-        const { stdout } = await execAsync("git config --get remote.origin.url", {
+        const { stdout } = await execAsync(`git config --get remote.${remoteName}.url`, {
             cwd,
             env: READ_ONLY_GIT_ENV,
         });
@@ -495,20 +512,171 @@ async function getOriginRemoteUrl(cwd) {
         return null;
     }
 }
-async function hasOriginRemote(cwd) {
-    const url = await getOriginRemoteUrl(cwd);
-    return url !== null;
+function parseSymbolicHeadRef(ref) {
+    const trimmed = ref.trim();
+    if (!trimmed.startsWith("ref: ")) {
+        return null;
+    }
+    const headRef = trimmed.slice("ref: ".length).trim();
+    const match = /^refs\/heads\/(.+)$/.exec(headRef);
+    return match?.[1] ?? null;
 }
-export async function resolveBaseRef(repoRoot) {
+async function getLocalRemoteHeadBranch(remoteUrl) {
+    let localPath = null;
     try {
-        const { stdout } = await execAsync("git symbolic-ref --quiet refs/remotes/origin/HEAD", {
-            cwd: repoRoot,
+        if (remoteUrl.startsWith("file://")) {
+            localPath = realpathSync(new URL(remoteUrl));
+        }
+        else if (remoteUrl.startsWith("/")) {
+            localPath = realpathSync(remoteUrl);
+        }
+    }
+    catch {
+        localPath = null;
+    }
+    if (!localPath) {
+        return null;
+    }
+    for (const candidateHeadPath of [`${localPath}/HEAD`, `${localPath}/.git/HEAD`]) {
+        try {
+            const headFile = await openFile(candidateHeadPath, "r");
+            try {
+                const contents = await headFile.readFile("utf8");
+                const branch = parseSymbolicHeadRef(contents);
+                if (branch) {
+                    return branch;
+                }
+            }
+            finally {
+                await headFile.close();
+            }
+        }
+        catch {
+            // try next location
+        }
+    }
+    return null;
+}
+async function listRemoteNames(cwd) {
+    const { stdout } = await execAsync("git remote", {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+    });
+    return stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .sort((left, right) => left.localeCompare(right));
+}
+async function getRemoteHeadBranch(cwd, remoteName) {
+    assertSafeRemoteName(remoteName);
+    try {
+        const { stdout } = await execAsync(`git symbolic-ref --quiet refs/remotes/${remoteName}/HEAD`, {
+            cwd,
             env: READ_ONLY_GIT_ENV,
         });
         const ref = stdout.trim();
+        if (!ref) {
+            const remoteUrl = await getRemoteUrl(cwd, remoteName);
+            return remoteUrl ? getLocalRemoteHeadBranch(remoteUrl) : null;
+        }
+        const shortRef = ref.replace(/^refs\/remotes\//, "");
+        return shortRef.startsWith(`${remoteName}/`)
+            ? shortRef.slice(`${remoteName}/`.length)
+            : shortRef;
+    }
+    catch {
+        try {
+            const { stdout } = await execAsync(`git ls-remote --symref ${remoteName} HEAD`, {
+                cwd,
+                env: READ_ONLY_GIT_ENV,
+            });
+            const headLine = stdout
+                .split("\n")
+                .map((line) => line.trim())
+                .find((line) => line.startsWith("ref: refs/heads/") && line.endsWith("\tHEAD"));
+            if (!headLine) {
+                const remoteUrl = await getRemoteUrl(cwd, remoteName);
+                return remoteUrl ? getLocalRemoteHeadBranch(remoteUrl) : null;
+            }
+            const match = /^ref:\s+refs\/heads\/(.+)\tHEAD$/.exec(headLine);
+            return match?.[1] ?? null;
+        }
+        catch {
+            const remoteUrl = await getRemoteUrl(cwd, remoteName);
+            return remoteUrl ? getLocalRemoteHeadBranch(remoteUrl) : null;
+        }
+    }
+}
+export async function listGitRemotes(cwd) {
+    await requireGitRepo(cwd);
+    const remoteNames = await listRemoteNames(cwd);
+    const remotes = await Promise.all(remoteNames.map(async (name) => {
+        const [url, headBranch] = await Promise.all([
+            getRemoteUrl(cwd, name),
+            getRemoteHeadBranch(cwd, name),
+        ]);
+        return {
+            name,
+            url,
+            headBranch,
+            isGitHub: typeof url === "string" && parseGitHubRepoFromRemoteUrl(url) !== null,
+        };
+    }));
+    return remotes;
+}
+async function resolveEffectiveRemoteName(cwd, requestedRemoteName) {
+    const remotes = await listRemoteNames(cwd);
+    if (remotes.length === 0) {
+        return null;
+    }
+    const trimmedRequested = requestedRemoteName?.trim();
+    if (trimmedRequested && remotes.includes(trimmedRequested)) {
+        assertSafeRemoteName(trimmedRequested);
+        return trimmedRequested;
+    }
+    if (remotes.includes("origin")) {
+        return "origin";
+    }
+    return remotes[0] ?? null;
+}
+export async function resolveBaseRef(repoRoot, options) {
+    const remoteName = await resolveEffectiveRemoteName(repoRoot, options?.remoteName);
+    if (remoteName) {
+        try {
+            const { stdout } = await execAsync(`git symbolic-ref --quiet refs/remotes/${remoteName}/HEAD`, {
+                cwd: repoRoot,
+                env: READ_ONLY_GIT_ENV,
+            });
+            const ref = stdout.trim();
+            if (ref) {
+                const remoteShort = ref.replace(/^refs\/remotes\//, "");
+                const localName = remoteShort.startsWith(`${remoteName}/`)
+                    ? remoteShort.slice(`${remoteName}/`.length)
+                    : remoteShort;
+                try {
+                    await execAsync(`git show-ref --verify --quiet refs/heads/${localName}`, {
+                        cwd: repoRoot,
+                        env: READ_ONLY_GIT_ENV,
+                    });
+                    return localName;
+                }
+                catch {
+                    return remoteShort;
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    try {
+        const fallbackOriginRef = await execAsync("git symbolic-ref --quiet refs/remotes/origin/HEAD", {
+            cwd: repoRoot,
+            env: READ_ONLY_GIT_ENV,
+        });
+        const ref = fallbackOriginRef.stdout.trim();
         if (ref) {
-            // Prefer a local branch name (e.g. "main") over the remote-tracking ref (e.g. "origin/main")
-            // so that status/diff/merge all operate against the same base ref.
             const remoteShort = ref.replace(/^refs\/remotes\//, "");
             const localName = remoteShort.startsWith("origin/")
                 ? remoteShort.slice("origin/".length)
@@ -545,7 +713,15 @@ export async function resolveBaseRef(repoRoot) {
     return null;
 }
 function normalizeLocalBranchRefName(input) {
-    return input.startsWith("origin/") ? input.slice("origin/".length) : input;
+    if (input.startsWith("origin/")) {
+        return input.slice("origin/".length);
+    }
+    if (input.startsWith("refs/remotes/")) {
+        const stripped = input.slice("refs/remotes/".length);
+        const slashIndex = stripped.indexOf("/");
+        return slashIndex > 0 ? stripped.slice(slashIndex + 1) : stripped;
+    }
+    return input;
 }
 async function doesGitRefExist(cwd, fullRef) {
     try {
@@ -559,28 +735,34 @@ async function doesGitRefExist(cwd, fullRef) {
         return false;
     }
 }
-async function resolveBestBaseRefForMerge(cwd, normalizedBaseRef) {
+async function resolveBestBaseRefForMerge(cwd, normalizedBaseRef, options) {
+    const remoteName = await resolveEffectiveRemoteName(cwd, options?.remoteName);
+    const remoteRef = remoteName ? `refs/remotes/${remoteName}/${normalizedBaseRef}` : null;
     const [hasLocal, hasOrigin] = await Promise.all([
         doesGitRefExist(cwd, `refs/heads/${normalizedBaseRef}`),
-        doesGitRefExist(cwd, `refs/remotes/origin/${normalizedBaseRef}`),
+        remoteRef ? doesGitRefExist(cwd, remoteRef) : Promise.resolve(false),
     ]);
     if (hasLocal && !hasOrigin) {
         return normalizedBaseRef;
     }
     if (!hasLocal && hasOrigin) {
-        return `origin/${normalizedBaseRef}`;
+        return `${remoteName}/${normalizedBaseRef}`;
     }
     if (!hasLocal && !hasOrigin) {
-        throw new Error(`Base branch not found locally or on origin: ${normalizedBaseRef}`);
+        const remoteLabel = remoteName ?? "any remote";
+        throw new Error(`Base branch not found locally or on ${remoteLabel}: ${normalizedBaseRef}`);
     }
     // Both exist: choose the ref with more unique commits compared to the other.
     try {
-        const { stdout } = await execAsync(`git rev-list --left-right --count ${normalizedBaseRef}...origin/${normalizedBaseRef}`, { cwd, env: READ_ONLY_GIT_ENV });
+        if (!remoteName) {
+            return normalizedBaseRef;
+        }
+        const { stdout } = await execAsync(`git rev-list --left-right --count ${normalizedBaseRef}...${remoteName}/${normalizedBaseRef}`, { cwd, env: READ_ONLY_GIT_ENV });
         const [localOnlyRaw, originOnlyRaw] = stdout.trim().split(/\s+/);
         const localOnly = Number.parseInt(localOnlyRaw ?? "0", 10);
         const originOnly = Number.parseInt(originOnlyRaw ?? "0", 10);
         if (!Number.isNaN(localOnly) && !Number.isNaN(originOnly) && originOnly > localOnly) {
-            return `origin/${normalizedBaseRef}`;
+            return `${remoteName}/${normalizedBaseRef}`;
         }
     }
     catch {
@@ -634,11 +816,12 @@ async function inspectCheckoutContext(cwd, context) {
         if (!root) {
             return null;
         }
-        const [currentBranch, remoteUrl, configured] = await Promise.all([
+        const [currentBranch, configured, effectiveRemoteName] = await Promise.all([
             getCurrentBranch(cwd),
-            getOriginRemoteUrl(cwd),
             getConfiguredBaseRefForCwd(cwd, context),
+            resolveEffectiveRemoteName(cwd),
         ]);
+        const remoteUrl = effectiveRemoteName ? await getRemoteUrl(cwd, effectiveRemoteName) : null;
         return {
             worktreeRoot: root,
             currentBranch,
@@ -1130,7 +1313,7 @@ export async function mergeFromBase(cwd, options = {}, context) {
         throw new Error("Unable to determine current branch for merge");
     }
     const configured = await getConfiguredBaseRefForCwd(cwd, context);
-    const baseRef = configured.baseRef ?? options.baseRef ?? (await resolveBaseRef(cwd));
+    const baseRef = configured.baseRef ?? options.baseRef ?? (await resolveBaseRef(cwd, { remoteName: options.remoteName }));
     if (!baseRef) {
         throw new Error("Unable to determine base branch for merge");
     }
@@ -1148,7 +1331,9 @@ export async function mergeFromBase(cwd, options = {}, context) {
         }
     }
     const normalizedBaseRef = normalizeLocalBranchRefName(baseRef);
-    const bestBaseRef = await resolveBestBaseRefForMerge(cwd, normalizedBaseRef);
+    const bestBaseRef = await resolveBestBaseRefForMerge(cwd, normalizedBaseRef, {
+        remoteName: options.remoteName,
+    });
     if (bestBaseRef === currentBranch) {
         return;
     }
@@ -1207,17 +1392,17 @@ export async function mergeFromBase(cwd, options = {}, context) {
         throw error;
     }
 }
-export async function pushCurrentBranch(cwd) {
+export async function pushCurrentBranch(cwd, options) {
     await requireGitRepo(cwd);
     const currentBranch = await getCurrentBranch(cwd);
     if (!currentBranch || currentBranch === "HEAD") {
         throw new Error("Unable to determine current branch for push");
     }
-    const hasRemote = await hasOriginRemote(cwd);
-    if (!hasRemote) {
-        throw new Error("Remote 'origin' is not configured.");
+    const remoteName = await resolveEffectiveRemoteName(cwd, options?.remoteName);
+    if (!remoteName) {
+        throw new Error("No git remotes are configured.");
     }
-    await execAsync(`git push -u origin ${currentBranch}`, { cwd });
+    await execAsync(`git push -u ${remoteName} ${currentBranch}`, { cwd });
 }
 const GH_JSON_MAX_BYTES = 512 * 1024;
 const GH_FAILED_LOG_MAX_BYTES = 200 * 1024;
@@ -1241,54 +1426,65 @@ function getCommandErrorText(error) {
 function isGhAuthError(error) {
     const text = getCommandErrorText(error);
     return (text.includes("gh auth login") ||
+        text.includes("gh auth status") ||
         text.includes("not logged into any github hosts") ||
+        text.includes("not logged into github.com") ||
         text.includes("authentication failed") ||
         text.includes("authentication required") ||
         text.includes("bad credentials") ||
         text.includes("http 401"));
 }
-async function resolveGitHubRepo(cwd) {
-    try {
-        const { stdout } = await execAsync("git config --get remote.origin.url", {
-            cwd,
-            env: READ_ONLY_GIT_ENV,
-        });
-        const url = stdout.trim();
-        if (!url) {
-            return null;
-        }
-        let cleaned = url;
-        if (cleaned.startsWith("git@github.com:")) {
-            cleaned = cleaned.slice("git@github.com:".length);
-        }
-        else if (cleaned.startsWith("https://github.com/")) {
-            cleaned = cleaned.slice("https://github.com/".length);
-        }
-        else if (cleaned.startsWith("http://github.com/")) {
-            cleaned = cleaned.slice("http://github.com/".length);
+function parseGitHubRepoFromRemoteUrl(url) {
+    let cleaned = url.trim();
+    if (!cleaned) {
+        return null;
+    }
+    if (cleaned.startsWith("git@github.com:")) {
+        cleaned = cleaned.slice("git@github.com:".length);
+    }
+    else if (cleaned.startsWith("https://github.com/")) {
+        cleaned = cleaned.slice("https://github.com/".length);
+    }
+    else if (cleaned.startsWith("http://github.com/")) {
+        cleaned = cleaned.slice("http://github.com/".length);
+    }
+    else {
+        const marker = "github.com/";
+        const index = cleaned.indexOf(marker);
+        if (index !== -1) {
+            cleaned = cleaned.slice(index + marker.length);
         }
         else {
-            const marker = "github.com/";
-            const index = cleaned.indexOf(marker);
-            if (index !== -1) {
-                cleaned = cleaned.slice(index + marker.length);
-            }
-            else {
-                return null;
-            }
-        }
-        if (cleaned.endsWith(".git")) {
-            cleaned = cleaned.slice(0, -".git".length);
-        }
-        if (!cleaned.includes("/")) {
             return null;
         }
-        return cleaned;
     }
-    catch {
-        // ignore
+    if (cleaned.endsWith(".git")) {
+        cleaned = cleaned.slice(0, -".git".length);
+    }
+    if (!cleaned.includes("/")) {
+        return null;
+    }
+    return cleaned;
+}
+async function resolveGitHubRepo(cwd, options) {
+    const remoteName = await resolveEffectiveRemoteName(cwd, options?.remoteName);
+    if (!remoteName) {
+        return null;
+    }
+    const remoteUrl = await getRemoteUrl(cwd, remoteName);
+    return remoteUrl ? parseGitHubRepoFromRemoteUrl(remoteUrl) : null;
+}
+async function hasAuthenticatedGitHubCliSession(cwd) {
+    try {
+        await execFileAsync("gh", ["auth", "status", "--hostname", "github.com"], { cwd });
+        return true;
+    }
+    catch (error) {
+        if (isGhAuthError(error)) {
+            return false;
+        }
+        throw error;
     }
-    return null;
 }
 async function listPullRequestsForHead(options) {
     const { stdout } = await execFileAsync("gh", [
@@ -1666,11 +1862,10 @@ function appendBoundedText(parts, next, currentBytes) {
     parts.push(`${truncated}\n\n[combined log output truncated]`);
     return GH_FAILED_LOG_TOTAL_MAX_BYTES;
 }
-async function loadCurrentPullRequest(cwd) {
+async function loadCurrentPullRequest(cwd, options) {
     await requireGitRepo(cwd);
-    const repo = await resolveGitHubRepo(cwd);
     const head = await getCurrentBranch(cwd);
-    if (!repo || !head) {
+    if (!head) {
         return {
             status: null,
             githubFeaturesEnabled: false,
@@ -1689,6 +1884,26 @@ async function loadCurrentPullRequest(cwd) {
             headSha: null,
         };
     }
+    const remoteName = await resolveEffectiveRemoteName(cwd, options?.remoteName);
+    const remoteUrl = remoteName ? await getRemoteUrl(cwd, remoteName) : null;
+    if (!remoteUrl) {
+        const hasAuthenticatedGhSession = await hasAuthenticatedGitHubCliSession(cwd);
+        return {
+            status: null,
+            githubFeaturesEnabled: hasAuthenticatedGhSession,
+            checks: [],
+            headSha: null,
+        };
+    }
+    const repo = parseGitHubRepoFromRemoteUrl(remoteUrl);
+    if (!repo) {
+        return {
+            status: null,
+            githubFeaturesEnabled: false,
+            checks: [],
+            headSha: null,
+        };
+    }
     const owner = repo.split("/")[0];
     let openPulls;
     try {
@@ -1794,13 +2009,14 @@ async function loadCurrentPullRequest(cwd) {
 export async function createPullRequest(cwd, options) {
     await requireGitRepo(cwd);
     await ensureGhAvailable(cwd);
-    const repo = await resolveGitHubRepo(cwd);
+    const remoteName = await resolveEffectiveRemoteName(cwd, options.remoteName);
+    const repo = await resolveGitHubRepo(cwd, { remoteName });
     if (!repo) {
         throw new Error("Unable to determine GitHub repo from git remote");
     }
     const head = options.head ?? (await getCurrentBranch(cwd));
     const configured = await getConfiguredBaseRefForCwd(cwd);
-    const base = configured.baseRef ?? options.base ?? (await resolveBaseRef(cwd));
+    const base = configured.baseRef ?? options.base ?? (await resolveBaseRef(cwd, { remoteName }));
     if (!head) {
         throw new Error("Unable to determine head branch for PR");
     }
@@ -1811,7 +2027,10 @@ export async function createPullRequest(cwd, options) {
     if (configured.isJunctionOwnedWorktree && options.base && options.base !== base) {
         throw new Error(`Base ref mismatch: expected ${base}, got ${options.base}`);
     }
-    await execAsync(`git push -u origin ${head}`, { cwd });
+    if (!remoteName) {
+        throw new Error("No git remotes are configured.");
+    }
+    await execAsync(`git push -u ${remoteName} ${head}`, { cwd });
     const args = ["api", "-X", "POST", `repos/${repo}/pulls`, "-f", `title=${options.title}`];
     args.push("-f", `head=${head}`);
     args.push("-f", `base=${normalizedBase}`);
@@ -1825,15 +2044,15 @@ export async function createPullRequest(cwd, options) {
     }
     return { url: parsed.url, number: parsed.number };
 }
-export async function getPullRequestStatus(cwd) {
-    const lookup = await loadCurrentPullRequest(cwd);
+export async function getPullRequestStatus(cwd, options) {
+    const lookup = await loadCurrentPullRequest(cwd, options);
     return {
         status: lookup.status,
         githubFeaturesEnabled: lookup.githubFeaturesEnabled,
     };
 }
-export async function getPullRequestFailureLogs(cwd) {
-    const lookup = await loadCurrentPullRequest(cwd);
+export async function getPullRequestFailureLogs(cwd, options) {
+    const lookup = await loadCurrentPullRequest(cwd, options);
     if (!lookup.githubFeaturesEnabled) {
         return {
             logs: null,
@@ -1910,7 +2129,7 @@ export async function mergePullRequest(cwd, options = {}) {
     if (method !== "squash") {
         throw new Error("Only squash merge is supported");
     }
-    const statusResult = await getPullRequestStatus(cwd);
+    const statusResult = await getPullRequestStatus(cwd, { remoteName: options.remoteName });
     if (!statusResult.githubFeaturesEnabled) {
         throw new Error("GitHub CLI (gh) is not available or not authenticated");
     }