feat(web-shell): show current git branch in composer toolbar

packages/cli/src/serve/routes/workspace-git.test.ts

@@ -0,0 +1,187 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import express from 'express';
+import request from 'supertest';
+import { describe, expect, it, vi } from 'vitest';
+import type { AcpSessionBridge } from '../acp-session-bridge.js';
+import { sendBridgeError } from '../server/error-response.js';
+import type { WorkspaceGitState } from '../workspace-git-state.js';
+import type {
+  WorkspaceRegistry,
+  WorkspaceRuntime,
+} from '../workspace-registry.js';
+import {
+  registerWorkspaceGitRoutes,
+  registerWorkspaceQualifiedGitRoutes,
+} from './workspace-git.js';
+
+function runtime(
+  workspaceId: string,
+  workspaceCwd: string,
+  trusted: boolean,
+): WorkspaceRuntime {
+  return {
+    workspaceId,
+    workspaceCwd,
+    primary: workspaceId === 'primary',
+    trusted,
+    bridge: { publishWorkspaceEvent: vi.fn() } as unknown as AcpSessionBridge,
+  } as WorkspaceRuntime;
+}
+
+function registry(runtimes: WorkspaceRuntime[]): WorkspaceRegistry {
+  return {
+    primary: runtimes[0]!,
+    list: () => runtimes,
+    getByWorkspaceCwd: (cwd) =>
+      runtimes.find((item) => item.workspaceCwd === cwd),
+    getByWorkspaceId: (id) => runtimes.find((item) => item.workspaceId === id),
+    resolveWorkspaceCwd: (cwd) =>
+      cwd === undefined
+        ? runtimes[0]
+        : runtimes.find((item) => item.workspaceCwd === cwd),
+    resolveLiveSessionOwner: () => ({ kind: 'not_found' }),
+    add: () => {},
+  };
+}
+
+describe('workspace Git routes', () => {
+  it('returns Git status for the bound workspace', async () => {
+    const app = express();
+    const bridge = runtime('primary', '/work/main', true).bridge;
+    const getStatus = vi.fn(async () => ({
+      v: 1 as const,
+      workspaceCwd: '/work/main',
+      branch: 'main',
+    }));
+    registerWorkspaceGitRoutes(app, {
+      boundWorkspace: '/work/main',
+      bridge,
+      gitState: { getStatus } as unknown as WorkspaceGitState,
+      sendBridgeError,
+    });
+
+    const response = await request(app).get('/workspace/git');
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      v: 1,
+      workspaceCwd: '/work/main',
+      branch: 'main',
+    });
+    expect(getStatus).toHaveBeenCalledWith('/work/main', bridge);
+  });
+
+  it('returns a structured error when bound Git status fails', async () => {
+    const app = express();
+    const bridge = runtime('primary', '/work/main', true).bridge;
+    const getStatus = vi.fn(async () => {
+      throw Object.assign(new Error('git failed'), {
+        code: 'git_status_failed',
+      });
+    });
+    registerWorkspaceGitRoutes(app, {
+      boundWorkspace: '/work/main',
+      bridge,
+      gitState: { getStatus } as unknown as WorkspaceGitState,
+      sendBridgeError,
+    });
+
+    const response = await request(app).get('/workspace/git');
+
+    expect(response.status).toBe(500);
+    expect(response.body).toMatchObject({
+      error: 'git failed',
+      code: 'git_status_failed',
+    });
+  });
+
+  it('uses the selected trusted workspace runtime', async () => {
+    const app = express();
+    const primary = runtime('primary', '/work/main', true);
+    const secondary = runtime('secondary', '/work/secondary', true);
+    const getStatus = vi.fn(async () => ({
+      v: 1 as const,
+      workspaceCwd: secondary.workspaceCwd,
+      branch: 'feature/web-shell',
+    }));
+    registerWorkspaceQualifiedGitRoutes(app, {
+      workspaceRegistry: registry([primary, secondary]),
+      gitState: { getStatus } as unknown as WorkspaceGitState,
+      sendBridgeError,
+    });
+
+    const response = await request(app).get('/workspaces/secondary/git');
+
+    expect(response.status).toBe(200);
+    expect(response.body.branch).toBe('feature/web-shell');
+    expect(getStatus).toHaveBeenCalledWith(
+      secondary.workspaceCwd,
+      secondary.bridge,
+    );
+  });
+
+  it('rejects an untrusted workspace before reading Git status', async () => {
+    const app = express();
+    const primary = runtime('primary', '/work/main', true);
+    const untrusted = runtime('untrusted', '/work/untrusted', false);
+    const getStatus = vi.fn();
+    registerWorkspaceQualifiedGitRoutes(app, {
+      workspaceRegistry: registry([primary, untrusted]),
+      gitState: { getStatus } as unknown as WorkspaceGitState,
+      sendBridgeError,
+    });
+
+    const response = await request(app).get('/workspaces/untrusted/git');
+
+    expect(response.status).toBe(403);
+    expect(response.body.code).toBe('untrusted_workspace');
+    expect(getStatus).not.toHaveBeenCalled();
+  });
+
+  it('rejects an unknown workspace before reading Git status', async () => {
+    const app = express();
+    const primary = runtime('primary', '/work/main', true);
+    const getStatus = vi.fn();
+    registerWorkspaceQualifiedGitRoutes(app, {
+      workspaceRegistry: registry([primary]),
+      gitState: { getStatus } as unknown as WorkspaceGitState,
+      sendBridgeError,
+    });
+
+    const response = await request(app).get('/workspaces/missing/git');
+
+    expect(response.status).toBe(400);
+    expect(response.body).toMatchObject({
+      code: 'workspace_mismatch',
+    });
+    expect(getStatus).not.toHaveBeenCalled();
+  });
+
+  it('returns a structured error when qualified Git status fails', async () => {
+    const app = express();
+    const primary = runtime('primary', '/work/main', true);
+    const getStatus = vi.fn(async () => {
+      throw Object.assign(new Error('qualified git failed'), {
+        data: { reason: 'watcher' },
+      });
+    });
+    registerWorkspaceQualifiedGitRoutes(app, {
+      workspaceRegistry: registry([primary]),
+      gitState: { getStatus } as unknown as WorkspaceGitState,
+      sendBridgeError,
+    });
+
+    const response = await request(app).get('/workspaces/primary/git');
+
+    expect(response.status).toBe(500);
+    expect(response.body).toMatchObject({
+      error: 'qualified git failed',
+      data: { reason: 'watcher' },
+    });
+  });
+});

