fix(github): gate the commit lookup on path, coerce line, name the failing field

Three corrections to the file-comment fix, from a validation sweep.

needsCommitLookup did not check `path`, and ran before the `path` branch in
request.url. A file comment with an empty File Path — reachable, since path
is not required on the block — went GET /pulls/{n} then POST /comments with
path undefined, a 422. On staging it posted to /pulls/{n}/reviews, which
GitHub documents as creating a pending review and where commit_id is
optional. The lookup is now gated on path, so only a request headed for
/comments triggers it.

The block has no tools.config.params, so `line` reached the tool as the
string the short-input produced while GitHub types it as an integer — file
comments would still have 422'd, one API call later. Coerced in
request.body, which runs at execution; anything non-finite is omitted
rather than sent as NaN.

readGitHubErrorMessage returned only the top-level message, so a 422 read
"Validation Failed" with no indication of which field was rejected. The
errors[] detail is now appended. Responses without errors[] are unchanged.

Author: waleedlatif1

apps/sim/tools/github/comment.ts

@@ -22,17 +22,34 @@ function pullRequestUrl(params: CreateCommentParams): string {
  * GitHub requires `commit_id` on a pull request review comment. When the caller did
  * not supply one, the pull request is fetched first so its head SHA can be used —
  * mirroring how Jira resolves a missing `cloudId` from `domain`.
+ *
+ * The lookup is gated on `path` because only a request headed for the `/comments`
+ * endpoint needs a commit SHA. `path` is optional on the block, so a file comment
+ * left without one still falls through to `/pulls/{n}/reviews`, where GitHub creates
+ * a pending review and `commit_id` is optional.
  */
 function needsCommitLookup(params: CreateCommentParams): boolean {
-  return params.commentType === 'file_comment' && !params.commitId
+  return params.commentType === 'file_comment' && Boolean(params.path) && !params.commitId
+}
+
+/**
+ * The block renders `line` as a short input, so a typed line number reaches the tool
+ * as a string while GitHub types the field as an integer. Anything that is not a
+ * finite number is omitted rather than sent as `NaN`.
+ */
+function toLineNumber(value: unknown): number | undefined {
+  if (typeof value === 'number') return Number.isFinite(value) ? Math.trunc(value) : undefined
+  if (typeof value !== 'string' || !value.trim()) return undefined
+  const parsed = Number(value.trim())
+  return Number.isFinite(parsed) ? Math.trunc(parsed) : undefined
 }
 
 function fileCommentBody(params: CreateCommentParams, commitId: string): Record<string, any> {
   return {
     body: params.body,
     commit_id: commitId,
     path: params.path,
-    line: params.line,
+    line: toLineNumber(params.line),
     side: params.side || 'RIGHT',
   }
 }

apps/sim/tools/github/response-parsers.ts

@@ -137,12 +137,38 @@ export function requiredRecord(
   return value
 }
 
+/**
+ * Renders one entry of GitHub's `errors[]` array. Entries are either a bare string or
+ * an object carrying some combination of `field`, `code`, and `message`.
+ */
+function readGitHubErrorEntry(entry: unknown): string | undefined {
+  if (typeof entry === 'string') return entry.trim() || undefined
+  if (!isRecordLike(entry)) return undefined
+  const field = typeof entry.field === 'string' ? entry.field.trim() : ''
+  const message = typeof entry.message === 'string' ? entry.message.trim() : ''
+  const code = typeof entry.code === 'string' ? entry.code.trim() : ''
+  const detail = message || code
+  if (!detail) return field || undefined
+  return field ? `${field}: ${detail}` : detail
+}
+
+/**
+ * A GitHub 422 names the offending field only in `errors[]` — the top-level `message`
+ * is the useless `"Validation Failed"`. The field-level detail is appended so the user
+ * can tell which input was rejected. Responses without an `errors[]` array, and
+ * responses without a top-level `message` at all, are unchanged.
+ */
 export async function readGitHubErrorMessage(response: Response): Promise<string | undefined> {
   try {
     const value: unknown = await response.json()
     if (!isRecordLike(value)) return undefined
     const message = value.message
-    return typeof message === 'string' && message.trim() ? message : undefined
+    if (typeof message !== 'string' || !message.trim()) return undefined
+    if (!Array.isArray(value.errors)) return message
+    const details = value.errors
+      .map(readGitHubErrorEntry)
+      .filter((detail): detail is string => Boolean(detail))
+    return details.length ? `${message}: ${details.join('; ')}` : message
   } catch {
     return undefined
   }