fix(files): address second search review round

Author: icecrasher321

apps/sim/blocks/blocks/file.test.ts

@@ -83,6 +83,16 @@ describe('FileV5Block', () => {
     expect(maxResults?.value?.()).toBe('50')
   })
 
+  it('uses the default search cap when the builder field is cleared', () => {
+    expect(
+      buildParams({
+        operation: 'file_search',
+        query: 'needle',
+        maxResults: '',
+      })
+    ).toEqual({ query: 'needle', maxResults: 50 })
+  })
+
   it.each(['10.5', '10results', '0', '201'])(
     'rejects invalid builder-configured search cap %s',
     (maxResults) => {

apps/sim/blocks/blocks/file.ts

@@ -1254,7 +1254,9 @@ export const FileV5Block: BlockConfig<FileParserV3Output> = {
         const operation = params.operation || 'file_read'
 
         if (operation === 'file_search') {
-          const maxResults = Number(params.maxResults ?? '50')
+          const maxResultsInput =
+            params.maxResults == null || params.maxResults === '' ? 50 : params.maxResults
+          const maxResults = Number(maxResultsInput)
           if (!Number.isInteger(maxResults) || maxResults < 1 || maxResults > 200) {
             throw new Error('Maximum Results must be an integer between 1 and 200')
           }

apps/sim/lib/internal/file/execute-tool.test.ts

@@ -70,6 +70,26 @@ const BILLING_ATTRIBUTION = {
   payerSubscription: null,
 } satisfies BillingAttributionSnapshot
 
+const SEARCH_RESULT = {
+  results: [{ fileId: 'file-1', lineNumber: 2, text: 'needle' }],
+  count: 1,
+  truncated: false,
+  complete: true,
+  indexStatus: {
+    readyFiles: 1,
+    pendingFiles: 0,
+    failedFiles: 0,
+    skippedFiles: 0,
+    partialFiles: 0,
+  },
+  sources: [
+    {
+      identity: { fileId: 'file-1', key: 'workspace/workspace-1/file.txt' },
+      ownerUserId: 'user-1',
+    },
+  ],
+}
+
 function request(
   toolId: string,
   input: unknown,
@@ -109,25 +129,7 @@ describe('executeFileTool', () => {
     })
     mocks.executeManage.mockResolvedValue(Response.json({ success: true }))
     mocks.executeParser.mockResolvedValue(Response.json({ success: true }))
-    mocks.searchContent.mockResolvedValue({
-      results: [{ fileId: 'file-1', lineNumber: 2, text: 'needle' }],
-      count: 1,
-      truncated: false,
-      complete: true,
-      indexStatus: {
-        readyFiles: 1,
-        pendingFiles: 0,
-        failedFiles: 0,
-        skippedFiles: 0,
-        partialFiles: 0,
-      },
-      sources: [
-        {
-          identity: { fileId: 'file-1', key: 'workspace/workspace-1/file.txt' },
-          ownerUserId: 'user-1',
-        },
-      ],
-    })
+    mocks.searchContent.mockResolvedValue(SEARCH_RESULT)
     mocks.getProvenance.mockResolvedValue({ version: 1, complete: true, entries: [] })
   })
 
@@ -146,7 +148,7 @@ describe('executeFileTool', () => {
     })
     expect(mocks.searchContent).toHaveBeenCalledWith({
       principal: expect.objectContaining({ serviceId: 'executor' }),
-      input: { workspaceId: 'workspace-1', query: 'needle', maxResults: 25 },
+      input: { workspaceId: 'workspace-1', query: 'needle', maxResults: 25, signal: undefined },
     })
     expect(mocks.executeManage).not.toHaveBeenCalled()
   })
@@ -176,7 +178,8 @@ describe('executeFileTool', () => {
         expect.objectContaining({
           identity: expect.objectContaining({ fileId: 'file-1' }),
         }),
-      ])
+      ]),
+      undefined
     )
     const body = await response.json()
     expect(body.data.sources).toBeUndefined()
@@ -207,6 +210,47 @@ describe('executeFileTool', () => {
     })
   })
 
