2c0dcdc4 · permissionBRICK/SillyTavern

  * @returns {Promise<Object>} - Returns the extension information as an object
  */
 async function checkIfRepoIsUpToDate(extensionPath) {
     const git = simpleGit({ baseDir: extensionPath });
     await git.cwd(extensionPath).fetch('origin');
     const currentBranch = await git.cwd(extensionPath).branch();
     const currentCommitHash = await git.cwd(extensionPath).revparse(['HEAD']);
     const log = await git.cwd(extensionPath).log({
         from: currentCommitHash,
         to: `origin/${currentBranch.current}`,
     });
     // Fetch remote repository information
     const remotes = await git.cwd(extensionPath).getRemotes(true);
 +    if (remotes.length === 0) {
 +        return {
 +            isUpToDate: true,
 +            remoteUrl: '',
 +        };
 +    }
     return {
         isUpToDate: log.total === 0,

  * @returns {void}
  */
 router.post('/update', async (request, response) => {
 -    const git = simpleGit();
     if (!request.body.extensionName) {
         return response.status(400).send('Bad Request: extensionName is required in the request body.');
+    }

+        }
         const { isUpToDate, remoteUrl } = await checkIfRepoIsUpToDate(extensionPath);
         const currentBranchgit = await git.cwdsimpleGit({ baseDir: extensionPath).branch( });
 +        const currentBranch = await git.branch();
         if (!isUpToDate) {
             await git.cwd(extensionPath).pull('origin', currentBranch.current);
             console.info(`Extension has been updated at ${extensionPath}`);
         } else {
             console.info(`Extension is up to date at ${extensionPath}`);
+        }
         await git.cwd(extensionPath).fetch('origin');
         const fullCommitHash = await git.cwd(extensionPath).revparse(['HEAD']);
         const shortCommitHash = fullCommitHash.slice(0, 7);
         return response.send({ shortCommitHash, extensionPath, isUpToDate, remoteUrl });

 router.post('/branches', async (request, response) => {
     try {
 -        const git = simpleGit();
+-
         const { extensionName, global } = request.body;
         if (!extensionName) {

             return response.status(404).send(`Directory does not exist at ${extensionPath}`);
+        }
 +        const git = simpleGit({ baseDir: extensionPath });
         // Unshallow the repository if it is shallow
         const isShallow = await git.cwd(extensionPath).revparse(['--is-shallow-repository']) === 'true';
         if (isShallow) {
             console.info(`Unshallowing the repository at ${extensionPath}`);
             await git.cwd(extensionPath).fetch('origin', ['--unshallow']);
+        }
         // Fetch all branches
         await git.cwd(extensionPath).remote(['set-branches', 'origin', '*']);
         await git.cwd(extensionPath).fetch('origin');
         const localBranches = await git.cwd(extensionPath).branchLocal();
         const remoteBranches = await git.cwd(extensionPath).branch(['-r', '--list', 'origin/*']);
         const result = [
             ...Object.values(localBranches.branches),
             ...Object.values(remoteBranches.branches),

 router.post('/switch', async (request, response) => {
     try {
 -        const git = simpleGit();
+-
         const { extensionName, branch, global } = request.body;
         if (!extensionName || !branch) {

             return response.status(404).send(`Directory does not exist at ${extensionPath}`);
+        }
         const branchesgit = await git.cwdsimpleGit({ baseDir: extensionPath).branchLocal( });
 +        const branches = await git.branchLocal();
         if (String(branch).startsWith('origin/')) {
             const localBranch = branch.replace('origin/', '');
             if (branches.all.includes(localBranch)) {
                 console.info(`Branch ${localBranch} already exists locally, checking it out`);
                 await git.cwd(extensionPath).checkout(localBranch);
                 return response.sendStatus(204);
+            }
             console.info(`Branch ${localBranch} does not exist locally, creating it from ${branch}`);
             await git.cwd(extensionPath).checkoutBranch(localBranch, branch);
             return response.sendStatus(204);
+        }

+        }
         // Check if the branch is already checked out
         const currentBranch = await git.cwd(extensionPath).branch();
         if (currentBranch.current === branch) {
             console.info(`Branch ${branch} is already checked out`);
             return response.sendStatus(204);
+        }
         // Checkout the branch
         await git.cwd(extensionPath).checkout(branch);
         console.info(`Checked out branch ${branch} at ${extensionPath}`);
         return response.sendStatus(204);

  * @returns {void}
  */
 router.post('/version', async (request, response) => {
 -    const git = simpleGit();
     if (!request.body.extensionName) {
         return response.status(400).send('Bad Request: extensionName is required in the request body.');
+    }

             return response.status(404).send(`Directory does not exist at ${extensionPath}`);
+        }
 +        const git = simpleGit({ baseDir: extensionPath });
         let currentCommitHash;
         try {
             currentCommitHash = await git.cwd(extensionPath).revparse(['HEAD']);
         } catch (error) {
             // it is not a git repo, or has no commits yet, or is a bare repo
             // not possible to update it, most likely can't get the branch name either
             return response.send({ currentBranchName: '', currentCommitHash: '', isUpToDate: true, remoteUrl: '' });
+        }
         const currentBranch = await git.cwd(extensionPath).branch();
         // get only the working branch
         const currentBranchName = currentBranch.current;
         await git.cwd(extensionPath).fetch('origin');
         console.debug(extensionName, currentBranchName, currentCommitHash);
         const { isUpToDate, remoteUrl } = await checkIfRepoIsUpToDate(extensionPath);

Refactor git operations to use baseDir