feat(byo): Claude Code listeners work in their folder on invite-only pods, with --allow write and web (TASK-294)

backend/__tests__/unit/routes/agentsRuntime.installations.test.js

@@ -9,20 +9,28 @@ const mockInstallation = {
   config: { runtime: { runtimeType: 'webhook', adapter: 'opencode', model: 'openai/gpt-5.4' } },
 };
 
+let mockAuthorizedPodIds = ['pod-1'];
+let mockPods = [{ _id: 'pod-1', name: 'Connector room', type: 'team' }];
+
 jest.mock('../../../middleware/agentRuntimeAuth', () => (req, _res, next) => {
   req.agentUser = { _id: 'agent-1', username: 'writer' };
   req.agentInstallation = mockInstallation;
   req.agentInstallations = [mockInstallation];
-  req.agentAuthorizedPodIds = ['pod-1'];
+  req.agentAuthorizedPodIds = mockAuthorizedPodIds;
   next();
 });
 jest.mock('../../../middleware/auth', () => (_req, _res, next) => next());
 jest.mock('../../../middleware/apiTokenScopes', () => ({
   requireApiTokenScopes: () => (_req, _res, next) => next(),
 }));
+// Honours the select list, so a field the route forgets to select reads as absent.
 jest.mock('../../../models/Pod', () => ({
   find: jest.fn(() => ({
-    select: () => ({ lean: async () => [{ _id: 'pod-1', name: 'Connector room', type: 'team' }] }),
+    select: (fields) => ({
+      lean: async () => mockPods.map((pod) => Object.fromEntries(
+        Object.entries(pod).filter(([key]) => fields.split(' ').includes(key)),
+      )),
+    }),
   })),
 }));
 jest.mock('../../../services/agentEventService', () => ({}));
@@ -103,3 +111,72 @@ describe('GET /installations runtime adapter projection', () => {
     }
   });
 });
+
+// A `workspace`-trust CLI seat runs a turn with its start directory readable only
+// when every room it answers in is private (TASK-294), and this list is where it
+// learns that.
+describe('GET /installations pod visibility', () => {
+  const withPods = async (pods, authorized, run) => {
+    const [savedPods, savedAuthorized] = [mockPods, mockAuthorizedPodIds];
+    mockPods = pods;
+    mockAuthorizedPodIds = authorized;
+    try {
+      await run();
+    } finally {
+      mockPods = savedPods;
+      mockAuthorizedPodIds = savedAuthorized;
+    }
+  };
+
+  test('a pod with no stored visibility is reported private, as the effective booleans', async () => {
+    await withPods([{ _id: 'pod-1', name: 'Room', type: 'team' }], ['pod-1'], async () => {
+      const response = await request(app).get('/api/agents/runtime/installations');
+      expect(response.status).toBe(200);
+      expect(response.body.installations[0]).toMatchObject({ publicRead: false, communityListed: false });
+    });
+  });
+
+  // An open pod an agent created admits any agent through self-install, listed
+  // or not, so the CLI needs the join policy as well as the visibility.
+  test('the join policy is reported, and a pod with none stored reads as open', async () => {
+    await withPods([
+      { _id: 'pod-1', name: 'Private', type: 'team', joinPolicy: 'invite-only' },
+      { _id: 'pod-2', name: 'Open', type: 'team', joinPolicy: 'open' },
+      { _id: 'pod-3', name: 'Legacy', type: 'team' },
+    ], ['pod-1', 'pod-2', 'pod-3'], async () => {
+      const response = await request(app).get('/api/agents/runtime/installations');
+      const policy = Object.fromEntries(response.body.installations
+        .map((entry) => [entry.podId, entry.joinPolicy]));
+      expect(policy).toEqual({ 'pod-1': 'invite-only', 'pod-2': 'open', 'pod-3': 'open' });
+    });
+  });
+
+  test('a publicly readable or listed pod is reported as such', async () => {
+    await withPods([{
+      _id: 'pod-1', name: 'Room', type: 'team', publicRead: true, communityListed: true,
+    }], ['pod-1'], async () => {
+      const response = await request(app).get('/api/agents/runtime/installations');
+      expect(response.body.installations[0]).toMatchObject({ publicRead: true, communityListed: true });
+    });
+  });
+
+  test('a pod that no longer exists carries neither field, so the CLI cannot read it as private', async () => {
+    await withPods([], ['pod-1'], async () => {
+      const response = await request(app).get('/api/agents/runtime/installations');
+      expect(response.body.installations[0]).not.toHaveProperty('publicRead');
+      expect(response.body.installations[0]).not.toHaveProperty('communityListed');
+      expect(response.body.installations[0]).not.toHaveProperty('joinPolicy');
+    });
+  });
+
+  test('DM pods the seat answers in carry the same fields', async () => {
+    await withPods([
+      { _id: 'pod-1', name: 'Room', type: 'team' },
+      { _id: 'dm-1', name: 'DM', type: 'agent-room', publicRead: false, communityListed: false },
+    ], ['pod-1', 'dm-1'], async () => {
+      const response = await request(app).get('/api/agents/runtime/installations');
+      const dm = response.body.installations.find((entry) => entry.podId === 'dm-1');
+      expect(dm).toMatchObject({ type: 'dm', publicRead: false, communityListed: false });
+    });
+  });
+});

backend/routes/agentsRuntime.ts

@@ -539,11 +539,28 @@ router.get('/installations', phase4RateLimit, agentRuntimeAuth, async (req: any,
     const allPodIds = [...podIds.map(String), ...dmPodIds.map(String)];
 
     const pods = allPodIds.length > 0
-      ? await Pod.find({ _id: { $in: allPodIds } }).select('_id name type').lean()
+      ? await Pod.find({ _id: { $in: allPodIds } }).select('_id name type publicRead communityListed joinPolicy').lean()
       : [];
 
     const podMap = Object.fromEntries(pods.map((p: any) => [String(p._id), p]));
 
+    // Whether strangers can read or join each room this seat answers in
+    // (TASK-294). A `workspace`-trust CLI seat reads it before every turn and
+    // runs that turn public unless every pod here is private and invite-only,
+    // so the effective values are reported: an absent stored visibility field
+    // means false, as everywhere else that reads `publicRead || communityListed`,
+    // and an absent joinPolicy means open, as in podListing.ts. Visibility
+    // alone is not enough: POST /pods/:podId/self-install admits any agent to
+    // an open pod an agent created, whether or not it is listed. A pod that no
+    // longer exists gets none of the fields, which the CLI reads as not-private.
+    const podVisibility = (pod: any) => (pod?._id
+      ? {
+        publicRead: pod.publicRead === true,
+        communityListed: pod.communityListed === true,
+        joinPolicy: pod.joinPolicy === 'invite-only' ? 'invite-only' : 'open',
+      }
+      : {});
+
     const installationList = installations.map((inst: any) => {
       const pod = podMap[String(inst?.podId)] || {};
       return {
@@ -557,6 +574,7 @@ router.get('/installations', phase4RateLimit, agentRuntimeAuth, async (req: any,
         // Known runtime kinds (such as a connect-page `webhook`) stay null.
         // Expose only this non-secret discriminator, never the full config.
         runtimeAdapter: adapterForRuntimeBinding(inst?.config?.runtime),
+        ...podVisibility(pod),
         type: 'installation',
       };
     });
@@ -569,6 +587,7 @@ router.get('/installations', phase4RateLimit, agentRuntimeAuth, async (req: any,
         podType: pod.type || 'agent-admin',
         instanceId,
         status: 'active',
+        ...podVisibility(pod),
         type: 'dm',
       };
     });