From 6cc983c32d4afc4af93d782713ccd1b2b862d5a7 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 16:56:59 -0300
Subject: [PATCH 01/18] Attach link previews on LinkedIn and Facebook text
 posts.

Neither API unfurls a URL left in the caption: LinkedIn needs an article payload, and Facebook only scrapes when the Page feed post sets link. A text-only post now sends that card from the first URL, and the editor preview shows it.
---
 .../Social/AbstractLinkedInPublisher.php      | 206 ++++++++++++++---
 app/Services/Social/FacebookPublisher.php     |  33 ++-
 .../posts/previews/FacebookPreview.vue        |  39 +++-
 .../posts/previews/LinkedInPreview.vue        |  19 +-
 .../posts/previews/MastodonPreview.vue        |  15 +-
 .../Services/Social/FacebookPublisherTest.php |  71 +++++-
 .../Social/LinkedInPagePublisherTest.php      |   3 +
 .../Services/Social/LinkedInPublisherTest.php | 213 +++++++++++++++++-
 8 files changed, 547 insertions(+), 52 deletions(-)

diff --git a/app/Services/Social/AbstractLinkedInPublisher.php b/app/Services/Social/AbstractLinkedInPublisher.php
index f20724178..969d7918d 100644
--- a/app/Services/Social/AbstractLinkedInPublisher.php
+++ b/app/Services/Social/AbstractLinkedInPublisher.php
@@ -11,24 +11,43 @@
 use App\Exceptions\TokenExpiredException;
 use App\Models\PostPlatform;
 use App\Models\SocialAccount;
+use App\Services\Brand\SafeHttpFetcher;
 use App\Services\Media\MediaOptimizer;
 use App\Services\Social\Concerns\HasSocialHttpClient;
+use App\Services\Social\LinkCard\LinkCardFetcher;
+use App\Services\Social\LinkCard\LinkCardMetadata;
 use Illuminate\Http\Client\PendingRequest;
 use Illuminate\Http\Client\Response;
 use Illuminate\Support\Facades\File;
 use Illuminate\Support\Facades\Http;
 use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Str;
+use Throwable;
 
 /**
  * Shared LinkedIn publishing pipeline. The publish format follows the attached
- * media — a PDF becomes a document post, 2+ images a multi-image post, and
- * anything else (a single image/video or text only) a regular post. Subclasses
+ * media — a PDF becomes a document post, 2+ images a multi-image post, a bare
+ * link with no media becomes an article post (the Posts API does not scrape
+ * URLs), and anything else is a regular post. Subclasses
  * provide the author identity (member vs. company page) and its public URL.
  */
 abstract class AbstractLinkedInPublisher
 {
     use HasSocialHttpClient;
 
+    /**
+     * ArticleContent limits are exclusive: title under 400 characters,
+     * description under 4,086.
+     *
+     * @see https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/posts-api
+     */
+    private const int ARTICLE_TITLE_MAX = 399;
+
+    private const int ARTICLE_DESCRIPTION_MAX = 4085;
+
+    /** og:image downloads are small and attacker-influenced; don't wait on a hung host. */
+    private const int ARTICLE_THUMB_TIMEOUT_SECONDS = 10;
+
     private string $apiVersion = '202601';
 
     private string $accessToken;
@@ -110,7 +129,7 @@ private function retryWithRefresh(PostPlatform $postPlatform, ?string $content,
             $this->accessToken = $this->account->access_token;
 
             return $this->dispatchByMedia($content, $postPlatform);
-        } catch (\Throwable $e) {
+        } catch (Throwable $e) {
             Log::error("{$this->label()} refresh failed during retry", [
                 'account_id' => $this->account->id,
                 'error' => $e->getMessage(),
@@ -133,11 +152,126 @@ private function publishPost(?string $content, $media): array
                     'altText' => $item->isImage() ? $item->altTextFor($this->platform()) : null,
                 ], fn ($v) => $v !== null)];
             }
+        } else {
+            $article = $this->articleContent($content);
+
+            if ($article !== null) {
+                $payload['content'] = ['article' => $article];
+            }
         }
 
         return $this->createPost($payload, 'post creation');
     }
 
+    /**
+     * Article payload for the first link in a text-only post, or null when there
+     * is no link, the page has no title, or the scrape fails. LinkedIn will not
+     * unfurl a URL left in `commentary`, so the card has to be sent explicitly.
+     * A thumbnail failure still publishes the article — the image is optional.
+     *
+     * @return array{source: string, title: string, description?: string, thumbnail?: string}|null
+     */
+    private function articleContent(?string $content): ?array
+    {
+        if (! filled($content)) {
+            return null;
+        }
+
+        try {
+            $card = app(LinkCardFetcher::class)->fetch($content);
+        } catch (Throwable $e) {
+            Log::warning("{$this->label()} link preview lookup failed", [
+                'error' => $e->getMessage(),
+            ]);
+
+            return null;
+        }
+
+        $title = $card !== null && filled($card->title)
+            ? Str::limit($card->title, self::ARTICLE_TITLE_MAX, '')
+            : null;
+
+        if ($card === null || $title === null || $title === '') {
+            return null;
+        }
+
+        $article = [
+            'source' => $card->uri,
+            'title' => $title,
+        ];
+
+        if (filled($card->description)) {
+            $article['description'] = Str::limit($card->description, self::ARTICLE_DESCRIPTION_MAX, '');
+        }
+
+        $thumbnail = $this->uploadArticleThumbnail($card);
+
+        if ($thumbnail !== null) {
+            $article['thumbnail'] = $thumbnail;
+        }
+
+        return $article;
+    }
+
+    /**
+     * Upload the card's og:image and return its Image URN. Returns null (the
+     * article renders without a thumbnail) when there is no image, the host is
+     * not a public URL, or the upload fails. A dead token still propagates so
+     * the publish retry can refresh it.
+     */
+    private function uploadArticleThumbnail(LinkCardMetadata $card): ?string
+    {
+        if ($card->imageUrl === null || $card->imageUrl === '') {
+            return null;
+        }
+
+        $tempFile = tempnam(sys_get_temp_dir(), 'li_article_');
+
+        if ($tempFile === false) {
+            return null;
+        }
+
+        try {
+            $response = app(SafeHttpFetcher::class)
+                ->guardedRequest($card->imageUrl, followRedirects: false)
+                ->timeout(self::ARTICLE_THUMB_TIMEOUT_SECONDS)
+                ->withOptions(['sink' => $tempFile])
+                ->get($card->imageUrl);
+
+            $size = filesize($tempFile);
+
+            if (! $response->successful() || $size === false || $size === 0) {
+                return null;
+            }
+
+            $detectedMime = File::mimeType($tempFile) ?: '';
+
+            if (MediaType::classify($detectedMime) !== MediaType::Image) {
+                return null;
+            }
+
+            if (! MediaType::isGif($detectedMime)) {
+                $optimizedPath = app(MediaOptimizer::class)->optimizeImage($tempFile, $this->platform());
+                @unlink($tempFile);
+                $tempFile = $optimizedPath;
+            }
+
+            return $this->uploadImageFile($tempFile);
+        } catch (TokenExpiredException $e) {
+            throw $e;
+        } catch (Throwable $e) {
+            Log::warning("{$this->label()} article thumbnail skipped", [
+                'error' => $e->getMessage(),
+            ]);
+
+            return null;
+        } finally {
+            if (is_file($tempFile)) {
+                @unlink($tempFile);
+            }
+        }
+    }
+
     private function publishCarousel(?string $content, $media): array
     {
         $images = [];
@@ -260,6 +394,29 @@ private function uploadMedia($mediaItem): ?string
     }
 
     private function uploadImage($mediaItem): ?string
+    {
+        $tempFile = tempnam(sys_get_temp_dir(), 'li_image_');
+
+        try {
+            $this->downloadToTempFile($mediaItem->url, $tempFile);
+
+            $detectedMime = File::mimeType($tempFile) ?: '';
+            if (MediaType::classify($detectedMime) === MediaType::Image && ! MediaType::isGif($detectedMime)) {
+                $optimizedPath = app(MediaOptimizer::class)->optimizeImage($tempFile, $this->platform());
+                @unlink($tempFile);
+                $tempFile = $optimizedPath;
+            }
+
+            return $this->uploadImageFile($tempFile);
+        } finally {
+            @unlink($tempFile);
+        }
+    }
+
+    /**
+     * Initialize a LinkedIn image upload and PUT the bytes already on disk.
+     */
+    private function uploadImageFile(string $path): string
     {
         $initResponse = $this->getHttpClient()
             ->post("{$this->baseUrl()}/rest/images?action=initializeUpload", [
@@ -275,45 +432,30 @@ private function uploadImage($mediaItem): ?string
         $uploadUrl = data_get($initData, 'value.uploadUrl');
         $imageUrn = data_get($initData, 'value.image');
 
-        if (! $uploadUrl || ! $imageUrn) {
+        if (! is_string($uploadUrl) || $uploadUrl === '' || ! is_string($imageUrn) || $imageUrn === '') {
             throw new LinkedInPublishException(
                 userMessage: "{$this->label()} did not accept the image upload. Please try again.",
                 category: ErrorCategory::ServerError,
             );
         }
 
-        $tempFile = tempnam(sys_get_temp_dir(), 'li_image_');
-
-        try {
-            $this->downloadToTempFile($mediaItem->url, $tempFile);
-
-            $detectedMime = File::mimeType($tempFile) ?: '';
-            if (MediaType::classify($detectedMime) === MediaType::Image && ! MediaType::isGif($detectedMime)) {
-                $optimizedPath = app(MediaOptimizer::class)->optimizeImage($tempFile, $this->platform());
-                @unlink($tempFile);
-                $tempFile = $optimizedPath;
-            }
+        $stream = fopen($path, 'r');
 
-            $stream = fopen($tempFile, 'r');
+        $uploadResponse = Http::withToken($this->accessToken)
+            ->withHeaders(['Content-Type' => 'application/octet-stream'])
+            ->withBody($stream, 'application/octet-stream')
+            ->put($uploadUrl);
 
-            $uploadResponse = Http::withToken($this->accessToken)
-                ->withHeaders(['Content-Type' => 'application/octet-stream'])
-                ->withBody($stream, 'application/octet-stream')
-                ->put($uploadUrl);
-
-            if (is_resource($stream)) {
-                fclose($stream);
-            }
-
-            if ($uploadResponse->failed()) {
-                Log::error("{$this->label()} image upload failed", ['body' => $this->redactResponseBody($uploadResponse->body())]);
-                $this->handleApiError($uploadResponse);
-            }
+        if (is_resource($stream)) {
+            fclose($stream);
+        }
 
-            return $imageUrn;
-        } finally {
-            @unlink($tempFile);
+        if ($uploadResponse->failed()) {
+            Log::error("{$this->label()} image upload failed", ['body' => $this->redactResponseBody($uploadResponse->body())]);
+            $this->handleApiError($uploadResponse);
         }
+
+        return $imageUrn;
     }
 
     private function uploadVideo($mediaItem): ?string
diff --git a/app/Services/Social/FacebookPublisher.php b/app/Services/Social/FacebookPublisher.php
index b9faf1839..785c57bce 100644
--- a/app/Services/Social/FacebookPublisher.php
+++ b/app/Services/Social/FacebookPublisher.php
@@ -15,6 +15,7 @@
 use App\Services\Social\Concerns\CropsImageForAspectRatio;
 use App\Services\Social\Concerns\HasSocialHttpClient;
 use App\Services\Social\Meta\GraphError;
+use App\Support\UrlDetector;
 use Closure;
 use Illuminate\Http\Client\ConnectionException;
 use Illuminate\Http\Client\PendingRequest;
@@ -101,12 +102,38 @@ private function publishTextPost(string $pageId, string $accessToken, ?string $c
             );
         }
 
-        $response = $this->postToGraph("{$pageId}/feed", [
+        $link = UrlDetector::firstUrl($content);
+
+        try {
+            $response = $this->postTextToFeed($pageId, $accessToken, $content, $link);
+        } catch (FacebookPublishException $exception) {
+            // Graph error 1609005: Facebook could not scrape the URL. The post
+            // would have published as plain text before `link` was sent, so drop
+            // the card and try once more instead of failing the whole post.
+            if ($link === null || $exception->platformErrorCode !== '1609005') {
+                throw $exception;
+            }
+
+            Log::warning('Facebook could not scrape the link preview; publishing the text without it');
+
+            $response = $this->postTextToFeed($pageId, $accessToken, $content, null);
+        }
+
+        return $this->feedPostResult(data_get($response->json(), 'id'));
+    }
+
+    /**
+     * A text post carries `link` when the caption contains a URL. Facebook does
+     * not unfurl a URL left only in `message`; the Page Feed `link` field is
+     * what makes it scrape Open Graph and render the preview.
+     */
+    private function postTextToFeed(string $pageId, string $accessToken, string $content, ?string $link): Response
+    {
+        return $this->postToGraph("{$pageId}/feed", [
             'message' => $content,
             'access_token' => $accessToken,
+            ...$this->optionalField('link', $link),
         ], 'text post');
-
-        return $this->feedPostResult(data_get($response->json(), 'id'));
     }
 
     /**
diff --git a/resources/js/components/posts/previews/FacebookPreview.vue b/resources/js/components/posts/previews/FacebookPreview.vue
index a6ff12c77..a3bc53390 100644
--- a/resources/js/components/posts/previews/FacebookPreview.vue
+++ b/resources/js/components/posts/previews/FacebookPreview.vue
@@ -1,10 +1,12 @@
 <script setup lang="ts">
 import { IconDots, IconPhoto } from '@tabler/icons-vue';
 import { trans } from 'laravel-vue-i18n';
-import { computed } from 'vue';
+import { computed, toRef } from 'vue';
 
+import LinkCard from '@/components/posts/previews/LinkCard.vue';
 import PostMediaPreview from '@/components/posts/previews/PostMediaPreview.vue';
 import { getInitials } from '@/composables/useInitials';
+import { useLinkCard } from '@/composables/useLinkCard';
 import date from '@/date';
 import type { MediaItem } from '@/types/media';
 
@@ -36,6 +38,11 @@ const postedAtLabel = computed(() =>
     date.formatFacebookPreview(props.postedAt, trans('common.just_now')),
 );
 
+const { card: linkCard, loading: linkCardLoading } = useLinkCard(
+    toRef(props, 'content'),
+    toRef(props, 'media'),
+);
+
 // Content type helpers
 const isReel = computed(() => props.contentType === 'facebook_reel');
 const isStory = computed(() => props.contentType === 'facebook_story');
@@ -146,19 +153,29 @@ const truncatedContent = computed(() => {
                         </p>
                     </div>
 
-                    <!-- Post Media - Aspect ratio matches user's chosen crop -->
+                    <!-- Link preview replaces the empty media well on a text post -->
                     <div
-                        v-if="feedAspectPadding !== null"
-                        class="relative w-full shrink-0 bg-black"
-                        :style="{ paddingBottom: `${feedAspectPadding}%` }"
-                    >
-                        <div class="absolute inset-0">
+                        v-if="media.length === 0 && linkCardLoading"
+                        class="mx-3 mb-2 h-24 shrink-0 animate-pulse rounded-lg bg-[#f0f2f5] dark:bg-[#3a3b3c]"
+                    ></div>
+                    <div v-else-if="media.length === 0 && linkCard" class="px-3">
+                        <LinkCard :card="linkCard" />
+                    </div>
+                    <template v-else>
+                        <!-- Post Media - Aspect ratio matches user's chosen crop -->
+                        <div
+                            v-if="feedAspectPadding !== null"
+                            class="relative w-full shrink-0 bg-black"
+                            :style="{ paddingBottom: `${feedAspectPadding}%` }"
+                        >
+                            <div class="absolute inset-0">
+                                <PostMediaPreview :media="media" v-bind="feedMediaProps" />
+                            </div>
+                        </div>
+                        <div v-else class="flex-1 relative bg-black min-h-0">
                             <PostMediaPreview :media="media" v-bind="feedMediaProps" />
                         </div>
-                    </div>
-                    <div v-else class="flex-1 relative bg-black min-h-0">
-                        <PostMediaPreview :media="media" v-bind="feedMediaProps" />
-                    </div>
+                    </template>
 
                     <!-- Reactions Bar -->
                     <div
diff --git a/resources/js/components/posts/previews/LinkedInPreview.vue b/resources/js/components/posts/previews/LinkedInPreview.vue
index 066d7c9e3..69066846e 100644
--- a/resources/js/components/posts/previews/LinkedInPreview.vue
+++ b/resources/js/components/posts/previews/LinkedInPreview.vue
@@ -1,6 +1,10 @@
 <script setup lang="ts">
+import { toRef } from 'vue';
+
+import LinkCard from "@/components/posts/previews/LinkCard.vue";
 import VideoPreview from "@/components/posts/previews/VideoPreview.vue";
 import { getInitials } from '@/composables/useInitials';
+import { useLinkCard } from '@/composables/useLinkCard';
 import { isDocumentMedia, isVideoMedia } from '@/composables/useMedia';
 import type { MediaItem } from '@/types/media';
 
@@ -19,7 +23,12 @@ interface Props {
     media: MediaItem[];
 }
 
-defineProps<Props>();
+const props = defineProps<Props>();
+
+const { card: linkCard, loading: linkCardLoading } = useLinkCard(
+    toRef(props, 'content'),
+    toRef(props, 'media'),
+);
 </script>
 
 <template>
@@ -67,6 +76,14 @@ defineProps<Props>();
                 </div>
             </div>
 
+            <div
+                v-if="media.length === 0 && linkCardLoading"
+                class="mx-4 mb-3 h-24 animate-pulse rounded-xl border border-neutral-200 bg-neutral-100 dark:border-[#38434f] dark:bg-[#38434f]"
+            ></div>
+            <div v-else-if="media.length === 0 && linkCard" class="px-4">
+                <LinkCard :card="linkCard" />
+            </div>
+
             <!-- Media -->
             <div v-if="media.length > 0">
                 <div class="grid" :class="{
diff --git a/resources/js/components/posts/previews/MastodonPreview.vue b/resources/js/components/posts/previews/MastodonPreview.vue
index f038fa80a..9f4472028 100644
--- a/resources/js/components/posts/previews/MastodonPreview.vue
+++ b/resources/js/components/posts/previews/MastodonPreview.vue
@@ -1,8 +1,10 @@
 <script setup lang="ts">
-import { computed } from 'vue';
+import { computed, toRef } from 'vue';
 
+import LinkCard from "@/components/posts/previews/LinkCard.vue";
 import VideoPreview from "@/components/posts/previews/VideoPreview.vue";
 import { getInitials } from '@/composables/useInitials';
+import { useLinkCard } from '@/composables/useLinkCard';
 import { isVideoMedia } from '@/composables/useMedia';
 import date from '@/date';
 import type { MediaItem } from '@/types/media';
@@ -26,6 +28,11 @@ interface Props {
 const props = defineProps<Props>();
 
 const postedAtLabel = computed(() => date.formatMastodonPreview(props.postedAt));
+
+const { card: linkCard, loading: linkCardLoading } = useLinkCard(
+    toRef(props, 'content'),
+    toRef(props, 'media'),
+);
 </script>
 
 <template>
@@ -58,6 +65,12 @@ const postedAtLabel = computed(() => date.formatMastodonPreview(props.postedAt))
                     {{ content }}
                 </div>
 
+                <div
+                    v-if="media.length === 0 && linkCardLoading"
+                    class="mb-3 h-24 animate-pulse rounded-xl border border-[#c9d4de] bg-neutral-100 dark:border-[#313543] dark:bg-[#313543]"
+                ></div>
+                <LinkCard v-else-if="media.length === 0 && linkCard" :card="linkCard" />
+
                 <!-- Media -->
                 <div v-if="media.length > 0" class="mb-3">
                     <div class="rounded-lg overflow-hidden" :class="{
diff --git a/tests/Feature/Services/Social/FacebookPublisherTest.php b/tests/Feature/Services/Social/FacebookPublisherTest.php
index bfe06fe97..816c13807 100644
--- a/tests/Feature/Services/Social/FacebookPublisherTest.php
+++ b/tests/Feature/Services/Social/FacebookPublisherTest.php
@@ -124,7 +124,8 @@ function facebookVideoUploadFakes(string $edge): array
 
     Http::assertSent(function ($request) {
         return str_contains($request->url(), '/page_123/feed')
-            && $request['message'] === 'Check out this Facebook post!';
+            && $request['message'] === 'Check out this Facebook post!'
+            && ! array_key_exists('link', $request->data());
     });
 });
 
@@ -1210,5 +1211,71 @@ function facebookVideoUploadFakes(string $edge): array
     $this->publisher->publish($this->postPlatform);
 
     Http::assertSent(fn ($request) => str_contains($request->url(), '/page_123/feed')
-        && $request['message'] === 'New post: https://acme.com/blog');
+        && $request['message'] === 'New post: https://acme.com/blog'
+        && $request['link'] === 'https://acme.com/blog');
+});
+
+test('facebook publisher retries a text post without the link when the scrape fails', function () {
+    $this->post->update(['content' => 'Read https://example.com/post today']);
+
+    Http::fake([
+        '*/page_123/feed' => Http::sequence()
+            ->push(['error' => ['message' => 'There was a problem scraping the URL.', 'code' => 1609005]], 400)
+            ->push(['id' => 'page_123_post_456'], 200),
+    ]);
+
+    $result = $this->publisher->publish($this->postPlatform);
+
+    expect($result['id'])->toBe('page_123_post_456');
+
+    $feed = collect(Http::recorded())
+        ->map(fn (array $pair) => $pair[0])
+        ->filter(fn ($request) => str_contains($request->url(), '/page_123/feed'))
+        ->values();
+
+    expect($feed)->toHaveCount(2)
+        ->and($feed[0]['link'])->toBe('https://example.com/post')
+        ->and($feed[1]->data())->not->toHaveKey('link')
+        ->and($feed[1]['message'])->toBe('Read https://example.com/post today');
+});
+
+test('facebook publisher does not drop the link on an unrelated feed error', function () {
+    $this->post->update(['content' => 'Read https://example.com/post']);
+
+    Http::fake([
+        '*/page_123/feed' => Http::response([
+            'error' => ['message' => 'Duplicate post', 'code' => 506],
+        ], 400),
+    ]);
+
+    expect(fn () => $this->publisher->publish($this->postPlatform))
+        ->toThrow(FacebookPublishException::class);
+
+    Http::assertSentCount(1);
+});
+
+test('facebook publisher does not attach a link card when the post has media', function () {
+    $this->post->update([
+        'content' => 'Read https://example.com/post',
+        'media' => [[
+            'id' => 'test-media-id',
+            'path' => 'media/2026-01/image.jpg',
+            'url' => 'https://example.com/media/2026-01/image.jpg',
+            'mime_type' => 'image/jpeg',
+            'original_filename' => 'image.jpg',
+        ]],
+    ]);
+
+    Http::fake([
+        '*/page_123/photos' => Http::response([
+            'id' => 'photo_123',
+            'post_id' => 'page_123_photo_post_456',
+        ], 200),
+    ]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertNotSent(fn ($request) => str_contains($request->url(), '/page_123/feed'));
+    Http::assertSent(fn ($request) => str_contains($request->url(), '/page_123/photos')
+        && ! array_key_exists('link', $request->data()));
 });
diff --git a/tests/Feature/Services/Social/LinkedInPagePublisherTest.php b/tests/Feature/Services/Social/LinkedInPagePublisherTest.php
index 52f3e65c1..b8cad8a02 100644
--- a/tests/Feature/Services/Social/LinkedInPagePublisherTest.php
+++ b/tests/Feature/Services/Social/LinkedInPagePublisherTest.php
@@ -10,6 +10,7 @@
 use App\Models\SocialAccount;
 use App\Models\User;
 use App\Models\Workspace;
+use App\Services\Social\LinkCard\LinkCardFetcher;
 use App\Services\Social\LinkedInPagePublisher;
 use Illuminate\Support\Facades\Http;
 
@@ -443,6 +444,8 @@
 
     $this->post->update(['content' => 'New post: https://acme.com/blog']);
 
+    $this->mock(LinkCardFetcher::class)->shouldReceive('fetch')->once()->andReturn(null);
+
     Http::fake([
         config('trypost.platforms.linkedin-page.api').'/rest/posts' => Http::response(null, 201, [
             'x-restli-id' => 'urn:li:share:1234567890',
diff --git a/tests/Feature/Services/Social/LinkedInPublisherTest.php b/tests/Feature/Services/Social/LinkedInPublisherTest.php
index efa4347cf..badfe2d24 100644
--- a/tests/Feature/Services/Social/LinkedInPublisherTest.php
+++ b/tests/Feature/Services/Social/LinkedInPublisherTest.php
@@ -11,6 +11,9 @@
 use App\Models\SocialAccount;
 use App\Models\User;
 use App\Models\Workspace;
+use App\Services\Media\MediaOptimizer;
+use App\Services\Social\LinkCard\LinkCardFetcher;
+use App\Services\Social\LinkCard\LinkCardMetadata;
 use App\Services\Social\LinkedInPublisher;
 use Illuminate\Support\Facades\Http;
 
@@ -59,7 +62,8 @@
         return str_contains($request->url(), '/rest/posts')
             && $request['author'] === 'urn:li:person:abc123xyz'
             && $request['commentary'] === 'Hello from LinkedIn!'
-            && $request['visibility'] === 'PUBLIC';
+            && $request['visibility'] === 'PUBLIC'
+            && ! isset($request['content']);
     });
 });
 
@@ -1151,6 +1155,8 @@ protected function processingPollSeconds(): int
 
     $this->post->update(['content' => 'New post: https://trypost.it/blog']);
 
+    $this->mock(LinkCardFetcher::class)->shouldReceive('fetch')->once()->andReturn(null);
+
     Http::fake([
         config('trypost.platforms.linkedin.api').'/rest/posts' => Http::response(null, 201, [
             'x-restli-id' => 'urn:li:share:1234567890',
@@ -1160,5 +1166,208 @@ protected function processingPollSeconds(): int
     $this->publisher->publish($this->postPlatform);
 
     Http::assertSent(fn ($request) => str_contains($request->url(), '/rest/posts')
-        && $request['commentary'] === 'New post: https://trypost.it/blog');
+        && $request['commentary'] === 'New post: https://trypost.it/blog'
+        && ! isset($request['content']));
 });
+
+test('linkedin publisher sends an article card for a text post that contains a link', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article today.']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: 'The Article',
+            description: 'A great read',
+            imageUrl: null,
+        ));
+
+    Http::fake([
+        config('trypost.platforms.linkedin.api').'/rest/posts' => Http::response(null, 201, [
+            'x-restli-id' => 'urn:li:share:article1',
+        ]),
+    ]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(function ($request) {
+        $article = $request['content']['article'] ?? null;
+
+        return str_contains($request->url(), '/rest/posts')
+            && $request['commentary'] === 'Read this https://example.com/article today.'
+            && $article['source'] === 'https://example.com/article'
+            && $article['title'] === 'The Article'
+            && $article['description'] === 'A great read'
+            && ! isset($article['thumbnail']);
+    });
+});
+
+test('linkedin publisher skips the article card when the page has no title', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: '   ',
+            description: 'Only a description',
+            imageUrl: null,
+        ));
+
+    Http::fake([
+        config('trypost.platforms.linkedin.api').'/rest/posts' => Http::response(null, 201, [
+            'x-restli-id' => 'urn:li:share:notitle',
+        ]),
+    ]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(fn ($request) => str_contains($request->url(), '/rest/posts')
+        && ! isset($request['content']));
+});
+
+test('linkedin publisher prefers attached media over a link card', function () {
+    $this->post->update([
+        'content' => 'see https://example.com/article',
+        'media' => [[
+            'id' => 'test-media-id',
+            'path' => 'media/2026-01/test-image.jpg',
+            'url' => 'https://example.com/media/2026-01/test-image.jpg',
+            'mime_type' => 'image/jpeg',
+            'original_filename' => 'test.jpg',
+        ]],
+    ]);
+
+    $this->mock(LinkCardFetcher::class)->shouldNotReceive('fetch');
+
+    $uploadUrl = 'https://www.linkedin.com/dms/upload/v2/pic/0/C5622AQFake';
+
+    Http::fake(function ($request) use ($uploadUrl) {
+        $url = $request->url();
+
+        if (str_contains($url, '/rest/images')) {
+            return Http::response([
+                'value' => [
+                    'uploadUrl' => $uploadUrl,
+                    'image' => 'urn:li:image:C5622AQFakeImageUrn',
+                ],
+            ], 200);
+        }
+
+        if ($url === $uploadUrl) {
+            return Http::response(null, 201);
+        }
+
+        if (str_contains($url, '/rest/posts')) {
+            return Http::response(null, 201, ['x-restli-id' => 'urn:li:share:mediawins']);
+        }
+
+        return Http::response('fake-image-content', 200);
+    });
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(fn ($request) => str_contains($request->url(), '/rest/posts')
+        && isset($request['content']['media']['id'])
+        && ! isset($request['content']['article']));
+});
+
+test('linkedin publisher uploads the article thumbnail', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: 'The Article',
+            description: 'A great read',
+            imageUrl: 'https://93.184.216.34/card.jpg',
+        ));
+
+    $this->mock(MediaOptimizer::class)
+        ->shouldReceive('optimizeImage')
+        ->once()
+        ->andReturnUsing(fn () => tap(tempnam(sys_get_temp_dir(), 'li_thumb_'), fn ($path) => file_put_contents($path, 'thumb-bytes')));
+
+    $jpeg = linkedInJpegBytes();
+    $uploadUrl = 'https://www.linkedin.com/dms/upload/v2/pic/0/article-thumb';
+
+    Http::fake(function ($request) use ($uploadUrl, $jpeg) {
+        $url = $request->url();
+
+        if (str_contains($url, '/rest/images')) {
+            return Http::response([
+                'value' => [
+                    'uploadUrl' => $uploadUrl,
+                    'image' => 'urn:li:image:articleThumb',
+                ],
+            ], 200);
+        }
+
+        if ($url === $uploadUrl) {
+            return Http::response(null, 201);
+        }
+
+        if (str_contains($url, '/rest/posts')) {
+            return Http::response(null, 201, ['x-restli-id' => 'urn:li:share:withthumb']);
+        }
+
+        return Http::response($jpeg, 200);
+    });
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(function ($request) {
+        $article = $request['content']['article'] ?? null;
+
+        return str_contains($request->url(), '/rest/posts')
+            && $article['thumbnail'] === 'urn:li:image:articleThumb'
+            && $article['source'] === 'https://example.com/article';
+    });
+});
+
+test('linkedin publisher still publishes the article when the thumbnail cannot be fetched', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: 'The Article',
+            description: 'A great read',
+            imageUrl: 'https://93.184.216.34/missing.jpg',
+        ));
+
+    Http::fake(function ($request) {
+        if (str_contains($request->url(), '/rest/posts')) {
+            return Http::response(null, 201, ['x-restli-id' => 'urn:li:share:nothumb']);
+        }
+
+        return Http::response('', 404);
+    });
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(function ($request) {
+        $article = $request['content']['article'] ?? null;
+
+        return str_contains($request->url(), '/rest/posts')
+            && $article['title'] === 'The Article'
+            && ! isset($article['thumbnail']);
+    });
+});
+
+function linkedInJpegBytes(): string
+{
+    $image = imagecreatetruecolor(8, 8);
+    ob_start();
+    imagejpeg($image);
+    $bytes = ob_get_clean();
+    imagedestroy($image);
+
+    return $bytes === false ? '' : $bytes;
+}

