diggylab 0.1.44 → 0.1.46

package/README.md

@@ -52,6 +52,19 @@ npm publish apps/desktop-agent/dist-npm --access public
 
 `CLI_PACKAGE_VERSION=0.1.31` works as well.
 
+## Local development
+
+Run the CLI from source against the local API without touching a real installation:
+
+```bash
+pnpm dev:cli                  # prints status against http://localhost:4000 and ~/.diggylab-dev
+pnpm dev:cli pair             # forwards any command to the CLI
+pnpm dev:cli --build run      # rebuilds dist-cli first, then runs the worker
+```
+
+The wrapper points `DIGGYLAB_API_URL` at `http://localhost:4000` and `DIGGYLAB_AGENT_DIR` at
+`~/.diggylab-dev`; set either variable to override the defaults.
+
 ## Commands
 
 | Command | What it does |

package/cli.js

@@ -5,10 +5,12 @@ import { randomUUID as randomUUID3 } from "node:crypto";
 import { spawn } from "node:child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { hostname, homedir } from "node:os";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { dirname as dirname3, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../../packages/facebook-scanner/dist/parser.js
+var COMMENT_TEXT_LIMIT = 2e3;
+var COMMENT_AUTHOR_LIMIT = 200;
 var paths = {
   text: [["message", "text"], ["comet_sections", "content", "story", "message", "text"], ["text"]],
   url: [["url"], ["permalink_url"], ["wwwURL"], ["comet_sections", "content", "story", "url"]],
@@ -36,6 +38,35 @@ var textFormatPaths = [
     "text_format_metadata"
   ]
 ];
