test(tools): bound the names-the-parameter match to whole words

cubic found namesParam was a substring scan after stripping non-letters, so it
accepted exactly the cases the assertion exists to reject:

  "Invalid input"                   satisfied paramName "id"     (generic)
  "projectId cannot have leading …" satisfied paramName "id"     (WRONG param)
  "tableId cannot be '.'"           satisfied paramName "table"  (WRONG param)
  "pathological failure"            satisfied paramName "path"   (substring)

A guard naming the wrong identifier therefore satisfied every rejects-by-name
assertion across all six suites.

The message is now split into letter-only tokens and the parameter must equal a
token or a run of adjacent tokens joined. The join keeps prose spellings valid —
validateFunctionName reports functionName as "Invalid function name", which is
a correct naming, not a near-miss. The run is capped at four tokens and
abandoned once longer than the target.

All 1523 existing assertions still pass, so no guard was relying on the loose
match. namesParam is now exported with its own contract test, because a weakness
in it is invisible from every suite it powers: reverting to the substring
version fails four of the new cases and nothing else.

Author: waleedlatif1

apps/sim/tools/__tests__/path-safety-matcher.test.ts

@@ -0,0 +1,50 @@
+/**
+ * @vitest-environment node
+ *
+ * Contract for `namesParam`, the matcher behind every "names the parameter"
+ * assertion in the path-safety suites.
+ *
+ * It gets its own test because the assertion it powers is only as strong as it
+ * is, and the previous substring implementation passed all seven suites while
+ * accepting a message that named the **wrong** parameter. A weakness here is
+ * invisible everywhere else.
+ */
+import { describe, expect, it } from 'vitest'
+import { namesParam } from '@/tools/__tests__/path-safety'
+
+describe('namesParam', () => {
+  it.each([
+    ['projectId cannot have leading or trailing whitespace', 'projectId'],
+    ['signRequestId cannot have leading or trailing whitespace', 'signRequestId'],
+    ['bucket cannot contain a path separator', 'bucket'],
+    ['path cannot contain an empty or whitespace-only path segment', 'path'],
+    ['tableId cannot be "." (path traversal is not allowed)', 'tableId'],
+    ['Invalid table: must start with a letter or underscore', 'table'],
+  ])('accepts %j as naming %j', (message, paramName) => {
+    expect(namesParam(message, paramName)).toBe(true)
+  })
+
+  /**
+   * A stricter service validator spells the name as prose. Joining adjacent
+   * tokens is what keeps that a correct naming rather than a near-miss.
+   */
+  it('accepts a prose spelling split across words', () => {
+    expect(namesParam('Invalid function name: must contain only letters', 'functionName')).toBe(
+      true
+    )
+  })
+
+  /** Each of these was accepted by the previous substring implementation. */
+  it.each([
+    ['a generic message', 'Invalid input', 'id'],
+    ['a message naming a different parameter', 'projectId cannot be ".."', 'id'],
+    ['a longer parameter name containing this one', 'tableId cannot be "."', 'table'],
+    ['the name as a substring of an unrelated word', 'pathological failure', 'path'],
+  ])('rejects %s', (_label, message, paramName) => {
+    expect(namesParam(message, paramName)).toBe(false)
+  })
+
+  it('rejects an unrelated message outright', () => {
+    expect(namesParam('Something went wrong', 'path')).toBe(false)
+  })
+})

apps/sim/tools/__tests__/path-safety.ts

@@ -424,18 +424,50 @@ export function toolsWithoutPathParams(
 }
 
 /**
- * Normalizes an error message and a parameter name to bare lowercase letters so
- * a guard can be credited with naming its parameter however it spells it.
+ * Reports whether an error message actually names the parameter it is about.
  *
- * A few parameters are refused by a stricter service-specific validator that
- * predates these guards and spells the name in prose — Supabase's
- * `functionName` is reported as *"Invalid function name"*. That is an equally
- * correct outcome and should still count as naming the offender, so both sides
- * are stripped of non-letters before the comparison.
+ * The match is bounded to whole words rather than a substring scan, because a
+ * substring scan quietly accepts the two things this assertion exists to
+ * reject. With a bare `strip(message).includes(strip(paramName))`:
+ *
+ * ```
+ * "Invalid input"                        satisfied paramName "id"     (generic message)
+ * "projectId cannot have leading …"      satisfied paramName "id"     (names the WRONG parameter)
+ * "tableId cannot be '.'"                satisfied paramName "table"  (names the WRONG parameter)
+ * "pathological failure"                 satisfied paramName "path"   (substring of a longer word)
+ * ```
+ *
+ * So the message is split into letter-only tokens, and the parameter matches
+ * only if it equals a token or a run of **adjacent** tokens joined. The join is
+ * what keeps prose spellings working: a stricter service validator reports
+ * `functionName` as *"Invalid function name"*, which is `function` + `name`,
+ * and that is a correct naming rather than a near-miss. The run is capped at
+ * four tokens and abandoned once it is longer than the target, so this stays
+ * linear in the message length.
+ *
+ * Exported so its own contract can be pinned in `path-safety-matcher.test.ts`;
+ * the loose version passed every suite while accepting all four cases above.
  */
-function namesParam(message: string, paramName: string): boolean {
+export function namesParam(message: string, paramName: string): boolean {
   const strip = (text: string) => text.toLowerCase().replaceAll(/[^a-z]/g, '')
-  return strip(message).includes(strip(paramName))
+  const target = strip(paramName)
+  if (!target) return false
+
+  const tokens = message
+    .toLowerCase()
+    .split(/[^a-z]+/)
+    .filter(Boolean)
+
+  for (let start = 0; start < tokens.length; start++) {
+    let joined = ''
+    for (let end = start; end < tokens.length && end < start + 4; end++) {
+      joined += tokens[end]
+      if (joined === target) return true
+      if (joined.length > target.length) break
+    }
+  }
+
+  return false
 }
 
 export interface TraversalOptions {