mothership agent-cli: viewer curation primitive for blocks get (Phase B3)

The v2 catalog already gates visibility, the integration allowlist, hidden-from-
toolbar and hosted-key restrictions; the one Go-era curation it lacks is a permission
group's deniedTools. When the mothership marks a request `curate: "block"`,
`curation.ts` applies resolveDeniedBlockOperations to the block detail: a partially
denied block loses the denied operations and their tools, a fully denied one is
refused. Contract mirror synced; no v2 or public CLI change.

Claude-Session: https://claude.ai/code/session_01HFVhPDtRZuCgupPco633w8

Author: Sg312

apps/sim/lib/mothership/agent-cli/curation.test.ts

@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { curateBlockDetail } from '@/lib/mothership/agent-cli/curation'
+
+const { permissionConfig, denied } = vi.hoisted(() => ({
+  permissionConfig: { current: null as { deniedTools?: string[] } | null },
+  denied: {
+    current: {
+      needsProjection: new Map<string, ReadonlySet<string>>(),
+      fullyDenied: new Set<string>(),
+    },
+  },
+}))
+
+vi.mock('@/ee/access-control/utils/permission-check', () => ({
+  getUserPermissionConfig: vi.fn(async () => permissionConfig.current),
+}))
+
+vi.mock('@/lib/mothership/integration-tool-projection', () => ({
+  resolveDeniedBlockOperations: vi.fn(() => denied.current),
+}))
+
+const viewer = { workspaceId: 'ws', userId: 'user' }
+
+function blockDetail() {
+  return {
+    type: 'slack',
+    operations: {
+      send: { toolId: 'slack_send' },
+      canvas: { toolId: 'slack_canvas' },
+    },
+    tools: [{ id: 'slack_send' }, { id: 'slack_canvas' }],
+  }
+}
+
+function ok(stdout: string) {
+  return { exitCode: 0, stdout, stderr: '' }
+}
+
+describe('curateBlockDetail', () => {
+  beforeEach(() => {
+    permissionConfig.current = null
+    denied.current = { needsProjection: new Map(), fullyDenied: new Set() }
+  })
+
+  it('passes through when the viewer has no denied tools', async () => {
+    const input = ok(JSON.stringify(blockDetail()))
+    expect(await curateBlockDetail(input, viewer)).toBe(input)
+  })
+
+  it('passes through non-block output untouched', async () => {
+    permissionConfig.current = { deniedTools: ['slack_canvas'] }
+    const input = ok('not json')
+    expect(await curateBlockDetail(input, viewer)).toBe(input)
+  })
+
+  it('drops denied operations and their tools from a partially denied block', async () => {
+    permissionConfig.current = { deniedTools: ['slack_canvas'] }
+    denied.current = {
+      needsProjection: new Map([['slack', new Set(['canvas'])]]),
+      fullyDenied: new Set(),
+    }
+    const result = await curateBlockDetail(ok(JSON.stringify(blockDetail())), viewer)
+    expect(result.exitCode).toBe(0)
+    const curated = JSON.parse(result.stdout)
+    expect(Object.keys(curated.operations)).toEqual(['send'])
+    expect(curated.tools).toEqual([{ id: 'slack_send' }])
+  })
+
+  it('refuses a fully denied block', async () => {
+    permissionConfig.current = { deniedTools: ['slack_send', 'slack_canvas'] }
+    denied.current = { needsProjection: new Map(), fullyDenied: new Set(['slack']) }
+    const result = await curateBlockDetail(ok(JSON.stringify(blockDetail())), viewer)
+    expect(result.exitCode).toBe(1)
+    expect(result.stderr).toContain('not available to you')
+  })
+})

apps/sim/lib/mothership/agent-cli/curation.ts

