@assistkick/create 1.9.0 → 1.11.0

package/templates/assistkick-product-system/packages/backend/src/routes/git.ts

@@ -1,21 +1,31 @@
 /**
  * Git repository routes — connect/manage git repos for projects.
- * POST   /api/projects/:id/git/connect       — connect a git repo (clone URL + GitHub App)
- * POST   /api/projects/:id/git/init           — initialize a new local git repo
- * POST   /api/projects/:id/git/disconnect     — disconnect a git repo
- * GET    /api/projects/:id/git/status         — get git repo status
- * POST   /api/projects/:id/git/test           — test GitHub App connection
- * GET    /api/projects/:id/git/installations  — list GitHub App installations
- * GET    /api/projects/:id/git/repos          — list repos for an installation
- * POST   /api/projects/:id/git/ssh/generate   — generate SSH keypair for project
- * POST   /api/projects/:id/git/ssh/connect    — connect repo via SSH clone URL
+ * POST   /api/projects/:id/git/connect        — connect a git repo (remote add + fetch)
+ * POST   /api/projects/:id/git/init            — initialize a new local git repo
+ * POST   /api/projects/:id/git/disconnect      — disconnect a git repo
+ * GET    /api/projects/:id/git/status          — get git repo status
+ * POST   /api/projects/:id/git/test            — test GitHub App connection
+ * GET    /api/projects/:id/git/installations   — list GitHub App installations
+ * GET    /api/projects/:id/git/repos           — list repos for an installation
+ * POST   /api/projects/:id/git/ssh/generate    — generate SSH keypair for project
+ * POST   /api/projects/:id/git/ssh/connect     — connect repo via SSH (remote add + fetch)
+ * GET    /api/projects/:id/git/branches        — list local + remote branches with current
+ * POST   /api/projects/:id/git/checkout        — switch branch (optional commit message for dirty state)
+ * POST   /api/projects/:id/git/branches        — create and checkout a new branch
+ * GET    /api/projects/:id/git/remotes         — list configured remotes
+ * POST   /api/projects/:id/git/remotes         — add a new remote
+ * POST   /api/projects/:id/git/fetch           — fetch from remote
+ * POST   /api/projects/:id/git/pull            — pull current branch from remote
+ * POST   /api/projects/:id/git/push            — push current branch to remote
+ * GET    /api/projects/:id/git/ahead-behind    — get ahead/behind commit counts
+ * GET    /api/projects/:id/git/initial-commit  — check if only initial empty commit exists
  */
 
 import { Router } from 'express';
 import type { ProjectService } from '../services/project_service.js';
 import type { GitHubAppService } from '../services/github_app_service.js';
 import type { ProjectWorkspaceService } from '../services/project_workspace_service.js';
-import type { SshKeyService } from '../services/ssh_key_service.js';
+import { SshKeyService } from '../services/ssh_key_service.js';
 
 interface GitRoutesDeps {
   projectService: ProjectService;
@@ -56,24 +66,39 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
         }
       }
 
-      // Clone the repo into the workspace
+      // Add remote and fetch (replaces old rm -rf + clone pattern)
       await workspaceService.cloneRepo(id, cloneUrl);
 
       // Detect default branch
       const detectedBranch = await workspaceService.getDefaultBranch(id);
       const effectiveBranch = baseBranch || detectedBranch;
 
+      // If local repo only has the initial empty commit, reset to remote content
+      const onlyInitial = await workspaceService.hasOnlyInitialCommit(id);
+      if (onlyInitial) {
+        try {
+          await workspaceService.resetToRemoteBranch(id, `origin/${effectiveBranch}`);
+        } catch {
+          // Remote might be empty too — that's fine
+        }
+      }
+
       // Save repo metadata to project