+  it('propagates cancellation that arrives while search work is running', async () => {
+    const controller = new AbortController()
+    mocks.searchContent.mockImplementationOnce(async () => {
+      controller.abort(new DOMException('cancelled', 'AbortError'))
+      return SEARCH_RESULT
+    })
+
+    await expect(
+      executeFileTool(request('file_search', { query: 'needle' }, { signal: controller.signal }))
+    ).rejects.toMatchObject({ name: 'AbortError' })
+    expect(mocks.searchContent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        input: expect.objectContaining({ signal: controller.signal }),
+      })
+    )
+    expect(mocks.getProvenance).not.toHaveBeenCalled()
+  })
+
+  it('propagates cancellation that arrives while search provenance is loading', async () => {
+    const controller = new AbortController()
+    mocks.getProvenance.mockImplementationOnce(async () => {
+      controller.abort(new DOMException('cancelled', 'AbortError'))
+      return { version: 1, complete: true, entries: [] }
+    })
+
+    await expect(
+      executeFileTool(
+        request(
+          'file_search',
+          { query: 'needle' },
+          {
+            signal: controller.signal,
+            headers: new Headers({
+              'x-sim-request-private-tool-metadata': 'resolved-secret-provenance-v1',
+            }),
+          }
+        )
+      )
+    ).rejects.toMatchObject({ name: 'AbortError' })
+  })
+
   it.each(Object.entries(MANAGE_INPUTS))('validates and dispatches %s', async (toolId, input) => {
     const response = await executeFileTool(request(toolId, input))
 

apps/sim/lib/internal/file/execute-tool.ts

@@ -107,16 +107,19 @@ export const executeFileTool: InternalToolOperationHandler = async (request) =>
           workspaceId,
           query: searchInput.data.query,
           maxResults: searchInput.data.maxResults,
+          signal: request.signal,
         },
       })
+      request.signal?.throwIfAborted()
       const { sources, ...data } = result
       const includePrivateProvenance = requestsPrivateToolMetadata(
         request.headers,
         RESOLVED_SECRET_PROVENANCE_METADATA_V1
       )
       const provenance = includePrivateProvenance
-        ? await getFileContentProvenance(principal, workspaceId, sources)
+        ? await getFileContentProvenance(principal, workspaceId, sources, request.signal)
         : undefined
