fix(grok): support /c/<id> URL pattern and responseNodes API shape

- Add /c/<id> to conversation ID regex (was only /chat/ and /i/grok/)
- Fix response-node parsing: API returns { responseNodes: [] } wrapper,
  not a tree rooted at a single RawResponseNode — caused 0 messages saved
- Keep legacy plain-array and nodes fallbacks for older API versions

Author: vchan-in

src/content-scripts/grok.tsx

@@ -9,9 +9,9 @@ import { mountWidget } from "./mount";
 import { FloatingDial } from "./FloatingDial";
 
 function getConversationId(): string | null {
-  // URL pattern: grok.com/chat/<id> or x.com/i/grok/<id>
+  // URL pattern: grok.com/c/<id>, grok.com/chat/<id>, or x.com/i/grok/<id>
   const match = window.location.pathname.match(
-    /(?:\/chat\/|\/i\/grok\/)([a-zA-Z0-9_-]+)/
+    /(?:\/c\/|\/chat\/|\/i\/grok\/)([a-zA-Z0-9_-]+)/
   );
   return match?.[1] ?? null;
 }
@@ -39,16 +39,14 @@ function attachViaFileInput(text: string): boolean {
 }
 
 function injectIntoTextarea(text: string) {
-  const tryAttach = () => attachViaFileInput(text);
-
-  if (tryAttach()) return;
+  if (attachViaFileInput(text)) return;
 
   // Retry – the file input may not be in the DOM until the user has focused
   // the composer at least once.
   let attempts = 0;
   const interval = setInterval(() => {
     attempts++;
-    if (tryAttach() || attempts > 20) {
+    if (attachViaFileInput(text) || attempts > 20) {
       clearInterval(interval);
     }
   }, 250);

src/extractors/grok.ts

@@ -1,29 +1,42 @@
 /* ──────────────────────────────────────────────
  *  Extractor – Grok (grok.com)
  *
- *  Endpoint: /rest/app-chat/conversations
+ *  Three-step fetch per conversation:
+ *    1. LIST   GET  /rest/app-chat/conversations?pageSize=60[&cursor=…]
+ *    2. IDs    GET  /rest/app-chat/conversations/{id}/response-node?includeThreads=true
+ *    3. BODY   POST /rest/app-chat/conversations/{id}/load-responses
+ *                   body: { responseIds: string[] }
+ *
  *  Auth: cookie-based (sso + sso-rw). No CSRF header required.
- *  Pagination: pageSize + cursor (X/Twitter API style).
+ *  Pagination: cursor-based (nextCursor field in response wrapper).
  * ────────────────────────────────────────────── */
 
 import type { Extractor } from "./base";
-import type { Message, Thread } from "../types/schema";
+import type { Message, Thread, Role } from "../types/schema";
 import { uuid, jitteredDelay } from "../utils/helpers";
 
-const BASE = "";
 const PAGE_SIZE = 60;
 
 async function apiFetch<T>(path: string): Promise<T> {
-  const res = await fetch(`${BASE}${path}`, {
+  const res = await fetch(path, {
     credentials: "include",
-    headers: {
-      "Content-Type": "application/json",
-    },
+    headers: { "Content-Type": "application/json" },
   });
   if (!res.ok) {
-    throw new Error(
-      `Grok API ${path} returned ${res.status}: ${res.statusText}`
-    );
+    throw new Error(`Grok API GET ${path} → ${res.status}: ${res.statusText}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+async function apiPost<T>(path: string, body: unknown): Promise<T> {
+  const res = await fetch(path, {
+    method: "POST",
+    credentials: "include",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    throw new Error(`Grok API POST ${path} → ${res.status}: ${res.statusText}`);
   }
   return res.json() as Promise<T>;
 }
@@ -46,28 +59,57 @@ type RawConvListResponse =
   | RawConvListItem[]
   | { conversations: RawConvListItem[]; nextCursor?: string; cursor?: string };
 
-interface RawGrokMessage {
+/**
+ * Shape returned by GET .../response-node?includeThreads=true
+ *
+ * Grok returns a flat list of nodes under `responseNodes`.
+ * Each node has a `responseId` and optional `parentResponseId`.
+ * Older API versions may return a tree via `children`/`nodes`.
+ */
+interface RawResponseNode {
+  responseId?: string;
   id?: string;
+  sender?: string;
+  parentResponseId?: string;
+  children?: RawResponseNode[];
+  nodes?: RawResponseNode[];
+  responses?: RawResponseNode[];
+}
+
+interface RawResponseNodeResult {
+  responseNodes?: RawResponseNode[];
+  // legacy / alternate shapes
+  nodes?: RawResponseNode[];
+}
+
+/** Shape of each item returned by POST .../load-responses */
+interface RawLoadedMessage {
+  responseId?: string;
   messageId?: string;
+  id?: string;
   sender?: "human" | "assistant";
   role?: "user" | "assistant";
   message?: string;
   text?: string;
+  query?: string;      // user turn (some versions)
+  response?: string;   // assistant turn (some versions)
   createTime?: string;
   created_at?: string;
   model?: string;
 }
 
-interface RawConversation {
+type RawLoadResponsesResult =
+  | RawLoadedMessage[]
+  | { responses: RawLoadedMessage[] };
+
+interface RawConvMeta {
   conversationId?: string;
   id?: string;
   title?: string;
   createTime?: string;
   modifyTime?: string;
   created_at?: string;
   updated_at?: string;
-  responses?: RawGrokMessage[];
-  messages?: RawGrokMessage[];
 }
 
 /* ── helpers ──────────────────────────────────────────────── */
@@ -81,18 +123,38 @@ function normaliseItem(item: RawConvListItem): { providerId: string; title: stri
   };
 }
 
-function mapMessages(raw: RawGrokMessage[]): Message[] {
-  return raw.map((m) => {
-    const role: "user" | "assistant" =
+/** Recursively collect all responseId values from a node tree. */
+function collectResponseIds(node: RawResponseNode): string[] {
+  const ids: string[] = [];
+  const id = node.responseId ?? node.id;
+  if (id) ids.push(id);
+  const children = node.children ?? node.nodes ?? node.responses ?? [];
+  for (const child of children) {
+    ids.push(...collectResponseIds(child));
+  }
+  return ids;
+}
+
+function mapMessages(raw: RawLoadedMessage[]): Message[] {
+  const out: Message[] = [];
+  for (const m of raw) {
+    const role: Role =
       m.role === "user" || m.sender === "human" ? "user" : "assistant";
-    return {
-      id: m.messageId ?? m.id ?? uuid(),
+    const content =
+      m.message ??
+      m.text ??
+      (role === "user" ? m.query : m.response) ??
+      "";
+    if (!content) continue;
+    out.push({
+      id: m.responseId ?? m.messageId ?? m.id ?? uuid(),
       role,
-      content: m.message ?? m.text ?? "",
+      content,
       createdAt: m.createTime ?? m.created_at ?? "",
       model: m.model,
-    };
-  });
+    });
+  }
+  return out;
 }
 
 /* ── Extractor implementation ─────────────────────────────── */
@@ -102,7 +164,6 @@ export const grokExtractor: Extractor = {
     const all: { providerId: string; title: string; createdAt: string; updatedAt: string }[] = [];
     let cursor: string | undefined;
 
-    // eslint-disable-next-line no-constant-condition
     while (true) {
       const qs = cursor
         ? `pageSize=${PAGE_SIZE}&cursor=${encodeURIComponent(cursor)}`
@@ -131,10 +192,7 @@ export const grokExtractor: Extractor = {
       if (nextCursor) {
         cursor = nextCursor;
         await jitteredDelay(500, 1200);
-      } else if (items.length < PAGE_SIZE) {
-        break;
       } else {
-        // No cursor returned but page was full — stop to avoid infinite loop.
         break;
       }
     }
@@ -143,19 +201,56 @@ export const grokExtractor: Extractor = {
   },
 
   async fetchThread(conversationId: string): Promise<Thread> {
-    const raw = await apiFetch<RawConversation>(
+    // Step 1: fetch conversation metadata (title, timestamps)
+    const meta = await apiFetch<RawConvMeta>(
       `/rest/app-chat/conversations/${conversationId}`
     );
 
-    const messages = mapMessages(raw.responses ?? raw.messages ?? []);
+    // Step 2: fetch the response-node list to collect all response IDs
+    const nodeResult = await apiFetch<RawResponseNodeResult | RawResponseNode[]>(
+      `/rest/app-chat/conversations/${conversationId}/response-node?includeThreads=true`
+    );
+
+    let responseIds: string[];
+    if (Array.isArray(nodeResult)) {
+      // legacy: root is a plain array
+      responseIds = nodeResult.flatMap(collectResponseIds);
+    } else {
+      // current API: { responseNodes: [...] }
+      const flatNodes =
+        (nodeResult as RawResponseNodeResult).responseNodes ??
+        (nodeResult as RawResponseNodeResult).nodes ??
+        [];
+      responseIds = flatNodes.flatMap(collectResponseIds);
+    }
+
+    // Step 3: load full message bodies
+    let messages: Message[] = [];
+    if (responseIds.length > 0) {
+      const loaded = await apiPost<RawLoadResponsesResult>(
+        `/rest/app-chat/conversations/${conversationId}/load-responses`,
+        { responseIds }
+      );
+
+      const rawMessages = Array.isArray(loaded)
+        ? loaded
+        : (loaded.responses ?? []);
+
+      messages = mapMessages(rawMessages);
+    }
 
     return {
       id: uuid(),
       providerId: conversationId,
       provider: "grok",
-      title: raw.title || "Untitled",
-      createdAt: raw.createTime ?? raw.created_at ?? "",
-      updatedAt: raw.modifyTime ?? raw.updated_at ?? raw.createTime ?? raw.created_at ?? "",
+      title: meta.title || "Untitled",
+      createdAt: meta.createTime ?? meta.created_at ?? "",
+      updatedAt:
+        meta.modifyTime ??
+        meta.updated_at ??
+        meta.createTime ??
+        meta.created_at ??
+        "",
       messages,
       tags: [],
     };