Refactor GitHub context retrieval and improve remote URL fetching for submodules

Author: brandon.m@electronicscience.net

src/commands/triggerWorkflowRun.ts

@@ -1,8 +1,9 @@
 import * as vscode from "vscode";
 
-import {getGitHead, getGitHubContextForWorkspaceUri, GitHubRepoContext} from "../git/repository";
+import {getGitHead, getGitHubContextForWorkspaceUri, GitHubRepoContext, getGitExtension} from "../git/repository";
 import {getRepositoryRootForDocumentUri} from "../git/submoduleHelper";
 import {getWorkflowUri, parseWorkflowFile} from "../workflow/workflow";
+import {Protocol} from "../external/protocol";
 
 import {Workflow} from "../model";
 
@@ -11,6 +12,40 @@ interface TriggerRunCommandOptions {
   gitHubRepoContext: GitHubRepoContext;
 }
 
+async function getGitHubContextForRepository(repositoryUri: vscode.Uri): Promise<GitHubRepoContext | undefined> {
+  let context = await getGitHubContextForWorkspaceUri(repositoryUri);
+  if (context) {
+    return context;
+  }
+
+  const git = await getGitExtension();
+  if (!git) {
+    return undefined;
+  }
+
+  for (const repository of git.repositories) {
+    if (repository.rootUri.fsPath === repositoryUri.fsPath) {
+      await repository.status();
+      const remote = repository.state.remotes.find(r => r.name === "origin") || repository.state.remotes[0];
+
+      if (remote?.pushUrl) {
+        try {
+          const protocol = new Protocol(remote.pushUrl);
+          return {
+            owner: protocol.owner,
+            name: protocol.repositoryName,
+            client: undefined as any
+          } as GitHubRepoContext;
+        } catch {
+          return undefined;
+        }
+      }
+    }
+  }
+
+  return undefined;
+}
+
 export function registerTriggerWorkflowRun(context: vscode.ExtensionContext) {
   context.subscriptions.push(
     vscode.commands.registerCommand(
@@ -39,7 +74,7 @@ export function registerTriggerWorkflowRun(context: vscode.ExtensionContext) {
           repositoryUri = workspaceFolder.uri;
         }
 
-        const gitHubRepoContext = await getGitHubContextForWorkspaceUri(repositoryUri);
+        const gitHubRepoContext = await getGitHubContextForRepository(repositoryUri);
         if (!gitHubRepoContext) {
           return;
         }
@@ -93,7 +128,7 @@ export function registerTriggerWorkflowRun(context: vscode.ExtensionContext) {
             try {
               const workflowPath = workflowUri.fsPath;
               const repositoryPath = repositoryUri.fsPath;
-              const relativeWorkflowPath = workflowPath.substring(repositoryPath.length + 1);
+              const relativeWorkflowPath = require("path").relative(repositoryPath, workflowPath).replace(/\\/g, "/");
 
               await gitHubRepoContext.client.actions.createWorkflowDispatch({
                 owner: gitHubRepoContext.owner,

src/git/submoduleHelper.ts

@@ -4,19 +4,27 @@ import * as path from "path";
 import {getGitExtension} from "./repository";
 import {logDebug} from "../log";
 
-async function getGitRemoteForPath(documentPath: string): Promise<string | undefined> {
+async function getGitRemoteForPath(directoryPath: string): Promise<string | undefined> {
   try {
-    const dir = path.dirname(documentPath);
-    const cp = await import("child_process");
+    const fs = await import("fs/promises");
+    const stats = await fs.stat(directoryPath);
+    const cwd = stats.isDirectory() ? directoryPath : path.dirname(directoryPath);
+
+    const child_process = await import("child_process");
     const util = await import("util");
-    const execPromise = util.promisify(cp.exec);
-    const {stdout} = await execPromise("git config --get remote.origin.url", {cwd: dir});
+    const execFile = util.promisify(child_process.execFile);
+    const {stdout} = await execFile("git", ["config", "--get", "remote.origin.url"], {cwd});
     return stdout.trim();
   } catch {
     return undefined;
   }
 }
 
+function isPathWithin(childPath: string, parentPath: string): boolean {
+  const relative = path.relative(parentPath, childPath);
+  return !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+
 export async function getRepositoryRootForDocumentUri(documentUri: vscode.Uri): Promise<vscode.Uri | undefined> {
   const git = await getGitExtension();
   if (!git || git.repositories.length === 0) {
@@ -28,14 +36,13 @@ export async function getRepositoryRootForDocumentUri(documentUri: vscode.Uri):
   for (const repository of git.repositories) {
     const repoPath = repository.rootUri.fsPath;
 
-    if (documentPath.startsWith(repoPath)) {
-      await repository.status();
+    if (isPathWithin(documentPath, repoPath)) {
       const state = repository.state;
 
       if (state && state.submodules && state.submodules.length > 0) {
         for (const submodule of state.submodules) {
           const submodulePath = path.join(repoPath, submodule.path);
-          if (documentPath.startsWith(submodulePath)) {
+          if (isPathWithin(documentPath, submodulePath)) {
             logDebug("Found document in submodule:", submodule.path);
             const remoteUrl = await getGitRemoteForPath(submodulePath);
             if (remoteUrl) {