fix: resolve configured remote instead of hardcoding origin (#219)

* fix: resolve configured remote instead of hardcoding origin

getDefaultBranch and pushSetUpstream always assumed a remote named
"origin", breaking fork workflows where the only remote is e.g.
"upstream". Both now take a remote parameter (still defaulting to
"origin" for source compatibility), and every call site resolves the
actual remote via the existing resolveRemote/remoteSelection helpers
(respecting the defaultRemote setting) instead of assuming origin.
getDefaultBranch also falls back to `git remote show <remote>` when
the local origin/HEAD symbolic ref was never set, before giving up
and guessing a local main/master branch.

Closes #210

* chore: retrigger CI

* test: fix e2e ConfigurationManager stub broken by remote-resolution change

TestableCheckoutToCommand in checkoutInlineActions.test.ts used
'{} as ConfigurationManager', which throws on .get() now that
publishBranchAction/deleteLocalBranchAction call
resolveRemoteInteractive(git, { defaultRemote: configManager.get()... }).
Give it a working get() stub, matching the unit-test fix already applied
in checkoutToInlineActions.test.ts.

---------

Co-authored-by: Test <t@t.local>

Author: zaknafeyn

src/commands/checkoutToCommand/index.ts

@@ -10,6 +10,7 @@ import { LoggingService } from '../../logging/loggingService';
 import { AutoStashService } from '../../services/autoStashService';
 import { RefDetailsCache } from '../../services/refDetailsCache';
 import { getRepoId } from '../../utils/getRepoId';
+import { resolveRemoteInteractive } from '../../utils/remoteSelection';
 import { UserCancelledError } from '../../utils/userCancelledError';
 import { BaseCommand } from '../command';
 import { validateBranchName } from '../createBranchFromTemplateCommand/validateBranchName';
@@ -386,12 +387,21 @@ export class CheckoutToCommand extends BaseCommand {
 
   protected async publishBranchAction(git: GitExecutor, ref: IGitRef): Promise<boolean> {
     try {
+      const remote = await resolveRemoteInteractive(git, {
+        branch: ref.name,
+        defaultRemote: this.configManager.get().defaultRemote,
+        purpose: 'push',
+      });
       await vscode.window.withProgress(
         { location: vscode.ProgressLocation.Notification, title: `Publishing ${ref.name}` },
-        () => git.pushSetUpstream(ref.name)
+        () => git.pushSetUpstream(ref.name, remote)
       );
       return true;
     } catch (e) {
+      if (e instanceof UserCancelledError) {
+        // User dismissed the remote picker — not an error.
+        return false;
+      }
       captureException(e);
       const msg = e instanceof Error ? e.message : String(e);
       await this.showErrorMessage(`Failed to publish branch ${ref.name}: ${msg}`, 'OK');
@@ -470,7 +480,12 @@ export class CheckoutToCommand extends BaseCommand {
     let force = false;
     let defaultBranch: string | undefined;
     try {
-      defaultBranch = await git.getDefaultBranch();
+      const remote = await resolveRemoteInteractive(git, {
+        branch: ref.name,
+        defaultRemote: this.configManager.get().defaultRemote,
+        purpose: 'fetch',
+      });
+      defaultBranch = await git.getDefaultBranch(remote);
       const merged = await git.getMergedBranches(defaultBranch);
       force = !merged.includes(ref.name);
     } catch (e) {

src/commands/cleanupBranchesCommand/index.ts

@@ -4,6 +4,8 @@ import { GitExecutor } from '../../common/git/gitExecutor';
 import { VscodeGitProvider } from '../../common/git/vscodeGitProvider';
 import { ConfigurationManager } from '../../configuration/configurationManager';
 import { LoggingService } from '../../logging/loggingService';
+import { resolveRemoteInteractive } from '../../utils/remoteSelection';
+import { UserCancelledError } from '../../utils/userCancelledError';
 import { BaseCommand } from '../command';
 import {
   buildCleanupQuickPickItems,
@@ -33,8 +35,17 @@ export class CleanupBranchesCommand extends BaseCommand {
 
     let base: string;
     try {
-      base = await git.getDefaultBranch();
+      const remote = await resolveRemoteInteractive(git, {
+        branch: current,
+        defaultRemote: this.configManager.get().defaultRemote,
+        purpose: 'fetch',
+      });
+      base = await git.getDefaultBranch(remote);
     } catch (error) {
+      if (error instanceof UserCancelledError) {
+        // User dismissed the remote picker — not an error.
+        return;
+      }
       await vscode.window.showErrorMessage(
         `Could not determine the default branch: ${error instanceof Error ? error.message : String(error)}`
       );

src/common/git/gitExecutor.ts

@@ -1108,8 +1108,8 @@ export class GitExecutor {
     await this.#execGitCommand(['tag', '-d', name]);
   }
 
-  async pushSetUpstream(branch: string): Promise<void> {
-    await this.#execGitCommand(['push', '-u', 'origin', branch]);
+  async pushSetUpstream(branch: string, remote = 'origin'): Promise<void> {
+    await this.#execGitCommand(['push', '-u', remote, branch]);
   }
 
   async getMergedBranches(base: string): Promise<string[]> {
@@ -1150,11 +1150,24 @@ export class GitExecutor {
     return !!line && line.trimStart().startsWith('-');
   }
 
-  async getDefaultBranch(): Promise<string> {
+  async getDefaultBranch(remote = 'origin'): Promise<string> {
     try {
-      const { stdout } = await this.#execGitCommand(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD']);
-      return stdout.trim().replace(/^origin\//, '');
+      const { stdout } = await this.#execGitCommand(['symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`]);
+      return stdout.trim().replace(new RegExp(`^${remote}/`), '');
     } catch {
+      // The symbolic ref is only populated after an explicit `git remote set-head`
+      // (or a clone that set it up); many repos never have it. `git remote show`
+      // asks the remote directly for its HEAD branch instead.
+      try {
+        const { stdout } = await this.#execGitCommand(['remote', 'show', remote]);
+        const match = stdout.match(/HEAD branch:\s*(\S+)/);
+        if (match && match[1] && match[1] !== '(unknown)') {
+          return match[1];
+        }
+      } catch {
+        // Remote unreachable or doesn't exist — fall through to local guesses.
+      }
+
       const refs = await this.getAllRefListExtended();
       if (refs.some((ref) => !ref.remote && !ref.isTag && ref.name === 'main')) return 'main';
       if (refs.some((ref) => !ref.remote && !ref.isTag && ref.name === 'master')) return 'master';

src/test/e2e/checkoutInlineActions.test.ts

@@ -27,7 +27,8 @@ class TestableCheckoutToCommand extends CheckoutToCommand {
   errorMessages: string[] = [];
 
   constructor() {
-    super({} as ConfigurationManager, mockLogService, {} as AutoStashService);
+    const configManager = { get: () => ({ defaultRemote: undefined }) } as unknown as ConfigurationManager;
+    super(configManager, mockLogService, {} as AutoStashService);
   }
 
   protected async showInformationMessage(message: string): Promise<string | undefined> {

src/test/unit/checkoutToInlineActions.test.ts

@@ -33,7 +33,8 @@ class TestableCheckoutToCommand extends CheckoutToCommand {
   infoMessages: string[] = [];
 
   constructor() {
-    super({} as ConfigurationManager, mockLogService, {} as AutoStashService);
+    const configManager = { get: () => ({ defaultRemote: undefined }) } as unknown as ConfigurationManager;
+    super(configManager, mockLogService, {} as AutoStashService);
   }
 
   // Avoid popping a real (blocking) notification during tests — just record it.

src/test/unit/cleanupBranches.test.ts

@@ -414,6 +414,85 @@ describe('GitExecutor.getDefaultBranch', () => {
     await assert.rejects(() => git.getDefaultBranch(), /Could not determine the default branch/);
     fs.rmSync(dir, { recursive: true, force: true });
   });
+
+  it('resolves the HEAD branch of a non-"origin" remote (e.g. a fork\'s "upstream")', async () => {
+    const remoteDir = initRepo('gsc-default-upstream-remote-');
+    execSync('git checkout -q -b develop', { cwd: remoteDir });
+    commit(remoteDir, 'init');
+
+    const dir = initRepo('gsc-default-upstream-local-');
+    execSync('git checkout -q -b unrelated', { cwd: dir });
+    commit(dir, 'init');
+    execSync(`git remote add upstream "${remoteDir}"`, { cwd: dir });
+    execSync('git fetch -q upstream', { cwd: dir });
+    execSync('git remote set-head upstream develop', { cwd: dir });
+
+    const git = new GitExecutor(dir, mockLogService as unknown as LoggingService);
+    assert.strictEqual(await git.getDefaultBranch('upstream'), 'develop');
+    fs.rmSync(remoteDir, { recursive: true, force: true });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('falls back to "git remote show <remote>" when the symbolic ref is absent, then to local main/master', async () => {
+    // A repo with only an "upstream" remote and no `refs/remotes/upstream/HEAD`
+    // symbolic ref set locally (e.g. never explicitly `git remote set-head`d)
+    // must still resolve via `git remote show upstream`, not throw or assume "origin".
+    const remoteDir = initRepo('gsc-default-show-remote-');
+    execSync('git checkout -q -b develop', { cwd: remoteDir });
+    commit(remoteDir, 'init');
+
+    const dir = initRepo('gsc-default-show-local-');
+    execSync('git checkout -q -b unrelated', { cwd: dir });
+    commit(dir, 'init');
+    execSync(`git remote add upstream "${remoteDir}"`, { cwd: dir });
+    execSync('git fetch -q upstream', { cwd: dir });
+    // Intentionally no `git remote set-head` — refs/remotes/upstream/HEAD is absent.
+
+    const git = new GitExecutor(dir, mockLogService as unknown as LoggingService);
+    assert.strictEqual(await git.getDefaultBranch('upstream'), 'develop');
+    fs.rmSync(remoteDir, { recursive: true, force: true });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
+
+describe('GitExecutor.pushSetUpstream', () => {
+  function initRepo(prefix: string): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    execSync('git init -q', { cwd: dir });
+    execSync('git config user.email "test@test.local"', { cwd: dir });
+    execSync('git config user.name "Test"', { cwd: dir });
+    return dir;
+  }
+
+  function commit(dir: string, message: string) {
+    fs.writeFileSync(path.join(dir, 'file.txt'), `${message}\n`);
+    execSync('git add file.txt', { cwd: dir });
+    execSync(`git commit -q -m "${message}"`, { cwd: dir });
+  }
+
+  it('pushes and sets upstream tracking against the given remote, not "origin"', async () => {
+    const remoteDir = initRepo('gsc-push-remote-');
+    execSync('git checkout -q -b main', { cwd: remoteDir });
+    commit(remoteDir, 'init');
+
+    const dir = initRepo('gsc-push-local-');
+    execSync(`git remote add upstream "${remoteDir}"`, { cwd: dir });
+    execSync('git fetch -q upstream', { cwd: dir });
+    execSync('git checkout -q -b feat upstream/main', { cwd: dir });
+    commit(dir, 'feat change');
+
+    const git = new GitExecutor(dir, mockLogService as unknown as LoggingService);
+    await git.pushSetUpstream('feat', 'upstream');
+
+    const remoteBranches = execSync('git branch', { cwd: remoteDir }).toString();
+    assert.ok(remoteBranches.includes('feat'), `expected "feat" to be pushed to remote, got: ${remoteBranches}`);
+
+    const upstreamRef = execSync('git rev-parse --abbrev-ref feat@{upstream}', { cwd: dir }).toString().trim();
+    assert.strictEqual(upstreamRef, 'upstream/feat');
+
+    fs.rmSync(remoteDir, { recursive: true, force: true });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
 });
 
 describe('GitExecutor.getMergedBranches', () => {