fix(microsoft-word): reject non-Word targets, scope SharePoint access, and tighten input bounds

Author: waleedlatif1

apps/docs/content/docs/en/integrations/microsoft_word.mdx

@@ -248,7 +248,7 @@ List or search Microsoft Word (.docx) documents in OneDrive or SharePoint. Non-W
 | `query` | string | No | Search text matched against file name, metadata, and content. If omitted, the documents directly inside the folder are listed. |
 | `folderId` | string | No | The ID of the folder to list or search within. If omitted, the drive root is used. |
 | `driveId` | string | No | The ID of the drive to list from. Required for SharePoint. If omitted, uses the personal OneDrive. |
-| `pageSize` | number | No | Maximum number of items to request from Microsoft Graph \(1-$\{MAX_PAGE_SIZE\}, default $\{DEFAULT_PAGE_SIZE\}\) |
+| `pageSize` | number | No | Maximum number of items to request from Microsoft Graph \(1-200, default 50\) |
 | `pageToken` | string | No | Continuation URL from a previous response's nextPageToken, used to fetch the next page |
 
 #### Output

apps/sim/app/api/tools/microsoft_word/append/route.test.ts

@@ -129,6 +129,49 @@ describe('POST /api/tools/microsoft_word/append', () => {
     )
   })
 