From 20c21d5e13f99c9355775ee27d37b68bb83ed707 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:04:38 -0300
Subject: [PATCH 02/18] Keep a Facebook text post alive when the link itself is
 rejected.

facebook.com, fb.com and fb.me are no longer sent as the Page feed link, and a scrape or invalid-URL error retries once without the card. LinkedIn still publishes the text if the preview lookup fails, and the thumbnail download stays off private hosts.
---
 .../Social/FacebookPublishException.php       | 11 +++
 app/Services/Social/FacebookPublisher.php     | 74 +++++++++++++--
 .../Services/Social/FacebookPublisherTest.php | 87 ++++++++++++++++++
 .../Services/Social/LinkedInPublisherTest.php | 89 +++++++++++++++++++
 .../Social/FacebookPublishExceptionTest.php   | 19 ++++
 5 files changed, 274 insertions(+), 6 deletions(-)

diff --git a/app/Exceptions/Social/FacebookPublishException.php b/app/Exceptions/Social/FacebookPublishException.php
index ec277c4ac..d26aa443e 100644
--- a/app/Exceptions/Social/FacebookPublishException.php
+++ b/app/Exceptions/Social/FacebookPublishException.php
@@ -9,6 +9,16 @@
 
 class FacebookPublishException extends SocialPublishException
 {
+    public function __construct(
+        string $userMessage,
+        ErrorCategory $category,
+        ?string $platformErrorCode = null,
+        ?string $rawResponse = null,
+        public readonly ?string $platformErrorSubcode = null,
+    ) {
+        parent::__construct($userMessage, $category, $platformErrorCode, $rawResponse);
+    }
+
     public static function fromApiResponse(mixed $response): static
     {
         /** @var Response $response */
@@ -66,6 +76,7 @@ public static function fromApiResponse(mixed $response): static
             category: $category,
             platformErrorCode: $errorCode !== null ? (string) $errorCode : null,
             rawResponse: $rawResponse,
+            platformErrorSubcode: $errorSubcode !== null ? (string) $errorSubcode : null,
         );
     }
 
diff --git a/app/Services/Social/FacebookPublisher.php b/app/Services/Social/FacebookPublisher.php
index 785c57bce..f72d1e011 100644
--- a/app/Services/Social/FacebookPublisher.php
+++ b/app/Services/Social/FacebookPublisher.php
@@ -102,19 +102,23 @@ private function publishTextPost(string $pageId, string $accessToken, ?string $c
             );
         }
 
-        $link = UrlDetector::firstUrl($content);
+        $link = $this->linkPreviewUrl($content);
 
         try {
             $response = $this->postTextToFeed($pageId, $accessToken, $content, $link);
         } catch (FacebookPublishException $exception) {
-            // Graph error 1609005: Facebook could not scrape the URL. The post
-            // would have published as plain text before `link` was sent, so drop
-            // the card and try once more instead of failing the whole post.
-            if ($link === null || $exception->platformErrorCode !== '1609005') {
+            // These codes mean the `link` itself was rejected (scrape failed,
+            // invalid URL, or a facebook.com URL). The caption would have
+            // published as plain text before `link` was sent, so drop the card
+            // and try once. Any other error still fails the post.
+            if ($link === null || ! $this->isLinkRejection($exception)) {
                 throw $exception;
             }
 
-            Log::warning('Facebook could not scrape the link preview; publishing the text without it');
+            Log::warning('Facebook rejected the link preview; publishing the text without it', [
+                'platform_error_code' => $exception->platformErrorCode,
+                'platform_error_subcode' => $exception->platformErrorSubcode,
+            ]);
 
             $response = $this->postTextToFeed($pageId, $accessToken, $content, null);
         }
@@ -122,6 +126,64 @@ private function publishTextPost(string $pageId, string $accessToken, ?string $c
         return $this->feedPostResult(data_get($response->json(), 'id'));
     }
 
+    /**
+     * First http(s) URL in the caption that Facebook will accept as a `link`.
+     * facebook.com, fb.com and fb.me (and their subdomains) are skipped: the
+     * Page Feed API rejects many of them and fails the whole post.
+     */
+    private function linkPreviewUrl(string $content): ?string
+    {
+        $offset = 0;
+        $length = strlen($content);
+
+        while ($offset < $length && preg_match(UrlDetector::URL_PATTERN, $content, $matches, PREG_OFFSET_CAPTURE, $offset) === 1) {
+            $raw = $matches[0][0];
+            $url = UrlDetector::trimTrailingPunctuation($raw);
+
+            if (! $this->isFacebookOwnedUrl($url)) {
+                return $url;
+            }
+
+            $offset = $matches[0][1] + strlen($raw);
+        }
+
+        return null;
+    }
+
+    private function isFacebookOwnedUrl(string $url): bool
+    {
+        $host = parse_url($url, PHP_URL_HOST);
+
+        if (! is_string($host) || $host === '') {
+            return false;
+        }
+
+        $host = strtolower($host);
+
+        foreach (['facebook.com', 'fb.com', 'fb.me'] as $domain) {
+            if ($host === $domain || str_ends_with($host, ".{$domain}")) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Graph rejects the link, not the post: 1609005 (scrape failed), 1500
+     * (invalid URL), and 200/1609008 (facebook.com links).
+     */
+    private function isLinkRejection(FacebookPublishException $exception): bool
+    {
+        $code = $exception->platformErrorCode;
+
+        if ($code === '1609005' || $code === '1500') {
+            return true;
+        }
+
+        return $code === '200' && $exception->platformErrorSubcode === '1609008';
+    }
+
     /**
      * A text post carries `link` when the caption contains a URL. Facebook does
      * not unfurl a URL left only in `message`; the Page Feed `link` field is
diff --git a/tests/Feature/Services/Social/FacebookPublisherTest.php b/tests/Feature/Services/Social/FacebookPublisherTest.php
index 816c13807..a12154178 100644
--- a/tests/Feature/Services/Social/FacebookPublisherTest.php
+++ b/tests/Feature/Services/Social/FacebookPublisherTest.php
@@ -1254,6 +1254,93 @@ function facebookVideoUploadFakes(string $edge): array
     Http::assertSentCount(1);
 });
 
+test('facebook publisher does not send a facebook-owned url as the link', function (string $url) {
+    $this->post->update(['content' => "See {$url}"]);
+
+    Http::fake(['*/page_123/feed' => Http::response(['id' => 'page_123_post_456'], 200)]);
+
+    $result = $this->publisher->publish($this->postPlatform);
+
+    expect($result['id'])->toBe('page_123_post_456');
+
+    Http::assertSent(fn ($request) => str_contains($request->url(), '/page_123/feed')
+        && $request['message'] === "See {$url}"
+        && ! array_key_exists('link', $request->data()));
+
+    Http::assertSentCount(1);
+})->with([
+    'www' => 'https://www.facebook.com/somepage',
+    'mobile' => 'https://m.facebook.com/somepage',
+    'apex' => 'https://facebook.com/events/1',
+    'fb.com' => 'https://fb.com/somepage',
+    'fb.me' => 'https://fb.me/abc',
+    'subdomain' => 'https://l.facebook.com/l.php?u=https://example.com',
+]);
+
+test('facebook publisher uses the first url that facebook can preview', function () {
+    $this->post->update(['content' => 'See https://www.facebook.com/page and https://example.com/post.']);
+
+    Http::fake(['*/page_123/feed' => Http::response(['id' => 'page_123_post_456'], 200)]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(fn ($request) => str_contains($request->url(), '/page_123/feed')
+        && $request['message'] === 'See https://www.facebook.com/page and https://example.com/post.'
+        && $request['link'] === 'https://example.com/post');
+});
+
+test('facebook publisher still attaches a link on a host that only looks like facebook', function () {
+    $this->post->update(['content' => 'See https://notfacebook.com/post']);
+
+    Http::fake(['*/page_123/feed' => Http::response(['id' => 'page_123_post_456'], 200)]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(fn ($request) => str_contains($request->url(), '/page_123/feed')
+        && $request['link'] === 'https://notfacebook.com/post');
+});
+
+test('facebook publisher retries without the link when facebook rejects the url', function (array $error) {
+    $this->post->update(['content' => 'Read https://example.com/post today']);
+
+    Http::fake([
+        '*/page_123/feed' => Http::sequence()
+            ->push(['error' => $error], 400)
+            ->push(['id' => 'page_123_post_456'], 200),
+    ]);
+
+    $result = $this->publisher->publish($this->postPlatform);
+
+    expect($result['id'])->toBe('page_123_post_456');
+
+    $feed = collect(Http::recorded())
+        ->map(fn (array $pair) => $pair[0])
+        ->filter(fn ($request) => str_contains($request->url(), '/page_123/feed'))
+        ->values();
+
+    expect($feed)->toHaveCount(2)
+        ->and($feed[0]['link'])->toBe('https://example.com/post')
+        ->and($feed[1]->data())->not->toHaveKey('link');
+})->with([
+    'invalid url' => [['message' => 'The url you supplied is invalid', 'code' => 1500]],
+    'facebook.com link' => [['message' => 'Permissions error', 'code' => 200, 'error_subcode' => 1609008]],
+]);
+
+test('facebook publisher does not drop the link on a permissions error without the facebook-url subcode', function () {
+    $this->post->update(['content' => 'Read https://example.com/post']);
+
+    Http::fake([
+        '*/page_123/feed' => Http::response([
+            'error' => ['message' => 'Permissions error', 'code' => 200],
+        ], 400),
+    ]);
+
+    expect(fn () => $this->publisher->publish($this->postPlatform))
+        ->toThrow(FacebookPublishException::class);
+
+    Http::assertSentCount(1);
+});
+
 test('facebook publisher does not attach a link card when the post has media', function () {
     $this->post->update([
         'content' => 'Read https://example.com/post',
diff --git a/tests/Feature/Services/Social/LinkedInPublisherTest.php b/tests/Feature/Services/Social/LinkedInPublisherTest.php
index badfe2d24..77be90985 100644
--- a/tests/Feature/Services/Social/LinkedInPublisherTest.php
+++ b/tests/Feature/Services/Social/LinkedInPublisherTest.php
@@ -16,6 +16,7 @@
 use App\Services\Social\LinkCard\LinkCardMetadata;
 use App\Services\Social\LinkedInPublisher;
 use Illuminate\Support\Facades\Http;
+use RuntimeException;
 
 beforeEach(function () {
     $this->user = User::factory()->create();
@@ -1361,6 +1362,94 @@ protected function processingPollSeconds(): int
     });
 });
 
+test('linkedin publisher publishes the text when the link preview lookup fails', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andThrow(new RuntimeException('scrape failed'));
+
+    Http::fake([
+        config('trypost.platforms.linkedin.api').'/rest/posts' => Http::response(null, 201, [
+            'x-restli-id' => 'urn:li:share:lookupfailed',
+        ]),
+    ]);
+
+    $result = $this->publisher->publish($this->postPlatform);
+
+    expect($result['id'])->toBe('urn:li:share:lookupfailed');
+
+    Http::assertSent(fn ($request) => str_contains($request->url(), '/rest/posts')
+        && $request['commentary'] === 'Read this https://example.com/article'
+        && ! isset($request['content']));
+});
+
+test('linkedin publisher blocks the article thumbnail when the image points at a private address', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: 'The Article',
+            description: 'A great read',
+            imageUrl: 'http://127.0.0.1/evil.jpg',
+        ));
+
+    Http::fake([
+        config('trypost.platforms.linkedin.api').'/rest/posts' => Http::response(null, 201, [
+            'x-restli-id' => 'urn:li:share:private',
+        ]),
+    ]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(function ($request) {
+        $article = $request['content']['article'] ?? null;
+
+        return str_contains($request->url(), '/rest/posts')
+            && $article['title'] === 'The Article'
+            && ! isset($article['thumbnail']);
+    });
+
+    Http::assertNotSent(fn ($request) => str_contains($request->url(), '127.0.0.1'));
+});
+
+test('linkedin publisher does not follow a redirect on the article thumbnail', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: 'The Article',
+            description: 'A great read',
+            imageUrl: 'https://93.184.216.34/card.jpg',
+        ));
+
+    Http::fake([
+        'https://93.184.216.34/card.jpg' => Http::response('', 302, ['Location' => 'http://127.0.0.1/internal.jpg']),
+        config('trypost.platforms.linkedin.api').'/rest/posts' => Http::response(null, 201, [
+            'x-restli-id' => 'urn:li:share:noredirect',
+        ]),
+    ]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(function ($request) {
+        $article = $request['content']['article'] ?? null;
+
+        return str_contains($request->url(), '/rest/posts')
+            && $article['title'] === 'The Article'
+            && ! isset($article['thumbnail']);
+    });
+
+    Http::assertNotSent(fn ($request) => str_contains($request->url(), '127.0.0.1'));
+});
+
 function linkedInJpegBytes(): string
 {
     $image = imagecreatetruecolor(8, 8);
diff --git a/tests/Unit/Exceptions/Social/FacebookPublishExceptionTest.php b/tests/Unit/Exceptions/Social/FacebookPublishExceptionTest.php
index f7394c8fd..d7f2c66ff 100644
--- a/tests/Unit/Exceptions/Social/FacebookPublishExceptionTest.php
+++ b/tests/Unit/Exceptions/Social/FacebookPublishExceptionTest.php
@@ -125,6 +125,25 @@
         ->and($exception->userMessage)->toBe('An unexpected error occurred.');
 });
 