-      const updated = await projectService.connectRepo(id, {
+      let updated = await projectService.connectRepo(id, {
         repoUrl: githubRepoFullName ? `https://github.com/${githubRepoFullName}.git` : repoUrl,
         githubInstallationId,
         githubRepoFullName,
         baseBranch: effectiveBranch,
       });
 
+      // Set auth method to 'github_app' when connecting via GitHub App
+      if (githubInstallationId) {
+        updated = await projectService.setGitHubAppAuth(id);
+      }
+
       res.json({ project: updated });
     } catch (err: any) {
-      log('GIT', `Connect repo failed: ${err.message}`);
+      log('GIT', `Connect repo failed:`, err.stack || err.message);
       res.status(500).json({ error: `Failed to connect repo: ${err.message}` });
     }
   });
@@ -101,7 +126,7 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
 
       res.json({ project: updated });
     } catch (err: any) {
-      log('GIT', `Init repo failed: ${err.message}`);
+      log('GIT', `Init repo failed:`, err.stack || err.message);
       res.status(500).json({ error: `Failed to initialize repo: ${err.message}` });
     }
   });
@@ -115,7 +140,7 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
       const updated = await projectService.disconnectRepo(id);
       res.json({ project: updated });
     } catch (err: any) {
-      log('GIT', `Disconnect repo failed: ${err.message}`);
+      log('GIT', `Disconnect repo failed:`, err.stack || err.message);
       if (err.message === 'Project not found') {
         res.status(404).json({ error: err.message });
         return;
@@ -148,7 +173,7 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
         sshConfigured: sshKeyService.isConfigured(),
       });
     } catch (err: any) {
-      log('GIT', `Get git status failed: ${err.message}`);
+      log('GIT', `Get git status failed:`, err.stack || err.message);
       res.status(500).json({ error: `Failed to get git status: ${err.message}` });
     }
   });
@@ -177,7 +202,7 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
         })),
       });
     } catch (err: any) {
-      log('GIT', `Test GitHub App connection failed: ${err.message}`);
+      log('GIT', `Test GitHub App connection failed:`, err.stack || err.message);
       res.json({
         configured: true,
         error: `Connection test failed: ${err.message}`,
@@ -203,7 +228,7 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
         })),
       });
     } catch (err: any) {
-      log('GIT', `List installations failed: ${err.message}`);
+      log('GIT', `List installations failed:`, err.stack || err.message);
       res.status(500).json({ error: `Failed to list installations: ${err.message}` });
     }
   });
@@ -229,7 +254,7 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
         })),
       });
     } catch (err: any) {
-      log('GIT', `List repos failed: ${err.message}`);
+      log('GIT', `List repos failed:`, err.stack || err.message);
       res.status(500).json({ error: `Failed to list repos: ${err.message}` });
     }
   });
@@ -241,7 +266,7 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
 
     try {
       if (!sshKeyService.isConfigured()) {
-        res.status(400).json({ error: 'ENCRYPTION_KEY environment variable is not configured' });
+        res.status(400).json({ error: `ENCRYPTION_KEY environment variable is not configured. ${SshKeyService.KEY_HELP}` });
         return;
       }
 
@@ -254,6 +279,9 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
       const keyPair = sshKeyService.generateKeyPair();
       const encryptedPrivateKey = sshKeyService.encrypt(keyPair.privateKey);
 
+      // Install the key to ~/.ssh/ so CLI git can use the same key
+      await sshKeyService.installKeyForCli(keyPair);
+
       const updated = await projectService.setSshKeys(id, {
         sshPrivateKeyEncrypted: encryptedPrivateKey,
         sshPublicKey: keyPair.publicKey,
@@ -267,7 +295,7 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
         publicKey: keyPair.publicKey,
       });
     } catch (err: any) {
-      log('GIT', `Generate SSH key failed: ${err.message}`);
+      log('GIT', `Generate SSH key failed:`, err.stack || err.message);
       res.status(500).json({ error: `Failed to generate SSH key: ${err.message}` });
     }
   });
@@ -295,13 +323,23 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
         return;
       }
 
-      // Clone using SSH
+      // Add remote and fetch using SSH (no rm -rf + clone)
       await workspaceService.cloneRepoSsh(id, repoUrl, project.sshPrivateKeyEncrypted);
 
       // Detect default branch
       const detectedBranch = await workspaceService.getDefaultBranch(id);
       const effectiveBranch = baseBranch || detectedBranch;
 