+      request.signal?.throwIfAborted()
       return fileContentJsonResponse(
         { success: true, data },
         includePrivateProvenance,

apps/sim/lib/internal/file/operations.ts

@@ -345,8 +345,10 @@ async function bindSelectedContentFile(
 export async function getFileContentProvenance(
   principal: Principal,
   workspaceId: string,
-  sources: readonly FileContentProvenanceSource[]
+  sources: readonly FileContentProvenanceSource[],
+  signal?: AbortSignal
 ): Promise<ResolvedSecretTraceProvenanceV1> {
+  signal?.throwIfAborted()
   const ownerIds = new Set(
     sources
       .map((source) => source.ownerUserId)
@@ -359,6 +361,7 @@ export async function getFileContentProvenance(
   const accumulator = new ResolvedSecretTraceProvenanceAccumulator(scope)
 
   for (const source of sources) {
+    signal?.throwIfAborted()
     if (!source.identity || !source.ownerUserId) {
       accumulator.markIncomplete('file-source-unidentified')
       continue
@@ -371,6 +374,7 @@ export async function getFileContentProvenance(
         expectedContentUpdatedAt: source.identity.contentUpdatedAt,
       },
     })
+    signal?.throwIfAborted()
     /**
      * `unrecorded` is a more specific `unknown`, and this accumulator has not opted into the
      * workspace file surface's policy, so it latches exactly as it did before.
@@ -766,7 +770,7 @@ export async function executeFileManageOperation(
 
         logger.info('File content extracted', { count: contents.length })
         const provenance = includePrivateContentProvenance
-          ? await getFileContentProvenance(principal, workspaceId, sources)
+          ? await getFileContentProvenance(principal, workspaceId, sources, signal)
           : undefined
 
         return contentResponse({ success: true, data: { contents } }, undefined, provenance)

apps/sim/lib/workspace-files/application/search-workspace-file-content.ts

@@ -9,23 +9,27 @@ export interface SearchWorkspaceFileContentInput {
   workspaceId: string
   query: string
   maxResults: number
+  signal?: AbortSignal
 }
 
-async function resolveSearchWorkspaceFileContext(workspaceId: string) {
-  const workspace = await loadActiveWorkspaceContext(workspaceId)
+async function resolveSearchWorkspaceFileContext(input: SearchWorkspaceFileContentInput) {
+  input.signal?.throwIfAborted()
+  const workspace = await loadActiveWorkspaceContext(input.workspaceId)
+  input.signal?.throwIfAborted()
   if (!workspace) throw new OrchestrationError('not_found', 'Workspace not found')
   return workspace
 }
 
 export const searchWorkspaceFileContent = defineAuthorizedWorkspaceFileUseCase({
   operation: fileOperations.searchContent,
   resolveContext: ({ input }: { input: SearchWorkspaceFileContentInput }) =>
-    resolveSearchWorkspaceFileContext(input.workspaceId),
+    resolveSearchWorkspaceFileContext(input),
   execute: ({ input, context }) =>
     searchWorkspaceFileIndex({
       workspaceId: context.workspaceId,
       query: input.query,
       maxResults: input.maxResults,
       caseSensitive: isFileSearchCaseSensitive(input.query),
+      signal: input.signal,
     }),
 })

apps/sim/lib/workspace-files/search/repository.ts

@@ -42,14 +42,17 @@ interface SearchWorkspaceFileIndexInput {
   query: string
   maxResults: number
   caseSensitive: boolean
+  signal?: AbortSignal
 }
 
 export async function searchWorkspaceFileIndex({
   workspaceId,
   query,
   maxResults,
   caseSensitive,
+  signal,
 }: SearchWorkspaceFileIndexInput): Promise<WorkspaceFileSearchResult> {
+  signal?.throwIfAborted()
   const escapedPattern = `%${escapeFileSearchLikePattern(query)}%`
   const matchExpression = caseSensitive
     ? sql`${workspaceFileSearchSegment.content} LIKE ${escapedPattern} ESCAPE '\\'`
@@ -110,6 +113,7 @@ export async function searchWorkspaceFileIndex({
     )
     .limit(maxResults + 1)
 
+  signal?.throwIfAborted()
   const coverageRows = await db
     .select({
       readyFiles: sql<number>`count(*) filter (where ${workspaceFileSearchIndex.status} = 'ready')::int`,
@@ -134,6 +138,7 @@ export async function searchWorkspaceFileIndex({
       )
     )
 
+  signal?.throwIfAborted()
   const resultRows = rows.slice(0, maxResults)
   const indexStatus = coverageRows[0] ?? {
     readyFiles: 0,
@@ -163,6 +168,7 @@ export async function searchWorkspaceFileIndex({
       suffixOmitted: row.segmentStart + row.content.length < row.lineLength,
     }),
   }))
+  signal?.throwIfAborted()
   return {
     results,
     count: results.length,

apps/sim/lib/workspace-files/search/text.test.ts

@@ -1,5 +1,5 @@
 import { Buffer } from 'node:buffer'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import {
   createFileSearchPreview,
   escapeFileSearchLikePattern,
@@ -51,6 +51,22 @@ describe('workspace file search text utilities', () => {
     expect(Buffer.byteLength(preview, 'utf8')).toBeLessThanOrEqual(2048)
   })
 
+  it('centers previews with locale-independent case folding', () => {
+    const localeLowerCase = vi
+      .spyOn(String.prototype, 'toLocaleLowerCase')
+      .mockImplementation(function (this: string) {
+        return String(this).replaceAll('I', 'ı').toLowerCase()
+      })
+
+    try {
+      const line = `${'x'.repeat(1500)}I${'y'.repeat(1500)}`
+      const preview = createFileSearchPreview(line, 'i', false, 128)
+      expect(preview).toContain('I')
+    } finally {
+      localeLowerCase.mockRestore()
+    }
+  })
+
   it('shows omitted logical-line content beyond the selected segment', () => {
     expect(
       createFileSearchPreview('needle and nearby text', 'needle', false, 2048, {

apps/sim/lib/workspace-files/search/text.ts

@@ -120,8 +120,8 @@ function findFileSearchMatchRange(
     return { start, end: Math.min(line.length, start + query.length) }
   }
 
-  const searchableLine = line.toLocaleLowerCase()
-  const searchableQuery = query.toLocaleLowerCase()
+  const searchableLine = line.toLowerCase()
+  const searchableQuery = query.toLowerCase()
   const foldedStart = searchableLine.indexOf(searchableQuery)
   if (foldedStart < 0) return { start: 0, end: Math.min(line.length, query.length) }
 
@@ -131,7 +131,7 @@ function findFileSearchMatchRange(
     const codePoint = line.codePointAt(offset)
     if (codePoint === undefined) break
     const character = String.fromCodePoint(codePoint)
-    const foldedCharacter = character.toLocaleLowerCase()
+    const foldedCharacter = character.toLowerCase()
     const end = offset + character.length
     for (let foldedOffset = 0; foldedOffset < foldedCharacter.length; foldedOffset += 1) {
       originalStarts.push(offset)

helm/sim/templates/_helpers.tpl

@@ -23,6 +23,19 @@ If release name contains chart name it will be used as a full name.
 {{- end }}
 {{- end }}
 
+{{/*
+Create a CronJob name that leaves room for the Job controller's generated suffix.
+Long names retain a stable hash so independently configured jobs cannot collide.
+*/}}
+{{- define "sim.cronjobName" -}}
+{{- $name := printf "%s-%s" (include "sim.fullname" .root) .jobName -}}
+{{- if gt (len $name) 52 -}}
+{{- printf "%s-%s" ($name | trunc 43 | trimSuffix "-") ($name | sha256sum | trunc 8) -}}
+{{- else -}}
+{{- $name -}}
+{{- end -}}
+{{- end }}
+
 {{/*
 Create chart name and version as used by the chart label.
 */}}
@@ -669,4 +682,4 @@ Validate Copilot configuration
     {{- end -}}
   {{- end -}}
 {{- end -}}
-{{- end }}
+{{- end }}