packages/cli/src/serve/routes/workspace-git.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Application, Request, Response } from 'express';
+import type { AcpSessionBridge } from '../acp-session-bridge.js';
+import type { SendBridgeError } from '../server/error-response.js';
+import type { WorkspaceGitState } from '../workspace-git-state.js';
+import type {
+  WorkspaceRegistry,
+  WorkspaceRuntime,
+} from '../workspace-registry.js';
+import {
+  requireTrustedWorkspaceRuntime,
+  resolveWorkspaceRuntimeFromParam,
+} from '../workspace-route-runtime.js';
+
+export function registerWorkspaceGitRoutes(
+  app: Application,
+  deps: {
+    boundWorkspace: string;
+    bridge: AcpSessionBridge;
+    gitState: WorkspaceGitState;
+    sendBridgeError: SendBridgeError;
+  },
+): void {
+  app.get('/workspace/git', async (_req, res) => {
+    try {
+      res
+        .status(200)
+        .json(await deps.gitState.getStatus(deps.boundWorkspace, deps.bridge));
+    } catch (err) {
+      deps.sendBridgeError(res, err, { route: 'GET /workspace/git' });
+    }
+  });
+}
+
+function resolveTrustedRuntime(
+  registry: WorkspaceRegistry,
+  req: Request,
+  res: Response,
+): WorkspaceRuntime | null {
+  const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
+  if (!runtime) return null;
+  return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
+}
+
+export function registerWorkspaceQualifiedGitRoutes(
+  app: Application,
+  deps: {
+    workspaceRegistry: WorkspaceRegistry;
+    gitState: WorkspaceGitState;
+    sendBridgeError: SendBridgeError;
+  },
+): void {
+  app.get('/workspaces/:workspace/git', async (req, res) => {
+    const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
+    if (!runtime) return;
+    const route = 'GET /workspaces/:workspace/git';
+    try {
+      res
+        .status(200)
+        .json(
+          await deps.gitState.getStatus(runtime.workspaceCwd, runtime.bridge),
+        );
+    } catch (err) {
+      deps.sendBridgeError(res, err, { route });
+    }
+  });
+}

packages/cli/src/serve/run-qwen-serve.ts

@@ -4430,6 +4430,9 @@ export async function runQwenServe(
             (
               app.locals as { stopScheduledTaskKeepalive?: () => void }
             ).stopScheduledTaskKeepalive?.();
+            (
+              app.locals as { stopWorkspaceGitState?: () => void }
+            ).stopWorkspaceGitState?.();
             // Same rationale for the create_sub_session launchers: stop accepting
             // new sub-session spawns before the bridges are torn down. Calls
             // every workspace's launcher stop (primary + secondaries).

packages/cli/src/serve/server.ts

@@ -168,6 +168,11 @@ import {
 } from './routes/workspace-lifecycle.js';
 import { registerWorkspaceManagementRoutes } from './routes/workspace-management.js';
 import type { WorkspaceRegistrationStore } from './workspace-registration-store.js';
+import {
+  registerWorkspaceGitRoutes,
+  registerWorkspaceQualifiedGitRoutes,
+} from './routes/workspace-git.js';
+import { WorkspaceGitState } from './workspace-git-state.js';
 import {
   registerWorkspaceMcpControlRoutes,
   registerWorkspaceQualifiedMcpControlRoutes,
@@ -803,6 +808,9 @@ export function createServeApp(
   const primaryBridge = primaryRuntime.bridge;
   const primaryWorkspace = primaryRuntime.workspaceService;
   const primaryRouteFileSystemFactory = primaryRuntime.routeFileSystemFactory;
+  const workspaceGitState = new WorkspaceGitState();
+  (app.locals as { stopWorkspaceGitState?: () => void }).stopWorkspaceGitState =
+    () => workspaceGitState.dispose();
   const workspaceQualifiedAcpEnabled = resolveAcpHttpEnabled();
 
   // Order matters: rejection guards (CORS / Host allowlist / bearer auth)
@@ -1002,6 +1010,17 @@ export function createServeApp(
     workspaceRegistry,
     sendBridgeError,
   });
+  registerWorkspaceGitRoutes(app, {
+    boundWorkspace: primaryBoundWorkspace,
+    bridge: primaryBridge,
+    gitState: workspaceGitState,
+    sendBridgeError,
+  });
+  registerWorkspaceQualifiedGitRoutes(app, {
+    workspaceRegistry,
+    gitState: workspaceGitState,
+    sendBridgeError,
+  });
 
   // Workspace memory + agents CRUD routes.
   mountWorkspaceMemoryRoutes(app, {