+      // If local repo only has the initial empty commit, reset to remote content
+      const onlyInitial = await workspaceService.hasOnlyInitialCommit(id);
+      if (onlyInitial) {
+        try {
+          await workspaceService.resetToRemoteBranch(id, `origin/${effectiveBranch}`);
+        } catch {
+          // Remote might be empty too — that's fine
+        }
+      }
+
       // Save repo metadata
       const updated = await projectService.connectRepo(id, {
         repoUrl,
@@ -317,10 +355,340 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
         },
       });
     } catch (err: any) {
-      log('GIT', `SSH connect repo failed: ${err.message}`);
+      log('GIT', `SSH connect repo failed:`, err.stack || err.message);
       res.status(500).json({ error: `Failed to connect repo via SSH: ${err.message}` });
     }
   });
 
+  // GET /api/projects/:id/git/remotes — list configured remotes
+  router.get('/remotes', async (req, res) => {
+    const { id } = req.params;
+    log('GIT', `GET /api/projects/${id}/git/remotes`);
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.status(404).json({ error: 'No git workspace found for this project' });
+        return;
+      }
+      const remotes = await workspaceService.listRemotes(id);
+      res.json({ remotes });
+    } catch (err: any) {
+      log('GIT', `List remotes failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to list remotes: ${err.message}` });
+    }
+  });
+
+  // POST /api/projects/:id/git/remotes — add a new remote
+  router.post('/remotes', async (req, res) => {
+    const { id } = req.params;
+    const { name, url } = req.body;
+    log('GIT', `POST /api/projects/${id}/git/remotes name="${name}" url="${url}"`);
+
+    if (!url) {
+      res.status(400).json({ error: 'url is required' });
+      return;
+    }
+
+    const remoteName = name || 'origin';
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.status(404).json({ error: 'No git workspace found for this project' });
+        return;
+      }
+      await workspaceService.addRemote(id, remoteName, url);
+
+      // Save repo URL to project metadata
+      if (remoteName === 'origin') {
+        await projectService.connectRepo(id, { repoUrl: url });
+      }
+
+      const remotes = await workspaceService.listRemotes(id);
+      res.json({ success: true, remotes });
+    } catch (err: any) {
+      log('GIT', `Add remote failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to add remote: ${err.message}` });
+    }
+  });
+
+  // POST /api/projects/:id/git/fetch — fetch from remote
+  router.post('/fetch', async (req, res) => {
+    const { id } = req.params;
+    const { remote = 'origin' } = req.body || {};
+    log('GIT', `POST /api/projects/${id}/git/fetch remote="${remote}"`);
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.status(404).json({ error: 'No git workspace found for this project' });
+        return;
+      }
+
+      const project = await projectService.getById(id);
+      if (!project) {
+        res.status(404).json({ error: 'Project not found' });
+        return;
+      }
+
+      if (project.gitAuthMethod === 'ssh_key' && project.sshPrivateKeyEncrypted) {
+        await workspaceService.fetchRemoteSsh(id, project.sshPrivateKeyEncrypted, remote);
+      } else if (project.gitAuthMethod === 'github_app' && project.githubInstallationId && project.githubRepoFullName) {
+        const token = await githubAppService.getInstallationToken(project.githubInstallationId);
+        const authUrl = `https://x-access-token:${token}@github.com/${project.githubRepoFullName}.git`;
+        const wsPath = workspaceService.getWorkspacePath(id);
+        await workspaceService['claudeService'].spawnCommand('git', ['remote', 'set-url', 'origin', authUrl], wsPath);
+        await workspaceService.fetchRemote(id, remote);
+        await workspaceService['claudeService'].spawnCommand(
+          'git', ['remote', 'set-url', 'origin', `https://github.com/${project.githubRepoFullName}.git`], wsPath,
+        ).catch(() => {});
+      } else {
+        await workspaceService.fetchRemote(id, remote);
+      }
+
+      const aheadBehind = await workspaceService.getAheadBehind(id);
+      res.json({ success: true, ...aheadBehind });
+    } catch (err: any) {
+      log('GIT', `Fetch failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to fetch: ${err.message}` });
+    }
+  });
+
+  // POST /api/projects/:id/git/pull — pull current branch from remote
+  router.post('/pull', async (req, res) => {
+    const { id } = req.params;
+    const { force } = req.body || {};
+    log('GIT', `POST /api/projects/${id}/git/pull force=${force}`);
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.status(404).json({ error: 'No git workspace found for this project' });
+        return;
+      }
+
+      const project = await projectService.getById(id);
+      if (!project) {
+        res.status(404).json({ error: 'Project not found' });
+        return;
+      }
+
+      // If force=true, do a hard reset to the remote branch (for pulling into projects with only initial commit)
+      if (force) {
+        const branch = await workspaceService.getDefaultBranch(id);
+        await workspaceService.resetToRemoteBranch(id, `origin/${branch}`);
+        // Checkout the remote branch properly
+        try {
+          await workspaceService.checkoutBranch(id, branch);
+        } catch {
+          // Already on the branch
+        }
+        const aheadBehind = await workspaceService.getAheadBehind(id);
+        res.json({ success: true, ...aheadBehind });
+        return;
+      }
+
+      if (project.gitAuthMethod === 'ssh_key' && project.sshPrivateKeyEncrypted) {
+        await workspaceService.pullBranchSsh(id, project.sshPrivateKeyEncrypted);
+      } else if (project.gitAuthMethod === 'github_app' && project.githubInstallationId && project.githubRepoFullName) {
+        const token = await githubAppService.getInstallationToken(project.githubInstallationId);
+        await workspaceService.pullBranch(id, token, project.githubRepoFullName);
+      } else {
+        await workspaceService.pullBranch(id);
+      }
+
+      const aheadBehind = await workspaceService.getAheadBehind(id);
+      res.json({ success: true, ...aheadBehind });
+    } catch (err: any) {
+      log('GIT', `Pull failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to pull: ${err.message}` });
+    }
+  });
+
+  // POST /api/projects/:id/git/push — push current branch to remote
+  router.post('/push', async (req, res) => {
+    const { id } = req.params;
+    log('GIT', `POST /api/projects/${id}/git/push`);
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.status(404).json({ error: 'No git workspace found for this project' });
+        return;
+      }
+
+      const project = await projectService.getById(id);
+      if (!project) {
+        res.status(404).json({ error: 'Project not found' });
+        return;
+      }
+
+      if (project.gitAuthMethod === 'ssh_key' && project.sshPrivateKeyEncrypted) {
+        await workspaceService.pushBranchSsh(id, project.sshPrivateKeyEncrypted);
+      } else if (project.gitAuthMethod === 'github_app' && project.githubInstallationId && project.githubRepoFullName) {
+        const token = await githubAppService.getInstallationToken(project.githubInstallationId);
+        await workspaceService.pushBranch(id, token, project.githubRepoFullName);
+      } else {
+        await workspaceService.pushBranch(id);
+      }
+
+      const aheadBehind = await workspaceService.getAheadBehind(id);
+      res.json({ success: true, ...aheadBehind });
+    } catch (err: any) {
+      log('GIT', `Push failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to push: ${err.message}` });
+    }
+  });
+
+  // GET /api/projects/:id/git/ahead-behind — get ahead/behind counts
+  router.get('/ahead-behind', async (req, res) => {
+    const { id } = req.params;
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.json({ ahead: 0, behind: 0 });
+        return;
+      }
+      const result = await workspaceService.getAheadBehind(id);
+      res.json(result);
+    } catch (err: any) {
+      log('GIT', `Ahead/behind failed: ${err.message}`);
+      res.json({ ahead: 0, behind: 0 });
+    }
+  });
+
+  // GET /api/projects/:id/git/initial-commit — check if workspace has only the initial empty commit
+  router.get('/initial-commit', async (req, res) => {
+    const { id } = req.params;
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.json({ onlyInitialCommit: true });
+        return;
+      }
+      const onlyInitialCommit = await workspaceService.hasOnlyInitialCommit(id);
+      res.json({ onlyInitialCommit });
+    } catch (err: any) {
+      log('GIT', `Initial commit check failed: ${err.message}`);
+      res.json({ onlyInitialCommit: true });
+    }
+  });
+
+  // GET /api/projects/:id/git/branches — list local + remote branches with current
+  router.get('/branches', async (req, res) => {
+    const { id } = req.params;
+    log('GIT', `GET /api/projects/${id}/git/branches`);
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.status(404).json({ error: 'No git workspace found for this project' });
+        return;
+      }
+
+      const branches = await workspaceService.listBranches(id);
+      res.json(branches);
+    } catch (err: any) {
+      log('GIT', `List branches failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to list branches: ${err.message}` });
+    }
+  });
+
+  // POST /api/projects/:id/git/checkout — switch branch
+  router.post('/checkout', async (req, res) => {
+    const { id } = req.params;
+    const { branch, commitMessage } = req.body;
+    log('GIT', `POST /api/projects/${id}/git/checkout branch="${branch}"`);
+
+    if (!branch) {
+      res.status(400).json({ error: 'branch is required' });
+      return;
+    }
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.status(404).json({ error: 'No git workspace found for this project' });
+        return;
+      }
+
+      // If there are uncommitted changes and a commit message was provided, commit first
+      const isDirty = await workspaceService.hasUncommittedChanges(id);
+      if (isDirty) {
+        if (!commitMessage) {
+          res.status(409).json({ error: 'Uncommitted changes exist', dirty: true });
+          return;
+        }
+        await workspaceService.commitAll(id, commitMessage);
+      }
+
+      await workspaceService.checkoutBranch(id, branch);
+      const branches = await workspaceService.listBranches(id);
+      res.json({ success: true, ...branches });
+    } catch (err: any) {
+      log('GIT', `Checkout branch failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to checkout branch: ${err.message}` });
+    }
+  });
+
+  // POST /api/projects/:id/git/branches — create and checkout a new branch
+  router.post('/branches', async (req, res) => {
+    const { id } = req.params;
+    const { name } = req.body;
+    log('GIT', `POST /api/projects/${id}/git/branches name="${name}"`);
+
+    if (!name) {
+      res.status(400).json({ error: 'name is required' });
+      return;
+    }
+
+    // Validate branch name (no spaces, no special chars that break git)
+    if (/[\s~^:?*\[\\]/.test(name) || name.startsWith('-') || name.endsWith('.') || name.includes('..')) {
+      res.status(400).json({ error: 'Invalid branch name' });
+      return;
+    }
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.status(404).json({ error: 'No git workspace found for this project' });
+        return;
+      }
+
+      await workspaceService.createBranch(id, name);
+      const branches = await workspaceService.listBranches(id);
+      res.json({ success: true, ...branches });
+    } catch (err: any) {
+      log('GIT', `Create branch failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to create branch: ${err.message}` });
+    }
+  });
+
+  // DELETE /api/projects/:id/git/branches — delete a local branch
+  router.delete('/branches', async (req, res) => {
+    const { id } = req.params;
+    const { name } = req.body;
+    log('GIT', `DELETE /api/projects/${id}/git/branches name="${name}"`);
+
+    if (!name) {
+      res.status(400).json({ error: 'name is required' });
+      return;
+    }
+
+    try {
+      if (!workspaceService.hasWorkspace(id)) {
+        res.status(404).json({ error: 'No git workspace found for this project' });
+        return;
+      }
+
+      // Prevent deleting the current branch
+      const branches = await workspaceService.listBranches(id);
+      if (branches.current === name) {
+        res.status(400).json({ error: 'Cannot delete the currently checked out branch' });
+        return;
+      }
+
+      await workspaceService.deleteBranch(id, name);
+      const updatedBranches = await workspaceService.listBranches(id);
+      res.json({ success: true, ...updatedBranches });
+    } catch (err: any) {
+      log('GIT', `Delete branch failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to delete branch: ${err.message}` });
+    }
+  });
+
   return router;
 };