From 304e40fe9c6dde1d273710c30c137f62f1db4593 Mon Sep 17 00:00:00 2001 From: Devin Foley Date: Sun, 15 Nov 2026 12:49:54 -0800 Subject: [PATCH] fix(auth): report effective Cloud owner access to the board UI (#21817) ## Thinking Path > - Paperclip manages AI agents and the environments where they run. > - Cloud owners can receive instance-admin rights for their own dedicated instance through the existing owner setting. > - Authentication computes these rights for each request without storing an instance-admin role. > - The board UI reads `/api/cli-auth/me` to decide whether to show administration controls such as Tailscale. > - That response used only stored roles, hiding controls that the Cloud backend already authorized. > - This change reports the effective Cloud request rights so the UI agrees with the backend. ## Linked Issues or Issue Description **What happened?** A Cloud owner with `enableOwnerInstanceAdmin` enabled can successfully read Tailscale connections, while `/api/cli-auth/me` reports `isInstanceAdmin: false`. The Connectors page therefore hides Tailscale. The same stale summary can hide other instance administration controls. **Expected behavior** The access summary should reflect the Cloud request's effective privileges. Turning off owner elevation must remove those privileges on the next request. Session and board-key callers must continue to use the fresh stored-role snapshot. **Steps to reproduce** Sign in as a Cloud stack owner with owner instance-admin elevation enabled and no stored instance-admin role. Open Connectors and compare the access summary with a Tailscale connections request: the summary reports no admin access even though the backend permits the request. Searched existing PRs for `"cli-auth/me" cloud` and `tailscale access`; no duplicate fix was found. Related: [#21526](https://github.com/paperclipai/paperclip/pull/21526), which added device sign-in and exposed this hosted permission-summary gap. ## What Changed - `/api/cli-auth/me` uses the trusted Cloud actor's computed `isInstanceAdmin` value for `cloud_tenant` requests. - Session and board-key requests retain fresh stored-role checks. No roles are persisted and no authorization gates or owner settings change. - Regression tests cover Cloud elevation and de-elevation, non-Cloud stored access, and rejection of anonymous/agent callers. Tailscale documentation explains Cloud owner access. ## Verification - Reproduced the deployed mismatch in an authenticated Cloud owner browser session: the access summary reported false while the Tailscale list request succeeded. No feature connection or configuration was changed. - Both Cloud access regression cases failed before the fix. - `pnpm exec vitest run server/src/__tests__/cli-auth-routes.test.ts server/src/middleware/cloud-tenant-actor.test.ts ui/src/pages/apps/TailscaleConnector.test.tsx` passes: 88 tests. - `pnpm --filter @paperclipai/server typecheck` passes. - `pnpm verify --explain` exits 2 and selects broad CI. All 57 checks pass on final head `6044d5097396de95f49bcbb7ce7bbb1e445a80fa`; no checks remain pending. Greptile scored this head 5/5 with no unresolved comments, and the branch is conflict-free. - `git diff --check` and a local credential/PII scan pass. - The fix has not been deployed or accepted in a hosted browser yet. ## Risks The summary exposes administration controls to Cloud owners already authorized by the backend. Non-owner access and disabled elevation remain denied by the existing authentication policy. No migration, provider configuration, or deployment change. ## Model Used OpenAI GPT-6.1 Sol (`gpt-6.1-sol`) through Codex in T3 Code, with xhigh reasoning. Context window size was not exposed. No subagents. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have described the issue in-PR following the bug template - [x] I have not referenced internal/instance-local Paperclip issues or links - [x] My branch name describes the change and contains no internal ticket or instance details - [x] I have run tests locally and they pass - [x] I have added regression tests - [x] I have updated relevant documentation - [x] I have considered and documented risks - [x] All Paperclip CI gates are green - [x] Greptile is 5/5 with no unresolved comments - [x] I will address actionable reviewer comments before requesting merge Co-authored-by: Paperclip --- doc/tailscale-environments.md | 3 ++ server/src/__tests__/cli-auth-routes.test.ts | 32 ++++++++++++++++++++ server/src/routes/access.ts | 4 ++- 3 files changed, 38 insertions(+), 1 deletion(-) diff --git a/doc/tailscale-environments.md b/doc/tailscale-environments.md index 3f40328ce48..cdcfd7d9f3b 100644 --- a/doc/tailscale-environments.md +++ b/doc/tailscale-environments.md @@ -74,6 +74,9 @@ tools or enter MCP discovery. Management requires an instance administrator with access to the company. Only the person who started a pending sign-in can retrieve its sign-in link. Existing SSH environment access governs which agents execute there. Cloud and self-hosted instances use the same Tailscale device sign-in. +For Cloud owners, the board access summary reports the effective instance-admin +rights computed by Cloud authentication while `enableOwnerInstanceAdmin` is +enabled. Disabling that setting removes those rights on the next request. The instance starts a private userspace Tailscale device and returns its generated `https://login.tailscale.com/a/...` sign-in address. Pending device state is stored diff --git a/server/src/__tests__/cli-auth-routes.test.ts b/server/src/__tests__/cli-auth-routes.test.ts index 24b6857ecb9..dc2e52d24d3 100644 --- a/server/src/__tests__/cli-auth-routes.test.ts +++ b/server/src/__tests__/cli-auth-routes.test.ts @@ -106,6 +106,38 @@ describe("cli auth routes", () => { await Promise.all([import("../routes/access.js"), import("../middleware/index.js")]); }); + it.each([ + [true, false], + [false, true], + ])("reports effective Cloud owner access when actor admin=%s and stored admin=%s", async (effectiveAdmin, storedAdmin) => { + mockBoardAuthService.resolveBoardAccess.mockResolvedValue({ + user: { id: "user-1", name: "User One", email: "user@example.com" }, + companyIds: ["company-1"], + memberships: [{ companyId: "company-1", membershipRole: "owner", status: "active" }], + isInstanceAdmin: storedAdmin, + }); + const app = await createApp({ type: "board", source: "cloud_tenant", userId: "user-1", isInstanceAdmin: effectiveAdmin }); + const res = await request(app).get("/api/cli-auth/me"); + expect(res.status).toBe(200); + expect(res.body).toMatchObject({ source: "cloud_tenant", isInstanceAdmin: effectiveAdmin, companyIds: ["company-1"] }); + }); + + it.each(["session", "board_key"])("keeps the fresh stored access snapshot for %s authentication", async source => { + mockBoardAuthService.resolveBoardAccess.mockResolvedValue({ user: null, companyIds: [], isInstanceAdmin: false }); + const app = await createApp({ type: "board", source, userId: "user-1", isInstanceAdmin: true }); + const res = await request(app).get("/api/cli-auth/me"); + expect(res.status).toBe(200); + expect(res.body.isInstanceAdmin).toBe(false); + }); + + it.each([{ type: "none", source: "none" }, { type: "agent", source: "agent_key", agentId: "agent-1" }])( + "denies the board access summary to $type callers", async actor => { + const app = await createApp(actor); + expect((await request(app).get("/api/cli-auth/me")).status).toBe(401); + expect(mockBoardAuthService.resolveBoardAccess).not.toHaveBeenCalled(); + }, + ); + it("creates a CLI auth challenge with approval metadata", async () => { mockBoardAuthService.createCliAuthChallenge.mockResolvedValue({ challenge: { diff --git a/server/src/routes/access.ts b/server/src/routes/access.ts index 96e549afdfa..67071145726 100644 --- a/server/src/routes/access.ts +++ b/server/src/routes/access.ts @@ -2892,7 +2892,9 @@ export function accessRoutes( res.json({ user: accessSnapshot.user, userId: req.actor.userId, - isInstanceAdmin: accessSnapshot.isInstanceAdmin, + isInstanceAdmin: req.actor.source === "cloud_tenant" + ? req.actor.isInstanceAdmin === true + : accessSnapshot.isInstanceAdmin, companyIds: accessSnapshot.companyIds, memberships: accessSnapshot.memberships, source: req.actor.source ?? "none",