+var commentTextPaths = [
+  ["body", "text"],
+  ["comment_body", "text"],
+  ["preferred_body", "text"]
+];
+var commentAuthorPaths = [
+  ["author", "name"],
+  ["author_name"],
+  ["author", "short_name"]
+];
+var commentAvatarPaths = [
+  ["author", "profile_picture_depth_0", "uri"],
+  ["author", "profile_picture_depth_1", "uri"],
+  ["author", "profile_picture_depth_0_increased", "uri"],
+  ["author", "profile_picture", "uri"]
+];
+var commentTimePaths = [
+  ["created_time"],
+  ["creation_time"],
+  ["publish_time"]
+];
+var commentCountPaths = [
+  ["feedback", "comment_count", "total_count"],
+  ["feedback", "comments", "total_count"],
+  ["feedback", "total_comment_count"],
+  ["comment_count", "total_count"],
+  ["comments", "total_count"],
+  ["total_comment_count"]
+];
 var facebookHosts = /* @__PURE__ */ new Set([
   "facebook.com",
   "fb.com",
@@ -197,6 +228,55 @@ function getTextFormat(node) {
   };
   return Object.values(textFormat).some(Boolean) ? textFormat : void 0;
 }
+function getCommentCount(node) {
+  return firstCount(node, commentCountPaths) ?? sweepCommentCount(node, 0);
+}
+function firstCount(root, candidates) {
+  for (const path of candidates) {
+    const count = toCount(get(root, path));
+    if (count !== void 0)
+      return count;
+  }
+  return void 0;
+}
+function sweepCommentCount(value, depth) {
+  if (!value || depth > 10)
+    return void 0;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const count = sweepCommentCount(item, depth + 1);
+      if (count !== void 0)
+        return count;
+    }
+    return void 0;
+  }
+  if (!isData(value))
+    return void 0;
+  if ("comment_id" in value || "parent_comment" in value)
+    return void 0;
+  const typename = typeof value.__typename === "string" ? value.__typename : void 0;
+  if (typename && /comment$/i.test(typename))
+    return void 0;
+  const direct = toCount(value.comment_count) ?? toCount(value.total_comment_count) ?? toCount(value.comments);
+  if (direct !== void 0)
+    return direct;
+  for (const child of Object.values(value)) {
+    const count = sweepCommentCount(child, depth + 1);
+    if (count !== void 0)
+      return count;
+  }
+  return void 0;
+}
+function toCount(value) {
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+  }
+  if (typeof value === "string" && /^\d{1,9}$/.test(value))
+    return Number(value);
+  if (isData(value))
+    return toCount(value.total_count);
+  return void 0;
+}
 function collectImageUrls(value, urls, depth) {
   if (!value || depth > 12 || urls.size >= 12)
     return;
@@ -258,12 +338,14 @@ function toItem(node, requestedGroup) {
       attachmentImages = dedupeImageUrls([...fallbackUrls]);
   }
   const textFormat = getTextFormat(node);
+  const commentCount = getCommentCount(node);
   return {
     text,
     url,
     authorName: firstString(node, paths.author),
     ...authorAvatarUrl ? { authorAvatarUrl } : {},
     ...attachmentImages.length ? { attachmentImages } : {},
+    ...commentCount !== void 0 ? { commentCount } : {},
     ...textFormat ? { textFormat } : {},
     publishedAt: toIso(firstString(node, paths.time)),
     groupName: firstString(node, paths.group)
@@ -298,6 +380,9 @@ function mergeFacebookScanItems(items, limit) {
       if (!existing.authorAvatarUrl && item.authorAvatarUrl) {
         existing.authorAvatarUrl = item.authorAvatarUrl;
       }
+      if (existing.commentCount === void 0 && item.commentCount !== void 0) {
+        existing.commentCount = item.commentCount;
+      }
       const attachmentImages = dedupeImageUrls([
         ...existing.attachmentImages ?? [],
         ...item.attachmentImages ?? []
@@ -327,6 +412,134 @@ function parseFacebookGraphqlBody(body, groupUrl) {
   }
   return mergeFacebookScanItems(items, Number.POSITIVE_INFINITY);
 }
+function toComment(node) {
+  const typename = typeof node.__typename === "string" ? node.__typename : void 0;
+  const text = firstString(node, commentTextPaths);
+  if (!text || typename && !/comment$/i.test(typename))
+    return void 0;
+  const authorName = firstString(node, commentAuthorPaths);
+  const authorAvatarUrl = firstString(node, commentAvatarPaths, false);
+  const depth = toDepth(node);
+  const publishedAt = toIso(firstString(node, commentTimePaths));
+  const id = firstString(node, [["id"]], false);
+  const parentId = firstString(node, [["comment_direct_parent", "id"]], false);
+  return {
+    text: text.trim(),
+    ...authorName ? { authorName } : {},
+    ...authorAvatarUrl ? { authorAvatarUrl } : {},
+    ...depth !== void 0 ? { depth } : {},
+    ...id ? { id } : {},
+    ...parentId ? { parentId } : {},
+    ...publishedAt ? { publishedAt } : {}
+  };
+}
+function toDepth(node) {
+  const value = node.depth;
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 5 ? value : void 0;
+}
+function visitComments(value, items) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      visitComments(item, items);
+    return;
+  }
+  if (!isData(value))
+    return;
+  const comment = toComment(value);
+  if (comment)
+    items.push(comment);
+  for (const child of Object.values(value))
+    visitComments(child, items);
+}
+function parseFacebookCommentBodies(body) {
+  const items = [];
+  for (const line of body.split(/\r?\n/)) {
+    const json = line.trim().replace(/^for\s*\(;;\);/, "");
+    if (!json.startsWith("{") && !json.startsWith("["))
+      continue;
+    try {
+      visitComments(JSON.parse(json), items);
+    } catch {
+    }
+  }
+  return mergeFacebookComments(items, Number.POSITIVE_INFINITY);
+}
+function parseFacebookCommentJson(value) {
+  const items = [];
+  visitComments(value, items);
+  return mergeFacebookComments(items, Number.POSITIVE_INFINITY);
+}
+function mergeFacebookComments(items, limit) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const text = item.text.trim();
+    if (!text)
+      continue;
+    const authorName = item.authorName?.trim();
+    const key = `${authorName ?? ""}\0${commentKeyText(text)}`;
+    const existing = merged.get(key);
+    if (existing) {
+      if (!existing.publishedAt && item.publishedAt)
+        existing.publishedAt = item.publishedAt;
+      if (!existing.authorAvatarUrl && item.authorAvatarUrl) {
+        existing.authorAvatarUrl = item.authorAvatarUrl;
+      }
+      if (!existing.id && item.id)
+        existing.id = item.id;
+      if (!existing.parentId && item.parentId)
+        existing.parentId = item.parentId;
+      if (item.depth !== void 0) {
+        existing.depth = existing.depth === void 0 ? item.depth : Math.min(existing.depth, item.depth);
+      }
+      continue;
+    }
+    if (merged.size >= limit)
+      continue;
+    merged.set(key, {
+      text: text.slice(0, COMMENT_TEXT_LIMIT),
+      ...authorName ? { authorName: authorName.slice(0, COMMENT_AUTHOR_LIMIT) } : {},
+      ...item.authorAvatarUrl ? { authorAvatarUrl: item.authorAvatarUrl } : {},
+      ...item.depth !== void 0 ? { depth: item.depth } : {},
+      ...item.id ? { id: item.id } : {},
+      ...item.parentId ? { parentId: item.parentId } : {},
+      ...item.publishedAt ? { publishedAt: item.publishedAt } : {}
+    });
+  }
+  return orderFacebookCommentThreads([...merged.values()]);
+}
+function orderFacebookCommentThreads(items) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.id && !byId.has(item.id))
+      byId.set(item.id, item);
+  }
+  const children = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const item of items) {
+    if (item.parentId && byId.has(item.parentId)) {
+      children.set(item.parentId, [...children.get(item.parentId) ?? [], item]);
+    } else {
+      roots.push(item);
+    }
+  }
+  const ordered = [];
+  const visited = /* @__PURE__ */ new Set();
+  const append = (item, depth) => {
+    if (visited.has(item))
+      return;
+    visited.add(item);
+    ordered.push({ ...item, depth: Math.max(depth, item.depth ?? 0) });
+    for (const child of item.id ? children.get(item.id) ?? [] : [])
+      append(child, depth + 1);
+  };
+  for (const root of roots)
+    append(root, 0);
+  for (const item of items) {
+    if (!visited.has(item))
+      append(item, item.depth ?? 0);
+  }
+  return ordered;
+}
 async function extractFacebookDomItems(page, groupUrl) {
   const requestedGroup = requestedGroupIdentifier(groupUrl);
   if (!requestedGroup)
@@ -348,12 +561,16 @@ async function extractFacebookDomItems(page, groupUrl) {
     const message = Array.from(article.querySelectorAll('[data-ad-preview="message"]')).find((element) => belongsToArticle(element) && element.checkVisibility());
     const author = Array.from(article.querySelectorAll("h2 a, h3 a, strong a")).find((element) => belongsToArticle(element) && element.checkVisibility());
     const time = Array.from(article.querySelectorAll("time[datetime], abbr[data-utime]")).find((element) => belongsToArticle(element) && element.checkVisibility());
+    const countText = Array.from(article.querySelectorAll('a, [role="button"]')).filter((element) => belongsToArticle(element) && element.checkVisibility()).map((element) => element.innerText.trim()).find((text) => /(?:^|\s)\d+\s*(?:bình luận|comments?)$/i.test(text));
+    const countMatch = countText ? /(\d+)\s*(?:bình luận|comments?)$/i.exec(countText) : null;
+    const commentCount = countMatch ? Number(countMatch[1]) : void 0;
     const attachmentImages = Array.from(article.querySelectorAll("img")).filter((image) => belongsToArticle(image) && image.naturalWidth >= 200).map((image) => image.currentSrc || image.src).filter((src) => /^https?:\/\//i.test(src) && /(scontent\.|fbcdn\.net)/i.test(src));
     return {
       text: message?.innerText ?? "",
       urls,
       authorName: author?.innerText,
       publishedAt: time?.getAttribute("datetime") ?? time?.getAttribute("data-utime") ?? void 0,
+      ...commentCount !== void 0 ? { commentCount } : {},
       ...attachmentImages.length ? { attachmentImages } : {}
     };
   }));
