@aiworker/web 1.22.2 → 1.23.1

package/server/lib/git/routes.js

@@ -1,19 +1,22 @@
-export function registerGitRoutes(app) {
+export function registerGitRoutes(app, { emitWorktreeChanged } = {}) {
   let gitLibraries = null;
   const getGitLibraries = async () => {
     if (!gitLibraries) {
       gitLibraries = await import('./index.js');
+      if (emitWorktreeChanged) {
+        gitLibraries.subscribeWorktreeTopologyChanges(emitWorktreeChanged);
+      }
     }
     return gitLibraries;
   };
 
-  const resolveDirectoryQuery = (value) => {
+  const resolveDirectoryQuery = (value, preserveWhitespace = false) => {
     const raw = Array.isArray(value) ? value[0] : value;
     if (typeof raw !== 'string') {
       return null;
     }
-    const trimmed = raw.trim();
-    return trimmed || null;
+    const normalized = preserveWhitespace ? raw : raw.trim();
+    return normalized || null;
   };
 
   const extractGitErrorText = (error) => {
@@ -220,7 +223,7 @@ export function registerGitRoutes(app) {
   });
 
   app.get('/api/git/status', async (req, res) => {
-    const { getStatus, isGitRepository } = await getGitLibraries();
+    const { getStatus, isGitRepository, observeWorktreeTopology } = await getGitLibraries();
 
     try {
       const directory = resolveDirectoryQuery(req.query.directory);
@@ -233,6 +236,11 @@ export function registerGitRoutes(app) {
         return res.json(nonRepoStatusPayload());
       }
 
+      // Clients ask for status while they work in a repository, so this is
+      // where an externally added or removed worktree gets noticed. It runs
+      // beside the status call and never delays or fails the response.
+      void observeWorktreeTopology(directory);
+
       const mode = req.query.mode === 'light' ? 'light' : undefined;
       const status = await getStatus(directory, { mode });
       res.json(status);
@@ -417,6 +425,7 @@ export function registerGitRoutes(app) {
       const diff = await getRangeDiff(directory, {
         base,
         head,
+        includeWorkingTree: req.query.includeWorkingTree === 'true',
         path: pathParam,
         contextLines: Number.isFinite(context) ? context : 3,
       });
@@ -463,7 +472,7 @@ export function registerGitRoutes(app) {
         return res.status(400).json({ error: 'base and head parameters are required' });
       }
 
-      const files = await getRangeFiles(directory, { base, head });
+      const files = await getRangeFiles(directory, { base, head, includeWorkingTree: req.query.includeWorkingTree === 'true' });
       res.json({ files });
     } catch (error) {
       console.error('Failed to get git range files:', error);
@@ -1077,7 +1086,7 @@ export function registerGitRoutes(app) {
   });
 
   app.get('/api/git/worktrees', async (req, res) => {
-    const { getWorktrees } = await getGitLibraries();
+    const { getWorktrees, observeWorktreeTopology } = await getGitLibraries();
     try {
       const directory = req.query.directory;
       if (!directory) {
@@ -1085,13 +1094,18 @@ export function registerGitRoutes(app) {
       }
 
       const worktrees = await getWorktrees(directory);
+      // A repository always lists at least its primary worktree; an empty
+      // list means "not a repository" and has no topology to track.
+      if (worktrees.length > 0) {
+        void observeWorktreeTopology(directory);
+      }
       res.json(worktrees);
     } catch (error) {
-      // Worktrees are an optional feature. Avoid repeated 500s (and repeated client retries)
-      // when the directory isn't a git repo or uses shell shorthand like "~/".
-      console.warn('Failed to get worktrees, returning empty list:', error?.message || error);
-      res.setHeader('X-AiWorker-Warning', 'git worktrees unavailable');
-      res.json([]);
+      // A directory outside any repository still answers `[]` from getWorktrees.
+      // Anything else is a real failure the client must not mistake for "no
+      // worktrees", or it would drop the ones it already knows.
+      console.error('Failed to get worktrees:', error);
+      res.status(500).json({ error: error.message || 'Failed to get worktrees' });
     }
   });
 
@@ -1300,6 +1314,25 @@ export function registerGitRoutes(app) {
     }
   });
 
+  app.get('/api/git/commit-diff', async (req, res) => {
+    const { getCommitDiff } = await getGitLibraries();
+    try {
+      const directory = resolveDirectoryQuery(req.query.directory);
+      const hash = resolveDirectoryQuery(req.query.hash);
+      if (!directory || !hash) return res.status(400).json({ error: 'directory and hash are required' });
+      const context = Number(req.query.context ?? 3);
+      const diff = await getCommitDiff(directory, {
+        hash,
+        path: resolveDirectoryQuery(req.query.path, true) ?? undefined,
+        previousPath: resolveDirectoryQuery(req.query.previousPath, true) ?? undefined,
+        contextLines: Number.isFinite(context) ? context : 3,
+      });
+      res.json({ diff });
+    } catch (error) {
+      res.status(500).json({ error: error.message || 'Failed to get commit diff' });
+    }
+  });
+
   app.get('/api/git/commit-file-diff', async (req, res) => {
     const { getCommitFileDiff } = await getGitLibraries();
     try {

package/server/lib/git/routes.test.js

@@ -5,6 +5,9 @@ const gitLibraries = {
   unstageFiles: vi.fn(),
   isGitRepository: vi.fn(),
   getStatus: vi.fn(),
+  getWorktrees: vi.fn(),
+  observeWorktreeTopology: vi.fn(),
+  subscribeWorktreeTopologyChanges: vi.fn(),
 };
 
 vi.mock('./index.js', () => ({
@@ -12,6 +15,9 @@ vi.mock('./index.js', () => ({
   unstageFiles: gitLibraries.unstageFiles,
   isGitRepository: gitLibraries.isGitRepository,
   getStatus: gitLibraries.getStatus,
+  getWorktrees: gitLibraries.getWorktrees,
+  observeWorktreeTopology: gitLibraries.observeWorktreeTopology,
+  subscribeWorktreeTopologyChanges: gitLibraries.subscribeWorktreeTopologyChanges,
 }));
 
 const { registerGitRoutes } = await import('./routes.js');
@@ -141,6 +147,78 @@ describe('git routes index mutations', () => {
   });
 });
 
+describe('git worktree topology routes', () => {
+  beforeEach(() => {
+    gitLibraries.isGitRepository.mockReset();
+    gitLibraries.getStatus.mockReset();
+    gitLibraries.getWorktrees.mockReset();
+    gitLibraries.observeWorktreeTopology.mockReset();
+    gitLibraries.subscribeWorktreeTopologyChanges.mockReset();
+    gitLibraries.observeWorktreeTopology.mockResolvedValue(undefined);
+  });
+
+  it('observes the repository topology while serving status, never for non-repositories', async () => {
+    gitLibraries.isGitRepository.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+    gitLibraries.getStatus.mockResolvedValue({ current: 'main' });
+    const { app, getRoute } = createRouteRegistry();
+    registerGitRoutes(app);
+    const route = getRoute('GET', '/api/git/status');
+
+    const repoResponse = createMockResponse();
+    await route({ query: { directory: '/repo' } }, repoResponse);
+    expect(repoResponse.body).toEqual({ current: 'main' });
+    expect(gitLibraries.observeWorktreeTopology).toHaveBeenCalledWith('/repo');
+
+    await route({ query: { directory: '/plain-folder' } }, createMockResponse());
+    expect(gitLibraries.observeWorktreeTopology).toHaveBeenCalledTimes(1);
+  });
+
+  it('observes topology after a repository listing and reports listing failures', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    gitLibraries.getWorktrees
+      .mockResolvedValueOnce([{ path: '/repo', branch: 'main' }])
+      .mockResolvedValueOnce([])
+      .mockRejectedValueOnce(new Error('git failed'));
+    const { app, getRoute } = createRouteRegistry();
+    registerGitRoutes(app);
+    const route = getRoute('GET', '/api/git/worktrees');
+
+    const listed = createMockResponse();
+    await route({ query: { directory: '/repo' } }, listed);
+    expect(listed.body).toEqual([{ path: '/repo', branch: 'main' }]);
+    expect(gitLibraries.observeWorktreeTopology).toHaveBeenCalledWith('/repo');
+
+    await route({ query: { directory: '/plain-folder' } }, createMockResponse());
+    expect(gitLibraries.observeWorktreeTopology).toHaveBeenCalledTimes(1);
+
+    const failed = createMockResponse();
+    await route({ query: { directory: '/repo' } }, failed);
+    expect(failed.statusCode).toBe(500);
+    expect(failed.body).toEqual({ error: 'git failed' });
+    errorSpy.mockRestore();
+  });
+
+  it('forwards topology changes to the control event emitter once', async () => {
+    let listener = null;
+    gitLibraries.subscribeWorktreeTopologyChanges.mockImplementation((next) => {
+      listener = next;
+      return () => undefined;
+    });
+    gitLibraries.getWorktrees.mockResolvedValue([]);
+    const emitWorktreeChanged = vi.fn();
+    const { app, getRoute } = createRouteRegistry();
+    registerGitRoutes(app, { emitWorktreeChanged });
+    const route = getRoute('GET', '/api/git/worktrees');
+
+    await route({ query: { directory: '/repo' } }, createMockResponse());
+    await route({ query: { directory: '/repo' } }, createMockResponse());
+    expect(gitLibraries.subscribeWorktreeTopologyChanges).toHaveBeenCalledTimes(1);
+
+    listener({ directories: ['/repo'], at: 123 });
+    expect(emitWorktreeChanged).toHaveBeenCalledWith({ directories: ['/repo'], at: 123 });
+  });
+});
+
 describe('git routes status discovery', () => {
   beforeEach(() => {
     gitLibraries.isGitRepository.mockReset();