Add the repurpose module

.claude/release-assets/render-thumbnail.mjs

@@ -16,11 +16,11 @@
 // Playwright is resolved from the repo's node_modules, so the script works
 // regardless of where it is invoked.
 
-import { createRequire } from 'module';
 import { readFileSync, writeFileSync, unlinkSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
+import { createRequire } from 'module';
 import { tmpdir } from 'os';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 
 const here = dirname(fileURLToPath(import.meta.url));
 const repoRoot = join(here, '..', '..');

.env.example

@@ -300,3 +300,6 @@ VITE_REVERB_SCHEME="${REVERB_SCHEME}"
 VITE_POSTHOG_ENABLED="${POSTHOG_ENABLED}"
 VITE_POSTHOG_API_KEY="${POSTHOG_API_KEY}"
 VITE_POSTHOG_HOST="${POSTHOG_HOST}"
+
+REPURPOSE_POLL_INTERVAL_MINUTES=15
+REPURPOSE_BACKOFF_MINUTES=60

.gitignore

@@ -24,6 +24,7 @@ Homestead.yaml
 npm-debug.log
 yarn-error.log
 /auth.json
+/.codex
 /.fleet
 /.idea
 /.nova

AGENTS.md

@@ -286,3 +286,50 @@ Standing constraints:
 - The editor counts characters and renders the X preview client-side, so the rewrite is mirrored in `resources/js/lib/defuseXLinks.ts`. The TLD list is NOT duplicated there: `PostController@edit` sends `App\Support\LinkTlds::all()` as the `xLinkTlds` page prop, and only when defusing is on — an empty set means the feature is off, since without the list a bare host cannot be told from `Node.js`. Do not move it to the Inertia shared props; only the editor needs it. Two tests keep the mirror honest: `XLinkDefusingParityTest` runs a shared corpus through both engines over the same list and diffs the output, and `tests/Browser/XLinkDefusingTest.php` drives the real editor.
 - Neither expression may use lookbehind. Safari only understands it from 16.4, esbuild cannot transpile it, and a `SyntaxError` there takes down the whole chunk — the character before a candidate URL is consumed and put back instead.
 
+## Repurpose account health
+
+A repurpose depends on social accounts it does not own the lifecycle of. Three
+decisions govern how it reacts, and each exists because the obvious alternative
+was tried and was wrong.
+
+- **A switched-off destination is skipped, never an error.** Deactivating an
+  account means "don't post here", which `ProcessRepurposeItem` already honours.
+  So `ActivateRepurpose::assertDestinationsPublishable()` requires **one** usable
+  destination, not all of them, and the destination rule in the repurpose
+  FormRequests carries **no** `is_active` clause. Requiring either is what used
+  to block editing *and* resuming any repurpose that listed a paused account.
+  Keep the `workspace_id` clause — that is tenancy, not health. The
+  `source_social_account_id` rules stay strict: a source genuinely must work.
+- **`repurposes.paused_reason` is not UI copy.** NULL means the user paused it.
+  Its only two jobs are deciding the watermark on resume (a system pause starts
+  from `now()`, a user pause keeps its place) and deciding whether the system may
+  auto-resume. Banners derive from current account health instead, so they can
+  say "ready to resume" once the cause is fixed. **Never clear it in
+  `UpdateRepurpose`** — that destroys the record that the pause was systemic, and
+  the next Resume replays the entire backlog.
+- **Source and destination are deliberately asymmetric.** A dead source stops the
+  automation; a dead destination keeps flowing to the publisher, which fails the
+  post visibly and lets the user retry it after reconnecting. Skipping a
+  destination at job time would be permanent for that item, since items are never
+  retried.
+
+`RepurposeAccountSync` runs from `SocialAccountObserver` and must never throw:
+`deleting` runs inside `$account->delete()`, and `persistIdentity()` wraps a
+reconnect in a transaction, so an exception there would 500 a disconnect or roll
+back a reconnect. It reads account health **from the database**, not from the
+model it was handed — `is_active` is absent from `SocialAccountFactory`, and
+strict mode exempts recently-created models from the missing-attribute
+exception, so a healthy account read back as `null` and silently skipped
+auto-resume.
+
+No email is sent when a repurpose stops. `markAsTokenExpired()` and
+`VerifyWorkspaceConnections` already email about the account, and reconnecting is
+what auto-resumes the repurpose; deleting or switching an account off is
+something the user just did, so the flash on the accounts page reports the count
+instead.
+
+`VerifyWorkspaceConnections` is the **only** thing that promotes an account back
+to `Connected`, because it does so after a real `verify()` call. A successful
+token refresh is not that proof — the refresh token being valid says nothing
+about whether publishing still works — so `RefreshSocialToken` must not promote,
+even though it would let a paused repurpose resume sooner.

CLAUDE.md

@@ -285,7 +285,7 @@ Self-hosted compose / `.env.example` set this `true`. When the env is unset, the
 - Always use normal pagination (`->paginate()`). NEVER use cursor pagination (`->cursorPaginate()`).
 - All paginated lists must use Inertia's scroll pagination (`Inertia::scroll()` on the backend with `<InfiniteScroll>` on the frontend). NEVER use traditional page-based pagination with page links/buttons.
 - The page size ALWAYS comes from `config('app.pagination.default')` — never a magic number, and never a `perPage`/`per_page` value supplied by the request or frontend. Action/service list methods must NOT accept a `$perPage` parameter; call `->paginate((int) config('app.pagination.default'))` directly.
-    - The only exception is the public REST API (`app/Http/Controllers/Api`), which uses its own fixed, documented page size (15) as a stable API contract.
+    - **This includes the public REST API** (`app/Http/Controllers/Api`). It used to pin its own page size of 15 as a stable contract; that exception is gone, so a list endpoint reads the same config as everything else. Changing `app.pagination.default` therefore changes the API's page size too — deliberate, and the reason a list response always carries `meta.per_page` for clients to read rather than assume.
 
 ## Form Validation
 
@@ -434,3 +434,51 @@ Standing constraints:
 - NEVER add `Co-Authored-By` lines to commit messages.
 - NEVER commit, push, or open PRs unless explicitly asked by the user.
 - Always create a new branch for feature work before making changes.
+
+## Repurpose account health
+
+A repurpose depends on social accounts it does not own the lifecycle of. Three
+decisions govern how it reacts, and each exists because the obvious alternative
+was tried and was wrong.
+
+- **A switched-off destination is skipped, never an error.** Deactivating an
+  account means "don't post here", which `ProcessRepurposeItem` already honours.
+  So `ActivateRepurpose::assertDestinationsPublishable()` requires **one** usable
+  destination, not all of them, and the destination rule in the repurpose
+  FormRequests carries **no** `is_active` clause. Requiring either is what used
+  to block editing *and* resuming any repurpose that listed a paused account.
+  Keep the `workspace_id` clause — that is tenancy, not health. The
+  `source_social_account_id` rules stay strict: a source genuinely must work.
+- **`repurposes.paused_reason` is not UI copy.** NULL means the user paused it.
+  Its only two jobs are deciding the watermark on resume (a system pause starts
+  from `now()`, a user pause keeps its place) and deciding whether the system may
+  auto-resume. Banners derive from current account health instead, so they can
+  say "ready to resume" once the cause is fixed. **Never clear it in
+  `UpdateRepurpose`** — that destroys the record that the pause was systemic, and
+  the next Resume replays the entire backlog.
+- **Source and destination are deliberately asymmetric.** A dead source stops the
+  automation; a dead destination keeps flowing to the publisher, which fails the
+  post visibly and lets the user retry it after reconnecting. Skipping a
+  destination at job time would be permanent for that item, since items are never
+  retried.
+
+`RepurposeAccountSync` runs from `SocialAccountObserver` and must never throw:
+`deleting` runs inside `$account->delete()`, and `persistIdentity()` wraps a
+reconnect in a transaction, so an exception there would 500 a disconnect or roll
+back a reconnect. It reads account health **from the database**, not from the
+model it was handed — `is_active` is absent from `SocialAccountFactory`, and
+strict mode exempts recently-created models from the missing-attribute
+exception, so a healthy account read back as `null` and silently skipped
+auto-resume.
+
+No email is sent when a repurpose stops. `markAsTokenExpired()` and
+`VerifyWorkspaceConnections` already email about the account, and reconnecting is
+what auto-resumes the repurpose; deleting or switching an account off is
+something the user just did, so the flash on the accounts page reports the count
+instead.
+
+`VerifyWorkspaceConnections` is the **only** thing that promotes an account back
+to `Connected`, because it does so after a real `verify()` call. A successful
+token refresh is not that proof — the refresh token being valid says nothing
+about whether publishing still works — so `RefreshSocialToken` must not promote,
+even though it would let a paused repurpose resume sooner.

README.md

@@ -46,6 +46,7 @@
 | **AI generate & review** | Draft from a prompt, get inline feedback before you publish. |
 | **AI carousel builder** | Prompt to a multi-slide carousel with images, on-brand. |
 | **Brand profile** | Tone, voice, language, and colors applied to every AI call. |
+| **Repurpose** | Auto-replicate the videos you post outside TryPost to your other networks. |
 | **Asset library** | Reusable workspace media, plus Unsplash and Giphy search built in. |
 | **Signatures & labels** | Reusable hashtag and CTA blocks, color-coded post tags. |
 | **Team collaboration** | Owner / Admin / Member roles, comments with @mentions on drafts. |

app/Actions/Repurpose/ActivateRepurpose.php

@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Repurpose;
+
+use App\Enums\Repurpose\Status;
+use App\Enums\SocialAccount\Status as AccountStatus;
+use App\Models\Repurpose;
+use App\Models\SocialAccount;
+use App\Support\PostPlatformMetaRules;
+use App\Support\Repurpose\RepurposeTransition;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Validation\ValidationException;
+
+class ActivateRepurpose
+{
+    public static function execute(Repurpose $repurpose): Repurpose
+    {
+        return RepurposeTransition::apply(
+            $repurpose,
+            [Status::Draft, Status::Disabled],
+            __('repurposes.errors.only_idle_activates'),
+            function (Repurpose $locked): void {
+                self::assertSourceUsable($locked);
+                self::assertHasUsableDestination($locked);
+                self::assertDestinationsCarryRequiredMeta($locked);
+
+                $locked->update([
+                    'status' => Status::Active,
+                    'activated_at' => now(),
+                    'paused_reason' => null,
+                    'next_poll_at' => null,
+                    'last_error' => null,
+                ]);
+            },
+        );
+    }
+
+    public static function assertSourceUsable(Repurpose $repurpose): void
+    {
+        $account = $repurpose->loadMissing('sourceAccount')->sourceAccount;
+
+        if ($account === null) {
+            throw ValidationException::withMessages([
+                'source_social_account_id' => __('repurposes.errors.source_missing'),
+            ]);
+        }
+
+        if (! $account->is_active || $account->status !== AccountStatus::Connected) {
+            throw ValidationException::withMessages([
+                'source_social_account_id' => __('repurposes.errors.source_unusable'),
+            ]);
+        }
+    }
+
+    public static function assertHasUsableDestination(Repurpose $repurpose): void
+    {
+        if ($repurpose->destinations === []) {
+            throw ValidationException::withMessages([
+                'destinations' => __('repurposes.errors.destinations_required'),
+            ]);
+        }
+
+        if (self::usableAccounts($repurpose)->isEmpty()) {
+            throw ValidationException::withMessages([
+                'destinations' => __('repurposes.errors.destination_unavailable'),
+            ]);
+        }
+    }
+
+    public static function assertDestinationsCarryRequiredMeta(Repurpose $repurpose): void
+    {
+        $accounts = self::usableAccounts($repurpose);
+
+        foreach ($repurpose->destinations as $destination) {
+            $account = $accounts->get(data_get($destination, 'social_account_id'));
+
+            if ($account === null) {
+                continue;
+            }
+
+            $violation = PostPlatformMetaRules::requiredMetaViolation($account->platform, data_get($destination, 'meta'));
+
+            if ($violation !== null) {
+                throw ValidationException::withMessages(['destinations' => $violation[1]]);
+            }
+        }
+    }
+
+    /**
+     * @return Collection<string, SocialAccount>
+     */
+    private static function usableAccounts(Repurpose $repurpose): Collection
+    {
+        return SocialAccount::query()
+            ->where('workspace_id', $repurpose->workspace_id)
+            ->where('is_active', true)
+            ->findMany(array_map(
+                fn (array $destination): mixed => data_get($destination, 'social_account_id'),
+                $repurpose->destinations,
+            ))
+            ->keyBy('id');
+    }
+}

app/Actions/Repurpose/CreateRepurpose.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Repurpose;
+
+use App\Enums\Repurpose\PublishMode;
+use App\Enums\Repurpose\SourceFormat;
+use App\Enums\Repurpose\Status;
+use App\Models\Repurpose;
+use App\Models\User;
+use App\Models\Workspace;
+use Illuminate\Database\UniqueConstraintViolationException;
+use Illuminate\Validation\ValidationException;
+
+class CreateRepurpose
+{
+    /**
+     * @param  array<string, mixed>  $data
+     */
+    public static function execute(Workspace $workspace, User $user, array $data): Repurpose
+    {
+        $sourceAccountId = data_get($data, 'source_social_account_id');
+        $sourceFormat = SourceFormat::from(data_get($data, 'source_format', SourceFormat::Reel->value));
+
+        if (self::existingFor($workspace, $sourceAccountId, $sourceFormat) !== null) {
+            throw ValidationException::withMessages([
+                'source_social_account_id' => __('repurposes.errors.source_already_used'),
+            ]);
+        }
+
+        try {
+            return Repurpose::query()->create([
+                'workspace_id' => $workspace->id,
+                'user_id' => $user->id,
+                'source_social_account_id' => $sourceAccountId,
+                'source_format' => $sourceFormat,
+                'publish_mode' => PublishMode::from(data_get($data, 'publish_mode', PublishMode::Publish->value)),
+                'destinations' => data_get($data, 'destinations', []),
+                'status' => Status::Draft,
+            ]);
+        } catch (UniqueConstraintViolationException) {
+            throw ValidationException::withMessages([
+                'source_social_account_id' => __('repurposes.errors.source_already_used'),
+            ]);
+        }
+    }
+
+    public static function existingFor(Workspace $workspace, string $sourceAccountId, SourceFormat $format): ?Repurpose
+    {
+        return Repurpose::query()
+            ->where('workspace_id', $workspace->id)
+            ->where('source_social_account_id', $sourceAccountId)
+            ->where('source_format', $format)
+            ->first();
+    }
+}

app/Actions/Repurpose/DeleteRepurpose.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Repurpose;
+
+use App\Models\Repurpose;
+
+class DeleteRepurpose
+{
+    public static function execute(Repurpose $repurpose): void
+    {
+        $repurpose->delete();
+    }
+}

app/Actions/Repurpose/DisableRepurpose.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Repurpose;
+
+use App\Enums\Repurpose\Status;
+use App\Models\Repurpose;
+use App\Support\Repurpose\RepurposeTransition;
+
+class DisableRepurpose
+{
+    public static function execute(Repurpose $repurpose): Repurpose
+    {
+        return RepurposeTransition::apply(
+            $repurpose,
+            [Status::Active, Status::Paused],
+            __('repurposes.errors.only_running_disables'),
+            fn (Repurpose $locked) => $locked->update([
+                'status' => Status::Disabled,
+                'activated_at' => null,
+                'paused_reason' => null,
+                'next_poll_at' => null,
+            ]),
+        );
+    }
+}

app/Actions/Repurpose/ListRepurposeItems.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Repurpose;
+
+use App\Models\Repurpose;
+use App\Models\RepurposeItem;
+use Illuminate\Pagination\LengthAwarePaginator;
+use Illuminate\Support\Facades\DB;
+
+class ListRepurposeItems
+{
+    /**
+     * @return LengthAwarePaginator<int, RepurposeItem>
+     */
+    public static function execute(Repurpose $repurpose, ?int $page = null): LengthAwarePaginator
+    {
+        return $repurpose->items()
+            ->with('posts.postPlatforms:id,post_id,platform,enabled,status')
+            ->orderByDesc(DB::raw('coalesce(source_created_at, created_at)'))
+            ->paginate((int) config('app.pagination.default'), page: $page);
+    }
+}