update method publish

Author: spartan-vutrannguyen

apps/web/client/src/env.ts

@@ -10,6 +10,7 @@ export const env = createEnv({
         NODE_ENV: z.enum(['development', 'test', 'production']),
         CSB_API_KEY: z.string(),
         SUPABASE_DATABASE_URL: z.string().url(),
+        SUPABASE_SERVICE_ROLE_KEY: z.string().optional(),
         RESEND_API_KEY: z.string().optional(),
         FREESTYLE_API_KEY: z.string().optional(),
 
@@ -71,6 +72,7 @@ export const env = createEnv({
 
         // Supabase
         SUPABASE_DATABASE_URL: process.env.SUPABASE_DATABASE_URL,
+        SUPABASE_SERVICE_ROLE_KEY: process.env.SUPABASE_SERVICE_ROLE_KEY,
         NEXT_PUBLIC_SITE_URL: process.env.NEXT_PUBLIC_SITE_URL,
         NEXT_PUBLIC_SUPABASE_URL: process.env.NEXT_PUBLIC_SUPABASE_URL,
         NEXT_PUBLIC_SUPABASE_ANON_KEY: process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY,

apps/web/client/src/server/api/routers/domain/adapters/freestyle.ts

@@ -1,4 +1,4 @@
-import type { FreestyleDeployWebSuccessResponseV2 } from 'freestyle-sandboxes';
+import type { DeploymentSource, FreestyleDeployWebSuccessResponseV2 } from 'freestyle-sandboxes';
 import { initializeFreestyleSdk } from '../freestyle';
 import type {
     HostingProviderAdapter,
@@ -9,34 +9,62 @@ import type {
 export class FreestyleAdapter implements HostingProviderAdapter {
     async deploy(request: DeploymentRequest): Promise<DeploymentResponse> {
         const sdk = initializeFreestyleSdk();
-        
+        if (request.sourceUrl) {
+            // Many SDKs accept a generic URL-based source. Use a loose cast to avoid type mismatch.
+             
+            const res = await sdk.deployWeb(
+                { kind: 'tar', url: request.sourceUrl } as unknown as DeploymentSource,
+                request.config,
+            );
+
+            const freestyleResponse = res as {
+                message?: string;
+                error?: { message: string };
+                data?: FreestyleDeployWebSuccessResponseV2;
+            };
+
+            if (freestyleResponse.error) {
+                throw new Error(
+                    freestyleResponse.error.message ||
+                    freestyleResponse.message ??
+                    'Unknown error',
+                );
+            }
+
+            return {
+                deploymentId: freestyleResponse.data?.deploymentId ?? '',
+                success: true,
+                message: freestyleResponse.message,
+            };
+        }
+
         const res = await sdk.deployWeb(
             {
                 files: request.files,
                 kind: 'files',
             },
-            request.config
+            request.config,
         );
-        
+
         const freestyleResponse = res as {
             message?: string;
             error?: {
                 message: string;
             };
             data?: FreestyleDeployWebSuccessResponseV2;
         };
-        
+
         if (freestyleResponse.error) {
             throw new Error(
-                freestyleResponse.error.message || 
-                freestyleResponse.message || 
-                'Unknown error'
+                freestyleResponse.error.message ||
+                freestyleResponse.message ||
+                'Unknown error',
             );
         }
-        
+
         return {
             deploymentId: freestyleResponse.data?.deploymentId ?? '',
-            success: true
+            success: true,
         };
     }
 } 

apps/web/client/src/server/api/routers/publish/deployment.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../../trpc";
 import { updateDeployment } from './helpers';
 import { createDeployment, publish } from './helpers/index.ts';
+import { getDeploymentLogs } from './helpers/logs';
 
 export const deploymentRouter = createTRPCRouter({
     getByType: protectedProcedure.input(z.object({
@@ -121,6 +122,11 @@ export const deploymentRouter = createTRPCRouter({
             throw error;
         }
     }),
+    getLogs: protectedProcedure.input(z.object({
+        deploymentId: z.string(),
+    })).query(async ({ input }) => {
+        return getDeploymentLogs(input.deploymentId);
+    }),
     cancel: protectedProcedure.input(z.object({
         deploymentId: z.string(),
     })).mutation(async ({ ctx, input }) => {

apps/web/client/src/server/api/routers/publish/helpers/deploy.ts

@@ -14,35 +14,39 @@ import {
 import { HostingProviderFactory } from '../../domain/hosting-factory.ts';
 
 export const deployFreestyle = async (
-    {
-        files,
-        urls,
-        envVars,
-    }: {
-        files: Record<string, FreestyleFile>,
-        urls: string[],
-        envVars?: Record<string, string>,
+    args: (
+        { files: Record<string, FreestyleFile>; sourceUrl?: undefined } |
+        { files?: undefined; sourceUrl: string }
+    ) & {
+        urls: string[];
+        envVars?: Record<string, string>;
     }
 ): Promise<{
     success: boolean;
     message?: string;
 }> => {
     const entrypoint = 'server.js';
     const adapter = HostingProviderFactory.create(HostingProvider.FREESTYLE);
-    const deploymentFiles: Record<string, { content: string; encoding?: 'utf-8' | 'base64' }> = {};
-    for (const [path, file] of Object.entries(files)) {
-        deploymentFiles[path] = {
-            content: file.content,
-            encoding: (file.encoding === 'base64' ? 'base64' : 'utf-8')
-        };
-    }
 
     const result = await adapter.deploy({
-        files: deploymentFiles,
+        ...(('sourceUrl' in args && typeof args.sourceUrl === 'string')
+            ? { sourceUrl: args.sourceUrl }
+            : {
+                files: Object.fromEntries(
+                    Object.entries(args.files ?? {}).map(([path, file]) => [
+                        path,
+                        {
+                            content: file.content,
+                            encoding: (file.encoding === 'base64' ? 'base64' : 'utf-8'),
+                        } as const,
+                    ]),
+                ),
+            }
+        ),
         config: {
-            domains: urls,
+            domains: args.urls,
             entrypoint,
-            envVars,
+            envVars: args.envVars,
         },
     });
 

apps/web/client/src/server/api/routers/publish/helpers/env.ts

@@ -1,4 +1,4 @@
-import { WebSocketSession } from '@codesandbox/sdk';
+import type { WebSocketSession } from '@codesandbox/sdk';
 
 /**
  * Parse .env file content into key-value pairs

apps/web/client/src/server/api/routers/publish/helpers/logs.ts

@@ -0,0 +1,44 @@
+export type DeploymentLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'success';
+
+export type DeploymentLogEntry = {
+  timestamp: number;
+  level: DeploymentLogLevel;
+  message: string;
+};
+
+const MAX_ENTRIES_PER_DEPLOYMENT = 500;
+
+const deploymentLogs = new Map<string, DeploymentLogEntry[]>();
+
+export const addDeploymentLog = (
+  deploymentId: string,
+  message: string,
+  level: DeploymentLogLevel = 'info',
+): void => {
+  if (!deploymentId) return;
+  const entry: DeploymentLogEntry = {
+    timestamp: Date.now(),
+    level,
+    message,
+  };
+  const list = deploymentLogs.get(deploymentId) ?? [];
+  list.push(entry);
+  // Trim to max
+  if (list.length > MAX_ENTRIES_PER_DEPLOYMENT) {
+    const excess = list.length - MAX_ENTRIES_PER_DEPLOYMENT;
+    list.splice(0, excess);
+  }
+  deploymentLogs.set(deploymentId, list);
+};
+
+export const getDeploymentLogs = (deploymentId: string): DeploymentLogEntry[] => {
+  if (!deploymentId) return [];
+  return deploymentLogs.get(deploymentId) ?? [];
+};
+
+export const clearDeploymentLogs = (deploymentId: string): void => {
+  if (!deploymentId) return;
+  deploymentLogs.delete(deploymentId);
+};
+
+

apps/web/client/src/server/api/routers/publish/helpers/publish.ts

@@ -11,6 +11,7 @@ import { deployFreestyle } from './deploy';
 import { extractEnvVarsFromSandbox } from './env';
 import { forkBuildSandbox } from './fork';
 import { getProjectUrls, getSandboxId, updateDeployment } from './helpers';
+import { addDeploymentLog, clearDeploymentLogs } from './logs';
 
 export async function publish({
     db,
@@ -21,8 +22,12 @@ export async function publish({
 }) {
     const { id: deploymentId, projectId, type, buildScript, buildFlags, envVars, requestedBy: userId } = deployment;
     try {
+        clearDeploymentLogs(deploymentId);
+        addDeploymentLog(deploymentId, 'Starting deployment...', 'info');
         const deploymentUrls = await getProjectUrls(db, projectId, type);
+        addDeploymentLog(deploymentId, `Resolved deployment URLs: ${deploymentUrls.join(', ')}`, 'debug');
         const sandboxId = await getSandboxId(db, projectId);
+        addDeploymentLog(deploymentId, `Using sandbox ${sandboxId} for build`, 'debug');
 
         const updateDeploymentResult1 = await updateDeployment(db, deploymentId, {
             status: DeploymentStatus.IN_PROGRESS,
@@ -37,6 +42,7 @@ export async function publish({
         }
 
         const { session, sandboxId: forkedSandboxId } = await forkBuildSandbox(sandboxId, userId, deploymentId);
+        addDeploymentLog(deploymentId, `Forked build sandbox: ${forkedSandboxId}`, 'info');
 
         try {
             const updateDeploymentResult2 = await updateDeployment(db, deploymentId, {
@@ -54,12 +60,15 @@ export async function publish({
 
 
             const publishManager = new PublishManager(session);
-            const files = await publishManager.publish({
+            addDeploymentLog(deploymentId, 'Building project inside sandbox...', 'info');
+            const artifactUrl = await publishManager.buildAndUploadArtifact({
                 skipBadge: type === DeploymentType.CUSTOM,
                 buildScript: buildScript ?? DefaultSettings.COMMANDS.build,
                 buildFlags: buildFlags ?? DefaultSettings.EDITOR_SETTINGS.buildFlags,
+                deploymentId,
                 updateDeployment: (deployment) => updateDeployment(db, deploymentId, deployment),
             });
+            addDeploymentLog(deploymentId, `Build artifact uploaded. Signed URL generated.`, 'success');
 
             const updateDeploymentResult3 = await updateDeployment(db, deploymentId, {
                 status: DeploymentStatus.IN_PROGRESS,
@@ -75,15 +84,19 @@ export async function publish({
 
             // Note: Prefer user provided env vars over sandbox env vars
             const sandboxEnvVars = await extractEnvVarsFromSandbox(session);
+            addDeploymentLog(deploymentId, `Extracted ${Object.keys(sandboxEnvVars).length} env vars from sandbox`, 'debug');
             const mergedEnvVars = { ...sandboxEnvVars, ...(envVars ?? {}) };
+            addDeploymentLog(deploymentId, 'Starting deployment to hosting provider...', 'info');
 
             await deployFreestyle({
-                files,
+                sourceUrl: artifactUrl,
                 urls: deploymentUrls,
                 envVars: mergedEnvVars,
             });
+            addDeploymentLog(deploymentId, 'Deployment finalized by hosting provider', 'success');
         } finally {
             await session.disconnect();
+            addDeploymentLog(deploymentId, 'Build sandbox disconnected', 'debug');
         }
     } catch (error) {
         console.error(error);
@@ -92,6 +105,11 @@ export async function publish({
             error: error instanceof Error ? error.message : 'Unknown error',
             progress: 100,
         });
+        addDeploymentLog(
+            deploymentId,
+            error instanceof Error ? error.message : 'Unknown error during deployment',
+            'error',
+        );
         throw error;
     }
 }