@@ -0,0 +1,60 @@
+/**
+ * Viewer curation for `blocks get` (18-agent-surface.md B3). The v2 catalog already
+ * hides blocks by visibility, allowlist and hosted-key restrictions, but it does not
+ * apply a permission group's `deniedTools`; the mothership asks for `curate: "block"`
+ * so a partially-denied block is trimmed to the operations this viewer may configure.
+ */
+
+import { agentCliFail } from '@/lib/mothership/agent-cli/types'
+import type { AgentCliRawResult } from '@/lib/mothership/generated/agent-cli'
+import { resolveDeniedBlockOperations } from '@/lib/mothership/integration-tool-projection'
+import { createToolAccessGate } from '@/lib/permission-groups/operation-access'
+import { getUserPermissionConfig } from '@/ee/access-control/utils/permission-check'
+
+export interface CurationViewer {
+  workspaceId: string
+  userId: string
+}
+
+interface BlockDetailShape {
+  type: string
+  operations?: Record<string, unknown>
+  tools?: Array<{ id?: unknown }>
+}
+
+function parseBlockDetail(stdout: string): BlockDetailShape | null {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null
+  const candidate = parsed as { type?: unknown }
+  return typeof candidate.type === 'string' ? (parsed as BlockDetailShape) : null
+}
+
+export async function curateBlockDetail(
+  result: AgentCliRawResult,
+  viewer: CurationViewer
+): Promise<AgentCliRawResult> {
+  const detail = parseBlockDetail(result.stdout)
+  if (!detail) return result
+  const config = await getUserPermissionConfig(viewer.userId, viewer.workspaceId)
+  const deniedTools = config?.deniedTools
+  if (!deniedTools?.length) return result
+  const isToolAllowed = createToolAccessGate(deniedTools)
+  const denied = resolveDeniedBlockOperations(deniedTools, isToolAllowed)
+  if (denied.fullyDenied.has(detail.type)) {
+    return agentCliFail(`Block "${detail.type}" is not available to you in this workspace.`)
+  }
+  const deniedOperations = denied.needsProjection.get(detail.type)
+  if (!deniedOperations) return result
+  const operations = Object.fromEntries(
+    Object.entries(detail.operations ?? {}).filter(([id]) => !deniedOperations.has(id))
+  )
+  const tools = (detail.tools ?? []).filter(
+    (tool) => typeof tool.id !== 'string' || isToolAllowed(tool.id)
+  )
+  return { ...result, stdout: JSON.stringify({ ...detail, operations, tools }, null, 2) }
+}

apps/sim/lib/mothership/agent-cli/index.ts

@@ -1,5 +1,6 @@
 import { createEmbeddedClient, type EmbeddedCliIdentity } from 'sim/embed'
 import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
+import { curateBlockDetail } from '@/lib/mothership/agent-cli/curation'
 import { runEngine } from '@/lib/mothership/agent-cli/engines'
 import { applyPipeline } from '@/lib/mothership/agent-cli/pipeline'
 import { runCli } from '@/lib/mothership/agent-cli/run-cli'
@@ -51,6 +52,9 @@ export async function executeAgentCliRequest(
     )
   } else {
     result = await runCli(request.invocation.argv, identity, sessionKey)
+    if (result.exitCode === 0 && request.curate === 'block') {
+      result = await curateBlockDetail(result, context)
+    }
   }
   if (result.exitCode === 0 && request.pipeline.length > 0) {
     result = await applyPipeline(result, request.pipeline)

apps/sim/lib/mothership/agent-cli/request-schema.ts

@@ -36,4 +36,5 @@ export const agentCliRequestSchema = z.object({
     ])
   ),
   sink: z.object({ kind: z.literal('sandbox-file'), path: z.string().min(1).max(300) }).optional(),
+  curate: z.literal('block').optional(),
 }) satisfies z.ZodType<AgentCliRequest>

apps/sim/lib/mothership/generated/agent-cli.ts

@@ -69,6 +69,12 @@ export interface AgentCliRequest {
   invocation: AgentCliInvocation;
   pipeline: AgentCliPipeStage[];
   sink?: AgentCliSink;
+  /**
+   * Viewer curation sim applies to the raw result before the pipeline: "block" trims a
+   * block detail to the operations, inputs and models this viewer may use. Decided by the
+   * worker's parse, applied by sim's primitive, so both sides see one policy.
+   */
+  curate?: "block";
 }
 
 /** What sim returns; the worker shapes the model-facing result from it. */