feat(cli): Sim CLI with AWS-style profiles and a platform key exchange

.github/workflows/test-build.yml

@@ -129,6 +129,13 @@ jobs:
       - name: Desktop bridge contract audit
         run: bun run check:desktop-bridge
 
+      # The CLI's view of the v2 API is generated from the same Zod contracts
+      # the routes validate against, so a contract change that skips
+      # `generate:cli-api` would ship a client describing endpoints the server
+      # no longer has.
+      - name: Sim CLI API generation up to date
+        run: bun run check:cli-api
+
       # Complements the bridge audit above, which compares against a snapshot
       # this same PR is allowed to regenerate. This one derives every fact from
       # the source both sides execute, so it has no such blind spot.

apps/sim/app/api/cli/auth/approve/route.test.ts

@@ -5,11 +5,13 @@ import { createHash } from 'node:crypto'
 import { createMockRequest } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockGetSession, mockCreateApproval, mockEnforceUserRateLimit } = vi.hoisted(() => ({
-  mockGetSession: vi.fn(),
-  mockCreateApproval: vi.fn(),
-  mockEnforceUserRateLimit: vi.fn(),
-}))
+const { mockGetSession, mockCreateApproval, mockEnforceUserRateLimit, mockGetPermissions } =
+  vi.hoisted(() => ({
+    mockGetSession: vi.fn(),
+    mockCreateApproval: vi.fn(),
+    mockEnforceUserRateLimit: vi.fn(),
+    mockGetPermissions: vi.fn(),
+  }))
 
 vi.mock('@/lib/auth', () => ({
   auth: { api: { getSession: vi.fn() } },
@@ -24,6 +26,10 @@ vi.mock('@/lib/core/rate-limiter', () => ({
   enforceUserRateLimit: mockEnforceUserRateLimit,
 }))
 
+vi.mock('@/lib/workspaces/permissions/utils', () => ({
+  getUserEntityPermissions: mockGetPermissions,
+}))
+
 import { POST } from '@/app/api/cli/auth/approve/route'
 
 const REQUEST = 'a'.repeat(43)
@@ -35,6 +41,7 @@ describe('POST /api/cli/auth/approve', () => {
     mockGetSession.mockResolvedValue({ user: { id: 'user-1' } })
     mockEnforceUserRateLimit.mockResolvedValue(null)
     mockCreateApproval.mockResolvedValue(undefined)
+    mockGetPermissions.mockResolvedValue('admin')
   })
 
   it('records the approval for the signed-in user', async () => {
@@ -43,7 +50,112 @@ describe('POST /api/cli/auth/approve', () => {
     )
     expect(response.status).toBe(200)
     await expect(response.json()).resolves.toEqual({ ok: true })
-    expect(mockCreateApproval).toHaveBeenCalledWith('user-1', REQUEST, CHALLENGE)
+    expect(mockCreateApproval).toHaveBeenCalledWith('user-1', REQUEST, CHALLENGE, {
+      scope: 'copilot',
+      workspaceId: undefined,
+      workspaceBound: false,
+    })
+  })
+
+  it('defaults to the copilot scope so pre-scope terminals keep working', async () => {
+    await POST(createMockRequest('POST', { request: REQUEST, challenge: CHALLENGE }))
+    expect(mockCreateApproval).toHaveBeenCalledWith(
+      'user-1',
+      REQUEST,
+      CHALLENGE,
+      expect.objectContaining({ scope: 'copilot' })
+    )
+  })
+
+  it('records a workspace binding when the approver is a workspace admin', async () => {
+    const response = await POST(
+      createMockRequest('POST', {
+        request: REQUEST,
+        challenge: CHALLENGE,
+        scope: 'platform',
+        workspaceId: 'ws-1',
+        bindKeyToWorkspace: true,
+      })
+    )
+    expect(response.status).toBe(200)
+    expect(mockCreateApproval).toHaveBeenCalledWith('user-1', REQUEST, CHALLENGE, {
+      scope: 'platform',
+      workspaceId: 'ws-1',
+      workspaceBound: true,
+    })
+  })
+
+  it("records a non-admin's pick as a default without binding the key to it", async () => {
+    mockGetPermissions.mockResolvedValue('write')
+    const response = await POST(
+      createMockRequest('POST', {
+        request: REQUEST,
+        challenge: CHALLENGE,
+        scope: 'platform',
+        workspaceId: 'ws-1',
+      })
+    )
+    expect(response.status).toBe(200)
+    expect(mockCreateApproval).toHaveBeenCalledWith('user-1', REQUEST, CHALLENGE, {
+      scope: 'platform',
+      workspaceId: 'ws-1',
+      workspaceBound: false,
+    })
+  })
+
+  it('refuses to bind a key to a workspace the approver is not admin of', async () => {
+    mockGetPermissions.mockResolvedValue('write')
+    const response = await POST(
+      createMockRequest('POST', {
+        request: REQUEST,
+        challenge: CHALLENGE,
+        scope: 'platform',
+        workspaceId: 'ws-1',
+        bindKeyToWorkspace: true,
+      })
+    )
+    expect(response.status).toBe(403)
+    expect(mockCreateApproval).not.toHaveBeenCalled()
+  })
+
+  it('refuses a workspace the approver is not a member of', async () => {
+    mockGetPermissions.mockResolvedValue(null)
+    const response = await POST(
+      createMockRequest('POST', {
+        request: REQUEST,
+        challenge: CHALLENGE,
+        scope: 'platform',
+        workspaceId: 'ws-1',
+      })
+    )
+    expect(response.status).toBe(404)
+    expect(mockCreateApproval).not.toHaveBeenCalled()
+  })
+
+  it('refuses bindKeyToWorkspace with no workspaceId', async () => {
+    const response = await POST(
+      createMockRequest('POST', {
+        request: REQUEST,
+        challenge: CHALLENGE,
+        scope: 'platform',
+        bindKeyToWorkspace: true,
+      })
+    )
+    expect(response.status).toBe(400)
+    expect(mockCreateApproval).not.toHaveBeenCalled()
+  })
+
+  it('refuses a workspace binding on the copilot scope', async () => {
+    const response = await POST(
+      createMockRequest('POST', {
+        request: REQUEST,
+        challenge: CHALLENGE,
+        scope: 'copilot',
+        workspaceId: 'ws-1',
+      })
+    )
+    expect(response.status).toBe(400)
+    expect(mockCreateApproval).not.toHaveBeenCalled()
   })
 
   it('rejects an unauthenticated caller', async () => {
@@ -59,7 +171,7 @@ describe('POST /api/cli/auth/approve', () => {
     await POST(
       createMockRequest('POST', { request: REQUEST, challenge: CHALLENGE, userId: 'attacker' })
     )
-    expect(mockCreateApproval).toHaveBeenCalledWith('user-1', REQUEST, CHALLENGE)
+    expect(mockCreateApproval).toHaveBeenCalledWith('user-1', REQUEST, CHALLENGE, expect.anything())
   })
 
   it('rejects a malformed challenge', async () => {

apps/sim/app/api/cli/auth/approve/route.ts

@@ -6,6 +6,7 @@ import { getSession } from '@/lib/auth'
 import { createApproval } from '@/lib/cli-auth/approval-store'
 import { enforceUserRateLimit } from '@/lib/core/rate-limiter'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('CliAuthApproveAPI')
 
@@ -16,6 +17,10 @@ const logger = createLogger('CliAuthApproveAPI')
  * The approving user comes from the session and nothing else — a client-supplied
  * user id here would let any caller approve a request redeemable for someone
  * else's key. No key is generated until the CLI polls.
+ *
+ * Workspace binding is authorized here rather than at poll time: the poll is
+ * unauthenticated by necessity, so it has no session to check a permission
+ * against. Approving is the only moment a human is present.
  */
 export const POST = withRouteHandler(async (request: NextRequest) => {
   const session = await getSession()
@@ -29,8 +34,56 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
   const parsed = await parseRequest(approveCliAuthContract, request, {})
   if (!parsed.success) return parsed.response
 
-  await createApproval(session.user.id, parsed.data.body.request, parsed.data.body.challenge)
-  logger.info('Recorded CLI authorization approval', { userId: session.user.id })
+  const { request: requestId, challenge, scope, workspaceId, bindKeyToWorkspace } = parsed.data.body
+
+  if ((workspaceId || bindKeyToWorkspace) && scope !== 'platform') {
+    return NextResponse.json(
+      { error: 'workspaceId is only valid for the platform scope' },
+      { status: 400 }
+    )
+  }
+
+  if (bindKeyToWorkspace && !workspaceId) {
+    return NextResponse.json(
+      { error: 'bindKeyToWorkspace requires a workspaceId' },
+      { status: 400 }
+    )
+  }
+
+  if (workspaceId) {
+    const permission = await getUserEntityPermissions(session.user.id, 'workspace', workspaceId)
+
+    // Reading the workspace at all requires membership. Without this, the
+    // terminal could be handed the id of a workspace the approver cannot see —
+    // harmless for the key, but it would silently become the profile default and
+    // every later command would 403 with no explanation.
+    if (!permission) {
+      return NextResponse.json({ error: 'Workspace not found' }, { status: 404 })
+    }
+
+    // Minting a workspace key is an admin action wherever else it is offered;
+    // the terminal is not a lower bar. Rejected outright rather than downgraded
+    // to a personal key, so the CLI never quietly stores a different credential
+    // than the browser said it would.
+    if (bindKeyToWorkspace && permission !== 'admin') {
+      return NextResponse.json(
+        { error: 'Workspace admin permission is required to issue a workspace API key' },
+        { status: 403 }
+      )
+    }
+  }
+
+  await createApproval(session.user.id, requestId, challenge, {
+    scope,
+    workspaceId,
+    workspaceBound: bindKeyToWorkspace,
+  })
+  logger.info('Recorded CLI authorization approval', {
+    userId: session.user.id,
+    scope,
+    workspaceId: workspaceId ?? null,
+    workspaceBound: bindKeyToWorkspace,
+  })
 
   return NextResponse.json({ ok: true })
 })