An open-source, self-hostable PaaS alternative to Vercel, Heroku & Netlify that lets you easily deploy static sites, databases, full-stack applications and 360+ one-click services on your own servers.
PHP coolifydatabasesdeploymentdockerdocker-composeinertiajslaravelmariadbmysqlnextjsnodejsphppostgresredisself-hostedself-hostingserverstatic-sitesveltesvelte5
feat(servers): add cross-instance server migration (#11075)
Andras Bacsaif9caa5250dcb
diff --git a/.gitignore b/.gitignoreindex 086b946d0b..460009bd98 100644--- a/.gitignore+++ b/.gitignore@@ -48,3 +48,6 @@ ref.dev/lima/ssh.config.dev/lima/ssh_key.dev/lima/hosts++# Multi-instance local Coolify env files (scripts/dev-instances)+.dev-instances/diff --git a/AGENTS.md b/AGENTS.mdindex 566d797770..076c30b483 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -18,9 +18,17 @@ Docker Compose-based dev setup with services: coolify (app), postgres, redis, so# Start dev environment (uses docker-compose.dev.yml)spin up # or: docker compose -f docker-compose.dev.yml up -dspin down # stop services++# Two local Coolify instances (isolated stacks; server transfer / multi-control-plane)+./scripts/dev-instances up # a:8000 + b:8001 (uses npm run build for CSS/JS)+./scripts/dev-instances up a --with vite # HMR only when starting a single instance+./scripts/dev-instances urls+./scripts/dev-instances down+# Compose: docker-compose.dev-multi.yml Env: .dev-instances/{a,b}.env (gitignored)+# Note: dual Vite HMR is unsupported (shared public/hot); multi-instance always uses public/build.```-The app runs at `localhost:8000` by default. Vite dev server on port 5173.+The app runs at `localhost:8000` by default. Instance **b** is on `8001` (db `5433`, redis `6380`, …); see `./scripts/dev-instances`.## Common Commandsdiff --git a/app/Actions/Server/ValidateServer.php b/app/Actions/Server/ValidateServer.phpindex 378998fe7d..9bb15c2053 100644--- a/app/Actions/Server/ValidateServer.php+++ b/app/Actions/Server/ValidateServer.php@@ -25,6 +25,15 @@ class ValidateServerpublic function handle(Server $server){+ if (! $server->canBeValidated()) {+ $this->error = 'This server was transferred to another Coolify instance and cannot be revalidated here.';+ $server->update([+ 'validation_logs' => $this->error,+ 'is_validating' => false,+ ]);+ throw new \Exception($this->error);+ }+$server->update(['validation_logs' => null,]);diff --git a/app/Http/Controllers/Api/ServerTransferController.php b/app/Http/Controllers/Api/ServerTransferController.phpnew file mode 100644index 0000000000..5c4d675110--- /dev/null+++ b/app/Http/Controllers/Api/ServerTransferController.php@@ -0,0 +1,510 @@+<?php++namespace App\Http\Controllers\Api;++use App\Http\Controllers\Controller;+use App\Models\Server;+use App\Services\ServerTransfer\ServerTransferBundle;+use App\Services\ServerTransfer\ServerTransferClaimer;+use App\Services\ServerTransfer\ServerTransferExporter;+use App\Services\ServerTransfer\ServerTransferImporter;+use App\Services\ServerTransfer\ServerTransferMigrator;+use Illuminate\Http\JsonResponse;+use Illuminate\Http\Request;+use Illuminate\Validation\ValidationException;+use OpenApi\Attributes as OA;+use Throwable;++class ServerTransferController extends Controller+{+ public function __construct(+ private ServerTransferExporter $exporter,+ private ServerTransferImporter $importer,+ private ServerTransferClaimer $claimer,+ private ServerTransferMigrator $migrator,+ ) {+ abort_unless(isDev(), 404);+ }++ #[OA\Post(+ summary: 'Migrate server to another Coolify instance',+ description: 'One-shot handoff: export this server, import+claim on the target instance (using the provided token), then disable automations here. Requires read:sensitive and write.',+ path: '/servers/{uuid}/migrate',+ operationId: 'migrate-server-between-instances',+ security: [['bearerAuth' => []]],+ tags: ['Servers'],+ parameters: [+ new OA\Parameter(name: 'uuid', in: 'path', required: true, schema: new OA\Schema(type: 'string')),+ ],+ requestBody: new OA\RequestBody(+ required: true,+ content: new OA\JsonContent(+ required: ['target_url', 'target_token'],+ properties: [+ new OA\Property(property: 'target_url', type: 'string', example: 'https://coolify-b.example.com'),+ new OA\Property(property: 'target_token', type: 'string', description: 'API token on the target instance (root or write)'),+ new OA\Property(property: 'write_remote', type: 'boolean', default: false),+ new OA\Property(property: 'rebind_sentinel', type: 'boolean', default: true),+ new OA\Property(property: 'preserve_uuids', type: 'boolean', default: true),+ new OA\Property(property: 'adopt_mode', type: 'boolean', default: true),+ ]+ )+ ),+ responses: [+ new OA\Response(response: 200, description: 'Migrated'),+ new OA\Response(response: 403, description: 'Missing sensitive permission'),+ new OA\Response(response: 404, ref: '#/components/responses/404'),+ new OA\Response(response: 422, description: 'Validation or remote import failed'),+ ]+ )]+ public function migrate(Request $request, string $uuid): JsonResponse+ {+ $teamId = getTeamIdFromToken();+ if (is_null($teamId)) {+ return invalidTokenResponse();+ }++ if (! $this->canReadSensitive($request)) {+ return response()->json([+ 'message' => 'Migrating a server requires a token with read:sensitive (or root) ability and an admin/owner team role.',+ ], 403);+ }++ $server = Server::whereTeamId($teamId)->whereUuid($uuid)->first();+ if (! $server) {+ return response()->json(['message' => 'Server not found.'], 404);+ }++ $this->authorize('update', $server);++ $return = validateIncomingRequest($request);+ if ($return instanceof JsonResponse) {+ return $return;+ }++ $validator = customApiValidator($request->all(), [+ 'target_url' => 'required|string|url',+ 'target_token' => 'required|string',+ 'write_remote' => 'boolean|nullable',+ 'rebind_sentinel' => 'boolean|nullable',+ 'preserve_uuids' => 'boolean|nullable',+ 'adopt_mode' => 'boolean|nullable',+ ]);+ $allowedFields = ['target_url', 'target_token', 'write_remote', 'rebind_sentinel', 'preserve_uuids', 'adopt_mode'];+ $extraFields = array_diff(array_keys($request->all()), $allowedFields);+ if ($validator->fails() || $extraFields !== []) {+ $errors = $validator->errors();+ foreach ($extraFields as $field) {+ $errors->add($field, 'This field is not allowed.');+ }++ return response()->json([+ 'message' => 'Validation failed.',+ 'errors' => $errors,+ ], 422);+ }++ try {+ $result = $this->migrator->migrate(+ server: $server,+ targetUrl: $request->string('target_url')->toString(),+ targetToken: $request->string('target_token')->toString(),+ writeRemote: $request->boolean('write_remote', false),+ rebindSentinel: $request->boolean('rebind_sentinel', true),+ preserveUuids: $request->boolean('preserve_uuids', true),+ adoptMode: $request->boolean('adopt_mode', true),+ );+ } catch (Throwable $e) {+ return response()->json(['message' => $e->getMessage()], 422);+ }++ auditLog('api.server.migrate', [+ 'team_id' => $teamId,+ 'server_uuid' => $server->uuid,+ 'export_id' => $result['export_id'],+ 'target_url' => $result['target_url'],+ ]);++ return response()->json($result);+ }++ #[OA\Get(+ summary: 'Export server transfer bundle',+ description: 'Export a server and all resources hosted on it as a versioned transfer bundle for moving between Coolify instances. Requires read:sensitive.',+ path: '/servers/{uuid}/export',+ operationId: 'export-server-transfer-bundle',+ security: [['bearerAuth' => []]],+ tags: ['Servers'],+ parameters: [+ new OA\Parameter(name: 'uuid', in: 'path', required: true, schema: new OA\Schema(type: 'string')),+ new OA\Parameter(name: 'encrypt', in: 'query', required: false, description: 'If true and passphrase is provided, return an encrypted envelope.', schema: new OA\Schema(type: 'boolean')),+ new OA\Parameter(name: 'passphrase', in: 'query', required: false, description: 'Passphrase used when encrypt=true.', schema: new OA\Schema(type: 'string')),+ ],+ responses: [+ new OA\Response(response: 200, description: 'Transfer bundle'),+ new OA\Response(response: 401, ref: '#/components/responses/401'),+ new OA\Response(response: 403, description: 'Missing sensitive permission'),+ new OA\Response(response: 404, ref: '#/components/responses/404'),+ ]+ )]+ public function export(Request $request, string $uuid): JsonResponse+ {+ $teamId = getTeamIdFromToken();+ if (is_null($teamId)) {+ return invalidTokenResponse();+ }++ if (! $this->canReadSensitive($request)) {+ return response()->json([+ 'message' => 'Exporting a server requires a token with read:sensitive (or root) ability and an admin/owner team role.',+ ], 403);+ }++ $server = Server::whereTeamId($teamId)->whereUuid($uuid)->first();+ if (! $server) {+ return response()->json(['message' => 'Server not found.'], 404);+ }++ $this->authorize('view', $server);++ try {+ $bundle = $this->exporter->export($server, includeSensitive: true);+ } catch (Throwable $e) {+ return response()->json(['message' => $e->getMessage()], 422);+ }++ auditLog('api.server.export', [+ 'team_id' => $teamId,+ 'server_uuid' => $server->uuid,+ 'export_id' => data_get($bundle, 'export_id'),+ ]);++ if ($request->boolean('encrypt') && $request->filled('passphrase')) {+ return response()->json(+ ServerTransferBundle::encryptWithPassphrase($bundle, $request->string('passphrase')->toString())+ );+ }++ return response()->json($bundle);+ }++ #[OA\Post(+ summary: 'Import server transfer bundle',+ description: 'Import a server transfer bundle into this Coolify instance (adopt mode by default).',+ path: '/servers/import',+ operationId: 'import-server-transfer-bundle',+ security: [['bearerAuth' => []]],+ tags: ['Servers'],+ requestBody: new OA\RequestBody(+ required: true,+ content: new OA\JsonContent(+ properties: [+ new OA\Property(property: 'bundle', type: 'object', description: 'Plain or encrypted transfer bundle'),+ new OA\Property(property: 'passphrase', type: 'string', nullable: true),+ new OA\Property(property: 'dry_run', type: 'boolean', default: false),+ new OA\Property(property: 'preserve_uuids', type: 'boolean', default: true),+ new OA\Property(property: 'adopt_mode', type: 'boolean', default: true, description: 'Import without forcing redeploy; keep statuses for adoption'),+ new OA\Property(property: 'claim', type: 'boolean', default: true, description: 'Automatically claim the host for this instance after import'),+ new OA\Property(property: 'write_remote', type: 'boolean', default: false, description: 'When claiming, write ownership file on the host via SSH'),+ new OA\Property(property: 'rebind_sentinel', type: 'boolean', default: true, description: 'When claiming, rebind Sentinel to this instance'),+ ]+ )+ ),+ responses: [+ new OA\Response(response: 200, description: 'Dry-run result'),+ new OA\Response(response: 201, description: 'Imported'),+ new OA\Response(response: 401, ref: '#/components/responses/401'),+ new OA\Response(response: 422, description: 'Validation failed'),+ ]+ )]+ public function import(Request $request): JsonResponse+ {+ $teamId = getTeamIdFromToken();+ if (is_null($teamId)) {+ return invalidTokenResponse();+ }++ $this->authorize('create', Server::class);++ $return = validateIncomingRequest($request);+ if ($return instanceof JsonResponse) {+ return $return;+ }++ $validator = customApiValidator($request->all(), [+ 'bundle' => 'required|array',+ 'passphrase' => 'string|nullable',+ 'dry_run' => 'boolean|nullable',+ 'preserve_uuids' => 'boolean|nullable',+ 'adopt_mode' => 'boolean|nullable',+ 'claim' => 'boolean|nullable',+ 'write_remote' => 'boolean|nullable',+ 'rebind_sentinel' => 'boolean|nullable',+ ]);+ $allowedFields = ['bundle', 'passphrase', 'dry_run', 'preserve_uuids', 'adopt_mode', 'claim', 'write_remote', 'rebind_sentinel'];+ $extraFields = array_diff(array_keys($request->all()), $allowedFields);+ if ($validator->fails() || $extraFields !== []) {+ $errors = $validator->errors();+ foreach ($extraFields as $field) {+ $errors->add($field, 'This field is not allowed.');+ }++ return response()->json([+ 'message' => 'Validation failed.',+ 'errors' => $errors,+ ], 422);+ }++ $bundle = $request->input('bundle', []);+ if (data_get($bundle, 'encrypted')) {+ if (! $request->filled('passphrase')) {+ return response()->json(['message' => 'Passphrase is required for encrypted bundles.'], 422);+ }+ try {+ $bundle = ServerTransferBundle::decryptWithPassphrase($bundle, $request->string('passphrase')->toString());+ } catch (Throwable $e) {+ return response()->json(['message' => $e->getMessage()], 422);+ }+ }++ try {+ $result = $this->importer->import(+ bundle: $bundle,+ teamId: $teamId,+ dryRun: $request->boolean('dry_run', false),+ preserveUuids: $request->boolean('preserve_uuids', true),+ adoptMode: $request->boolean('adopt_mode', true),+ claim: $request->boolean('claim', true),+ writeRemote: $request->boolean('write_remote', false),+ rebindSentinel: $request->boolean('rebind_sentinel', true),+ );+ } catch (Throwable $e) {+ $status = $e instanceof ValidationException ? 422 : 422;+ $payload = ['message' => $e->getMessage()];+ if ($e instanceof ValidationException) {+ $payload['errors'] = $e->errors();+ }++ return response()->json($payload, $status);+ }++ auditLog('api.server.import', [+ 'team_id' => $teamId,+ 'server_uuid' => $result['server_uuid'],+ 'export_id' => $result['export_id'],+ 'dry_run' => $result['dry_run'],+ ]);++ return response()->json($result, $result['dry_run'] ? 200 : 201);+ }++ #[OA\Post(+ summary: 'Claim imported server',+ description: 'Claim a managed host for this instance: write ownership file and rebind Sentinel.',+ path: '/servers/{uuid}/claim',+ operationId: 'claim-server',+ security: [['bearerAuth' => []]],+ tags: ['Servers'],+ parameters: [+ new OA\Parameter(name: 'uuid', in: 'path', required: true, schema: new OA\Schema(type: 'string')),+ ],+ requestBody: new OA\RequestBody(+ content: new OA\JsonContent(+ properties: [+ new OA\Property(property: 'write_remote', type: 'boolean', default: true),+ new OA\Property(property: 'rebind_sentinel', type: 'boolean', default: true),+ ]+ )+ ),+ responses: [+ new OA\Response(response: 200, description: 'Claim result'),+ new OA\Response(response: 404, ref: '#/components/responses/404'),+ ]+ )]+ public function claim(Request $request, string $uuid): JsonResponse+ {+ $teamId = getTeamIdFromToken();+ if (is_null($teamId)) {+ return invalidTokenResponse();+ }++ $server = Server::whereTeamId($teamId)->whereUuid($uuid)->first();+ if (! $server) {+ return response()->json(['message' => 'Server not found.'], 404);+ }++ $this->authorize('update', $server);++ $validator = customApiValidator($request->all(), [+ 'write_remote' => 'boolean|nullable',+ 'rebind_sentinel' => 'boolean|nullable',+ ]);+ if ($validator->fails()) {+ return response()->json([+ 'message' => 'Validation failed.',+ 'errors' => $validator->errors(),+ ], 422);+ }++ try {+ $result = $this->claimer->claim(+ $server,+ writeRemote: $request->boolean('write_remote', true),+ rebindSentinel: $request->boolean('rebind_sentinel', true),+ );+ } catch (Throwable $e) {+ return response()->json(['message' => $e->getMessage()], 422);+ }++ auditLog('api.server.claim', [+ 'team_id' => $teamId,+ 'server_uuid' => $server->uuid,+ 'claim_written' => $result['claim_written'],+ ]);++ return response()->json($result);+ }++ #[OA\Post(+ summary: 'Mark server transferred',+ description: 'Source-instance step: disable automations after a successful export/import handoff.',+ path: '/servers/{uuid}/transfer/complete',+ operationId: 'complete-server-transfer',+ security: [['bearerAuth' => []]],+ tags: ['Servers'],+ parameters: [+ new OA\Parameter(name: 'uuid', in: 'path', required: true, schema: new OA\Schema(type: 'string')),+ ],+ requestBody: new OA\RequestBody(+ content: new OA\JsonContent(+ properties: [+ new OA\Property(property: 'export_id', type: 'string', nullable: true),+ new OA\Property(property: 'target_instance_url', type: 'string', nullable: true),+ ]+ )+ ),+ responses: [+ new OA\Response(response: 200, description: 'Marked transferred'),+ new OA\Response(response: 404, ref: '#/components/responses/404'),+ ]+ )]+ public function complete(Request $request, string $uuid): JsonResponse+ {+ $teamId = getTeamIdFromToken();+ if (is_null($teamId)) {+ return invalidTokenResponse();+ }++ $server = Server::whereTeamId($teamId)->whereUuid($uuid)->first();+ if (! $server) {+ return response()->json(['message' => 'Server not found.'], 404);+ }++ $this->authorize('update', $server);++ $validator = customApiValidator($request->all(), [+ 'export_id' => 'string|nullable',+ 'target_instance_url' => 'string|nullable',+ ]);+ if ($validator->fails()) {+ return response()->json([+ 'message' => 'Validation failed.',+ 'errors' => $validator->errors(),+ ], 422);+ }++ try {+ $result = $this->claimer->markTransferred(+ $server,+ exportId: $request->input('export_id'),+ targetInstanceUrl: $request->input('target_instance_url'),+ );+ } catch (Throwable $e) {+ return response()->json(['message' => $e->getMessage()], 422);+ }++ auditLog('api.server.transfer_complete', [+ 'team_id' => $teamId,+ 'server_uuid' => $server->uuid,+ 'export_id' => $request->input('export_id'),+ ]);++ return response()->json($result);+ }++ #[OA\Post(+ summary: 'Write transfer bundle to server mailbox',+ description: 'Write an export bundle to /data/coolify/exports on the managed host for air-gapped import.',+ path: '/servers/{uuid}/export/mailbox',+ operationId: 'export-server-transfer-mailbox',+ security: [['bearerAuth' => []]],+ tags: ['Servers'],+ parameters: [+ new OA\Parameter(name: 'uuid', in: 'path', required: true, schema: new OA\Schema(type: 'string')),+ ],+ requestBody: new OA\RequestBody(+ content: new OA\JsonContent(+ properties: [+ new OA\Property(property: 'passphrase', type: 'string', nullable: true),+ ]+ )+ ),+ responses: [+ new OA\Response(response: 200, description: 'Mailbox write result'),+ new OA\Response(response: 403, description: 'Missing sensitive permission'),+ new OA\Response(response: 404, ref: '#/components/responses/404'),+ ]+ )]+ public function writeMailbox(Request $request, string $uuid): JsonResponse+ {+ $teamId = getTeamIdFromToken();+ if (is_null($teamId)) {+ return invalidTokenResponse();+ }++ if (! $this->canReadSensitive($request)) {+ return response()->json([+ 'message' => 'Writing a transfer mailbox requires read:sensitive (or root) ability and an admin/owner team role.',+ ], 403);+ }++ $server = Server::whereTeamId($teamId)->whereUuid($uuid)->first();+ if (! $server) {+ return response()->json(['message' => 'Server not found.'], 404);+ }++ $this->authorize('view', $server);++ try {+ $bundle = $this->exporter->export($server, includeSensitive: true);+ $result = $this->claimer->writeMailbox(+ $server,+ $bundle,+ $request->filled('passphrase') ? $request->string('passphrase')->toString() : null,+ );+ } catch (Throwable $e) {+ return response()->json(['message' => $e->getMessage()], 422);+ }++ auditLog('api.server.export_mailbox', [+ 'team_id' => $teamId,+ 'server_uuid' => $server->uuid,+ 'export_id' => data_get($bundle, 'export_id'),+ 'path' => $result['path'],+ ]);++ return response()->json([+ 'export_id' => data_get($bundle, 'export_id'),+ 'path' => $result['path'],+ 'written' => $result['written'],+ 'message' => $result['written']+ ? 'Transfer bundle written to server mailbox.'+ : 'Failed to write mailbox on remote host.',+ ], $result['written'] ? 200 : 422);+ }++ private function canReadSensitive(Request $request): bool+ {+ return (bool) $request->attributes->get('can_read_sensitive', false);+ }+}diff --git a/app/Http/Controllers/Api/ServersController.php b/app/Http/Controllers/Api/ServersController.phpindex 256a07eb48..d50a5226a9 100644--- a/app/Http/Controllers/Api/ServersController.php+++ b/app/Http/Controllers/Api/ServersController.php@@ -970,6 +970,12 @@ class ServersController extends Controller}$this->authorize('update', $server);+ if (! $server->canBeValidated()) {+ return response()->json([+ 'message' => 'This server was transferred to another Coolify instance and cannot be revalidated here.',+ ], 422);+ }+$validator = customApiValidator($request->all(), ['install' => 'boolean',]);diff --git a/app/Jobs/ValidateAndInstallServerJob.php b/app/Jobs/ValidateAndInstallServerJob.phpindex ee8cf27970..af2588ddaf 100644--- a/app/Jobs/ValidateAndInstallServerJob.php+++ b/app/Jobs/ValidateAndInstallServerJob.php@@ -33,6 +33,19 @@ class ValidateAndInstallServerJob implements ShouldBeEncrypted, ShouldQueuepublic function handle(): void{try {+ if (! $this->server->canBeValidated()) {+ $message = 'This server was transferred to another Coolify instance and cannot be revalidated here.';+ $this->server->update([+ 'validation_logs' => $message,+ 'is_validating' => false,+ ]);+ Log::warning('ValidateAndInstallServer: blocked for transferred server', [+ 'server_id' => $this->server->id,+ ]);++ return;+ }+// Mark validation as in progress$this->server->update(['is_validating' => true]);diff --git a/app/Livewire/Server/Show.php b/app/Livewire/Server/Show.phpindex 1090e98921..9678cb8d7b 100644--- a/app/Livewire/Server/Show.php+++ b/app/Livewire/Server/Show.php@@ -327,6 +327,15 @@ class Show extends Component{try {$this->authorize('update', $this->server);+ if (! $this->server->canBeValidated()) {+ $this->dispatch(+ 'error',+ 'Cannot revalidate',+ 'This server was transferred to another Coolify instance. Manage it from the target instance instead.'+ );++ return;+ }if ($this->server->vultr_instance_id) {$status = $this->server->refreshVultrState();$this->server->refresh();diff --git a/app/Livewire/Server/Transfer.php b/app/Livewire/Server/Transfer.phpnew file mode 100644index 0000000000..0573aba0f7--- /dev/null+++ b/app/Livewire/Server/Transfer.php@@ -0,0 +1,198 @@+<?php++namespace App\Livewire\Server;++use App\Models\Server;+use App\Services\ServerTransfer\ServerTransferBundle;+use App\Services\ServerTransfer\ServerTransferClaimer;+use App\Services\ServerTransfer\ServerTransferExporter;+use App\Services\ServerTransfer\ServerTransferMigrator;+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;+use Livewire\Component;+use Throwable;++class Transfer extends Component+{+ use AuthorizesRequests;++ public Server $server;++ /** Primary one-click migrate fields */+ public string $targetUrl = '';++ public string $targetToken = '';++ public bool $writeRemote = false;++ /** Advanced */+ public bool $showAdvanced = false;++ public string $passphrase = '';++ public bool $encryptBundle = false;++ public bool $writeRemoteOnClaim = false;++ public bool $rebindSentinelOnClaim = true;++ public ?string $exportId = null;++ /** @var list<string> */+ public array $lastWarnings = [];++ public ?string $lastResultJson = null;++ public function mount(string $server_uuid): void+ {+ $this->ensureDevelopmentAvailability();++ try {+ $this->server = Server::ownedByCurrentTeam()->whereUuid($server_uuid)->firstOrFail();+ $this->authorize('view', $this->server);+ $this->exportId = data_get($this->server->server_metadata, 'transfer.export_id');+ } catch (Throwable $e) {+ handleError($e, $this);+ $this->redirect(route('server.index'), navigate: true);+ }+ }++ public function getTransferStatusProperty(): ?string+ {+ return data_get($this->server->fresh()->server_metadata, 'transfer.status');+ }++ public function getIsLocalhostProperty(): bool+ {+ return (int) $this->server->id === 0;+ }++ public function migrateServer(ServerTransferMigrator $migrator): void+ {+ $this->ensureDevelopmentAvailability();++ try {+ $this->authorize('update', $this->server);+ if ($this->isLocalhost) {+ throw new \RuntimeException('The Coolify host (localhost) cannot be transferred.');+ }++ $result = $migrator->migrate(+ server: $this->server,+ targetUrl: $this->targetUrl,+ targetToken: $this->targetToken,+ writeRemote: $this->writeRemote,+ );++ $this->server->refresh();+ $this->exportId = $result['export_id'] ?? $this->exportId;+ $this->lastWarnings = array_values((array) data_get($result, 'warnings', []));+ // Never echo the target token in the result dump.+ $safe = $result;+ unset($safe['target_token']);+ $this->lastResultJson = json_encode($safe, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);+ $this->targetToken = '';+ $this->dispatch('success', $result['message'] ?? 'Server transferred.');+ } catch (Throwable $e) {+ handleError($e, $this);+ }+ }++ public function exportBundle(ServerTransferExporter $exporter)+ {+ $this->ensureDevelopmentAvailability();++ try {+ $this->authorize('view', $this->server);+ if ($this->isLocalhost) {+ throw new \RuntimeException('The Coolify host (localhost) cannot be transferred.');+ }++ $bundle = $exporter->export($this->server, includeSensitive: true);+ $this->exportId = data_get($bundle, 'export_id');+ $this->lastWarnings = array_values((array) data_get($bundle, 'warnings', []));+ $this->lastResultJson = null;++ $payload = $bundle;+ $fileName = 'server-transfer-'.$this->server->uuid.'.json';+ if ($this->encryptBundle) {+ if (blank($this->passphrase)) {+ throw new \RuntimeException('Passphrase is required to encrypt the bundle.');+ }+ $payload = ServerTransferBundle::encryptWithPassphrase($bundle, $this->passphrase);+ $fileName = 'server-transfer-'.$this->server->uuid.'.encrypted.json';+ }++ $json = json_encode($payload, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);+ if ($json === false) {+ throw new \RuntimeException('Failed to encode transfer bundle.');+ }++ $this->dispatch('success', 'Transfer bundle ready for download.');++ return response()->streamDownload(function () use ($json) {+ echo $json;+ }, $fileName, [+ 'Content-Type' => 'application/json',+ ]);+ } catch (Throwable $e) {+ return handleError($e, $this);+ }+ }++ public function completeTransfer(ServerTransferClaimer $claimer): void+ {+ $this->ensureDevelopmentAvailability();++ try {+ $this->authorize('update', $this->server);+ if ($this->isLocalhost) {+ throw new \RuntimeException('The Coolify host cannot be marked as transferred.');+ }++ $result = $claimer->markTransferred(+ $this->server,+ exportId: $this->exportId ?: data_get($this->server->server_metadata, 'transfer.export_id'),+ targetInstanceUrl: filled($this->targetUrl) ? rtrim($this->targetUrl, '/') : null,+ );+ $this->server->refresh();+ $this->lastResultJson = json_encode($result, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);+ $this->dispatch('success', $result['message'] ?? 'Server marked as transferred.');+ } catch (Throwable $e) {+ handleError($e, $this);+ }+ }++ public function claimServer(ServerTransferClaimer $claimer): void+ {+ $this->ensureDevelopmentAvailability();++ try {+ $this->authorize('update', $this->server);+ if ($this->isLocalhost) {+ throw new \RuntimeException('The Coolify host cannot be claimed.');+ }++ $result = $claimer->claim(+ $this->server,+ writeRemote: $this->writeRemoteOnClaim,+ rebindSentinel: $this->rebindSentinelOnClaim,+ );+ $this->server->refresh();+ $this->lastResultJson = json_encode($result, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);+ $this->lastWarnings = [];+ $this->dispatch('success', $result['message'] ?? 'Server claimed.');+ } catch (Throwable $e) {+ handleError($e, $this);+ }+ }++ public function render()+ {+ return view('livewire.server.transfer');+ }++ private function ensureDevelopmentAvailability(): void+ {+ abort_unless(isDev(), 404);+ }+}diff --git a/app/Livewire/Server/TransferImport.php b/app/Livewire/Server/TransferImport.phpnew file mode 100644index 0000000000..db8999c268--- /dev/null+++ b/app/Livewire/Server/TransferImport.php@@ -0,0 +1,147 @@+<?php++namespace App\Livewire\Server;++use App\Models\Server;+use App\Services\ServerTransfer\ServerTransferBundle;+use App\Services\ServerTransfer\ServerTransferImporter;+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;+use Livewire\Component;+use Livewire\Features\SupportFileUploads\TemporaryUploadedFile;+use Livewire\WithFileUploads;+use Throwable;++class TransferImport extends Component+{+ use AuthorizesRequests;+ use WithFileUploads;++ public string $bundleJson = '';++ public string $passphrase = '';++ public bool $preserveUuids = true;++ public bool $adoptMode = true;++ /** Write ownership file on the host via SSH when claiming after import. */+ public bool $writeRemote = false;++ /** @var TemporaryUploadedFile|null */+ public $bundleFile = null;++ /** @var array<string, mixed>|null */+ public ?array $lastResult = null;++ /** @var list<string> */+ public array $lastWarnings = [];++ public ?string $importedServerUuid = null;++ public function mount(): void+ {+ $this->ensureDevelopmentAvailability();+ $this->authorize('create', Server::class);+ }++ public function updatedBundleFile(): void+ {+ $this->ensureDevelopmentAvailability();++ if (! $this->bundleFile) {+ return;+ }+ try {+ $contents = $this->bundleFile->get();+ if (! is_string($contents) || blank($contents)) {+ throw new \RuntimeException('Uploaded file is empty.');+ }+ $this->bundleJson = $contents;+ $this->dispatch('success', 'Bundle file loaded into the form.');+ } catch (Throwable $e) {+ handleError($e, $this);+ }+ }++ /**+ * @return array<string, mixed>+ */+ private function resolveBundle(): array+ {+ $raw = trim($this->bundleJson);+ if ($raw === '') {+ throw new \RuntimeException('Paste a transfer bundle JSON or upload a file.');+ }++ $decoded = json_decode($raw, true);+ if (! is_array($decoded)) {+ throw new \RuntimeException('Bundle is not valid JSON.');+ }++ if (data_get($decoded, 'encrypted')) {+ if (blank($this->passphrase)) {+ throw new \RuntimeException('Passphrase is required for encrypted bundles.');+ }++ return ServerTransferBundle::decryptWithPassphrase($decoded, $this->passphrase);+ }++ return $decoded;+ }++ public function dryRun(ServerTransferImporter $importer): void+ {+ $this->ensureDevelopmentAvailability();+ $this->runImport($importer, dryRun: true);+ }++ public function importBundle(ServerTransferImporter $importer): void+ {+ $this->ensureDevelopmentAvailability();+ $this->runImport($importer, dryRun: false);+ }++ private function runImport(ServerTransferImporter $importer, bool $dryRun): void+ {+ try {+ $this->authorize('create', Server::class);+ $teamId = currentTeam()->id;+ $bundle = $this->resolveBundle();++ $result = $importer->import(+ bundle: $bundle,+ teamId: $teamId,+ dryRun: $dryRun,+ preserveUuids: $this->preserveUuids,+ adoptMode: $this->adoptMode,+ claim: ! $dryRun,+ writeRemote: $this->writeRemote,+ rebindSentinel: true,+ );++ $this->lastResult = $result;+ $this->lastWarnings = array_values((array) data_get($result, 'warnings', []));+ $this->importedServerUuid = $dryRun ? null : data_get($result, 'server_uuid');++ if ($dryRun) {+ $this->dispatch('success', 'Dry run completed — nothing was written.');+ } elseif (data_get($result, 'claimed')) {+ $this->dispatch('success', 'Server imported and claimed for this instance.');+ } else {+ $this->dispatch('success', 'Server imported. Claim did not complete — check warnings or re-claim from the server Transfer page.');+ }+ } catch (Throwable $e) {+ handleError($e, $this);+ }+ }++ public function render()+ {+ return view('livewire.server.transfer-import');+ }++ private function ensureDevelopmentAvailability(): void+ {+ abort_unless(isDev(), 404);+ }+}diff --git a/app/Livewire/Server/ValidateAndInstall.php b/app/Livewire/Server/ValidateAndInstall.phpindex 9e6108de0f..c39f868baf 100644--- a/app/Livewire/Server/ValidateAndInstall.php+++ b/app/Livewire/Server/ValidateAndInstall.php@@ -53,6 +53,21 @@ class ValidateAndInstall extends Componentpublic function init(int $data = 0){+ if (! $this->server->canBeValidated()) {+ $this->error = 'This server was transferred to another Coolify instance and cannot be revalidated here.';+ $this->server->update([+ 'validation_logs' => $this->error,+ 'is_validating' => false,+ ]);+ $this->dispatch(+ 'error',+ 'Cannot revalidate',+ $this->error+ );++ return;+ }+$this->isInstalling = false;$this->uptime = null;$this->supported_os_type = null;diff --git a/app/Models/Server.php b/app/Models/Server.phpindex 3acaf35079..619382dfda 100644--- a/app/Models/Server.php+++ b/app/Models/Server.php@@ -862,8 +862,29 @@ $schema://$host {return $this->settings->force_disabled;}+ /**+ * Server was migrated away from this Coolify instance (source side).+ * Must not be revalidated or re-enabled as a live managed host.+ */+ public function isTransferredAway(): bool+ {+ return data_get($this->server_metadata, 'transfer.status') === 'transferred';+ }++ /**+ * Whether this server may be validated / installed against from this instance.+ */+ public function canBeValidated(): bool+ {+ return ! $this->isTransferredAway();+ }+public function forceEnableServer(){+ if ($this->isTransferredAway()) {+ return;+ }+$this->settings->force_disabled = false;$this->settings->save();}diff --git a/app/Services/ServerTransfer/ServerTransferBundle.php b/app/Services/ServerTransfer/ServerTransferBundle.phpnew file mode 100644index 0000000000..cbc1594034--- /dev/null+++ b/app/Services/ServerTransfer/ServerTransferBundle.php@@ -0,0 +1,181 @@+<?php++namespace App\Services\ServerTransfer;++use Illuminate\Support\Facades\Crypt;+use Illuminate\Validation\ValidationException;+use RuntimeException;++class ServerTransferBundle+{+ public const SCHEMA_VERSION = 1;++ public const CLAIM_PATH = '/data/coolify/instance-claim.json';++ public const MAILBOX_DIR = '/data/coolify/exports';++ /**+ * @param array<string, mixed> $payload+ */+ public static function wrap(array $payload): array+ {+ return array_merge([+ 'schema_version' => self::SCHEMA_VERSION,+ 'exported_at' => now()->toIso8601String(),+ 'export_id' => new_public_id(),+ ], $payload);+ }++ /**+ * @param array<string, mixed> $bundle+ * @return array{valid: bool, errors: list<string>, warnings: list<string>}+ */+ public static function validate(array $bundle): array+ {+ $errors = [];+ $warnings = [];++ if (! isset($bundle['schema_version'])) {+ $errors[] = 'Missing schema_version.';+ } elseif ((int) $bundle['schema_version'] !== self::SCHEMA_VERSION) {+ $errors[] = 'Unsupported schema_version '.$bundle['schema_version'].'. Expected '.self::SCHEMA_VERSION.'.';+ }++ if (! isset($bundle['export_id']) || ! is_string($bundle['export_id']) || $bundle['export_id'] === '') {+ $errors[] = 'Missing export_id.';+ }++ if (! isset($bundle['server']) || ! is_array($bundle['server'])) {+ $errors[] = 'Missing server payload.';+ } else {+ foreach (['uuid', 'name', 'ip', 'port', 'user'] as $field) {+ if (! array_key_exists($field, $bundle['server'])) {+ $errors[] = "Missing server.{$field}.";+ }+ }+ }++ if (! isset($bundle['private_key']) || ! is_array($bundle['private_key'])) {+ $errors[] = 'Missing private_key payload.';+ } else {+ if (blank(data_get($bundle, 'private_key.private_key'))) {+ $errors[] = 'Missing private_key.private_key material.';+ }+ }++ if (! isset($bundle['destinations']) || ! is_array($bundle['destinations'])) {+ $errors[] = 'Missing destinations array.';+ } elseif (count($bundle['destinations']) === 0) {+ $warnings[] = 'Bundle has no destinations; a default destination will be used.';+ }++ if (! isset($bundle['projects']) || ! is_array($bundle['projects'])) {+ $errors[] = 'Missing projects array.';+ }++ return [+ 'valid' => $errors === [],+ 'errors' => $errors,+ 'warnings' => $warnings,+ ];+ }++ /**+ * @param array<string, mixed> $bundle+ */+ public static function assertValid(array $bundle): void+ {+ $result = self::validate($bundle);+ if (! $result['valid']) {+ throw ValidationException::withMessages([+ 'bundle' => $result['errors'],+ ]);+ }+ }++ /**+ * Encrypt an entire bundle for mailbox/API transport with a user passphrase.+ *+ * @param array<string, mixed> $bundle+ * @return array{encrypted: true, schema_version: int, payload: string}+ */+ public static function encryptWithPassphrase(array $bundle, string $passphrase): array+ {+ if ($passphrase === '') {+ throw new RuntimeException('Passphrase must not be empty.');+ }++ $json = json_encode($bundle, JSON_THROW_ON_ERROR);+ $key = hash('sha256', $passphrase, true);+ $iv = random_bytes(16);+ $cipher = openssl_encrypt($json, 'AES-256-CBC', $key, OPENSSL_RAW_DATA, $iv);+ if ($cipher === false) {+ throw new RuntimeException('Failed to encrypt transfer bundle.');+ }++ $mac = hash_hmac('sha256', $iv.$cipher, $key);++ return [+ 'encrypted' => true,+ 'schema_version' => self::SCHEMA_VERSION,+ 'payload' => base64_encode($iv.$mac.$cipher),+ ];+ }++ /**+ * @param array<string, mixed> $encrypted+ * @return array<string, mixed>+ */+ public static function decryptWithPassphrase(array $encrypted, string $passphrase): array+ {+ if (! data_get($encrypted, 'encrypted')) {+ throw new RuntimeException('Bundle is not encrypted.');+ }++ $raw = base64_decode((string) data_get($encrypted, 'payload'), true);+ if ($raw === false || strlen($raw) < 48) {+ throw new RuntimeException('Invalid encrypted payload.');+ }++ $key = hash('sha256', $passphrase, true);+ $iv = substr($raw, 0, 16);+ $mac = substr($raw, 16, 64);+ $cipher = substr($raw, 80);+ $expectedMac = hash_hmac('sha256', $iv.$cipher, $key);+ if (! hash_equals($expectedMac, $mac)) {+ throw new RuntimeException('Invalid passphrase or corrupted bundle.');+ }++ $json = openssl_decrypt($cipher, 'AES-256-CBC', $key, OPENSSL_RAW_DATA, $iv);+ if ($json === false) {+ throw new RuntimeException('Failed to decrypt transfer bundle.');+ }++ /** @var array<string, mixed> $bundle */+ $bundle = json_decode($json, true, 512, JSON_THROW_ON_ERROR);++ return $bundle;+ }++ /**+ * Optionally re-seal secrets with Laravel's app key for intermediate storage.+ * Prefer passphrase encryption for cross-instance transfers.+ *+ * @param array<string, mixed> $bundle+ */+ public static function sealWithAppKey(array $bundle): string+ {+ return Crypt::encryptString(json_encode($bundle, JSON_THROW_ON_ERROR));+ }++ /**+ * @return array<string, mixed>+ */+ public static function unsealWithAppKey(string $sealed): array+ {+ /** @var array<string, mixed> $bundle */+ $bundle = json_decode(Crypt::decryptString($sealed), true, 512, JSON_THROW_ON_ERROR);++ return $bundle;+ }+}diff --git a/app/Services/ServerTransfer/ServerTransferClaimer.php b/app/Services/ServerTransfer/ServerTransferClaimer.phpnew file mode 100644index 0000000000..d1d984a191--- /dev/null+++ b/app/Services/ServerTransfer/ServerTransferClaimer.php@@ -0,0 +1,248 @@+<?php++namespace App\Services\ServerTransfer;++use App\Models\Server;+use Illuminate\Support\Facades\DB;+use Illuminate\Support\Facades\Log;+use RuntimeException;+use Throwable;++class ServerTransferClaimer+{+ /**+ * Claim a managed host for this Coolify instance.+ *+ * Database ownership (metadata + Sentinel settings) is committed in one transaction so a+ * mid-flight failure rolls back. Remote SSH claim-file writes happen after commit and are+ * best-effort — they cannot participate in the DB transaction.+ *+ * @return array{+ * server_uuid: string,+ * claim: array<string, mixed>,+ * sentinel_rebound: bool,+ * claim_written: bool,+ * message: string+ * }+ */+ public function claim(Server $server, bool $writeRemote = true, bool $rebindSentinel = true): array+ {+ if ($server->id === 0) {+ throw new RuntimeException('Cannot claim the Coolify host itself.');+ }++ $instanceUrl = rtrim((string) (instanceSettings()->fqdn ?: config('app.url')), '/');+ if ($instanceUrl === '') {+ throw new RuntimeException('Instance URL (FQDN or APP_URL) must be set before claiming a server.');+ }++ $exportId = data_get($server->server_metadata, 'transfer.export_id');++ $claim = [+ 'instance_url' => $instanceUrl,+ 'server_uuid' => $server->uuid,+ 'team_id' => $server->team_id,+ 'claimed_at' => now()->toIso8601String(),+ 'export_id' => $exportId,+ 'schema_version' => ServerTransferBundle::SCHEMA_VERSION,+ ];++ $result = DB::transaction(function () use ($server, $claim, $rebindSentinel, $instanceUrl) {+ $server = Server::query()->with('settings')->lockForUpdate()->findOrFail($server->id);++ $sentinelRebound = false;+ if ($rebindSentinel && $server->settings) {+ $server->settings->sentinel_custom_url = $instanceUrl;+ $server->settings->ensureValidSentinelToken();+ // Leave sentinel disabled until operator enables metrics; endpoint is ready.+ $server->settings->save();+ $sentinelRebound = true;+ }++ $metadata = $server->server_metadata ?? [];+ $metadata['transfer'] = array_merge((array) data_get($metadata, 'transfer', []), [+ 'status' => 'claimed',+ 'claimed_at' => $claim['claimed_at'],+ 'claim' => $claim,+ 'claim_written' => false,+ 'sentinel_rebound' => $sentinelRebound,+ ]);+ $server->server_metadata = $metadata;+ $server->save();++ return [+ 'server_uuid' => $server->uuid,+ 'claim' => $claim,+ 'sentinel_rebound' => $sentinelRebound,+ 'claim_written' => false,+ ];+ });++ // Remote host I/O is outside the transaction (cannot be rolled back with DB rows).+ $claimWritten = false;+ if ($writeRemote) {+ $claimWritten = $this->writeClaimFile($server, $claim);+ if ($claimWritten) {+ $this->persistClaimWritten($server);+ }+ }++ $result['claim_written'] = $claimWritten;+ $result['message'] = $claimWritten+ ? 'Server claimed. Ownership file written and Sentinel rebound to this instance.'+ : 'Server claimed in Coolify. Remote ownership file was not written (SSH unavailable or skipped).';++ return $result;+ }++ /**+ * Mark a server as transferred away from this instance (source side).+ * Disables automations to prevent dual management.+ *+ * All database writes run in one transaction so partial disable state cannot stick on failure.+ * Local SSH key cache cleanup runs after commit (filesystem; not transactional).+ *+ * @return array{server_uuid: string, message: string}+ */+ public function markTransferred(Server $server, ?string $exportId = null, ?string $targetInstanceUrl = null): array+ {+ if ($server->id === 0) {+ throw new RuntimeException('Cannot transfer the Coolify host itself.');+ }++ $result = DB::transaction(function () use ($server, $exportId, $targetInstanceUrl) {+ $server = Server::query()->with('settings')->lockForUpdate()->findOrFail($server->id);++ if ($server->settings) {+ $server->settings->force_disabled = true;+ $server->settings->is_sentinel_enabled = false;+ $server->settings->save();+ }++ $metadata = $server->server_metadata ?? [];+ $metadata['transfer'] = array_merge((array) data_get($metadata, 'transfer', []), [+ 'status' => 'transferred',+ 'export_id' => $exportId ?? data_get($metadata, 'transfer.export_id'),+ 'target_instance_url' => $targetInstanceUrl,+ 'transferred_at' => now()->toIso8601String(),+ ]);+ $server->server_metadata = $metadata;+ $server->save();++ return [+ 'server_uuid' => $server->uuid,+ 'message' => 'Server marked as transferred. Automations disabled on this instance.',+ ];+ });++ $this->clearLocalSshArtifacts($server);++ return $result;+ }++ private function persistClaimWritten(Server $server): void+ {+ DB::transaction(function () use ($server) {+ $server = Server::query()->lockForUpdate()->find($server->id);+ if (! $server) {+ return;+ }++ $metadata = $server->server_metadata ?? [];+ data_set($metadata, 'transfer.claim_written', true);+ $server->server_metadata = $metadata;+ $server->save();+ });+ }++ /**+ * Best-effort local SSH mux/key cleanup after transfer (filesystem; not part of DB rollback).+ * forceDisableServer is idempotent for force_disabled and also clears cached SSH key material.+ */+ private function clearLocalSshArtifacts(Server $server): void+ {+ try {+ $server->refresh();+ $server->forceDisableServer();+ } catch (Throwable $e) {+ Log::warning('Failed to clear local SSH artifacts after transfer', [+ 'server_uuid' => $server->uuid,+ 'error' => $e->getMessage(),+ ]);+ }+ }++ /**+ * Write export bundle to the managed host mailbox (air-gapped transfer).+ *+ * @param array<string, mixed> $bundle+ * @return array{path: string, written: bool}+ */+ public function writeMailbox(Server $server, array $bundle, ?string $passphrase = null): array+ {+ ServerTransferBundle::assertValid($bundle);++ $exportId = (string) data_get($bundle, 'export_id', new_public_id());+ $filename = "server-transfer-{$exportId}.coolify.json";+ $path = ServerTransferBundle::MAILBOX_DIR.'/'.$filename;++ $payload = $passphrase+ ? ServerTransferBundle::encryptWithPassphrase($bundle, $passphrase)+ : $bundle;++ $json = json_encode($payload, JSON_THROW_ON_ERROR | JSON_UNESCAPED_SLASHES);+ $b64 = base64_encode($json);++ $written = false;+ try {+ instant_remote_process([+ 'mkdir -p '.escapeshellarg(ServerTransferBundle::MAILBOX_DIR),+ 'echo '.escapeshellarg($b64).' | base64 -d > '.escapeshellarg($path),+ 'chmod 600 '.escapeshellarg($path),+ 'chown 9999:root '.escapeshellarg($path).' || true',+ ], $server, true);+ $written = true;+ } catch (Throwable $e) {+ Log::warning('Failed to write server transfer mailbox', [+ 'server_uuid' => $server->uuid,+ 'error' => $e->getMessage(),+ ]);+ if (! app()->runningUnitTests()) {+ throw $e;+ }+ }++ return [+ 'path' => $path,+ 'written' => $written,+ ];+ }++ /**+ * @param array<string, mixed> $claim+ */+ private function writeClaimFile(Server $server, array $claim): bool+ {+ $json = json_encode($claim, JSON_THROW_ON_ERROR | JSON_UNESCAPED_SLASHES);+ $b64 = base64_encode($json);+ $path = ServerTransferBundle::CLAIM_PATH;++ try {+ instant_remote_process([+ 'mkdir -p /data/coolify',+ 'echo '.escapeshellarg($b64).' | base64 -d > '.escapeshellarg($path),+ 'chmod 600 '.escapeshellarg($path),+ 'chown 9999:root '.escapeshellarg($path).' || true',+ ], $server, true);++ return true;+ } catch (Throwable $e) {+ Log::warning('Failed to write instance claim file', [+ 'server_uuid' => $server->uuid,+ 'error' => $e->getMessage(),+ ]);++ return false;+ }+ }+}diff --git a/app/Services/ServerTransfer/ServerTransferExporter.php b/app/Services/ServerTransfer/ServerTransferExporter.phpnew file mode 100644index 0000000000..bd67f8e39a--- /dev/null+++ b/app/Services/ServerTransfer/ServerTransferExporter.php@@ -0,0 +1,1255 @@+<?php++namespace App\Services\ServerTransfer;++use App\Models\Application;+use App\Models\ApplicationPreview;+use App\Models\CloudProviderToken;+use App\Models\Environment;+use App\Models\EnvironmentVariable;+use App\Models\GithubApp;+use App\Models\GitlabApp;+use App\Models\LocalFileVolume;+use App\Models\LocalPersistentVolume;+use App\Models\PrivateKey;+use App\Models\Project;+use App\Models\S3Storage;+use App\Models\ScheduledDatabaseBackup;+use App\Models\ScheduledTask;+use App\Models\Server;+use App\Models\Service;+use App\Models\SharedEnvironmentVariable;+use App\Models\StandaloneDocker;+use App\Models\SwarmDocker;+use App\Models\Tag;+use Illuminate\Database\Eloquent\Model;+use Illuminate\Support\Collection;+use Illuminate\Support\Facades\DB;+use Illuminate\Support\Facades\Schema;+use RuntimeException;++class ServerTransferExporter+{+ /**+ * Settings that are instance-bound or runtime health state and must not transfer.+ *+ * @var list<string>+ */+ private const SKIP_SERVER_SETTINGS = [+ 'id',+ 'server_id',+ 'created_at',+ 'updated_at',+ 'is_reachable',+ 'is_usable',+ 'force_disabled',+ 'sentinel_token',+ 'sentinel_custom_url',+ 'is_sentinel_enabled',+ 'is_sentinel_debug_enabled',+ ];++ /**+ * Application attributes that are relational FKs remapped on import.+ *+ * @var list<string>+ */+ private const SKIP_APPLICATION_ATTRS = [+ 'id',+ 'created_at',+ 'updated_at',+ 'deleted_at',+ 'environment_id',+ 'destination_id',+ 'destination_type',+ 'source_id',+ 'source_type',+ 'private_key_id',+ 'additional_servers_count',+ 'additional_networks_count',+ 'server_status',+ ];++ /**+ * @return array<string, mixed>+ */+ public function export(Server $server, bool $includeSensitive = true): array+ {+ if ($server->id === 0) {+ throw new RuntimeException('The Coolify host (localhost) cannot be transferred between instances.');+ }++ $server->loadMissing(['settings', 'privateKey', 'standaloneDockers', 'swarmDockers', 'cloudProviderToken', 'sslCertificates']);++ $privateKey = $server->privateKey;+ if (! $privateKey instanceof PrivateKey) {+ throw new RuntimeException('Server has no private key to export.');+ }++ if (! $includeSensitive) {+ throw new RuntimeException('Server transfer export requires sensitive data access (read:sensitive).');+ }++ // applications() also includes multi-destination attachments on this server;+ // unique by id so a multi-dest app is only considered once for validation/export.+ $applications = $server->applications()->unique('id')->values();+ $databases = collect($server->databases())->unique(fn ($db) => $db::class.':'.$db->id)->values();+ $services = $server->services()->get()->unique('id')->values();++ $this->assertNoAdditionalDestinations($server, $applications);++ $projectIds = $this->collectProjectIds($applications, $databases, $services);+ $projects = Project::query()->whereIn('id', $projectIds)->orderBy('name')->get();++ $destinationUuidByKey = $this->destinationUuidMap($server);+ $dependencies = $this->collectDependencies($server, $applications, $databases, $services);++ $sourceInstanceUrl = rtrim((string) (instanceSettings()->fqdn ?: config('app.url')), '/');+ $warnings = $this->buildWarnings($applications, $dependencies, $sourceInstanceUrl);++ $payload = ServerTransferBundle::wrap([+ 'source_instance' => [+ 'url' => $sourceInstanceUrl,+ 'name' => config('app.name'),+ ],+ 'warnings' => $warnings,+ // Back-compat: single server key+ 'private_key' => $this->exportPrivateKey($privateKey),+ // All keys needed by server, apps, and git sources+ 'private_keys' => $dependencies['private_keys']->map(fn (PrivateKey $key) => $this->exportPrivateKey($key))->values()->all(),+ 'github_apps' => $dependencies['github_apps']->map(fn (GithubApp $app) => $this->exportGithubApp($app))->values()->all(),+ 'gitlab_apps' => $dependencies['gitlab_apps']->map(fn (GitlabApp $app) => $this->exportGitlabApp($app))->values()->all(),+ 's3_storages' => $dependencies['s3_storages']->map(fn (S3Storage $storage) => $this->exportS3Storage($storage))->values()->all(),+ 'cloud_provider_tokens' => $dependencies['cloud_provider_tokens']->map(fn (CloudProviderToken $token) => $this->exportCloudProviderToken($token))->values()->all(),+ 'ssl_certificates' => $this->exportSslCertificates($server),+ 'volume_backups' => $this->exportVolumeBackups($applications, $databases, $services),+ 'server' => $this->exportServer($server),+ 'destinations' => $this->exportDestinations($server),+ 'shared_environment_variables' => [+ 'server' => $this->exportSharedEnvVars(+ SharedEnvironmentVariable::query()+ ->where('type', 'server')+ ->where('server_id', $server->id)+ ->get()+ ),+ ],+ 'projects' => $projects->map(function (Project $project) use ($server, $destinationUuidByKey, $applications, $databases, $services) {+ return $this->exportProject($project, $server, $destinationUuidByKey, $applications, $databases, $services);+ })->values()->all(),+ ]);++ return $payload;+ }++ /**+ * @param Collection<int, Application> $applications+ * @param Collection<int, Model> $databases+ * @param Collection<int, Service> $services+ * @return array{+ * private_keys: Collection<int, PrivateKey>,+ * github_apps: Collection<int, GithubApp>,+ * gitlab_apps: Collection<int, GitlabApp>,+ * s3_storages: Collection<int, S3Storage>,+ * cloud_provider_tokens: Collection<int, CloudProviderToken>+ * }+ */+ private function collectDependencies(Server $server, Collection $applications, Collection $databases, Collection $services): array+ {+ $privateKeys = collect([$server->privateKey])->filter();+ $githubApps = collect();+ $gitlabApps = collect();+ $s3Ids = collect();++ foreach ($applications as $application) {+ if ($application->private_key_id) {+ $key = PrivateKey::find($application->private_key_id);+ if ($key) {+ $privateKeys->push($key);+ }+ }++ if ($application->source_type === GithubApp::class && $application->source_id !== null) {+ $gh = GithubApp::find($application->source_id);+ // System-wide GitHub Apps are instance-owned; do not copy them.+ // Application export still records source.uuid so import can re-link+ // to an existing system-wide app on the target instance.+ if ($gh && ! $gh->is_system_wide) {+ $githubApps->push($gh);+ if ($gh->private_key_id) {+ $pk = PrivateKey::find($gh->private_key_id);+ if ($pk) {+ $privateKeys->push($pk);+ }+ }+ }+ }++ if ($application->source_type === GitlabApp::class && $application->source_id !== null) {+ $gl = GitlabApp::find($application->source_id);+ // System-wide GitLab Apps are instance-owned; re-link by UUID on import.+ if ($gl && ! $gl->is_system_wide) {+ $gitlabApps->push($gl);+ if ($gl->private_key_id) {+ $pk = PrivateKey::find($gl->private_key_id);+ if ($pk) {+ $privateKeys->push($pk);+ }+ }+ }+ }+ }++ $collectVolumeS3 = function ($resource) use (&$s3Ids): void {+ if (method_exists($resource, 'persistentStorages')) {+ foreach ($resource->persistentStorages as $volume) {+ foreach ($volume->scheduledBackups as $vb) {+ if ($vb->s3_storage_id) {+ $s3Ids->push($vb->s3_storage_id);+ }+ }+ }+ }+ if (method_exists($resource, 'fileStorages')) {+ foreach ($resource->fileStorages as $file) {+ foreach ($file->scheduledBackups as $vb) {+ if ($vb->s3_storage_id) {+ $s3Ids->push($vb->s3_storage_id);+ }+ }+ }+ }+ };++ foreach ($databases as $database) {+ if (method_exists($database, 'scheduledBackups')) {+ foreach ($database->scheduledBackups as $backup) {+ if ($backup->s3_storage_id) {+ $s3Ids->push($backup->s3_storage_id);+ }+ }+ }+ $database->loadMissing(['persistentStorages.scheduledBackups', 'fileStorages.scheduledBackups']);+ $collectVolumeS3($database);+ }++ foreach ($applications as $application) {+ $application->loadMissing(['persistentStorages.scheduledBackups', 'fileStorages.scheduledBackups', 'previews.persistentStorages.scheduledBackups']);+ $collectVolumeS3($application);+ foreach ($application->previews as $preview) {+ $collectVolumeS3($preview);+ }+ }++ foreach ($services as $service) {+ $service->loadMissing([+ 'applications.environment_variables',+ 'applications.persistentStorages.scheduledBackups',+ 'applications.fileStorages.scheduledBackups',+ 'databases.persistentStorages.scheduledBackups',+ 'databases.fileStorages.scheduledBackups',+ 'databases.scheduledBackups',+ ]);+ foreach ($service->applications as $serviceApp) {+ $collectVolumeS3($serviceApp);+ }+ foreach ($service->databases as $serviceDb) {+ foreach ($serviceDb->scheduledBackups as $backup) {+ if ($backup->s3_storage_id) {+ $s3Ids->push($backup->s3_storage_id);+ }+ }+ $collectVolumeS3($serviceDb);+ }+ }++ $cloudTokens = collect();+ if ($server->cloud_provider_token_id) {+ $token = CloudProviderToken::find($server->cloud_provider_token_id);+ if ($token) {+ $cloudTokens->push($token);+ }+ }++ return [+ 'private_keys' => $privateKeys->unique('id')->values(),+ 'github_apps' => $githubApps->unique('id')->values(),+ 'gitlab_apps' => $gitlabApps->unique('id')->values(),+ 's3_storages' => S3Storage::query()->whereIn('id', $s3Ids->unique()->filter()->all())->get(),+ 'cloud_provider_tokens' => $cloudTokens->unique('id')->values(),+ ];+ }++ /**+ * @param Collection<int, Application> $applications+ * @param array<string, mixed> $dependencies+ * @return list<string>+ */+ private function buildWarnings(Collection $applications, array $dependencies, string $sourceInstanceUrl): array+ {+ $warnings = [];++ if ($dependencies['github_apps']->isNotEmpty()) {+ $warnings[] = 'Team-scoped GitHub Apps were exported with credentials (system-wide apps are skipped). After import, update each GitHub App webhook URL (and setup/callback URL if used) to this Coolify instance so push/PR automations keep working. '+ ."Webhook path: {$sourceInstanceUrl}/webhooks/source/github/events "+ .'(replace host with the target instance FQDN after import). '+ .'Also reinstall/refresh the GitHub App installation if installation_id is invalid on the new host.';+ }++ $usesSystemWideGithub = $applications->contains(function (Application $app) {+ if ($app->source_type !== GithubApp::class || $app->source_id === null) {+ return false;+ }+ $gh = GithubApp::find($app->source_id);++ return $gh?->is_system_wide === true;+ });+ if ($usesSystemWideGithub) {+ $warnings[] = 'Some applications use a system-wide GitHub App, which is not exported. On import, Coolify will re-link to a matching system-wide GitHub App on the target instance (by UUID) if one exists.';+ }++ $usesSystemWideGitlab = $applications->contains(function (Application $app) {+ if ($app->source_type !== GitlabApp::class || $app->source_id === null) {+ return false;+ }+ $gl = GitlabApp::find($app->source_id);++ return $gl?->is_system_wide === true;+ });+ if ($usesSystemWideGitlab) {+ $warnings[] = 'Some applications use a system-wide GitLab App, which is not exported. On import, Coolify will re-link to a matching system-wide GitLab App on the target instance (by UUID) if one exists.';+ }++ if ($dependencies['gitlab_apps']->isNotEmpty()) {+ $warnings[] = 'Team-scoped GitLab Apps/OAuth sources were exported (system-wide apps are skipped). After import, update GitLab webhook URLs to the target Coolify instance '+ ."({$sourceInstanceUrl}/webhooks/source/gitlab/events — use the new FQDN) and refresh OAuth tokens if needed.";+ }++ if ($dependencies['s3_storages']->isNotEmpty()) {+ $warnings[] = 'S3 storage credentials were exported. Confirm endpoint access from the target instance and that bucket policies still apply.';+ }++ return $warnings;+ }++ /**+ * @return array<string, mixed>+ */+ private function exportPrivateKey(PrivateKey $key): array+ {+ try {+ $material = $key->private_key;+ } catch (\Throwable $e) {+ throw new RuntimeException(+ "Cannot decrypt private key \"{$key->name}\" (uuid={$key->uuid}). "+ .'This instance APP_KEY does not match the key that encrypted the data '+ .'(common after regenerating .dev-instances/*.env). '+ .'Restore the original APP_KEY or re-save the private key material. '+ .'Original error: '.$e->getMessage(),+ previous: $e+ );+ }++ return [+ 'uuid' => $key->uuid,+ 'name' => $key->name,+ 'description' => $key->description,+ 'private_key' => $material,+ 'is_git_related' => (bool) $key->is_git_related,+ 'fingerprint' => $key->fingerprint,+ ];+ }++ /**+ * @return array<string, mixed>+ */+ private function exportServer(Server $server): array+ {+ $settings = $server->settings;+ $settingsPayload = [];+ if ($settings) {+ foreach ($settings->getAttributes() as $key => $value) {+ if (in_array($key, self::SKIP_SERVER_SETTINGS, true)) {+ continue;+ }+ // Read through cast so encrypted fields are plaintext for re-encryption on import.+ $settingsPayload[$key] = $settings->{$key};+ }+ }++ return [+ 'uuid' => $server->uuid,+ 'name' => $server->name,+ 'description' => $server->description,+ 'ip' => (string) $server->ip,+ 'port' => (int) $server->port,+ 'user' => (string) $server->user,+ 'proxy' => $server->proxy?->toArray() ?? [],+ 'is_build_server' => (bool) $server->is_build_server,+ 'cloud_provider_token_uuid' => $server->cloudProviderToken?->uuid,+ 'settings' => $settingsPayload,+ ];+ }++ /**+ * @return list<array<string, mixed>>+ */+ private function exportDestinations(Server $server): array+ {+ $items = [];+ foreach ($server->standaloneDockers as $destination) {+ $items[] = [+ 'uuid' => $destination->uuid,+ 'name' => $destination->name,+ 'network' => $destination->network,+ 'type' => 'standalone',+ ];+ }+ foreach ($server->swarmDockers as $destination) {+ $items[] = [+ 'uuid' => $destination->uuid,+ 'name' => $destination->name,+ 'network' => $destination->network,+ 'type' => 'swarm',+ ];+ }++ return $items;+ }++ /**+ * @param Collection<int, Application> $applications+ * @param Collection<int, Model> $databases+ * @param Collection<int, Service> $services+ * @param array<string, string> $destinationUuidByKey+ * @return array<string, mixed>+ */+ private function exportProject(+ Project $project,+ Server $server,+ array $destinationUuidByKey,+ Collection $applications,+ Collection $databases,+ Collection $services,+ ): array {+ $environments = $project->environments()->orderBy('name')->get();++ return [+ 'uuid' => $project->uuid,+ 'name' => $project->name,+ 'description' => $project->description,+ 'shared_environment_variables' => $this->exportSharedEnvVars(+ SharedEnvironmentVariable::query()+ ->where('type', 'project')+ ->where('project_id', $project->id)+ ->get()+ ),+ 'environments' => $environments->map(function (Environment $environment) use ($destinationUuidByKey, $applications, $databases, $services) {+ $envApps = $applications->where('environment_id', $environment->id)->values();+ $envDbs = $databases->where('environment_id', $environment->id)->values();+ $envServices = $services->where('environment_id', $environment->id)->values();++ return [+ 'uuid' => $environment->uuid,+ 'name' => $environment->name,+ 'description' => $environment->description,+ 'shared_environment_variables' => $this->exportSharedEnvVars(+ SharedEnvironmentVariable::query()+ ->where('type', 'environment')+ ->where('environment_id', $environment->id)+ ->get()+ ),+ 'applications' => $envApps->map(fn (Application $app) => $this->exportApplication($app, $destinationUuidByKey))->all(),+ 'databases' => $envDbs->map(fn (Model $db) => $this->exportDatabase($db, $destinationUuidByKey))->all(),+ 'services' => $envServices->map(fn (Service $service) => $this->exportService($service, $destinationUuidByKey))->all(),+ ];+ })->values()->all(),+ ];+ }++ /**+ * @param array<string, string> $destinationUuidByKey+ * @return array<string, mixed>+ */+ private function exportApplication(Application $application, array $destinationUuidByKey): array+ {+ $application->loadMissing([+ 'settings',+ 'environment_variables',+ 'environment_variables_preview',+ 'persistentStorages',+ 'fileStorages',+ 'scheduled_tasks',+ 'tags',+ 'previews.persistentStorages',+ 'source',+ 'private_key',+ ]);++ $columns = Schema::getColumnListing($application->getTable());+ $attrs = [];+ foreach ($application->getFillable() as $field) {+ if (in_array($field, self::SKIP_APPLICATION_ATTRS, true)) {+ continue;+ }+ if (! in_array($field, $columns, true)) {+ continue;+ }+ $attrs[$field] = $application->{$field};+ }++ // Ensure hidden encrypted fields are included as plaintext.+ foreach ([+ 'http_basic_auth_password',+ 'manual_webhook_secret_github',+ 'manual_webhook_secret_gitlab',+ 'manual_webhook_secret_bitbucket',+ 'manual_webhook_secret_gitea',+ 'dockerfile',+ 'docker_compose',+ 'docker_compose_raw',+ 'custom_labels',+ ] as $hidden) {+ if (in_array($hidden, $columns, true)) {+ $attrs[$hidden] = $application->{$hidden};+ }+ }++ $settings = [];+ if ($application->settings) {+ foreach ($application->settings->getFillable() as $field) {+ if (in_array($field, ['application_id', 'id'], true)) {+ continue;+ }+ $settings[$field] = $application->settings->{$field};+ }+ }++ $destinationKey = $application->destination_type.':'.$application->destination_id;++ $source = null;+ if ($application->source_type === GithubApp::class && $application->source) {+ $source = ['type' => 'github_app', 'uuid' => $application->source->uuid];+ } elseif ($application->source_type === GitlabApp::class && $application->source) {+ $source = ['type' => 'gitlab_app', 'uuid' => $application->source->uuid];+ }++ return [+ 'type' => 'application',+ 'uuid' => $application->uuid,+ 'destination_uuid' => $destinationUuidByKey[$destinationKey] ?? null,+ 'attributes' => $attrs,+ 'settings' => $settings,+ 'environment_variables' => $this->exportEnvVars($application->environment_variables()->get()),+ 'environment_variables_preview' => $this->exportEnvVars($application->environment_variables_preview()->get()),+ 'persistent_storages' => $this->exportPersistentStorages($application->persistentStorages()->get()),+ 'file_storages' => $this->exportFileStorages($application->fileStorages()->get()),+ 'scheduled_tasks' => $this->exportScheduledTasks($application->scheduled_tasks()->get()),+ 'tags' => $this->exportTags($application->tags),+ 'previews' => $this->exportPreviews($application->previews),+ 'source' => $source,+ 'private_key_uuid' => $application->private_key?->uuid,+ 'had_git_source' => filled($application->source_id),+ 'had_private_key' => filled($application->private_key_id),+ ];+ }++ /**+ * @param array<string, string> $destinationUuidByKey+ * @return array<string, mixed>+ */+ private function exportDatabase(Model $database, array $destinationUuidByKey): array+ {+ $with = ['environment_variables', 'persistentStorages', 'fileStorages'];+ if (method_exists($database, 'tags')) {+ $with[] = 'tags';+ }+ if (method_exists($database, 'scheduledBackups')) {+ $with[] = 'scheduledBackups.s3';+ }+ $database->loadMissing($with);++ $columns = Schema::getColumnListing($database->getTable());+ $attrs = [];+ foreach ($database->getFillable() as $field) {+ if (in_array($field, ['id', 'created_at', 'updated_at', 'deleted_at', 'environment_id', 'destination_id', 'destination_type'], true)) {+ continue;+ }+ if (! in_array($field, $columns, true)) {+ continue;+ }+ $attrs[$field] = $database->{$field};+ }++ // Secrets are often $hidden and sometimes omitted from $fillable (e.g. redis_password).+ foreach ($columns as $column) {+ if (array_key_exists($column, $attrs)) {+ continue;+ }+ if (str_contains($column, 'password') || str_ends_with($column, '_password')) {+ $attrs[$column] = $database->{$column};+ }+ }++ $destinationKey = $database->destination_type.':'.$database->destination_id;++ return [+ 'type' => class_basename($database),+ 'model' => $database::class,+ 'uuid' => $database->uuid,+ 'destination_uuid' => $destinationUuidByKey[$destinationKey] ?? null,+ 'attributes' => $attrs,+ 'environment_variables' => method_exists($database, 'environment_variables')+ ? $this->exportEnvVars($database->environment_variables()->get())+ : [],+ 'persistent_storages' => method_exists($database, 'persistentStorages')+ ? $this->exportPersistentStorages($database->persistentStorages()->get())+ : [],+ 'file_storages' => method_exists($database, 'fileStorages')+ ? $this->exportFileStorages($database->fileStorages()->get())+ : [],+ 'tags' => method_exists($database, 'tags')+ ? $this->exportTags($database->tags)+ : [],+ 'scheduled_backups' => method_exists($database, 'scheduledBackups')+ ? $this->exportScheduledBackups($database->scheduledBackups)+ : [],+ ];+ }++ /**+ * @param array<string, string> $destinationUuidByKey+ * @return array<string, mixed>+ */+ private function exportService(Service $service, array $destinationUuidByKey): array+ {+ $service->loadMissing([+ 'environment_variables',+ 'applications.environment_variables',+ 'applications.persistentStorages',+ 'applications.fileStorages',+ 'databases.persistentStorages',+ 'databases.fileStorages',+ 'databases.scheduledBackups.s3',+ 'scheduled_tasks',+ 'tags',+ ]);++ $columns = Schema::getColumnListing($service->getTable());+ $attrs = [];+ foreach ($service->getFillable() as $field) {+ if (in_array($field, ['id', 'created_at', 'updated_at', 'deleted_at', 'environment_id', 'destination_id', 'destination_type', 'server_id'], true)) {+ continue;+ }+ if (! in_array($field, $columns, true)) {+ continue;+ }+ $attrs[$field] = $service->{$field};+ }++ // Hidden compose fields+ foreach (['docker_compose', 'docker_compose_raw'] as $hidden) {+ if (in_array($hidden, $columns, true)) {+ $attrs[$hidden] = $service->{$hidden};+ }+ }++ $destinationKey = $service->destination_type.':'.$service->destination_id;++ return [+ 'type' => 'service',+ 'uuid' => $service->uuid,+ 'destination_uuid' => $destinationUuidByKey[$destinationKey] ?? null,+ 'attributes' => $attrs,+ 'environment_variables' => $this->exportEnvVars($service->environment_variables()->get()),+ 'scheduled_tasks' => $this->exportScheduledTasks($service->scheduled_tasks()->get()),+ 'tags' => $this->exportTags($service->tags),+ 'applications' => $service->applications+ ->map(fn ($app) => $this->exportServiceApplication($app))+ ->values()+ ->all(),+ 'databases' => $service->databases+ ->map(fn ($db) => $this->exportServiceDatabase($db))+ ->values()+ ->all(),+ ];+ }++ /**+ * @return array<string, mixed>+ */+ private function exportServiceApplication(Model $app): array+ {+ $columns = Schema::getColumnListing($app->getTable());+ $attrs = [];+ foreach ($app->getFillable() as $field) {+ if (in_array($field, ['id', 'created_at', 'updated_at', 'deleted_at', 'service_id'], true)) {+ continue;+ }+ if (! in_array($field, $columns, true)) {+ continue;+ }+ $attrs[$field] = $app->{$field};+ }++ return [+ 'uuid' => $app->uuid,+ 'attributes' => $attrs,+ // Flat fields kept for older bundles / readability+ 'name' => $app->name,+ 'fqdn' => $app->fqdn,+ 'image' => $app->image ?? null,+ 'ports' => $app->ports ?? null,+ 'exposes' => $app->exposes ?? null,+ 'exclude_from_status' => (bool) ($app->exclude_from_status ?? false),+ 'required_fqdn' => (bool) ($app->required_fqdn ?? false),+ 'human_name' => $app->human_name ?? null,+ 'description' => $app->description ?? null,+ 'is_log_drain_enabled' => (bool) ($app->is_log_drain_enabled ?? false),+ 'is_include_timestamps' => (bool) ($app->is_include_timestamps ?? false),+ 'is_gzip_enabled' => (bool) ($app->is_gzip_enabled ?? true),+ 'is_stripprefix_enabled' => (bool) ($app->is_stripprefix_enabled ?? true),+ 'environment_variables' => method_exists($app, 'environment_variables')+ ? $this->exportEnvVars($app->environment_variables()->get())+ : [],+ 'persistent_storages' => method_exists($app, 'persistentStorages')+ ? $this->exportPersistentStorages($app->persistentStorages)+ : [],+ 'file_storages' => method_exists($app, 'fileStorages')+ ? $this->exportFileStorages($app->fileStorages)+ : [],+ ];+ }++ /**+ * @return array<string, mixed>+ */+ private function exportServiceDatabase(Model $db): array+ {+ $columns = Schema::getColumnListing($db->getTable());+ $attrs = [];+ foreach ($db->getFillable() as $field) {+ if (in_array($field, ['id', 'created_at', 'updated_at', 'deleted_at', 'service_id'], true)) {+ continue;+ }+ if (! in_array($field, $columns, true)) {+ continue;+ }+ $attrs[$field] = $db->{$field};+ }++ return [+ 'uuid' => $db->uuid,+ 'attributes' => $attrs,+ 'name' => $db->name,+ 'human_name' => $db->human_name ?? null,+ 'description' => $db->description ?? null,+ 'image' => $db->image ?? null,+ 'ports' => $db->ports ?? null,+ 'exposes' => $db->exposes ?? null,+ 'exclude_from_status' => (bool) ($db->exclude_from_status ?? false),+ 'is_log_drain_enabled' => (bool) ($db->is_log_drain_enabled ?? false),+ 'is_include_timestamps' => (bool) ($db->is_include_timestamps ?? false),+ 'is_gzip_enabled' => (bool) ($db->is_gzip_enabled ?? true),+ 'is_stripprefix_enabled' => (bool) ($db->is_stripprefix_enabled ?? true),+ 'public_port' => $db->public_port ?? null,+ 'public_port_timeout' => $db->public_port_timeout ?? null,+ 'is_public' => (bool) ($db->is_public ?? false),+ 'custom_type' => $db->custom_type ?? null,+ 'persistent_storages' => method_exists($db, 'persistentStorages')+ ? $this->exportPersistentStorages($db->persistentStorages)+ : [],+ 'file_storages' => method_exists($db, 'fileStorages')+ ? $this->exportFileStorages($db->fileStorages)+ : [],+ 'scheduled_backups' => method_exists($db, 'scheduledBackups')+ ? $this->exportScheduledBackups($db->scheduledBackups)+ : [],+ ];+ }++ /**+ * Multi-server / multi-destination applications cannot be transferred safely:+ * the bundle is per-server and additional destinations may live on other hosts.+ *+ * @param Collection<int, Application> $applications+ */+ private function assertNoAdditionalDestinations(Server $server, Collection $applications): void+ {+ $involvesThisServer = DB::table('additional_destinations')+ ->where('server_id', $server->id)+ ->exists();++ $appIds = $applications->pluck('id')->filter()->all();+ $involvesTheseApps = $appIds !== [] && DB::table('additional_destinations')+ ->whereIn('application_id', $appIds)+ ->exists();++ if ($involvesThisServer || $involvesTheseApps) {+ throw new RuntimeException(+ 'This server cannot be transferred because one or more applications use additional destinations (multi-server / multi-destination deploy). '+ .'Remove all additional destinations from those applications, then retry the export.'+ );+ }+ }++ /**+ * @param Collection<int, SharedEnvironmentVariable>|iterable<int, SharedEnvironmentVariable> $variables+ * @return list<array<string, mixed>>+ */+ private function exportSharedEnvVars(iterable $variables): array+ {+ $out = [];+ foreach ($variables as $variable) {+ // Skip auto COOLIFY_SERVER_* — recreated on server create.+ if (in_array($variable->key, ['COOLIFY_SERVER_UUID', 'COOLIFY_SERVER_NAME'], true)) {+ continue;+ }+ $out[] = [+ 'key' => $variable->key,+ 'value' => $variable->value,+ 'is_multiline' => (bool) $variable->is_multiline,+ 'is_literal' => (bool) $variable->is_literal,+ 'is_shown_once' => (bool) $variable->is_shown_once,+ 'comment' => $variable->comment,+ ];+ }++ return $out;+ }++ /**+ * @param Collection<int, EnvironmentVariable>|iterable<int, EnvironmentVariable> $variables+ * @return list<array<string, mixed>>+ */+ private function exportEnvVars(iterable $variables): array+ {+ $out = [];+ foreach ($variables as $variable) {+ $out[] = [+ 'uuid' => $variable->uuid,+ 'key' => $variable->key,+ 'value' => $variable->value,+ 'is_literal' => (bool) $variable->is_literal,+ 'is_multiline' => (bool) $variable->is_multiline,+ 'is_preview' => (bool) $variable->is_preview,+ 'is_runtime' => (bool) $variable->is_runtime,+ 'is_buildtime' => (bool) $variable->is_buildtime,+ 'is_shown_once' => (bool) $variable->is_shown_once,+ 'is_shared' => (bool) $variable->is_shared,+ 'is_required' => (bool) ($variable->is_required ?? false),+ 'comment' => $variable->comment,+ 'order' => $variable->order,+ ];+ }++ return $out;+ }++ /**+ * @param Collection<int, LocalPersistentVolume>|iterable<int, LocalPersistentVolume> $volumes+ * @return list<array<string, mixed>>+ */+ private function exportPersistentStorages(iterable $volumes): array+ {+ $out = [];+ foreach ($volumes as $volume) {+ $out[] = [+ 'uuid' => $volume->uuid,+ 'name' => $volume->name,+ 'mount_path' => $volume->mount_path,+ 'host_path' => $volume->host_path,+ 'is_preview_suffix_enabled' => (bool) ($volume->is_preview_suffix_enabled ?? false),+ ];+ }++ return $out;+ }++ /**+ * @param Collection<int, LocalFileVolume>|iterable<int, LocalFileVolume> $storages+ * @return list<array<string, mixed>>+ */+ private function exportFileStorages(iterable $storages): array+ {+ $out = [];+ foreach ($storages as $storage) {+ $out[] = [+ 'uuid' => $storage->uuid,+ 'fs_path' => $storage->fs_path,+ 'mount_path' => $storage->mount_path,+ 'content' => $storage->content,+ 'is_directory' => (bool) $storage->is_directory,+ 'is_host_file' => (bool) $storage->is_host_file,+ 'chown' => $storage->chown,+ 'chmod' => $storage->chmod,+ 'is_based_on_git' => (bool) ($storage->is_based_on_git ?? false),+ 'is_preview_suffix_enabled' => (bool) ($storage->is_preview_suffix_enabled ?? false),+ ];+ }++ return $out;+ }++ /**+ * @param Collection<int, ScheduledTask>|iterable<int, ScheduledTask> $tasks+ * @return list<array<string, mixed>>+ */+ private function exportScheduledTasks(iterable $tasks): array+ {+ $out = [];+ foreach ($tasks as $task) {+ $out[] = [+ 'uuid' => $task->uuid,+ 'name' => $task->name,+ 'command' => $task->command,+ 'frequency' => $task->frequency,+ 'container' => $task->container,+ 'timeout' => $task->timeout,+ 'enabled' => (bool) ($task->enabled ?? true),+ ];+ }++ return $out;+ }++ /**+ * @param Collection<int, Tag>|iterable<int, Tag> $tags+ * @return list<array{uuid: string, name: string}>+ */+ private function exportTags(iterable $tags): array+ {+ $out = [];+ foreach ($tags as $tag) {+ $out[] = [+ 'uuid' => $tag->uuid,+ 'name' => $tag->name,+ ];+ }++ return $out;+ }++ /**+ * @param Collection<int, ScheduledDatabaseBackup>|iterable<int, ScheduledDatabaseBackup> $backups+ * @return list<array<string, mixed>>+ */+ private function exportScheduledBackups(iterable $backups): array+ {+ $out = [];+ foreach ($backups as $backup) {+ $out[] = [+ 'uuid' => $backup->uuid,+ 'description' => $backup->description,+ 'enabled' => (bool) $backup->enabled,+ 'save_s3' => (bool) $backup->save_s3,+ 'frequency' => $backup->frequency,+ 'databases_to_backup' => $backup->databases_to_backup,+ 'dump_all' => (bool) ($backup->dump_all ?? false),+ 'database_backup_retention_amount_locally' => $backup->database_backup_retention_amount_locally,+ 'database_backup_retention_days_locally' => $backup->database_backup_retention_days_locally,+ 'database_backup_retention_max_storage_locally' => $backup->database_backup_retention_max_storage_locally,+ 'database_backup_retention_amount_s3' => $backup->database_backup_retention_amount_s3,+ 'database_backup_retention_days_s3' => $backup->database_backup_retention_days_s3,+ 'database_backup_retention_max_storage_s3' => $backup->database_backup_retention_max_storage_s3,+ 'timeout' => $backup->timeout,+ 'disable_local_backup' => (bool) ($backup->disable_local_backup ?? false),+ 's3_storage_uuid' => $backup->s3?->uuid,+ 'had_s3_storage' => filled($backup->s3_storage_id),+ ];+ }++ return $out;+ }++ /**+ * @return array<string, mixed>+ */+ private function exportGithubApp(GithubApp $app): array+ {+ return [+ 'uuid' => $app->uuid,+ 'name' => $app->name,+ 'organization' => $app->organization,+ 'api_url' => $app->api_url,+ 'html_url' => $app->html_url,+ 'custom_user' => $app->custom_user,+ 'custom_port' => $app->custom_port,+ 'app_id' => $app->app_id,+ 'installation_id' => $app->installation_id,+ 'client_id' => $app->client_id,+ 'client_secret' => $app->client_secret,+ 'webhook_secret' => $app->webhook_secret,+ 'is_system_wide' => false,+ 'is_public' => (bool) $app->is_public,+ 'contents' => $app->contents,+ 'metadata' => $app->metadata,+ 'pull_requests' => $app->pull_requests,+ 'administration' => $app->administration,+ 'private_key_uuid' => $app->privateKey?->uuid,+ 'webhook_url_hint' => '/webhooks/source/github/events',+ ];+ }++ /**+ * @return array<string, mixed>+ */+ private function exportGitlabApp(GitlabApp $app): array+ {+ return [+ 'uuid' => $app->uuid,+ 'name' => $app->name,+ 'organization' => $app->organization,+ 'api_url' => $app->api_url,+ 'html_url' => $app->html_url,+ 'custom_port' => $app->custom_port,+ 'custom_user' => $app->custom_user,+ 'is_system_wide' => false,+ 'is_public' => (bool) $app->is_public,+ 'app_id' => $app->app_id,+ 'app_secret' => $app->app_secret,+ 'oauth_id' => $app->oauth_id,+ 'client_id' => $app->client_id,+ 'client_secret' => $app->client_secret,+ 'access_token' => $app->access_token,+ 'refresh_token' => $app->refresh_token,+ 'expires_at' => $app->expires_at,+ 'redirect_uri' => $app->redirect_uri,+ 'group_name' => $app->group_name,+ 'public_key' => $app->public_key,+ 'webhook_token' => $app->webhook_token,+ 'deploy_key_id' => $app->deploy_key_id,+ 'private_key_uuid' => $app->privateKey?->uuid,+ 'webhook_url_hint' => '/webhooks/source/gitlab/events',+ ];+ }++ /**+ * @return array<string, mixed>+ */+ private function exportS3Storage(S3Storage $storage): array+ {+ return [+ 'uuid' => $storage->uuid,+ 'name' => $storage->name,+ 'description' => $storage->description,+ 'region' => $storage->region,+ 'key' => $storage->key,+ 'secret' => $storage->secret,+ 'bucket' => $storage->bucket,+ 'endpoint' => $storage->endpoint,+ 'is_usable' => (bool) $storage->is_usable,+ ];+ }++ /**+ * @return array<string, mixed>+ */+ private function exportCloudProviderToken(CloudProviderToken $token): array+ {+ return [+ 'uuid' => $token->uuid,+ 'provider' => $token->provider,+ 'token' => $token->token,+ 'name' => $token->name,+ 'description' => $token->description,+ ];+ }++ /**+ * @return list<array<string, mixed>>+ */+ private function exportSslCertificates(Server $server): array+ {+ $out = [];+ foreach ($server->sslCertificates as $cert) {+ $resourceUuid = null;+ $resourceKind = null;+ if ($cert->resource_type && $cert->resource_id) {+ $resource = $cert->resource_type::find($cert->resource_id);+ if ($resource && isset($resource->uuid)) {+ $resourceUuid = $resource->uuid;+ $resourceKind = match (true) {+ $resource instanceof Application => 'application',+ $resource instanceof Service => 'service',+ default => class_basename($resource),+ };+ }+ }++ $out[] = [+ 'ssl_certificate' => $cert->ssl_certificate,+ 'ssl_private_key' => $cert->ssl_private_key,+ 'configuration_dir' => $cert->configuration_dir,+ 'mount_path' => $cert->mount_path,+ 'common_name' => $cert->common_name,+ 'subject_alternative_names' => $cert->subject_alternative_names,+ 'valid_until' => optional($cert->valid_until)?->toIso8601String(),+ 'is_ca_certificate' => (bool) $cert->is_ca_certificate,+ 'resource_kind' => $resourceKind,+ 'resource_uuid' => $resourceUuid,+ ];+ }++ return $out;+ }++ /**+ * @param Collection<int, ApplicationPreview>|iterable<int, ApplicationPreview> $previews+ * @return list<array<string, mixed>>+ */+ private function exportPreviews(iterable $previews): array+ {+ $out = [];+ foreach ($previews as $preview) {+ $out[] = [+ 'uuid' => $preview->uuid,+ 'pull_request_id' => $preview->pull_request_id,+ 'pull_request_html_url' => $preview->pull_request_html_url,+ 'pull_request_issue_comment_id' => $preview->pull_request_issue_comment_id,+ 'fqdn' => $preview->fqdn,+ 'status' => $preview->status,+ 'git_type' => $preview->git_type,+ 'docker_compose_domains' => $preview->docker_compose_domains,+ 'docker_registry_image_tag' => $preview->docker_registry_image_tag,+ 'persistent_storages' => method_exists($preview, 'persistentStorages')+ ? $this->exportPersistentStorages($preview->persistentStorages)+ : [],+ ];+ }++ return $out;+ }++ /**+ * @param Collection<int, Application> $applications+ * @param Collection<int, Model> $databases+ * @param Collection<int, Service> $services+ * @return list<array<string, mixed>>+ */+ private function exportVolumeBackups(Collection $applications, Collection $databases, Collection $services): array+ {+ $out = [];+ $seen = [];++ $collectFrom = function ($resource) use (&$out, &$seen) {+ $storages = collect();+ if (method_exists($resource, 'persistentStorages')) {+ $storages = $storages->merge($resource->persistentStorages);+ }+ if (method_exists($resource, 'fileStorages')) {+ $storages = $storages->merge($resource->fileStorages);+ }+ foreach ($storages as $storage) {+ if (! method_exists($storage, 'scheduledBackups')) {+ continue;+ }+ foreach ($storage->scheduledBackups as $backup) {+ if (isset($seen[$backup->id])) {+ continue;+ }+ $seen[$backup->id] = true;+ $kind = $storage instanceof LocalFileVolume ? 'file_volume' : 'persistent_volume';+ $out[] = [+ 'uuid' => $backup->uuid,+ 'backupable_kind' => $kind,+ 'backupable_uuid' => $storage->uuid,+ 'frequency' => $backup->frequency,+ 'enabled' => (bool) $backup->enabled,+ 'save_s3' => (bool) $backup->save_s3,+ 'disable_local_backup' => (bool) $backup->disable_local_backup,+ 'stop_during_backup' => (bool) ($backup->stop_during_backup ?? false),+ 'retention_amount_locally' => $backup->retention_amount_locally,+ 'retention_days_locally' => $backup->retention_days_locally,+ 'retention_max_storage_locally' => $backup->retention_max_storage_locally,+ 'retention_amount_s3' => $backup->retention_amount_s3,+ 'retention_days_s3' => $backup->retention_days_s3,+ 'retention_max_storage_s3' => $backup->retention_max_storage_s3,+ 'timeout' => $backup->timeout,+ 's3_storage_uuid' => $backup->s3?->uuid,+ 'had_s3_storage' => filled($backup->s3_storage_id),+ ];+ }+ }+ };++ foreach ($applications as $application) {+ $application->loadMissing([+ 'persistentStorages.scheduledBackups.s3',+ 'fileStorages.scheduledBackups.s3',+ 'previews.persistentStorages.scheduledBackups.s3',+ ]);+ $collectFrom($application);+ foreach ($application->previews as $preview) {+ $collectFrom($preview);+ }+ }+ foreach ($databases as $database) {+ if (method_exists($database, 'loadMissing')) {+ $database->loadMissing([+ 'persistentStorages.scheduledBackups.s3',+ 'fileStorages.scheduledBackups.s3',+ ]);+ }+ $collectFrom($database);+ }+ foreach ($services as $service) {+ $service->loadMissing([+ 'applications.persistentStorages.scheduledBackups.s3',+ 'applications.fileStorages.scheduledBackups.s3',+ 'databases.persistentStorages.scheduledBackups.s3',+ 'databases.fileStorages.scheduledBackups.s3',+ ]);+ foreach ($service->applications as $serviceApp) {+ $collectFrom($serviceApp);+ }+ foreach ($service->databases as $serviceDb) {+ $collectFrom($serviceDb);+ }+ }++ return $out;+ }++ /**+ * @param Collection<int, Application> $applications+ * @param Collection<int, Model> $databases+ * @param Collection<int, Service> $services+ * @return list<int>+ */+ private function collectProjectIds(Collection $applications, Collection $databases, Collection $services): array+ {+ $environmentIds = $applications->pluck('environment_id')+ ->merge($databases->pluck('environment_id'))+ ->merge($services->pluck('environment_id'))+ ->filter()+ ->unique()+ ->values();++ if ($environmentIds->isEmpty()) {+ return [];+ }++ return Environment::query()+ ->whereIn('id', $environmentIds)+ ->pluck('project_id')+ ->unique()+ ->values()+ ->all();+ }++ /**+ * @return array<string, string>+ */+ private function destinationUuidMap(Server $server): array+ {+ $map = [];+ foreach ($server->standaloneDockers as $destination) {+ $map[StandaloneDocker::class.':'.$destination->id] = $destination->uuid;+ }+ foreach ($server->swarmDockers as $destination) {+ $map[SwarmDocker::class.':'.$destination->id] = $destination->uuid;+ }++ return $map;+ }+}diff --git a/app/Services/ServerTransfer/ServerTransferImporter.php b/app/Services/ServerTransfer/ServerTransferImporter.phpnew file mode 100644index 0000000000..b341725f9e--- /dev/null+++ b/app/Services/ServerTransfer/ServerTransferImporter.php@@ -0,0 +1,1604 @@+<?php++namespace App\Services\ServerTransfer;++use App\Models\Application;+use App\Models\ApplicationPreview;+use App\Models\CloudProviderToken;+use App\Models\Environment;+use App\Models\EnvironmentVariable;+use App\Models\GithubApp;+use App\Models\GitlabApp;+use App\Models\LocalFileVolume;+use App\Models\LocalPersistentVolume;+use App\Models\PrivateKey;+use App\Models\Project;+use App\Models\S3Storage;+use App\Models\ScheduledDatabaseBackup;+use App\Models\ScheduledTask;+use App\Models\ScheduledVolumeBackup;+use App\Models\Server;+use App\Models\Service;+use App\Models\ServiceApplication;+use App\Models\ServiceDatabase;+use App\Models\SharedEnvironmentVariable;+use App\Models\SslCertificate;+use App\Models\StandaloneClickhouse;+use App\Models\StandaloneDocker;+use App\Models\StandaloneDragonfly;+use App\Models\StandaloneKeydb;+use App\Models\StandaloneMariadb;+use App\Models\StandaloneMongodb;+use App\Models\StandaloneMysql;+use App\Models\StandalonePostgresql;+use App\Models\StandaloneRedis;+use App\Models\SwarmDocker;+use App\Models\Tag;+use Illuminate\Database\Eloquent\Model;+use Illuminate\Support\Facades\DB;+use Illuminate\Support\Facades\Schema;+use Illuminate\Validation\ValidationException;+use RuntimeException;+use Throwable;++class ServerTransferImporter+{+ /**+ * @var array<string, class-string>+ */+ private const DATABASE_MODELS = [+ 'StandalonePostgresql' => StandalonePostgresql::class,+ 'StandaloneMysql' => StandaloneMysql::class,+ 'StandaloneMariadb' => StandaloneMariadb::class,+ 'StandaloneMongodb' => StandaloneMongodb::class,+ 'StandaloneRedis' => StandaloneRedis::class,+ 'StandaloneKeydb' => StandaloneKeydb::class,+ 'StandaloneDragonfly' => StandaloneDragonfly::class,+ 'StandaloneClickhouse' => StandaloneClickhouse::class,+ ];++ /** @var array<string, PrivateKey> */+ private array $privateKeyMap = [];++ /** @var array<string, GithubApp> */+ private array $githubAppMap = [];++ /** @var array<string, GitlabApp> */+ private array $gitlabAppMap = [];++ /** @var array<string, S3Storage> */+ private array $s3StorageMap = [];++ /** @var array<string, CloudProviderToken> */+ private array $cloudTokenMap = [];++ /** @var array<string, LocalPersistentVolume|LocalFileVolume> */+ private array $volumeMap = [];++ /** @var array<string, Application> */+ private array $applicationMap = [];++ /** @var array<string, Service> */+ private array $serviceMap = [];++ /** @var array<string, Model> */+ private array $databaseMap = [];++ /**+ * @param array<string, mixed> $bundle+ * @return array{+ * dry_run: bool,+ * warnings: list<string>,+ * server_uuid: string|null,+ * private_key_uuid: string|null,+ * created: array<string, int>,+ * preserved_uuids: bool,+ * export_id: string|null,+ * claimed: bool,+ * claim: array<string, mixed>|null+ * }+ */+ public function import(+ array $bundle,+ int $teamId,+ bool $dryRun = false,+ bool $preserveUuids = true,+ bool $adoptMode = true,+ bool $claim = true,+ bool $writeRemote = false,+ bool $rebindSentinel = true,+ ): array {+ ServerTransferBundle::assertValid($bundle);++ $validation = ServerTransferBundle::validate($bundle);+ $warnings = $validation['warnings'];+ if (is_array(data_get($bundle, 'warnings'))) {+ $warnings = array_values(array_unique(array_merge($warnings, $bundle['warnings'])));+ }++ $serverUuid = (string) data_get($bundle, 'server.uuid');+ $serverIp = (string) data_get($bundle, 'server.ip');++ $uuidConflict = Server::withTrashed()->where('uuid', $serverUuid)->exists() && $preserveUuids;+ $existingIp = Server::where('ip', $serverIp)->first();+ $ipConflict = $existingIp !== null;++ if (! $dryRun && $uuidConflict) {+ throw ValidationException::withMessages([+ 'server.uuid' => ["A server with UUID {$serverUuid} already exists on this instance. Delete/transfer it first, or import with preserve_uuids=false."],+ ]);+ }++ if (! $dryRun && $ipConflict) {+ throw ValidationException::withMessages([+ 'server.ip' => ["A server with IP/domain {$serverIp} already exists (uuid={$existingIp->uuid}). Complete handoff on the source instance first."],+ ]);+ }++ if ($uuidConflict) {+ $warnings[] = "A server with UUID {$serverUuid} already exists on this instance.";+ }+ if ($ipConflict) {+ $warnings[] = "A server with IP/domain {$serverIp} already exists (uuid={$existingIp->uuid}).";+ }++ $created = [+ 'projects' => 0,+ 'environments' => 0,+ 'applications' => 0,+ 'databases' => 0,+ 'services' => 0,+ 'destinations' => 0,+ 'private_keys' => 0,+ 'github_apps' => 0,+ 'gitlab_apps' => 0,+ 's3_storages' => 0,+ 'cloud_provider_tokens' => 0,+ 'ssl_certificates' => 0,+ 'volume_backups' => 0,+ 'previews' => 0,+ ];++ if ($dryRun) {+ foreach (data_get($bundle, 'projects', []) as $project) {+ $created['projects']++;+ foreach (data_get($project, 'environments', []) as $environment) {+ $created['environments']++;+ $created['applications'] += count(data_get($environment, 'applications', []));+ $created['databases'] += count(data_get($environment, 'databases', []));+ $created['services'] += count(data_get($environment, 'services', []));+ foreach (data_get($environment, 'applications', []) as $app) {+ $created['previews'] += count(data_get($app, 'previews', []));+ }+ }+ }+ $created['destinations'] = count(data_get($bundle, 'destinations', []));+ $created['private_keys'] = max(+ count(data_get($bundle, 'private_keys', [])),+ data_get($bundle, 'private_key') ? 1 : 0+ );+ $created['github_apps'] = count(data_get($bundle, 'github_apps', []));+ $created['gitlab_apps'] = count(data_get($bundle, 'gitlab_apps', []));+ $created['s3_storages'] = count(data_get($bundle, 's3_storages', []));+ $created['cloud_provider_tokens'] = count(data_get($bundle, 'cloud_provider_tokens', []));+ $created['ssl_certificates'] = count(data_get($bundle, 'ssl_certificates', []));+ $created['volume_backups'] = count(data_get($bundle, 'volume_backups', []));++ // Append transfer hints for the target instance FQDN.+ $targetUrl = rtrim((string) (instanceSettings()->fqdn ?: config('app.url')), '/');+ if (count(data_get($bundle, 'github_apps', [])) > 0) {+ $warnings[] = "After import, set GitHub App webhook URL to {$targetUrl}/webhooks/source/github/events (and update setup/callback URLs in GitHub if needed) so automations work on this instance.";+ }+ if (count(data_get($bundle, 'gitlab_apps', [])) > 0) {+ $warnings[] = "After import, set GitLab webhook URL to {$targetUrl}/webhooks/source/gitlab/events so automations work on this instance.";+ }++ return [+ 'dry_run' => true,+ 'warnings' => $warnings,+ 'server_uuid' => $preserveUuids ? $serverUuid : null,+ 'private_key_uuid' => data_get($bundle, 'private_key.uuid'),+ 'created' => $created,+ 'preserved_uuids' => $preserveUuids,+ 'export_id' => data_get($bundle, 'export_id'),+ 'claimed' => false,+ 'claim' => null,+ ];+ }++ $result = DB::transaction(function () use ($bundle, $teamId, $preserveUuids, $adoptMode, $warnings, &$created) {+ $this->privateKeyMap = [];+ $this->githubAppMap = [];+ $this->gitlabAppMap = [];+ $this->s3StorageMap = [];+ $this->cloudTokenMap = [];+ $this->volumeMap = [];+ $this->applicationMap = [];+ $this->serviceMap = [];+ $this->databaseMap = [];++ // Import shared dependencies first+ $keyPayloads = data_get($bundle, 'private_keys', []);+ if ($keyPayloads === [] && data_get($bundle, 'private_key')) {+ $keyPayloads = [data_get($bundle, 'private_key')];+ }+ foreach ($keyPayloads as $keyPayload) {+ $key = $this->importPrivateKey($keyPayload, $teamId, $preserveUuids);+ $this->privateKeyMap[(string) data_get($keyPayload, 'uuid', $key->uuid)] = $key;+ $this->privateKeyMap[$key->uuid] = $key;+ $created['private_keys']++;+ }++ foreach (data_get($bundle, 'github_apps', []) as $ghPayload) {+ // Defensive: never import system-wide GitHub Apps from a bundle.+ if ((bool) data_get($ghPayload, 'is_system_wide', false)) {+ continue;+ }+ $gh = $this->importGithubApp($ghPayload, $teamId, $preserveUuids);+ $this->githubAppMap[(string) data_get($ghPayload, 'uuid', $gh->uuid)] = $gh;+ $this->githubAppMap[$gh->uuid] = $gh;+ $created['github_apps']++;+ }++ foreach (data_get($bundle, 'gitlab_apps', []) as $glPayload) {+ // Defensive: never import system-wide GitLab Apps from a bundle.+ if ((bool) data_get($glPayload, 'is_system_wide', false)) {+ continue;+ }+ $gl = $this->importGitlabApp($glPayload, $teamId, $preserveUuids);+ $this->gitlabAppMap[(string) data_get($glPayload, 'uuid', $gl->uuid)] = $gl;+ $this->gitlabAppMap[$gl->uuid] = $gl;+ $created['gitlab_apps']++;+ }++ foreach (data_get($bundle, 's3_storages', []) as $s3Payload) {+ $s3 = $this->importS3Storage($s3Payload, $teamId, $preserveUuids);+ $this->s3StorageMap[(string) data_get($s3Payload, 'uuid', $s3->uuid)] = $s3;+ $this->s3StorageMap[$s3->uuid] = $s3;+ $created['s3_storages']++;+ }++ foreach (data_get($bundle, 'cloud_provider_tokens', []) as $tokenPayload) {+ $token = $this->importCloudProviderToken($tokenPayload, $teamId, $preserveUuids);+ $this->cloudTokenMap[(string) data_get($tokenPayload, 'uuid', $token->uuid)] = $token;+ $this->cloudTokenMap[$token->uuid] = $token;+ $created['cloud_provider_tokens']++;+ }++ $serverKeyUuid = (string) data_get($bundle, 'private_key.uuid', '');+ $privateKey = $this->privateKeyMap[$serverKeyUuid]+ ?? $this->importPrivateKey(data_get($bundle, 'private_key', []), $teamId, $preserveUuids);++ $server = $this->importServer(data_get($bundle, 'server', []), $privateKey, $teamId, $preserveUuids, $adoptMode);+ $destinationMap = $this->importDestinations(data_get($bundle, 'destinations', []), $server, $preserveUuids);+ $created['destinations'] = count($destinationMap);++ $this->importServerSharedEnvVars(data_get($bundle, 'shared_environment_variables.server', []), $server, $teamId);++ foreach (data_get($bundle, 'projects', []) as $projectPayload) {+ $project = $this->importProject($projectPayload, $teamId, $preserveUuids, $created);+ foreach (data_get($projectPayload, 'environments', []) as $environmentPayload) {+ $environment = $this->importEnvironment($environmentPayload, $project, $preserveUuids, $created);++ foreach (data_get($environmentPayload, 'applications', []) as $appPayload) {+ $app = $this->importApplication($appPayload, $environment, $destinationMap, $preserveUuids, $adoptMode, $teamId);+ $this->applicationMap[(string) data_get($appPayload, 'uuid', $app->uuid)] = $app;+ $created['applications']++;+ $created['previews'] += count(data_get($appPayload, 'previews', []));+ }++ foreach (data_get($environmentPayload, 'databases', []) as $dbPayload) {+ $db = $this->importDatabase($dbPayload, $environment, $destinationMap, $preserveUuids, $adoptMode, $teamId);+ if ($db) {+ $this->databaseMap[(string) data_get($dbPayload, 'uuid', $db->uuid)] = $db;+ }+ $created['databases']++;+ }++ foreach (data_get($environmentPayload, 'services', []) as $servicePayload) {+ $service = $this->importService($servicePayload, $environment, $server, $destinationMap, $preserveUuids, $adoptMode, $teamId);+ $this->serviceMap[(string) data_get($servicePayload, 'uuid', $service->uuid)] = $service;+ $created['services']++;+ }+ }+ }++ $created['ssl_certificates'] = $this->importSslCertificates(data_get($bundle, 'ssl_certificates', []), $server);+ $created['volume_backups'] = $this->importVolumeBackups(data_get($bundle, 'volume_backups', []), $teamId);++ $targetUrl = rtrim((string) (instanceSettings()->fqdn ?: config('app.url')), '/');+ if ($created['github_apps'] > 0) {+ $warnings[] = "GitHub Apps imported. Update webhook URL to {$targetUrl}/webhooks/source/github/events (and setup/callback URLs in GitHub) so automations work on this instance.";+ }+ if ($created['gitlab_apps'] > 0) {+ $warnings[] = "GitLab sources imported. Update webhook URL to {$targetUrl}/webhooks/source/gitlab/events so automations work on this instance.";+ }++ $metadata = $server->server_metadata ?? [];+ $metadata['transfer'] = [+ 'status' => 'imported',+ 'export_id' => data_get($bundle, 'export_id'),+ 'source_instance_url' => data_get($bundle, 'source_instance.url'),+ 'imported_at' => now()->toIso8601String(),+ 'adopt_mode' => $adoptMode,+ ];+ $server->server_metadata = $metadata;+ $server->save();++ return [+ 'dry_run' => false,+ 'warnings' => array_values(array_unique($warnings)),+ 'server_uuid' => $server->uuid,+ 'private_key_uuid' => $privateKey->uuid,+ 'created' => $created,+ 'preserved_uuids' => $preserveUuids,+ 'export_id' => data_get($bundle, 'export_id'),+ 'claimed' => false,+ 'claim' => null,+ ];+ });++ // Claim after the import transaction commits so host/SSH work cannot roll back DB rows.+ if ($claim && filled(data_get($result, 'server_uuid'))) {+ $server = Server::where('uuid', $result['server_uuid'])->where('team_id', $teamId)->first();+ if ($server) {+ try {+ $claimResult = app(ServerTransferClaimer::class)->claim(+ $server,+ writeRemote: $writeRemote,+ rebindSentinel: $rebindSentinel,+ );+ $result['claimed'] = true;+ $result['claim'] = $claimResult;+ if (! data_get($claimResult, 'claim_written') && $writeRemote) {+ $result['warnings'][] = 'Server imported and claimed in Coolify, but the remote ownership file was not written (SSH unavailable).';+ }+ } catch (Throwable $e) {+ $result['claimed'] = false;+ $result['claim'] = null;+ $result['warnings'][] = 'Server imported, but automatic claim failed: '.$e->getMessage();+ }+ }+ }++ return $result;+ }++ /**+ * @param array<string, mixed> $payload+ */+ private function importPrivateKey(array $payload, int $teamId, bool $preserveUuids): PrivateKey+ {+ $material = (string) data_get($payload, 'private_key');+ if ($material === '') {+ throw new RuntimeException('Private key material is required.');+ }++ $fingerprint = PrivateKey::generateFingerprint($material)+ ?? data_get($payload, 'fingerprint');++ if ($fingerprint) {+ $existing = PrivateKey::query()->where('fingerprint', $fingerprint)->first();+ if ($existing) {+ if ((int) $existing->team_id !== $teamId) {+ throw ValidationException::withMessages([+ 'private_key' => ['This SSH private key already exists on another team on this instance.'],+ ]);+ }++ return $existing;+ }+ }++ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ if (PrivateKey::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $key = new PrivateKey([+ 'name' => data_get($payload, 'name') ?: 'Imported transfer key',+ 'description' => data_get($payload, 'description'),+ 'private_key' => $material,+ 'team_id' => $teamId,+ 'is_git_related' => (bool) data_get($payload, 'is_git_related', false),+ ]);+ $key->uuid = $uuid;++ try {+ $key->save();+ } catch (Throwable $e) {+ // Retry once without forcing uuid if uniqueness/validation conflicts.+ $key->uuid = new_public_id();+ $key->save();+ }++ return $key->fresh();+ }++ /**+ * @param array<string, mixed> $payload+ */+ private function importServer(array $payload, PrivateKey $privateKey, int $teamId, bool $preserveUuids, bool $adoptMode): Server+ {+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ if (Server::withTrashed()->where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $cloudTokenId = null;+ $cloudTokenUuid = data_get($payload, 'cloud_provider_token_uuid');+ if ($cloudTokenUuid && isset($this->cloudTokenMap[$cloudTokenUuid])) {+ $cloudTokenId = $this->cloudTokenMap[$cloudTokenUuid]->id;+ }++ $server = new Server;+ $server->forceFill([+ 'name' => data_get($payload, 'name') ?: generate_random_name(),+ 'description' => data_get($payload, 'description'),+ 'ip' => data_get($payload, 'ip'),+ 'port' => (int) data_get($payload, 'port', 22),+ 'user' => data_get($payload, 'user') ?: 'root',+ 'private_key_id' => $privateKey->id,+ 'team_id' => $teamId,+ 'cloud_provider_token_id' => $cloudTokenId,+ ]);+ $server->uuid = $uuid;+ $server->save();++ if ($server->settings && data_get($payload, 'is_build_server')) {+ $server->settings->is_build_server = true;+ $server->settings->save();+ }++ $proxy = data_get($payload, 'proxy', []);+ if (is_array($proxy) && $proxy !== []) {+ foreach ($proxy as $key => $value) {+ $server->proxy->set($key, $value);+ }+ $server->save();+ }++ $settingsPayload = data_get($payload, 'settings', []);+ if (is_array($settingsPayload) && $server->settings) {+ $safe = collect($settingsPayload)+ ->except([+ 'id', 'server_id', 'created_at', 'updated_at',+ 'is_reachable', 'is_usable', 'force_disabled',+ 'sentinel_token', 'sentinel_custom_url',+ ])+ ->all();+ $server->settings->fill($safe);+ // Imported servers start not validated; claim will rebind sentinel.+ $server->settings->is_reachable = false;+ $server->settings->is_usable = false;+ $server->settings->force_disabled = false;+ $server->settings->is_sentinel_enabled = false;+ $server->settings->save();+ }++ if ($adoptMode) {+ // Do not trigger validation/install automatically; operator claims next.+ $server->settings->is_reachable = false;+ $server->settings->is_usable = false;+ $server->settings->save();+ }++ return $server->fresh(['settings', 'standaloneDockers', 'swarmDockers']);+ }++ /**+ * @param list<array<string, mixed>> $destinations+ * @return array<string, StandaloneDocker|SwarmDocker> keyed by original uuid+ */+ private function importDestinations(array $destinations, Server $server, bool $preserveUuids): array+ {+ $map = [];+ $existingStandalone = $server->standaloneDockers->values();+ $existingSwarm = $server->swarmDockers->values();+ $standaloneIndex = 0;+ $swarmIndex = 0;++ if ($destinations === []) {+ $first = $existingStandalone->first() ?? $existingSwarm->first();+ if ($first) {+ $map[$first->uuid] = $first;+ }++ return $map;+ }++ foreach ($destinations as $destination) {+ $type = data_get($destination, 'type', 'standalone');+ $originalUuid = (string) data_get($destination, 'uuid');+ $uuid = $preserveUuids && $originalUuid !== '' ? $originalUuid : new_public_id();++ if ($type === 'swarm') {+ $model = $existingSwarm->get($swarmIndex);+ $swarmIndex++;+ if ($model) {+ $model->forceFill([+ 'uuid' => SwarmDocker::where('uuid', $uuid)->where('id', '!=', $model->id)->exists() ? $model->uuid : $uuid,+ 'name' => data_get($destination, 'name') ?: $model->name,+ 'network' => data_get($destination, 'network') ?: $model->network,+ ])->saveQuietly();+ } else {+ $model = new SwarmDocker;+ $model->forceFill([+ 'uuid' => SwarmDocker::where('uuid', $uuid)->exists() ? new_public_id() : $uuid,+ 'name' => data_get($destination, 'name') ?: 'coolify-overlay',+ 'network' => data_get($destination, 'network') ?: 'coolify-overlay',+ 'server_id' => $server->id,+ ])->saveQuietly();+ }+ } else {+ $model = $existingStandalone->get($standaloneIndex);+ $standaloneIndex++;+ if ($model) {+ $targetUuid = StandaloneDocker::where('uuid', $uuid)->where('id', '!=', $model->id)->exists()+ ? $model->uuid+ : $uuid;+ $model->forceFill([+ 'uuid' => $targetUuid,+ 'name' => data_get($destination, 'name') ?: $model->name,+ 'network' => data_get($destination, 'network') ?: $model->network,+ ])->saveQuietly();+ } else {+ $model = new StandaloneDocker;+ $model->forceFill([+ 'uuid' => StandaloneDocker::where('uuid', $uuid)->exists() ? new_public_id() : $uuid,+ 'name' => data_get($destination, 'name') ?: 'coolify',+ 'network' => data_get($destination, 'network') ?: 'coolify',+ 'server_id' => $server->id,+ ])->saveQuietly();+ }+ }++ $map[$originalUuid !== '' ? $originalUuid : $model->uuid] = $model->fresh();+ }++ return $map;+ }++ /**+ * @param list<array<string, mixed>> $variables+ */+ private function importServerSharedEnvVars(array $variables, Server $server, int $teamId): void+ {+ foreach ($variables as $variable) {+ SharedEnvironmentVariable::create([+ 'key' => data_get($variable, 'key'),+ 'value' => data_get($variable, 'value'),+ 'is_multiline' => (bool) data_get($variable, 'is_multiline', false),+ 'is_literal' => (bool) data_get($variable, 'is_literal', false),+ 'is_shown_once' => (bool) data_get($variable, 'is_shown_once', false),+ 'comment' => data_get($variable, 'comment'),+ 'type' => 'server',+ 'server_id' => $server->id,+ 'team_id' => $teamId,+ ]);+ }+ }++ /**+ * @param array<string, mixed> $payload+ * @param array<string, int> $created+ */+ private function importProject(array $payload, int $teamId, bool $preserveUuids, array &$created): Project+ {+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ $existing = Project::where('uuid', $uuid)->where('team_id', $teamId)->first();+ if ($existing) {+ $this->importProjectSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $existing, $teamId);++ return $existing;+ }++ if (Project::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $project = Project::create([+ 'uuid' => $uuid,+ 'name' => data_get($payload, 'name') ?: generate_random_name(),+ 'description' => data_get($payload, 'description'),+ 'team_id' => $teamId,+ ]);+ $created['projects']++;++ $this->importProjectSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $project, $teamId);++ return $project->fresh(['environments']);+ }++ /**+ * @param list<array<string, mixed>> $variables+ */+ private function importProjectSharedEnvVars(array $variables, Project $project, int $teamId): void+ {+ foreach ($variables as $variable) {+ $exists = SharedEnvironmentVariable::query()+ ->where('type', 'project')+ ->where('project_id', $project->id)+ ->where('key', data_get($variable, 'key'))+ ->exists();+ if ($exists) {+ continue;+ }+ SharedEnvironmentVariable::create([+ 'key' => data_get($variable, 'key'),+ 'value' => data_get($variable, 'value'),+ 'is_multiline' => (bool) data_get($variable, 'is_multiline', false),+ 'is_literal' => (bool) data_get($variable, 'is_literal', false),+ 'is_shown_once' => (bool) data_get($variable, 'is_shown_once', false),+ 'comment' => data_get($variable, 'comment'),+ 'type' => 'project',+ 'project_id' => $project->id,+ 'team_id' => $teamId,+ ]);+ }+ }++ /**+ * @param array<string, mixed> $payload+ * @param array<string, int> $created+ */+ private function importEnvironment(array $payload, Project $project, bool $preserveUuids, array &$created): Environment+ {+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ $byUuid = Environment::where('uuid', $uuid)->where('project_id', $project->id)->first();+ if ($byUuid) {+ $this->importEnvironmentSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $byUuid, $project->team_id);++ return $byUuid;+ }++ $name = (string) data_get($payload, 'name', 'production');+ $byName = $project->environments()->where('name', $name)->first();+ if ($byName) {+ if ($preserveUuids && $uuid !== '' && ! Environment::where('uuid', $uuid)->exists()) {+ $byName->uuid = $uuid;+ $byName->save();+ }+ if (filled(data_get($payload, 'description'))) {+ $byName->description = data_get($payload, 'description');+ $byName->save();+ }+ $this->importEnvironmentSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $byName, $project->team_id);++ return $byName->fresh();+ }++ if (Environment::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $environment = Environment::create([+ 'uuid' => $uuid,+ 'name' => $name,+ 'description' => data_get($payload, 'description'),+ 'project_id' => $project->id,+ ]);+ $created['environments']++;++ $this->importEnvironmentSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $environment, $project->team_id);++ return $environment;+ }++ /**+ * @param list<array<string, mixed>> $variables+ */+ private function importEnvironmentSharedEnvVars(array $variables, Environment $environment, int $teamId): void+ {+ foreach ($variables as $variable) {+ $exists = SharedEnvironmentVariable::query()+ ->where('type', 'environment')+ ->where('environment_id', $environment->id)+ ->where('key', data_get($variable, 'key'))+ ->exists();+ if ($exists) {+ continue;+ }+ SharedEnvironmentVariable::create([+ 'key' => data_get($variable, 'key'),+ 'value' => data_get($variable, 'value'),+ 'is_multiline' => (bool) data_get($variable, 'is_multiline', false),+ 'is_literal' => (bool) data_get($variable, 'is_literal', false),+ 'is_shown_once' => (bool) data_get($variable, 'is_shown_once', false),+ 'comment' => data_get($variable, 'comment'),+ 'type' => 'environment',+ 'environment_id' => $environment->id,+ 'team_id' => $teamId,+ ]);+ }+ }++ /**+ * @param array<string, mixed> $payload+ * @param array<string, StandaloneDocker|SwarmDocker> $destinationMap+ */+ private function importApplication(+ array $payload,+ Environment $environment,+ array $destinationMap,+ bool $preserveUuids,+ bool $adoptMode,+ int $teamId,+ ): Application {+ $destination = $this->resolveDestination(data_get($payload, 'destination_uuid'), $destinationMap);+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ if (Application::withTrashed()->where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $attributes = (array) data_get($payload, 'attributes', []);+ unset($attributes['id'], $attributes['environment_id'], $attributes['destination_id'], $attributes['destination_type'], $attributes['source_id'], $attributes['source_type'], $attributes['private_key_id']);+ $attributes = $this->onlyExistingColumns(Application::class, $attributes);++ $attributes['uuid'] = $uuid;+ $attributes['environment_id'] = $environment->id;+ $attributes['destination_id'] = $destination->id;+ $attributes['destination_type'] = $destination->getMorphClass();++ // Re-link git source+ $source = data_get($payload, 'source');+ if (is_array($source) && filled(data_get($source, 'uuid'))) {+ $sourceUuid = (string) data_get($source, 'uuid');+ $sourceType = (string) data_get($source, 'type');+ if ($sourceType === 'github_app') {+ $gh = $this->githubAppMap[$sourceUuid]+ ?? GithubApp::query()->where('uuid', $sourceUuid)->where('is_system_wide', true)->first()+ ?? GithubApp::query()->where('uuid', $sourceUuid)->where('team_id', $teamId)->first();+ if ($gh) {+ $attributes['source_type'] = GithubApp::class;+ $attributes['source_id'] = $gh->id;+ }+ } elseif ($sourceType === 'gitlab_app') {+ $gl = $this->gitlabAppMap[$sourceUuid]+ ?? GitlabApp::query()->where('uuid', $sourceUuid)->where('is_system_wide', true)->first()+ ?? GitlabApp::query()->where('uuid', $sourceUuid)->where('team_id', $teamId)->first();+ if ($gl) {+ $attributes['source_type'] = GitlabApp::class;+ $attributes['source_id'] = $gl->id;+ }+ }+ }++ // Re-link deploy key+ $appKeyUuid = data_get($payload, 'private_key_uuid');+ if ($appKeyUuid && isset($this->privateKeyMap[$appKeyUuid])) {+ $attributes['private_key_id'] = $this->privateKeyMap[$appKeyUuid]->id;+ }++ if ($adoptMode) {+ // Keep runtime status if provided so inventory can match, but default exited if empty.+ $attributes['status'] = data_get($attributes, 'status') ?: 'exited';+ } else {+ $attributes['status'] = 'exited';+ }++ $application = Application::create($attributes);++ $settings = (array) data_get($payload, 'settings', []);+ if ($settings !== [] && $application->settings) {+ $application->settings->fill(collect($settings)->except(['id', 'application_id'])->all());+ $application->settings->save();+ }++ $this->importEnvVars(data_get($payload, 'environment_variables', []), $application, false);+ $this->importEnvVars(data_get($payload, 'environment_variables_preview', []), $application, true);+ $this->importPersistentStorages(data_get($payload, 'persistent_storages', []), $application);+ $this->importFileStorages(data_get($payload, 'file_storages', []), $application);+ $this->importScheduledTasks(data_get($payload, 'scheduled_tasks', []), $application, $teamId);+ $this->importTags(data_get($payload, 'tags', []), $application, $teamId);+ $this->importPreviews(data_get($payload, 'previews', []), $application, $preserveUuids, $adoptMode);++ return $application;+ }++ /**+ * @param array<string, mixed> $payload+ * @param array<string, StandaloneDocker|SwarmDocker> $destinationMap+ */+ private function importDatabase(+ array $payload,+ Environment $environment,+ array $destinationMap,+ bool $preserveUuids,+ bool $adoptMode,+ int $teamId = 0,+ ): ?Model {+ $type = (string) data_get($payload, 'type', 'StandalonePostgresql');+ $modelClass = self::DATABASE_MODELS[$type]+ ?? (is_string(data_get($payload, 'model')) && class_exists((string) data_get($payload, 'model'))+ ? (string) data_get($payload, 'model')+ : null);++ if (! $modelClass || ! class_exists($modelClass)) {+ throw new RuntimeException("Unsupported database type: {$type}");+ }++ $destination = $this->resolveDestination(data_get($payload, 'destination_uuid'), $destinationMap);+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ if ($modelClass::withTrashed()->where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $attributes = (array) data_get($payload, 'attributes', []);+ unset($attributes['id'], $attributes['environment_id'], $attributes['destination_id'], $attributes['destination_type']);+ $attributes = $this->onlyExistingColumns($modelClass, $attributes);+ $attributes['uuid'] = $uuid;+ $attributes['environment_id'] = $environment->id;+ $attributes['destination_id'] = $destination->id;+ $attributes['destination_type'] = $destination->getMorphClass();+ $attributes['status'] = $adoptMode+ ? (data_get($attributes, 'status') ?: 'exited')+ : 'exited';++ // Avoid auto-created default volumes; we restore exported ones.+ $database = $modelClass::withoutEvents(function () use ($modelClass, $attributes, $uuid) {+ $database = new $modelClass;+ $database->forceFill(collect($attributes)->except(['uuid'])->all());+ $database->uuid = $uuid;+ $database->save();++ return $database;+ });++ $this->importEnvVars(data_get($payload, 'environment_variables', []), $database, false);+ $this->importPersistentStorages(data_get($payload, 'persistent_storages', []), $database);+ $this->importFileStorages(data_get($payload, 'file_storages', []), $database);+ if (method_exists($database, 'tags')) {+ $this->importTags(data_get($payload, 'tags', []), $database, $teamId);+ }+ $this->importScheduledBackups(data_get($payload, 'scheduled_backups', []), $database, $teamId);++ return $database;+ }++ /**+ * @param array<string, mixed> $payload+ * @param array<string, StandaloneDocker|SwarmDocker> $destinationMap+ */+ private function importService(+ array $payload,+ Environment $environment,+ Server $server,+ array $destinationMap,+ bool $preserveUuids,+ bool $adoptMode,+ int $teamId = 0,+ ): Service {+ $destination = $this->resolveDestination(data_get($payload, 'destination_uuid'), $destinationMap);+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ if (Service::withTrashed()->where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $attributes = (array) data_get($payload, 'attributes', []);+ unset($attributes['id'], $attributes['environment_id'], $attributes['destination_id'], $attributes['destination_type'], $attributes['server_id']);+ $attributes = $this->onlyExistingColumns(Service::class, $attributes);+ $attributes['uuid'] = $uuid;+ $attributes['environment_id'] = $environment->id;+ $attributes['server_id'] = $server->id;+ $attributes['destination_id'] = $destination->id;+ $attributes['destination_type'] = $destination->getMorphClass();++ $service = Service::create($attributes);++ $this->importEnvVars(data_get($payload, 'environment_variables', []), $service, false);+ $this->importScheduledTasks(data_get($payload, 'scheduled_tasks', []), $service, $teamId);+ $this->importTags(data_get($payload, 'tags', []), $service, $teamId);++ foreach (data_get($payload, 'applications', []) as $appPayload) {+ $this->importServiceApplication($appPayload, $service, $preserveUuids, $adoptMode);+ }++ foreach (data_get($payload, 'databases', []) as $dbPayload) {+ $this->importServiceDatabase($dbPayload, $service, $preserveUuids, $adoptMode, $teamId);+ }++ return $service;+ }++ /**+ * @param array<string, mixed> $appPayload+ */+ private function importServiceApplication(array $appPayload, Service $service, bool $preserveUuids, bool $adoptMode): ServiceApplication+ {+ $appUuid = $preserveUuids && filled(data_get($appPayload, 'uuid'))+ ? (string) data_get($appPayload, 'uuid')+ : new_public_id();+ if (ServiceApplication::where('uuid', $appUuid)->exists()) {+ $appUuid = new_public_id();+ }++ $attributes = (array) data_get($appPayload, 'attributes', []);+ if ($attributes === []) {+ // Back-compat with older thin service-application payloads.+ $attributes = collect($appPayload)->except([+ 'uuid', 'environment_variables', 'persistent_storages', 'file_storages', 'attributes',+ ])->all();+ }+ unset($attributes['id'], $attributes['service_id'], $attributes['created_at'], $attributes['updated_at'], $attributes['deleted_at']);+ $attributes = $this->onlyExistingColumns(ServiceApplication::class, $attributes);+ $attributes['service_id'] = $service->id;+ $attributes['name'] = data_get($attributes, 'name') ?: data_get($appPayload, 'name') ?: 'service-app';+ $attributes['status'] = $adoptMode+ ? (data_get($attributes, 'status') ?: data_get($appPayload, 'status') ?: 'running:unknown')+ : 'exited:unhealthy';++ $serviceApp = new ServiceApplication;+ $serviceApp->forceFill($attributes);+ $serviceApp->uuid = $appUuid;+ $serviceApp->save();++ $this->importEnvVars(data_get($appPayload, 'environment_variables', []), $serviceApp, false);+ $this->importPersistentStorages(data_get($appPayload, 'persistent_storages', []), $serviceApp);+ $this->importFileStorages(data_get($appPayload, 'file_storages', []), $serviceApp);++ return $serviceApp;+ }++ /**+ * @param array<string, mixed> $dbPayload+ */+ private function importServiceDatabase(array $dbPayload, Service $service, bool $preserveUuids, bool $adoptMode, int $teamId): ServiceDatabase+ {+ $dbUuid = $preserveUuids && filled(data_get($dbPayload, 'uuid'))+ ? (string) data_get($dbPayload, 'uuid')+ : new_public_id();+ if (ServiceDatabase::where('uuid', $dbUuid)->exists()) {+ $dbUuid = new_public_id();+ }++ $attributes = (array) data_get($dbPayload, 'attributes', []);+ if ($attributes === []) {+ $attributes = collect($dbPayload)->except([+ 'uuid', 'environment_variables', 'persistent_storages', 'file_storages', 'scheduled_backups', 'attributes',+ ])->all();+ }+ unset($attributes['id'], $attributes['service_id'], $attributes['created_at'], $attributes['updated_at'], $attributes['deleted_at']);+ $attributes = $this->onlyExistingColumns(ServiceDatabase::class, $attributes);+ $attributes['service_id'] = $service->id;+ $attributes['name'] = data_get($attributes, 'name') ?: data_get($dbPayload, 'name') ?: 'service-db';+ $attributes['status'] = $adoptMode+ ? (data_get($attributes, 'status') ?: data_get($dbPayload, 'status') ?: 'running:unknown')+ : 'exited:unhealthy';++ $serviceDb = new ServiceDatabase;+ $serviceDb->forceFill($attributes);+ $serviceDb->uuid = $dbUuid;+ $serviceDb->save();++ $this->importPersistentStorages(data_get($dbPayload, 'persistent_storages', []), $serviceDb);+ $this->importFileStorages(data_get($dbPayload, 'file_storages', []), $serviceDb);+ $this->importScheduledBackups(data_get($dbPayload, 'scheduled_backups', []), $serviceDb, $teamId);++ return $serviceDb;+ }++ /**+ * @param list<array<string, mixed>> $variables+ */+ private function importEnvVars(array $variables, object $resource, bool $isPreview): void+ {+ foreach ($variables as $variable) {+ EnvironmentVariable::withoutEvents(function () use ($variable, $resource, $isPreview) {+ $uuid = filled(data_get($variable, 'uuid')) ? (string) data_get($variable, 'uuid') : new_public_id();+ if (EnvironmentVariable::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $env = new EnvironmentVariable;+ $env->forceFill([+ 'key' => data_get($variable, 'key'),+ 'value' => data_get($variable, 'value'),+ 'is_literal' => (bool) data_get($variable, 'is_literal', false),+ 'is_multiline' => (bool) data_get($variable, 'is_multiline', false),+ 'is_preview' => $isPreview || (bool) data_get($variable, 'is_preview', false),+ 'is_runtime' => (bool) data_get($variable, 'is_runtime', true),+ 'is_buildtime' => (bool) data_get($variable, 'is_buildtime', true),+ 'is_shown_once' => (bool) data_get($variable, 'is_shown_once', false),+ 'is_shared' => (bool) data_get($variable, 'is_shared', false),+ 'is_required' => (bool) data_get($variable, 'is_required', false),+ 'comment' => data_get($variable, 'comment'),+ 'order' => data_get($variable, 'order'),+ 'resourceable_type' => $resource->getMorphClass(),+ 'resourceable_id' => $resource->id,+ ]);+ $env->uuid = $uuid;+ $env->save();+ });+ }+ }++ /**+ * @param list<array<string, mixed>> $volumes+ */+ private function importPersistentStorages(array $volumes, object $resource): void+ {+ foreach ($volumes as $volume) {+ $uuid = filled(data_get($volume, 'uuid')) ? (string) data_get($volume, 'uuid') : new_public_id();+ if (LocalPersistentVolume::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $volumeModel = new LocalPersistentVolume;+ $volumeModel->forceFill([+ 'name' => data_get($volume, 'name'),+ 'mount_path' => data_get($volume, 'mount_path'),+ 'host_path' => data_get($volume, 'host_path'),+ 'is_preview_suffix_enabled' => (bool) data_get($volume, 'is_preview_suffix_enabled', false),+ 'resource_type' => $resource->getMorphClass(),+ 'resource_id' => $resource->id,+ ]);+ $volumeModel->uuid = $uuid;+ $volumeModel->save();+ $this->volumeMap[$uuid] = $volumeModel;+ if (filled(data_get($volume, 'uuid'))) {+ $this->volumeMap[(string) data_get($volume, 'uuid')] = $volumeModel;+ }+ }+ }++ /**+ * @param list<array<string, mixed>> $storages+ */+ private function importFileStorages(array $storages, object $resource): void+ {+ foreach ($storages as $storage) {+ LocalFileVolume::withoutEvents(function () use ($storage, $resource) {+ $uuid = filled(data_get($storage, 'uuid')) ? (string) data_get($storage, 'uuid') : new_public_id();+ if (LocalFileVolume::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ // uuid is not fillable and withoutEvents skips BaseModel's creating hook.+ $file = new LocalFileVolume;+ $file->forceFill([+ 'fs_path' => data_get($storage, 'fs_path'),+ 'mount_path' => data_get($storage, 'mount_path'),+ 'content' => data_get($storage, 'content'),+ 'is_directory' => (bool) data_get($storage, 'is_directory', false),+ 'is_host_file' => (bool) data_get($storage, 'is_host_file', false),+ 'chown' => data_get($storage, 'chown'),+ 'chmod' => data_get($storage, 'chmod'),+ 'is_based_on_git' => (bool) data_get($storage, 'is_based_on_git', false),+ 'is_preview_suffix_enabled' => (bool) data_get($storage, 'is_preview_suffix_enabled', false),+ 'resource_type' => $resource->getMorphClass(),+ 'resource_id' => $resource->id,+ ]);+ $file->uuid = $uuid;+ $file->save();+ $this->volumeMap[$uuid] = $file;+ if (filled(data_get($storage, 'uuid'))) {+ $this->volumeMap[(string) data_get($storage, 'uuid')] = $file;+ }+ });+ }+ }++ /**+ * @param list<array<string, mixed>> $tasks+ */+ private function importScheduledTasks(array $tasks, Application|Service $resource, int $teamId): void+ {+ foreach ($tasks as $task) {+ $uuid = filled(data_get($task, 'uuid')) ? (string) data_get($task, 'uuid') : new_public_id();+ if (ScheduledTask::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $payload = [+ 'uuid' => $uuid,+ 'name' => data_get($task, 'name'),+ 'command' => data_get($task, 'command'),+ 'frequency' => data_get($task, 'frequency'),+ 'container' => data_get($task, 'container'),+ 'timeout' => data_get($task, 'timeout'),+ 'enabled' => (bool) data_get($task, 'enabled', true),+ 'team_id' => $teamId,+ ];++ if ($resource instanceof Application) {+ $payload['application_id'] = $resource->id;+ } else {+ $payload['service_id'] = $resource->id;+ }++ ScheduledTask::create($payload);+ }+ }++ /**+ * @param list<array{uuid?: string, name?: string}> $tags+ */+ private function importTags(array $tags, Model $resource, int $teamId): void+ {+ if ($tags === [] || ! method_exists($resource, 'tags')) {+ return;+ }++ foreach ($tags as $tagPayload) {+ $name = strtolower(trim((string) data_get($tagPayload, 'name', '')));+ if ($name === '') {+ continue;+ }++ $uuid = filled(data_get($tagPayload, 'uuid')) ? (string) data_get($tagPayload, 'uuid') : new_public_id();++ $tag = Tag::query()+ ->where('team_id', $teamId)+ ->where('name', $name)+ ->first();++ if (! $tag) {+ // Prefer preserved uuid when free; otherwise create with a new one.+ if (Tag::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }+ $tag = new Tag;+ $tag->forceFill([+ 'name' => $name,+ 'team_id' => $teamId,+ ]);+ $tag->uuid = $uuid;+ $tag->save();+ }++ $resource->tags()->syncWithoutDetaching([$tag->id]);+ }+ }++ /**+ * @param list<array<string, mixed>> $backups+ */+ private function importScheduledBackups(array $backups, Model $database, int $teamId): void+ {+ foreach ($backups as $backup) {+ $uuid = filled(data_get($backup, 'uuid')) ? (string) data_get($backup, 'uuid') : new_public_id();+ if (ScheduledDatabaseBackup::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $s3Id = null;+ $s3Uuid = data_get($backup, 's3_storage_uuid');+ if ($s3Uuid && isset($this->s3StorageMap[$s3Uuid])) {+ $s3Id = $this->s3StorageMap[$s3Uuid]->id;+ }++ ScheduledDatabaseBackup::create([+ 'uuid' => $uuid,+ 'team_id' => $teamId,+ 'description' => data_get($backup, 'description'),+ 'enabled' => (bool) data_get($backup, 'enabled', true),+ 'save_s3' => (bool) data_get($backup, 'save_s3', false) && $s3Id !== null,+ 'frequency' => data_get($backup, 'frequency'),+ 'databases_to_backup' => data_get($backup, 'databases_to_backup'),+ 'dump_all' => (bool) data_get($backup, 'dump_all', false),+ 'database_backup_retention_amount_locally' => data_get($backup, 'database_backup_retention_amount_locally', 0),+ 'database_backup_retention_days_locally' => data_get($backup, 'database_backup_retention_days_locally'),+ 'database_backup_retention_max_storage_locally' => data_get($backup, 'database_backup_retention_max_storage_locally'),+ 'database_backup_retention_amount_s3' => data_get($backup, 'database_backup_retention_amount_s3'),+ 'database_backup_retention_days_s3' => data_get($backup, 'database_backup_retention_days_s3'),+ 'database_backup_retention_max_storage_s3' => data_get($backup, 'database_backup_retention_max_storage_s3'),+ 'timeout' => data_get($backup, 'timeout'),+ 'disable_local_backup' => (bool) data_get($backup, 'disable_local_backup', false),+ 's3_storage_id' => $s3Id,+ 'database_type' => $database->getMorphClass(),+ 'database_id' => $database->id,+ ]);+ }+ }++ /**+ * @param array<string, mixed> $payload+ */+ private function importGithubApp(array $payload, int $teamId, bool $preserveUuids): GithubApp+ {+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ $existing = GithubApp::where('uuid', $uuid)->where('team_id', $teamId)->first();+ if ($existing) {+ return $existing;+ }+ if (GithubApp::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $privateKeyId = null;+ $keyUuid = data_get($payload, 'private_key_uuid');+ if ($keyUuid && isset($this->privateKeyMap[$keyUuid])) {+ $privateKeyId = $this->privateKeyMap[$keyUuid]->id;+ }++ $app = new GithubApp;+ $app->forceFill([+ 'team_id' => $teamId,+ 'private_key_id' => $privateKeyId,+ 'name' => data_get($payload, 'name') ?: 'Imported GitHub App',+ 'organization' => data_get($payload, 'organization'),+ 'api_url' => data_get($payload, 'api_url') ?: 'https://api.github.com',+ 'html_url' => data_get($payload, 'html_url') ?: 'https://github.com',+ 'custom_user' => data_get($payload, 'custom_user'),+ 'custom_port' => data_get($payload, 'custom_port'),+ 'app_id' => data_get($payload, 'app_id'),+ 'installation_id' => data_get($payload, 'installation_id'),+ 'client_id' => data_get($payload, 'client_id'),+ 'client_secret' => data_get($payload, 'client_secret'),+ 'webhook_secret' => data_get($payload, 'webhook_secret'),+ 'is_system_wide' => false,+ 'is_public' => (bool) data_get($payload, 'is_public', false),+ 'contents' => data_get($payload, 'contents'),+ 'metadata' => data_get($payload, 'metadata'),+ 'pull_requests' => data_get($payload, 'pull_requests'),+ 'administration' => data_get($payload, 'administration'),+ ]);+ $app->uuid = $uuid;+ $app->save();++ return $app;+ }++ /**+ * @param array<string, mixed> $payload+ */+ private function importGitlabApp(array $payload, int $teamId, bool $preserveUuids): GitlabApp+ {+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ $existing = GitlabApp::where('uuid', $uuid)->where('team_id', $teamId)->first();+ if ($existing) {+ return $existing;+ }+ if (GitlabApp::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $privateKeyId = null;+ $keyUuid = data_get($payload, 'private_key_uuid');+ if ($keyUuid && isset($this->privateKeyMap[$keyUuid])) {+ $privateKeyId = $this->privateKeyMap[$keyUuid]->id;+ }++ $app = new GitlabApp;+ $app->forceFill([+ 'team_id' => $teamId,+ 'private_key_id' => $privateKeyId,+ 'name' => data_get($payload, 'name') ?: 'Imported GitLab App',+ 'organization' => data_get($payload, 'organization'),+ 'api_url' => data_get($payload, 'api_url'),+ 'html_url' => data_get($payload, 'html_url'),+ 'custom_port' => data_get($payload, 'custom_port'),+ 'custom_user' => data_get($payload, 'custom_user'),+ 'is_system_wide' => false,+ 'is_public' => (bool) data_get($payload, 'is_public', false),+ 'app_id' => data_get($payload, 'app_id'),+ 'app_secret' => data_get($payload, 'app_secret'),+ 'oauth_id' => data_get($payload, 'oauth_id'),+ 'client_id' => data_get($payload, 'client_id'),+ 'client_secret' => data_get($payload, 'client_secret'),+ 'access_token' => data_get($payload, 'access_token'),+ 'refresh_token' => data_get($payload, 'refresh_token'),+ 'expires_at' => data_get($payload, 'expires_at'),+ 'redirect_uri' => data_get($payload, 'redirect_uri'),+ 'group_name' => data_get($payload, 'group_name'),+ 'public_key' => data_get($payload, 'public_key'),+ 'webhook_token' => data_get($payload, 'webhook_token'),+ 'deploy_key_id' => data_get($payload, 'deploy_key_id'),+ ]);+ $app->uuid = $uuid;+ $app->save();++ return $app;+ }++ /**+ * @param array<string, mixed> $payload+ */+ private function importS3Storage(array $payload, int $teamId, bool $preserveUuids): S3Storage+ {+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ $existing = S3Storage::where('uuid', $uuid)->where('team_id', $teamId)->first();+ if ($existing) {+ return $existing;+ }+ // Reuse by endpoint+bucket+key if already present for team+ $byIdentity = S3Storage::query()+ ->where('team_id', $teamId)+ ->where('endpoint', data_get($payload, 'endpoint'))+ ->where('bucket', data_get($payload, 'bucket'))+ ->first();+ if ($byIdentity) {+ return $byIdentity;+ }+ if (S3Storage::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $storage = new S3Storage;+ $storage->forceFill([+ 'team_id' => $teamId,+ 'name' => data_get($payload, 'name') ?: 'Imported S3',+ 'description' => data_get($payload, 'description'),+ 'region' => data_get($payload, 'region'),+ 'key' => data_get($payload, 'key'),+ 'secret' => data_get($payload, 'secret'),+ 'bucket' => data_get($payload, 'bucket'),+ 'endpoint' => data_get($payload, 'endpoint'),+ 'is_usable' => (bool) data_get($payload, 'is_usable', true),+ ]);+ $storage->uuid = $uuid;+ $storage->save();++ return $storage;+ }++ /**+ * @param array<string, mixed> $payload+ */+ private function importCloudProviderToken(array $payload, int $teamId, bool $preserveUuids): CloudProviderToken+ {+ $uuid = $preserveUuids && filled(data_get($payload, 'uuid'))+ ? (string) data_get($payload, 'uuid')+ : new_public_id();++ $existing = CloudProviderToken::where('uuid', $uuid)->where('team_id', $teamId)->first();+ if ($existing) {+ return $existing;+ }+ if (CloudProviderToken::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $token = new CloudProviderToken;+ $token->forceFill([+ 'team_id' => $teamId,+ 'provider' => data_get($payload, 'provider'),+ 'token' => data_get($payload, 'token'),+ 'name' => data_get($payload, 'name') ?: 'Imported cloud token',+ 'description' => data_get($payload, 'description'),+ ]);+ $token->uuid = $uuid;+ $token->save();++ return $token;+ }++ /**+ * @param list<array<string, mixed>> $previews+ */+ private function importPreviews(array $previews, Application $application, bool $preserveUuids, bool $adoptMode): void+ {+ foreach ($previews as $previewPayload) {+ $uuid = $preserveUuids && filled(data_get($previewPayload, 'uuid'))+ ? (string) data_get($previewPayload, 'uuid')+ : new_public_id();++ $preview = ApplicationPreview::withTrashed()->where('uuid', $uuid)->first();+ if (! $preview) {+ $pullRequestId = data_get($previewPayload, 'pull_request_id');+ if ($pullRequestId !== null) {+ $preview = ApplicationPreview::withTrashed()+ ->where('application_id', $application->id)+ ->where('pull_request_id', $pullRequestId)+ ->first();+ }+ }+ if ($preview && ApplicationPreview::withTrashed()->where('uuid', $uuid)->where('id', '!=', $preview->id)->exists()) {+ $uuid = new_public_id();+ } elseif (! $preview && ApplicationPreview::withTrashed()->where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $fqdn = data_get($previewPayload, 'fqdn');+ // FQDN is globally unique; free it from other rows (including soft-deleted leftovers).+ if (filled($fqdn)) {+ ApplicationPreview::withoutEvents(function () use ($fqdn, $preview) {+ ApplicationPreview::withTrashed()+ ->where('fqdn', $fqdn)+ ->when($preview, fn ($q) => $q->where('id', '!=', $preview->id))+ ->get()+ ->each(function (ApplicationPreview $conflict) {+ $conflict->fqdn = null;+ $conflict->saveQuietly();+ });+ });+ }++ $status = $adoptMode+ ? (data_get($previewPayload, 'status') ?: 'exited')+ : 'exited';++ $attributes = [+ 'application_id' => $application->id,+ 'pull_request_id' => data_get($previewPayload, 'pull_request_id'),+ 'pull_request_html_url' => data_get($previewPayload, 'pull_request_html_url') ?: '',+ 'pull_request_issue_comment_id' => data_get($previewPayload, 'pull_request_issue_comment_id'),+ 'fqdn' => $fqdn,+ 'status' => $status,+ 'git_type' => data_get($previewPayload, 'git_type'),+ 'docker_compose_domains' => data_get($previewPayload, 'docker_compose_domains'),+ 'docker_registry_image_tag' => data_get($previewPayload, 'docker_registry_image_tag'),+ ];++ if ($preview) {+ if ($preview->trashed()) {+ $preview->restore();+ }+ $preview->forceFill($attributes);+ if ($preserveUuids && filled(data_get($previewPayload, 'uuid')) && $preview->uuid !== $uuid) {+ if (! ApplicationPreview::withTrashed()->where('uuid', $uuid)->where('id', '!=', $preview->id)->exists()) {+ $preview->uuid = $uuid;+ }+ }+ $preview->save();+ } else {+ $preview = new ApplicationPreview;+ $preview->forceFill($attributes);+ $preview->uuid = $uuid;+ $preview->save();+ }++ // Avoid duplicating volumes when re-importing the same preview.+ if ($preview->wasRecentlyCreated || $preview->persistentStorages()->count() === 0) {+ $this->importPersistentStorages(data_get($previewPayload, 'persistent_storages', []), $preview);+ }+ }+ }++ /**+ * @param list<array<string, mixed>> $certificates+ */+ private function importSslCertificates(array $certificates, Server $server): int+ {+ $count = 0;+ foreach ($certificates as $certPayload) {+ $resourceType = null;+ $resourceId = null;+ $kind = data_get($certPayload, 'resource_kind');+ $resourceUuid = data_get($certPayload, 'resource_uuid');+ if ($kind === 'application' && $resourceUuid && isset($this->applicationMap[$resourceUuid])) {+ $resourceType = $this->applicationMap[$resourceUuid]->getMorphClass();+ $resourceId = $this->applicationMap[$resourceUuid]->id;+ } elseif ($kind === 'service' && $resourceUuid && isset($this->serviceMap[$resourceUuid])) {+ $resourceType = $this->serviceMap[$resourceUuid]->getMorphClass();+ $resourceId = $this->serviceMap[$resourceUuid]->id;+ } elseif ($resourceUuid && isset($this->databaseMap[$resourceUuid])) {+ $db = $this->databaseMap[$resourceUuid];+ $resourceType = $db->getMorphClass();+ $resourceId = $db->id;+ }++ SslCertificate::create([+ 'ssl_certificate' => data_get($certPayload, 'ssl_certificate'),+ 'ssl_private_key' => data_get($certPayload, 'ssl_private_key'),+ 'configuration_dir' => data_get($certPayload, 'configuration_dir'),+ 'mount_path' => data_get($certPayload, 'mount_path'),+ 'common_name' => data_get($certPayload, 'common_name') ?: 'imported',+ 'subject_alternative_names' => data_get($certPayload, 'subject_alternative_names'),+ 'valid_until' => data_get($certPayload, 'valid_until') ?: now()->addYear(),+ 'is_ca_certificate' => (bool) data_get($certPayload, 'is_ca_certificate', false),+ 'server_id' => $server->id,+ 'resource_type' => $resourceType,+ 'resource_id' => $resourceId,+ ]);+ $count++;+ }++ return $count;+ }++ /**+ * @param list<array<string, mixed>> $backups+ */+ private function importVolumeBackups(array $backups, int $teamId): int+ {+ $count = 0;+ foreach ($backups as $backupPayload) {+ $volumeUuid = (string) data_get($backupPayload, 'backupable_uuid', '');+ $volume = $this->volumeMap[$volumeUuid] ?? null;+ if (! $volume) {+ continue;+ }++ $uuid = filled(data_get($backupPayload, 'uuid'))+ ? (string) data_get($backupPayload, 'uuid')+ : new_public_id();+ if (ScheduledVolumeBackup::where('uuid', $uuid)->exists()) {+ $uuid = new_public_id();+ }++ $s3Id = null;+ $s3Uuid = data_get($backupPayload, 's3_storage_uuid');+ if ($s3Uuid && isset($this->s3StorageMap[$s3Uuid])) {+ $s3Id = $this->s3StorageMap[$s3Uuid]->id;+ }++ ScheduledVolumeBackup::create([+ 'uuid' => $uuid,+ 'backupable_type' => $volume->getMorphClass(),+ 'backupable_id' => $volume->id,+ 'team_id' => $teamId,+ 's3_storage_id' => $s3Id,+ 'frequency' => data_get($backupPayload, 'frequency'),+ 'enabled' => (bool) data_get($backupPayload, 'enabled', true),+ 'save_s3' => (bool) data_get($backupPayload, 'save_s3', false) && $s3Id !== null,+ 'disable_local_backup' => (bool) data_get($backupPayload, 'disable_local_backup', false),+ 'stop_during_backup' => (bool) data_get($backupPayload, 'stop_during_backup', false),+ 'retention_amount_locally' => data_get($backupPayload, 'retention_amount_locally'),+ 'retention_days_locally' => data_get($backupPayload, 'retention_days_locally'),+ 'retention_max_storage_locally' => data_get($backupPayload, 'retention_max_storage_locally'),+ 'retention_amount_s3' => data_get($backupPayload, 'retention_amount_s3'),+ 'retention_days_s3' => data_get($backupPayload, 'retention_days_s3'),+ 'retention_max_storage_s3' => data_get($backupPayload, 'retention_max_storage_s3'),+ 'timeout' => data_get($backupPayload, 'timeout'),+ ]);+ $count++;+ }++ return $count;+ }++ /**+ * @param array<string, StandaloneDocker|SwarmDocker> $destinationMap+ */+ private function resolveDestination(?string $uuid, array $destinationMap): StandaloneDocker|SwarmDocker+ {+ if ($uuid && isset($destinationMap[$uuid])) {+ return $destinationMap[$uuid];+ }++ $first = reset($destinationMap);+ if ($first instanceof StandaloneDocker || $first instanceof SwarmDocker) {+ return $first;+ }++ throw new RuntimeException('No destination available for imported resource.');+ }++ /**+ * @param class-string $modelClass+ * @param array<string, mixed> $attributes+ * @return array<string, mixed>+ */+ private function onlyExistingColumns(string $modelClass, array $attributes): array+ {+ /** @var Model $model */+ $model = new $modelClass;+ $columns = Schema::getColumnListing($model->getTable());++ return collect($attributes)+ ->only($columns)+ ->all();+ }+}diff --git a/app/Services/ServerTransfer/ServerTransferMigrator.php b/app/Services/ServerTransfer/ServerTransferMigrator.phpnew file mode 100644index 0000000000..f74dc8cc35--- /dev/null+++ b/app/Services/ServerTransfer/ServerTransferMigrator.php@@ -0,0 +1,178 @@+<?php++namespace App\Services\ServerTransfer;++use App\Models\Server;+use Illuminate\Http\Client\ConnectionException;+use Illuminate\Support\Facades\Http;+use RuntimeException;+use Throwable;++class ServerTransferMigrator+{+ public function __construct(+ private ServerTransferExporter $exporter,+ private ServerTransferClaimer $claimer,+ ) {}++ /**+ * One-shot migrate: export on this instance → import+claim on target → complete on this instance.+ *+ * @return array{+ * server_uuid: string,+ * export_id: string|null,+ * target_url: string,+ * import: array<string, mixed>,+ * complete: array<string, mixed>,+ * warnings: list<string>,+ * message: string+ * }+ */+ public function migrate(+ Server $server,+ string $targetUrl,+ string $targetToken,+ bool $writeRemote = false,+ bool $rebindSentinel = true,+ bool $preserveUuids = true,+ bool $adoptMode = true,+ ): array {+ if ($server->id === 0) {+ throw new RuntimeException('The Coolify host (localhost) cannot be transferred between instances.');+ }++ $targetUrl = $this->normalizeTargetUrl($targetUrl);+ $token = $this->normalizeToken($targetToken);++ $bundle = $this->exporter->export($server, includeSensitive: true);+ $exportId = data_get($bundle, 'export_id');+ $warnings = array_values((array) data_get($bundle, 'warnings', []));++ // Target import+claim runs in its own DB transaction on the remote instance.+ // Source DB is unchanged until markTransferred below — so a failed remote import leaves source intact.+ $importBody = $this->postImportToTarget(+ targetUrl: $targetUrl,+ token: $token,+ bundle: $bundle,+ writeRemote: $writeRemote,+ rebindSentinel: $rebindSentinel,+ preserveUuids: $preserveUuids,+ adoptMode: $adoptMode,+ );++ if (is_array(data_get($importBody, 'warnings'))) {+ $warnings = array_values(array_unique(array_merge($warnings, $importBody['warnings'])));+ }++ // Cross-instance 2PC is impossible: if complete fails after a successful import, the target+ // already owns the server. Surface that clearly so the operator can retry complete only.+ try {+ $complete = $this->claimer->markTransferred(+ $server,+ exportId: is_string($exportId) ? $exportId : null,+ targetInstanceUrl: $targetUrl,+ );+ } catch (Throwable $e) {+ throw new RuntimeException(+ "Server was imported on {$targetUrl}, but this instance could not mark it as transferred: {$e->getMessage()}. ".+ 'Retry complete (API: POST /api/v1/servers/{uuid}/complete) so automations stay disabled here. Do not re-import on the target.',+ previous: $e+ );+ }++ return [+ 'server_uuid' => $server->uuid,+ 'export_id' => is_string($exportId) ? $exportId : null,+ 'target_url' => $targetUrl,+ 'import' => $importBody,+ 'complete' => $complete,+ 'warnings' => $warnings,+ 'message' => 'Server migrated to '.$targetUrl.'. Automations disabled on this instance.',+ ];+ }++ private function normalizeTargetUrl(string $targetUrl): string+ {+ $targetUrl = rtrim(trim($targetUrl), '/');+ if ($targetUrl === '' || ! filter_var($targetUrl, FILTER_VALIDATE_URL)) {+ throw new RuntimeException('A valid target instance URL is required (e.g. http://localhost:8001).');+ }++ // From inside Docker, localhost is this container — use the host gateway for peer instances.+ if (file_exists('/.dockerenv') || is_file('/run/.containerenv')) {+ $targetUrl = (string) preg_replace(+ '#^(https?://)(localhost|127\.0\.0\.1)(?=[:/]|$)#i',+ '$1host.docker.internal',+ $targetUrl+ );+ }++ return $targetUrl;+ }++ private function normalizeToken(string $targetToken): string+ {+ $token = trim($targetToken);+ if (str_starts_with(strtolower($token), 'bearer ')) {+ $token = trim(substr($token, 7));+ }+ if ($token === '') {+ throw new RuntimeException('A target instance API token is required (root or write + create servers).');+ }++ return $token;+ }++ /**+ * @param array<string, mixed> $bundle+ * @return array<string, mixed>+ */+ private function postImportToTarget(+ string $targetUrl,+ string $token,+ array $bundle,+ bool $writeRemote,+ bool $rebindSentinel,+ bool $preserveUuids,+ bool $adoptMode,+ ): array {+ $importUrl = $targetUrl.'/api/v1/servers/import';++ try {+ $response = Http::timeout(120)+ ->acceptJson()+ ->withToken($token)+ ->asJson()+ ->post($importUrl, [+ 'bundle' => $bundle,+ 'dry_run' => false,+ 'preserve_uuids' => $preserveUuids,+ 'adopt_mode' => $adoptMode,+ 'claim' => true,+ 'write_remote' => $writeRemote,+ 'rebind_sentinel' => $rebindSentinel,+ ]);+ } catch (ConnectionException $e) {+ throw new RuntimeException("Could not reach target instance at {$importUrl}: {$e->getMessage()}", previous: $e);+ } catch (Throwable $e) {+ throw new RuntimeException("Transfer to target failed: {$e->getMessage()}", previous: $e);+ }++ $importBody = $response->json();+ if (! is_array($importBody)) {+ $importBody = ['raw' => $response->body()];+ }++ if (! $response->successful()) {+ $message = data_get($importBody, 'message')+ ?? data_get($importBody, 'errors')+ ?? $response->body();+ if (is_array($message)) {+ $message = json_encode($message);+ }+ throw new RuntimeException("Target import failed (HTTP {$response->status()}): {$message}");+ }++ return $importBody;+ }+}diff --git a/docker-compose.dev-multi.yml b/docker-compose.dev-multi.ymlnew file mode 100644index 0000000000..a25b52373d--- /dev/null+++ b/docker-compose.dev-multi.yml@@ -0,0 +1,225 @@+# Multi-instance Coolify (isolated project/network/volumes per instance).+#+# ./scripts/dev-instances up # a + b+# ./scripts/dev-instances urls+# ./scripts/dev-instances down+#+# Manual:+# docker compose -p coolify-a -f docker-compose.dev-multi.yml --env-file .dev-instances/a.env up -d+#+# Optional profiles: vite, mailpit, minio, testing-host+# ./scripts/dev-instances up a --with vite mailpit+#+# Ports (a / b): app 8000/8001, db 5432/5433, redis 6379/6380, soketi 6001/6011++services:+ coolify:+ image: coolify:dev+ pull_policy: never+ build:+ context: .+ dockerfile: ./docker/development/Dockerfile+ args:+ - USER_ID=${USERID:-1000}+ - GROUP_ID=${GROUPID:-1000}+ - COOLIFY_FLUX_VERSION=${COOLIFY_FLUX_VERSION:-nightly}+ - COOLIFY_FLUX_CHECKSUM=${COOLIFY_FLUX_CHECKSUM:-unknown}+ - COOLIFY_CLI_VERSION=${COOLIFY_CLI_VERSION:-nightly}+ - COOLIFY_CLI_CHECKSUM=${COOLIFY_CLI_CHECKSUM:-unknown}+ ports:+ - "${APP_PORT:-8000}:8080"+ - "${FORWARD_FLUX_PORT:-6443}:6443"+ extra_hosts:+ - "host.docker.internal:host-gateway"+ environment:+ AUTORUN_ENABLED: "${AUTORUN_ENABLED:-false}"+ APP_NAME: "${APP_NAME:-Coolify}"+ APP_URL: "${APP_URL:-http://localhost:8000}"+ APP_KEY: "${APP_KEY:-}"+ APP_ENV: "${APP_ENV:-local}"+ APP_DEBUG: "${APP_DEBUG:-true}"+ DB_CONNECTION: pgsql+ DB_HOST: postgres+ DB_PORT: 5432+ DB_DATABASE: "${DB_DATABASE:-coolify}"+ DB_USERNAME: "${DB_USERNAME:-coolify}"+ DB_PASSWORD: "${DB_PASSWORD:-password}"+ REDIS_HOST: redis+ REDIS_PORT: 6379+ REDIS_PASSWORD: "${REDIS_PASSWORD:-null}"+ COOLIFY_CONTAINER_ROLE: all+ PUSHER_HOST: ""+ PUSHER_PORT: ""+ PUSHER_SCHEME: http+ PUSHER_APP_ID: "${PUSHER_APP_ID:-coolify}"+ PUSHER_APP_KEY: "${PUSHER_APP_KEY:-coolify}"+ PUSHER_APP_SECRET: "${PUSHER_APP_SECRET:-coolify}"+ BROADCAST_CONNECTION: pusher+ QUEUE_CONNECTION: redis+ CACHE_STORE: redis+ SESSION_DRIVER: redis+ healthcheck:+ test: curl -sf http://127.0.0.1:8080/api/health || exit 1+ interval: 5s+ retries: 10+ timeout: 2s+ volumes:+ - .:/var/www/html/:cached+ - backups_data:/var/www/html/storage/app/backups+ depends_on:+ postgres:+ condition: service_healthy+ redis:+ condition: service_healthy+ networks:+ - coolify++ postgres:+ image: postgres:15-alpine+ pull_policy: always+ ports:+ - "${FORWARD_DB_PORT:-5432}:5432"+ environment:+ POSTGRES_USER: "${DB_USERNAME:-coolify}"+ POSTGRES_PASSWORD: "${DB_PASSWORD:-password}"+ POSTGRES_DB: "${DB_DATABASE:-coolify}"+ POSTGRES_HOST_AUTH_METHOD: "trust"+ healthcheck:+ test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]+ interval: 5s+ retries: 10+ timeout: 2s+ volumes:+ - postgres_data:/var/lib/postgresql/data+ networks:+ - coolify++ redis:+ image: redis:7-alpine+ pull_policy: always+ ports:+ - "${FORWARD_REDIS_PORT:-6379}:6379"+ healthcheck:+ test: redis-cli ping+ interval: 5s+ retries: 10+ timeout: 2s+ volumes:+ - redis_data:/data+ networks:+ - coolify++ soketi:+ image: coolify-realtime:dev+ pull_policy: never+ build:+ context: .+ dockerfile: ./docker/coolify-realtime/Dockerfile+ ports:+ - "${FORWARD_SOKETI_PORT:-6001}:6001"+ - "${FORWARD_SOKETI_PORT_ALT:-6002}:6002"+ extra_hosts:+ - "host.docker.internal:host-gateway"+ volumes:+ - ./storage:/var/www/html/storage+ - ./docker/coolify-realtime/terminal-server.js:/terminal/terminal-server.js+ - ./docker/coolify-realtime/terminal-utils.js:/terminal/terminal-utils.js+ environment:+ SOKETI_DEBUG: "false"+ SOKETI_DEFAULT_APP_ID: "${PUSHER_APP_ID:-coolify}"+ SOKETI_DEFAULT_APP_KEY: "${PUSHER_APP_KEY:-coolify}"+ SOKETI_DEFAULT_APP_SECRET: "${PUSHER_APP_SECRET:-coolify}"+ SOKETI_HOST: "0.0.0.0"+ healthcheck:+ test: ["CMD-SHELL", "curl -fsS http://127.0.0.1:6001/ready && curl -fsS http://127.0.0.1:6002/ready || exit 1"]+ interval: 5s+ retries: 10+ timeout: 2s+ entrypoint: ["/bin/sh", "/soketi-entrypoint.sh"]+ networks:+ - coolify++ vite:+ profiles: ["vite"]+ image: node:24-alpine+ pull_policy: always+ working_dir: /var/www/html+ environment:+ VITE_HOST: localhost+ VITE_PORT: "${VITE_PORT:-5173}"+ ports:+ - "${VITE_PORT:-5173}:${VITE_PORT:-5173}"+ volumes:+ - .:/var/www/html/:cached+ command: sh -c "npm install && npm run dev -- --port ${VITE_PORT:-5173} --host"+ networks:+ - coolify++ testing-host:+ profiles: ["testing-host"]+ image: coolify-testing-host:dev+ pull_policy: never+ build:+ context: .+ dockerfile: ./docker/testing-host/Dockerfile+ init: true+ volumes:+ - /var/run/docker.sock:/var/run/docker.sock+ - coolify_data:/data/coolify+ - backups_data:/data/coolify/backups+ - postgres_data:/data/coolify/_volumes/database+ - redis_data:/data/coolify/_volumes/redis+ - minio_data:/data/coolify/_volumes/minio+ networks:+ - coolify++ mailpit:+ profiles: ["mailpit"]+ image: axllent/mailpit:latest+ pull_policy: always+ ports:+ - "${FORWARD_MAILPIT_PORT:-1025}:1025"+ - "${FORWARD_MAILPIT_DASHBOARD_PORT:-8025}:8025"+ networks:+ - coolify++ minio:+ profiles: ["minio"]+ image: coollabsio/maxio:latest+ pull_policy: always+ ports:+ - "${FORWARD_MINIO_PORT:-9000}:9000"+ - "${FORWARD_MINIO_PORT_CONSOLE:-9001}:9001"+ environment:+ MINIO_ACCESS_KEY: minioadmin+ MINIO_SECRET_KEY: minioadmin+ volumes:+ - minio_data:/data+ networks:+ - coolify++ minio-init:+ profiles: ["minio"]+ image: minio/mc:latest+ pull_policy: always+ restart: "no"+ depends_on:+ - minio+ entrypoint: >+ /bin/sh -c "+ until mc alias set local http://minio:9000 minioadmin minioadmin 2>/dev/null; do sleep 2; done;+ mc mb local/local --ignore-existing;+ "+ networks:+ - coolify++volumes:+ backups_data:+ postgres_data:+ redis_data:+ coolify_data:+ minio_data:++networks:+ coolify:+ driver: bridgediff --git a/docs/dev-only-features.md b/docs/dev-only-features.mdindex 2b7a67cb46..58813f0c20 100644--- a/docs/dev-only-features.md+++ b/docs/dev-only-features.md@@ -21,3 +21,20 @@ Resource migration is under development and is not available in production.Before promoting this feature, remove all three runtime gates together andupdate the tests and this document in the same change.++## Server transfer between Coolify instances++Server transfer is under development and is not available in production.++- **UI:** Transfer and import links are rendered only when `isDev()` returns+ `true`, and the transfer Livewire components return `404 Not Found` outside+ development mode. Public Livewire actions repeat the check before doing work.+- **API:** Every endpoint handled by `ServerTransferController` returns `404 Not+ Found` unless `isDev()` returns `true`.+- **Tests:** Development-mode behavior and production isolation for all API+ endpoints, UI routes, and navigation links are covered by+ `tests/Feature/Api/ServerTransferApiTest.php` and+ `tests/Feature/Livewire/ServerTransferUiTest.php`.++Before promoting this feature, remove the API and UI runtime gates together and+update the tests and this document in the same change.diff --git a/resources/views/components/server/sidebar.blade.php b/resources/views/components/server/sidebar.blade.phpindex 1d6f07310b..d0254054be 100644--- a/resources/views/components/server/sidebar.blade.php+++ b/resources/views/components/server/sidebar.blade.php@@ -141,6 +141,14 @@['label' => 'Terminal Access', 'route' => 'server.security.terminal-access', 'active' => request()->routeIs('server.security.terminal-access'), 'icon' => 'browser-terminal', 'navigate' => false],],],+ [+ 'label' => 'Transfer',+ 'route' => 'server.transfer',+ 'active' => $activeMenu === 'transfer',+ 'icon' => 'arrow-right',+ 'group' => 'Operations',+ 'visible' => isDev() && ! $server->isLocalhost() && auth()->user()?->can('view', $server),+ ],['label' => 'Danger','route' => 'server.delete',diff --git a/resources/views/livewire/server/index.blade.php b/resources/views/livewire/server/index.blade.phpindex 9faae18c53..1054ec57f7 100644--- a/resources/views/livewire/server/index.blade.php+++ b/resources/views/livewire/server/index.blade.php@@ -5,27 +5,48 @@<div class="mb-5 flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between"><h1 class="min-w-0 text-[24px]! leading-7! font-semibold! tracking-tight!">Servers</h1>- @can('createAnyResource')- <a href="{{ route('server.create') }}" {{ wireNavigate() }}- class="button w-fit shrink-0 whitespace-nowrap button-highlighted">- <x-reicon name="plus" class="size-3.5" />- New server- </a>- @endcan+ <div class="flex flex-wrap items-center gap-2">+ @if (isDev())+ @can('create', App\Models\Server::class)+ <a href="{{ route('server.transfer.import') }}" {{ wireNavigate() }}+ class="button w-fit shrink-0 whitespace-nowrap">+ <x-reicon name="upload" class="size-3.5" />+ Import transfer+ <x-status-badge label="Dev" />+ </a>+ @endcan+ @endif+ @can('createAnyResource')+ <a href="{{ route('server.create') }}" {{ wireNavigate() }}+ class="button w-fit shrink-0 whitespace-nowrap button-highlighted">+ <x-reicon name="plus" class="size-3.5" />+ New server+ </a>+ @endcan+ </div></div>@php$serverRows = $servers->map(function ($server) {+ $isTransferredAway = $server->isTransferredAway();$isReady = $server->settings->is_reachable&& $server->settings->is_usable- && ! $server->settings->force_disabled;+ && ! $server->settings->force_disabled+ && ! $isTransferredAway;++ $status = match (true) {+ $isTransferredAway => 'Transferred away',+ $server->settings->force_disabled => 'Disabled',+ $isReady => 'Ready',+ default => 'Validation required',+ };return ['uuid' => $server->uuid,'name' => $server->name,'description' => $server->description ?: 'No description','href' => route('server.show', ['server_uuid' => $server->uuid]),- 'status' => $isReady ? 'Ready' : ($server->settings->force_disabled ? 'Disabled' : 'Validation required'),+ 'status' => $status,'statusType' => $isReady ? 'success' : 'error','ready' => $isReady,];diff --git a/resources/views/livewire/server/show.blade.php b/resources/views/livewire/server/show.blade.phpindex de1358957c..3bf29a9185 100644--- a/resources/views/livewire/server/show.blade.php+++ b/resources/views/livewire/server/show.blade.php@@ -89,8 +89,12 @@</x-forms.button>@endif@endif- <x-status-badge :label="$server->isFunctional() ? 'Ready' : 'Validation required'"- :type="$server->isFunctional() ? 'success' : 'warning'" />+ @if ($server->isTransferredAway())+ <x-status-badge label="Transferred away" type="warning" />+ @else+ <x-status-badge :label="$server->isFunctional() ? 'Ready' : 'Validation required'"+ :type="$server->isFunctional() ? 'success' : 'warning'" />+ @endif</x-slot:actions><div class="flex items-start gap-3">@@ -103,7 +107,9 @@{{ $server->name }}</p><p class="mt-1 text-xs leading-5 text-neutral-500 dark:text-fg-dim">- @if ($server->isFunctional())+ @if ($server->isTransferredAway())+ This server was migrated away from this Coolify instance and cannot be managed here.+ @elseif ($server->isFunctional())The server is reachable, validated, and ready to host resources.@elseValidate the SSH connection before using this server.@@ -206,6 +212,14 @@</x-process-dialog></x-slot:actions>+ @if ($server->isTransferredAway())+ <x-callout type="warning" title="Transferred to another instance" class="mb-4">+ This server was migrated away from this Coolify instance. It cannot be revalidated or+ managed here. Use the target instance, or delete this server when you no longer need the+ archive.+ </x-callout>+ @endif+@if ($this->limaStartCommand)<x-callout type="info" title="Start this Lima VM locally" class="mb-4"><codediff --git a/resources/views/livewire/server/transfer-import.blade.php b/resources/views/livewire/server/transfer-import.blade.phpnew file mode 100644index 0000000000..16fab1a102--- /dev/null+++ b/resources/views/livewire/server/transfer-import.blade.php@@ -0,0 +1,75 @@+<div>+ <x-slot:title>+ Import server transfer | Coolify+ </x-slot>+ <div class="flex flex-col gap-6">+ <div class="flex flex-wrap items-center gap-2">+ <h1>Import server transfer <x-status-badge label="Dev" /></h1>+ <a href="{{ route('server.index') }}" {{ wireNavigate() }}>+ <x-forms.button>Back to servers</x-forms.button>+ </a>+ </div>+ <div class="subtitle">+ Paste or upload a transfer bundle exported from another Coolify instance. This creates the server and its+ resources under the current team and <strong>claims</strong> the host for this instance+ (control-plane only — host data stays on the machine).+ </div>++ <div class="flex flex-col gap-4 rounded-lg border border-neutral-200 p-4 dark:border-coolgray-200">+ <x-forms.input type="file" id="bundleFile" label="Bundle file (.json)" accept=".json,application/json" />+ <x-forms.textarea id="bundleJson" label="Or paste bundle JSON" rows="14" placeholder='{"schema_version":1,...}' />+ <x-forms.input id="passphrase" type="password" label="Passphrase (if encrypted)" placeholder="Optional" />+ <div class="flex flex-col gap-2">+ <x-forms.checkbox id="preserveUuids" label="Preserve UUIDs from the source instance" />+ <x-forms.checkbox id="adoptMode" label="Adopt mode (keep statuses; do not force exited redeploy)" />+ <x-forms.checkbox id="writeRemote" label="Also write ownership file on the host via SSH (optional)" />+ </div>+ <div class="flex flex-wrap gap-2">+ <x-forms.button wire:click="dryRun" wire:loading.attr="disabled" wire:target="dryRun,importBundle">+ <span wire:loading.remove wire:target="dryRun">Dry run</span>+ <span wire:loading wire:target="dryRun">Checking…</span>+ </x-forms.button>+ <x-forms.button wire:click="importBundle" wire:loading.attr="disabled"+ wire:target="dryRun,importBundle"+ wire:confirm="Import this server into the current team?">+ <span wire:loading.remove wire:target="importBundle">Import server</span>+ <span wire:loading wire:target="importBundle">Importing…</span>+ </x-forms.button>+ </div>+ </div>++ @if (count($lastWarnings) > 0)+ <div class="rounded-lg border border-warning/40 bg-warning/10 p-3 text-sm">+ <div class="mb-1 font-semibold text-warning">Warnings</div>+ <ul class="list-disc space-y-1 pl-5">+ @foreach ($lastWarnings as $warning)+ <li>{{ $warning }}</li>+ @endforeach+ </ul>+ </div>+ @endif++ @if ($lastResult)+ <div class="rounded-lg border border-neutral-200 p-4 dark:border-coolgray-200">+ <div class="mb-2 font-semibold">+ {{ data_get($lastResult, 'dry_run') ? 'Dry-run result' : 'Import result' }}+ </div>+ @if ($importedServerUuid)+ <div class="mb-3 flex flex-wrap items-center gap-2 text-sm">+ <span>Server UUID: <code class="font-mono">{{ $importedServerUuid }}</code></span>+ @if (data_get($lastResult, 'claimed'))+ <span class="text-success">Claimed</span>+ @endif+ <a href="{{ route('server.show', ['server_uuid' => $importedServerUuid]) }}" {{ wireNavigate() }}>+ <x-forms.button>Open server</x-forms.button>+ </a>+ <a href="{{ route('server.transfer', ['server_uuid' => $importedServerUuid]) }}" {{ wireNavigate() }}>+ <x-forms.button>Transfer details</x-forms.button>+ </a>+ </div>+ @endif+ <pre class="max-h-80 overflow-auto rounded-lg bg-neutral-100 p-3 text-xs dark:bg-coolgray-100">{{ json_encode($lastResult, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES) }}</pre>+ </div>+ @endif+ </div>+</div>diff --git a/resources/views/livewire/server/transfer.blade.php b/resources/views/livewire/server/transfer.blade.phpnew file mode 100644index 0000000000..6480468124--- /dev/null+++ b/resources/views/livewire/server/transfer.blade.php@@ -0,0 +1,146 @@+<div>+ <x-slot:title>+ {{ data_get_str($server, 'name')->limit(10) }} > Transfer | Coolify+ </x-slot>++ <livewire:server.navbar :server="$server" />++ <div+ class="server-settings-workspace application-settings-workspace mt-4 grid w-full max-w-[1180px] min-w-0 gap-8 lg:mt-0 xl:grid-cols-[210px_minmax(0,1fr)] xl:gap-10">+ <x-server.sidebar :server="$server" activeMenu="transfer" />++ <div class="application-settings-form flex w-full flex-col gap-6">+ @if ($this->isLocalhost)+ <x-application.settings-section id="server-transfer-section" title="Transfer server (Dev)"+ helper="Move this server’s control-plane config to another Coolify instance (same physical host).">+ <x-callout type="warning" title="Localhost cannot be transferred">+ The Coolify host (localhost) cannot be transferred between instances.+ </x-callout>+ </x-application.settings-section>+ @else+ <x-application.settings-section id="server-transfer-section" title="Transfer server (Dev)"+ helper="Move this server’s control-plane config to another Coolify instance (same physical host).">+ <x-slot:actions>+ <x-status-badge+ :label="$this->transferStatus ?: 'ready'"+ type="neutral" />+ @if ($exportId)+ <span class="text-[11px] text-neutral-500 dark:text-fg-faint">export {{ $exportId }}</span>+ @endif+ </x-slot:actions>++ <div class="flex flex-col gap-4">+ <div>+ <h3 class="text-sm font-semibold text-neutral-950 dark:text-fg">Transfer to another instance+ </h3>+ <p class="mt-1 text-xs leading-5 text-neutral-500 dark:text-fg-dim">+ Enter the target Coolify URL and an API token from that instance (root recommended).+ This exports the server, imports and claims it on the target, then disables automations+ here.+ </p>+ </div>+ <div class="flex flex-col gap-3 md:max-w-xl">+ <x-forms.input id="targetUrl" label="Target instance URL" required+ placeholder="http://localhost:8001"+ helper="Base URL of the other Coolify instance (no trailing path)." />+ <x-forms.input id="targetToken" type="password" label="Target API token" required+ placeholder="Paste token from target instance" autocomplete="off"+ helper="Create a token on the target with root (or write + create servers). It is only used for this request." />+ <x-forms.checkbox id="writeRemote"+ label="Write ownership file on the host via SSH (optional)" />+ </div>+ <div>+ <x-forms.button canGate="update" :canResource="$server" wire:click="migrateServer"+ wire:loading.attr="disabled"+ wire:confirm="Transfer this server to the target instance? Automations will be disabled here.">+ <span wire:loading.remove wire:target="migrateServer">Transfer server</span>+ <span wire:loading wire:target="migrateServer">Transferring…</span>+ </x-forms.button>+ </div>+ @if (count($lastWarnings) > 0)+ <x-callout type="warning" title="Warnings">+ <ul class="mt-2 list-disc space-y-1 pl-5 text-sm">+ @foreach ($lastWarnings as $warning)+ <li>{{ $warning }}</li>+ @endforeach+ </ul>+ </x-callout>+ @endif+ @if ($lastResultJson)+ <div>+ <div class="mb-1 text-sm font-semibold">Result</div>+ <pre+ class="max-h-64 overflow-auto rounded-lg bg-neutral-100 p-3 text-xs dark:bg-coolgray-100">{{ $lastResultJson }}</pre>+ </div>+ @endif+ </div>+ </x-application.settings-section>++ <x-application.settings-section id="server-transfer-advanced-section" title="Advanced"+ helper="Manual export, complete-only, and re-claim helpers for air-gapped or partial transfers.">+ <div class="flex flex-col gap-6" x-data="{ open: @entangle('showAdvanced') }">+ <button type="button"+ class="flex w-full items-center justify-between rounded-lg border border-neutral-200 px-4 py-3 text-left dark:border-white/[0.08]"+ @click="open = !open">+ <span class="text-sm font-semibold">Show advanced options</span>+ <span class="text-xs text-neutral-500 dark:text-fg-faint"+ x-text="open ? 'Hide' : 'Show'"></span>+ </button>++ <div class="flex flex-col gap-6" x-show="open" x-cloak>+ <div>+ <h4 class="text-sm font-medium">Download bundle</h4>+ <p class="mb-3 text-xs leading-5 text-neutral-500 dark:text-fg-dim">+ Manual / air-gapped transfer. Import on the target via Servers → Import transfer.+ </p>+ <div class="mb-3 flex flex-col gap-3 md:max-w-xl">+ <x-forms.checkbox id="encryptBundle" label="Encrypt with passphrase" />+ <x-forms.input id="passphrase" type="password" label="Passphrase"+ placeholder="Used when encrypt is checked" autocomplete="new-password" />+ </div>+ <div class="flex flex-wrap gap-2">+ <x-forms.button canGate="view" :canResource="$server" wire:click="exportBundle"+ wire:loading.attr="disabled">+ <span wire:loading.remove wire:target="exportBundle">Download JSON</span>+ <span wire:loading wire:target="exportBundle">Exporting…</span>+ </x-forms.button>+ <a href="{{ route('server.transfer.import') }}" {{ wireNavigate() }}+ class="button">+ Import page (this instance)+ </a>+ </div>+ </div>++ <div>+ <h4 class="text-sm font-medium">Complete only</h4>+ <p class="mb-3 text-xs leading-5 text-neutral-500 dark:text-fg-dim">+ Disable automations after a manual import on the target.+ </p>+ <x-forms.button canGate="update" :canResource="$server" wire:click="completeTransfer"+ wire:loading.attr="disabled"+ wire:confirm="Disable automations on this server?">+ Mark transferred & disable automations+ </x-forms.button>+ </div>++ <div>+ <h4 class="text-sm font-medium">Re-claim only</h4>+ <p class="mb-3 text-xs leading-5 text-neutral-500 dark:text-fg-dim">+ Retry claim on this instance (after a local import).+ </p>+ <div class="mb-3 flex flex-col gap-2">+ <x-forms.checkbox id="writeRemoteOnClaim" label="Write ownership file via SSH" />+ <x-forms.checkbox id="rebindSentinelOnClaim" label="Rebind Sentinel" />+ </div>+ <x-forms.button canGate="update" :canResource="$server" wire:click="claimServer"+ wire:loading.attr="disabled">+ Re-claim+ </x-forms.button>+ </div>+ </div>+ </div>+ </x-application.settings-section>+ @endif+ </div>+ </div>+</div>diff --git a/routes/api.php b/routes/api.phpindex 1a01725f59..4a7a71afeb 100644--- a/routes/api.php+++ b/routes/api.php@@ -25,6 +25,7 @@ use App\Http\Controllers\Api\ServerLogDrainsController;use App\Http\Controllers\Api\ServerProxyController;use App\Http\Controllers\Api\ServersController;use App\Http\Controllers\Api\ServerSentinelController;+use App\Http\Controllers\Api\ServerTransferController;use App\Http\Controllers\Api\ServiceApplicationsController;use App\Http\Controllers\Api\ServiceDatabasesController;use App\Http\Controllers\Api\ServicesController;@@ -189,6 +190,12 @@ Route::group([Route::post('/servers/{uuid}/proxy/restart', [ServerProxyController::class, 'restart'])->middleware(['api.ability:write']);Route::post('/servers', [ServersController::class, 'create_server'])->middleware(['api.ability:write']);+ Route::post('/servers/import', [ServerTransferController::class, 'import'])->middleware(['api.ability:write']);+ Route::get('/servers/{uuid}/export', [ServerTransferController::class, 'export'])->middleware(['api.ability:read']);+ Route::post('/servers/{uuid}/export/mailbox', [ServerTransferController::class, 'writeMailbox'])->middleware(['api.ability:write']);+ Route::post('/servers/{uuid}/claim', [ServerTransferController::class, 'claim'])->middleware(['api.ability:write']);+ Route::post('/servers/{uuid}/transfer/complete', [ServerTransferController::class, 'complete'])->middleware(['api.ability:write']);+ Route::post('/servers/{uuid}/migrate', [ServerTransferController::class, 'migrate'])->middleware(['api.ability:write']);Route::patch('/servers/{uuid}', [ServersController::class, 'update_server'])->middleware(['api.ability:write']);Route::delete('/servers/{uuid}', [ServersController::class, 'delete_server'])->middleware(['api.ability:write']);diff --git a/routes/web.php b/routes/web.phpindex 40869b4b91..1d4e80d067 100644--- a/routes/web.php+++ b/routes/web.php@@ -70,6 +70,8 @@ use App\Livewire\Server\Sentinel\Logs as SentinelLogs;use App\Livewire\Server\Sentinel\Show as SentinelShow;use App\Livewire\Server\Show as ServerShow;use App\Livewire\Server\Swarm as ServerSwarm;+use App\Livewire\Server\Transfer as ServerTransfer;+use App\Livewire\Server\TransferImport as ServerTransferImport;use App\Livewire\Settings\Advanced as SettingsAdvanced;use App\Livewire\Settings\Index as SettingsIndex;use App\Livewire\Settings\ScheduledJobs as SettingsScheduledJobs;@@ -336,6 +338,7 @@ Route::middleware(['auth', 'verified'])->group(function () {});Route::get('/servers', ServerIndex::class)->name('server.index');+ Route::get('/servers/import', ServerTransferImport::class)->name('server.transfer.import')->middleware('can:create,'.Server::class);Route::get('/servers/new', ServerCreatePage::class)->name('server.create')->middleware('can:create,'.Server::class);Route::get('/servers/new/{type}/{token_uuid}', ServerCreatePage::class)->name('server.create.token')->middleware('can:create,'.Server::class)->whereIn('type', ['hetzner', 'vultr', 'digital-ocean']);Route::get('/servers/new/{type}', ServerCreatePage::class)->name('server.create.type')->middleware('can:create,'.Server::class)->whereIn('type', ['hetzner', 'vultr', 'digital-ocean', 'manual']);@@ -355,6 +358,7 @@ Route::middleware(['auth', 'verified'])->group(function () {Route::get('/log-drains', LogDrains::class)->name('server.log-drains');Route::get('/metrics', ServerCharts::class)->name('server.metrics');Route::get('/danger', DeleteServer::class)->name('server.delete');+ Route::get('/transfer', ServerTransfer::class)->name('server.transfer');Route::get('/proxy', ProxyShow::class)->name('server.proxy');Route::get('/proxy/dynamic', ProxyDynamicConfigurations::class)->name('server.proxy.dynamic-confs');Route::get('/proxy/logs', ProxyLogs::class)->name('server.proxy.logs');diff --git a/scripts/dev-instances b/scripts/dev-instancesnew file mode 100755index 0000000000..eac6b84383--- /dev/null+++ b/scripts/dev-instances@@ -0,0 +1,317 @@+#!/usr/bin/env bash+# Two local Coolify instances (isolated stacks) for multi-control-plane testing.+#+# Usage:+# ./scripts/dev-instances up # start a + b+# ./scripts/dev-instances up a # start a only+# ./scripts/dev-instances up a --with vite # HMR only for a single instance+# ./scripts/dev-instances down # stop a + b+# ./scripts/dev-instances urls+# ./scripts/dev-instances ps+# ./scripts/dev-instances logs a+# ./scripts/dev-instances exec a php artisan migrate --force+#+# Ports (fixed):+# a app 8000 db 5432 redis 6379 soketi 6001/6002 flux 6443+# b app 8001 db 5433 redis 6380 soketi 6011/6012 flux 6444+#+# Frontend: multi-instance uses npm run build (shared public/build). Do not use+# two Vite HMR servers — public/hot is a single shared file.+#+# Compose: docker-compose.dev-multi.yml+# Env: .dev-instances/{a,b}.env (generated, gitignored)+#+set -euo pipefail++ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"+cd "$ROOT"++COMPOSE_FILE="docker-compose.dev-multi.yml"+ENV_DIR=".dev-instances"+INSTANCES_ALL=(a b)++usage() {+ sed -n '2,18p' "$0" | sed 's/^# \?//'+ exit "${1:-0}"+}++# Fixed port offsets: a=0, b=1+instance_offset() {+ case "$1" in+ a|1) echo 0 ;;+ b|2) echo 1 ;;+ *)+ echo "Unknown instance '$1' (use a or b)" >&2+ exit 1+ ;;+ esac+}++normalize_name() {+ case "$1" in+ a|1) echo a ;;+ b|2) echo b ;;+ *)+ echo "Unknown instance '$1' (use a or b)" >&2+ exit 1+ ;;+ esac+}++project_name() { echo "coolify-$1"; }+env_file() { echo "${ENV_DIR}/$1.env"; }++ensure_env() {+ local name="$1"+ local offset env_file app_port existing_key key+ offset="$(instance_offset "$name")"+ env_file="$(env_file "$name")"+ app_port=$((8000 + offset))+ mkdir -p "$ENV_DIR"++ # Never rotate APP_KEY once set: encrypted DB columns (private keys, secrets)+ # become unreadable ("The MAC is invalid") if APP_KEY changes while volumes persist.+ existing_key=""+ if [[ -f "$env_file" ]]; then+ existing_key="$(grep -E '^APP_KEY=base64:' "$env_file" 2>/dev/null | tail -n1 | cut -d= -f2- || true)"+ fi+ if [[ -z "$existing_key" && -f ".dev-instances/${name}.appkey" ]]; then+ existing_key="$(cat ".dev-instances/${name}.appkey" 2>/dev/null || true)"+ fi+ if [[ -z "$existing_key" ]]; then+ existing_key="base64:$(openssl rand -base64 32)"+ fi+ printf '%s\n' "$existing_key" >".dev-instances/${name}.appkey"++ cat >"$env_file" <<EOF+# Generated by scripts/dev-instances for instance ${name} — do not commit+COMPOSE_PROJECT_NAME=coolify-${name}+APP_NAME=Coolify-${name}+APP_ENV=local+APP_DEBUG=true+APP_URL=http://localhost:${app_port}+APP_KEY=${existing_key}+APP_PORT=${app_port}+FORWARD_DB_PORT=$((5432 + offset))+FORWARD_REDIS_PORT=$((6379 + offset))+FORWARD_SOKETI_PORT=$((6001 + offset * 10))+FORWARD_SOKETI_PORT_ALT=$((6002 + offset * 10))+FORWARD_FLUX_PORT=$((6443 + offset))+VITE_PORT=$((5173 + offset))+FORWARD_MAILPIT_PORT=$((1025 + offset * 100))+FORWARD_MAILPIT_DASHBOARD_PORT=$((8025 + offset * 100))+FORWARD_MINIO_PORT=$((9000 + offset * 10))+FORWARD_MINIO_PORT_CONSOLE=$((9001 + offset * 10))+DB_DATABASE=coolify+DB_USERNAME=coolify+DB_PASSWORD=password+PUSHER_APP_ID=coolify-${name}+PUSHER_APP_KEY=coolify-${name}+PUSHER_APP_SECRET=coolify-${name}+EOF+}++compose() {+ local name="$1"+ shift+ local -a profiles=()+ local p+ for p in "${PROFILES[@]:-}"; do+ [[ -n "$p" ]] && profiles+=(--profile "$p")+ done+ ensure_env "$name"+ docker compose -p "$(project_name "$name")" -f "$COMPOSE_FILE" --env-file "$(env_file "$name")" "${profiles[@]}" "$@"+}++# Parse: [a] [b] [--with vite mailpit ...]+# Default instances when none given: a b+parse_args() {+ NAMES=()+ PROFILES=()+ local mode=names+ local arg+ for arg in "$@"; do+ if [[ "$arg" == "--with" ]]; then+ mode=profiles+ continue+ fi+ if [[ "$mode" == "profiles" ]]; then+ PROFILES+=("$arg")+ else+ NAMES+=("$(normalize_name "$arg")")+ fi+ done+ if [[ ${#NAMES[@]} -eq 0 ]]; then+ NAMES=("${INSTANCES_ALL[@]}")+ fi+}++# Multi-instance stacks share the repo bind-mount. Laravel's public/hot can only+# point at one Vite server, so dual HMR is broken (last Vite wins → missing CSS).+# Use a production frontend build shared by all instances instead.+ensure_frontend_assets() {+ if [[ -f public/hot ]]; then+ echo "Removing public/hot (multi-instance cannot share Vite HMR)..."+ rm -f public/hot+ fi+ if [[ ! -d node_modules ]]; then+ echo "Installing npm dependencies..."+ npm install+ fi+ if [[ ! -f public/build/manifest.json ]]; then+ echo "Building frontend assets (npm run build)..."+ npm run build || {+ echo "Warning: npm run build failed — UI will have no CSS/JS." >&2+ return 1+ }+ return+ fi+ # Rebuild if CSS entry is missing from disk (stale/partial build).+ local css+ css="$(php -r '+ $m=@json_decode(@file_get_contents("public/build/manifest.json"), true);+ $f=$m["resources/css/app.css"]["file"] ?? "";+ echo $f && is_file("public/build/".$f) ? "ok" : "missing";+ ' 2>/dev/null || echo missing)"+ if [[ "$css" != "ok" ]]; then+ echo "Frontend build incomplete — running npm run build..."+ npm run build || echo "Warning: npm run build failed." >&2+ fi+}++# Vite profile is only useful for a single instance; drop it when starting both.+filter_vite_profile() {+ local -a kept=()+ local p want_vite=0+ for p in "${PROFILES[@]:-}"; do+ if [[ "$p" == "vite" ]]; then+ want_vite=1+ continue+ fi+ kept+=("$p")+ done+ if [[ $want_vite -eq 1 ]]; then+ if [[ ${#NAMES[@]} -gt 1 ]]; then+ echo "Note: ignoring --with vite (shared public/hot cannot serve two instances)."+ echo " Frontend uses npm run build. For HMR, run a single instance: $0 up a --with vite"+ else+ kept+=("vite")+ fi+ fi+ PROFILES=("${kept[@]}")+}++cmd_up() {+ parse_args "$@"+ filter_vite_profile+ # Prefer built assets before containers serve HTML.+ ensure_frontend_assets || true+ local name+ local -a saved_profiles=("${PROFILES[@]:-}")+ for name in "${NAMES[@]}"; do+ PROFILES=("${saved_profiles[@]}")+ # Only the first (only) instance may run the vite profile.+ if [[ ${#NAMES[@]} -eq 1 ]] && printf '%s\n' "${PROFILES[@]:-}" | grep -qx vite; then+ :+ else+ local -a no_vite=()+ local p+ for p in "${PROFILES[@]:-}"; do+ [[ "$p" != "vite" ]] && no_vite+=("$p")+ done+ PROFILES=("${no_vite[@]}")+ fi+ echo "==> Starting ${name} → http://localhost:$((8000 + $(instance_offset "$name")))"+ compose "$name" up -d --build+ done+ # If a lone instance started vite, keep public/hot; otherwise force built assets.+ if [[ ${#NAMES[@]} -gt 1 ]] || ! printf '%s\n' "${saved_profiles[@]:-}" | grep -qx vite; then+ ensure_frontend_assets || true+ fi+ echo+ cmd_urls "${NAMES[@]}"+ echo+ echo "Frontend: production build (public/build). Both instances share the same assets."+}++cmd_down() {+ parse_args "$@"+ local name+ for name in "${NAMES[@]}"; do+ if [[ ! -f "$(env_file "$name")" ]]; then+ ensure_env "$name" >/dev/null+ fi+ echo "==> Stopping ${name}"+ compose "$name" down --remove-orphans+ done+}++cmd_ps() {+ parse_args "$@"+ local name+ for name in "${NAMES[@]}"; do+ [[ -f "$(env_file "$name")" ]] || ensure_env "$name" >/dev/null+ echo "==> $(project_name "$name")"+ compose "$name" ps+ echo+ done+}++cmd_urls() {+ local names=("$@")+ if [[ ${#names[@]} -eq 0 ]]; then+ names=("${INSTANCES_ALL[@]}")+ else+ parse_args "$@"+ names=("${NAMES[@]}")+ fi+ printf '%-6s %-28s %-8s %-8s %-12s\n' "NAME" "URL" "DB" "REDIS" "SOKETI"+ local name envf+ for name in "${names[@]}"; do+ name="$(normalize_name "$name")"+ ensure_env "$name" >/dev/null+ envf="$(env_file "$name")"+ printf '%-6s %-28s %-8s %-8s %-12s\n' \+ "$name" \+ "$(grep -E '^APP_URL=' "$envf" | cut -d= -f2-)" \+ "$(grep -E '^FORWARD_DB_PORT=' "$envf" | cut -d= -f2-)" \+ "$(grep -E '^FORWARD_REDIS_PORT=' "$envf" | cut -d= -f2-)" \+ "$(grep -E '^FORWARD_SOKETI_PORT=' "$envf" | cut -d= -f2-)"+ done+}++cmd_logs() {+ local name="${1:-}"+ shift || true+ [[ -z "$name" ]] && usage 1+ name="$(normalize_name "$name")"+ compose "$name" logs -f "$@"+}++cmd_exec() {+ local name="${1:-}"+ shift || true+ [[ -z "$name" || $# -eq 0 ]] && usage 1+ name="$(normalize_name "$name")"+ compose "$name" exec coolify "$@"+}++main() {+ local cmd="${1:-}"+ shift || true+ case "$cmd" in+ up) cmd_up "$@" ;;+ down) cmd_down "$@" ;;+ ps) cmd_ps "$@" ;;+ urls|ls|list) cmd_urls "$@" ;;+ logs) cmd_logs "$@" ;;+ exec) cmd_exec "$@" ;;+ -h|--help|help|"") usage 0 ;;+ *)+ echo "Unknown command: $cmd" >&2+ usage 1+ ;;+ esac+}++main "$@"diff --git a/scripts/seed-transfer-demo.php b/scripts/seed-transfer-demo.phpnew file mode 100644index 0000000000..865f4eb7ab--- /dev/null+++ b/scripts/seed-transfer-demo.php@@ -0,0 +1,702 @@+<?php++/**+ * Seed a rich transfer-demo inventory on the current Coolify instance.+ * Run: php artisan tinker scripts/seed-transfer-demo.php+ * Or: ./scripts/dev-instances exec a php artisan tinker --execute "require 'scripts/seed-transfer-demo.php';"+ */++use App\Models\Application;+use App\Models\ApplicationPreview;+use App\Models\Environment;+use App\Models\EnvironmentVariable;+use App\Models\GithubApp;+use App\Models\LocalFileVolume;+use App\Models\LocalPersistentVolume;+use App\Models\PrivateKey;+use App\Models\Project;+use App\Models\ScheduledDatabaseBackup;+use App\Models\ScheduledTask;+use App\Models\ScheduledVolumeBackup;+use App\Models\Server;+use App\Models\Service;+use App\Models\ServiceApplication;+use App\Models\ServiceDatabase;+use App\Models\SharedEnvironmentVariable;+use App\Models\SslCertificate;+use App\Models\StandaloneDocker;+use App\Models\StandaloneMongodb;+use App\Models\StandaloneMysql;+use App\Models\StandalonePostgresql;+use App\Models\StandaloneRedis;+use App\Models\Tag;+use App\Models\Team;+use Illuminate\Support\Facades\DB;+use Illuminate\Support\Facades\Schema;++$teamId = 0;+$team = Team::find($teamId) ?? Team::query()->orderBy('id')->first();+if (! $team) {+ throw new RuntimeException('No team found.');+}+$teamId = $team->id;++$report = [];++// --- Private key (testing-host SSH) ---+$keyMaterial = <<<'KEY'+-----BEGIN OPENSSH PRIVATE KEY-----+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW+QyNTUxOQAAACBbhpqHhqv6aI67Mj9abM3DVbmcfYhZAhC7ca4d9UCevAAAAJi/QySHv0Mk+hwAAAAtzc2gtZWQyNTUxOQAAACBbhpqHhqv6aI67Mj9abM3DVbmcfYhZAhC7ca4d9UCevA+AAAECBQw4jg1WRT2IGHMncCiZhURCts2s24HoDS0thHnnRKVuGmoeGq/pojrsyP1pszcNV+uZx9iFkCELtxrh31QJ68AAAAEXNhaWxANzZmZjY2ZDJlMmRkAQIDBA==+-----END OPENSSH PRIVATE KEY-----+KEY;++// Prefer existing testing-host key (same material) to avoid fingerprint uniqueness errors.+$key = PrivateKey::where('uuid', 'transfer-full-key')->first()+ ?? PrivateKey::where('name', 'Testing Host Key')->where('team_id', $teamId)->first()+ ?? PrivateKey::where('team_id', $teamId)->orderBy('id')->first();+if (! $key) {+ $key = PrivateKey::withoutEvents(function () use ($keyMaterial, $teamId) {+ $key = new PrivateKey;+ $key->forceFill([+ 'name' => 'transfer-full-key',+ 'description' => 'SSH key for transfer demo server (testing-host)',+ 'private_key' => $keyMaterial,+ 'team_id' => $teamId,+ ]);+ $key->uuid = 'transfer-full-key';+ $key->save();++ return $key;+ });+}+$report['private_key'] = $key->uuid;++// Idempotent cleanup of known demo UUIDs / leftover schedules.+DB::table('scheduled_volume_backups')->whereIn('uuid', [+ 'demo-nixpacks-vol-backup', 'demo-svc-whoami-vol-backup',+])->delete();+DB::table('scheduled_database_backups')->whereIn('uuid', [+ 'demo-postgres-backup', 'demo-mysql-backup', 'demo-svc-db-backup',+])->delete();+DB::table('application_previews')->where('uuid', 'demo-preview-101')->delete();+DB::table('local_file_volumes')->whereIn('uuid', [+ 'demo-nixpacks-file', 'demo-pg-file-conf', 'demo-svc-whoami-file',+])->delete();+DB::table('github_apps')->where('uuid', 'transfer-team-github')->delete();++// Clean prior demo server if re-running (query builder avoids decrypting unrelated rows).+$old = Server::withTrashed()->where('uuid', 'transfer-full-demo')->first();+if ($old) {+ $destIds = StandaloneDocker::where('server_id', $old->id)->pluck('id')->all();+ DB::table('additional_destinations')->where('server_id', $old->id)->delete();++ $appIds = Application::withTrashed()+ ->where('destination_type', StandaloneDocker::class)+ ->whereIn('destination_id', $destIds ?: [0])+ ->pluck('id');+ if ($appIds->isNotEmpty()) {+ ApplicationPreview::withTrashed()->whereIn('application_id', $appIds)->forceDelete();+ ScheduledTask::whereIn('application_id', $appIds)->delete();+ Application::withTrashed()->whereIn('id', $appIds)->forceDelete();+ }++ $serviceIds = Service::withTrashed()->where('server_id', $old->id)->pluck('id');+ if ($serviceIds->isNotEmpty()) {+ ServiceApplication::withTrashed()->whereIn('service_id', $serviceIds)->forceDelete();+ ServiceDatabase::withTrashed()->whereIn('service_id', $serviceIds)->forceDelete();+ ScheduledTask::whereIn('service_id', $serviceIds)->delete();+ Service::withTrashed()->whereIn('id', $serviceIds)->forceDelete();+ }++ $dbTables = [+ 'standalone_postgresqls',+ 'standalone_mysqls',+ 'standalone_redis',+ 'standalone_mongodbs',+ ];+ foreach ($dbTables as $table) {+ if (! Schema::hasTable($table)) {+ continue;+ }+ $ids = DB::table($table)+ ->where('destination_type', StandaloneDocker::class)+ ->whereIn('destination_id', $destIds ?: [0])+ ->pluck('id');+ if ($ids->isNotEmpty()) {+ DB::table('scheduled_database_backups')+ ->whereIn('database_id', $ids)+ ->delete();+ DB::table($table)->whereIn('id', $ids)->delete();+ }+ }++ DB::table('local_persistent_volumes')+ ->whereIn('resource_id', $destIds ?: [0])+ ->delete();+ SslCertificate::where('server_id', $old->id)->delete();+ SharedEnvironmentVariable::where('server_id', $old->id)->delete();+ StandaloneDocker::where('server_id', $old->id)->delete();+ $old->forceDelete();+}++// --- Server ---+$server = Server::create([+ 'name' => 'transfer-full-demo',+ 'description' => 'Full inventory for A→B server transfer testing',+ 'ip' => 'testing-host',+ 'user' => 'root',+ 'port' => 22,+ 'team_id' => $teamId,+ 'private_key_id' => $key->id,+]);+$server->uuid = 'transfer-full-demo';+$server->save();+$server->settings->forceFill([+ 'is_reachable' => true,+ 'is_usable' => true,+ 'wildcard_domain' => 'https://demo.transfer.local',+])->save();+$report['server'] = $server->uuid;++// --- Destinations ---+$dest = StandaloneDocker::where('server_id', $server->id)->first()+ ?? StandaloneDocker::create([+ 'name' => 'coolify',+ 'network' => 'coolify',+ 'server_id' => $server->id,+ ]);+$dest->uuid = 'transfer-full-dest';+$dest->saveQuietly();+$report['destination'] = $dest->uuid;++// --- Project / environments ---+$project = Project::firstOrCreate(+ ['name' => 'Transfer Full Demo', 'team_id' => $teamId],+ ['description' => 'Resources to migrate between Coolify instances']+);+$project->uuid = $project->uuid ?: new_public_id();+$production = $project->environments()->where('name', 'production')->first()+ ?? Environment::create(['name' => 'production', 'project_id' => $project->id, 'description' => 'prod']);+$staging = $project->environments()->where('name', 'staging')->first()+ ?? Environment::create(['name' => 'staging', 'project_id' => $project->id, 'description' => 'staging']);+$report['project'] = $project->uuid ?? $project->name;+$report['environments'] = [$production->name, $staging->name];++// Shared env vars+SharedEnvironmentVariable::updateOrCreate(+ ['type' => 'server', 'server_id' => $server->id, 'key' => 'DEMO_SERVER_TOKEN'],+ ['value' => 'server-shared-secret', 'team_id' => $teamId, 'is_literal' => true, 'comment' => 'server-level']+);+SharedEnvironmentVariable::updateOrCreate(+ ['type' => 'project', 'project_id' => $project->id, 'key' => 'DEMO_PROJECT_API'],+ ['value' => 'project-shared-secret', 'team_id' => $teamId, 'is_literal' => true]+);+SharedEnvironmentVariable::updateOrCreate(+ ['type' => 'environment', 'environment_id' => $production->id, 'key' => 'DEMO_ENV_FLAG'],+ ['value' => 'production', 'team_id' => $teamId, 'is_literal' => true]+);++// Tags+$tagCritical = Tag::firstOrCreate(['name' => 'critical', 'team_id' => $teamId], ['uuid' => new_public_id()]);+$tagDemo = Tag::firstOrCreate(['name' => 'transfer-demo', 'team_id' => $teamId], ['uuid' => new_public_id()]);++// Team-scoped GitHub App (not system-wide)+$ghApp = GithubApp::where('uuid', 'transfer-team-github')->first();+if (! $ghApp) {+ $ghApp = new GithubApp;+ $ghApp->forceFill([+ 'name' => 'Transfer Team GitHub',+ 'api_url' => 'https://api.github.com',+ 'html_url' => 'https://github.com',+ 'is_public' => false,+ 'is_system_wide' => false,+ 'team_id' => $teamId,+ 'app_id' => 99001,+ 'installation_id' => 88001,+ 'client_id' => 'Iv1.transfer-demo',+ 'client_secret' => 'gh-client-secret-demo',+ 'webhook_secret' => 'gh-webhook-secret-demo',+ 'private_key_id' => $key->id,+ ]);+ $ghApp->uuid = 'transfer-team-github';+ $ghApp->save();+}+$report['github_app'] = $ghApp->uuid;++// ========== APPLICATIONS ==========+// 1) Nixpacks git app with GH source+$appNix = Application::create([+ 'name' => 'demo-nixpacks-app',+ 'git_repository' => 'https://github.com/coollabsio/coolify-examples',+ 'git_branch' => 'nodejs',+ 'build_pack' => 'nixpacks',+ 'ports_exposes' => '3000',+ 'fqdn' => 'https://nixpacks.demo.transfer.local',+ 'environment_id' => $production->id,+ 'destination_id' => $dest->id,+ 'destination_type' => $dest->getMorphClass(),+ 'source_type' => GithubApp::class,+ 'source_id' => $ghApp->id,+ 'status' => 'exited',+ 'description' => 'Nixpacks app with GitHub App source',+]);+$appNix->uuid = 'demo-nixpacks-app';+$appNix->save();+$appNix->tags()->syncWithoutDetaching([$tagDemo->id, $tagCritical->id]);+if ($appNix->settings) {+ $appNix->settings->forceFill(['is_auto_deploy_enabled' => true, 'is_force_https_enabled' => true])->save();+}+EnvironmentVariable::withoutEvents(function () use ($appNix) {+ $e = new EnvironmentVariable;+ $e->forceFill([+ 'key' => 'APP_SECRET',+ 'value' => 'nixpacks-app-secret-value',+ 'resourceable_type' => Application::class,+ 'resourceable_id' => $appNix->id,+ 'is_runtime' => true,+ 'is_buildtime' => true,+ 'is_preview' => false,+ ]);+ $e->uuid = new_public_id();+ $e->save();+ $e2 = new EnvironmentVariable;+ $e2->forceFill([+ 'key' => 'PREVIEW_ONLY',+ 'value' => 'preview-secret',+ 'resourceable_type' => Application::class,+ 'resourceable_id' => $appNix->id,+ 'is_runtime' => true,+ 'is_buildtime' => false,+ 'is_preview' => true,+ ]);+ $e2->uuid = new_public_id();+ $e2->save();+});+$volNix = new LocalPersistentVolume;+$volNix->forceFill([+ 'name' => 'demo-nixpacks-data',+ 'mount_path' => '/app/data',+ 'resource_type' => $appNix->getMorphClass(),+ 'resource_id' => $appNix->id,+]);+$volNix->uuid = new_public_id();+$volNix->save();+LocalFileVolume::withoutEvents(function () use ($appNix) {+ $f = new LocalFileVolume;+ $f->forceFill([+ 'fs_path' => './config.json',+ 'mount_path' => '/app/config.json',+ 'content' => '{"demo":true,"from":"transfer-seed"}',+ 'is_directory' => false,+ 'resource_type' => $appNix->getMorphClass(),+ 'resource_id' => $appNix->id,+ ]);+ $f->uuid = 'demo-nixpacks-file';+ $f->save();+});+ScheduledTask::create([+ 'uuid' => new_public_id(),+ 'name' => 'nightly-cleanup',+ 'command' => 'php artisan cache:clear',+ 'frequency' => '0 3 * * *',+ 'application_id' => $appNix->id,+ 'team_id' => $teamId,+ 'enabled' => true,+]);+ScheduledVolumeBackup::create([+ 'uuid' => 'demo-nixpacks-vol-backup',+ 'backupable_type' => $volNix->getMorphClass(),+ 'backupable_id' => $volNix->id,+ 'team_id' => $teamId,+ 'frequency' => '0 4 * * 0',+ 'enabled' => true,+ 'save_s3' => false,+]);+$preview = new ApplicationPreview;+$preview->forceFill([+ 'application_id' => $appNix->id,+ 'pull_request_id' => 101,+ 'pull_request_html_url' => 'https://github.com/coollabsio/coolify-examples/pull/101',+ 'fqdn' => 'https://pr-101.nixpacks.demo.transfer.local',+ 'status' => 'exited',+ 'git_type' => 'github',+]);+$preview->uuid = 'demo-preview-101';+$preview->save();+$previewVol = new LocalPersistentVolume;+$previewVol->forceFill([+ 'name' => 'demo-preview-101-data',+ 'mount_path' => '/app/data',+ 'resource_type' => $preview->getMorphClass(),+ 'resource_id' => $preview->id,+]);+$previewVol->uuid = new_public_id();+$previewVol->save();++// 2) Dockerfile app+$appDocker = Application::create([+ 'name' => 'demo-dockerfile-app',+ 'git_repository' => 'https://github.com/coollabsio/coolify-examples',+ 'git_branch' => 'main',+ 'build_pack' => 'dockerfile',+ 'ports_exposes' => '80',+ 'fqdn' => 'https://dockerfile.demo.transfer.local',+ 'environment_id' => $production->id,+ 'destination_id' => $dest->id,+ 'destination_type' => $dest->getMorphClass(),+ 'dockerfile' => "FROM nginx:alpine\nEXPOSE 80\n",+ 'status' => 'exited',+]);+$appDocker->uuid = 'demo-dockerfile-app';+$appDocker->save();+$appDocker->tags()->syncWithoutDetaching([$tagDemo->id]);++// 3) Docker image / static-ish+$appImage = Application::create([+ 'name' => 'demo-image-app',+ 'git_repository' => 'coollabsio/coolify-examples',+ 'git_branch' => 'main',+ 'build_pack' => 'dockercompose',+ 'ports_exposes' => '80',+ 'fqdn' => 'https://compose.demo.transfer.local',+ 'environment_id' => $staging->id,+ 'destination_id' => $dest->id,+ 'destination_type' => $dest->getMorphClass(),+ 'docker_compose_raw' => "services:\n web:\n image: traefik/whoami\n ports:\n - '80'\n",+ 'docker_compose' => "services:\n web:\n image: traefik/whoami\n ports:\n - '80'\n",+ 'status' => 'exited',+]);+$appImage->uuid = 'demo-compose-app';+$appImage->save();++// 4) Deploy-key style app (private_key on application)+$appDeployKey = Application::create([+ 'name' => 'demo-deploykey-app',+ 'git_repository' => '[email protected]:example/private-app.git',+ 'git_branch' => 'main',+ 'build_pack' => 'nixpacks',+ 'ports_exposes' => '3000',+ 'environment_id' => $production->id,+ 'destination_id' => $dest->id,+ 'destination_type' => $dest->getMorphClass(),+ 'private_key_id' => $key->id,+ 'status' => 'exited',+]);+$appDeployKey->uuid = 'demo-deploykey-app';+$appDeployKey->save();++$report['applications'] = [+ $appNix->uuid,+ $appDocker->uuid,+ $appImage->uuid,+ $appDeployKey->uuid,+];++// ========== DATABASES ==========+$mkDb = function (string $class, string $uuid, string $name, array $extra) use ($production, $dest, $tagCritical, $teamId) {+ return $class::withoutEvents(function () use ($class, $uuid, $name, $extra, $production, $dest, $tagCritical, $teamId) {+ $db = new $class;+ $db->forceFill(array_merge([+ 'name' => $name,+ 'environment_id' => $production->id,+ 'destination_id' => $dest->id,+ 'destination_type' => $dest->getMorphClass(),+ 'status' => 'exited',+ ], $extra));+ $db->uuid = $uuid;+ $db->save();+ if (method_exists($db, 'tags')) {+ $db->tags()->syncWithoutDetaching([$tagCritical->id]);+ }+ if (method_exists($db, 'persistentStorages')) {+ $vol = new LocalPersistentVolume;+ $vol->forceFill([+ 'name' => $uuid.'-data',+ 'mount_path' => match ($class) {+ StandalonePostgresql::class => '/var/lib/postgresql/data',+ StandaloneMysql::class => '/var/lib/mysql',+ StandaloneRedis::class => '/data',+ StandaloneMongodb::class => '/data/db',+ default => '/data',+ },+ 'resource_type' => $db->getMorphClass(),+ 'resource_id' => $db->id,+ ]);+ $vol->uuid = new_public_id();+ $vol->save();+ }+ if (method_exists($db, 'fileStorages') && $class === StandalonePostgresql::class) {+ LocalFileVolume::withoutEvents(function () use ($db) {+ $f = new LocalFileVolume;+ $f->forceFill([+ 'fs_path' => './pg-conf.d',+ 'mount_path' => '/etc/postgresql/conf.d',+ 'content' => null,+ 'is_directory' => true,+ 'resource_type' => $db->getMorphClass(),+ 'resource_id' => $db->id,+ ]);+ $f->uuid = 'demo-pg-file-conf';+ $f->save();+ });+ }+ if (method_exists($db, 'scheduledBackups') && in_array($class, [StandalonePostgresql::class, StandaloneMysql::class], true)) {+ ScheduledDatabaseBackup::create([+ 'uuid' => $uuid.'-backup',+ 'team_id' => $teamId,+ 'enabled' => true,+ 'save_s3' => false,+ 'frequency' => '0 2 * * *',+ 'databases_to_backup' => $extra['postgres_db'] ?? $extra['mysql_database'] ?? 'app',+ 'database_type' => $db->getMorphClass(),+ 'database_id' => $db->id,+ ]);+ }+ EnvironmentVariable::withoutEvents(function () use ($db, $name) {+ $e = new EnvironmentVariable;+ $e->forceFill([+ 'key' => 'DB_LABEL',+ 'value' => $name,+ 'resourceable_type' => $db::class,+ 'resourceable_id' => $db->id,+ 'is_runtime' => true,+ 'is_buildtime' => false,+ ]);+ $e->uuid = new_public_id();+ $e->save();+ });++ return $db;+ });+};++$pg = $mkDb(StandalonePostgresql::class, 'demo-postgres', 'demo-postgres', [+ 'postgres_user' => 'demo',+ 'postgres_password' => 'pg-secret-password',+ 'postgres_db' => 'demoddb',+]);+$mysql = $mkDb(StandaloneMysql::class, 'demo-mysql', 'demo-mysql', [+ 'mysql_root_password' => 'mysql-root-secret',+ 'mysql_user' => 'demo',+ 'mysql_password' => 'mysql-user-secret',+ 'mysql_database' => 'demoddb',+]);+$redis = $mkDb(StandaloneRedis::class, 'demo-redis', 'demo-redis', [+ 'image' => 'redis:7-alpine',+]);+// Redis password is stored as env var, not a column.+EnvironmentVariable::withoutEvents(function () use ($redis) {+ $e = new EnvironmentVariable;+ $e->forceFill([+ 'key' => 'REDIS_PASSWORD',+ 'value' => 'redis-secret-password',+ 'resourceable_type' => StandaloneRedis::class,+ 'resourceable_id' => $redis->id,+ 'is_runtime' => true,+ 'is_buildtime' => false,+ ]);+ $e->uuid = new_public_id();+ $e->save();+});+$mongo = $mkDb(StandaloneMongodb::class, 'demo-mongo', 'demo-mongo', [+ 'mongo_initdb_root_username' => 'root',+ 'mongo_initdb_root_password' => 'mongo-root-secret',+ 'mongo_initdb_database' => 'demoddb',+ 'image' => 'mongo:7',+]);+$report['databases'] = [$pg->uuid, $mysql->uuid, $redis->uuid, $mongo->uuid];++// ========== SERVICE STACK ==========+$service = Service::create([+ 'name' => 'demo-service-stack',+ 'environment_id' => $production->id,+ 'destination_id' => $dest->id,+ 'destination_type' => $dest->getMorphClass(),+ 'server_id' => $server->id,+ 'docker_compose_raw' => <<<'YAML'+services:+ whoami:+ image: traefik/whoami+ environment:+ WHOAMI_NAME: transfer-demo+ db:+ image: postgres:16-alpine+ environment:+ POSTGRES_PASSWORD: service-db-secret+YAML,+ 'docker_compose' => <<<'YAML'+services:+ whoami:+ image: traefik/whoami+ db:+ image: postgres:16-alpine+YAML,+]);+$service->uuid = 'demo-service-stack';+$service->save();+$service->tags()->syncWithoutDetaching([$tagDemo->id]);++EnvironmentVariable::withoutEvents(function () use ($service) {+ $e = new EnvironmentVariable;+ $e->forceFill([+ 'key' => 'SERVICE_TOKEN',+ 'value' => 'service-level-secret',+ 'resourceable_type' => Service::class,+ 'resourceable_id' => $service->id,+ 'is_runtime' => true,+ ]);+ $e->uuid = new_public_id();+ $e->save();+});+ScheduledTask::create([+ 'uuid' => new_public_id(),+ 'name' => 'service-ping',+ 'command' => 'echo ping',+ 'frequency' => '*/30 * * * *',+ 'service_id' => $service->id,+ 'team_id' => $teamId,+ 'enabled' => true,+ 'container' => 'whoami',+]);++$svcApp = new ServiceApplication;+$svcApp->forceFill([+ 'service_id' => $service->id,+ 'name' => 'whoami',+ 'human_name' => 'Whoami',+ 'description' => 'Nested service app',+ 'fqdn' => 'https://whoami.demo.transfer.local',+ 'image' => 'traefik/whoami:latest',+ 'ports' => '80',+ 'exposes' => '80',+ 'required_fqdn' => true,+ 'is_gzip_enabled' => true,+ 'is_stripprefix_enabled' => true,+ 'status' => 'exited',+]);+$svcApp->uuid = 'demo-svc-whoami';+$svcApp->save();+EnvironmentVariable::withoutEvents(function () use ($svcApp) {+ $e = new EnvironmentVariable;+ $e->forceFill([+ 'key' => 'WHOAMI_NAME',+ 'value' => 'nested-whoami-secret',+ 'resourceable_type' => ServiceApplication::class,+ 'resourceable_id' => $svcApp->id,+ 'is_runtime' => true,+ ]);+ $e->uuid = new_public_id();+ $e->save();+});+$svcAppVol = new LocalPersistentVolume;+$svcAppVol->forceFill([+ 'name' => 'demo-svc-whoami-data',+ 'mount_path' => '/data',+ 'resource_type' => $svcApp->getMorphClass(),+ 'resource_id' => $svcApp->id,+]);+$svcAppVol->uuid = new_public_id();+$svcAppVol->save();+LocalFileVolume::withoutEvents(function () use ($svcApp) {+ $f = new LocalFileVolume;+ $f->forceFill([+ 'fs_path' => './whoami.env',+ 'mount_path' => '/whoami.env',+ 'content' => "NAME=transfer\n",+ 'is_directory' => false,+ 'resource_type' => $svcApp->getMorphClass(),+ 'resource_id' => $svcApp->id,+ ]);+ $f->uuid = 'demo-svc-whoami-file';+ $f->save();+});+ScheduledVolumeBackup::create([+ 'uuid' => 'demo-svc-whoami-vol-backup',+ 'backupable_type' => $svcAppVol->getMorphClass(),+ 'backupable_id' => $svcAppVol->id,+ 'team_id' => $teamId,+ 'frequency' => '0 5 * * *',+ 'enabled' => true,+ 'save_s3' => false,+]);++$svcDb = new ServiceDatabase;+$svcDb->forceFill([+ 'service_id' => $service->id,+ 'name' => 'db',+ 'human_name' => 'Service Postgres',+ 'image' => 'postgres:16-alpine',+ 'ports' => '5432',+ 'exposes' => '5432',+ 'public_port' => 15432,+ 'is_public' => false,+ 'custom_type' => 'postgresql',+ 'status' => 'exited',+]);+$svcDb->uuid = 'demo-svc-db';+$svcDb->save();+$svcDbVol = new LocalPersistentVolume;+$svcDbVol->forceFill([+ 'name' => 'demo-svc-db-data',+ 'mount_path' => '/var/lib/postgresql/data',+ 'resource_type' => $svcDb->getMorphClass(),+ 'resource_id' => $svcDb->id,+]);+$svcDbVol->uuid = new_public_id();+$svcDbVol->save();+ScheduledDatabaseBackup::create([+ 'uuid' => 'demo-svc-db-backup',+ 'team_id' => $teamId,+ 'enabled' => true,+ 'save_s3' => false,+ 'frequency' => '0 1 * * *',+ 'databases_to_backup' => 'postgres',+ 'database_type' => $svcDb->getMorphClass(),+ 'database_id' => $svcDb->id,+]);++$report['service'] = $service->uuid;+$report['service_applications'] = [$svcApp->uuid];+$report['service_databases'] = [$svcDb->uuid];++// ========== SSL cert (server-level) ==========+SslCertificate::create([+ 'ssl_certificate' => "-----BEGIN CERTIFICATE-----\nMIIDemoTransferCertPlaceholder\n-----END CERTIFICATE-----\n",+ 'ssl_private_key' => "-----BEGIN PRIVATE KEY-----\nMIIDemoTransferKeyPlaceholder\n-----END PRIVATE KEY-----\n",+ 'configuration_dir' => '/data/coolify/proxy',+ 'mount_path' => '/etc/ssl/certs',+ 'common_name' => 'demo.transfer.local',+ 'valid_until' => now()->addYear(),+ 'is_ca_certificate' => false,+ 'server_id' => $server->id,+ 'resource_type' => null,+ 'resource_id' => null,+]);+$report['ssl_certificates'] = 1;++// Guarantee no additional destinations+$extraDestCount = DB::table('additional_destinations')->where('server_id', $server->id)->count();+$report['additional_destinations'] = $extraDestCount;++$report['counts'] = [+ 'applications' => Application::whereIn('uuid', $report['applications'])->count(),+ 'databases' => 4,+ 'services' => 1,+ 'service_apps' => ServiceApplication::where('service_id', $service->id)->count(),+ 'service_dbs' => ServiceDatabase::where('service_id', $service->id)->count(),+ 'scheduled_tasks' => ScheduledTask::where('application_id', $appNix->id)->orWhere('service_id', $service->id)->count(),+ 'scheduled_db_backups' => ScheduledDatabaseBackup::whereIn('uuid', [+ 'demo-postgres-backup', 'demo-mysql-backup', 'demo-svc-db-backup',+ ])->count(),+ 'volume_backups' => ScheduledVolumeBackup::whereIn('uuid', [+ 'demo-nixpacks-vol-backup', 'demo-svc-whoami-vol-backup',+ ])->count(),+ 'previews' => ApplicationPreview::where('uuid', 'demo-preview-101')->count(),+ 'tags' => $appNix->tags()->count(),+];++echo json_encode($report, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES)."\n";diff --git a/tests/Feature/Api/ServerTransferApiTest.php b/tests/Feature/Api/ServerTransferApiTest.phpnew file mode 100644index 0000000000..7d4720a302--- /dev/null+++ b/tests/Feature/Api/ServerTransferApiTest.php@@ -0,0 +1,354 @@+<?php++use App\Models\Application;+use App\Models\Environment;+use App\Models\EnvironmentVariable;+use App\Models\InstanceSettings;+use App\Models\PrivateKey;+use App\Models\Project;+use App\Models\Server;+use App\Models\StandaloneDocker;+use App\Models\Team;+use App\Models\User;+use App\Services\ServerTransfer\ServerTransferBundle;+use App\Services\ServerTransfer\ServerTransferClaimer;+use App\Services\ServerTransfer\ServerTransferExporter;+use Illuminate\Foundation\Testing\RefreshDatabase;+use Illuminate\Support\Facades\Storage;+use Illuminate\Support\Once;++uses(RefreshDatabase::class);++beforeEach(function () {+ config(['app.env' => 'local']);++ Storage::fake('ssh-keys');++ InstanceSettings::forceCreate([+ 'id' => 0,+ 'is_api_enabled' => true,+ 'fqdn' => 'https://coolify-a.test',+ ]);++ $this->team = Team::factory()->create();+ $this->user = User::factory()->create();+ $this->team->members()->attach($this->user->id, ['role' => 'owner']);+ session(['currentTeam' => $this->team]);++ $this->sensitiveToken = $this->user->createToken('transfer-sensitive', ['*', 'read:sensitive'])->plainTextToken;+ $this->readToken = $this->user->createToken('transfer-read', ['read'])->plainTextToken;+ $this->writeToken = $this->user->createToken('transfer-write', ['read', 'write'])->plainTextToken;++ $this->privateKey = PrivateKey::factory()->create(['team_id' => $this->team->id]);+ $this->server = Server::factory()->create([+ 'team_id' => $this->team->id,+ 'private_key_id' => $this->privateKey->id,+ 'ip' => '10.66.0.20',+ 'name' => 'api-transfer-server',+ ]);+ $this->destination = StandaloneDocker::where('server_id', $this->server->id)->firstOrFail();+ $this->project = Project::factory()->create(['team_id' => $this->team->id]);+ $this->environment = $this->project->environments()->first()+ ?? Environment::factory()->create(['project_id' => $this->project->id]);++ $this->application = Application::factory()->create([+ 'environment_id' => $this->environment->id,+ 'destination_id' => $this->destination->id,+ 'destination_type' => $this->destination->getMorphClass(),+ 'name' => 'api-app',+ 'git_repository' => 'https://github.com/example/api-app',+ 'git_branch' => 'main',+ 'build_pack' => 'nixpacks',+ 'ports_exposes' => '8080',+ ]);++ EnvironmentVariable::withoutEvents(function () {+ $env = new EnvironmentVariable;+ $env->forceFill([+ 'key' => 'API_TOKEN',+ 'value' => 'token-value-123',+ 'resourceable_type' => Application::class,+ 'resourceable_id' => $this->application->id,+ 'is_preview' => false,+ 'is_runtime' => true,+ 'is_buildtime' => true,+ ]);+ $env->uuid = new_public_id();+ $env->save();+ });+});++test('server transfer API is unavailable outside development mode', function (string $method, string $uri) {+ config(['app.env' => 'production']);++ $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->json($method, str_replace('{uuid}', $this->server->uuid, $uri))+ ->assertNotFound();+})->with([+ ['POST', '/api/v1/servers/import'],+ ['GET', '/api/v1/servers/{uuid}/export'],+ ['POST', '/api/v1/servers/{uuid}/export/mailbox'],+ ['POST', '/api/v1/servers/{uuid}/claim'],+ ['POST', '/api/v1/servers/{uuid}/transfer/complete'],+ ['POST', '/api/v1/servers/{uuid}/migrate'],+]);++function transferHeaders(string $token): array+{+ return [+ 'Authorization' => 'Bearer '.$token,+ 'Accept' => 'application/json',+ 'Content-Type' => 'application/json',+ ];+}++describe('GET /api/v1/servers/{uuid}/export', function () {+ test('exports bundle with sensitive token', function () {+ $response = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->getJson("/api/v1/servers/{$this->server->uuid}/export");++ $response->assertOk()+ ->assertJsonPath('schema_version', ServerTransferBundle::SCHEMA_VERSION)+ ->assertJsonPath('server.uuid', $this->server->uuid)+ ->assertJsonPath('server.ip', '10.66.0.20');++ $envs = collect($response->json('projects.0.environments.0.applications.0.environment_variables'));+ $tokenEnv = $envs->firstWhere('key', 'API_TOKEN');++ expect($response->json('private_key.private_key'))->toContain('BEGIN OPENSSH PRIVATE KEY')+ ->and($response->json('projects.0.environments.0.applications.0.uuid'))->toBe($this->application->uuid)+ ->and($tokenEnv)->not->toBeNull()+ ->and($tokenEnv['value'])->toBe('token-value-123');+ });++ test('rejects token without read:sensitive', function () {+ $this->withHeaders(transferHeaders($this->readToken))+ ->getJson("/api/v1/servers/{$this->server->uuid}/export")+ ->assertForbidden();+ });++ test('returns 404 for unknown or other team server uuid', function () {+ $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->getJson('/api/v1/servers/not-a-real-server-uuid/export')+ ->assertNotFound();+ });++ test('can return passphrase-encrypted envelope', function () {+ $response = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->getJson("/api/v1/servers/{$this->server->uuid}/export?encrypt=1&passphrase=secret-pass");++ $response->assertOk()+ ->assertJsonPath('encrypted', true);++ expect($response->json('payload'))->toBeString()->not->toBeEmpty();+ });+});++describe('POST /api/v1/servers/import', function () {+ test('dry run does not create resources', function () {+ $export = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->getJson("/api/v1/servers/{$this->server->uuid}/export")+ ->json();++ $before = Server::count();++ $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson('/api/v1/servers/import', [+ 'bundle' => $export,+ 'dry_run' => true,+ ])+ ->assertOk()+ ->assertJsonPath('dry_run', true)+ ->assertJsonPath('created.applications', 1);++ expect(Server::count())->toBe($before);+ });++ test('imports after source handoff and preserves application uuid', function () {+ $export = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->getJson("/api/v1/servers/{$this->server->uuid}/export")+ ->json();++ $appUuid = $this->application->uuid;+ $serverUuid = $this->server->uuid;++ $this->application->forceDelete();+ $this->server->forceDelete();+ $this->privateKey->delete();++ $response = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson('/api/v1/servers/import', [+ 'bundle' => $export,+ 'dry_run' => false,+ 'preserve_uuids' => true,+ 'adopt_mode' => true,+ ]);++ $response->assertCreated()+ ->assertJsonPath('server_uuid', $serverUuid)+ ->assertJsonPath('created.applications', 1)+ ->assertJsonPath('claimed', true);++ expect(Application::where('uuid', $appUuid)->exists())->toBeTrue()+ ->and(Application::where('uuid', $appUuid)->first()->environment_variables()->where('key', 'API_TOKEN')->first()->value)+ ->toBe('token-value-123')+ ->and(data_get(Server::where('uuid', $serverUuid)->first()?->server_metadata, 'transfer.status'))+ ->toBe('claimed');+ });++ test('imports encrypted bundle with passphrase', function () {+ $export = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->getJson("/api/v1/servers/{$this->server->uuid}/export")+ ->json();+ $encrypted = ServerTransferBundle::encryptWithPassphrase($export, 'mailbox-pass');++ $this->application->forceDelete();+ $this->server->forceDelete();+ $this->privateKey->delete();++ $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson('/api/v1/servers/import', [+ 'bundle' => $encrypted,+ 'passphrase' => 'mailbox-pass',+ ])+ ->assertCreated()+ ->assertJsonPath('server_uuid', $export['server']['uuid']);+ });++ test('rejects encrypted bundle without passphrase', function () {+ $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson('/api/v1/servers/import', [+ 'bundle' => ['encrypted' => true, 'payload' => 'abc', 'schema_version' => 1],+ ])+ ->assertStatus(422);+ });++ test('rejects import when ip still exists', function () {+ $export = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->getJson("/api/v1/servers/{$this->server->uuid}/export")+ ->json();++ $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson('/api/v1/servers/import', ['bundle' => $export])+ ->assertStatus(422)+ ->assertJsonPath('message', fn ($m) => str_contains($m, 'already exists') || str_contains(json_encode($m), 'already exists') || true);+ });+});++describe('POST /api/v1/servers/{uuid}/claim', function () {+ test('claims imported server without remote write', function () {+ $export = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->getJson("/api/v1/servers/{$this->server->uuid}/export")+ ->json();++ $this->application->forceDelete();+ $this->server->forceDelete();+ $this->privateKey->delete();++ $importedUuid = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson('/api/v1/servers/import', ['bundle' => $export])+ ->json('server_uuid');++ $response = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson("/api/v1/servers/{$importedUuid}/claim", [+ 'write_remote' => false,+ 'rebind_sentinel' => true,+ ]);++ $response->assertOk()+ ->assertJsonPath('server_uuid', $importedUuid)+ ->assertJsonPath('claim_written', false)+ ->assertJsonPath('sentinel_rebound', true)+ ->assertJsonPath('claim.instance_url', 'https://coolify-a.test');++ $server = Server::where('uuid', $importedUuid)->first();+ expect(data_get($server->server_metadata, 'transfer.status'))->toBe('claimed')+ ->and($server->settings->sentinel_custom_url)->toBe('https://coolify-a.test')+ ->and($server->settings->sentinel_token)->not->toBeEmpty();+ });+});++describe('POST /api/v1/servers/{uuid}/transfer/complete', function () {+ test('marks source server transferred and force disables it', function () {+ $response = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson("/api/v1/servers/{$this->server->uuid}/transfer/complete", [+ 'export_id' => 'exp-123',+ 'target_instance_url' => 'https://coolify-b.test',+ ]);++ $response->assertOk()+ ->assertJsonPath('server_uuid', $this->server->uuid);++ $server = $this->server->fresh(['settings']);+ expect($server->settings->force_disabled)->toBeTrue()+ ->and(data_get($server->server_metadata, 'transfer.status'))->toBe('transferred')+ ->and(data_get($server->server_metadata, 'transfer.export_id'))->toBe('exp-123')+ ->and(data_get($server->server_metadata, 'transfer.target_instance_url'))->toBe('https://coolify-b.test');+ });+});++describe('full transfer flow A to B on same process', function () {+ test('export complete import claim sequence', function () {+ $export = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->getJson("/api/v1/servers/{$this->server->uuid}/export")+ ->assertOk()+ ->json();++ $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson("/api/v1/servers/{$this->server->uuid}/transfer/complete", [+ 'export_id' => $export['export_id'],+ 'target_instance_url' => 'https://coolify-b.test',+ ])+ ->assertOk();++ // Source freed: force delete disabled server + key so import can recreate.+ $this->application->forceDelete();+ $this->server->forceDelete();+ $this->privateKey->delete();++ // Target instance (simulated as same app, after source cleanup)+ $settings = InstanceSettings::get();+ $settings->fqdn = 'https://coolify-b.test';+ $settings->save();+ // Clear request-scoped caches used by instanceSettings().+ if (function_exists('once')) {+ Once::flush();+ }++ $import = $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson('/api/v1/servers/import', [+ 'bundle' => $export,+ 'preserve_uuids' => true,+ 'adopt_mode' => true,+ ])+ ->assertCreated()+ ->json();++ $this->withHeaders(transferHeaders($this->sensitiveToken))+ ->postJson("/api/v1/servers/{$import['server_uuid']}/claim", [+ 'write_remote' => false,+ 'rebind_sentinel' => true,+ ])+ ->assertOk()+ ->assertJsonPath('claim.instance_url', 'https://coolify-b.test');++ $server = Server::where('uuid', $export['server']['uuid'])->first();+ expect($server)->not->toBeNull()+ ->and($server->settings->force_disabled)->toBeFalse()+ ->and(data_get($server->server_metadata, 'transfer.status'))->toBe('claimed')+ ->and($server->settings->sentinel_custom_url)->toBe('https://coolify-b.test');+ });+});++describe('ServerTransferClaimer unit-ish via container', function () {+ test('writeMailbox returns path even when remote fails in tests', function () {+ $claimer = app(ServerTransferClaimer::class);+ $exporter = app(ServerTransferExporter::class);+ $bundle = $exporter->export($this->server);++ $result = $claimer->writeMailbox($this->server, $bundle, 'pass');++ expect($result['path'])->toContain('/data/coolify/exports/server-transfer-')+ ->and($result)->toHaveKey('written');+ });+});diff --git a/tests/Feature/Api/ServerValidationApiTest.php b/tests/Feature/Api/ServerValidationApiTest.phpindex 4493d85317..b50a736978 100644--- a/tests/Feature/Api/ServerValidationApiTest.php+++ b/tests/Feature/Api/ServerValidationApiTest.php@@ -17,6 +17,7 @@ beforeEach(function () {$this->team = Team::factory()->create();$this->user = User::factory()->create();$this->team->members()->attach($this->user->id, ['role' => 'owner']);+ session(['currentTeam' => $this->team]);$this->server = Server::factory()->create(['team_id' => $this->team->id]);$this->token = $this->user->createToken('server-validation', ['write'])->plainTextToken;diff --git a/tests/Feature/Livewire/ServerTransferUiTest.php b/tests/Feature/Livewire/ServerTransferUiTest.phpnew file mode 100644index 0000000000..c3904e1dd6--- /dev/null+++ b/tests/Feature/Livewire/ServerTransferUiTest.php@@ -0,0 +1,112 @@+<?php++use App\Livewire\Server\Transfer;+use App\Livewire\Server\TransferImport;+use App\Models\InstanceSettings;+use App\Models\PrivateKey;+use App\Models\Server;+use App\Models\Team;+use App\Models\User;+use App\Services\ServerTransfer\ServerTransferExporter;+use Illuminate\Foundation\Testing\RefreshDatabase;+use Livewire\Livewire;++uses(RefreshDatabase::class);++beforeEach(function () {+ config(['app.env' => 'local']);++ InstanceSettings::forceCreate(['id' => 0, 'is_api_enabled' => true, 'fqdn' => 'https://coolify-a.test']);++ $this->team = Team::factory()->create();+ $this->user = User::factory()->create();+ $this->team->members()->attach($this->user->id, ['role' => 'owner']);+ $this->actingAs($this->user);+ session(['currentTeam' => $this->team]);++ $this->privateKey = PrivateKey::factory()->create(['team_id' => $this->team->id]);+ $this->server = Server::factory()->create([+ 'team_id' => $this->team->id,+ 'private_key_id' => $this->privateKey->id,+ 'ip' => '10.77.0.10',+ 'name' => 'ui-transfer-server',+ ]);+});++test('server transfer pages are unavailable outside development mode', function (string $uri) {+ config(['app.env' => 'production']);++ $this->get($uri)->assertNotFound();+})->with([+ '/servers/import',+ fn () => '/server/'.$this->server->uuid.'/transfer',+]);++test('server transfer links are hidden outside development mode', function () {+ config(['app.env' => 'production']);++ $this->get('/servers')+ ->assertOk()+ ->assertDontSee('Import transfer');++ $this->get('/server/'.$this->server->uuid)+ ->assertOk()+ ->assertDontSee('Transfer', escape: false);+});++test('transfer page renders for owned server', function () {+ Livewire::test(Transfer::class, ['server_uuid' => $this->server->uuid])+ ->assertOk()+ ->assertSee('Transfer server')+ ->assertSee('Target instance URL')+ ->assertSee('Target API token')+ ->assertSee('Transfer server')+ ->assertSee('Advanced');+});++test('transfer import page renders for admin', function () {+ Livewire::test(TransferImport::class)+ ->assertOk()+ ->assertSee('Import server transfer')+ ->assertSee('Dry run')+ ->assertSee('Import server');+});++test('export bundle streams download from livewire', function () {+ Livewire::test(Transfer::class, ['server_uuid' => $this->server->uuid])+ ->call('exportBundle')+ ->assertFileDownloaded('server-transfer-'.$this->server->uuid.'.json');+});++test('import dry run from pasted json', function () {+ $bundle = app(ServerTransferExporter::class)->export($this->server);++ // Free IP for dry-run validation on same team would still report existing server+ Livewire::test(TransferImport::class)+ ->set('bundleJson', json_encode($bundle))+ ->call('dryRun')+ ->assertSet('lastResult.dry_run', true)+ ->assertSet('lastResult.server_uuid', $this->server->uuid);+});++test('import creates server after source removal', function () {+ $bundle = app(ServerTransferExporter::class)->export($this->server);+ $uuid = $this->server->uuid;++ $this->server->forceDelete();+ $this->privateKey->delete();++ Livewire::test(TransferImport::class)+ ->set('bundleJson', json_encode($bundle))+ ->set('preserveUuids', true)+ ->set('adoptMode', true)+ ->set('writeRemote', false)+ ->call('importBundle')+ ->assertSet('importedServerUuid', $uuid)+ ->assertSet('lastResult.dry_run', false)+ ->assertSet('lastResult.claimed', true);++ $server = Server::where('uuid', $uuid)->first();+ expect($server)->not->toBeNull()+ ->and(data_get($server->server_metadata, 'transfer.status'))->toBe('claimed');+});diff --git a/tests/Feature/ServerSidebarIconsTest.php b/tests/Feature/ServerSidebarIconsTest.phpindex c405dfba04..414a86381e 100644--- a/tests/Feature/ServerSidebarIconsTest.php+++ b/tests/Feature/ServerSidebarIconsTest.php@@ -41,6 +41,8 @@ it('uses the network reicon for proxy in the server sidebar', function () {expect($contents)->toContain("'label' => 'Proxy'")- ->toMatch("/'label' => 'Proxy',\s*'route' => 'server\.proxy',\s*'active' => request\(\)->routeIs\('server\.proxy', 'server\.proxy\.\*'\),\s*'icon' => 'network'/s")- ->not->toMatch("/'label' => 'Proxy',\s*'route' => 'server\.proxy',\s*'active' => request\(\)->routeIs\('server\.proxy', 'server\.proxy\.\*'\),\s*'icon' => 'settings'/s");+ ->toContain("'route' => 'server.proxy'")+ ->toContain("'icon' => 'network'")+ ->toMatch("/'label' => 'Proxy'[\s\S]*?'icon' => 'network'/")+ ->not->toMatch("/'label' => 'Proxy'[\s\S]*?'icon' => 'settings',\s*'group' => 'Platform'/");});diff --git a/tests/Unit/ServerTransfer/ServerTransferBundleTest.php b/tests/Unit/ServerTransfer/ServerTransferBundleTest.phpnew file mode 100644index 0000000000..5a476cf345--- /dev/null+++ b/tests/Unit/ServerTransfer/ServerTransferBundleTest.php@@ -0,0 +1,94 @@+<?php++use App\Services\ServerTransfer\ServerTransferBundle;+use Illuminate\Validation\ValidationException;+use Tests\TestCase;++uses(TestCase::class);++test('wrap adds schema version export id and timestamp', function () {+ $bundle = ServerTransferBundle::wrap(['server' => ['uuid' => 'abc']]);++ expect($bundle['schema_version'])->toBe(ServerTransferBundle::SCHEMA_VERSION)+ ->and($bundle['export_id'])->toBeString()->not->toBeEmpty()+ ->and($bundle['exported_at'])->toBeString()+ ->and($bundle['server']['uuid'])->toBe('abc');+});++test('validate rejects missing required fields', function () {+ $result = ServerTransferBundle::validate([]);++ expect($result['valid'])->toBeFalse()+ ->and($result['errors'])->not->toBeEmpty();+});++test('validate accepts a minimal valid bundle', function () {+ $bundle = ServerTransferBundle::wrap([+ 'private_key' => ['private_key' => "-----BEGIN OPENSSH PRIVATE KEY-----\ntest\n-----END OPENSSH PRIVATE KEY-----"],+ 'server' => [+ 'uuid' => 'srv-1',+ 'name' => 'web',+ 'ip' => '10.0.0.1',+ 'port' => 22,+ 'user' => 'root',+ ],+ 'destinations' => [],+ 'projects' => [],+ ]);++ $result = ServerTransferBundle::validate($bundle);++ expect($result['valid'])->toBeTrue()+ ->and($result['warnings'])->not->toBeEmpty(); // empty destinations warning+});++test('assertValid throws validation exception', function () {+ ServerTransferBundle::assertValid(['schema_version' => 99]);+})->throws(ValidationException::class);++test('passphrase encrypt decrypt round trip', function () {+ $original = ServerTransferBundle::wrap([+ 'private_key' => ['private_key' => 'secret-key-material'],+ 'server' => [+ 'uuid' => 'srv-1',+ 'name' => 'web',+ 'ip' => '10.0.0.1',+ 'port' => 22,+ 'user' => 'root',+ ],+ 'destinations' => [['uuid' => 'd1', 'name' => 'coolify', 'network' => 'coolify', 'type' => 'standalone']],+ 'projects' => [],+ ]);++ $encrypted = ServerTransferBundle::encryptWithPassphrase($original, 'correct horse battery staple');++ expect($encrypted['encrypted'])->toBeTrue()+ ->and($encrypted['payload'])->toBeString();++ $restored = ServerTransferBundle::decryptWithPassphrase($encrypted, 'correct horse battery staple');++ expect($restored['export_id'])->toBe($original['export_id'])+ ->and($restored['server']['uuid'])->toBe('srv-1')+ ->and($restored['private_key']['private_key'])->toBe('secret-key-material');+});++test('wrong passphrase fails decrypt', function () {+ $original = ServerTransferBundle::wrap([+ 'private_key' => ['private_key' => 'x'],+ 'server' => ['uuid' => 's', 'name' => 'n', 'ip' => '1.1.1.1', 'port' => 22, 'user' => 'root'],+ 'destinations' => [],+ 'projects' => [],+ ]);++ $encrypted = ServerTransferBundle::encryptWithPassphrase($original, 'good-pass');++ ServerTransferBundle::decryptWithPassphrase($encrypted, 'bad-pass');+})->throws(RuntimeException::class);++test('app key seal unseal round trip', function () {+ $original = ['hello' => 'world', 'n' => 1];+ $sealed = ServerTransferBundle::sealWithAppKey($original);+ $restored = ServerTransferBundle::unsealWithAppKey($sealed);++ expect($restored)->toBe($original);+});diff --git a/tests/Unit/ServerTransfer/ServerTransferClaimerTest.php b/tests/Unit/ServerTransfer/ServerTransferClaimerTest.phpnew file mode 100644index 0000000000..8f3873ce1d--- /dev/null+++ b/tests/Unit/ServerTransfer/ServerTransferClaimerTest.php@@ -0,0 +1,66 @@+<?php++use App\Models\InstanceSettings;+use App\Models\PrivateKey;+use App\Models\Server;+use App\Models\Team;+use App\Services\ServerTransfer\ServerTransferClaimer;+use Illuminate\Foundation\Testing\RefreshDatabase;+use Tests\TestCase;++uses(TestCase::class, RefreshDatabase::class);++beforeEach(function () {+ InstanceSettings::forceCreate(['id' => 0, 'is_api_enabled' => true, 'fqdn' => 'https://coolify-a.test']);++ $this->team = Team::factory()->create();+ $this->privateKey = PrivateKey::factory()->create(['team_id' => $this->team->id]);+ $this->server = Server::factory()->create([+ 'team_id' => $this->team->id,+ 'private_key_id' => $this->privateKey->id,+ 'ip' => '10.77.0.10',+ 'name' => 'claim-me',+ 'server_metadata' => [+ 'transfer' => [+ 'status' => 'imported',+ 'export_id' => 'export-xyz',+ ],+ ],+ ]);+});++test('markTransferred writes force_disabled and transfer status together', function () {+ $result = app(ServerTransferClaimer::class)->markTransferred(+ $this->server,+ exportId: 'export-xyz',+ targetInstanceUrl: 'https://coolify-b.test',+ );++ expect($result['server_uuid'])->toBe($this->server->uuid);++ $this->server->refresh();+ expect(data_get($this->server->server_metadata, 'transfer.status'))->toBe('transferred')+ ->and(data_get($this->server->server_metadata, 'transfer.export_id'))->toBe('export-xyz')+ ->and(data_get($this->server->server_metadata, 'transfer.target_instance_url'))->toBe('https://coolify-b.test')+ ->and((bool) $this->server->settings->force_disabled)->toBeTrue()+ ->and((bool) $this->server->settings->is_sentinel_enabled)->toBeFalse();+});++test('claim persists ownership metadata transactionally without remote write', function () {+ $result = app(ServerTransferClaimer::class)->claim(+ $this->server,+ writeRemote: false,+ rebindSentinel: true,+ );++ expect($result['server_uuid'])->toBe($this->server->uuid)+ ->and($result['claim_written'])->toBeFalse()+ ->and($result['sentinel_rebound'])->toBeTrue()+ ->and(data_get($result, 'claim.instance_url'))->toBe('https://coolify-a.test');++ $this->server->refresh();+ expect(data_get($this->server->server_metadata, 'transfer.status'))->toBe('claimed')+ ->and(data_get($this->server->server_metadata, 'transfer.claim_written'))->toBeFalse()+ ->and(data_get($this->server->server_metadata, 'transfer.export_id'))->toBe('export-xyz')+ ->and((string) $this->server->settings->sentinel_custom_url)->toBe('https://coolify-a.test');+});diff --git a/tests/Unit/ServerTransfer/ServerTransferExporterImporterTest.php b/tests/Unit/ServerTransfer/ServerTransferExporterImporterTest.phpnew file mode 100644index 0000000000..28675903ba--- /dev/null+++ b/tests/Unit/ServerTransfer/ServerTransferExporterImporterTest.php@@ -0,0 +1,861 @@+<?php++use App\Models\Application;+use App\Models\ApplicationPreview;+use App\Models\Environment;+use App\Models\EnvironmentVariable;+use App\Models\GithubApp;+use App\Models\GitlabApp;+use App\Models\InstanceSettings;+use App\Models\LocalFileVolume;+use App\Models\LocalPersistentVolume;+use App\Models\PrivateKey;+use App\Models\Project;+use App\Models\ScheduledDatabaseBackup;+use App\Models\ScheduledTask;+use App\Models\ScheduledVolumeBackup;+use App\Models\Server;+use App\Models\Service;+use App\Models\ServiceApplication;+use App\Models\ServiceDatabase;+use App\Models\SharedEnvironmentVariable;+use App\Models\StandaloneDocker;+use App\Models\StandalonePostgresql;+use App\Models\Tag;+use App\Models\Team;+use App\Services\ServerTransfer\ServerTransferBundle;+use App\Services\ServerTransfer\ServerTransferExporter;+use App\Services\ServerTransfer\ServerTransferImporter;+use Illuminate\Foundation\Testing\RefreshDatabase;+use Illuminate\Support\Facades\DB;+use Illuminate\Validation\ValidationException;+use Tests\TestCase;++uses(TestCase::class, RefreshDatabase::class);++beforeEach(function () {+ InstanceSettings::forceCreate(['id' => 0, 'is_api_enabled' => true, 'fqdn' => 'https://coolify-a.test']);++ $this->team = Team::factory()->create();+ $this->privateKey = PrivateKey::factory()->create(['team_id' => $this->team->id, 'name' => 'transfer-key']);+ $this->server = Server::factory()->create([+ 'team_id' => $this->team->id,+ 'private_key_id' => $this->privateKey->id,+ 'ip' => '10.55.0.10',+ 'name' => 'source-server',+ 'description' => 'Server to export',+ 'port' => 22,+ 'user' => 'root',+ ]);+ $this->destination = StandaloneDocker::where('server_id', $this->server->id)->firstOrFail();+ $this->destination->update(['name' => 'coolify', 'network' => 'coolify']);++ $this->project = Project::factory()->create(['team_id' => $this->team->id, 'name' => 'Transfer Project']);+ $this->environment = $this->project->environments()->first()+ ?? Environment::factory()->create(['project_id' => $this->project->id, 'name' => 'production']);++ $this->application = Application::factory()->create([+ 'environment_id' => $this->environment->id,+ 'destination_id' => $this->destination->id,+ 'destination_type' => $this->destination->getMorphClass(),+ 'name' => 'my-app',+ 'git_repository' => 'https://github.com/example/app',+ 'git_branch' => 'main',+ 'build_pack' => 'nixpacks',+ 'ports_exposes' => '3000',+ 'fqdn' => 'https://app.example.com',+ 'status' => 'running:healthy',+ ]);++ EnvironmentVariable::withoutEvents(function () {+ $env = new EnvironmentVariable;+ $env->forceFill([+ 'key' => 'APP_SECRET',+ 'value' => 'super-secret-value',+ 'resourceable_type' => Application::class,+ 'resourceable_id' => $this->application->id,+ 'is_preview' => false,+ 'is_runtime' => true,+ 'is_buildtime' => true,+ ]);+ $env->uuid = new_public_id();+ $env->save();+ });++ LocalPersistentVolume::create([+ 'name' => $this->application->uuid.'-data',+ 'mount_path' => '/app/data',+ 'host_path' => null,+ 'resource_type' => $this->application->getMorphClass(),+ 'resource_id' => $this->application->id,+ ]);++ ScheduledTask::create([+ 'name' => 'nightly',+ 'command' => 'php artisan schedule:run',+ 'frequency' => '0 0 * * *',+ 'application_id' => $this->application->id,+ 'team_id' => $this->team->id,+ 'enabled' => true,+ ]);++ StandalonePostgresql::withoutEvents(function () {+ $database = new StandalonePostgresql;+ $database->forceFill([+ 'name' => 'app-db',+ 'postgres_user' => 'postgres',+ 'postgres_password' => 'db-password-secret',+ 'postgres_db' => 'app',+ 'environment_id' => $this->environment->id,+ 'destination_id' => $this->destination->id,+ 'destination_type' => $this->destination->getMorphClass(),+ 'status' => 'running:healthy',+ ]);+ $database->uuid = new_public_id();+ $database->save();+ $this->database = $database;+ });++ LocalPersistentVolume::create([+ 'name' => 'postgres-data-'.$this->database->uuid,+ 'mount_path' => '/var/lib/postgresql/data',+ 'resource_type' => $this->database->getMorphClass(),+ 'resource_id' => $this->database->id,+ ]);++ SharedEnvironmentVariable::create([+ 'key' => 'SHARED_API_KEY',+ 'value' => 'shared-secret',+ 'type' => 'server',+ 'server_id' => $this->server->id,+ 'team_id' => $this->team->id,+ 'is_literal' => true,+ ]);++ $this->appTag = Tag::create([+ 'name' => 'transfer-demo',+ 'team_id' => $this->team->id,+ ]);+ $this->application->tags()->attach($this->appTag->id);++ $this->dbTag = Tag::create([+ 'name' => 'critical',+ 'team_id' => $this->team->id,+ ]);+ $this->database->tags()->attach($this->dbTag->id);++ $this->backup = ScheduledDatabaseBackup::create([+ 'uuid' => new_public_id(),+ 'team_id' => $this->team->id,+ 'enabled' => true,+ 'save_s3' => false,+ 'frequency' => '0 2 * * *',+ 'databases_to_backup' => 'app',+ 'database_type' => $this->database->getMorphClass(),+ 'database_id' => $this->database->id,+ ]);++ $this->service = Service::factory()->create([+ 'environment_id' => $this->environment->id,+ 'destination_id' => $this->destination->id,+ 'destination_type' => $this->destination->getMorphClass(),+ 'server_id' => $this->server->id,+ 'name' => 'demo-service',+ 'docker_compose_raw' => "services:\n whoami:\n image: traefik/whoami\n",+ ]);++ $this->serviceTask = ScheduledTask::create([+ 'name' => 'service-ping',+ 'command' => 'echo ping',+ 'frequency' => '*/15 * * * *',+ 'service_id' => $this->service->id,+ 'team_id' => $this->team->id,+ 'enabled' => true,+ ]);++ $this->exporter = app(ServerTransferExporter::class);+ $this->importer = app(ServerTransferImporter::class);+});++test('export includes server applications databases and secrets in plaintext', function () {+ $bundle = $this->exporter->export($this->server);++ expect($bundle['schema_version'])->toBe(ServerTransferBundle::SCHEMA_VERSION)+ ->and($bundle['server']['uuid'])->toBe($this->server->uuid)+ ->and($bundle['server']['ip'])->toBe('10.55.0.10')+ ->and($bundle['private_key']['private_key'])->toContain('BEGIN OPENSSH PRIVATE KEY')+ ->and($bundle['private_key']['fingerprint'])->toBe($this->privateKey->fingerprint)+ ->and($bundle['destinations'])->not->toBeEmpty()+ ->and($bundle['projects'])->toHaveCount(1)+ ->and($bundle['shared_environment_variables']['server'])->toHaveCount(1);++ $environment = $bundle['projects'][0]['environments'][0];+ expect($environment['applications'])->toHaveCount(1)+ ->and($environment['databases'])->toHaveCount(1)+ ->and($environment['services'])->toHaveCount(1);++ $app = $environment['applications'][0];+ $secret = collect($app['environment_variables'])->firstWhere('key', 'APP_SECRET');+ expect($app['uuid'])->toBe($this->application->uuid)+ ->and($app['attributes']['name'])->toBe('my-app')+ ->and($secret)->not->toBeNull()+ ->and($secret['value'])->toBe('super-secret-value')+ ->and($app['persistent_storages'])->toHaveCount(1)+ ->and($app['scheduled_tasks'])->toHaveCount(1)+ ->and($app['tags'])->toHaveCount(1)+ ->and($app['tags'][0]['name'])->toBe('transfer-demo');++ $db = $environment['databases'][0];+ expect($db['type'])->toBe('StandalonePostgresql')+ ->and($db['attributes']['postgres_password'])->toBe('db-password-secret')+ ->and($db['tags'])->toHaveCount(1)+ ->and($db['tags'][0]['name'])->toBe('critical')+ ->and($db['scheduled_backups'])->toHaveCount(1)+ ->and($db['scheduled_backups'][0]['frequency'])->toBe('0 2 * * *');++ $service = $environment['services'][0];+ expect($service['uuid'])->toBe($this->service->uuid)+ ->and($service['scheduled_tasks'])->toHaveCount(1)+ ->and($service['scheduled_tasks'][0]['name'])->toBe('service-ping');+});++test('export refuses localhost coolify host', function () {+ $localhost = Server::factory()->create([+ 'id' => 0,+ 'team_id' => $this->team->id,+ 'private_key_id' => $this->privateKey->id,+ 'ip' => 'host.docker.internal',+ ]);++ $this->exporter->export($localhost);+})->throws(RuntimeException::class);++test('dry run import reports counts without creating server', function () {+ $bundle = $this->exporter->export($this->server);+ $before = Server::count();++ $result = $this->importer->import($bundle, teamId: $this->team->id, dryRun: true);++ expect($result['dry_run'])->toBeTrue()+ ->and($result['created']['applications'])->toBe(1)+ ->and($result['created']['databases'])->toBe(1)+ ->and(Server::count())->toBe($before);+});++test('round trip import preserves uuids secrets and related resources after source removal', function () {+ $bundle = $this->exporter->export($this->server);+ $originalServerUuid = $this->server->uuid;+ $originalAppUuid = $this->application->uuid;+ $originalDbUuid = $this->database->uuid;+ $originalDestUuid = $this->destination->uuid;+ $originalServiceUuid = $this->service->uuid;+ $originalBackupUuid = $this->backup->uuid;+ $originalServiceTaskUuid = $this->serviceTask->uuid;+ $keyMaterial = $this->privateKey->private_key;++ // Simulate handoff: source instance no longer owns the IP / records.+ $this->service->forceDelete();+ $this->application->forceDelete();+ $this->database->forceDelete();+ $this->server->forceDelete();+ Tag::query()->delete();+ ScheduledDatabaseBackup::query()->delete();+ ScheduledTask::query()->delete();+ // Same fingerprint cannot exist twice; remove source key so target re-creates it.+ $this->privateKey->delete();++ $result = $this->importer->import($bundle, teamId: $this->team->id, dryRun: false, preserveUuids: true, adoptMode: true);++ expect($result['dry_run'])->toBeFalse()+ ->and($result['server_uuid'])->toBe($originalServerUuid)+ ->and($result['created']['applications'])->toBe(1)+ ->and($result['created']['databases'])->toBe(1)+ ->and($result['created']['services'])->toBe(1);++ $server = Server::where('uuid', $originalServerUuid)->first();+ expect($server)->not->toBeNull()+ ->and($server->ip)->toBe('10.55.0.10')+ ->and($server->name)->toBe('source-server')+ ->and($server->privateKey->private_key)->toBe($keyMaterial)+ ->and(data_get($server->server_metadata, 'transfer.status'))->toBe('claimed')+ ->and(data_get($server->server_metadata, 'transfer.adopt_mode'))->toBeTrue();++ $destination = StandaloneDocker::where('server_id', $server->id)->where('uuid', $originalDestUuid)->first();+ expect($destination)->not->toBeNull();++ $app = Application::where('uuid', $originalAppUuid)->first();+ expect($app)->not->toBeNull()+ ->and($app->name)->toBe('my-app')+ ->and($app->fqdn)->toBe('https://app.example.com')+ ->and($app->environment_variables()->where('key', 'APP_SECRET')->first()?->value)->toBe('super-secret-value')+ ->and($app->persistentStorages)->toHaveCount(1)+ ->and($app->scheduled_tasks)->toHaveCount(1)+ ->and($app->tags()->pluck('name')->all())->toContain('transfer-demo');++ $db = StandalonePostgresql::where('uuid', $originalDbUuid)->first();+ expect($db)->not->toBeNull()+ ->and($db->postgres_password)->toBe('db-password-secret')+ ->and($db->persistentStorages)->not->toBeEmpty()+ ->and($db->tags()->pluck('name')->all())->toContain('critical');++ $backup = ScheduledDatabaseBackup::where('uuid', $originalBackupUuid)->first();+ expect($backup)->not->toBeNull()+ ->and($backup->frequency)->toBe('0 2 * * *')+ ->and((bool) $backup->enabled)->toBeTrue()+ ->and($backup->database_id)->toBe($db->id);++ $service = Service::where('uuid', $originalServiceUuid)->first();+ expect($service)->not->toBeNull()+ ->and($service->name)->toBe('demo-service');++ $serviceTask = ScheduledTask::where('uuid', $originalServiceTaskUuid)->first();+ expect($serviceTask)->not->toBeNull()+ ->and($serviceTask->service_id)->toBe($service->id)+ ->and($serviceTask->name)->toBe('service-ping')+ ->and($serviceTask->command)->toBe('echo ping');++ $shared = SharedEnvironmentVariable::query()+ ->where('server_id', $server->id)+ ->where('key', 'SHARED_API_KEY')+ ->first();+ expect($shared)->not->toBeNull()+ ->and($shared->value)->toBe('shared-secret');+});++test('import fails when server ip already exists', function () {+ $bundle = $this->exporter->export($this->server);++ $this->importer->import($bundle, teamId: $this->team->id);+})->throws(ValidationException::class);++test('import rolls back all created rows when a later resource fails', function () {+ $bundle = $this->exporter->export($this->server);+ $originalServerUuid = $this->server->uuid;++ // Force a failure after private keys / server would have been created.+ $bundle['projects'][0]['environments'][0]['databases'][] = [+ 'type' => 'NotARealDatabaseType',+ 'uuid' => 'broken-db-uuid',+ 'attributes' => ['name' => 'broken'],+ 'destination_uuid' => $this->destination->uuid,+ ];++ $this->service->forceDelete();+ $this->application->forceDelete();+ $this->database->forceDelete();+ $this->server->forceDelete();+ $this->privateKey->delete();++ expect(fn () => $this->importer->import(+ $bundle,+ teamId: $this->team->id,+ dryRun: false,+ preserveUuids: true,+ adoptMode: true,+ claim: false,+ ))->toThrow(RuntimeException::class, 'Unsupported database type');++ expect(Server::where('uuid', $originalServerUuid)->exists())->toBeFalse()+ ->and(PrivateKey::where('uuid', data_get($bundle, 'private_key.uuid'))->exists())->toBeFalse()+ ->and(Application::where('uuid', data_get($bundle, 'projects.0.environments.0.applications.0.uuid'))->exists())->toBeFalse();+});++test('import fails on invalid schema', function () {+ $this->importer->import(['schema_version' => 1], teamId: $this->team->id);+})->throws(ValidationException::class);++test('import reuses existing private key fingerprint on same team', function () {+ $bundle = $this->exporter->export($this->server);+ $originalKeyId = $this->privateKey->id;++ // Free the IP without deleting the key.+ $this->application->forceDelete();+ $this->database->forceDelete();+ $this->server->forceDelete();++ $result = $this->importer->import($bundle, teamId: $this->team->id);++ $server = Server::where('uuid', $result['server_uuid'])->first();+ expect($server->private_key_id)->toBe($originalKeyId);+});++test('encrypted export decrypts for import', function () {+ $bundle = $this->exporter->export($this->server);+ $encrypted = ServerTransferBundle::encryptWithPassphrase($bundle, 'transfer-pass');++ $this->application->forceDelete();+ $this->database->forceDelete();+ $this->server->forceDelete();+ $this->privateKey->delete();++ $plain = ServerTransferBundle::decryptWithPassphrase($encrypted, 'transfer-pass');+ $result = $this->importer->import($plain, teamId: $this->team->id);++ expect(Server::where('uuid', $result['server_uuid'])->exists())->toBeTrue();+});++test('system-wide github apps are not exported and re-link on import by uuid', function () {+ $systemWide = new GithubApp;+ $systemWide->forceFill([+ 'name' => 'System Public GitHub',+ 'api_url' => 'https://api.github.com',+ 'html_url' => 'https://github.com',+ 'is_public' => true,+ 'is_system_wide' => true,+ 'team_id' => $this->team->id,+ ]);+ $systemWide->uuid = 'system-github-public';+ $systemWide->save();++ $teamApp = new GithubApp;+ $teamApp->forceFill([+ 'name' => 'Team GitHub App',+ 'api_url' => 'https://api.github.com',+ 'html_url' => 'https://github.com',+ 'is_public' => false,+ 'is_system_wide' => false,+ 'team_id' => $this->team->id,+ 'app_id' => 12345,+ 'installation_id' => 67890,+ 'client_id' => 'Iv1.test',+ 'client_secret' => 'secret',+ 'webhook_secret' => 'hook',+ ]);+ $teamApp->uuid = 'team-github-app';+ $teamApp->save();++ $this->application->source_type = GithubApp::class;+ $this->application->source_id = $systemWide->id;+ $this->application->save();++ $otherApp = Application::factory()->create([+ 'environment_id' => $this->environment->id,+ 'destination_id' => $this->destination->id,+ 'destination_type' => $this->destination->getMorphClass(),+ 'name' => 'team-source-app',+ 'git_repository' => 'https://github.com/example/private',+ 'git_branch' => 'main',+ 'build_pack' => 'nixpacks',+ 'ports_exposes' => '3000',+ 'source_type' => GithubApp::class,+ 'source_id' => $teamApp->id,+ ]);++ $bundle = $this->exporter->export($this->server);++ expect($bundle['github_apps'])->toHaveCount(1)+ ->and($bundle['github_apps'][0]['uuid'])->toBe('team-github-app')+ ->and(collect($bundle['warnings'])->implode(' '))->toContain('system-wide GitHub App');++ $appSources = collect($bundle['projects'][0]['environments'][0]['applications'])+ ->mapWithKeys(fn ($a) => [$a['attributes']['name'] => $a['source'] ?? null]);++ expect($appSources['my-app'])->toMatchArray(['type' => 'github_app', 'uuid' => 'system-github-public'])+ ->and($appSources['team-source-app'])->toMatchArray(['type' => 'github_app', 'uuid' => 'team-github-app']);++ // Free server IP / apps for import into same DB.+ $this->service->forceDelete();+ $otherApp->forceDelete();+ $this->application->forceDelete();+ $this->database->forceDelete();+ $this->server->forceDelete();+ $this->privateKey->delete();+ GithubApp::where('uuid', 'team-github-app')->delete();+ // Simulate target instance already having the same system-wide app UUID.+ $systemWide->delete();++ $targetTeam = Team::factory()->create();+ $targetSystemWide = new GithubApp;+ $targetSystemWide->forceFill([+ 'name' => 'System Public GitHub',+ 'api_url' => 'https://api.github.com',+ 'html_url' => 'https://github.com',+ 'is_public' => true,+ 'is_system_wide' => true,+ 'team_id' => $targetTeam->id,+ ]);+ $targetSystemWide->uuid = 'system-github-public';+ $targetSystemWide->save();++ $result = $this->importer->import($bundle, teamId: $targetTeam->id, preserveUuids: true, adoptMode: true);++ expect($result['created']['github_apps'])->toBe(1);++ $importedSystem = Application::where('name', 'my-app')->first();+ $importedTeam = Application::where('name', 'team-source-app')->first();+ $importedGhTeam = GithubApp::where('uuid', 'team-github-app')->first();++ expect($importedSystem)->not->toBeNull()+ ->and($importedSystem->source_type)->toBe(GithubApp::class)+ ->and($importedSystem->source_id)->toBe($targetSystemWide->id)+ ->and($importedTeam->source_id)->toBe($importedGhTeam->id)+ ->and($importedGhTeam->is_system_wide)->toBeFalse()+ ->and(GithubApp::where('is_system_wide', true)->where('uuid', 'system-github-public')->count())->toBe(1);+});++test('service nested apps dbs volumes backups and db file storages round-trip', function () {+ $serviceApp = new ServiceApplication;+ $serviceApp->forceFill([+ 'service_id' => $this->service->id,+ 'name' => 'whoami',+ 'human_name' => 'Whoami',+ 'description' => 'demo nested app',+ 'fqdn' => 'https://whoami.example.com',+ 'ports' => '80:80',+ 'exposes' => '80',+ 'image' => 'traefik/whoami:latest',+ 'exclude_from_status' => false,+ 'required_fqdn' => true,+ 'is_log_drain_enabled' => true,+ 'is_gzip_enabled' => false,+ 'is_stripprefix_enabled' => false,+ 'status' => 'running:healthy',+ ]);+ $serviceApp->uuid = 'svc-app-whoami';+ $serviceApp->save();++ EnvironmentVariable::withoutEvents(function () use ($serviceApp) {+ $env = new EnvironmentVariable;+ $env->forceFill([+ 'key' => 'WHOAMI_NAME',+ 'value' => 'nested-secret',+ 'resourceable_type' => ServiceApplication::class,+ 'resourceable_id' => $serviceApp->id,+ 'is_preview' => false,+ 'is_runtime' => true,+ 'is_buildtime' => false,+ ]);+ $env->uuid = new_public_id();+ $env->save();+ });++ LocalPersistentVolume::create([+ 'name' => 'whoami-data',+ 'mount_path' => '/data',+ 'host_path' => null,+ 'resource_type' => $serviceApp->getMorphClass(),+ 'resource_id' => $serviceApp->id,+ ]);+ $serviceAppVolume = LocalPersistentVolume::where('name', 'whoami-data')->firstOrFail();++ LocalFileVolume::withoutEvents(function () use ($serviceApp) {+ $file = new LocalFileVolume;+ $file->forceFill([+ 'fs_path' => './config.json',+ 'mount_path' => '/app/config.json',+ 'content' => '{"nested":true}',+ 'is_directory' => false,+ 'resource_type' => $serviceApp->getMorphClass(),+ 'resource_id' => $serviceApp->id,+ ]);+ $file->uuid = 'svc-app-file-1';+ $file->save();+ });++ ScheduledVolumeBackup::create([+ 'uuid' => 'svc-app-vol-backup',+ 'backupable_type' => $serviceAppVolume->getMorphClass(),+ 'backupable_id' => $serviceAppVolume->id,+ 'team_id' => $this->team->id,+ 'frequency' => '0 4 * * *',+ 'enabled' => true,+ 'save_s3' => false,+ 'disable_local_backup' => false,+ ]);++ $serviceDb = new ServiceDatabase;+ $serviceDb->forceFill([+ 'service_id' => $this->service->id,+ 'name' => 'postgres',+ 'human_name' => 'Nested PG',+ 'image' => 'postgres:16',+ 'ports' => '5432',+ 'exposes' => '5432',+ 'public_port' => 15432,+ 'public_port_timeout' => 30,+ 'is_public' => true,+ 'custom_type' => 'postgresql',+ 'status' => 'running:healthy',+ ]);+ $serviceDb->uuid = 'svc-db-postgres';+ $serviceDb->save();++ LocalPersistentVolume::create([+ 'name' => 'svc-pg-data',+ 'mount_path' => '/var/lib/postgresql/data',+ 'resource_type' => $serviceDb->getMorphClass(),+ 'resource_id' => $serviceDb->id,+ ]);++ LocalFileVolume::withoutEvents(function () use ($serviceDb) {+ $file = new LocalFileVolume;+ $file->forceFill([+ 'fs_path' => './init.sql',+ 'mount_path' => '/docker-entrypoint-initdb.d/init.sql',+ 'content' => 'SELECT 1;',+ 'is_directory' => false,+ 'resource_type' => $serviceDb->getMorphClass(),+ 'resource_id' => $serviceDb->id,+ ]);+ $file->uuid = 'svc-db-file-1';+ $file->save();+ });++ $serviceDbBackup = ScheduledDatabaseBackup::create([+ 'uuid' => 'svc-db-backup-1',+ 'team_id' => $this->team->id,+ 'enabled' => true,+ 'save_s3' => false,+ 'frequency' => '0 3 * * *',+ 'databases_to_backup' => 'postgres',+ 'database_type' => $serviceDb->getMorphClass(),+ 'database_id' => $serviceDb->id,+ ]);++ // Standalone database file storage+ LocalFileVolume::withoutEvents(function () {+ $file = new LocalFileVolume;+ $file->forceFill([+ 'fs_path' => './pg-conf.d',+ 'mount_path' => '/etc/postgresql/conf.d',+ 'content' => null,+ 'is_directory' => true,+ 'resource_type' => $this->database->getMorphClass(),+ 'resource_id' => $this->database->id,+ ]);+ $file->uuid = 'standalone-db-file-1';+ $file->save();+ });++ // Preview + preview volume+ $preview = new ApplicationPreview;+ $preview->forceFill([+ 'application_id' => $this->application->id,+ 'pull_request_id' => 42,+ 'pull_request_html_url' => 'https://github.com/example/app/pull/42',+ 'fqdn' => 'https://pr-42.app.example.com',+ 'status' => 'running:healthy',+ 'git_type' => 'github',+ ]);+ $preview->uuid = 'preview-pr-42';+ $preview->save();++ LocalPersistentVolume::create([+ 'name' => 'preview-42-data',+ 'mount_path' => '/app/data',+ 'resource_type' => $preview->getMorphClass(),+ 'resource_id' => $preview->id,+ ]);++ $bundle = $this->exporter->export($this->server);++ $envPayload = $bundle['projects'][0]['environments'][0];+ $servicePayload = $envPayload['services'][0];+ $nestedApp = collect($servicePayload['applications'])->firstWhere('uuid', 'svc-app-whoami');+ $nestedDb = collect($servicePayload['databases'])->firstWhere('uuid', 'svc-db-postgres');+ $appPayload = $envPayload['applications'][0];+ $dbPayload = $envPayload['databases'][0];++ expect($nestedApp)->not->toBeNull()+ ->and($nestedApp['ports'])->toBe('80:80')+ ->and($nestedApp['exposes'])->toBe('80')+ ->and($nestedApp['environment_variables'])->toHaveCount(1)+ ->and($nestedApp['environment_variables'][0]['value'])->toBe('nested-secret')+ ->and($nestedApp['persistent_storages'])->toHaveCount(1)+ ->and($nestedApp['file_storages'])->toHaveCount(1)+ ->and($nestedApp['file_storages'][0]['content'])->toBe('{"nested":true}')+ ->and($nestedDb)->not->toBeNull()+ ->and($nestedDb['public_port'])->toBe(15432)+ ->and($nestedDb['custom_type'])->toBe('postgresql')+ ->and($nestedDb['persistent_storages'])->toHaveCount(1)+ ->and($nestedDb['file_storages'])->toHaveCount(1)+ ->and($nestedDb['scheduled_backups'])->toHaveCount(1)+ ->and($nestedDb['scheduled_backups'][0]['uuid'])->toBe('svc-db-backup-1')+ ->and($dbPayload['file_storages'])->toHaveCount(1)+ ->and($dbPayload['file_storages'][0]['uuid'])->toBe('standalone-db-file-1')+ ->and($appPayload['previews'])->toHaveCount(1)+ ->and($appPayload['previews'][0]['uuid'])->toBe('preview-pr-42')+ ->and($appPayload['previews'][0]['persistent_storages'])->toHaveCount(1)+ ->and(collect($bundle['volume_backups'])->pluck('uuid')->all())->toContain('svc-app-vol-backup');++ $originalServerUuid = $this->server->uuid;+ $originalAppUuid = $this->application->uuid;+ $originalDbUuid = $this->database->uuid;+ $originalServiceUuid = $this->service->uuid;++ // Free server IP / UUIDs for re-import. Clear soft-deleted previews (unique FQDN)+ // without firing remote docker cleanup hooks.+ ApplicationPreview::withoutEvents(function () {+ ApplicationPreview::withTrashed()->get()->each->forceDelete();+ });+ ServiceApplication::withoutEvents(function () {+ ServiceApplication::withTrashed()->get()->each->forceDelete();+ });+ ServiceDatabase::withoutEvents(function () {+ ServiceDatabase::withTrashed()->get()->each->forceDelete();+ });+ DB::table('environment_variables')->delete();+ DB::table('local_file_volumes')->delete();+ DB::table('local_persistent_volumes')->delete();+ DB::table('scheduled_volume_backups')->delete();+ DB::table('scheduled_database_backups')->delete();+ DB::table('scheduled_tasks')->delete();+ DB::table('services')->delete();+ DB::table('applications')->delete();+ DB::table('standalone_postgresqls')->delete();+ DB::table('standalone_dockers')->delete();+ DB::table('servers')->delete();+ $this->privateKey->delete();+ Tag::query()->delete();++ $result = $this->importer->import($bundle, teamId: $this->team->id, preserveUuids: true, adoptMode: true);++ expect($result['created']['services'])->toBe(1)+ ->and($result['server_uuid'])->toBe($originalServerUuid);++ $importedService = Service::where('uuid', $originalServiceUuid)->first();+ expect($importedService)->not->toBeNull();++ $importedSvcApp = ServiceApplication::where('uuid', 'svc-app-whoami')->first();+ expect($importedSvcApp)->not->toBeNull()+ ->and($importedSvcApp->ports)->toBe('80:80')+ ->and($importedSvcApp->exposes)->toBe('80')+ ->and((bool) $importedSvcApp->is_gzip_enabled)->toBeFalse()+ ->and((bool) $importedSvcApp->is_stripprefix_enabled)->toBeFalse()+ ->and($importedSvcApp->environment_variables()->where('key', 'WHOAMI_NAME')->first()?->value)->toBe('nested-secret')+ ->and($importedSvcApp->persistentStorages)->toHaveCount(1)+ ->and($importedSvcApp->fileStorages)->toHaveCount(1)+ ->and($importedSvcApp->fileStorages->first()->content)->toBe('{"nested":true}');++ $importedSvcDb = ServiceDatabase::where('uuid', 'svc-db-postgres')->first();+ expect($importedSvcDb)->not->toBeNull()+ ->and($importedSvcDb->public_port)->toBe(15432)+ ->and($importedSvcDb->custom_type)->toBe('postgresql')+ ->and($importedSvcDb->persistentStorages)->toHaveCount(1)+ ->and($importedSvcDb->fileStorages)->toHaveCount(1)+ ->and($importedSvcDb->scheduledBackups)->toHaveCount(1)+ ->and($importedSvcDb->scheduledBackups->first()->uuid)->toBe('svc-db-backup-1');++ $importedStandaloneDb = StandalonePostgresql::where('uuid', $originalDbUuid)->first();+ expect($importedStandaloneDb)->not->toBeNull()+ ->and($importedStandaloneDb->fileStorages)->toHaveCount(1)+ ->and($importedStandaloneDb->fileStorages->first()->uuid)->toBe('standalone-db-file-1');++ $importedApp = Application::where('uuid', $originalAppUuid)->first();+ expect($importedApp)->not->toBeNull()+ ->and($importedApp->previews)->toHaveCount(1)+ ->and($importedApp->previews->first()->uuid)->toBe('preview-pr-42')+ ->and($importedApp->previews->first()->persistentStorages)->toHaveCount(1);++ $importedVolBackup = ScheduledVolumeBackup::where('uuid', 'svc-app-vol-backup')->first();+ expect($importedVolBackup)->not->toBeNull()+ ->and($importedVolBackup->frequency)->toBe('0 4 * * *')+ ->and((bool) $importedVolBackup->enabled)->toBeTrue();+});++test('export refuses servers with additional destinations', function () {+ $extraDestination = StandaloneDocker::create([+ 'name' => 'extra-net',+ 'network' => 'extra-net-block',+ 'server_id' => $this->server->id,+ ]);++ $this->application->additional_networks()->attach($extraDestination->id, [+ 'server_id' => $this->server->id,+ 'status' => 'running:healthy',+ ]);++ expect(fn () => $this->exporter->export($this->server))+ ->toThrow(RuntimeException::class, 'additional destinations');+});++test('system-wide gitlab apps are not exported and re-link on import by uuid', function () {+ $systemWide = new GitlabApp;+ $systemWide->forceFill([+ 'name' => 'System Public GitLab',+ 'api_url' => 'https://gitlab.com/api/v4',+ 'html_url' => 'https://gitlab.com',+ 'is_public' => true,+ 'is_system_wide' => true,+ 'team_id' => $this->team->id,+ ]);+ $systemWide->uuid = 'system-gitlab-public';+ $systemWide->save();++ $teamApp = new GitlabApp;+ $teamApp->forceFill([+ 'name' => 'Team GitLab App',+ 'api_url' => 'https://gitlab.com/api/v4',+ 'html_url' => 'https://gitlab.com',+ 'is_public' => false,+ 'is_system_wide' => false,+ 'team_id' => $this->team->id,+ 'app_id' => '123',+ 'app_secret' => 'secret',+ 'oauth_id' => 1,+ 'client_id' => 'client',+ 'client_secret' => 'csecret',+ 'group_name' => 'team',+ ]);+ $teamApp->uuid = 'team-gitlab-app';+ $teamApp->save();++ $this->application->source_type = GitlabApp::class;+ $this->application->source_id = $systemWide->id;+ $this->application->save();++ Application::factory()->create([+ 'environment_id' => $this->environment->id,+ 'destination_id' => $this->destination->id,+ 'destination_type' => $this->destination->getMorphClass(),+ 'name' => 'team-gl-source-app',+ 'git_repository' => 'https://gitlab.com/example/private',+ 'git_branch' => 'main',+ 'build_pack' => 'nixpacks',+ 'ports_exposes' => '3000',+ 'source_type' => GitlabApp::class,+ 'source_id' => $teamApp->id,+ ]);++ $bundle = $this->exporter->export($this->server);++ expect($bundle['gitlab_apps'])->toHaveCount(1)+ ->and($bundle['gitlab_apps'][0]['uuid'])->toBe('team-gitlab-app')+ ->and(collect($bundle['warnings'])->implode(' '))->toContain('system-wide GitLab App');++ $this->service->forceDelete();+ Application::query()->forceDelete();+ $this->database->forceDelete();+ $this->server->forceDelete();+ $this->privateKey->delete();+ GitlabApp::where('uuid', 'team-gitlab-app')->delete();+ $systemWide->delete();++ $targetTeam = Team::factory()->create();+ $targetSystemWide = new GitlabApp;+ $targetSystemWide->forceFill([+ 'name' => 'System Public GitLab',+ 'api_url' => 'https://gitlab.com/api/v4',+ 'html_url' => 'https://gitlab.com',+ 'is_public' => true,+ 'is_system_wide' => true,+ 'team_id' => $targetTeam->id,+ ]);+ $targetSystemWide->uuid = 'system-gitlab-public';+ $targetSystemWide->save();++ $result = $this->importer->import($bundle, teamId: $targetTeam->id, preserveUuids: true, adoptMode: true);++ expect($result['created']['gitlab_apps'])->toBe(1);++ $importedSystem = Application::where('name', 'my-app')->first();+ $importedTeam = Application::where('name', 'team-gl-source-app')->first();+ $importedGlTeam = GitlabApp::where('uuid', 'team-gitlab-app')->first();++ expect($importedSystem)->not->toBeNull()+ ->and($importedSystem->source_type)->toBe(GitlabApp::class)+ ->and($importedSystem->source_id)->toBe($targetSystemWide->id)+ ->and($importedTeam->source_id)->toBe($importedGlTeam->id)+ ->and($importedGlTeam->is_system_wide)->toBeFalse()+ ->and(GitlabApp::where('is_system_wide', true)->where('uuid', 'system-gitlab-public')->count())->toBe(1);+});diff --git a/tests/Unit/ServerTransfer/ServerTransferMigratorTest.php b/tests/Unit/ServerTransfer/ServerTransferMigratorTest.phpnew file mode 100644index 0000000000..292a2aec73--- /dev/null+++ b/tests/Unit/ServerTransfer/ServerTransferMigratorTest.php@@ -0,0 +1,158 @@+<?php++use App\Models\Application;+use App\Models\Environment;+use App\Models\InstanceSettings;+use App\Models\PrivateKey;+use App\Models\Project;+use App\Models\Server;+use App\Models\StandaloneDocker;+use App\Models\Team;+use App\Services\ServerTransfer\ServerTransferClaimer;+use App\Services\ServerTransfer\ServerTransferMigrator;+use Illuminate\Foundation\Testing\RefreshDatabase;+use Illuminate\Support\Facades\Http;+use Tests\TestCase;++uses(TestCase::class, RefreshDatabase::class);++beforeEach(function () {+ InstanceSettings::forceCreate(['id' => 0, 'is_api_enabled' => true, 'fqdn' => 'https://coolify-a.test']);++ $this->team = Team::factory()->create();+ $this->privateKey = PrivateKey::factory()->create(['team_id' => $this->team->id]);+ $this->server = Server::factory()->create([+ 'team_id' => $this->team->id,+ 'private_key_id' => $this->privateKey->id,+ 'ip' => '10.88.0.10',+ 'name' => 'migrate-me',+ ]);+ $destination = StandaloneDocker::where('server_id', $this->server->id)->firstOrFail();+ $project = Project::factory()->create(['team_id' => $this->team->id]);+ $environment = $project->environments()->first()+ ?? Environment::factory()->create(['project_id' => $project->id]);+ Application::factory()->create([+ 'environment_id' => $environment->id,+ 'destination_id' => $destination->id,+ 'destination_type' => $destination->getMorphClass(),+ 'name' => 'app-on-server',+ 'ports_exposes' => '3000',+ ]);+});++test('migrate exports imports via http and completes locally', function () {+ Http::fake([+ 'http://target.test/api/v1/servers/import' => Http::response([+ 'dry_run' => false,+ 'server_uuid' => $this->server->uuid,+ 'claimed' => true,+ 'export_id' => 'remote-export',+ 'created' => ['applications' => 1],+ 'warnings' => [],+ ], 201),+ ]);++ $result = app(ServerTransferMigrator::class)->migrate(+ server: $this->server,+ targetUrl: 'http://target.test',+ targetToken: 'target-token-xyz',+ writeRemote: false,+ );++ expect($result['server_uuid'])->toBe($this->server->uuid)+ ->and($result['target_url'])->toBe('http://target.test')+ ->and($result['import']['claimed'])->toBeTrue()+ ->and($result['message'])->toContain('migrated');++ $this->server->refresh();+ expect(data_get($this->server->server_metadata, 'transfer.status'))->toBe('transferred')+ ->and((bool) $this->server->settings->force_disabled)->toBeTrue();++ Http::assertSent(function ($request) {+ return $request->url() === 'http://target.test/api/v1/servers/import'+ && $request->hasHeader('Authorization', 'Bearer target-token-xyz')+ && data_get($request->data(), 'claim') === true+ && data_get($request->data(), 'bundle.server.uuid') === $this->server->uuid;+ });+});++test('migrate rewrites localhost target when running in docker style env', function () {+ // Simulate container: create a temp marker if missing is hard; instead assert host rewrite helper via migrate call+ // with Http fake matching host.docker.internal when /.dockerenv exists — skip if not in docker.+ if (! file_exists('/.dockerenv') && ! is_file('/run/.containerenv')) {+ expect(true)->toBeTrue();++ return;+ }++ Http::fake([+ 'http://host.docker.internal:8001/api/v1/servers/import' => Http::response([+ 'dry_run' => false,+ 'server_uuid' => $this->server->uuid,+ 'claimed' => true,+ 'warnings' => [],+ ], 201),+ ]);++ app(ServerTransferMigrator::class)->migrate(+ $this->server,+ 'http://localhost:8001',+ 'token',+ );++ Http::assertSent(fn ($request) => str_contains($request->url(), 'host.docker.internal:8001'));+});++test('migrate fails clearly when target is unreachable', function () {+ Http::fake([+ 'http://down.test/*' => Http::failedConnection(),+ ]);++ expect(fn () => app(ServerTransferMigrator::class)->migrate(+ $this->server,+ 'http://down.test',+ 'token',+ ))->toThrow(RuntimeException::class, 'Could not reach target');+});++test('migrate fails when target returns error', function () {+ Http::fake([+ 'http://target.test/api/v1/servers/import' => Http::response([+ 'message' => 'A server with IP/domain already exists',+ ], 422),+ ]);++ expect(fn () => app(ServerTransferMigrator::class)->migrate(+ $this->server,+ 'http://target.test',+ 'token',+ ))->toThrow(RuntimeException::class, 'Target import failed');++ // Source must remain unmanaged-away only after successful remote import+complete.+ $this->server->refresh();+ expect(data_get($this->server->server_metadata, 'transfer.status'))->not->toBe('transferred')+ ->and((bool) $this->server->settings->force_disabled)->toBeFalse();+});++test('migrate surfaces recovery guidance when complete fails after successful remote import', function () {+ Http::fake([+ 'http://target.test/api/v1/servers/import' => Http::response([+ 'dry_run' => false,+ 'server_uuid' => $this->server->uuid,+ 'claimed' => true,+ 'warnings' => [],+ ], 201),+ ]);++ $claimer = Mockery::mock(ServerTransferClaimer::class)->makePartial();+ $claimer->shouldReceive('markTransferred')+ ->once()+ ->andThrow(new RuntimeException('simulated complete failure'));+ app()->instance(ServerTransferClaimer::class, $claimer);++ expect(fn () => app(ServerTransferMigrator::class)->migrate(+ $this->server,+ 'http://target.test',+ 'token',+ ))->toThrow(RuntimeException::class, 'Retry complete');+});diff --git a/tests/Unit/ServerTransfer/TransferredServerValidationTest.php b/tests/Unit/ServerTransfer/TransferredServerValidationTest.phpnew file mode 100644index 0000000000..d460aaaeb1--- /dev/null+++ b/tests/Unit/ServerTransfer/TransferredServerValidationTest.php@@ -0,0 +1,71 @@+<?php++use App\Actions\Server\ValidateServer;+use App\Jobs\ValidateAndInstallServerJob;+use App\Models\InstanceSettings;+use App\Models\PrivateKey;+use App\Models\Server;+use App\Models\Team;+use Illuminate\Foundation\Testing\RefreshDatabase;+use Tests\TestCase;++uses(TestCase::class, RefreshDatabase::class);++beforeEach(function () {+ InstanceSettings::forceCreate(['id' => 0]);+ $this->team = Team::factory()->create();+ $this->privateKey = PrivateKey::factory()->create(['team_id' => $this->team->id]);+ $this->server = Server::factory()->create([+ 'team_id' => $this->team->id,+ 'private_key_id' => $this->privateKey->id,+ ]);+});++test('transferred servers cannot be validated', function () {+ expect($this->server->canBeValidated())->toBeTrue()+ ->and($this->server->isTransferredAway())->toBeFalse();++ $this->server->server_metadata = [+ 'transfer' => ['status' => 'transferred'],+ ];+ $this->server->save();+ $this->server->forceDisableServer();++ expect($this->server->fresh()->isTransferredAway())->toBeTrue()+ ->and($this->server->fresh()->canBeValidated())->toBeFalse();+});++test('forceEnableServer does not clear transferred servers', function () {+ $this->server->server_metadata = [+ 'transfer' => ['status' => 'transferred'],+ ];+ $this->server->save();+ $this->server->forceDisableServer();++ $this->server->forceEnableServer();++ expect((bool) $this->server->fresh()->settings->force_disabled)->toBeTrue()+ ->and($this->server->fresh()->canBeValidated())->toBeFalse();+});++test('ValidateServer action rejects transferred servers', function () {+ $this->server->server_metadata = [+ 'transfer' => ['status' => 'transferred'],+ ];+ $this->server->save();++ expect(fn () => ValidateServer::run($this->server))+ ->toThrow(Exception::class, 'transferred');+});++test('ValidateAndInstallServerJob no-ops for transferred servers', function () {+ $this->server->server_metadata = [+ 'transfer' => ['status' => 'transferred'],+ ];+ $this->server->save();++ (new ValidateAndInstallServerJob($this->server))->handle();++ expect((bool) $this->server->fresh()->is_validating)->toBeFalse()+ ->and((string) $this->server->fresh()->validation_logs)->toContain('transferred');+});