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

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,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Repurpose;
+
+use App\Enums\Repurpose\Status;
+use App\Models\Repurpose;
+use App\Models\SocialAccount;
+use App\Support\PostPlatformMetaRules;
+use App\Support\Repurpose\RepurposeTransition;
+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::assertPublishable($locked);
+
+                $locked->update([
+                    'status' => Status::Active,
+                    'activated_at' => now(),
+                    'next_poll_at' => null,
+                    'last_error' => null,
+                ]);
+            },
+        );
+    }
+
+    public static function assertPublishable(Repurpose $repurpose): void
+    {
+        if ($repurpose->destinations === []) {
+            throw ValidationException::withMessages([
+                'destinations' => __('repurposes.errors.destinations_required'),
+            ]);
+        }
+
+        foreach ($repurpose->destinations as $destination) {
+            $account = SocialAccount::query()
+                ->where('workspace_id', $repurpose->workspace_id)
+                ->where('is_active', true)
+                ->find(data_get($destination, 'social_account_id'));
+
+            if ($account === null) {
+                throw ValidationException::withMessages([
+                    'destinations' => __('repurposes.errors.destination_unavailable'),
+                ]);
+            }
+
+            $violation = PostPlatformMetaRules::requiredMetaViolation($account->platform, data_get($destination, 'meta'));
+
+            if ($violation !== null) {
+                throw ValidationException::withMessages(['destinations' => $violation[1]]);
+            }
+        }
+    }
+}

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 = (string) data_get($data, 'source_social_account_id');
+        $sourceFormat = SourceFormat::tryFrom((string) data_get($data, 'source_format')) ?? SourceFormat::Reel;
+
+        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::tryFrom((string) data_get($data, 'publish_mode')) ?? PublishMode::Publish,
+                '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,26 @@
+<?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,
+                '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): LengthAwarePaginator
+    {
+        return $repurpose->items()
+            ->with('posts.postPlatforms:id,post_id,platform,enabled')
+            ->orderByDesc(DB::raw('coalesce(source_created_at, created_at)'))
+            ->paginate((int) config('app.pagination.default'));
+    }
+}

app/Actions/Repurpose/ListRepurposes.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Repurpose;
+
+use App\Enums\Repurpose\ItemStatus;
+use App\Models\Repurpose;
+use App\Models\Workspace;
+use Illuminate\Pagination\LengthAwarePaginator;
+
+class ListRepurposes
+{
+    /**
+     * @return LengthAwarePaginator<int, Repurpose>
+     */
+    public static function execute(Workspace $workspace, ?int $page = null): LengthAwarePaginator
+    {
+        return Repurpose::query()
+            ->where('workspace_id', $workspace->id)
+            ->with('sourceAccount')
+            ->withCount(['items as published_items_count' => fn ($query) => $query->where('status', ItemStatus::Published)])
+            ->latest()
+            ->paginate((int) config('app.pagination.default'), page: $page);
+    }
+}

app/Actions/Repurpose/PauseRepurpose.php

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

app/Actions/Repurpose/ResumeRepurpose.php

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

app/Actions/Repurpose/UpdateRepurpose.php

@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Repurpose;
+
+use App\Enums\Repurpose\Status;
+use App\Models\Repurpose;
+use Illuminate\Database\UniqueConstraintViolationException;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
+
+class UpdateRepurpose
+{
+    /**
+     * @param  array<string, mixed>  $data
+     */
+    public static function execute(Repurpose $repurpose, array $data): Repurpose
+    {
+        $attributes = Arr::only($data, [
+            'source_social_account_id',
+            'source_format',
+            'publish_mode',
+            'destinations',
+        ]);
+
+        if (self::watchesSomethingElse($repurpose, $attributes)) {
+            $attributes['activated_at'] = $repurpose->activated_at === null ? null : now();
+        }
+
+        try {
+            return DB::transaction(function () use ($repurpose, $attributes): Repurpose {
+                $locked = Repurpose::query()->whereKey($repurpose->id)->lockForUpdate()->firstOrFail();
+
+                $locked->update($attributes);
+                $locked = $locked->fresh();
+
+                if ($locked->status === Status::Active) {
+                    ActivateRepurpose::assertPublishable($locked);
+                }
+
+                return $locked;
+            });
+        } catch (UniqueConstraintViolationException) {
+            throw ValidationException::withMessages([
+                'source_social_account_id' => __('repurposes.errors.source_already_used'),
+            ]);
+        }
+    }
+
+    /**
+     * A repurpose aimed at another account or another format has a back catalogue
+     * behind it that was never meant for these destinations, so the watermark
+     * moves to now instead of replaying it.
+     *
+     * @param  array<string, mixed>  $attributes
+     */
+    private static function watchesSomethingElse(Repurpose $repurpose, array $attributes): bool
+    {
+        return data_get($attributes, 'source_social_account_id', $repurpose->source_social_account_id) !== $repurpose->source_social_account_id
+            || data_get($attributes, 'source_format', $repurpose->source_format->value) !== $repurpose->source_format->value;
+    }
+}