fix(agiloft): redact credentials before the shared reader truncates the body

Review round 3.

The create path redacts before truncating, but natural language search reads
its response through readAlrestJson, which embeds its own truncated slice of
the body in the error it throws. The route redacted that message afterwards,
by which point a credential clipped at the 300-character boundary had already
been reduced to a prefix that a full-value replace can never match.

readAlrestJson now redacts while the text is whole, for the callers that send
credentials on the request itself. The rest authenticate with a bearer token
and cannot echo one back, so they pass nothing and are unchanged.

Login had the same shape and no redaction at all, which is worse than the
reported case: EWLogin posts the credentials in its form body, and all three
of its failure paths relayed the response text. It now redacts before any of
them run.

The regression test asserts no prefix of the password survives, not just the
whole value, since a prefix is what the boundary produces.

Author: mzxchandra

apps/sim/app/api/tools/agiloft/nlp_search/route.test.ts

@@ -222,3 +222,30 @@ describe('EWNLPSearch response', () => {
     expect(data.output.truncated).toBe(true)
   })
 })
+
+describe('EWNLPSearch credential handling at the truncation boundary', () => {
+  /**
+   * The shared alrest reader embeds a truncated slice of the body in its error.
+   * Clipping before redacting can cut through a credential and leave a prefix
+   * the route's later replace can no longer match, so the redaction has to
+   * happen while the text is still whole.
+   */
+  it('redacts a credential that would otherwise be clipped by truncation', async () => {
+    const filler = 'x'.repeat(290)
+    inputValidationMockFns.mockSecureFetchWithPinnedIP.mockResolvedValueOnce(
+      res({
+        ok: false,
+        status: 500,
+        text: `${filler}$password=${PLACEHOLDER_PASSWORD}`,
+      })
+    )
+
+    const response = await POST(createMockRequest('POST', baseBody))
+    const data = (await response.json()) as { error?: string }
+
+    expect(data.error).not.toContain(PLACEHOLDER_PASSWORD)
+    for (let cut = 6; cut < PLACEHOLDER_PASSWORD.length; cut++) {
+      expect(data.error).not.toContain(PLACEHOLDER_PASSWORD.slice(0, cut))
+    }
+  })
+})

apps/sim/app/api/tools/agiloft/nlp_search/route.ts

@@ -73,7 +73,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
            * the two halves deliberately use different conventions. Do not
            * "correct" this to `parseEwRest` to match create.
            */
-          const payload = await readAlrestJson<Record<string, unknown>[]>(response)
+          const payload = await readAlrestJson<Record<string, unknown>[]>(response, params)
 
           /**
            * `result` is documented as an array, but a single-record or empty-object

apps/sim/tools/agiloft/utils.server.ts

@@ -7,7 +7,12 @@ import {
   validateUrlWithDNS,
 } from '@/lib/core/security/input-validation.server'
 import type { AgiloftBaseParams, AgiloftCredentials } from '@/tools/agiloft/types'
-import { AGILOFT_LANG, agiloftAlrestBase, describeAgiloftError } from '@/tools/agiloft/utils'
+import {
+  AGILOFT_LANG,
+  agiloftAlrestBase,
+  describeAgiloftError,
+  redactAgiloftSecrets,
+} from '@/tools/agiloft/utils'
 import type { HttpMethod, ToolResponse } from '@/tools/types'
 
 const logger = createLogger('AgiloftAuthServer')
@@ -104,7 +109,12 @@ export async function agiloftLoginPinned(
     ),
   })
 
-  const text = await response.text()
+  /**
+   * Login posts the credentials in its form body, so an error page echoing the
+   * submitted parameters echoes them. Redacted while the text is still whole,
+   * before any of the messages below truncate it.
+   */
+  const text = redactAgiloftSecrets(await response.text(), params)
 
   if (!response.ok) {
     throw new Error(`Agiloft login failed (${response.status}): ${describeAgiloftError(text)}`)
@@ -237,12 +247,26 @@ export function isAgiloftRefusal(error: unknown): error is AgiloftAlrestError {
  * — whether it failed by status code, by `success: false`, or by returning
  * something that is not JSON at all.
  */
-export async function readAlrestJson<T>(response: SecureFetchResponse): Promise<T | undefined> {
-  const text = await response.text()
+export async function readAlrestJson<T>(
+  response: SecureFetchResponse,
+  credentials?: { login: string; password: string }
+): Promise<T | undefined> {
+  const rawText = await response.text()
+
+  /**
+   * Redacted here rather than by the caller, because the messages below embed a
+   * truncated slice of the body. Clipping first can cut through a credential and
+   * leave a prefix that a later full-value replace can no longer match, so the
+   * redaction has to happen while the text is still whole.
+   *
+   * `credentials` is passed by the operations that send them on the request
+   * itself; the rest authenticate with a bearer token and cannot echo one back.
+   */
+  const text = credentials ? redactAgiloftSecrets(rawText, credentials) : rawText
 
   let envelope: AlrestEnvelope<T>
   try {
-    envelope = JSON.parse(text)
+    envelope = JSON.parse(rawText)
   } catch {
     throw new AgiloftAlrestError(
       `Agiloft returned a non-JSON response (${response.status}): ${truncate(text, 300)}`
@@ -257,7 +281,9 @@ export async function readAlrestJson<T>(response: SecureFetchResponse): Promise<
         .join('; ') ||
       envelope.message ||
       describeAgiloftError(truncate(text, 300))
-    throw new AgiloftAlrestError(`Agiloft error: ${detail}`)
+    throw new AgiloftAlrestError(
+      `Agiloft error: ${credentials ? redactAgiloftSecrets(detail, credentials) : detail}`
+    )
   }
 
   return envelope.result