@@ -364,10 +581,80 @@ async function extractFacebookDomItems(page, groupUrl) {
       url,
       authorName: item.authorName,
       publishedAt: item.publishedAt,
+      ...item.commentCount !== void 0 ? { commentCount: item.commentCount } : {},
       ...item.attachmentImages?.length ? { attachmentImages: dedupeImageUrls(item.attachmentImages) } : {}
     }] : [];
   }), Number.POSITIVE_INFINITY);
 }
+async function extractFacebookDomComments(page) {
+  const raw = await page.locator('[role="article"][aria-label]').evaluateAll((articles) => articles.map((article) => {
+    const label = (article.getAttribute("aria-label") ?? "").trim();
+    if (!/^(?:bình luận|comment|trả lời|reply)\b/i.test(label) || !article.checkVisibility()) {
+      return void 0;
+    }
+    const belongsToArticle = (element) => element.closest('[role="article"]') === article;
+    const readText = (element) => {
+      let text = "";
+      for (const node of Array.from(element.childNodes)) {
+        if (node.nodeType === Node.TEXT_NODE) {
+          text += node.textContent ?? "";
+        } else if (node instanceof HTMLImageElement) {
+          text += node.getAttribute("alt") ?? "";
+        } else if (node instanceof HTMLElement) {
+          text += readText(node);
+        }
+      }
+      return text.trim();
+    };
+    const texts = Array.from(article.querySelectorAll('[dir="auto"]')).filter((element) => belongsToArticle(element) && element.checkVisibility()).map((element) => readText(element)).filter(Boolean);
+    const time = Array.from(article.querySelectorAll("time[datetime], abbr[data-utime]")).find((element) => belongsToArticle(element) && element.checkVisibility());
+    return {
+      texts: Array.from(new Set(texts)),
+      authorLabel: label,
+      publishedAt: time?.getAttribute("datetime") ?? time?.getAttribute("data-utime") ?? void 0
+    };
+  }));
+  return mergeFacebookComments(raw.flatMap((item) => {
+    if (!item)
+      return [];
+    const authorName = parseCommentAuthor(item.authorLabel);
+    const text = pickCommentText(item.texts, authorName);
+    if (!text)
+      return [];
+    const depth = parseCommentDepth(item.authorLabel);
+    return [{
+      text,
+      ...authorName ? { authorName } : {},
+      ...depth !== void 0 ? { depth } : {},
+      ...toIso(item.publishedAt) ? { publishedAt: toIso(item.publishedAt) } : {}
+    }];
+  }), Number.POSITIVE_INFINITY);
+}
+function pickCommentText(texts, authorName) {
+  if (!Array.isArray(texts) || !texts.length)
+    return "";
+  const candidates = texts.filter((text) => text !== authorName && !COMMENT_UI_LABELS.test(text));
+  return candidates.reduce((longest, text) => text.length > longest.length ? text : longest, "");
+}
+var COMMENT_UI_LABELS = /^(?:follow|theo dõi|like|thích|reply|trả lời|share|chia sẻ|see more|xem thêm|hide|ẩn|report|báo cáo)$/i;
+function commentKeyText(text) {
+  const normalized = text.replace(/[\p{Extended_Pictographic}\u200d\uFE0F]/gu, "").replace(/[:;=8xX]-?[)(\]\[dDpP/\\|]+/g, "").replace(/\s+/g, " ").trim();
+  return normalized || text.replace(/\s+/g, " ");
+}
+function parseCommentAuthor(label) {
+  const match = /^(?:bình luận|comment|trả lời|reply)\s+(?:dưới tên|by)\s+(.+)$/i.exec(label.trim());
+  if (!match)
+    return void 0;
+  const name = match[1].replace(/\s+vào\s+.*$/i, "").replace(/\s+on\s+.*$/i, "").replace(/\s+to\s+.*$/i, "").replace(/\s+\d+\s*(?:giây|phút|giờ|ngày|tuần|tháng|năm|seconds?|minutes?|hours?|days?|weeks?|months?|years?)\s*(?:ago|trước)?\s*$/i, "").trim();
+  return name || void 0;
+}
+function parseCommentDepth(label) {
+  const trimmed = label.trim();
+  if (/^(?:bình luận|comment)\b/i.test(trimmed))
+    return 0;
+  const parentPart = trimmed.split(/\s+(?:to|về|của)\s+/i)[1] ?? "";
+  return /\brepl(?:y|ies)\b|trả lời|phản hồi/i.test(parentPart) ? 2 : 1;
+}
 
 // ../../packages/facebook-scanner/dist/session.js
 async function detectFacebookSession(page, context) {
@@ -403,13 +690,19 @@ var FacebookScannerError = class extends Error {
 var FacebookScanner = class {
   browserType;
   extractDomItems;
+  extractDomComments;
   parseGraphqlBody;
+  parseGraphqlComments;
+  parseCommentJson;
   graphqlResponseTimeoutMs;
   running = false;
   constructor(options) {
     this.browserType = options.browserType;
     this.extractDomItems = options.extractDomItems ?? extractFacebookDomItems;
+    this.extractDomComments = options.extractDomComments ?? extractFacebookDomComments;
     this.parseGraphqlBody = options.parseGraphqlBody ?? parseFacebookGraphqlBody;
+    this.parseGraphqlComments = options.parseGraphqlComments ?? parseFacebookCommentBodies;
+    this.parseCommentJson = options.parseCommentJson ?? parseFacebookCommentJson;
     this.graphqlResponseTimeoutMs = options.graphqlResponseTimeoutMs ?? 1e4;
   }
   async scanMany(options) {
@@ -431,6 +724,79 @@ var FacebookScanner = class {
       this.running = false;
     }
   }
+  async fetchComments(options) {
+    if (this.running)
+      throw new FacebookScannerError("SCANNER_BUSY");
+    const target = normalizePostUrl(options.postUrl);
+    if (!target)
+      throw new FacebookScannerError("POST_URL_INVALID");
+    assertNotAborted(options.signal);
+    this.running = true;
+    let browser = null;
+    try {
+      browser = await this.browserType.launch({ headless: true });
+      const context = await browser.newContext({ storageState: options.storageState });
+      let page = null;
+      const graphqlComments = [];
+      const responseTasks = [];
+      const responseHandler = (response) => {
+        if (!response.url().includes("/api/graphql/"))
+          return;
+        responseTasks.push(withTimeout(response.text(), this.graphqlResponseTimeoutMs).then((body) => graphqlComments.push(...this.parseGraphqlComments(body))).then(() => void 0).catch(() => void 0));
+      };
+      try {
+        page = await context.newPage();
+        page.on("response", responseHandler);
+        await page.route("**/*", (route) => ["font", "image", "media"].includes(route.request().resourceType()) ? route.abort() : route.continue());
+        try {
+          await page.goto(target, { waitUntil: "domcontentloaded", timeout: 45e3 });
+        } catch {
+          throw new FacebookScannerError("NAVIGATION_FAILED");
+        }
+        const condition = await detectFacebookSession(page, context);
+        if (condition !== "READY")
+          throw new FacebookScannerError(condition);
+        await options.onProgress?.({ phase: "FETCHING", commentCount: 0 });
+        const embeddedComments = await readEmbeddedComments(page, this.parseCommentJson);
+        let comments = [];
+        let idleRounds = 0;
+        let rounds = 0;
+        while (comments.length < options.limit && idleRounds < 3 && rounds < 20) {
+          assertNotAborted(options.signal);
+          rounds += 1;
+          const previousCount = comments.length;
+          await page.waitForTimeout(1200);
+          await drain(responseTasks, this.graphqlResponseTimeoutMs);
+          const domComments2 = await this.extractDomComments(page);
+          comments = mergeFacebookComments([...embeddedComments, ...graphqlComments, ...domComments2], options.limit);
+          if (comments.length !== previousCount) {
+            await options.onProgress?.({ phase: "FETCHING", commentCount: comments.length });
+          }
+          const expanded = await clickCommentExpanders(page);
+          idleRounds = comments.length === previousCount && !expanded ? idleRounds + 1 : 0;
+          if (comments.length < options.limit) {
+            await scrollCommentArea(page);
+            await page.mouse.wheel(0, 2e3);
+          }
+        }
+        assertNotAborted(options.signal);
+        await drain(responseTasks, this.graphqlResponseTimeoutMs);
+        const domComments = await this.extractDomComments(page);
+        comments = mergeFacebookComments([...embeddedComments, ...graphqlComments, ...domComments], options.limit);
+        await options.onProgress?.({ phase: "COMPLETE", commentCount: comments.length });
+        return comments;
+      } finally {
+        page?.off("response", responseHandler);
+        await page?.unroute("**/*").catch(() => void 0);
+        await Promise.allSettled(responseTasks);
+        await page?.close();
+        await context.close();
+      }
+    } finally {
+      await browser?.close();
+      this.running = false;
+    }
+  }
   async scanGroup(browser, options, groupUrl, groupIndex) {
     const context = await browser.newContext({ storageState: options.storageState });
     let page = null;
@@ -510,6 +876,58 @@ function withTimeout(promise, timeoutMs) {
   });
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
+var COMMENT_EXPANDER_PATTERN = /^(?:xem|view)\b.*(?:bình luận|comments?|câu trả lời|repl(?:y|ies))/i;
+var MAX_EXPANDER_CLICKS = 4;
+async function clickCommentExpanders(page) {
+  let clicked = 0;
+  for (let attempt = 0; attempt < MAX_EXPANDER_CLICKS; attempt += 1) {
+    const buttons = page.getByRole("button", { name: COMMENT_EXPANDER_PATTERN });
+    let count = 0;
+    try {
+      count = await buttons.count();
+    } catch {
+      break;
+    }
+    if (!count)
+      break;
+    try {
+      await buttons.first().click({ timeout: 1e3 });
+      clicked += 1;
+    } catch {
+      break;
+    }
+  }
+  return clicked;
+}
+async function scrollCommentArea(page) {
+  await page.evaluate(() => {
+    const article = document.querySelector('[role="article"][aria-label]');
+    let node = article instanceof HTMLElement ? article.parentElement : null;
+    while (node) {
+      if (node.scrollHeight > node.clientHeight + 80) {
+        node.scrollTop = node.scrollHeight;
+        return;
+      }
+      node = node.parentElement;
+    }
+    window.scrollTo(0, document.body.scrollHeight);
+  }).catch(() => void 0);
+}
+async function readEmbeddedComments(page, parse) {
+  const blocks = await page.evaluate(() => Array.from(document.querySelectorAll('script[type="application/json"]')).map((script) => script.textContent ?? "").filter((text) => text.includes('"Comment"'))).catch(() => []);
+  if (!Array.isArray(blocks))
+    return [];
+  const items = [];
+  for (const block of blocks) {
+    if (typeof block !== "string")
+      continue;
+    try {
+      items.push(...parse(JSON.parse(block)));
+    } catch {
+    }
+  }
+  return mergeFacebookComments(items, Number.POSITIVE_INFINITY);
+}
 
 // src/cli/cli.ts
 import { chromium } from "playwright";
@@ -625,7 +1043,7 @@ function sanitize(value) {
   return value.replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]").replace(/\b(authorization|cookie|set-cookie|token|access[ _-]?token|refresh[ _-]?token|api[ _-]?key|private[ _-]?key|signature|pairing[ _-]?code|storage[ _-]?state)\b\s*[:=]\s*[^\s;]+/gi, "$1=[REDACTED]").replace(/https?:\/\/[^\s/@:]+:[^\s/@]+@/gi, "https://[REDACTED]@").replace(/\b[A-F0-9]{32}\b/gi, "[REDACTED]").replace(/[\r\n\t]+/g, " ").trim();
 }
 function isEntry(value) {
-  return typeof value?.id === "string" && typeof value.timestamp === "string" && ["INFO", "WARN", "ERROR"].includes(value.level) && ["CONNECTION", "PAIRING", "FACEBOOK", "SCAN", "UPLOAD", "SYSTEM"].includes(value.category) && typeof value.code === "string" && typeof value.message === "string";
+  return typeof value?.id === "string" && typeof value.timestamp === "string" && ["INFO", "WARN", "ERROR"].includes(value.level) && ["CONNECTION", "PAIRING", "FACEBOOK", "SCAN", "COMMENTS", "UPLOAD", "SYSTEM"].includes(value.category) && typeof value.code === "string" && typeof value.message === "string";
 }
 
 // src/main/browser-runtime.ts
@@ -926,6 +1344,8 @@ import { randomUUID } from "node:crypto";
 
 // ../../packages/shared/src/index.ts
 var DESKTOP_AGENT_PROTOCOL_VERSION = 1;
+var DESKTOP_POST_COMMENTS_MAX_LIMIT = 200;
+var DESKTOP_POST_COMMENTS_REQUEST_TIMEOUT_MS = 3 * 60 * 1e3;
 
 // src/main/desktop-agent-session.ts
 var MESSAGE_FRESHNESS_MS = 5 * 60 * 1e3;
@@ -1091,7 +1511,8 @@ var DesktopAgentSession = class {
         platform: this.options.platform,
         state: this.reportedState,
         facebookReady: this.options.getFacebookReady(),
-        currentJobId: this.reportedJobId
+        currentJobId: this.reportedJobId,
+        capabilities: ["POST_COMMENTS", "POST_COMMENTS_MORE"]
       });
       this.handshake = "WELCOME";
       return;
@@ -1135,8 +1556,15 @@ var DesktopAgentSession = class {
       this.emitJob({ type: "STOP", ...envelope.payload });
       return;
     }
+    if (envelope.type === "POST_COMMENTS_FETCH") {
+      if (!isPostCommentsFetch(envelope.payload)) {
+        this.protocolFailure(socket, stored, generation);
+        return;
+      }
+      this.emitJob({ type: "COMMENTS", ...envelope.payload });
+      return;
+    }
     if (envelope.type !== "SCAN_JOB_START") {
-      this.protocolFailure(socket, stored, generation);
       return;
     }
     this.update({ ...this.snapshot, currentJobId: envelope.payload.jobId, pendingJobId: null });
@@ -1280,6 +1708,11 @@ function describeEnvelopeProblem(envelope, deviceId, replayIds) {
   if (replayIds.has(envelope.messageId)) return `replayed message ${envelope.messageId}`;
   return "unknown";
 }
+function isPostCommentsFetch(value) {
+  if (!value || typeof value !== "object") return false;
+  const payload = value;
+  return typeof payload.requestId === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(payload.requestId) && typeof payload.postUrl === "string" && payload.postUrl.length <= 2e3 && /^https:\/\/[\w.-]*facebook\.com\//i.test(payload.postUrl) && typeof payload.limit === "number" && Number.isInteger(payload.limit) && payload.limit > 0 && payload.limit <= DESKTOP_POST_COMMENTS_MAX_LIMIT;
+}
 function emptySnapshot(state) {
   return {
     state,
@@ -1309,6 +1742,161 @@ function readErrorCode(error) {
   return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN_ERROR";
 }
 
+// src/main/desktop-comment-runner.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 2 * 60 * 1e3;
+var DEFAULT_MAX_QUEUE = 5;
+var DesktopCommentRunner = class {
+  options;
+  queue = [];
+  listeners = /* @__PURE__ */ new Set();
+  stopController = new AbortController();
+  active = null;
+  currentController = null;
+  unsubscribe = null;
+  stopped = false;
+  constructor(options) {
+    this.options = options;
+  }
+  start() {
+    if (this.unsubscribe) return;
+    this.unsubscribe = this.options.session.subscribeJobs((event) => this.handleEvent(event));
+  }
+  stop() {
+    this.stopped = true;
+    this.queue.length = 0;
+    this.stopController.abort();
+    this.currentController?.abort();
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+  }
+  isRunning() {
+    return this.active !== null;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  async whenIdle() {
+    await this.active;
+  }
+  async handleEvent(event) {
+    if (event.type !== "COMMENTS" || this.stopped) return;
+    if (this.queue.length >= (this.options.maxQueue ?? DEFAULT_MAX_QUEUE)) {
+      await this.fail(event, "QUEUE_FULL");
+      return;
+    }
+    this.queue.push(event);
+    await this.drain();
+  }
+  drain() {
+    if (!this.active) {
+      this.active = this.run().finally(() => {
+        this.active = null;
+      });
+    }
+    return this.active;
+  }
+  async run() {
+    while (this.queue.length > 0 && !this.stopped) {
+      const request = this.queue.shift();
+      if (request) await this.process(request);
+    }
+  }
+  async process(request) {
+    const controller = new AbortController();
+    const timeout = this.options.setTimer(
+      () => controller.abort(),
+      this.options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS
+    );
+    this.currentController = controller;
+    this.emit({ type: "STARTED", requestId: request.requestId, postUrl: request.postUrl });
+    try {
+      if (this.options.isScanActive()) {
+        await this.fail(request, "SCANNER_BUSY");
+        return;
+      }
+      if (this.options.isLoginActive()) {
+        await this.fail(request, "LOGIN_ACTIVE");
+        return;
+      }
+      const storageState = await this.options.facebookState.load();
+      if (!storageState) {
+        await this.fail(request, "FACEBOOK_SESSION_MISSING");
+        return;
+      }
+      let comments;
+      try {
+        comments = await this.options.scanner.fetchComments({
+          limit: request.limit,
+          postUrl: request.postUrl,
+          signal: controller.signal,
+          storageState
+        });
+      } catch (error) {
+        await this.fail(request, readErrorCode2(error));
+        return;
+      }
+      if (!await this.upload(request.requestId, { comments })) {
+        if (!this.stopped) {
+          this.emit({
+            type: "FAILED",
+            requestId: request.requestId,
+            postUrl: request.postUrl,
+            errorCode: "UPLOAD_FAILED"
+          });
+        }
+        return;
+      }
+      this.emit({
+        type: "SUCCEEDED",
+        requestId: request.requestId,
+        postUrl: request.postUrl,
+        commentCount: comments.length
+      });
+    } finally {
+      this.options.clearTimer(timeout);
+      if (this.currentController === controller) this.currentController = null;
+    }
+  }
+  async fail(request, errorCode) {
+    await this.upload(request.requestId, { comments: [], errorCode });
+    this.emit({
+      type: "FAILED",
+      requestId: request.requestId,
+      postUrl: request.postUrl,
+      errorCode
+    });
+  }
+  emit(event) {
+    for (const listener of this.listeners) listener(event);
+  }
+  async upload(requestId, payload) {
+    const signal = this.stopController.signal;
+    if (signal.aborted) return false;
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        await this.options.http.uploadComments(requestId, payload, signal);
+        return true;
+      } catch (error) {
+        if (!isRecoverable(error) || attempt >= 2 || signal.aborted) return false;
+        try {
+          await this.options.wait(1e3 * 2 ** attempt, signal);
+        } catch {
+          return false;
+        }
+      }
+    }
+  }
+};
+function readErrorCode2(error) {
+  const code = error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : "";
+  const sanitized = code.replace(/[^A-Z0-9_]/g, "_").slice(0, 100);
+  return sanitized || "COMMENT_FETCH_FAILED";
+}
+function isRecoverable(error) {
+  return Boolean(error && typeof error === "object" && "recoverable" in error && error.recoverable === true);
+}
+
 // src/main/desktop-scan-http.ts
 import { createHash, createPrivateKey, randomUUID as randomUUID2, sign } from "node:crypto";
 var RESPONSE_LIMIT2 = 64 * 1024;
@@ -1344,6 +1932,13 @@ var DesktopScanHttp = class {
   cancel(jobId, attemptToken) {
     return this.signedPost(`/leads/desktop-agent/jobs/${jobId}/cancel`, { attemptToken });
   }
+  uploadComments(requestId, payload, signal) {
+    return this.signedPost(
+      `/leads/desktop-agent/post-comments/${requestId}`,
+      normalizeComments(payload),
+      signal
+    );
+  }
   async signedPost(path, businessPayload, signal) {
     const credential = this.getCredential();
     if (!credential) throw new DesktopScanHttpError("CREDENTIAL_UNAVAILABLE");
@@ -1425,10 +2020,12 @@ function normalizeBatch(payload) {
     const authorAvatarUrl = normalizeMediaUrl(item.authorAvatarUrl);
     const attachmentImages = item.attachmentImages?.map(normalizeMediaUrl).filter((url) => Boolean(url)).slice(0, 6);
     const groupName = typeof item.groupName === "string" && item.groupName.trim() ? item.groupName.trim().slice(0, 200) : void 0;
+    const commentCount = normalizeCount(item.commentCount);
     const textFormat = normalizeTextFormat(item.textFormat);
     return {
       ...item,
       ...groupName ? { groupName } : {},
+      ...commentCount !== void 0 ? { commentCount } : {},
       sourceUrl: normalizeFacebookPostUrl(item.sourceUrl),
       authorAvatarUrl,
       attachmentImages: attachmentImages?.length ? attachmentImages : void 0,
@@ -1485,6 +2082,24 @@ function normalizeFormatToken(value) {
   const normalized = value?.trim();
   return normalized && normalized.length <= 50 ? normalized : void 0;
 }
+function normalizeCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= 1e7 ? value : void 0;
+}
+function normalizeComments(payload) {
+  const comments = payload.comments.slice(0, DESKTOP_POST_COMMENTS_MAX_LIMIT).map((comment) => {
+    const authorAvatarUrl = normalizeMediaUrl(comment.authorAvatarUrl);
+    const depth = normalizeCount(comment.depth);
+    return {
+      text: comment.text.trim().slice(0, 2e3),
+      ...comment.authorName?.trim() ? { authorName: comment.authorName.trim().slice(0, 200) } : {},
+      ...authorAvatarUrl ? { authorAvatarUrl } : {},
+      ...depth !== void 0 && depth <= 5 ? { depth } : {},
+      ...comment.publishedAt ? { publishedAt: comment.publishedAt } : {}
+    };
+  }).filter((comment) => comment.text.length > 0);
+  const errorCode = payload.errorCode?.replace(/[^A-Z0-9_]/g, "_").slice(0, 100);
+  return { comments, ...errorCode ? { errorCode } : {} };
+}
 function normalizeFacebookPostUrl(value) {
   try {
     const url = new URL(value);
@@ -1525,7 +2140,7 @@ var DesktopScanRunner = class {
       records = await this.options.spool.loadAll();
     } catch (error) {
       this.recoveryBlocked = true;
-      this.update({ ...idleSnapshot(), state: "SPOOL_FULL", errorCode: readErrorCode2(error) });
+      this.update({ ...idleSnapshot(), state: "SPOOL_FULL", errorCode: readErrorCode3(error) });
       return;
     }
     const current = records.find((record) => Date.parse(record.job.leaseExpiresAt) > this.options.now()) ?? null;
@@ -1587,6 +2202,7 @@ var DesktopScanRunner = class {
     return true;
   }
   async handleEvent(event) {
+    if (event.type === "COMMENTS") return;
     if (event.type === "AVAILABLE") {
       await this.claimIfReady(event.jobId);
       return;
@@ -1653,6 +2269,7 @@ var DesktopScanRunner = class {
   async claimIfReady(jobId) {
     const session = this.options.session.getSnapshot();
     if (this.recoveryBlocked || this.active || this.snapshot.jobId || session.currentJobId || session.state !== "ONLINE" || session.accessMode !== "FULL" || this.options.isLoginActive() || !await this.options.facebookState.isReady()) return;
+    if (this.options.isCommentFetchActive?.()) return;
     this.options.session.claimJob(jobId);
   }
   async run(job, resume) {
@@ -1783,7 +2400,7 @@ var DesktopScanRunner = class {
       this.recovered = null;
       this.options.session.finishJob(job.jobId);
     } catch (error) {
-      const code = readErrorCode2(error);
+      const code = readErrorCode3(error);
       const checkpoint = code === "LOGIN_REQUIRED" || code === "CHECKPOINT_REQUIRED";
       if (code === "OFFLINE_PENDING") {
         this.recovered = record;
@@ -1820,7 +2437,7 @@ var DesktopScanRunner = class {
           await this.options.spool.put(record);
           confirmed = await this.completeWithRetry(job, completion, controller.signal);
         } catch (completionError) {
-          const completionCode = readErrorCode2(completionError);
+          const completionCode = readErrorCode3(completionError);
           terminalPersistenceFailed = true;
           this.recovered = record;
           this.update({
@@ -1856,7 +2473,7 @@ var DesktopScanRunner = class {
         await this.options.http.uploadBatch(job.jobId, batch, signal);
         return true;
       } catch (error) {
-        if (!isRecoverable(error)) throw error;
+        if (!isRecoverable2(error)) throw error;
         if (attempt >= 4) return false;
         attempt += 1;
         await this.options.wait(Math.min(8e3, 500 * 2 ** attempt), signal);
@@ -1871,7 +2488,7 @@ var DesktopScanRunner = class {
         await this.options.http.complete(job.jobId, payload, signal);
         return true;
       } catch (error) {
-        if (!isRecoverable(error)) throw error;
+        if (!isRecoverable2(error)) throw error;
         if (attempt >= 4) return false;
         attempt += 1;
         await this.options.wait(Math.min(8e3, 500 * 2 ** attempt), signal);
@@ -1916,6 +2533,7 @@ function toDesktopPost(item) {
     ...item.authorName ? { authorName: item.authorName } : {},
     ...item.authorAvatarUrl ? { authorAvatarUrl: item.authorAvatarUrl } : {},
     ...item.attachmentImages?.length ? { attachmentImages: item.attachmentImages } : {},
+    ...item.commentCount !== void 0 ? { commentCount: item.commentCount } : {},
     ...item.textFormat ? { textFormat: item.textFormat } : {},
     ...item.publishedAt ? { publishedAt: item.publishedAt } : {},
     ...item.groupName ? { groupName: item.groupName } : {}
@@ -1960,10 +2578,10 @@ function createSpoolRecord(job, now) {
 function nowIso(now) {
   return new Date(now).toISOString();
 }
-function readErrorCode2(error) {
+function readErrorCode3(error) {
   return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code.slice(0, 500) : "SCAN_FAILED";
 }
-function isRecoverable(error) {
+function isRecoverable2(error) {
   return Boolean(error && typeof error === "object" && "recoverable" in error && error.recoverable === true);
 }
 function abortableDelay(milliseconds, signal) {
@@ -2304,6 +2922,21 @@ function getFacebookAccountId(state) {
   return value && /^\d{1,32}$/.test(value) ? value : null;
 }
 
+// src/main/graphql-dump.ts
+import { writeFile as writeFile4 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+function createGraphqlDumpParser(directory) {
+  if (!directory) return void 0;
+  return (body, groupUrl) => {
+    void writeFile4(
+      join3(directory, `graphql-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.txt`),
+      `// group: ${groupUrl}
+${body}`
+    ).catch(() => void 0);
+    return parseFacebookGraphqlBody(body, groupUrl);
+  };
+}
+
 // src/main/reconnect-backoff.ts
 var BASE_DELAY_MS = 1e3;
 var MAX_DELAY_MS = 3e4;
@@ -2574,7 +3207,7 @@ var MISSING_BROWSER_HINT = "Chromium for Playwright is not installed yet. Run `d
 function agentVersion() {
   let directory = fileURLToPath(new URL(".", import.meta.url));
   for (let depth = 0; depth < 4; depth += 1) {
-    const manifest = join3(directory, "package.json");
+    const manifest = join4(directory, "package.json");
     if (existsSync2(manifest)) {
       try {
         const version = JSON.parse(readFileSync2(manifest, "utf8")).version;
@@ -2591,7 +3224,7 @@ function resolvePlatform() {
   return process.platform === "linux" ? "LINUX" : "WINDOWS";
 }
 function resolveConfigDirectory(options) {
-  return options.config?.trim() || process.env.DIGGYLAB_AGENT_DIR?.trim() || join3(homedir(), CONFIG_DIRECTORY);
+  return options.config?.trim() || process.env.DIGGYLAB_AGENT_DIR?.trim() || join4(homedir(), CONFIG_DIRECTORY);
 }
 function resolveEndpoint(options) {
   const configured = (options.api ?? process.env.DIGGYLAB_API_URL)?.trim() || "https://api.diggylab.com";
@@ -2601,12 +3234,12 @@ function resolveEndpoint(options) {
 function createRuntime(options) {
   const directory = resolveConfigDirectory(options);
   const endpoint = resolveEndpoint(options);
-  const crypto2 = createFileCrypto(join3(directory, "key"));
-  const credentials = new CredentialStore(join3(directory, "credentials.json"), crypto2);
+  const crypto2 = createFileCrypto(join4(directory, "key"));
+  const credentials = new CredentialStore(join4(directory, "credentials.json"), crypto2);
   const sessions = new DeviceSessionStore(credentials);
   const facebook = new FacebookSessionStore(credentials);
-  const spool = new EncryptedScanSpool(join3(directory, "scan-spool"), crypto2);
-  const activity = new ActivityLog({ directory: join3(directory, "activity") });
+  const spool = new EncryptedScanSpool(join4(directory, "scan-spool"), crypto2);
+  const activity = new ActivityLog({ directory: join4(directory, "activity") });
   const http = new DesktopAgentHttpClient(endpoint.httpOrigin);
   const manager = new DeviceCredentialManager(sessions, http, createDeviceIdentity);
   return { activity, browserType: createBrowserLauncher(chromium), directory, endpoint, facebook, manager, sessions, spool };
@@ -2937,8 +3570,13 @@ async function commandRun(runtime, io) {
     io.error("This agent is not paired yet. Run `diggylab pair --code <code>` first.");
     return 2;
   }
-  const recordActivity = (message, code) => {
-    void runtime.activity.append({ category: "CONNECTION", code, level: "INFO", message }).catch(() => void 0);
+  const recordActivity = (message, code, options = {}) => {
+    void runtime.activity.append({
+      category: options.category ?? "CONNECTION",
+      code,
+      level: options.level ?? "INFO",
+      message
+    }).catch(() => void 0);
   };
   const facebookReady = await runtime.facebook.isReady();
   const session = new DesktopAgentSession({
@@ -2975,17 +3613,37 @@ async function commandRun(runtime, io) {
     },
     origin: runtime.endpoint.httpOrigin
   });
+  const scanner = new FacebookScanner({
+    browserType: runtime.browserType,
+    parseGraphqlBody: createGraphqlDumpParser(process.env.FACEBOOK_SCAN_DUMP_DIR)
+  });
+  const commentRunner = new DesktopCommentRunner({
+    clearTimer: (timer) => clearTimeout(timer),
+    facebookState: runtime.facebook,
+    http: scanHttp,
+    isLoginActive: () => false,
+    isScanActive: () => scanRunner?.isRunning() ?? false,
+    scanner,
+    session,
+    setTimer: (callback, delay) => {
+      const timer = setTimeout(callback, delay);
+      timer.unref();
+      return timer;
+    },
+    wait: abortableDelay
+  });
   const scanRunner = new DesktopScanRunner({
     clearTimer: (timer) => clearTimeout(timer),
     facebookState: runtime.facebook,
     http: scanHttp,
+    isCommentFetchActive: () => commentRunner.isRunning(),
     isLoginActive: () => false,
     now: Date.now,
     randomUuid: () => randomUUID3(),
     requestFacebookLogin: async () => {
       io.error("The Facebook session expired. Stop this worker, run `diggylab login`, then start it again.");
     },
-    scanner: new FacebookScanner({ browserType: runtime.browserType }),
+    scanner,
     session,
     setTimer: (callback, delay) => {
       const timer = setTimeout(callback, delay);
@@ -3013,6 +3671,30 @@ async function commandRun(runtime, io) {
     recordActivity(`Scanner state changed to ${snapshot.state}.`, snapshot.state);
   });
   scanRunner.start();
+  commentRunner.start();
+  const unsubscribeComments = commentRunner.subscribe((event) => {
+    if (event.type === "STARTED") {
+      io.log(`${stamp()} comments: fetching ${event.postUrl}`);
+      recordActivity(`Fetching comments for ${event.postUrl}.`, "COMMENT_FETCH_STARTED", {
+        category: "COMMENTS"
+      });
+      return;
+    }
+    if (event.type === "SUCCEEDED") {
+      io.log(`${stamp()} comments: fetched ${event.commentCount} comment(s)`);
+      recordActivity(
+        `Fetched ${event.commentCount} comment(s) for ${event.postUrl}.`,
+        "COMMENT_FETCH_SUCCEEDED",
+        { category: "COMMENTS" }
+      );
+      return;
+    }
+    io.log(`${stamp()} comments: failed (${event.errorCode})`);
+    recordActivity(`Comment fetch failed (${event.errorCode}) for ${event.postUrl}.`, event.errorCode, {
+      category: "COMMENTS",
+      level: "WARN"
+    });
+  });
   await scanRunner.recover();
   await session.start();
   io.log(`Worker running as "${stored.device.name}" (API ${runtime.endpoint.httpOrigin}). Press Ctrl+C to stop.`);
@@ -3028,6 +3710,8 @@ async function commandRun(runtime, io) {
   } finally {
     clearInterval(keepAlive);
     session.stop();
+    commentRunner.stop();
+    unsubscribeComments();
     scanRunner.stop();
   }
   return 0;
@@ -3058,7 +3742,7 @@ function runCommand(command, args) {
   });
 }
 function resolveServiceExecStart() {
-  const candidates = [join3(dirname3(process.execPath), "diggylab"), "/usr/local/bin/diggylab", "/usr/bin/diggylab"];
+  const candidates = [join4(dirname3(process.execPath), "diggylab"), "/usr/local/bin/diggylab", "/usr/bin/diggylab"];
   const link = candidates.find((candidate) => existsSync2(candidate));
   return link ? [link] : [process.execPath, fileURLToPath(import.meta.url)];
 }
@@ -3084,7 +3768,7 @@ async function commandInstallService(runtime, io) {
   }
   io.log(`Wrote ${SERVICE_PATH}.`);
   io.log(`State directory: ${runtime.directory}`);
-  if (process.env.SUDO_USER && process.env.SUDO_USER !== "root" && runtime.directory === join3(homedir(), CONFIG_DIRECTORY)) {
+  if (process.env.SUDO_USER && process.env.SUDO_USER !== "root" && runtime.directory === join4(homedir(), CONFIG_DIRECTORY)) {
     io.error(`Heads up: this ran as root, so the service will use ${runtime.directory} (root's home).`);
     io.error(`If you paired as "${process.env.SUDO_USER}", pass --config to point at that user's ~/${CONFIG_DIRECTORY} instead.`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diggylab",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "DiggyLab Desktop Agent collects posts and information from Facebook Groups on a paired computer. (headless CLI)",
   "type": "module",
   "bin": {