diggylab 0.1.51 → 0.1.52

package/cli.js

@@ -8,7 +8,12 @@ import { hostname, homedir } from "node:os";
 import { dirname as dirname3, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
 
-// ../../packages/shared/src/index.ts
+// ../../packages/shared/dist/comment-publishing.js
+var COMMENT_TEXT_MAX_LENGTH = 2e3;
+var COMMENT_IMAGE_MAX_BYTES = 5 * 1024 * 1024;
+var COMMENT_IMAGE_QUOTA_BYTES = 500 * 1024 * 1024;
+
+// ../../packages/shared/dist/index.js
 var DESKTOP_AGENT_PROTOCOL_VERSION = 1;
 var DESKTOP_POST_COMMENTS_MAX_LIMIT = 200;
 var DESKTOP_POST_COMMENTS_REQUEST_TIMEOUT_MS = 3 * 60 * 1e3;
@@ -18,17 +23,22 @@ function isFacebookDomain(domain) {
   return Boolean(domain && FACEBOOK_HOST.test(domain.replace(/^\./, "")));
 }
 function normalizeSameSite(value) {
-  if (typeof value !== "string") return void 0;
+  if (typeof value !== "string")
+    return void 0;
   const lower = value.toLowerCase().replace(/[^a-z]/g, "");
-  if (lower === "lax") return "Lax";
-  if (lower === "strict") return "Strict";
-  if (lower === "none" || lower === "norestriction") return "None";
+  if (lower === "lax")
+    return "Lax";
+  if (lower === "strict")
+    return "Strict";
+  if (lower === "none" || lower === "norestriction")
+    return "None";
   return void 0;
 }
 function toCookie(value) {
   const name = typeof value.name === "string" ? value.name.trim() : "";
   const cookieValue = typeof value.value === "string" ? value.value : "";
-  if (!name || !cookieValue) return null;
+  if (!name || !cookieValue)
+    return null;
   return {
     domain: typeof value.domain === "string" ? value.domain : void 0,
     expires: typeof value.expires === "number" ? value.expires : typeof value.expirationDate === "number" ? value.expirationDate : void 0,
@@ -44,7 +54,8 @@ function parseCookieHeader(input) {
   const header = input.replace(/^\s*cookie\s*:/i, "");
   return header.split(/[;\n]/).map((part) => part.trim()).filter(Boolean).map((part) => {
     const separator = part.indexOf("=");
-    if (separator <= 0) return null;
+    if (separator <= 0)
+      return null;
     return { name: part.slice(0, separator).trim(), value: part.slice(separator + 1) };
   }).filter((cookie) => cookie !== null);
 }
@@ -54,14 +65,16 @@ function parseCookieTable(input) {
     const columns = line.split("	");
     const name = columns[0]?.trim() ?? "";
     const value = columns[1];
-    if (!value || !name || name === "Name") continue;
+    if (!value || !name || name === "Name")
+      continue;
     cookies.push({ domain: columns[2]?.trim(), name, value });
   }
   return cookies;
 }
 function parseCookieInput(input) {
   const trimmed = input.trim();
-  if (!trimmed) return [];
+  if (!trimmed)
+    return [];
   if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
     return trimmed.includes("	") ? parseCookieTable(trimmed) : parseCookieHeader(trimmed);
   }
@@ -762,6 +775,370 @@ function parseCommentDepth(label) {
   return /\brepl(?:y|ies)\b|trả lời|phản hồi/i.test(parentPart) ? 2 : 1;
 }
 
+// ../../packages/facebook-scanner/dist/comment-publish-evidence.js
+function readCommentPublishEvidence(body, parseComments) {
+  const evidence = { comments: [], declinedIds: /* @__PURE__ */ new Set(), createdIds: /* @__PURE__ */ new Set() };
+  const visit2 = (value, depth = 0) => {
+    if (!value || typeof value !== "object" || depth > 60)
+      return;
+    const node = value;
+    const creation = node.comment_create;
+    const createdId = commentId(creation?.comment?.legacy_fbid) ?? commentId(creation?.comment?.id);
+    if (createdId)
+      evidence.createdIds.add(createdId);
+    const id = commentId(node.legacy_fbid) ?? commentId(node.id);
+    if (id) {
+      const groupInfo = node.group_comment_info;
+      if (groupInfo?.declined_feedback_text != null)
+        evidence.declinedIds.add(id);
+      if (node.body || node.comment_body || node.preferred_body) {
+        evidence.comments.push(...parseComments(JSON.stringify({ ...node, __typename: "Comment", id })));
+      }
+    }
+    for (const child of Object.values(node))
+      visit2(child, depth + 1);
+  };
+  for (const line of body.split(/\r?\n/)) {
+    try {
+      visit2(JSON.parse(line.trim().replace(/^for\s*\(;;\);/, "")));
+    } catch {
+    }
+  }
+  return evidence;
+}
+function commentId(value) {
+  if (typeof value !== "string")
+    return void 0;
+  if (/^\d{1,100}$/.test(value))
+    return value;
+  const decoded = Buffer.from(value, "base64").toString("utf8");
+  return /^comment:\d+_(\d{1,100})$/.exec(decoded)?.[1];
+}
+
+// ../../packages/facebook-scanner/dist/comment-publisher.js
+var SUBMIT_TIMEOUT_MS = 15e3;
+var COMPOSER_TIMEOUT_MS = 1e4;
+var IMAGE_UPLOAD_TIMEOUT_MS = 15e3;
+var APPROVAL_PATTERN = /pending approval|awaiting approval|chờ duyệt|đang chờ duyệt|chờ quản trị viên/i;
+var EXTENSION = { "image/jpeg": "jpg", "image/png": "png", "image/webp": "webp" };
+async function publishCommentOnPage(page, options, config) {
+  const started = Date.now();
+  const diagnostic = {
+    stage: "COMPOSER",
+    mutationResponses: 0,
+    graphqlResponses: 0,
+    readErrors: 0,
+    comments: 0,
+    createdIds: 0,
+    declinedIds: 0,
+    reload: "NOT_STARTED",
+    durationMs: 0
+  };
+  try {
+    const result = await publishWithDiagnostic(page, options, config, diagnostic);
+    diagnostic.outcome = result.outcome;
+    diagnostic.errorCode = result.errorCode;
+    return result;
+  } catch (error) {
+    diagnostic.errorCode = options.signal?.aborted ? "PUBLISH_ABORTED" : "PUBLISH_EXCEPTION";
+    throw error;
+  } finally {
+    diagnostic.durationMs = Date.now() - started;
+    try {
+      options.onDiagnostic?.({ ...diagnostic });
+    } catch {
+    }
+  }
+}
+async function publishWithDiagnostic(page, options, config, diagnostic) {
+  const composer = await waitForComposer(page);
+  if (!composer)
+    return failed("COMPOSER_NOT_FOUND");
+  const fileInput = options.image ? await findFileInput(page, composer) : null;
+  if (options.image && !fileInput)
+    return failed("IMAGE_NOT_SUPPORTED");
+  assertNotAborted(options.signal);
+  const allowed = await options.beforeSubmit();
+  assertNotAborted(options.signal);
+  if (!allowed)
+    return failed("START_NOT_ALLOWED");
+  if (options.content) {
+    diagnostic.stage = "FILL";
+    await composer.fill(options.content);
+  }
+  {
+    if (options.image && fileInput) {
+      const currentFileInput = await findFileInput(page, composer);
+      if (!currentFileInput)
+        return failed("IMAGE_NOT_SUPPORTED");
+      const uploadDeadline = Date.now() + IMAGE_UPLOAD_TIMEOUT_MS;
+      const uploadResponse = page.waitForResponse((response2) => {
+        const url = new URL(response2.url());
+        return (url.hostname === "facebook.com" || url.hostname.endsWith(".facebook.com")) && url.pathname === "/ajax/ufi/upload/" && response2.request().method() === "POST";
+      }, { timeout: IMAGE_UPLOAD_TIMEOUT_MS }).catch(() => null);
+      await currentFileInput.setInputFiles({
+        buffer: options.image.buffer,
+        mimeType: options.image.contentType,
+        name: `comment.${EXTENSION[options.image.contentType]}`
+      });
+      const response = await uploadResponse;
+      if (!response || !response.ok())
+        return failed("IMAGE_UPLOAD_FAILED");
+      try {
+        let timer;
+        const body = await Promise.race([
+          response.text(),
+          new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(new Error("IMAGE_UPLOAD_FAILED")), Math.max(0, uploadDeadline - Date.now()));
+          })
+        ]).finally(() => clearTimeout(timer));
+        const uploaded = JSON.parse(body.replace(/^for\s*\(;;\);/, ""));
+        const id = uploaded.payload?.fbid;
+        if (uploaded.error || !(typeof id === "number" && Number.isSafeInteger(id) && id > 0 || typeof id === "string" && /^[1-9]\d{0,99}$/.test(id)))
+          return failed("IMAGE_UPLOAD_FAILED");
+      } catch {
+        return failed("IMAGE_UPLOAD_FAILED");
+      }
+    }
+    const submit = await findSubmit(page, composer);
+    if (!submit)
+      return failed("SUBMIT_NOT_FOUND");
+    const evidence = { comments: [], declinedIds: /* @__PURE__ */ new Set(), createdIds: /* @__PURE__ */ new Set() };
+    const onResponse = (response) => {
+      if (!response.url().includes("/api/graphql/"))
+        return;
+      diagnostic.graphqlResponses += 1;
+      const name = new URLSearchParams(response.request().postData() ?? "").get("fb_api_req_friendly_name");
+      if (name !== "useCometUFICreateCommentMutation")
+        return;
+      diagnostic.mutationResponses += 1;
+      diagnostic.httpStatus = response.status();
+      if (response.status() >= 400)
+        return;
+      void response.text().then((body) => {
+        try {
+          diagnostic.stage = "READ_RESPONSE";
+          const received = readCommentPublishEvidence(body, config.parseGraphqlComments);
+          evidence.comments.push(...received.comments);
+          for (const id of received.declinedIds)
+            evidence.declinedIds.add(id);
+          for (const id of received.createdIds)
+            evidence.createdIds.add(id);
+          diagnostic.comments = evidence.comments.length;
+          diagnostic.createdIds = evidence.createdIds.size;
+          diagnostic.declinedIds = evidence.declinedIds.size;
+        } catch {
+          diagnostic.readErrors += 1;
+        }
+      }).catch(() => {
+        diagnostic.readErrors += 1;
+      });
+    };
+    page.on("response", onResponse);
+    try {
+      diagnostic.stage = "SUBMIT";
+      await submit.click({ timeout: 1e4 });
+      if (options.skipVerification) {
+        diagnostic.reload = "SKIPPED";
+        return { outcome: "UNKNOWN", submitAttempted: true, errorCode: "VERIFICATION_SKIPPED" };
+      }
+      if (diagnostic.stage === "SUBMIT")
+        diagnostic.stage = "WAITING_RESPONSE";
+      return await waitForEvidence(page, {
+        evidence,
+        parseComments: config.parseGraphqlComments,
+        diagnostic,
+        content: options.content,
+        hasImage: Boolean(options.image),
+        postUrl: options.postUrl
+      });
+    } finally {
+      page.off("response", onResponse);
+    }
+  }
+}
+async function waitForComposer(page) {
+  const deadline = Date.now() + COMPOSER_TIMEOUT_MS;
+  for (; ; ) {
+    const composer = await findComposer(page);
+    if (composer)
+      return composer;
+    if (Date.now() >= deadline)
+      return null;
+    await page.mouse.wheel(0, 800).catch(() => void 0);
+    await page.waitForTimeout(400);
+  }
+}
+async function findComposer(page) {
+  const handle = await page.evaluateHandle(() => {
+    const boxes = Array.from(document.querySelectorAll('[contenteditable="true"][role="textbox"]')).filter((element2) => {
+      const style = window.getComputedStyle(element2);
+      const label = element2.getAttribute("aria-label") ?? "";
+      return style.display !== "none" && style.visibility !== "hidden" && !/reply|trả lời/i.test(label);
+    });
+    const composer = boxes.find((element2) => /comment|bình luận/i.test(element2.getAttribute("aria-label") ?? "")) ?? boxes[0];
+    return composer ?? null;
+  });
+  const element = handle.asElement();
+  if (!element)
+    return null;
+  return element;
+}
+async function findFileInput(page, composer) {
+  const handle = await composer.evaluateHandle((element2) => {
+    let node = element2;
+    for (let depth = 0; depth < 8 && node; depth += 1, node = node.parentElement) {
+      const input = node.querySelector('input[type="file"][accept*="image"]');
+      if (input) {
+        return input;
+      }
+    }
+    return null;
+  });
+  const element = handle.asElement();
+  return element;
+}
+async function findSubmit(page, composer) {
+  const handle = await composer.evaluateHandle((element2) => {
+    let node = element2;
+    for (let depth = 0; depth < 8 && node; depth += 1, node = node.parentElement) {
+      const button = Array.from(node.querySelectorAll('[role="button"], button')).find((candidate) => {
+        const name = (candidate.getAttribute("aria-label") ?? candidate.textContent ?? "").trim();
+        return /^(comment|post comment|bình luận|post|đăng|gửi)$/i.test(name) && candidate.getAttribute("aria-disabled") !== "true" && !candidate.disabled;
+      });
+      if (button) {
+        return button;
+      }
+    }
+    return null;
+  });
+  const element = handle.asElement();
+  if (!element)
+    return null;
+  return element;
+}
+async function waitForEvidence(page, state) {
+  const deadline = Date.now() + SUBMIT_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const declinedCreatedId = [...state.evidence.createdIds].find((id) => state.evidence.declinedIds.has(id));
+    if (declinedCreatedId) {
+      state.diagnostic.commentId = declinedCreatedId;
+      return {
+        outcome: "UNKNOWN",
+        submitAttempted: true,
+        errorCode: "FACEBOOK_COMMENT_DECLINED",
+        facebookCommentId: declinedCreatedId,
+        commentUrl: `${state.postUrl}?comment_id=${encodeURIComponent(declinedCreatedId)}`
+      };
+    }
+    const match = state.evidence.comments.find((comment) => /^\d{1,100}$/.test(comment.id ?? "") && (!state.evidence.createdIds.size || state.evidence.createdIds.has(comment.id ?? "")) && (state.content ? normalize(comment.text) === normalize(state.content) : true) && (!state.hasImage || (comment.attachmentImages?.length ?? 0) > 0));
+    const submittedId = match?.id ?? (state.evidence.createdIds.size === 1 ? state.evidence.createdIds.values().next().value : void 0);
+    if (submittedId) {
+      state.diagnostic.commentId = submittedId;
+      const identity = {
+        commentUrl: `${state.postUrl}?comment_id=${encodeURIComponent(submittedId)}`,
+        facebookCommentId: submittedId
+      };
+      if (state.evidence.declinedIds.has(submittedId)) {
+        return { ...identity, outcome: "UNKNOWN", submitAttempted: true, errorCode: "FACEBOOK_COMMENT_DECLINED" };
+      }
+      try {
+        state.diagnostic.stage = "RELOAD";
+        const verification = await verifyAfterReload(page, state, submittedId);
+        state.diagnostic.reload = verification === "PENDING" ? "MISSING" : verification;
+        if (verification === "DECLINED") {
+          return { ...identity, outcome: "UNKNOWN", submitAttempted: true, errorCode: "FACEBOOK_COMMENT_DECLINED" };
+        }
+        if (verification === "PENDING") {
+          return { ...identity, outcome: "UNKNOWN", submitAttempted: true, errorCode: "FACEBOOK_APPROVAL_PENDING" };
+        }
+        if (verification === "CONFIRMED") {
+          return { ...identity, outcome: "SUCCEEDED", submitAttempted: true };
+        }
+      } catch {
+        state.diagnostic.reload = "ERROR";
+      }
+      return { ...identity, outcome: "UNKNOWN", submitAttempted: true, errorCode: "SUBMIT_UNCONFIRMED" };
+    }
+    const pending = await page.getByText(APPROVAL_PATTERN).count().catch(() => 0);
+    if (pending > 0) {
+      return { outcome: "UNKNOWN", submitAttempted: true, errorCode: "FACEBOOK_APPROVAL_PENDING" };
+    }
+    await page.waitForTimeout(500);
+  }
+  return { outcome: "UNKNOWN", submitAttempted: true, errorCode: "SUBMIT_UNCONFIRMED" };
+}
+async function verifyAfterReload(page, state, submittedId) {
+  const received = [];
+  let observing = true;
+  let timer;
+  const onResponse = (response) => {
+    if (!response.url().includes("/api/graphql/") || response.status() >= 400)
+      return;
+    void response.text().then((body) => {
+      if (observing)
+        received.push(readCommentPublishEvidence(body, state.parseComments));
+    }).catch(() => void 0);
+  };
+  page.on("response", onResponse);
+  try {
+    const commentUrl = new URL(state.postUrl);
+    commentUrl.searchParams.set("comment_id", submittedId);
+    await page.goto(commentUrl.href, { waitUntil: "domcontentloaded", timeout: 15e3 });
+    const deadline = Date.now() + 3e3;
+    const inspect = async () => {
+      while (observing && Date.now() < deadline) {
+        const visible = await page.evaluate(({ id, postUrl }) => {
+          const target = new URL(postUrl);
+          const found = Array.from(document.querySelectorAll('a[href*="comment_id="]')).some((link) => {
+            const article = link.closest('[role="article"]');
+            const visibility = { visibilityProperty: true, opacityProperty: true };
+            if (!article || !link.checkVisibility(visibility) || !article.checkVisibility(visibility))
+              return false;
+            const url = new URL(link.href);
+            return url.hostname === target.hostname && url.pathname.replace(/\/$/, "") === target.pathname.replace(/\/$/, "") && url.searchParams.get("comment_id") === id;
+          });
+          return {
+            found,
+            scripts: Array.from(document.querySelectorAll('script[type="application/json"]')).map((script) => script.textContent ?? "").join("\n")
+          };
+        }, { id: submittedId, postUrl: state.postUrl });
+        if (!observing)
+          return "MISSING";
+        const evidence = [...received, readCommentPublishEvidence(visible.scripts, state.parseComments)];
+        if (evidence.some((item) => item.declinedIds.has(submittedId)))
+          return "DECLINED";
+        if (await page.getByText(APPROVAL_PATTERN).count())
+          return "PENDING";
+        if (evidence.some((item) => item.comments.some((comment) => comment.id === submittedId && (!state.hasImage || (comment.attachmentImages?.length ?? 0) > 0))) || !state.hasImage && visible.found)
+          return "CONFIRMED";
+        await page.waitForTimeout(Math.min(200, Math.max(0, deadline - Date.now())));
+      }
+      return "MISSING";
+    };
+    return await Promise.race([
+      inspect(),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve("MISSING"), 3e3);
+      })
+    ]);
+  } finally {
+    observing = false;
+    clearTimeout(timer);
+    page.off("response", onResponse);
+  }
+}
+function normalize(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function failed(errorCode) {
+  return { errorCode, outcome: "FAILED", submitAttempted: false };
+}
+function assertNotAborted(signal) {
+  if (signal?.aborted)
+    throw new Error("SCAN_CANCELED");
+}
+
 // ../../packages/facebook-scanner/dist/session.js
 async function detectFacebookSession(page, context) {
   let url;
@@ -825,7 +1202,7 @@ var FacebookScanner = class {
       });
       const results = [];
       for (const [index, groupUrl] of options.groupUrls.entries()) {
-        assertNotAborted(options.signal);
+        assertNotAborted2(options.signal);
         const items = await this.scanGroup(browser, options, groupUrl, index);
         results.push(items);
       }
@@ -841,7 +1218,7 @@ var FacebookScanner = class {
     const target = normalizePostUrl(options.postUrl);
     if (!target)
       throw new FacebookScannerError("POST_URL_INVALID");
-    assertNotAborted(options.signal);
+    assertNotAborted2(options.signal);
     this.running = true;
     let browser = null;
     try {
@@ -876,7 +1253,7 @@ var FacebookScanner = class {
         let idleRounds = 0;
         let rounds = 0;
         while (comments.length < options.limit && idleRounds < 3 && rounds < 20) {
-          assertNotAborted(options.signal);
+          assertNotAborted2(options.signal);
           rounds += 1;
           const previousCount = comments.length;
           await page.waitForTimeout(1200);
@@ -893,7 +1270,7 @@ var FacebookScanner = class {
             await page.mouse.wheel(0, 2e3);
           }
         }
-        assertNotAborted(options.signal);
+        assertNotAborted2(options.signal);
         await drain(responseTasks, this.graphqlResponseTimeoutMs);
         const domComments = await this.extractDomComments(page);
         comments = mergeFacebookComments([...embeddedComments, ...graphqlComments, ...domComments], options.limit);
@@ -911,6 +1288,57 @@ var FacebookScanner = class {
       this.running = false;
     }
   }
+  async publishComment(options) {
+    if (this.running)
+      throw new FacebookScannerError("SCANNER_BUSY");
+    const target = normalizePostUrl(options.postUrl);
+    if (!target)
+      throw new FacebookScannerError("POST_URL_INVALID");
+    assertNotAborted2(options.signal);
+    this.running = true;
+    let browser = null;
+    try {
+      browser = await this.browserType.launch({
+        headless: true,
+        ...this.proxy ? { proxy: this.proxy } : {}
+      });
+      const context = await browser.newContext({ storageState: options.storageState });
+      let page = null;
+      const closeOnAbort = () => {
+        void page?.close().catch(() => void 0);
+        void context.close().catch(() => void 0);
+        void browser?.close().catch(() => void 0);
+      };
+      options.signal?.addEventListener("abort", closeOnAbort, { once: true });
+      if (options.signal?.aborted)
+        closeOnAbort();
+      try {
+        page = await context.newPage();
+        if (options.signal?.aborted)
+          closeOnAbort();
+        await page.route("**/*", (route) => ["font", "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);
+        return await publishCommentOnPage(page, options, {
+          parseGraphqlComments: this.parseGraphqlComments
+        });
+      } finally {
+        options.signal?.removeEventListener("abort", closeOnAbort);
+        await page?.unroute("**/*").catch(() => void 0);
+        await page?.close().catch(() => void 0);
+        await context.close().catch(() => void 0);
+      }
+    } finally {
+      await browser?.close();
+      this.running = false;
+    }
+  }
   async scanGroup(browser, options, groupUrl, groupIndex) {
     const context = await browser.newContext({ storageState: options.storageState });
     let page = null;
@@ -940,7 +1368,7 @@ var FacebookScanner = class {
       let items = [];
       let idleRounds = 0;
       while (items.length < options.limit && idleRounds < 3) {
-        assertNotAborted(options.signal);
+        assertNotAborted2(options.signal);
         const previousCount = items.length;
         await page.waitForTimeout(1500);
         await drain(responseTasks, this.graphqlResponseTimeoutMs);
@@ -958,7 +1386,7 @@ var FacebookScanner = class {
         if (items.length < options.limit)
           await page.mouse.wheel(0, 2e3);
       }
-      assertNotAborted(options.signal);
+      assertNotAborted2(options.signal);
       await drain(responseTasks, this.graphqlResponseTimeoutMs);
       items = mergeFacebookScanItems([...graphqlItems, ...domItems], options.limit);
       if (!items.length)
@@ -974,7 +1402,7 @@ var FacebookScanner = class {
     }
   }
 };
-function assertNotAborted(signal) {
+function assertNotAborted2(signal) {
   if (signal?.aborted)
     throw new FacebookScannerError("SCAN_CANCELED");
 }
@@ -1620,7 +2048,7 @@ var DesktopAgentSession = class {
         state: this.reportedState,
         facebookReady: this.options.getFacebookReady(),
         currentJobId: this.reportedJobId,
-        capabilities: ["POST_COMMENTS", "POST_COMMENTS_MORE"]
+        capabilities: ["POST_COMMENTS", "POST_COMMENTS_MORE", "POST_COMMENT_PUBLISH"]
       });
       this.handshake = "WELCOME";
       return;
@@ -1664,6 +2092,16 @@ var DesktopAgentSession = class {
       this.emitJob({ type: "STOP", ...envelope.payload });
       return;
     }
+    if (envelope.type === "POST_COMMENT_PUBLISH") {
+      const payload = envelope.payload;
+      if (!isCommentPublish(payload)) {
+        this.protocolFailure(socket, stored, generation);
+        return;
+      }
+      if (Date.parse(payload.expiresAt) <= Date.now()) return;
+      this.emitJob({ type: "COMMENT_PUBLISH", ...payload });
+      return;
+    }
     if (envelope.type === "POST_COMMENTS_FETCH") {
       if (!isPostCommentsFetch(envelope.payload)) {
         this.protocolFailure(socket, stored, generation);
@@ -1823,6 +2261,20 @@ function isPostCommentsFetch(value) {
   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 isCommentPublish(value) {
+  if (!value || typeof value !== "object") return false;
+  const payload = value;
+  const image = payload.image;
+  if (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.content !== "string" || payload.content.length > COMMENT_TEXT_MAX_LENGTH || payload.skipVerification !== void 0 && typeof payload.skipVerification !== "boolean" || typeof payload.expiresAt !== "string" || !Number.isFinite(Date.parse(payload.expiresAt))) {
+    return false;
+  }
+  const hasImage = image !== null && image !== void 0;
+  if (!payload.content.trim() && !hasImage) return false;
+  if (!hasImage) return true;
+  if (typeof image !== "object" || Array.isArray(image)) return false;
+  const asset = image;
+  return typeof asset.id === "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(asset.id) && ["image/jpeg", "image/png", "image/webp"].includes(String(asset.contentType)) && typeof asset.byteSize === "number" && Number.isInteger(asset.byteSize) && asset.byteSize > 0 && asset.byteSize <= COMMENT_IMAGE_MAX_BYTES && typeof asset.sha256 === "string" && /^[0-9a-f]{64}$/i.test(asset.sha256);
+}
 function emptySnapshot(state) {
   return {
     state,
@@ -1852,6 +2304,184 @@ function readErrorCode(error) {
   return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN_ERROR";
 }
 
+// src/main/desktop-comment-publish-runner.ts
+var DEFAULT_REPORT_ATTEMPTS = 3;
+var DesktopCommentPublishRunner = class {
+  options;
+  listeners = /* @__PURE__ */ new Set();
+  stopController = new AbortController();
+  currentController = null;
+  activeRequestId = null;
+  finishedRequestIds = /* @__PURE__ */ new Set();
+  active = 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.currentController?.abort();
+    this.stopController.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;
+  }
+  handleEvent(event) {
+    if (event.type !== "COMMENT_PUBLISH" || this.stopped) return;
+    if (this.activeRequestId === event.requestId || this.finishedRequestIds.has(event.requestId)) return;
+    if (this.active) {
+      void this.reportOnly(event, "AGENT_BUSY", "FAILED");
+      return;
+    }
+    this.active = this.run(event).finally(() => {
+      this.active = null;
+    });
+  }
+  async run(request) {
+    const controller = new AbortController();
+    const timeout = this.options.setTimer(
+      () => controller.abort(),
+      this.options.publishTimeoutMs ?? 3 * 60 * 1e3
+    );
+    this.currentController = controller;
+    this.activeRequestId = request.requestId;
+    this.emit({ type: "STARTED", requestId: request.requestId, postUrl: request.postUrl });
+    let granted = false;
+    try {
+      if (this.options.isScanActive()) {
+        await this.reportOnly(request, "SCANNER_BUSY", "FAILED");
+        return;
+      }
+      if (this.options.isCommentFetchActive()) {
+        await this.reportOnly(request, "COMMENT_FETCH_ACTIVE", "FAILED");
+        return;
+      }
+      if (this.options.isLoginActive()) {
+        await this.reportOnly(request, "LOGIN_ACTIVE", "FAILED");
+        return;
+      }
+      let image;
+      if (request.image) {
+        try {
+          image = await this.options.http.downloadCommentImage(request.requestId, request.image, controller.signal);
+        } catch {
+          await this.reportOnly(request, "IMAGE_DOWNLOAD_FAILED", "FAILED");
+          return;
+        }
+      }
+      const storageState = await this.options.facebookState.load();
+      if (!storageState) {
+        await this.reportOnly(request, "FACEBOOK_SESSION_MISSING", "FAILED");
+        return;
+      }
+      let result;
+      try {
+        result = await this.options.scanner.publishComment({
+          onDiagnostic: (diagnostic) => this.emit({ type: "DIAGNOSTIC", requestId: request.requestId, diagnostic }),
+          beforeSubmit: async () => {
+            const started = await this.options.http.startCommentPublish(request.requestId, controller.signal);
+            granted = started.allowed;
+            return started.allowed;
+          },
+          content: request.content,
+          skipVerification: request.skipVerification,
+          ...image && request.image ? { image: { buffer: image, contentType: request.image.contentType } } : {},
+          postUrl: request.postUrl,
+          signal: controller.signal,
+          storageState
+        });
+      } catch {
+        await this.reportOnly(
+          request,
+          granted ? "SUBMIT_UNCONFIRMED" : "PUBLISH_START_FAILED",
+          granted ? "UNKNOWN" : "FAILED"
+        );
+        return;
+      }
+      await this.report(request, {
+        ...result.commentUrl ? { commentUrl: result.commentUrl } : {},
+        ...result.errorCode ? { errorCode: result.errorCode } : {},
+        ...result.facebookCommentId ? { facebookCommentId: result.facebookCommentId } : {},
+        outcome: result.outcome,
+        submitAttempted: result.submitAttempted
+      });
+    } finally {
+      this.options.clearTimer(timeout);
+      if (this.currentController === controller) this.currentController = null;
+      this.activeRequestId = null;
+      this.finishedRequestIds.add(request.requestId);
+      if (this.finishedRequestIds.size > 100) {
+        const oldest = this.finishedRequestIds.values().next().value;
+        if (oldest) this.finishedRequestIds.delete(oldest);
+      }
+    }
+  }
+  async reportOnly(request, errorCode, outcome) {
+    await this.report(request, { errorCode, outcome, submitAttempted: outcome === "UNKNOWN" });
+  }
+  async report(request, result) {
+    const attempts = Math.max(1, this.options.reportAttempts ?? DEFAULT_REPORT_ATTEMPTS);
+    let delivered = false;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+      try {
+        await this.options.http.reportCommentPublish(request.requestId, result);
+        delivered = true;
+        break;
+      } catch {
+        if (attempt === attempts || this.stopController.signal.aborted) break;
+        try {
+          await this.options.wait(1e3 * 2 ** (attempt - 1), this.stopController.signal);
+        } catch {
+          break;
+        }
+      }
+    }
+    if (!delivered) {
+      this.emit({
+        type: "REPORT_FAILED",
+        errorCode: "RESULT_REPORT_FAILED",
+        requestId: request.requestId,
+        postUrl: request.postUrl
+      });
+    } else {
+      if (result.outcome === "SUCCEEDED") {
+        this.emit({ type: "SUCCEEDED", requestId: request.requestId, postUrl: request.postUrl });
+      } else if (result.outcome === "UNKNOWN") {
+        this.emit({
+          type: "UNKNOWN",
+          errorCode: result.errorCode ?? "UNKNOWN",
+          requestId: request.requestId,
+          postUrl: request.postUrl
+        });
+      } else {
+        this.emit({
+          type: "FAILED",
+          errorCode: result.errorCode ?? "FAILED",
+          requestId: request.requestId,
+          postUrl: request.postUrl
+        });
+      }
+    }
+  }
+  emit(event) {
+    for (const listener of this.listeners) listener(event);
+  }
+};
+
 // src/main/desktop-comment-runner.ts
 var DEFAULT_FETCH_TIMEOUT_MS = 2 * 60 * 1e3;
 var DEFAULT_MAX_QUEUE = 5;
@@ -2049,7 +2679,60 @@ var DesktopScanHttp = class {
       signal
     );
   }
+  startCommentPublish(requestId, signal) {
+    return this.signedPost(
+      `/leads/desktop-agent/comment-publish-requests/${requestId}/start`,
+      {},
+      signal
+    );
+  }
+  reportCommentPublish(requestId, result, signal) {
+    return this.signedPost(
+      `/leads/desktop-agent/comment-publish-requests/${requestId}/result`,
+      result,
+      signal
+    );
+  }
+  async downloadCommentImage(requestId, metadata, signal) {
+    const response = await this.signedRequest(
+      `/leads/desktop-agent/comment-publish-requests/${requestId}/image`,
+      {},
+      signal,
+      "image"
+    );
+    const lengthHeader = response.headers.get("content-length");
+    if (lengthHeader !== null) {
+      const length = Number(lengthHeader);
+      if (!Number.isFinite(length) || length > COMMENT_IMAGE_MAX_BYTES || length !== metadata.byteSize) {
+        throw new DesktopScanHttpError("IMAGE_INVALID");
+      }
+    }
+    if (!response.body) throw new DesktopScanHttpError("IMAGE_INVALID");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > COMMENT_IMAGE_MAX_BYTES || size > metadata.byteSize) {
+        await reader.cancel();
+        throw new DesktopScanHttpError("IMAGE_INVALID");
+      }
+      chunks.push(value);
+    }
+    const bytes = Buffer.concat(chunks, size);
+    if (bytes.byteLength !== metadata.byteSize) throw new DesktopScanHttpError("IMAGE_INVALID");
+    if (createHash("sha256").update(bytes).digest("hex") !== metadata.sha256) {
+      throw new DesktopScanHttpError("IMAGE_INVALID");
+    }
+    return bytes;
+  }
   async signedPost(path, businessPayload, signal) {
+    const response = await this.signedRequest(path, businessPayload, signal);
+    return readBoundedJson2(response);
+  }
+  async signedRequest(path, businessPayload, signal, responseType = "json") {
     const credential = this.getCredential();
     if (!credential) throw new DesktopScanHttpError("CREDENTIAL_UNAVAILABLE");
     const signedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -2083,21 +2766,26 @@ var DesktopScanHttp = class {
           "content-type": "application/json"
         },
         method: "POST",
+        redirect: "error",
         signal: requestSignal
       });
     } catch {
       throw new DesktopScanHttpError("NETWORK_ERROR", true);
     }
-    const contentType = response.headers.get("content-type")?.split(";", 1)[0];
-    if (contentType !== "application/json") throw new DesktopScanHttpError("RESPONSE_INVALID");
-    const value = await readBoundedJson2(response);
     if (!response.ok) {
       throw new DesktopScanHttpError(
         response.status >= 500 ? "SERVER_UNAVAILABLE" : response.status === 413 ? "BATCH_TOO_LARGE" : "BATCH_REJECTED",
         response.status >= 500
       );
     }
-    return value;
+    const contentType = response.headers.get("content-type")?.split(";", 1)[0] ?? "";
+    if (responseType === "json" && contentType !== "application/json") {
+      throw new DesktopScanHttpError("RESPONSE_INVALID");
+    }
+    if (responseType === "image" && !contentType.startsWith("image/")) {
+      throw new DesktopScanHttpError("IMAGE_INVALID");
+    }
+    return response;
   }
 };
 async function readBoundedJson2(response) {
@@ -2314,7 +3002,7 @@ var DesktopScanRunner = class {
     return true;
   }
   async handleEvent(event) {
-    if (event.type === "COMMENTS") return;
+    if (event.type === "COMMENTS" || event.type === "COMMENT_PUBLISH") return;
     if (event.type === "AVAILABLE") {
       await this.claimIfReady(event.jobId);
       return;
@@ -3696,6 +4384,7 @@ async function commandRun(runtime, io) {
     browserType: runtime.browserType,
     parseGraphqlBody: createGraphqlDumpParser(process.env.FACEBOOK_SCAN_DUMP_DIR)
   });
+  let publishRunner = null;
   const commentRunner = new DesktopCommentRunner({
     clearTimer: (timer) => clearTimeout(timer),
     facebookState: runtime.facebook,
@@ -3715,7 +4404,7 @@ async function commandRun(runtime, io) {
     clearTimer: (timer) => clearTimeout(timer),
     facebookState: runtime.facebook,
     http: scanHttp,
-    isCommentFetchActive: () => commentRunner.isRunning(),
+    isCommentFetchActive: () => commentRunner.isRunning() || (publishRunner?.isRunning() ?? false),
     isLoginActive: () => false,
     now: Date.now,
     randomUuid: () => randomUUID3(),
@@ -3732,6 +4421,22 @@ async function commandRun(runtime, io) {
     spool: runtime.spool,
     wait: abortableDelay
   });
+  publishRunner = new DesktopCommentPublishRunner({
+    clearTimer: (timer) => clearTimeout(timer),
+    facebookState: runtime.facebook,
+    http: scanHttp,
+    isCommentFetchActive: () => commentRunner.isRunning(),
+    isLoginActive: () => false,
+    isScanActive: () => scanRunner.isRunning(),
+    scanner,
+    session,
+    setTimer: (callback, delay) => {
+      const timer = setTimeout(callback, delay);
+      timer.unref();
+      return timer;
+    },
+    wait: abortableDelay
+  });
   let onReplaced = () => void 0;
   const replaced = new Promise((resolve) => {
     onReplaced = resolve;
@@ -3751,6 +4456,7 @@ async function commandRun(runtime, io) {
   });
   scanRunner.start();
   commentRunner.start();
+  publishRunner.start();
   const unsubscribeComments = commentRunner.subscribe((event) => {
     if (event.type === "STARTED") {
       io.log(`${stamp()} comments: fetching ${event.postUrl}`);
@@ -3774,6 +4480,34 @@ async function commandRun(runtime, io) {
       level: "WARN"
     });
   });
+  const unsubscribePublish = publishRunner.subscribe((event) => {
+    if (event.type === "DIAGNOSTIC") {
+      const message = JSON.stringify({ requestId: event.requestId, ...event.diagnostic });
+      io.log(`${stamp()} comments: diagnostic ${message}`);
+      recordActivity(message, "COMMENT_PUBLISH_DIAGNOSTIC", { category: "COMMENTS" });
+      return;
+    }
+    if (event.type === "STARTED") {
+      io.log(`${stamp()} comments: publishing on ${event.postUrl}`);
+      recordActivity(`Publishing a comment on ${event.postUrl}.`, "COMMENT_PUBLISH_STARTED", {
+        category: "COMMENTS"
+      });
+      return;
+    }
+    if (event.type === "SUCCEEDED") {
+      io.log(`${stamp()} comments: published`);
+      recordActivity(`Published a comment on ${event.postUrl}.`, "COMMENT_PUBLISH_SUCCEEDED", {
+        category: "COMMENTS"
+      });
+      return;
+    }
+    io.log(`${stamp()} comments: publish ${event.type.toLowerCase()} (${event.errorCode})`);
+    recordActivity(
+      `Comment publish ${event.type.toLowerCase()} (${event.errorCode}) on ${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.`);
@@ -3790,7 +4524,9 @@ async function commandRun(runtime, io) {
     clearInterval(keepAlive);
     session.stop();
     commentRunner.stop();
+    publishRunner.stop();
     unsubscribeComments();
+    unsubscribePublish();
     scanRunner.stop();
   }
   return 0;