+test('code 200 keeps the facebook-url subcode', function () {
+    $response = Http::response([
+        'error' => [
+            'message' => 'Permissions error',
+            'type' => 'OAuthException',
+            'code' => 200,
+            'error_subcode' => 1609008,
+        ],
+    ], 400);
+
+    $fakeResponse = Http::fake(['*' => $response])->post('https://graph.facebook.com/test');
+
+    $exception = FacebookPublishException::fromApiResponse($fakeResponse);
+
+    expect($exception->platformErrorCode)->toBe('200')
+        ->and($exception->platformErrorSubcode)->toBe('1609008')
+        ->and($exception->userMessage)->toBe('Permissions error');
+});
+
 test('subcode 463 throws TokenExpiredException', function () {
     $response = Http::response([
         'error' => [

From a79d6a80c5cee969a93715191f728ab7e22202c6 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:14:27 -0300
Subject: [PATCH 03/18] Show the Facebook preview card for the link that will
 actually publish.

The editor now skips facebook.com, fb.com and fb.me the same way the publisher does, and a link rejection that is retried as plain text is no longer logged as a failed post.
---
 app/Services/Social/FacebookPublisher.php     | 75 ++++++-------------
 app/Support/FacebookLinkPreview.php           | 53 +++++++++++++
 .../posts/previews/FacebookPreview.vue        |  2 +
 resources/js/composables/useLinkCard.ts       | 24 +++++-
 resources/js/lib/facebookLinkPreview.ts       | 44 +++++++++++
 .../Services/Social/FacebookPublisherTest.php | 36 +++++++++
 .../Unit/Support/FacebookLinkPreviewTest.php  | 63 ++++++++++++++++
 .../fixtures/facebook-link-preview-harness.js | 13 ++++
 8 files changed, 253 insertions(+), 57 deletions(-)
 create mode 100644 app/Support/FacebookLinkPreview.php
 create mode 100644 resources/js/lib/facebookLinkPreview.ts
 create mode 100644 tests/Unit/Support/FacebookLinkPreviewTest.php
 create mode 100644 tests/fixtures/facebook-link-preview-harness.js

diff --git a/app/Services/Social/FacebookPublisher.php b/app/Services/Social/FacebookPublisher.php
index f72d1e011..7e63f45ac 100644
--- a/app/Services/Social/FacebookPublisher.php
+++ b/app/Services/Social/FacebookPublisher.php
@@ -15,7 +15,7 @@
 use App\Services\Social\Concerns\CropsImageForAspectRatio;
 use App\Services\Social\Concerns\HasSocialHttpClient;
 use App\Services\Social\Meta\GraphError;
-use App\Support\UrlDetector;
+use App\Support\FacebookLinkPreview;
 use Closure;
 use Illuminate\Http\Client\ConnectionException;
 use Illuminate\Http\Client\PendingRequest;
@@ -102,16 +102,25 @@ private function publishTextPost(string $pageId, string $accessToken, ?string $c
             );
         }
 
-        $link = $this->linkPreviewUrl($content);
+        $link = FacebookLinkPreview::url($content);
 
         try {
-            $response = $this->postTextToFeed($pageId, $accessToken, $content, $link);
+            // A link we might drop must not be logged as a failed publish. The
+            // retry below is the real attempt, and that one still reports.
+            $response = $this->postTextToFeed($pageId, $accessToken, $content, $link, reportFailure: $link === null);
         } catch (FacebookPublishException $exception) {
             // These codes mean the `link` itself was rejected (scrape failed,
             // invalid URL, or a facebook.com URL). The caption would have
             // published as plain text before `link` was sent, so drop the card
             // and try once. Any other error still fails the post.
             if ($link === null || ! $this->isLinkRejection($exception)) {
+                if ($link !== null) {
+                    Log::error('Facebook text post failed', [
+                        'platform_error_code' => $exception->platformErrorCode,
+                        'body' => $this->redactResponseBody($exception->rawResponse ?? ''),
+                    ]);
+                }
+
                 throw $exception;
             }
 
@@ -126,49 +135,6 @@ private function publishTextPost(string $pageId, string $accessToken, ?string $c
         return $this->feedPostResult(data_get($response->json(), 'id'));
     }
 
-    /**
-     * First http(s) URL in the caption that Facebook will accept as a `link`.
-     * facebook.com, fb.com and fb.me (and their subdomains) are skipped: the
-     * Page Feed API rejects many of them and fails the whole post.
-     */
-    private function linkPreviewUrl(string $content): ?string
-    {
-        $offset = 0;
-        $length = strlen($content);
-
-        while ($offset < $length && preg_match(UrlDetector::URL_PATTERN, $content, $matches, PREG_OFFSET_CAPTURE, $offset) === 1) {
-            $raw = $matches[0][0];
-            $url = UrlDetector::trimTrailingPunctuation($raw);
-
-            if (! $this->isFacebookOwnedUrl($url)) {
-                return $url;
-            }
-
-            $offset = $matches[0][1] + strlen($raw);
-        }
-
-        return null;
-    }
-
-    private function isFacebookOwnedUrl(string $url): bool
-    {
-        $host = parse_url($url, PHP_URL_HOST);
-
-        if (! is_string($host) || $host === '') {
-            return false;
-        }
-
-        $host = strtolower($host);
-
-        foreach (['facebook.com', 'fb.com', 'fb.me'] as $domain) {
-            if ($host === $domain || str_ends_with($host, ".{$domain}")) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
     /**
      * Graph rejects the link, not the post: 1609005 (scrape failed), 1500
      * (invalid URL), and 200/1609008 (facebook.com links).
@@ -189,13 +155,13 @@ private function isLinkRejection(FacebookPublishException $exception): bool
      * not unfurl a URL left only in `message`; the Page Feed `link` field is
      * what makes it scrape Open Graph and render the preview.
      */
-    private function postTextToFeed(string $pageId, string $accessToken, string $content, ?string $link): Response
+    private function postTextToFeed(string $pageId, string $accessToken, string $content, ?string $link, bool $reportFailure = true): Response
     {
         return $this->postToGraph("{$pageId}/feed", [
             'message' => $content,
             'access_token' => $accessToken,
             ...$this->optionalField('link', $link),
-        ], 'text post');
+        ], 'text post', $reportFailure);
     }
 
     /**
@@ -553,7 +519,7 @@ private function facebookHttp(): PendingRequest
      *
      * @param  array<string, string>  $payload
      */
-    private function postToGraph(string $path, array $payload, string $label): Response
+    private function postToGraph(string $path, array $payload, string $label, bool $reportFailure = true): Response
     {
         $response = $this->reachOrRetry(
             fn (): Response => $this->facebookHttp()->post("{$this->baseUrl}/{$path}", $payload),
@@ -561,10 +527,13 @@ private function postToGraph(string $path, array $payload, string $label): Respo
         );
 
         if ($response->failed()) {
-            Log::error("Facebook {$label} failed", [
-                'status' => $response->status(),
-                'body' => $this->redactResponseBody($response->body()),
-            ]);
+            if ($reportFailure) {
+                Log::error("Facebook {$label} failed", [
+                    'status' => $response->status(),
+                    'body' => $this->redactResponseBody($response->body()),
+                ]);
+            }
+
             $this->handleApiError($response);
         }
 
diff --git a/app/Support/FacebookLinkPreview.php b/app/Support/FacebookLinkPreview.php
new file mode 100644
index 000000000..27a0c0abb
--- /dev/null
+++ b/app/Support/FacebookLinkPreview.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Support;
+
+/**
+ * First http(s) URL Facebook will accept as a Page feed `link`. facebook.com,
+ * fb.com and fb.me (and their subdomains) are skipped: the API rejects many of
+ * them and fails the whole post. The editor mirrors this in
+ * `resources/js/lib/facebookLinkPreview.ts`; the parity test keeps the two
+ * in step.
+ */
+final class FacebookLinkPreview
+{
+    public static function url(string $text): ?string
+    {
+        $offset = 0;
+        $length = strlen($text);
+
+        while ($offset < $length && preg_match(UrlDetector::URL_PATTERN, $text, $matches, PREG_OFFSET_CAPTURE, $offset) === 1) {
+            $raw = $matches[0][0];
+            $url = UrlDetector::trimTrailingPunctuation($raw);
+
+            if (! self::isOwnedHost($url)) {
+                return $url;
+            }
+
+            $offset = $matches[0][1] + strlen($raw);
+        }
+
+        return null;
+    }
+
+    private static function isOwnedHost(string $url): bool
+    {
+        $host = parse_url($url, PHP_URL_HOST);
+
+        if (! is_string($host) || $host === '') {
+            return false;
+        }
+
+        $host = strtolower($host);
+
+        foreach (['facebook.com', 'fb.com', 'fb.me'] as $domain) {
+            if ($host === $domain || str_ends_with($host, ".{$domain}")) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/resources/js/components/posts/previews/FacebookPreview.vue b/resources/js/components/posts/previews/FacebookPreview.vue
index a3bc53390..65af59f46 100644
--- a/resources/js/components/posts/previews/FacebookPreview.vue
+++ b/resources/js/components/posts/previews/FacebookPreview.vue
@@ -8,6 +8,7 @@ import PostMediaPreview from '@/components/posts/previews/PostMediaPreview.vue';
 import { getInitials } from '@/composables/useInitials';
 import { useLinkCard } from '@/composables/useLinkCard';
 import date from '@/date';
+import { facebookLinkPreviewUrl } from '@/lib/facebookLinkPreview';
 import type { MediaItem } from '@/types/media';
 
 interface SocialAccount {
@@ -41,6 +42,7 @@ const postedAtLabel = computed(() =>
 const { card: linkCard, loading: linkCardLoading } = useLinkCard(
     toRef(props, 'content'),
     toRef(props, 'media'),
+    { selectUrl: facebookLinkPreviewUrl },
 );
 
 // Content type helpers
diff --git a/resources/js/composables/useLinkCard.ts b/resources/js/composables/useLinkCard.ts
index 429a63196..046f2d160 100644
--- a/resources/js/composables/useLinkCard.ts
+++ b/resources/js/composables/useLinkCard.ts
@@ -18,15 +18,31 @@ export interface LinkCard {
  * — a rough match is enough, because the backend re-detects it and returns the
  * exact, trimmed URL as `card.uri` — and resolves its OpenGraph card, but only
  * when no media is attached (media suppresses the link card on every platform).
+ *
+ * `selectUrl` replaces that first-match when a platform publishes a different
+ * URL than the first one in the caption. Facebook does: it skips facebook.com,
+ * fb.com and fb.me.
  */
-export const useLinkCard = (content: Ref<string>, media: Ref<MediaItem[]>) => {
+export const useLinkCard = (
+    content: Ref<string>,
+    media: Ref<MediaItem[]>,
+    options: { selectUrl?: (content: string) => string | null } = {},
+) => {
     const card = ref<LinkCard | null>(null);
     const loading = ref(false);
     const http = useHttp<{ url: string }, LinkCard | null>({ url: '' });
 
-    const url = computed(() =>
-        media.value.length > 0 ? null : (content.value.match(/https?:\/\/\S+/)?.[0] ?? null),
-    );
+    const url = computed(() => {
+        if (media.value.length > 0) {
+            return null;
+        }
+
+        if (options.selectUrl) {
+            return options.selectUrl(content.value);
+        }
+
+        return content.value.match(/https?:\/\/\S+/)?.[0] ?? null;
+    });
 
     const fetchCard = async (target: string): Promise<void> => {
         loading.value = true;
diff --git a/resources/js/lib/facebookLinkPreview.ts b/resources/js/lib/facebookLinkPreview.ts
new file mode 100644
index 000000000..abf9e9529
--- /dev/null
+++ b/resources/js/lib/facebookLinkPreview.ts
@@ -0,0 +1,44 @@
+/**
+ * Mirrors `App\Support\FacebookLinkPreview`. The composer has to pick the same
+ * URL the publisher will send as `link`, or the preview card is a different
+ * page than the one Facebook receives. One trailing punctuation mark and an
+ * unmatched closing parenthesis are trimmed, matching
+ * `UrlDetector::trimTrailingPunctuation`.
+ */
+const FACEBOOK_HOSTS = ['facebook.com', 'fb.com', 'fb.me'];
+
+const trimTrailingPunctuation = (url: string): string => {
+    if (/[.,;:!?]$/.test(url)) {
+        url = url.slice(0, -1);
+    }
+
+    if (url.endsWith(')') && !url.includes('(')) {
+        url = url.slice(0, -1);
+    }
+
+    return url;
+};
+
+const isFacebookOwnedUrl = (url: string): boolean => {
+    let host: string;
+
+    try {
+        host = new URL(url).hostname.toLowerCase();
+    } catch {
+        return false;
+    }
+
+    return FACEBOOK_HOSTS.some((domain) => host === domain || host.endsWith(`.${domain}`));
+};
+
+export const facebookLinkPreviewUrl = (text: string): string | null => {
+    for (const match of text.matchAll(/https?:\/\/\S+/gu)) {
+        const url = trimTrailingPunctuation(match[0]);
+
+        if (!isFacebookOwnedUrl(url)) {
+            return url;
+        }
+    }
+
+    return null;
+};
diff --git a/tests/Feature/Services/Social/FacebookPublisherTest.php b/tests/Feature/Services/Social/FacebookPublisherTest.php
index a12154178..ce023e9d8 100644
--- a/tests/Feature/Services/Social/FacebookPublisherTest.php
+++ b/tests/Feature/Services/Social/FacebookPublisherTest.php
@@ -15,6 +15,7 @@
 use App\Services\Social\FacebookPublisher;
 use Illuminate\Http\Client\ConnectionException;
 use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Sleep;
 use Intervention\Image\Drivers\Gd\Driver;
@@ -1239,6 +1240,41 @@ function facebookVideoUploadFakes(string $edge): array
         ->and($feed[1]['message'])->toBe('Read https://example.com/post today');
 });
 
+test('facebook publisher does not log an error when the rejected link is published without it', function () {
+    $this->post->update(['content' => 'Read https://example.com/post today']);
+
+    Log::spy();
+
+    Http::fake([
+        '*/page_123/feed' => Http::sequence()
+            ->push(['error' => ['message' => 'There was a problem scraping the URL.', 'code' => 1609005]], 400)
+            ->push(['id' => 'page_123_post_456'], 200),
+    ]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Log::shouldHaveReceived('warning')->once();
+    Log::shouldNotHaveReceived('error');
+});
+
+test('facebook publisher logs an error when a text post fails for a reason other than the link', function () {
+    $this->post->update(['content' => 'Read https://example.com/post']);
+
+    Log::spy();
+
+    Http::fake([
+        '*/page_123/feed' => Http::response([
+            'error' => ['message' => 'Duplicate post', 'code' => 506],
+        ], 400),
+    ]);
+
+    expect(fn () => $this->publisher->publish($this->postPlatform))
+        ->toThrow(FacebookPublishException::class);
+
+    Log::shouldHaveReceived('error')->once();
+    Log::shouldNotHaveReceived('warning');
+});
+
 test('facebook publisher does not drop the link on an unrelated feed error', function () {
     $this->post->update(['content' => 'Read https://example.com/post']);
 
diff --git a/tests/Unit/Support/FacebookLinkPreviewTest.php b/tests/Unit/Support/FacebookLinkPreviewTest.php
new file mode 100644
index 000000000..77acebaab
--- /dev/null
+++ b/tests/Unit/Support/FacebookLinkPreviewTest.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Support\FacebookLinkPreview;
+use Symfony\Component\Process\Process;
+
+/**
+ * Captions the publisher and the editor must resolve to the same `link`.
+ * A null value means the post goes out as plain text.
+ *
+ * @return array<string, ?string>
+ */
+function facebookLinkPreviewCorpus(): array
+{
+    return [
+        'no link here' => null,
+        'Read https://example.com/post today' => 'https://example.com/post',
+        'See https://example.com/post.' => 'https://example.com/post',
+        'See https://example.com/post).' => 'https://example.com/post',
+        'See https://www.facebook.com/page' => null,
+        'See https://m.facebook.com/page' => null,
+        'See https://facebook.com/events/1' => null,
+        'See https://FB.com/page' => null,
+        'See https://fb.me/abc' => null,
+        'See https://l.facebook.com/l.php?u=https://example.com' => null,
+        'See https://www.facebook.com/page and https://example.com/post.' => 'https://example.com/post',
+        'See https://notfacebook.com/post' => 'https://notfacebook.com/post',
+        'See https://example.com/a..' => 'https://example.com/a.',
+    ];
+}
+
+test('facebook link preview picks the url the page feed will accept', function () {
+    foreach (facebookLinkPreviewCorpus() as $text => $expected) {
+        expect(FacebookLinkPreview::url($text))->toBe($expected);
+    }
+});
+
+test('the editor picks the same facebook link as the publisher', function () {
+    $corpus = array_keys(facebookLinkPreviewCorpus());
+    $corpusPath = tempnam(sys_get_temp_dir(), 'fb_links').'.json';
+    file_put_contents($corpusPath, json_encode($corpus, JSON_THROW_ON_ERROR));
+
+    $process = new Process([
+        'node',
+        '--experimental-strip-types',
+        base_path('tests/fixtures/facebook-link-preview-harness.js'),
+        resource_path('js/lib/facebookLinkPreview.ts'),
+        $corpusPath,
+    ]);
+    $process->run();
+
+    unlink($corpusPath);
+
+    if (! $process->isSuccessful()) {
+        $this->markTestSkipped('node is unavailable: '.$process->getErrorOutput());
+    }
+
+    $fromTypeScript = json_decode($process->getOutput(), true, flags: JSON_THROW_ON_ERROR);
+    $fromPhp = array_map(fn (string $entry): ?string => FacebookLinkPreview::url($entry), $corpus);
+
+    expect(array_combine($corpus, $fromTypeScript))->toEqual(array_combine($corpus, $fromPhp));
+});
diff --git a/tests/fixtures/facebook-link-preview-harness.js b/tests/fixtures/facebook-link-preview-harness.js
new file mode 100644
index 000000000..13fc8ae8e
--- /dev/null
+++ b/tests/fixtures/facebook-link-preview-harness.js
@@ -0,0 +1,13 @@
+/**
+ * Runs `resources/js/lib/facebookLinkPreview.ts` over a corpus and prints the
+ * results as JSON, so the PHP parity test can diff it against
+ * `App\Support\FacebookLinkPreview`.
+ */
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+const [modulePath, corpusPath] = process.argv.slice(2);
+const { facebookLinkPreviewUrl } = await import(pathToFileURL(modulePath).href);
+const corpus = JSON.parse(fs.readFileSync(corpusPath, 'utf8'));
+
+console.log(JSON.stringify(corpus.map((entry) => facebookLinkPreviewUrl(entry))));

From 68cc49111a2d60e244fefceeaf4c56a0b0e8e0ef Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:17:43 -0300
Subject: [PATCH 04/18] Simplify the Facebook link picker the editor uses.

---
 resources/js/lib/facebookLinkPreview.ts | 43 ++++++++-----------------
 1 file changed, 13 insertions(+), 30 deletions(-)

diff --git a/resources/js/lib/facebookLinkPreview.ts b/resources/js/lib/facebookLinkPreview.ts
index abf9e9529..dd78f0f70 100644
--- a/resources/js/lib/facebookLinkPreview.ts
+++ b/resources/js/lib/facebookLinkPreview.ts
@@ -1,44 +1,27 @@
 /**
- * Mirrors `App\Support\FacebookLinkPreview`. The composer has to pick the same
- * URL the publisher will send as `link`, or the preview card is a different
- * page than the one Facebook receives. One trailing punctuation mark and an
- * unmatched closing parenthesis are trimmed, matching
- * `UrlDetector::trimTrailingPunctuation`.
+ * Mirror of `App\Support\FacebookLinkPreview`. Facebook rejects many
+ * facebook.com, fb.com and fb.me links, so the preview skips the same hosts
+ * the publisher does.
  */
-const FACEBOOK_HOSTS = ['facebook.com', 'fb.com', 'fb.me'];
+const FACEBOOK_HOSTS = ['facebook.com', 'fb.com', 'fb.me'] as const;
 
 const trimTrailingPunctuation = (url: string): string => {
-    if (/[.,;:!?]$/.test(url)) {
-        url = url.slice(0, -1);
-    }
-
-    if (url.endsWith(')') && !url.includes('(')) {
-        url = url.slice(0, -1);
-    }
+    const trimmed = url.replace(/[.,;:!?]$/, '');
 
-    return url;
+    return trimmed.endsWith(')') && !trimmed.includes('(') ? trimmed.slice(0, -1) : trimmed;
 };
 
 const isFacebookOwnedUrl = (url: string): boolean => {
-    let host: string;
-
-    try {
-        host = new URL(url).hostname.toLowerCase();
-    } catch {
+    if (!URL.canParse(url)) {
         return false;
     }
 
+    const host = new URL(url).hostname.toLowerCase();
+
     return FACEBOOK_HOSTS.some((domain) => host === domain || host.endsWith(`.${domain}`));
 };
 
-export const facebookLinkPreviewUrl = (text: string): string | null => {
-    for (const match of text.matchAll(/https?:\/\/\S+/gu)) {
-        const url = trimTrailingPunctuation(match[0]);
-
-        if (!isFacebookOwnedUrl(url)) {
-            return url;
-        }
-    }
-
-    return null;
-};
+export const facebookLinkPreviewUrl = (text: string): string | null =>
+    [...text.matchAll(/https?:\/\/\S+/gu)]
+        .map(([raw]) => trimTrailingPunctuation(raw))
+        .find((url) => !isFacebookOwnedUrl(url)) ?? null;

From 8266c8657879aa2867223d3ec4e22c024ae46d04 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:20:50 -0300
Subject: [PATCH 05/18] Split the LinkedIn article card into the same small
 steps as the rest of the publisher.

---
 .../Social/AbstractLinkedInPublisher.php      | 156 +++++++++++-------
 1 file changed, 92 insertions(+), 64 deletions(-)

diff --git a/app/Services/Social/AbstractLinkedInPublisher.php b/app/Services/Social/AbstractLinkedInPublisher.php
index 969d7918d..52f12fc3c 100644
--- a/app/Services/Social/AbstractLinkedInPublisher.php
+++ b/app/Services/Social/AbstractLinkedInPublisher.php
@@ -26,26 +26,20 @@
 
 /**
  * Shared LinkedIn publishing pipeline. The publish format follows the attached
- * media — a PDF becomes a document post, 2+ images a multi-image post, a bare
- * link with no media becomes an article post (the Posts API does not scrape
- * URLs), and anything else is a regular post. Subclasses
- * provide the author identity (member vs. company page) and its public URL.
+ * media: a PDF becomes a document post, two or more images a multi-image post,
+ * and a single image or video a media post. A text post with a link becomes an
+ * article, because the Posts API does not scrape URLs. Subclasses provide the
+ * author identity (member or company page) and its public URL.
  */
 abstract class AbstractLinkedInPublisher
 {
     use HasSocialHttpClient;
 
-    /**
-     * ArticleContent limits are exclusive: title under 400 characters,
-     * description under 4,086.
-     *
-     * @see https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/posts-api
-     */
+    /** Article title must be under 400 characters, description under 4,086. */
     private const int ARTICLE_TITLE_MAX = 399;
 
     private const int ARTICLE_DESCRIPTION_MAX = 4085;
 
-    /** og:image downloads are small and attacker-influenced; don't wait on a hung host. */
     private const int ARTICLE_THUMB_TIMEOUT_SECONDS = 10;
 
     private string $apiVersion = '202601';
@@ -164,10 +158,9 @@ private function publishPost(?string $content, $media): array
     }
 
     /**
-     * Article payload for the first link in a text-only post, or null when there
-     * is no link, the page has no title, or the scrape fails. LinkedIn will not
-     * unfurl a URL left in `commentary`, so the card has to be sent explicitly.
-     * A thumbnail failure still publishes the article — the image is optional.
+     * Article payload for the first link in a text-only post. Null when there is
+     * no link, the page has no title, or the scrape fails — the post still goes
+     * out as text. The thumbnail is optional.
      *
      * @return array{source: string, title: string, description?: string, thumbnail?: string}|null
      */
@@ -177,8 +170,29 @@ private function articleContent(?string $content): ?array
             return null;
         }
 
+        $card = $this->articleCard($content);
+        $title = $card !== null && filled($card->title)
+            ? Str::limit($card->title, self::ARTICLE_TITLE_MAX, '')
+            : null;
+
+        if ($card === null || blank($title)) {
+            return null;
+        }
+
+        return array_filter([
+            'source' => $card->uri,
+            'title' => $title,
+            'description' => filled($card->description)
+                ? Str::limit($card->description, self::ARTICLE_DESCRIPTION_MAX, '')
+                : null,
+            'thumbnail' => $this->uploadArticleThumbnail($card),
+        ], filled(...));
+    }
+
+    private function articleCard(string $content): ?LinkCardMetadata
+    {
         try {
-            $card = app(LinkCardFetcher::class)->fetch($content);
+            return app(LinkCardFetcher::class)->fetch($content);
         } catch (Throwable $e) {
             Log::warning("{$this->label()} link preview lookup failed", [
                 'error' => $e->getMessage(),
@@ -186,45 +200,45 @@ private function articleContent(?string $content): ?array
 
             return null;
         }
+    }
 
-        $title = $card !== null && filled($card->title)
-            ? Str::limit($card->title, self::ARTICLE_TITLE_MAX, '')
-            : null;
-
-        if ($card === null || $title === null || $title === '') {
+    /**
+     * Image URN for the card's og:image, or null when there is no usable image.
+     * A dead token still propagates so the publish retry can refresh it.
+     */
+    private function uploadArticleThumbnail(LinkCardMetadata $card): ?string
+    {
+        if (blank($card->imageUrl)) {
             return null;
         }
 
-        $article = [
-            'source' => $card->uri,
-            'title' => $title,
-        ];
+        $path = $this->downloadArticleThumbnail($card->imageUrl);
 
-        if (filled($card->description)) {
-            $article['description'] = Str::limit($card->description, self::ARTICLE_DESCRIPTION_MAX, '');
+        if ($path === null) {
+            return null;
         }
 
-        $thumbnail = $this->uploadArticleThumbnail($card);
+        try {
+            return $this->uploadImageFile($path);
+        } catch (TokenExpiredException $e) {
+            throw $e;
+        } catch (Throwable $e) {
+            Log::warning("{$this->label()} article thumbnail skipped", [
+                'error' => $e->getMessage(),
+            ]);
 
-        if ($thumbnail !== null) {
-            $article['thumbnail'] = $thumbnail;
+            return null;
+        } finally {
+            $this->deleteTempFile($path);
         }
-
-        return $article;
     }
 
     /**
-     * Upload the card's og:image and return its Image URN. Returns null (the
-     * article renders without a thumbnail) when there is no image, the host is
-     * not a public URL, or the upload fails. A dead token still propagates so
-     * the publish retry can refresh it.
+     * A public og:image saved locally and ready to upload, or null. Redirects
+     * are not followed: the URL is attacker-influenced and was guarded once.
      */
-    private function uploadArticleThumbnail(LinkCardMetadata $card): ?string
+    private function downloadArticleThumbnail(string $url): ?string
     {
-        if ($card->imageUrl === null || $card->imageUrl === '') {
-            return null;
-        }
-
         $tempFile = tempnam(sys_get_temp_dir(), 'li_article_');
 
         if ($tempFile === false) {
@@ -233,42 +247,56 @@ private function uploadArticleThumbnail(LinkCardMetadata $card): ?string
 
         try {
             $response = app(SafeHttpFetcher::class)
-                ->guardedRequest($card->imageUrl, followRedirects: false)
+                ->guardedRequest($url, followRedirects: false)
                 ->timeout(self::ARTICLE_THUMB_TIMEOUT_SECONDS)
                 ->withOptions(['sink' => $tempFile])
-                ->get($card->imageUrl);
-
-            $size = filesize($tempFile);
+                ->get($url);
 
-            if (! $response->successful() || $size === false || $size === 0) {
-                return null;
-            }
+            if (! $response->successful() || ! $this->isArticleImage($tempFile)) {
+                $this->deleteTempFile($tempFile);
 
-            $detectedMime = File::mimeType($tempFile) ?: '';
-
-            if (MediaType::classify($detectedMime) !== MediaType::Image) {
                 return null;
             }
 
-            if (! MediaType::isGif($detectedMime)) {
-                $optimizedPath = app(MediaOptimizer::class)->optimizeImage($tempFile, $this->platform());
-                @unlink($tempFile);
-                $tempFile = $optimizedPath;
-            }
-
-            return $this->uploadImageFile($tempFile);
-        } catch (TokenExpiredException $e) {
-            throw $e;
+            return $this->optimizeUnlessGif($tempFile);
         } catch (Throwable $e) {
+            $this->deleteTempFile($tempFile);
+
             Log::warning("{$this->label()} article thumbnail skipped", [
                 'error' => $e->getMessage(),
             ]);
 
             return null;
-        } finally {
-            if (is_file($tempFile)) {
-                @unlink($tempFile);
-            }
+        }
+    }
+
+    private function isArticleImage(string $path): bool
+    {
+        $size = filesize($path);
+
+        if ($size === false || $size === 0) {
+            return false;
+        }
+
+        return MediaType::classify(File::mimeType($path) ?: '') === MediaType::Image;
+    }
+
+    private function optimizeUnlessGif(string $path): string
+    {
+        if (MediaType::isGif(File::mimeType($path) ?: '')) {
+            return $path;
+        }
+
+        $optimized = app(MediaOptimizer::class)->optimizeImage($path, $this->platform());
+        $this->deleteTempFile($path);
+
+        return $optimized;
+    }
+
+    private function deleteTempFile(string $path): void
+    {
+        if (is_file($path)) {
+            @unlink($path);
         }
     }
 

From 7fc7c9ec68f7d0970e95afaa878bd920d7379d07 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:20:50 -0300
Subject: [PATCH 06/18] Take the link picker as a function instead of an
 options object.

---
 .../posts/previews/FacebookPreview.vue        |  2 +-
 resources/js/composables/useLinkCard.ts       | 42 +++++++------------
 2 files changed, 15 insertions(+), 29 deletions(-)

diff --git a/resources/js/components/posts/previews/FacebookPreview.vue b/resources/js/components/posts/previews/FacebookPreview.vue
index 65af59f46..be601ba80 100644
--- a/resources/js/components/posts/previews/FacebookPreview.vue
+++ b/resources/js/components/posts/previews/FacebookPreview.vue
@@ -42,7 +42,7 @@ const postedAtLabel = computed(() =>
 const { card: linkCard, loading: linkCardLoading } = useLinkCard(
     toRef(props, 'content'),
     toRef(props, 'media'),
-    { selectUrl: facebookLinkPreviewUrl },
+    facebookLinkPreviewUrl,
 );
 
 // Content type helpers
diff --git a/resources/js/composables/useLinkCard.ts b/resources/js/composables/useLinkCard.ts
index 046f2d160..4a954d24e 100644
--- a/resources/js/composables/useLinkCard.ts
+++ b/resources/js/composables/useLinkCard.ts
@@ -13,38 +13,25 @@ export interface LinkCard {
     image: string | null;
 }
 
+const firstHttpUrl = (text: string): string | null => text.match(/https?:\/\/\S+/)?.[0] ?? null;
+
 /**
- * Live link-preview card for the composer. Detects the first link in `content`
- * — a rough match is enough, because the backend re-detects it and returns the
- * exact, trimmed URL as `card.uri` — and resolves its OpenGraph card, but only
- * when no media is attached (media suppresses the link card on every platform).
- *
- * `selectUrl` replaces that first-match when a platform publishes a different
- * URL than the first one in the caption. Facebook does: it skips facebook.com,
- * fb.com and fb.me.
+ * OpenGraph card for the link a platform will publish. Attached media hides it.
+ * The default is the first http(s) URL; pass a picker when the platform skips
+ * some hosts. The backend trims the URL and returns the card.
  */
 export const useLinkCard = (
     content: Ref<string>,
     media: Ref<MediaItem[]>,
-    options: { selectUrl?: (content: string) => string | null } = {},
+    selectUrl: (text: string) => string | null = firstHttpUrl,
 ) => {
     const card = ref<LinkCard | null>(null);
     const loading = ref(false);
     const http = useHttp<{ url: string }, LinkCard | null>({ url: '' });
 
-    const url = computed(() => {
-        if (media.value.length > 0) {
-            return null;
-        }
+    const url = computed(() => (media.value.length === 0 ? selectUrl(content.value) : null));
 
-        if (options.selectUrl) {
-            return options.selectUrl(content.value);
-        }
-
-        return content.value.match(/https?:\/\/\S+/)?.[0] ?? null;
-    });
-
-    const fetchCard = async (target: string): Promise<void> => {
+    const loadCard = async (target: string): Promise<void> => {
         loading.value = true;
 
         try {
@@ -58,21 +45,20 @@ export const useLinkCard = (
         }
     };
 
-    // The link went away (media attached, or URL removed) — drop the card at once.
     watch(url, (next) => {
-        if (!next) {
-            card.value = null;
-            loading.value = false;
+        if (next) {
+            return;
         }
+
+        card.value = null;
+        loading.value = false;
     });
 
-    // A new link appeared — fetch it. `watch` only fires on change, so the same
-    // URL is never re-requested; the debounce keeps it off every keystroke.
     watchDebounced(
         url,
         (next) => {
             if (next) {
-                void fetchCard(next);
+                void loadCard(next);
             }
         },
         { debounce: 400, immediate: true },

From e75bdc10b213534cd54015351b0f835106f73873 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:27:53 -0300
Subject: [PATCH 07/18] Pick the Facebook link in one pass instead of walking
 the caption by hand.

---
 app/Support/FacebookLinkPreview.php | 42 +++++++++++++----------------
 1 file changed, 19 insertions(+), 23 deletions(-)

diff --git a/app/Support/FacebookLinkPreview.php b/app/Support/FacebookLinkPreview.php
index 27a0c0abb..81d17a030 100644
--- a/app/Support/FacebookLinkPreview.php
+++ b/app/Support/FacebookLinkPreview.php
@@ -4,6 +4,8 @@
 
 namespace App\Support;
 
+use Illuminate\Support\Str;
+
 /**
  * First http(s) URL Facebook will accept as a Page feed `link`. facebook.com,
  * fb.com and fb.me (and their subdomains) are skipped: the API rejects many of
@@ -13,23 +15,25 @@
  */
 final class FacebookLinkPreview
 {
+    /**
+     * @var list<string>
+     */
+    private const array OWNED_HOSTS = [
+        'facebook.com',
+        '*.facebook.com',
+        'fb.com',
+        '*.fb.com',
+        'fb.me',
+        '*.fb.me',
+    ];
+
     public static function url(string $text): ?string
     {
-        $offset = 0;
-        $length = strlen($text);
-
-        while ($offset < $length && preg_match(UrlDetector::URL_PATTERN, $text, $matches, PREG_OFFSET_CAPTURE, $offset) === 1) {
-            $raw = $matches[0][0];
-            $url = UrlDetector::trimTrailingPunctuation($raw);
+        $url = Str::matchAll(UrlDetector::URL_PATTERN, $text)
+            ->map(fn (string $raw): string => UrlDetector::trimTrailingPunctuation($raw))
+            ->first(fn (string $candidate): bool => ! self::isOwnedHost($candidate));
 
-            if (! self::isOwnedHost($url)) {
-                return $url;
-            }
-
-            $offset = $matches[0][1] + strlen($raw);
-        }
-
-        return null;
+        return is_string($url) ? $url : null;
     }
 
     private static function isOwnedHost(string $url): bool
@@ -40,14 +44,6 @@ private static function isOwnedHost(string $url): bool
             return false;
         }
 
-        $host = strtolower($host);
-
-        foreach (['facebook.com', 'fb.com', 'fb.me'] as $domain) {
-            if ($host === $domain || str_ends_with($host, ".{$domain}")) {
-                return true;
-            }
-        }
-
-        return false;
+        return Str::is(self::OWNED_HOSTS, $host, ignoreCase: true);
     }
 }

From f3d159315e213f0aebf0073d10d27f872e39d047 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:31:01 -0300
Subject: [PATCH 08/18] Give the LinkedIn thumbnail and the Facebook link retry
 one clear path each.

The LinkedIn article thumbnail shares the optimize-and-upload step with
regular image posts instead of carrying its own copy, and each method removes
only the temp file it created. The Facebook text post with a link lives in
its own method, so the retry without the link reads top to bottom.
---
 .../Social/AbstractLinkedInPublisher.php      | 141 ++++++------------
 app/Services/Social/FacebookPublisher.php     |  54 ++++---
 2 files changed, 74 insertions(+), 121 deletions(-)

diff --git a/app/Services/Social/AbstractLinkedInPublisher.php b/app/Services/Social/AbstractLinkedInPublisher.php
index 52f12fc3c..1f8ece6be 100644
--- a/app/Services/Social/AbstractLinkedInPublisher.php
+++ b/app/Services/Social/AbstractLinkedInPublisher.php
@@ -22,6 +22,7 @@
 use Illuminate\Support\Facades\Http;
 use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Str;
+use RuntimeException;
 use Throwable;
 
 /**
@@ -159,32 +160,23 @@ private function publishPost(?string $content, $media): array
 
     /**
      * Article payload for the first link in a text-only post. Null when there is
-     * no link, the page has no title, or the scrape fails — the post still goes
+     * no link, the page has no title, or the scrape fails: the post still goes
      * out as text. The thumbnail is optional.
      *
      * @return array{source: string, title: string, description?: string, thumbnail?: string}|null
      */
     private function articleContent(?string $content): ?array
     {
-        if (! filled($content)) {
-            return null;
-        }
-
-        $card = $this->articleCard($content);
-        $title = $card !== null && filled($card->title)
-            ? Str::limit($card->title, self::ARTICLE_TITLE_MAX, '')
-            : null;
+        $card = filled($content) ? $this->articleCard($content) : null;
 
-        if ($card === null || blank($title)) {
+        if ($card === null || blank($card->title)) {
             return null;
         }
 
         return array_filter([
             'source' => $card->uri,
-            'title' => $title,
-            'description' => filled($card->description)
-                ? Str::limit($card->description, self::ARTICLE_DESCRIPTION_MAX, '')
-                : null,
+            'title' => Str::limit($card->title, self::ARTICLE_TITLE_MAX, ''),
+            'description' => Str::limit($card->description, self::ARTICLE_DESCRIPTION_MAX, ''),
             'thumbnail' => $this->uploadArticleThumbnail($card),
         ], filled(...));
     }
@@ -194,9 +186,7 @@ private function articleCard(string $content): ?LinkCardMetadata
         try {
             return app(LinkCardFetcher::class)->fetch($content);
         } catch (Throwable $e) {
-            Log::warning("{$this->label()} link preview lookup failed", [
-                'error' => $e->getMessage(),
-            ]);
+            Log::warning("{$this->label()} link preview lookup failed", ['error' => $e->getMessage()]);
 
             return null;
         }
@@ -212,91 +202,41 @@ private function uploadArticleThumbnail(LinkCardMetadata $card): ?string
             return null;
         }
 
-        $path = $this->downloadArticleThumbnail($card->imageUrl);
-
-        if ($path === null) {
-            return null;
-        }
+        $tempFile = tempnam(sys_get_temp_dir(), 'li_article_');
 
         try {
-            return $this->uploadImageFile($path);
+            $this->downloadArticleThumbnail($card->imageUrl, $tempFile);
+
+            return $this->uploadLocalImage($tempFile);
         } catch (TokenExpiredException $e) {
             throw $e;
         } catch (Throwable $e) {
-            Log::warning("{$this->label()} article thumbnail skipped", [
-                'error' => $e->getMessage(),
-            ]);
+            Log::warning("{$this->label()} article thumbnail skipped", ['error' => $e->getMessage()]);
 
             return null;
         } finally {
-            $this->deleteTempFile($path);
+            @unlink($tempFile);
         }
     }
 
     /**
-     * A public og:image saved locally and ready to upload, or null. Redirects
-     * are not followed: the URL is attacker-influenced and was guarded once.
+     * Redirects are not followed: the og:image URL is attacker-influenced and
+     * was only guarded against SSRF once.
      */
-    private function downloadArticleThumbnail(string $url): ?string
+    private function downloadArticleThumbnail(string $url, string $tempFile): void
     {
-        $tempFile = tempnam(sys_get_temp_dir(), 'li_article_');
+        $response = app(SafeHttpFetcher::class)
+            ->guardedRequest($url, followRedirects: false)
+            ->timeout(self::ARTICLE_THUMB_TIMEOUT_SECONDS)
+            ->withOptions(['sink' => $tempFile])
+            ->get($url);
 
-        if ($tempFile === false) {
-            return null;
+        if (! $response->successful()) {
+            throw new RuntimeException("og:image responded with HTTP {$response->status()}");
         }
 
-        try {
-            $response = app(SafeHttpFetcher::class)
-                ->guardedRequest($url, followRedirects: false)
-                ->timeout(self::ARTICLE_THUMB_TIMEOUT_SECONDS)
-                ->withOptions(['sink' => $tempFile])
-                ->get($url);
-
-            if (! $response->successful() || ! $this->isArticleImage($tempFile)) {
-                $this->deleteTempFile($tempFile);
-
-                return null;
-            }
-
-            return $this->optimizeUnlessGif($tempFile);
-        } catch (Throwable $e) {
-            $this->deleteTempFile($tempFile);
-
-            Log::warning("{$this->label()} article thumbnail skipped", [
-                'error' => $e->getMessage(),
-            ]);
-
-            return null;
-        }
-    }
-
-    private function isArticleImage(string $path): bool
-    {
-        $size = filesize($path);
-
-        if ($size === false || $size === 0) {
-            return false;
-        }
-
-        return MediaType::classify(File::mimeType($path) ?: '') === MediaType::Image;
-    }
-
-    private function optimizeUnlessGif(string $path): string
-    {
-        if (MediaType::isGif(File::mimeType($path) ?: '')) {
-            return $path;
-        }
-
-        $optimized = app(MediaOptimizer::class)->optimizeImage($path, $this->platform());
-        $this->deleteTempFile($path);
-
-        return $optimized;
-    }
-
-    private function deleteTempFile(string $path): void
-    {
-        if (is_file($path)) {
-            @unlink($path);
+        if (MediaType::classify(File::mimeType($tempFile) ?: '') !== MediaType::Image) {
+            throw new RuntimeException('og:image is not an image');
         }
     }
 
@@ -428,19 +368,34 @@ private function uploadImage($mediaItem): ?string
         try {
             $this->downloadToTempFile($mediaItem->url, $tempFile);
 
-            $detectedMime = File::mimeType($tempFile) ?: '';
-            if (MediaType::classify($detectedMime) === MediaType::Image && ! MediaType::isGif($detectedMime)) {
-                $optimizedPath = app(MediaOptimizer::class)->optimizeImage($tempFile, $this->platform());
-                @unlink($tempFile);
-                $tempFile = $optimizedPath;
-            }
-
-            return $this->uploadImageFile($tempFile);
+            return $this->uploadLocalImage($tempFile);
         } finally {
             @unlink($tempFile);
         }
     }
 
+    /**
+     * Upload an image already on disk, re-encoded for LinkedIn first. GIFs are
+     * sent as they are so the animation survives. The caller owns the given
+     * file; the optimized copy is removed here.
+     */
+    private function uploadLocalImage(string $path): string
+    {
+        $mime = File::mimeType($path) ?: '';
+
+        if (MediaType::classify($mime) !== MediaType::Image || MediaType::isGif($mime)) {
+            return $this->uploadImageFile($path);
+        }
+
+        $optimized = app(MediaOptimizer::class)->optimizeImage($path, $this->platform());
+
+        try {
+            return $this->uploadImageFile($optimized);
+        } finally {
+            @unlink($optimized);
+        }
+    }
+
     /**
      * Initialize a LinkedIn image upload and PUT the bytes already on disk.
      */
diff --git a/app/Services/Social/FacebookPublisher.php b/app/Services/Social/FacebookPublisher.php
index 7e63f45ac..ba050de04 100644
--- a/app/Services/Social/FacebookPublisher.php
+++ b/app/Services/Social/FacebookPublisher.php
@@ -104,22 +104,31 @@ private function publishTextPost(string $pageId, string $accessToken, ?string $c
 
         $link = FacebookLinkPreview::url($content);
 
+        $response = $link === null
+            ? $this->postTextToFeed($pageId, $accessToken, $content, null)
+            : $this->postTextWithLink($pageId, $accessToken, $content, $link);
+
+        return $this->feedPostResult(data_get($response->json(), 'id'));
+    }
+
+    /**
+     * Facebook can reject the link and not the post: 1609005 (scrape failed),
+     * 1500 (invalid URL) or 200/1609008 (facebook.com URL). The caption
+     * published as plain text before `link` existed, so on those codes the
+     * card is dropped and the text is posted once more. Any other error fails
+     * the post. The first attempt stays quiet in the log because only the
+     * outcome of the retry says whether the publish failed.
+     */
+    private function postTextWithLink(string $pageId, string $accessToken, string $content, string $link): Response
+    {
         try {
-            // A link we might drop must not be logged as a failed publish. The
-            // retry below is the real attempt, and that one still reports.
-            $response = $this->postTextToFeed($pageId, $accessToken, $content, $link, reportFailure: $link === null);
+            return $this->postTextToFeed($pageId, $accessToken, $content, $link, reportFailure: false);
         } catch (FacebookPublishException $exception) {
-            // These codes mean the `link` itself was rejected (scrape failed,
-            // invalid URL, or a facebook.com URL). The caption would have
-            // published as plain text before `link` was sent, so drop the card
-            // and try once. Any other error still fails the post.
-            if ($link === null || ! $this->isLinkRejection($exception)) {
-                if ($link !== null) {
-                    Log::error('Facebook text post failed', [
-                        'platform_error_code' => $exception->platformErrorCode,
-                        'body' => $this->redactResponseBody($exception->rawResponse ?? ''),
-                    ]);
-                }
+            if (! $this->isLinkRejection($exception)) {
+                Log::error('Facebook text post failed', [
+                    'platform_error_code' => $exception->platformErrorCode,
+                    'body' => $this->redactResponseBody($exception->rawResponse ?? ''),
+                ]);
 
                 throw $exception;
             }
@@ -128,26 +137,15 @@ private function publishTextPost(string $pageId, string $accessToken, ?string $c
                 'platform_error_code' => $exception->platformErrorCode,
                 'platform_error_subcode' => $exception->platformErrorSubcode,
             ]);
-
-            $response = $this->postTextToFeed($pageId, $accessToken, $content, null);
         }
 
-        return $this->feedPostResult(data_get($response->json(), 'id'));
+        return $this->postTextToFeed($pageId, $accessToken, $content, null);
     }
 
-    /**
-     * Graph rejects the link, not the post: 1609005 (scrape failed), 1500
-     * (invalid URL), and 200/1609008 (facebook.com links).
-     */
     private function isLinkRejection(FacebookPublishException $exception): bool
     {
-        $code = $exception->platformErrorCode;
-
-        if ($code === '1609005' || $code === '1500') {
-            return true;
-        }
-
-        return $code === '200' && $exception->platformErrorSubcode === '1609008';
+        return in_array($exception->platformErrorCode, ['1609005', '1500'], true)
+            || ($exception->platformErrorCode === '200' && $exception->platformErrorSubcode === '1609008');
     }
 
     /**

From 89251c8aa3ce4863a2220f19fa5687252ad5bad7 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:33:15 -0300
Subject: [PATCH 09/18] Let the Facebook exception say whether Graph rejected
 the link.

The publisher asks rejectsLink() instead of comparing Graph codes inline; the
codes live next to the rest of the Facebook error table.
---
 .../Social/FacebookPublishException.php       | 24 +++++++++++++++++++
 app/Services/Social/FacebookPublisher.php     |  8 +------
 .../Social/FacebookPublishExceptionTest.php   | 13 ++++++++++
 3 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/app/Exceptions/Social/FacebookPublishException.php b/app/Exceptions/Social/FacebookPublishException.php
index d26aa443e..258b59491 100644
--- a/app/Exceptions/Social/FacebookPublishException.php
+++ b/app/Exceptions/Social/FacebookPublishException.php
@@ -9,6 +9,20 @@
 
 class FacebookPublishException extends SocialPublishException
 {
+    /**
+     * Graph codes that reject the Page feed `link` and leave the caption
+     * untouched: 1609005 (could not scrape the URL) and 1500 (invalid URL).
+     *
+     * @var list<string>
+     */
+    private const array LINK_REJECTION_CODES = ['1609005', '1500'];
+
+    /**
+     * Subcode under a code 200 "Permissions error" that means the `link`
+     * pointed at facebook.com, which Pages may not share through the API.
+     */
+    private const string FACEBOOK_URL_SUBCODE = '1609008';
+
     public function __construct(
         string $userMessage,
         ErrorCategory $category,
@@ -80,6 +94,16 @@ public static function fromApiResponse(mixed $response): static
         );
     }
 
+    /**
+     * Whether Graph rejected the `link` rather than the post. The same caption
+     * publishes as plain text once the link is dropped.
+     */
+    public function rejectsLink(): bool
+    {
+        return in_array($this->platformErrorCode, self::LINK_REJECTION_CODES, true)
+            || ($this->platformErrorCode === '200' && $this->platformErrorSubcode === self::FACEBOOK_URL_SUBCODE);
+    }
+
     public function platform(): string
     {
         return 'facebook';
diff --git a/app/Services/Social/FacebookPublisher.php b/app/Services/Social/FacebookPublisher.php
index ba050de04..c62bc57b6 100644
--- a/app/Services/Social/FacebookPublisher.php
+++ b/app/Services/Social/FacebookPublisher.php
@@ -124,7 +124,7 @@ private function postTextWithLink(string $pageId, string $accessToken, string $c
         try {
             return $this->postTextToFeed($pageId, $accessToken, $content, $link, reportFailure: false);
         } catch (FacebookPublishException $exception) {
-            if (! $this->isLinkRejection($exception)) {
+            if (! $exception->rejectsLink()) {
                 Log::error('Facebook text post failed', [
                     'platform_error_code' => $exception->platformErrorCode,
                     'body' => $this->redactResponseBody($exception->rawResponse ?? ''),
@@ -142,12 +142,6 @@ private function postTextWithLink(string $pageId, string $accessToken, string $c
         return $this->postTextToFeed($pageId, $accessToken, $content, null);
     }
 
-    private function isLinkRejection(FacebookPublishException $exception): bool
-    {
-        return in_array($exception->platformErrorCode, ['1609005', '1500'], true)
-            || ($exception->platformErrorCode === '200' && $exception->platformErrorSubcode === '1609008');
-    }
-
     /**
      * A text post carries `link` when the caption contains a URL. Facebook does
      * not unfurl a URL left only in `message`; the Page Feed `link` field is
diff --git a/tests/Unit/Exceptions/Social/FacebookPublishExceptionTest.php b/tests/Unit/Exceptions/Social/FacebookPublishExceptionTest.php
index d7f2c66ff..d1f6a491b 100644
--- a/tests/Unit/Exceptions/Social/FacebookPublishExceptionTest.php
+++ b/tests/Unit/Exceptions/Social/FacebookPublishExceptionTest.php
@@ -144,6 +144,19 @@
         ->and($exception->userMessage)->toBe('Permissions error');
 });
 
+test('a link rejection is told apart from a failed post', function (array $error, bool $rejectsLink) {
+    $fakeResponse = Http::fake(['*' => Http::response(['error' => $error], 400)])
+        ->post('https://graph.facebook.com/test');
+
+    expect(FacebookPublishException::fromApiResponse($fakeResponse)->rejectsLink())->toBe($rejectsLink);
+})->with([
+    'scrape failed' => [['message' => 'There was a problem scraping the URL.', 'code' => 1609005], true],
+    'invalid url' => [['message' => 'The url you supplied is invalid', 'code' => 1500], true],
+    'facebook.com link' => [['message' => 'Permissions error', 'code' => 200, 'error_subcode' => 1609008], true],
+    'permissions error without the subcode' => [['message' => 'Permissions error', 'code' => 200], false],
+    'duplicate post' => [['message' => 'Duplicate post', 'code' => 506], false],
+]);
+
 test('subcode 463 throws TokenExpiredException', function () {
     $response = Http::response([
         'error' => [

From 648a99a29c311eb2446ded69c518320399ce6e05 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:37:30 -0300
Subject: [PATCH 10/18] Cover the edges of the LinkedIn article and the
 Facebook link retry.

Title and description trimming, a non-image og:image, a dead token during the
thumbnail upload, the article under a company page, a retry that fails too,
and a dead token on the first Facebook attempt.
---
 .../Services/Social/FacebookPublisherTest.php |  34 +++++
 .../Social/LinkedInPagePublisherTest.php      |  28 ++++
 .../Services/Social/LinkedInPublisherTest.php | 121 ++++++++++++++++++
 3 files changed, 183 insertions(+)

diff --git a/tests/Feature/Services/Social/FacebookPublisherTest.php b/tests/Feature/Services/Social/FacebookPublisherTest.php
index ce023e9d8..0484c5370 100644
--- a/tests/Feature/Services/Social/FacebookPublisherTest.php
+++ b/tests/Feature/Services/Social/FacebookPublisherTest.php
@@ -1377,6 +1377,40 @@ function facebookVideoUploadFakes(string $edge): array
     Http::assertSentCount(1);
 });
 
+test('facebook publisher fails the post when the retry without the link is rejected too', function () {
+    $this->post->update(['content' => 'Read https://example.com/post']);
+
+    Log::spy();
+
+    Http::fake([
+        '*/page_123/feed' => Http::sequence()
+            ->push(['error' => ['message' => 'There was a problem scraping the URL.', 'code' => 1609005]], 400)
+            ->push(['error' => ['message' => 'Duplicate post', 'code' => 506]], 400),
+    ]);
+
+    expect(fn () => $this->publisher->publish($this->postPlatform))
+        ->toThrow(FacebookPublishException::class, 'Duplicate post detected. Please modify content.');
+
+    Http::assertSentCount(2);
+    Log::shouldHaveReceived('warning')->once();
+    Log::shouldHaveReceived('error')->once();
+});
+
+test('facebook publisher does not retry a text post with a link when the token is dead', function () {
+    $this->post->update(['content' => 'Read https://example.com/post']);
+
+    Http::fake([
+        '*/page_123/feed' => Http::response([
+            'error' => ['message' => 'Invalid OAuth access token.', 'code' => 190],
+        ], 400),
+    ]);
+
+    expect(fn () => $this->publisher->publish($this->postPlatform))
+        ->toThrow(TokenExpiredException::class);
+
+    Http::assertSentCount(1);
+});
+
 test('facebook publisher does not attach a link card when the post has media', function () {
     $this->post->update([
         'content' => 'Read https://example.com/post',
diff --git a/tests/Feature/Services/Social/LinkedInPagePublisherTest.php b/tests/Feature/Services/Social/LinkedInPagePublisherTest.php
index b8cad8a02..43cd85911 100644
--- a/tests/Feature/Services/Social/LinkedInPagePublisherTest.php
+++ b/tests/Feature/Services/Social/LinkedInPagePublisherTest.php
@@ -11,6 +11,7 @@
 use App\Models\User;
 use App\Models\Workspace;
 use App\Services\Social\LinkCard\LinkCardFetcher;
+use App\Services\Social\LinkCard\LinkCardMetadata;
 use App\Services\Social\LinkedInPagePublisher;
 use Illuminate\Support\Facades\Http;
 
@@ -457,3 +458,30 @@
     Http::assertSent(fn ($request) => str_contains($request->url(), '/rest/posts')
         && $request['commentary'] === 'New post: https://acme.com/blog');
 });
+
+test('linkedin page publisher sends the article card under the organization', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: 'The Article',
+            description: 'A great read',
+            imageUrl: null,
+        ));
+
+    Http::fake([
+        config('trypost.platforms.linkedin-page.api').'/rest/posts' => Http::response(null, 201, [
+            'x-restli-id' => 'urn:li:share:orgArticle',
+        ]),
+    ]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(fn ($request) => str_contains($request->url(), '/rest/posts')
+        && $request['author'] === 'urn:li:organization:123456'
+        && $request['content']['article']['source'] === 'https://example.com/article'
+        && $request['content']['article']['title'] === 'The Article');
+});
diff --git a/tests/Feature/Services/Social/LinkedInPublisherTest.php b/tests/Feature/Services/Social/LinkedInPublisherTest.php
index 77be90985..71f399bcb 100644
--- a/tests/Feature/Services/Social/LinkedInPublisherTest.php
+++ b/tests/Feature/Services/Social/LinkedInPublisherTest.php
@@ -1450,6 +1450,127 @@ protected function processingPollSeconds(): int
     Http::assertNotSent(fn ($request) => str_contains($request->url(), '127.0.0.1'));
 });
 
+test('linkedin publisher trims the article title and description to what the api accepts', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: str_repeat('t', 500),
+            description: str_repeat('d', 5000),
+            imageUrl: null,
+        ));
+
+    Http::fake([
+        config('trypost.platforms.linkedin.api').'/rest/posts' => Http::response(null, 201, [
+            'x-restli-id' => 'urn:li:share:trimmed',
+        ]),
+    ]);
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(function ($request) {
+        $article = $request['content']['article'] ?? null;
+
+        return str_contains($request->url(), '/rest/posts')
+            && mb_strlen($article['title']) === 399
+            && mb_strlen($article['description']) === 4085;
+    });
+});
+
+test('linkedin publisher skips the thumbnail when og:image does not point at an image', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: 'The Article',
+            description: 'A great read',
+            imageUrl: 'https://93.184.216.34/card.jpg',
+        ));
+
+    Http::fake(function ($request) {
+        if (str_contains($request->url(), '/rest/posts')) {
+            return Http::response(null, 201, ['x-restli-id' => 'urn:li:share:html']);
+        }
+
+        return Http::response('<html><body>Not an image</body></html>', 200, ['Content-Type' => 'text/html']);
+    });
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertNotSent(fn ($request) => str_contains($request->url(), '/rest/images'));
+    Http::assertSent(function ($request) {
+        $article = $request['content']['article'] ?? null;
+
+        return str_contains($request->url(), '/rest/posts')
+            && $article['title'] === 'The Article'
+            && ! isset($article['thumbnail']);
+    });
+});
+
+test('linkedin publisher refreshes the token when the thumbnail upload is rejected', function () {
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->twice()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: 'The Article',
+            description: 'A great read',
+            imageUrl: 'https://93.184.216.34/card.jpg',
+        ));
+
+    $this->mock(MediaOptimizer::class)
+        ->shouldReceive('optimizeImage')
+        ->twice()
+        ->andReturnUsing(fn () => tap(tempnam(sys_get_temp_dir(), 'li_thumb_'), fn ($path) => file_put_contents($path, 'thumb-bytes')));
+
+    $jpeg = linkedInJpegBytes();
+    $uploadUrl = 'https://www.linkedin.com/dms/upload/v2/pic/0/article-thumb';
+    $imageInitCalls = 0;
+
+    Http::fake(function ($request) use ($uploadUrl, $jpeg, &$imageInitCalls) {
+        $url = $request->url();
+
+        if (str_contains($url, '/rest/images')) {
+            return ++$imageInitCalls === 1
+                ? Http::response(['message' => 'Expired token'], 401)
+                : Http::response(['value' => ['uploadUrl' => $uploadUrl, 'image' => 'urn:li:image:afterRefresh']], 200);
+        }
+
+        if ($url === $uploadUrl) {
+            return Http::response(null, 201);
+        }
+
+        if (str_contains($url, '/oauth/v2/accessToken')) {
+            return Http::response(['access_token' => 'new-access-token', 'refresh_token' => 'new-refresh-token', 'expires_in' => 5184000], 200);
+        }
+
+        if (str_contains($url, '/rest/posts')) {
+            return Http::response(null, 201, ['x-restli-id' => 'urn:li:share:refreshed']);
+        }
+
+        return Http::response($jpeg, 200);
+    });
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertSent(fn ($request) => str_contains($request->url(), '/oauth/v2/accessToken'));
+    Http::assertSent(function ($request) {
+        $article = $request['content']['article'] ?? null;
+
+        return str_contains($request->url(), '/rest/posts')
+            && $request->hasHeader('Authorization', 'Bearer new-access-token')
+            && $article['thumbnail'] === 'urn:li:image:afterRefresh';
+    });
+});
+
 function linkedInJpegBytes(): string
 {
     $image = imagecreatetruecolor(8, 8);

From 5d78b7798509edbdfd37882fa7b444fa8a9620b9 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:41:17 -0300
Subject: [PATCH 11/18] Run prettier on the new editor files and stop leaking a
 temp file in the parity test.

---
 resources/js/composables/useLinkCard.ts        | 7 +++++--
 resources/js/lib/facebookLinkPreview.ts        | 8 ++++++--
 tests/Unit/Support/FacebookLinkPreviewTest.php | 2 +-
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/resources/js/composables/useLinkCard.ts b/resources/js/composables/useLinkCard.ts
index 4a954d24e..bfd8b61bc 100644
--- a/resources/js/composables/useLinkCard.ts
+++ b/resources/js/composables/useLinkCard.ts
@@ -13,7 +13,8 @@ export interface LinkCard {
     image: string | null;
 }
 
-const firstHttpUrl = (text: string): string | null => text.match(/https?:\/\/\S+/)?.[0] ?? null;
+const firstHttpUrl = (text: string): string | null =>
+    text.match(/https?:\/\/\S+/)?.[0] ?? null;
 
 /**
  * OpenGraph card for the link a platform will publish. Attached media hides it.
@@ -29,7 +30,9 @@ export const useLinkCard = (
     const loading = ref(false);
     const http = useHttp<{ url: string }, LinkCard | null>({ url: '' });
 
-    const url = computed(() => (media.value.length === 0 ? selectUrl(content.value) : null));
+    const url = computed(() =>
+        media.value.length === 0 ? selectUrl(content.value) : null,
+    );
 
     const loadCard = async (target: string): Promise<void> => {
         loading.value = true;
diff --git a/resources/js/lib/facebookLinkPreview.ts b/resources/js/lib/facebookLinkPreview.ts
index dd78f0f70..aa665353d 100644
--- a/resources/js/lib/facebookLinkPreview.ts
+++ b/resources/js/lib/facebookLinkPreview.ts
@@ -8,7 +8,9 @@ const FACEBOOK_HOSTS = ['facebook.com', 'fb.com', 'fb.me'] as const;
 const trimTrailingPunctuation = (url: string): string => {
     const trimmed = url.replace(/[.,;:!?]$/, '');
 
-    return trimmed.endsWith(')') && !trimmed.includes('(') ? trimmed.slice(0, -1) : trimmed;
+    return trimmed.endsWith(')') && !trimmed.includes('(')
+        ? trimmed.slice(0, -1)
+        : trimmed;
 };
 
 const isFacebookOwnedUrl = (url: string): boolean => {
@@ -18,7 +20,9 @@ const isFacebookOwnedUrl = (url: string): boolean => {
 
     const host = new URL(url).hostname.toLowerCase();
 
-    return FACEBOOK_HOSTS.some((domain) => host === domain || host.endsWith(`.${domain}`));
+    return FACEBOOK_HOSTS.some(
+        (domain) => host === domain || host.endsWith(`.${domain}`),
+    );
 };
 
 export const facebookLinkPreviewUrl = (text: string): string | null =>
diff --git a/tests/Unit/Support/FacebookLinkPreviewTest.php b/tests/Unit/Support/FacebookLinkPreviewTest.php
index 77acebaab..0d5972dd3 100644
--- a/tests/Unit/Support/FacebookLinkPreviewTest.php
+++ b/tests/Unit/Support/FacebookLinkPreviewTest.php
@@ -38,7 +38,7 @@ function facebookLinkPreviewCorpus(): array
 
 test('the editor picks the same facebook link as the publisher', function () {
     $corpus = array_keys(facebookLinkPreviewCorpus());
-    $corpusPath = tempnam(sys_get_temp_dir(), 'fb_links').'.json';
+    $corpusPath = tempnam(sys_get_temp_dir(), 'fb_links');
     file_put_contents($corpusPath, json_encode($corpus, JSON_THROW_ON_ERROR));
 
     $process = new Process([

From 8b8bdc22c9fc169d19da31268bdd53efd666b502 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:43:58 -0300
Subject: [PATCH 12/18] Drop a link card response that arrives after the link
 changed.

A slow preview used to revive a card the user had already removed, or
overwrite the card of the link they typed next. The response now only lands
when the URL it was fetched for is still the one in the caption.
---
 app/Support/FacebookLinkPreview.php     |  4 +---
 resources/js/composables/useLinkCard.ts | 17 +++++++++--------
 2 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/app/Support/FacebookLinkPreview.php b/app/Support/FacebookLinkPreview.php
index 81d17a030..b690838f6 100644
--- a/app/Support/FacebookLinkPreview.php
+++ b/app/Support/FacebookLinkPreview.php
@@ -29,11 +29,9 @@ final class FacebookLinkPreview
 
     public static function url(string $text): ?string
     {
-        $url = Str::matchAll(UrlDetector::URL_PATTERN, $text)
+        return Str::matchAll(UrlDetector::URL_PATTERN, $text)
             ->map(fn (string $raw): string => UrlDetector::trimTrailingPunctuation($raw))
             ->first(fn (string $candidate): bool => ! self::isOwnedHost($candidate));
-
-        return is_string($url) ? $url : null;
     }
 
     private static function isOwnedHost(string $url): bool
diff --git a/resources/js/composables/useLinkCard.ts b/resources/js/composables/useLinkCard.ts
index bfd8b61bc..4fc79ecfd 100644
--- a/resources/js/composables/useLinkCard.ts
+++ b/resources/js/composables/useLinkCard.ts
@@ -36,16 +36,17 @@ export const useLinkCard = (
 
     const loadCard = async (target: string): Promise<void> => {
         loading.value = true;
+        http.url = target;
 
-        try {
-            http.url = target;
-            const data = await http.post(linkPreview.url());
-            card.value = data?.uri ? data : null;
-        } catch {
-            card.value = null;
-        } finally {
-            loading.value = false;
+        const data = await http.post(linkPreview.url()).catch(() => null);
+
+        // A slow response must not revive a removed link or overwrite a newer one.
+        if (url.value !== target) {
+            return;
         }
+
+        card.value = data?.uri ? data : null;
+        loading.value = false;
     };
 
     watch(url, (next) => {

From a262991dc019393cbfc2759525dfdaf3f83cf16d Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:49:16 -0300
Subject: [PATCH 13/18] Hardening the link-card race and the LinkedIn temp-file
 path.

Changing the caption URL now clears the old card immediately and bumps a
request id so an in-flight response cannot land on the wrong caption. The
LinkedIn image/thumbnail path also refuses a failed tempnam or fopen instead
of feeding false into unlink.
---
 .../Social/AbstractLinkedInPublisher.php      | 24 +++++++++++++++++++
 resources/js/composables/useLinkCard.ts       | 14 +++++------
 2 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/app/Services/Social/AbstractLinkedInPublisher.php b/app/Services/Social/AbstractLinkedInPublisher.php
index 1f8ece6be..c6e83194a 100644
--- a/app/Services/Social/AbstractLinkedInPublisher.php
+++ b/app/Services/Social/AbstractLinkedInPublisher.php
@@ -204,6 +204,10 @@ private function uploadArticleThumbnail(LinkCardMetadata $card): ?string
 
         $tempFile = tempnam(sys_get_temp_dir(), 'li_article_');
 
+        if ($tempFile === false) {
+            return null;
+        }
+
         try {
             $this->downloadArticleThumbnail($card->imageUrl, $tempFile);
 
@@ -235,6 +239,12 @@ private function downloadArticleThumbnail(string $url, string $tempFile): void
             throw new RuntimeException("og:image responded with HTTP {$response->status()}");
         }
 
+        $size = filesize($tempFile);
+
+        if ($size === false || $size === 0) {
+            throw new RuntimeException('og:image is empty');
+        }
+
         if (MediaType::classify(File::mimeType($tempFile) ?: '') !== MediaType::Image) {
             throw new RuntimeException('og:image is not an image');
         }
@@ -365,6 +375,13 @@ private function uploadImage($mediaItem): ?string
     {
         $tempFile = tempnam(sys_get_temp_dir(), 'li_image_');
 
+        if ($tempFile === false) {
+            throw new LinkedInPublishException(
+                userMessage: "Could not prepare the image for {$this->label()}. Please try again.",
+                category: ErrorCategory::ServerError,
+            );
+        }
+
         try {
             $this->downloadToTempFile($mediaItem->url, $tempFile);
 
@@ -424,6 +441,13 @@ private function uploadImageFile(string $path): string
 
         $stream = fopen($path, 'r');
 
+        if ($stream === false) {
+            throw new LinkedInPublishException(
+                userMessage: "Could not read the image for {$this->label()}. Please try again.",
+                category: ErrorCategory::ServerError,
+            );
+        }
+
         $uploadResponse = Http::withToken($this->accessToken)
             ->withHeaders(['Content-Type' => 'application/octet-stream'])
             ->withBody($stream, 'application/octet-stream')
diff --git a/resources/js/composables/useLinkCard.ts b/resources/js/composables/useLinkCard.ts
index 4fc79ecfd..6784c6186 100644
--- a/resources/js/composables/useLinkCard.ts
+++ b/resources/js/composables/useLinkCard.ts
@@ -29,19 +29,20 @@ export const useLinkCard = (
     const card = ref<LinkCard | null>(null);
     const loading = ref(false);
     const http = useHttp<{ url: string }, LinkCard | null>({ url: '' });
+    let requestId = 0;
 
     const url = computed(() =>
         media.value.length === 0 ? selectUrl(content.value) : null,
     );
 
     const loadCard = async (target: string): Promise<void> => {
-        loading.value = true;
+        const id = requestId;
         http.url = target;
 
         const data = await http.post(linkPreview.url()).catch(() => null);
 
         // A slow response must not revive a removed link or overwrite a newer one.
-        if (url.value !== target) {
+        if (id !== requestId) {
             return;
         }
 
@@ -49,13 +50,12 @@ export const useLinkCard = (
         loading.value = false;
     };
 
+    // Drop the card the moment the URL changes so we never show A while B loads,
+    // and bump requestId so any in-flight response for the previous URL is ignored.
     watch(url, (next) => {
-        if (next) {
-            return;
-        }
-
+        requestId++;
         card.value = null;
-        loading.value = false;
+        loading.value = next !== null;
     });
 
     watchDebounced(

From 43e27a4125cf804bc83d47b01a0b9262cc389250 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 17:51:53 -0300
Subject: [PATCH 14/18] Drop the no-op RuntimeException import that breaks CI
 under strict errors.

---
 tests/Feature/Services/Social/LinkedInPublisherTest.php | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/Feature/Services/Social/LinkedInPublisherTest.php b/tests/Feature/Services/Social/LinkedInPublisherTest.php
index 71f399bcb..cd90fa383 100644
--- a/tests/Feature/Services/Social/LinkedInPublisherTest.php
+++ b/tests/Feature/Services/Social/LinkedInPublisherTest.php
@@ -16,7 +16,6 @@
 use App\Services\Social\LinkCard\LinkCardMetadata;
 use App\Services\Social\LinkedInPublisher;
 use Illuminate\Support\Facades\Http;
-use RuntimeException;
 
 beforeEach(function () {
     $this->user = User::factory()->create();

From 9381d79164340366dbff027597cd2dcffc881494 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Mon, 21 Sep 2026 20:55:43 -0300
Subject: [PATCH 15/18] Harden social link preview downloads

---
 .../Social/AbstractLinkedInPublisher.php      | 15 +++++++-
 resources/js/lib/facebookLinkPreview.ts       | 14 +++----
 .../Services/Social/LinkedInPublisherTest.php | 38 +++++++++++++++++++
 3 files changed, 59 insertions(+), 8 deletions(-)

diff --git a/app/Services/Social/AbstractLinkedInPublisher.php b/app/Services/Social/AbstractLinkedInPublisher.php
index c6e83194a..a541df9f8 100644
--- a/app/Services/Social/AbstractLinkedInPublisher.php
+++ b/app/Services/Social/AbstractLinkedInPublisher.php
@@ -229,10 +229,19 @@ private function uploadArticleThumbnail(LinkCardMetadata $card): ?string
      */
     private function downloadArticleThumbnail(string $url, string $tempFile): void
     {
+        $maxBytes = MediaType::Image->maxSizeInBytes();
+
         $response = app(SafeHttpFetcher::class)
             ->guardedRequest($url, followRedirects: false)
             ->timeout(self::ARTICLE_THUMB_TIMEOUT_SECONDS)
-            ->withOptions(['sink' => $tempFile])
+            ->sink($tempFile)
+            ->withOptions([
+                'progress' => static function ($total, $downloaded) use ($maxBytes): void {
+                    if ($total > $maxBytes || $downloaded > $maxBytes) {
+                        throw new RuntimeException('og:image exceeds the maximum image size');
+                    }
+                },
+            ])
             ->get($url);
 
         if (! $response->successful()) {
@@ -245,6 +254,10 @@ private function downloadArticleThumbnail(string $url, string $tempFile): void
             throw new RuntimeException('og:image is empty');
         }
 
+        if ($size > $maxBytes) {
+            throw new RuntimeException('og:image exceeds the maximum image size');
+        }
+
         if (MediaType::classify(File::mimeType($tempFile) ?: '') !== MediaType::Image) {
             throw new RuntimeException('og:image is not an image');
         }
diff --git a/resources/js/lib/facebookLinkPreview.ts b/resources/js/lib/facebookLinkPreview.ts
index aa665353d..608645075 100644
--- a/resources/js/lib/facebookLinkPreview.ts
+++ b/resources/js/lib/facebookLinkPreview.ts
@@ -14,15 +14,15 @@ const trimTrailingPunctuation = (url: string): string => {
 };
 
 const isFacebookOwnedUrl = (url: string): boolean => {
-    if (!URL.canParse(url)) {
+    try {
+        const host = new URL(url).hostname.toLowerCase();
+
+        return FACEBOOK_HOSTS.some(
+            (domain) => host === domain || host.endsWith(`.${domain}`),
+        );
+    } catch {
         return false;
     }
-
-    const host = new URL(url).hostname.toLowerCase();
-
-    return FACEBOOK_HOSTS.some(
-        (domain) => host === domain || host.endsWith(`.${domain}`),
-    );
 };
 
 export const facebookLinkPreviewUrl = (text: string): string | null =>
diff --git a/tests/Feature/Services/Social/LinkedInPublisherTest.php b/tests/Feature/Services/Social/LinkedInPublisherTest.php
index cd90fa383..595bb5d5e 100644
--- a/tests/Feature/Services/Social/LinkedInPublisherTest.php
+++ b/tests/Feature/Services/Social/LinkedInPublisherTest.php
@@ -1361,6 +1361,44 @@ protected function processingPollSeconds(): int
     });
 });
 
+test('linkedin publisher stops downloading an oversized article thumbnail', function () {
+    config()->set('trypost.media.max_size_mb.image', 1);
+
+    $this->post->update(['content' => 'Read this https://example.com/article']);
+
+    $this->mock(LinkCardFetcher::class)
+        ->shouldReceive('fetch')
+        ->once()
+        ->andReturn(new LinkCardMetadata(
+            uri: 'https://example.com/article',
+            title: 'The Article',
+            description: 'A great read',
+            imageUrl: 'https://93.184.216.34/oversized.jpg',
+        ));
+
+    Http::fake(function ($request) {
+        if (str_contains($request->url(), '/rest/posts')) {
+            return Http::response(null, 201, ['x-restli-id' => 'urn:li:share:oversized']);
+        }
+
+        return Http::response(str_repeat('x', (1024 * 1024) + 1), 200, [
+            'Content-Type' => 'image/jpeg',
+            'Content-Length' => (string) ((1024 * 1024) + 1),
+        ]);
+    });
+
+    $this->publisher->publish($this->postPlatform);
+
+    Http::assertNotSent(fn ($request) => str_contains($request->url(), '/rest/images'));
+    Http::assertSent(function ($request) {
+        $article = $request['content']['article'] ?? null;
+
+        return str_contains($request->url(), '/rest/posts')
+            && $article['title'] === 'The Article'
+            && ! isset($article['thumbnail']);
+    });
+});
+
 test('linkedin publisher publishes the text when the link preview lookup fails', function () {
     $this->post->update(['content' => 'Read this https://example.com/article']);
 

From be72d1245c8ef501acdb1072363a37fb2aae827b Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Tue, 22 Sep 2026 09:48:01 -0300
Subject: [PATCH 16/18] fix: bound link preview fetches and cover editor cards

---
 app/Services/Brand/SafeHttpFetcher.php        |  49 ++++
 .../Social/LinkCard/LinkCardFetcher.php       |   9 +-
 .../posts/editor/PostEditorTabs.vue           |  60 +++--
 .../js/components/posts/previews/LinkCard.vue |  14 +-
 tests/Browser/LinkCardPreviewTest.php         | 238 ++++++++++++++++++
 .../Social/LinkCard/LinkCardFetcherTest.php   |   8 +
 .../Services/Brand/SafeHttpFetcherTest.php    |  18 ++
 7 files changed, 375 insertions(+), 21 deletions(-)
 create mode 100644 tests/Browser/LinkCardPreviewTest.php

diff --git a/app/Services/Brand/SafeHttpFetcher.php b/app/Services/Brand/SafeHttpFetcher.php
index 9c8428878..c3b406882 100644
--- a/app/Services/Brand/SafeHttpFetcher.php
+++ b/app/Services/Brand/SafeHttpFetcher.php
@@ -92,6 +92,55 @@ public function tryGet(string $url): ?Response
         }
     }
 
+    /**
+     * Fetch a user-supplied URL without buffering more than the permitted body.
+     * Returns null for transport, HTTP, SSRF, redirect, or size failures.
+     */
+    public function tryGetBody(string $url, int $maxBytes): ?string
+    {
+        if ($maxBytes < 1) {
+            return null;
+        }
+
+        $stream = tmpfile();
+
+        if ($stream === false) {
+            return null;
+        }
+
+        try {
+            $response = $this->guardedRequest($url)
+                ->connectTimeout(3)
+                ->timeout(self::TIMEOUT_SECONDS)
+                ->sink($stream)
+                ->withOptions([
+                    'progress' => static function ($total, $downloaded) use ($maxBytes): void {
+                        if ($total > $maxBytes || $downloaded > $maxBytes) {
+                            throw new RuntimeException('Response body exceeded the maximum permitted size.');
+                        }
+                    },
+                ])
+                ->get($url);
+
+            if ($response->failed()) {
+                return null;
+            }
+
+            rewind($stream);
+            $body = stream_get_contents($stream, $maxBytes + 1);
+
+            if ($body === false || strlen($body) > $maxBytes) {
+                return null;
+            }
+
+            return $body;
+        } catch (ConnectionException|RuntimeException) {
+            return null;
+        } finally {
+            fclose($stream);
+        }
+    }
+
     /**
      * Guzzle allow_redirects options that re-run the SSRF guard on every hop.
      * For callers that follow redirects on user-supplied URLs with methods/bodies
diff --git a/app/Services/Social/LinkCard/LinkCardFetcher.php b/app/Services/Social/LinkCard/LinkCardFetcher.php
index d987cf42d..7d4d735ef 100644
--- a/app/Services/Social/LinkCard/LinkCardFetcher.php
+++ b/app/Services/Social/LinkCard/LinkCardFetcher.php
@@ -19,6 +19,9 @@ class LinkCardFetcher
     /** Cards for a public URL are identical for everyone; cache briefly and globally. */
     private const int CACHE_MINUTES = 10;
 
+    /** OpenGraph metadata should occur near the document head; never buffer an unbounded page. */
+    private const int MAX_HTML_BYTES = 2 * 1024 * 1024;
+
     public function __construct(
         private readonly SafeHttpFetcher $http = new SafeHttpFetcher,
         private readonly OpenGraphExtractor $extractor = new OpenGraphExtractor,
@@ -46,13 +49,13 @@ public function fetch(string $text): ?LinkCardMetadata
 
     private function build(string $url): ?LinkCardMetadata
     {
-        $response = $this->http->tryGet($url);
+        $html = $this->http->tryGetBody($url, self::MAX_HTML_BYTES);
 
-        if ($response === null) {
+        if ($html === null) {
             return null;
         }
 
-        $meta = $this->extractor->extract($response->body(), $url);
+        $meta = $this->extractor->extract($html, $url);
         $title = data_get($meta, 'title');
         $description = data_get($meta, 'description');
 
diff --git a/resources/js/components/posts/editor/PostEditorTabs.vue b/resources/js/components/posts/editor/PostEditorTabs.vue
index 9dcefb699..532528b83 100644
--- a/resources/js/components/posts/editor/PostEditorTabs.vue
+++ b/resources/js/components/posts/editor/PostEditorTabs.vue
@@ -78,28 +78,48 @@ const activeTab = defineModel<string>('activeTab', { required: true });
 const emit = defineEmits<{
     (e: 'toggle-platform', platformId: string): void;
     (e: 'toggle-label', labelId: string): void;
-    (e: 'update:platformMeta', platformId: string, meta: Record<string, any>): void;
-    (e: 'update:platformContentType', platformId: string, contentType: string): void;
+    (
+        e: 'update:platformMeta',
+        platformId: string,
+        meta: Record<string, any>,
+    ): void;
+    (
+        e: 'update:platformContentType',
+        platformId: string,
+        contentType: string,
+    ): void;
 }>();
 
 const commentsTabRef = ref<InstanceType<typeof CommentsTab> | null>(null);
 
 const previewablePlatforms = computed(() =>
-    props.post.post_platforms.filter((pp) => props.selectedPlatformIds.includes(pp.id)),
+    props.post.post_platforms.filter((pp) =>
+        props.selectedPlatformIds.includes(pp.id),
+    ),
 );
 
 defineExpose({
-    addCommentFromBroadcast: (comment: any) => commentsTabRef.value?.addCommentFromBroadcast(comment),
-    registerMentionedUsers: (users: any) => commentsTabRef.value?.registerMentionedUsers(users),
+    addCommentFromBroadcast: (comment: any) =>
+        commentsTabRef.value?.addCommentFromBroadcast(comment),
+    registerMentionedUsers: (users: any) =>
+        commentsTabRef.value?.registerMentionedUsers(users),
 });
 </script>
 
 <template>
-    <Tabs v-model="activeTab" class="h-full flex flex-col">
-        <TabsList class="mx-4 mt-4 hidden w-fit shrink-0 self-start lg:inline-flex">
-            <TabsTrigger value="preview">{{ $t('posts.edit.tabs.preview') }}</TabsTrigger>
-            <TabsTrigger value="schedule">{{ $t('posts.edit.tabs.channels') }}</TabsTrigger>
-            <TabsTrigger value="comments">{{ $t('posts.edit.tabs.comments') }}</TabsTrigger>
+    <Tabs v-model="activeTab" class="flex h-full flex-col">
+        <TabsList
+            class="mx-4 mt-4 hidden w-fit shrink-0 self-start lg:inline-flex"
+        >
+            <TabsTrigger value="preview" data-testid="editor-tab-preview">{{
+                $t('posts.edit.tabs.preview')
+            }}</TabsTrigger>
+            <TabsTrigger value="schedule">{{
+                $t('posts.edit.tabs.channels')
+            }}</TabsTrigger>
+            <TabsTrigger value="comments">{{
+                $t('posts.edit.tabs.comments')
+            }}</TabsTrigger>
         </TabsList>
 
         <TabsContent value="preview" class="flex-1 overflow-y-auto">
@@ -113,7 +133,15 @@ defineExpose({
             />
         </TabsContent>
 
-        <TabsContent value="schedule" force-mount data-testid="channels-panel" :class="['flex-1 overflow-y-auto p-4', { hidden: activeTab !== 'schedule' }]">
+        <TabsContent
+            value="schedule"
+            force-mount
+            data-testid="channels-panel"
+            :class="[
+                'flex-1 overflow-y-auto p-4',
+                { hidden: activeTab !== 'schedule' },
+            ]"
+        >
             <ScheduleTab
                 :post-platforms="post.post_platforms"
                 :selected-platform-ids="selectedPlatformIds"
@@ -129,8 +157,13 @@ defineExpose({
                 :media="media"
                 @toggle-platform="(id) => emit('toggle-platform', id)"
                 @toggle-label="(id) => emit('toggle-label', id)"
-                @update:platform-meta="(id, meta) => emit('update:platformMeta', id, meta)"
-                @update:platform-content-type="(id, contentType) => emit('update:platformContentType', id, contentType)"
+                @update:platform-meta="
+                    (id, meta) => emit('update:platformMeta', id, meta)
+                "
+                @update:platform-content-type="
+                    (id, contentType) =>
+                        emit('update:platformContentType', id, contentType)
+                "
             />
         </TabsContent>
 
@@ -142,6 +175,5 @@ defineExpose({
                 :highlight-comment-id="initialHighlightCommentId"
             />
         </TabsContent>
-
     </Tabs>
 </template>
diff --git a/resources/js/components/posts/previews/LinkCard.vue b/resources/js/components/posts/previews/LinkCard.vue
index d440cc53b..8e8c950f2 100644
--- a/resources/js/components/posts/previews/LinkCard.vue
+++ b/resources/js/components/posts/previews/LinkCard.vue
@@ -5,7 +5,10 @@ defineProps<{ card: LinkCard }>();
 </script>
 
 <template>
-    <div class="mt-3 overflow-hidden rounded-xl border border-neutral-200 dark:border-neutral-700">
+    <div
+        data-testid="link-card"
+        class="mt-3 overflow-hidden rounded-xl border border-neutral-200 dark:border-neutral-700"
+    >
         <img
             v-if="card.image"
             :src="card.image"
@@ -13,16 +16,19 @@ defineProps<{ card: LinkCard }>();
             class="aspect-[1.91/1] w-full object-cover"
         />
         <div class="px-3 py-2">
-            <div class="text-[13px] text-neutral-500 dark:text-neutral-400">{{ card.domain }}</div>
+            <div class="text-[13px] text-neutral-500 dark:text-neutral-400">
+                {{ card.domain }}
+            </div>
             <div
                 v-if="card.title"
-                class="mt-0.5 text-[15px] font-semibold text-neutral-900 dark:text-neutral-100 line-clamp-2"
+                data-testid="link-card-title"
+                class="mt-0.5 line-clamp-2 text-[15px] font-semibold text-neutral-900 dark:text-neutral-100"
             >
                 {{ card.title }}
             </div>
             <div
                 v-if="card.description"
-                class="mt-0.5 text-[14px] text-neutral-500 dark:text-neutral-400 line-clamp-2"
+                class="mt-0.5 line-clamp-2 text-[14px] text-neutral-500 dark:text-neutral-400"
             >
                 {{ card.description }}
             </div>
diff --git a/tests/Browser/LinkCardPreviewTest.php b/tests/Browser/LinkCardPreviewTest.php
new file mode 100644
index 000000000..78c72c1bc
--- /dev/null
+++ b/tests/Browser/LinkCardPreviewTest.php
@@ -0,0 +1,238 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Enums\PostPlatform\ContentType;
+use App\Enums\SocialAccount\Platform;
+use App\Enums\UserWorkspace\Role;
+use App\Models\Post;
+use App\Models\PostPlatform;
+use App\Models\SocialAccount;
+use App\Models\User;
+use App\Models\Workspace;
+
+/**
+ * @param  array<int, array<string, mixed>>  $media
+ */
+function seedLinkCardPreviewPost(
+    Platform $platform,
+    string $content = 'Draft without a link',
+    array $media = [],
+): Post {
+    $user = User::factory()->create();
+    $workspace = Workspace::factory()->create(['user_id' => $user->id]);
+    $workspace->members()->attach($user->id, ['role' => Role::Member->value]);
+    $user->update(['current_workspace_id' => $workspace->id]);
+
+    $account = SocialAccount::factory()->create([
+        'workspace_id' => $workspace->id,
+        'platform' => $platform,
+        'scopes' => $platform->requiredPublishScopes(),
+    ]);
+
+    $post = Post::factory()->create([
+        'workspace_id' => $workspace->id,
+        'user_id' => $user->id,
+        'content' => $content,
+        'media' => $media,
+    ]);
+
+    PostPlatform::factory()->create([
+        'post_id' => $post->id,
+        'social_account_id' => $account->id,
+        'platform' => $platform,
+        'content_type' => match ($platform) {
+            Platform::Facebook => ContentType::FacebookPost,
+            Platform::LinkedIn => ContentType::LinkedInPost,
+            Platform::Mastodon => ContentType::MastodonPost,
+            default => throw new LogicException('Unsupported link-card browser test platform.'),
+        },
+    ]);
+
+    test()->actingAs($user);
+
+    return $post;
+}
+
+/**
+ * The browser server is a separate process, so Laravel HTTP fakes do not cross
+ * that boundary. Intercept only the standalone Inertia HTTP request used by
+ * useLinkCard; every other XHR still uses the browser's native implementation.
+ *
+ * @param  array<string, array{status?: int, delay?: int, body?: array<string, mixed>|null}>  $responses
+ */
+function installLinkPreviewResponses(mixed $page, array $responses): void
+{
+    $encodedResponses = json_encode($responses, JSON_THROW_ON_ERROR);
+
+    $page->script(<<<JS
+        (() => {
+            const responses = {$encodedResponses};
+            const originalOpen = XMLHttpRequest.prototype.open;
+            const originalSend = XMLHttpRequest.prototype.send;
+            window.__linkPreviewRequests = 0;
+
+            XMLHttpRequest.prototype.open = function(method, url, ...rest) {
+                this.__linkPreviewRequest = String(url).includes('/posts/link-preview');
+                return originalOpen.call(this, method, url, ...rest);
+            };
+
+            XMLHttpRequest.prototype.send = function(body) {
+                if (!this.__linkPreviewRequest) {
+                    return originalSend.call(this, body);
+                }
+
+                window.__linkPreviewRequests++;
+                const target = JSON.parse(String(body)).url;
+                const response = responses[target] ?? { status: 500, body: null };
+
+                setTimeout(() => {
+                    Object.defineProperty(this, 'status', { configurable: true, value: response.status ?? 200 });
+                    Object.defineProperty(this, 'responseText', {
+                        configurable: true,
+                        value: JSON.stringify(response.body ?? null),
+                    });
+                    this.getAllResponseHeaders = () => 'content-type: application/json\\r\\n';
+                    this.onload?.();
+                }, response.delay ?? 0);
+            };
+        })();
+    JS);
+}
+
+function waitForLinkCardState(mixed $page, bool $visible): void
+{
+    $expected = $visible ? 'true' : 'false';
+
+    $page->script(<<<JS
+        (async () => {
+            for (let i = 0; i < 100; i++) {
+                const card = document.querySelector('[data-testid="link-card"]');
+                const isVisible = Boolean(card && card.getBoundingClientRect().height > 0);
+                if (isVisible === {$expected}) return;
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+        })();
+    JS);
+}
+
+function waitForLinkCardTitle(mixed $page, string $title): void
+{
+    $encodedTitle = json_encode($title, JSON_THROW_ON_ERROR);
+
+    $page->script(<<<JS
+        (async () => {
+            for (let i = 0; i < 100; i++) {
+                const title = document.querySelector('[data-testid="link-card-title"]');
+                if (title?.textContent?.trim() === {$encodedTitle}) return;
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+        })();
+    JS);
+}
+
+test('facebook linkedin and mastodon previews render fetched link cards', function (Platform $platform) {
+    $url = "https://93.184.216.34/{$platform->value}";
+    $title = "{$platform->label()} preview card";
+
+    $post = seedLinkCardPreviewPost($platform);
+    $page = visit(route('app.posts.edit', $post));
+    $page->click('@editor-tab-preview');
+    installLinkPreviewResponses($page, [
+        $url => ['body' => [
+            'uri' => $url,
+            'domain' => '93.184.216.34',
+            'title' => $title,
+            'description' => 'Browser-tested description',
+            'image' => null,
+        ]],
+    ]);
+    $page->fill('textarea:not([readonly])', "Read {$url}");
+    waitForLinkCardTitle($page, $title);
+
+    $page->assertSee($title)
+        ->assertPresent('@link-card')
+        ->assertNoJavaScriptErrors();
+})->with([
+    'Facebook' => Platform::Facebook,
+    'LinkedIn' => Platform::LinkedIn,
+    'Mastodon' => Platform::Mastodon,
+]);
+
+test('the link card ignores stale responses, handles failure and disappears with the url', function () {
+    $firstUrl = 'https://93.184.216.34/first';
+    $secondUrl = 'https://93.184.216.34/second';
+    $failedUrl = 'https://93.184.216.34/failure';
+
+    $post = seedLinkCardPreviewPost(Platform::LinkedIn);
+    $page = visit(route('app.posts.edit', $post));
+    $page->click('@editor-tab-preview');
+    installLinkPreviewResponses($page, [
+        $firstUrl => ['delay' => 900, 'body' => [
+            'uri' => $firstUrl,
+            'domain' => '93.184.216.34',
+            'title' => 'First card',
+            'description' => '',
+            'image' => null,
+        ]],
+        $secondUrl => ['delay' => 100, 'body' => [
+            'uri' => $secondUrl,
+            'domain' => '93.184.216.34',
+            'title' => 'Second card',
+            'description' => '',
+            'image' => null,
+        ]],
+        $failedUrl => ['status' => 500],
+    ]);
+
+    $page->fill('textarea:not([readonly])', "Initial {$firstUrl}");
+    $page->script('() => new Promise((resolve) => setTimeout(resolve, 500))');
+    $page->fill('textarea:not([readonly])', "Updated {$secondUrl}");
+    waitForLinkCardTitle($page, 'Second card');
+    $page->script('() => new Promise((resolve) => setTimeout(resolve, 500))');
+    $page->assertSee('Second card')->assertDontSee('First card');
+
+    $page->fill('textarea:not([readonly])', "Broken {$failedUrl}");
+    $page->script('() => new Promise((resolve) => setTimeout(resolve, 600))');
+    waitForLinkCardState($page, false);
+    $page->assertMissing('@link-card');
+
+    $page->clear('textarea:not([readonly])');
+    waitForLinkCardState($page, false);
+
+    $page->assertMissing('@link-card')
+        ->assertNoJavaScriptErrors();
+});
+
+test('attached media suppresses the link card request', function () {
+    $url = 'https://93.184.216.34/with-media';
+    $post = seedLinkCardPreviewPost(
+        Platform::LinkedIn,
+        "Media post {$url}",
+        [[
+            'id' => 'image-1',
+            'type' => 'image',
+            'mime_type' => 'image/png',
+            'path' => 'uploads/image.png',
+            'url' => 'data:image/png;base64,iVBORw0KGgo=',
+            'size' => 12,
+        ]],
+    );
+
+    $page = visit(route('app.posts.edit', $post));
+    installLinkPreviewResponses($page, [
+        $url => ['body' => [
+            'uri' => $url,
+            'domain' => '93.184.216.34',
+            'title' => 'Should not render',
+            'description' => '',
+            'image' => null,
+        ]],
+    ]);
+    $page->click('@editor-tab-preview');
+    $page->script('() => new Promise((resolve) => setTimeout(resolve, 600))');
+
+    $page->assertMissing('@link-card')
+        ->assertScript('window.__linkPreviewRequests', 0)
+        ->assertNoJavaScriptErrors();
+});
diff --git a/tests/Feature/Services/Social/LinkCard/LinkCardFetcherTest.php b/tests/Feature/Services/Social/LinkCard/LinkCardFetcherTest.php
index ca024fdf6..61c372ede 100644
--- a/tests/Feature/Services/Social/LinkCard/LinkCardFetcherTest.php
+++ b/tests/Feature/Services/Social/LinkCard/LinkCardFetcherTest.php
@@ -43,6 +43,14 @@
     expect(app(LinkCardFetcher::class)->fetch('see https://example.com'))->toBeNull();
 });
 
+test('returns null when the page exceeds the html download limit', function () {
+    Http::fake([
+        'https://example.com' => Http::response(str_repeat('x', (2 * 1024 * 1024) + 1), 200),
+    ]);
+
+    expect(app(LinkCardFetcher::class)->fetch('see https://example.com'))->toBeNull();
+});
+
 test('caches the result so a repeated url is fetched once', function () {
     Http::fake([
         'https://example.com' => Http::response(
diff --git a/tests/Unit/Services/Brand/SafeHttpFetcherTest.php b/tests/Unit/Services/Brand/SafeHttpFetcherTest.php
index 9f4983e54..3ec2cfa3a 100644
--- a/tests/Unit/Services/Brand/SafeHttpFetcherTest.php
+++ b/tests/Unit/Services/Brand/SafeHttpFetcherTest.php
@@ -90,3 +90,21 @@
     expect(app(SafeHttpFetcher::class)->guardedRequest('https://93.184.216.34/x'))
         ->toBeInstanceOf(PendingRequest::class);
 });
+
+test('tryGetBody returns a body within the requested byte limit', function () {
+    Http::fake([
+        'https://93.184.216.34/page' => Http::response('1234', 200),
+    ]);
+
+    expect(app(SafeHttpFetcher::class)->tryGetBody('https://93.184.216.34/page', 4))
+        ->toBe('1234');
+});
+
+test('tryGetBody rejects a body larger than the requested byte limit', function () {
+    Http::fake([
+        'https://93.184.216.34/page' => Http::response('12345', 200),
+    ]);
+
+    expect(app(SafeHttpFetcher::class)->tryGetBody('https://93.184.216.34/page', 4))
+        ->toBeNull();
+});

From fd11477dedc69c0ed27bd6b44f01e8106bc3c9d0 Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Tue, 22 Sep 2026 10:05:11 -0300
Subject: [PATCH 17/18] test: simplify link card coverage with Laravel HTTP
 fakes

---
 tests/Browser/LinkCardPreviewTest.php         | 262 +++++++-----------
 .../Services/Brand/SafeHttpFetcherTest.php    |  22 ++
 2 files changed, 122 insertions(+), 162 deletions(-)

diff --git a/tests/Browser/LinkCardPreviewTest.php b/tests/Browser/LinkCardPreviewTest.php
index 78c72c1bc..dad52fffb 100644
--- a/tests/Browser/LinkCardPreviewTest.php
+++ b/tests/Browser/LinkCardPreviewTest.php
@@ -2,6 +2,7 @@
 
 declare(strict_types=1);
 
+use Amp\DeferredFuture;
 use App\Enums\PostPlatform\ContentType;
 use App\Enums\SocialAccount\Platform;
 use App\Enums\UserWorkspace\Role;
@@ -10,6 +11,8 @@
 use App\Models\SocialAccount;
 use App\Models\User;
 use App\Models\Workspace;
+use Illuminate\Support\Facades\Http;
+use Pest\Browser\Execution;
 
 /**
  * @param  array<int, array<string, mixed>>  $media
@@ -54,185 +57,120 @@ function seedLinkCardPreviewPost(
     return $post;
 }
 
-/**
- * The browser server is a separate process, so Laravel HTTP fakes do not cross
- * that boundary. Intercept only the standalone Inertia HTTP request used by
- * useLinkCard; every other XHR still uses the browser's native implementation.
- *
- * @param  array<string, array{status?: int, delay?: int, body?: array<string, mixed>|null}>  $responses
- */
-function installLinkPreviewResponses(mixed $page, array $responses): void
-{
-    $encodedResponses = json_encode($responses, JSON_THROW_ON_ERROR);
-
-    $page->script(<<<JS
-        (() => {
-            const responses = {$encodedResponses};
-            const originalOpen = XMLHttpRequest.prototype.open;
-            const originalSend = XMLHttpRequest.prototype.send;
-            window.__linkPreviewRequests = 0;
-
-            XMLHttpRequest.prototype.open = function(method, url, ...rest) {
-                this.__linkPreviewRequest = String(url).includes('/posts/link-preview');
-                return originalOpen.call(this, method, url, ...rest);
-            };
-
-            XMLHttpRequest.prototype.send = function(body) {
-                if (!this.__linkPreviewRequest) {
-                    return originalSend.call(this, body);
-                }
-
-                window.__linkPreviewRequests++;
-                const target = JSON.parse(String(body)).url;
-                const response = responses[target] ?? { status: 500, body: null };
-
-                setTimeout(() => {
-                    Object.defineProperty(this, 'status', { configurable: true, value: response.status ?? 200 });
-                    Object.defineProperty(this, 'responseText', {
-                        configurable: true,
-                        value: JSON.stringify(response.body ?? null),
-                    });
-                    this.getAllResponseHeaders = () => 'content-type: application/json\\r\\n';
-                    this.onload?.();
-                }, response.delay ?? 0);
-            };
-        })();
-    JS);
-}
-
-function waitForLinkCardState(mixed $page, bool $visible): void
-{
-    $expected = $visible ? 'true' : 'false';
-
-    $page->script(<<<JS
-        (async () => {
-            for (let i = 0; i < 100; i++) {
-                const card = document.querySelector('[data-testid="link-card"]');
-                const isVisible = Boolean(card && card.getBoundingClientRect().height > 0);
-                if (isVisible === {$expected}) return;
-                await new Promise((resolve) => setTimeout(resolve, 50));
-            }
-        })();
-    JS);
-}
-
-function waitForLinkCardTitle(mixed $page, string $title): void
-{
-    $encodedTitle = json_encode($title, JSON_THROW_ON_ERROR);
-
-    $page->script(<<<JS
-        (async () => {
-            for (let i = 0; i < 100; i++) {
-                const title = document.querySelector('[data-testid="link-card-title"]');
-                if (title?.textContent?.trim() === {$encodedTitle}) return;
-                await new Promise((resolve) => setTimeout(resolve, 50));
-            }
-        })();
-    JS);
-}
-
 test('facebook linkedin and mastodon previews render fetched link cards', function (Platform $platform) {
     $url = "https://93.184.216.34/{$platform->value}";
-    $title = "{$platform->label()} preview card";
-
-    $post = seedLinkCardPreviewPost($platform);
-    $page = visit(route('app.posts.edit', $post));
-    $page->click('@editor-tab-preview');
-    installLinkPreviewResponses($page, [
-        $url => ['body' => [
-            'uri' => $url,
-            'domain' => '93.184.216.34',
-            'title' => $title,
-            'description' => 'Browser-tested description',
-            'image' => null,
-        ]],
-    ]);
-    $page->fill('textarea:not([readonly])', "Read {$url}");
-    waitForLinkCardTitle($page, $title);
+    Http::fake([$url => Http::response('<meta property="og:title" content="Article card">')]);
+
+    $post = seedLinkCardPreviewPost($platform, "Read {$url}");
 
-    $page->assertSee($title)
+    visit(route('app.posts.edit', $post))
+        ->click('@editor-tab-preview')
+        ->assertSee('Article card')
         ->assertPresent('@link-card')
         ->assertNoJavaScriptErrors();
+
+    Http::assertSentCount(1);
 })->with([
     'Facebook' => Platform::Facebook,
     'LinkedIn' => Platform::LinkedIn,
     'Mastodon' => Platform::Mastodon,
 ]);
 
-test('the link card ignores stale responses, handles failure and disappears with the url', function () {
-    $firstUrl = 'https://93.184.216.34/first';
-    $secondUrl = 'https://93.184.216.34/second';
-    $failedUrl = 'https://93.184.216.34/failure';
-
-    $post = seedLinkCardPreviewPost(Platform::LinkedIn);
-    $page = visit(route('app.posts.edit', $post));
-    $page->click('@editor-tab-preview');
-    installLinkPreviewResponses($page, [
-        $firstUrl => ['delay' => 900, 'body' => [
-            'uri' => $firstUrl,
-            'domain' => '93.184.216.34',
-            'title' => 'First card',
-            'description' => '',
-            'image' => null,
-        ]],
-        $secondUrl => ['delay' => 100, 'body' => [
-            'uri' => $secondUrl,
-            'domain' => '93.184.216.34',
-            'title' => 'Second card',
-            'description' => '',
-            'image' => null,
-        ]],
-        $failedUrl => ['status' => 500],
-    ]);
-
-    $page->fill('textarea:not([readonly])', "Initial {$firstUrl}");
-    $page->script('() => new Promise((resolve) => setTimeout(resolve, 500))');
-    $page->fill('textarea:not([readonly])', "Updated {$secondUrl}");
-    waitForLinkCardTitle($page, 'Second card');
-    $page->script('() => new Promise((resolve) => setTimeout(resolve, 500))');
-    $page->assertSee('Second card')->assertDontSee('First card');
-
-    $page->fill('textarea:not([readonly])', "Broken {$failedUrl}");
-    $page->script('() => new Promise((resolve) => setTimeout(resolve, 600))');
-    waitForLinkCardState($page, false);
-    $page->assertMissing('@link-card');
-
-    $page->clear('textarea:not([readonly])');
-    waitForLinkCardState($page, false);
+test('removing a url removes its visible card', function () {
+    Http::fake(['https://93.184.216.34/*' => Http::response('<meta property="og:title" content="Article card">')]);
+    $post = seedLinkCardPreviewPost(Platform::LinkedIn, 'https://93.184.216.34/article');
 
-    $page->assertMissing('@link-card')
+    visit(route('app.posts.edit', $post))
+        ->click('@editor-tab-preview')
+        ->assertSee('Article card')
+        ->clear('textarea:not([readonly])')
+        ->assertMissing('@link-card')
         ->assertNoJavaScriptErrors();
 });
 
-test('attached media suppresses the link card request', function () {
-    $url = 'https://93.184.216.34/with-media';
-    $post = seedLinkCardPreviewPost(
-        Platform::LinkedIn,
-        "Media post {$url}",
-        [[
-            'id' => 'image-1',
-            'type' => 'image',
-            'mime_type' => 'image/png',
-            'path' => 'uploads/image.png',
-            'url' => 'data:image/png;base64,iVBORw0KGgo=',
-            'size' => 12,
-        ]],
-    );
-
-    $page = visit(route('app.posts.edit', $post));
-    installLinkPreviewResponses($page, [
-        $url => ['body' => [
-            'uri' => $url,
-            'domain' => '93.184.216.34',
-            'title' => 'Should not render',
-            'description' => '',
-            'image' => null,
-        ]],
+test('a failed fetch clears the previous card and a later url can recover', function () {
+    Http::fake([
+        'https://93.184.216.34/article' => Http::response('<meta property="og:title" content="Article card">'),
+        'https://93.184.216.34/broken' => Http::response('', 500),
+        'https://93.184.216.34/recovered' => Http::response('<meta property="og:title" content="Recovered card">'),
     ]);
-    $page->click('@editor-tab-preview');
-    $page->script('() => new Promise((resolve) => setTimeout(resolve, 600))');
+    $post = seedLinkCardPreviewPost(Platform::LinkedIn, 'https://93.184.216.34/article');
+    $page = visit(route('app.posts.edit', $post))
+        ->click('@editor-tab-preview')
+        ->assertSee('Article card')
+        ->fill('textarea:not([readonly])', 'https://93.184.216.34/broken');
 
+    Execution::instance()->waitForExpectation(fn () => Http::assertSentCount(2));
     $page->assertMissing('@link-card')
-        ->assertScript('window.__linkPreviewRequests', 0)
+        ->fill('textarea:not([readonly])', 'https://93.184.216.34/recovered')
+        ->assertSee('Recovered card')
         ->assertNoJavaScriptErrors();
 });
+
+test('a pending response cannot overwrite a newer card or revive a removed url', function (bool $removeUrl) {
+    $release = new DeferredFuture;
+    $started = false;
+    Http::fake(function ($request) use ($release, &$started) {
+        if ($request->url() === 'https://93.184.216.34/slow') {
+            $started = true;
+            $release->getFuture()->await();
+
+            return Http::response('<meta property="og:title" content="Stale card">');
+        }
+
+        return Http::response('<meta property="og:title" content="Current card">');
+    });
+
+    $post = seedLinkCardPreviewPost(Platform::LinkedIn, 'https://93.184.216.34/slow');
+    $page = visit(route('app.posts.edit', $post))->click('@editor-tab-preview');
+
+    try {
+        Execution::instance()->waitForExpectation(function () use (&$started) {
+            expect($started)->toBeTrue();
+        });
+
+        $page->fill('textarea:not([readonly])', $removeUrl ? '' : 'https://93.184.216.34/current');
+
+        if (! $removeUrl) {
+            $page->assertSee('Current card');
+        }
+    } finally {
+        $release->complete();
+    }
+
+    $page->page()->waitForLoadState('networkidle');
+    $page->assertDontSee('Stale card');
+
+    if ($removeUrl) {
+        $page->assertMissing('@link-card');
+    } else {
+        $page->assertSee('Current card');
+    }
+
+    $page->assertNoJavaScriptErrors();
+})->with(['newer url' => false, 'removed url' => true]);
+
+test('attached media suppresses fetching until it is removed', function () {
+    Http::fake(['https://93.184.216.34/*' => Http::response('<meta property="og:title" content="Article card">')]);
+    $post = seedLinkCardPreviewPost(Platform::LinkedIn, 'https://93.184.216.34/article', [[
+        'id' => 'image-1',
+        'type' => 'image',
+        'mime_type' => 'image/png',
+        'path' => 'uploads/image.png',
+        'url' => 'data:image/png;base64,'.base64_encode(file_get_contents(__DIR__.'/../fixtures/1x1.png')),
+        'size' => 68,
+    ]]);
+
+    $page = visit(route('app.posts.edit', $post))
+        ->click('@editor-tab-preview')
+        ->assertPresent('@media-thumbnail')
+        ->assertMissing('@link-card');
+
+    Http::assertNothingSent();
+
+    $page->click('@media-remove')
+        ->assertSee('Article card')
+        ->assertNoJavaScriptErrors();
+
+    Http::assertSentCount(1);
+});
diff --git a/tests/Unit/Services/Brand/SafeHttpFetcherTest.php b/tests/Unit/Services/Brand/SafeHttpFetcherTest.php
index 3ec2cfa3a..adc405f61 100644
--- a/tests/Unit/Services/Brand/SafeHttpFetcherTest.php
+++ b/tests/Unit/Services/Brand/SafeHttpFetcherTest.php
@@ -108,3 +108,25 @@
     expect(app(SafeHttpFetcher::class)->tryGetBody('https://93.184.216.34/page', 4))
         ->toBeNull();
 });
+
+test('tryGetBody aborts an oversized transfer and closes its temporary stream', function (int $total, int $downloaded) {
+    $stream = null;
+    $completed = false;
+
+    Http::fake(function ($request, array $options) use ($total, $downloaded, &$stream, &$completed) {
+        $stream = $options['sink'];
+        expect(is_resource($stream))->toBeTrue();
+
+        $options['progress']($total, $downloaded);
+        $completed = true;
+
+        return Http::response('should never finish');
+    });
+
+    expect(app(SafeHttpFetcher::class)->tryGetBody('https://93.184.216.34/page', 4))->toBeNull()
+        ->and($completed)->toBeFalse()
+        ->and(is_resource($stream))->toBeFalse();
+})->with([
+    'declared length' => [5, 0],
+    'unknown length' => [0, 5],
+]);

From e2281cf41580f1fbb5535111a1561f4425b0fbdf Mon Sep 17 00:00:00 2001
From: Paulo Castellano <paulo@castellanos.llc>
Date: Tue, 22 Sep 2026 10:12:30 -0300
Subject: [PATCH 18/18] fix: isolate link preview temporary file from Guzzle
 stream ownership

---
 app/Services/Brand/SafeHttpFetcher.php        |  3 ++-
 .../Services/Brand/SafeHttpFetcherTest.php    | 19 +++++++++++++++++--
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/app/Services/Brand/SafeHttpFetcher.php b/app/Services/Brand/SafeHttpFetcher.php
index c3b406882..f5d4700c4 100644
--- a/app/Services/Brand/SafeHttpFetcher.php
+++ b/app/Services/Brand/SafeHttpFetcher.php
@@ -112,7 +112,8 @@ public function tryGetBody(string $url, int $maxBytes): ?string
             $response = $this->guardedRequest($url)
                 ->connectTimeout(3)
                 ->timeout(self::TIMEOUT_SECONDS)
-                ->sink($stream)
+                // Guzzle owns and closes its sink; keep our temporary-file handle independent.
+                ->sink(stream_get_meta_data($stream)['uri'])
                 ->withOptions([
                     'progress' => static function ($total, $downloaded) use ($maxBytes): void {
                         if ($total > $maxBytes || $downloaded > $maxBytes) {
diff --git a/tests/Unit/Services/Brand/SafeHttpFetcherTest.php b/tests/Unit/Services/Brand/SafeHttpFetcherTest.php
index adc405f61..a6b39d2b8 100644
--- a/tests/Unit/Services/Brand/SafeHttpFetcherTest.php
+++ b/tests/Unit/Services/Brand/SafeHttpFetcherTest.php
@@ -3,6 +3,7 @@
 declare(strict_types=1);
 
 use App\Services\Brand\SafeHttpFetcher;
+use GuzzleHttp\Psr7\Utils;
 use Illuminate\Http\Client\PendingRequest;
 use Illuminate\Support\Facades\Http;
 
@@ -100,6 +101,20 @@
         ->toBe('1234');
 });
 
+test('tryGetBody cleans up when the transport closes its sink before failing', function () {
+    Http::fake(function ($request, array $options) {
+        $sink = $options['sink'];
+        $body = Utils::streamFor(
+            is_string($sink) ? Utils::tryFopen($sink, 'w+') : $sink,
+        );
+        $body->close();
+
+        throw new RuntimeException('Transport failed after closing the response body.');
+    });
+
+    expect(app(SafeHttpFetcher::class)->tryGetBody('https://93.184.216.34/page', 4))->toBeNull();
+});
+
 test('tryGetBody rejects a body larger than the requested byte limit', function () {
     Http::fake([
         'https://93.184.216.34/page' => Http::response('12345', 200),
@@ -115,7 +130,7 @@
 
     Http::fake(function ($request, array $options) use ($total, $downloaded, &$stream, &$completed) {
         $stream = $options['sink'];
-        expect(is_resource($stream))->toBeTrue();
+        expect(is_file($stream))->toBeTrue();
 
         $options['progress']($total, $downloaded);
         $completed = true;
@@ -125,7 +140,7 @@
 
     expect(app(SafeHttpFetcher::class)->tryGetBody('https://93.184.216.34/page', 4))->toBeNull()
         ->and($completed)->toBeFalse()
-        ->and(is_resource($stream))->toBeFalse();
+        ->and(file_exists($stream))->toBeFalse();
 })->with([
     'declared length' => [5, 0],
     'unknown length' => [0, 5],