+  it('refuses to write Word bytes over a drive item that is not a .docx', async () => {
+    const pdf = {
+      id: 'doc-abc',
+      name: 'invoice.pdf',
+      cTag: 'tag-1',
+      file: { mimeType: 'application/pdf' },
+    }
+    mockSecureFetchWithPinnedIP.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      statusText: '',
+      headers: new Headers(),
+      body: null,
+      text: async () => JSON.stringify(pdf),
+      json: async () => pdf,
+      arrayBuffer: async () => new ArrayBuffer(0),
+    })
+
+    const response = await POST(createMockRequest('POST', baseBody))
+
+    expect(response.status).toBe(400)
+    const data = (await response.json()) as { error: string }
+    expect(data.error).toMatch(/not a Word document/)
+    expect(mockSecureFetchWithPinnedIP.mock.calls.some((call) => call[2]?.method === 'PUT')).toBe(
+      false
+    )
+  })
+
+  it('reports a no-op without writing when the content adds no paragraph', async () => {
+    mockSecureFetchWithPinnedIP
+      .mockResolvedValueOnce(itemResponse('tag-1'))
+      .mockResolvedValueOnce(await docxResponse())
+
+    const response = await POST(createMockRequest('POST', { ...baseBody, content: '   \n  \n' }))
+
+    expect(response.status).toBe(200)
+    const data = (await response.json()) as { output: { updatedContent: boolean } }
+    expect(data.output.updatedContent).toBe(false)
+    expect(mockSecureFetchWithPinnedIP.mock.calls.some((call) => call[2]?.method === 'PUT')).toBe(
+      false
+    )
+  })
+
   it('surfaces a 412 from the upload precondition as the same conflict', async () => {
     mockSecureFetchWithPinnedIP
       .mockResolvedValueOnce(itemResponse('tag-1'))

apps/sim/app/api/tools/microsoft_word/append/route.ts

@@ -44,22 +44,38 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
 
   try {
     const basePath = getDocumentBasePath(documentId, driveId ?? undefined)
-    const contentTag = getContentTag(await fetchDocumentItem(basePath, accessToken))
+    const existingItem = await fetchDocumentItem(basePath, accessToken)
+    const contentTag = getContentTag(existingItem)
 
     const existingBuffer = await downloadDocumentContent(basePath, accessToken)
-    const updatedBuffer = await appendParagraphsToDocx(existingBuffer, content)
+    const { buffer, paragraphsAppended } = await appendParagraphsToDocx(existingBuffer, content)
+
+    if (paragraphsAppended === 0) {
+      logger.info(`[${requestId}] No paragraphs to append; document left untouched`, { documentId })
+      return NextResponse.json({
+        success: true,
+        output: {
+          updatedContent: false,
+          metadata: toDocumentMetadata(existingItem, documentId),
+        },
+      })
+    }
 
     await assertContentUnchanged(basePath, accessToken, contentTag)
 
     const item = await uploadDocumentContent(
       `${basePath}/content`,
       accessToken,
-      updatedBuffer,
+      buffer,
       DOCX_MIME_TYPE,
       contentTag
     )
 
-    logger.info(`[${requestId}] Appended to Word document`, { documentId, size: item.size })
+    logger.info(`[${requestId}] Appended to Word document`, {
+      documentId,
+      paragraphsAppended,
+      size: item.size,
+    })
 
     return NextResponse.json({
       success: true,

apps/sim/app/api/tools/onedrive/folders/route.ts

@@ -34,6 +34,7 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
     const validation = onedriveFoldersQuerySchema.safeParse({
       credentialId: searchParams.get('credentialId') ?? '',
       query: searchParams.get('query') ?? undefined,
+      driveId: searchParams.get('driveId') ?? undefined,
     })
     if (!validation.success) {
       logger.warn(`[${requestId}] Invalid folders request data`, {
@@ -44,7 +45,7 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
         { status: 400 }
       )
     }
-    const { credentialId } = validation.data
+    const { credentialId, driveId } = validation.data
     const query = validation.data.query ?? ''
 
     const credentialIdValidation = validateMicrosoftGraphId(credentialId, 'credentialId')
@@ -70,7 +71,19 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
       return NextResponse.json({ error: 'Failed to obtain valid access token' }, { status: 401 })
     }
 
-    let url = `https://graph.microsoft.com/v1.0/me/drive/root/children?$filter=folder ne null&$select=id,name,folder,webUrl,createdDateTime,lastModifiedDateTime&$top=${ONEDRIVE_FOLDERS_PAGE_SIZE}`
+    // Scope to the requested drive so a SharePoint-targeted block does not list
+    // the signed-in user's personal OneDrive folders instead.
+    let drivePath = 'me/drive'
+    if (driveId) {
+      const driveIdValidation = validateMicrosoftGraphId(driveId, 'driveId')
+      if (!driveIdValidation.isValid) {
+        logger.warn(`[${requestId}] Invalid drive ID`, { error: driveIdValidation.error })
+        return NextResponse.json({ error: driveIdValidation.error }, { status: 400 })
+      }
+      drivePath = `drives/${driveId}`
+    }
+
+    let url = `https://graph.microsoft.com/v1.0/${drivePath}/root/children?$filter=folder ne null&$select=id,name,folder,webUrl,createdDateTime,lastModifiedDateTime&$top=${ONEDRIVE_FOLDERS_PAGE_SIZE}`
 
     if (query) {
       url += `&$search="${encodeURIComponent(query)}"`

apps/sim/blocks/blocks/microsoft_word.ts

@@ -260,8 +260,8 @@ export const MicrosoftWordBlock: BlockConfig<MicrosoftWordResponse> = {
       selectorKey: 'onedrive.folders',
       requiredScopes: [],
       mimeType: 'application/vnd.microsoft.graph.folder',
-      placeholder: 'Leave empty for the OneDrive root',
-      dependsOn: ['credential'],
+      placeholder: 'Leave empty to use the drive root',
+      dependsOn: ['credential', 'driveId'],
       mode: 'basic',
       condition: { field: 'operation', value: ['create', 'create_from_template'] },
     },
@@ -291,8 +291,8 @@ export const MicrosoftWordBlock: BlockConfig<MicrosoftWordResponse> = {
       selectorKey: 'onedrive.folders',
       requiredScopes: [],
       mimeType: 'application/vnd.microsoft.graph.folder',
-      placeholder: 'Leave empty for the OneDrive root',
-      dependsOn: ['credential'],
+      placeholder: 'Leave empty to use the drive root',
+      dependsOn: ['credential', 'driveId'],
       mode: 'basic',
       condition: { field: 'operation', value: 'list' },
     },

apps/sim/hooks/selectors/providers/microsoft/selectors.ts

@@ -227,12 +227,13 @@ export const microsoftSelectors = {
       'selectors',
       'onedrive.folders',
       context.oauthCredential ?? 'none',
+      context.driveId ?? 'none',
     ],
     enabled: ({ context }) => Boolean(context.oauthCredential),
     fetchList: async ({ context, signal }: SelectorQueryArgs) => {
       const credentialId = ensureCredential(context, 'onedrive.folders')
       const data = await requestJson(selectorContracts.onedriveFoldersSelectorContract, {
-        query: { credentialId },
+        query: { credentialId, driveId: context.driveId },
         signal,
       })
       return (data.files || []).map((file) => ({

apps/sim/lib/api/contracts/selectors/microsoft.ts

@@ -68,7 +68,14 @@ export const onedriveFolderQuerySchema = z.object({
 })
 
 export const onedriveFilesQuerySchema = credentialIdQueryWithSearchSchema
-export const onedriveFoldersQuerySchema = credentialIdQueryWithSearchSchema
+/**
+ * Folder listing is drive-scoped like the file listing above: without `driveId`
+ * the picker would always show the signed-in user's OneDrive, even for a block
+ * pointed at a SharePoint document library.
+ */
+export const onedriveFoldersQuerySchema = credentialIdQueryWithSearchSchema.extend({
+  driveId: z.string().optional(),
+})
 export const outlookFoldersQuerySchema = credentialIdQuerySchema
 
 export const outlookFoldersSelectorContract = defineGetSelector(

apps/sim/lib/api/contracts/tools/microsoft.ts

@@ -111,6 +111,47 @@ export const dataverseUploadFileBodySchema = z.object({
  */
 const MAX_DOCUMENT_CONTENT_LENGTH = 2_000_000
 
+/**
+ * Ceiling on the serialized placeholder map. Replacement values are substituted
+ * into a package that is rewritten in memory, so they need the same kind of
+ * bound the generated document text has.
+ */
+const MAX_REPLACEMENTS_LENGTH = 200_000
+
+/** Whether a string parses as a JSON object (not an array or scalar). */
+function isJsonObjectString(value: string): boolean {
+  if (!value.trim()) return true
+  try {
+    const parsed: unknown = JSON.parse(value)
+    return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * The placeholder map, accepted either as an object from the editor or as the
+ * JSON string a variable reference resolves to. Both forms are bounded and both
+ * must describe an object, so malformed caller input is a 400 rather than a 500
+ * raised later while the template is being filled.
+ */
+const wordReplacementsSchema = z
+  .union([
+    z
+      .string()
+      .refine(
+        isJsonObjectString,
+        'Placeholder values must be a JSON object mapping each placeholder to its value'
+      ),
+    z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()])),
+  ])
+  .refine(
+    (value) =>
+      (typeof value === 'string' ? value.length : JSON.stringify(value).length) <=
+      MAX_REPLACEMENTS_LENGTH,
+    'Placeholder values are too long'
+  )
+
 const wordDocumentIdSchema = z.string().min(1, 'Document ID is required')
 const wordDriveIdSchema = z.string().optional().nullable()
 
@@ -148,13 +189,7 @@ export const microsoftWordCreateFromTemplateBodySchema = z.object({
   accessToken: accessTokenSchema,
   templateDocumentId: z.string().min(1, 'Template document ID is required'),
   name: z.string().min(1, 'Document name is required').max(255, 'Document name is too long'),
-  replacements: z
-    .union([
-      z.string(),
-      z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()])),
-    ])
-    .optional()
-    .nullable(),
+  replacements: wordReplacementsSchema.optional().nullable(),
   matchCase: z.boolean().optional().nullable(),
   folderId: z.string().optional().nullable(),
   driveId: wordDriveIdSchema,

apps/sim/lib/microsoft-word/document.server.test.ts

@@ -100,7 +100,7 @@ describe('buildDocxFromContent', () => {
 describe('appendParagraphsToDocx', () => {
   it('keeps the existing content and adds the new paragraphs after it', async () => {
     const original = await buildDocxFromContent('Existing paragraph')
-    const updated = await appendParagraphsToDocx(original, 'Appended paragraph')
+    const { buffer: updated } = await appendParagraphsToDocx(original, 'Appended paragraph')
     const text = await extractDocxText(updated)
 
     expect(text).toContain('Existing paragraph')
@@ -110,7 +110,7 @@ describe('appendParagraphsToDocx', () => {
 
   it('inserts before the body-level section properties', async () => {
     const original = await buildDocxFromContent('Existing paragraph')
-    const updated = await appendParagraphsToDocx(original, 'Appended paragraph')
+    const { buffer: updated } = await appendParagraphsToDocx(original, 'Appended paragraph')
     const xml = await readDocumentXml(updated)
 
     const appendedIndex = xml.indexOf('Appended paragraph')
@@ -122,7 +122,7 @@ describe('appendParagraphsToDocx', () => {
 
   it('preserves every other part of the original package', async () => {
     const original = await buildDocxFromContent('# Heading\n- bullet')
-    const updated = await appendParagraphsToDocx(original, 'More')
+    const { buffer: updated } = await appendParagraphsToDocx(original, 'More')
 
     const originalNames = Object.keys((await JSZip.loadAsync(original)).files).sort()
     const updatedNames = Object.keys((await JSZip.loadAsync(updated)).files).sort()
@@ -132,7 +132,7 @@ describe('appendParagraphsToDocx', () => {
 
   it('escapes XML metacharacters instead of emitting broken markup', async () => {
     const original = await buildDocxFromContent('Existing')
-    const updated = await appendParagraphsToDocx(original, 'a < b & c > d')
+    const { buffer: updated } = await appendParagraphsToDocx(original, 'a < b & c > d')
     const xml = await readDocumentXml(updated)
 
     expect(xml).toContain('a &lt; b &amp; c &gt; d')
@@ -141,12 +141,27 @@ describe('appendParagraphsToDocx', () => {
 
   it('skips blank lines so appended text does not grow trailing paragraphs', async () => {
     const original = await buildDocxFromContent('Existing')
-    const updated = await appendParagraphsToDocx(original, 'one\n\n\ntwo')
+    const { buffer: updated } = await appendParagraphsToDocx(original, 'one\n\n\ntwo')
     const xml = await readDocumentXml(updated)
 
     expect(xml.match(/<w:p><w:r><w:t xml:space="preserve">/g)).toHaveLength(2)
   })
 
+  it('reports a no-op for whitespace-only content and leaves the package untouched', async () => {
+    const original = await buildDocxFromContent('Existing')
+    const result = await appendParagraphsToDocx(original, '   \n\n  \n')
+
+    expect(result.paragraphsAppended).toBe(0)
+    expect(result.buffer).toBe(original)
+  })
+
+  it('reports how many paragraphs it appended', async () => {
+    const original = await buildDocxFromContent('Existing')
+    const result = await appendParagraphsToDocx(original, 'one\ntwo\nthree')
+
+    expect(result.paragraphsAppended).toBe(3)
+  })
+
   it('rejects an archive that is not a Word package', async () => {
     const zip = new JSZip()
     zip.file('hello.txt', 'not a word document')
@@ -158,6 +173,22 @@ describe('appendParagraphsToDocx', () => {
   })
 })
 
+describe('extractDocxText', () => {
+  it('reads a blank Word document as empty text rather than failing', async () => {
+    const blank = await buildDocxFromContent('')
+
+    await expect(extractDocxText(blank)).resolves.toBe('')
+  })
+
+  it('still fails on an archive that is not a Word package', async () => {
+    const zip = new JSZip()
+    zip.file('hello.txt', 'not a word document')
+    const buffer = await zip.generateAsync({ type: 'nodebuffer' })
+
+    await expect(extractDocxText(buffer)).rejects.toThrow()
+  })
+})
+
 describe('replaceTextInDocx', () => {
   it('replaces text inside a single run and keeps that run formatting', async () => {
     const original = await buildDocxWithRuns([