diff --git a/website/client/components/Home/TryIt.vue b/website/client/components/Home/TryIt.vue
index 1c243fc0e..db2fc7498 100644
--- a/website/client/components/Home/TryIt.vue
+++ b/website/client/components/Home/TryIt.vue
@@ -96,6 +96,8 @@
           :error-type="errorType"
           :repository-url="inputRepositoryUrl"
           :pack-options="packOptions"
+          :progress-stage="progressStage"
+          :progress-message="progressMessage"
           @repack="handleRepack"
         />
       </div>
@@ -136,6 +138,8 @@ const {
   errorType,
   result,
   hasExecuted,
+  progressStage,
+  progressMessage,
 
   // Computed
   isSubmitValid,
diff --git a/website/client/components/Home/TryItLoading.vue b/website/client/components/Home/TryItLoading.vue
index 265a551b1..a46fcb708 100644
--- a/website/client/components/Home/TryItLoading.vue
+++ b/website/client/components/Home/TryItLoading.vue
@@ -1,9 +1,38 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+import type { PackProgressStage } from '../api/client';
+
+interface Props {
+  stage?: PackProgressStage | null;
+  message?: string | null;
+}
+
+const props = defineProps<Props>();
+
+const stageMessages: Record<PackProgressStage, string> = {
+  'cache-check': 'Checking cache...',
+  cloning: 'Cloning repository...',
+  'repository-fetch': 'Fetching repository...',
+  extracting: 'Extracting files...',
+  processing: 'Processing files...',
+};
+
+const MAX_DETAIL_LENGTH = 60;
+
+const detailMessage = computed(() => {
+  const text = props.message || (props.stage && stageMessages[props.stage]) || '...';
+  if (text.length <= MAX_DETAIL_LENGTH) return text;
+  return `${text.slice(0, MAX_DETAIL_LENGTH)}...`;
+});
+</script>
+
 <template>
   <div class="loading">
     <div class="loading-header">
       <div class="spinner"></div>
       <p>Processing repository...</p>
     </div>
+    <p class="loading-detail">{{ detailMessage }}</p>
     <div class="sponsor-section">
       <p class="sponsor-header">Special thanks to:</p>
       <a href="https://go.warp.dev/repomix" target="_blank" rel="noopener noreferrer">
@@ -40,6 +69,12 @@
   margin: 0;
 }
 
+.loading-detail {
+  margin: 4px 0 0;
+  font-size: 0.8em;
+  color: var(--vp-c-text-3);
+}
+
 .spinner {
   flex-shrink: 0;
   width: 20px;
diff --git a/website/client/components/Home/TryItResult.vue b/website/client/components/Home/TryItResult.vue
index 5fb2f201f..2c5a59d74 100644
--- a/website/client/components/Home/TryItResult.vue
+++ b/website/client/components/Home/TryItResult.vue
@@ -2,7 +2,7 @@
 import { computed, ref } from 'vue';
 import type { PackOptions } from '../../composables/usePackOptions';
 import type { TabType } from '../../types/ui';
-import type { FileInfo, PackResult } from '../api/client';
+import type { FileInfo, PackProgressStage, PackResult } from '../api/client';
 import SupportMessage from './SupportMessage.vue';
 import TryItFileSelection from './TryItFileSelection.vue';
 import TryItLoading from './TryItLoading.vue';
@@ -16,6 +16,8 @@ interface Props {
   errorType?: 'error' | 'warning';
   repositoryUrl?: string;
   packOptions?: PackOptions;
+  progressStage?: PackProgressStage | null;
+  progressMessage?: string | null;
 }
 
 interface Emits {
@@ -51,7 +53,7 @@ const handleRepack = (selectedFiles: FileInfo[]) => {
 <template>
   <div class="result-viewer">
     <template v-if="loading && !result">
-      <TryItLoading />
+      <TryItLoading :stage="progressStage" :message="progressMessage" />
       <SupportMessage />
     </template>
     <TryItResultErrorContent
diff --git a/website/client/components/api/client.ts b/website/client/components/api/client.ts
index 55e250ba8..445eeb51c 100644
--- a/website/client/components/api/client.ts
+++ b/website/client/components/api/client.ts
@@ -20,7 +20,6 @@ export interface PackRequest {
   url: string;
   format: 'xml' | 'markdown' | 'plain';
   options: PackOptions;
-  signal?: AbortSignal;
   file?: File;
 }
 
@@ -61,9 +60,35 @@ export class ApiError extends Error {
   }
 }
 
+export type PackProgressStage = 'cache-check' | 'cloning' | 'repository-fetch' | 'extracting' | 'processing';
+
+export interface PackStreamCallbacks {
+  onProgress?: (stage: PackProgressStage, message?: string) => void;
+  signal?: AbortSignal;
+}
+
 const API_BASE_URL = import.meta.env.PROD ? 'https://api.repomix.com' : 'http://localhost:8080';
 
-export async function packRepository(request: PackRequest): Promise<PackResult> {
+// NDJSON stream event types
+interface ProgressEvent {
+  type: 'progress';
+  stage: PackProgressStage;
+  message?: string;
+}
+
+interface ResultEvent {
+  type: 'result';
+  data: PackResult;
+}
+
+interface StreamErrorEvent {
+  type: 'error';
+  message: string;
+}
+
+type StreamEvent = ProgressEvent | ResultEvent | StreamErrorEvent;
+
+export async function packRepository(request: PackRequest, callbacks?: PackStreamCallbacks): Promise<PackResult> {
   const formData = new FormData();
 
   if (request.file) {
@@ -77,14 +102,56 @@ export async function packRepository(request: PackRequest): Promise<PackResult>
   const response = await fetch(`${API_BASE_URL}/api/pack`, {
     method: 'POST',
     body: formData,
-    signal: request.signal,
+    signal: callbacks?.signal,
   });
 
-  const data = await response.json();
-
+  // Handle non-streaming error responses (validation errors return JSON)
   if (!response.ok) {
+    const data = await response.json();
     throw new ApiError((data as ErrorResponse).error);
   }
 
-  return data as PackResult;
+  // Handle NDJSON stream
+  if (!response.body) {
+    throw new ApiError('No response body received');
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let result: PackResult | null = null;
+
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      // Parse complete lines from buffer
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        const event = JSON.parse(line) as StreamEvent;
+        if (event.type === 'progress') {
+          callbacks?.onProgress?.(event.stage, event.message);
+        } else if (event.type === 'result') {
+          result = event.data;
+        } else if (event.type === 'error') {
+          throw new ApiError(event.message);
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  if (!result) {
+    throw new ApiError('No result received from server');
+  }
+
+  return result;
 }
diff --git a/website/client/components/utils/requestHandlers.ts b/website/client/components/utils/requestHandlers.ts
index 0ca0c0964..f43a5972c 100644
--- a/website/client/components/utils/requestHandlers.ts
+++ b/website/client/components/utils/requestHandlers.ts
@@ -1,4 +1,4 @@
-import type { PackOptions, PackRequest, PackResult } from '../api/client';
+import type { PackOptions, PackProgressStage, PackRequest, PackResult } from '../api/client';
 import { packRepository } from '../api/client';
 import { type AnalyticsActionType, analyticsUtils } from './analytics';
 
@@ -6,6 +6,7 @@ interface RequestHandlerOptions {
   onSuccess?: (result: PackResult) => void;
   onError?: (error: string) => void;
   onAbort?: (message: string) => void;
+  onProgress?: (stage: PackProgressStage, message?: string) => void;
   signal?: AbortSignal;
   file?: File;
 }
@@ -19,7 +20,7 @@ export async function handlePackRequest(
   options: PackOptions,
   handlerOptions: RequestHandlerOptions = {},
 ): Promise<void> {
-  const { onSuccess, onError, onAbort, signal, file } = handlerOptions;
+  const { onSuccess, onError, onAbort, onProgress, signal, file } = handlerOptions;
   const processedUrl = url.trim();
 
   // Track pack start
@@ -30,11 +31,13 @@ export async function handlePackRequest(
       url: processedUrl,
       format,
       options,
-      signal,
       file,
     };
 
-    const response = await packRepository(request);
+    const response = await packRepository(request, {
+      onProgress,
+      signal,
+    });
 
     // Track successful pack
     if (response.metadata.summary) {
diff --git a/website/client/composables/usePackRequest.ts b/website/client/composables/usePackRequest.ts
index 9fb583119..f5fc2c31f 100644
--- a/website/client/composables/usePackRequest.ts
+++ b/website/client/composables/usePackRequest.ts
@@ -1,5 +1,5 @@
 import { computed, onMounted, ref } from 'vue';
-import type { FileInfo, PackResult } from '../components/api/client';
+import type { FileInfo, PackProgressStage, PackResult } from '../components/api/client';
 import { handlePackRequest } from '../components/utils/requestHandlers';
 import { isValidRemoteValue } from '../components/utils/validation';
 import { parseUrlParameters } from '../utils/urlParams';
@@ -24,6 +24,8 @@ export function usePackRequest() {
   const errorType = ref<'error' | 'warning'>('error');
   const result = ref<PackResult | null>(null);
   const hasExecuted = ref(false);
+  const progressStage = ref<PackProgressStage | null>(null);
+  const progressMessage = ref<string | null>(null);
 
   // Request controller for cancellation
   let requestController: AbortController | null = null;
@@ -71,6 +73,8 @@ export function usePackRequest() {
     errorType.value = 'error';
     result.value = null;
     hasExecuted.value = true;
+    progressStage.value = null;
+    progressMessage.value = null;
     inputRepositoryUrl.value = inputUrl.value;
 
     // Set up automatic timeout
@@ -93,6 +97,10 @@ export function usePackRequest() {
             error.value = message;
             errorType.value = 'warning';
           },
+          onProgress: (stage, message) => {
+            progressStage.value = stage;
+            progressMessage.value = message ?? null;
+          },
           signal: requestController.signal,
           file: mode.value === 'file' || mode.value === 'folder' ? uploadedFile.value || undefined : undefined,
         },
@@ -175,6 +183,8 @@ export function usePackRequest() {
     errorType,
     result,
     hasExecuted,
+    progressStage,
+    progressMessage,
 
     // Computed
     isSubmitValid,
diff --git a/website/server/package-lock.json b/website/server/package-lock.json
index 8e9f4fad4..c23cf8b67 100644
--- a/website/server/package-lock.json
+++ b/website/server/package-lock.json
@@ -3476,7 +3476,7 @@
     },
     "node_modules/repomix": {
       "version": "1.13.1",
-      "resolved": "git+ssh://git@github.com/yamadashy/repomix.git#7b9e3d4ccf86d2842af7b04dd31d5ada777deeac",
+      "resolved": "git+ssh://git@github.com/yamadashy/repomix.git#513d62ac9c6aa86d9ec8c426dc1371cc338bb837",
       "license": "MIT",
       "dependencies": {
         "@clack/prompts": "^0.11.0",
diff --git a/website/server/src/actions/packAction.ts b/website/server/src/actions/packAction.ts
index 825b8227e..ba659f927 100644
--- a/website/server/src/actions/packAction.ts
+++ b/website/server/src/actions/packAction.ts
@@ -1,11 +1,12 @@
 import type { Context } from 'hono';
+import { stream } from 'hono/streaming';
 import { isValidRemoteValue } from 'repomix';
 import { z } from 'zod';
 import { processZipFile } from '../domains/pack/processZipFile.js';
 import { processRemoteRepo } from '../domains/pack/remoteRepo.js';
 import { FILE_SIZE_LIMITS } from '../domains/pack/utils/fileUtils.js';
 import { sanitizePattern } from '../domains/pack/utils/validation.js';
-import type { PackResult } from '../types.js';
+import type { PackProgressStage, PackResult } from '../types.js';
 import { getClientInfo } from '../utils/clientInfo.js';
 import { createErrorResponse } from '../utils/http.js';
 import { logError, logInfo } from '../utils/logger.js';
@@ -70,12 +71,12 @@ const packRequestSchema = z
   });
 
 export const packAction = async (c: Context) => {
+  // Parse and validate request before starting stream
+  let validatedData: z.infer<typeof packRequestSchema>;
+  let sanitizedOptions: { includePatterns?: string; ignorePatterns?: string } & Record<string, unknown>;
+
   try {
     const formData = await c.req.formData();
-    const requestId = c.get('requestId');
-
-    // Get client information for logging
-    const clientInfo = getClientInfo(c);
 
     // Get form data
     const format = formData.get('format') as 'xml' | 'markdown' | 'plain';
@@ -84,13 +85,13 @@ export const packAction = async (c: Context) => {
     try {
       options = optionsRaw ? JSON.parse(optionsRaw) : {};
     } catch {
-      return c.json(createErrorResponse('Invalid JSON in options', requestId), 400);
+      return c.json(createErrorResponse('Invalid JSON in options', c.get('requestId')), 400);
     }
     const file = formData.get('file') as File | null;
     const url = formData.get('url') as string | null;
 
     // Validate and sanitize request data
-    const validatedData = validateRequest(packRequestSchema, {
+    validatedData = validateRequest(packRequestSchema, {
       url: url || undefined,
       file: file || undefined,
       format,
@@ -100,55 +101,13 @@ export const packAction = async (c: Context) => {
     const sanitizedIncludePatterns = sanitizePattern(validatedData.options.includePatterns);
     const sanitizedIgnorePatterns = sanitizePattern(validatedData.options.ignorePatterns);
 
-    // Create sanitized options
-    const sanitizedOptions = {
+    sanitizedOptions = {
       ...validatedData.options,
       includePatterns: sanitizedIncludePatterns,
       ignorePatterns: sanitizedIgnorePatterns,
     };
-
-    const startTime = Date.now();
-    const beforeMemory = getMemoryUsage();
-
-    // Process file or repository
-    let result: PackResult;
-    if (validatedData.file) {
-      result = await processZipFile(validatedData.file, validatedData.format, sanitizedOptions);
-    } else {
-      // Zod schema guarantees that url is present when file is not
-      result = await processRemoteRepo(validatedData.url as string, validatedData.format, sanitizedOptions);
-    }
-
-    // Log operation result with memory usage
-    const afterMemory = getMemoryUsage();
-    const memoryDiff = calculateMemoryDiff(beforeMemory, afterMemory);
-
-    logInfo('Pack operation completed', {
-      requestId,
-      format: validatedData.format,
-      repository: result.metadata.repository,
-      duration: formatLatencyForDisplay(startTime),
-      inputType: validatedData.file ? 'file' : validatedData.url ? 'url' : 'unknown',
-      clientInfo: {
-        ip: clientInfo.ip,
-        userAgent: clientInfo.userAgent,
-      },
-      memory: {
-        before: beforeMemory,
-        after: afterMemory,
-        diff: memoryDiff,
-      },
-      metrics: {
-        totalFiles: result.metadata.summary?.totalFiles,
-        totalCharacters: result.metadata.summary?.totalCharacters,
-        totalTokens: result.metadata.summary?.totalTokens,
-      },
-    });
-
-    return c.json(result);
   } catch (error) {
-    // Handle errors
-    logError('Pack operation failed', error instanceof Error ? error : new Error('Unknown error'), {
+    logError('Pack validation failed', error instanceof Error ? error : new Error('Unknown error'), {
       requestId: c.get('requestId'),
     });
 
@@ -156,4 +115,92 @@ export const packAction = async (c: Context) => {
     const appError = handlePackError(error);
     return c.json(createErrorResponse(appError.message, c.get('requestId')), appError.statusCode);
   }
+
+  const requestId = c.get('requestId');
+  const clientInfo = getClientInfo(c);
+
+  // Skip compression for streaming response to ensure real-time progress delivery
+  // (compress middleware skips when Content-Encoding is already set)
+  c.header('Content-Encoding', 'identity');
+
+  // Stream progress events and result via NDJSON using Hono's stream helper
+  return stream(c, async (s) => {
+    const writeLine = async (data: unknown) => {
+      await s.write(`${JSON.stringify(data)}\n`);
+    };
+
+    try {
+      const THROTTLE_MS = 200;
+      let lastProgressTime = 0;
+      let lastStage: PackProgressStage | null = null;
+
+      const sendProgress = async (stage: PackProgressStage, message?: string) => {
+        const now = Date.now();
+        const stageChanged = stage !== lastStage;
+
+        // Always send immediately when stage changes; throttle within same stage
+        if (!stageChanged && now - lastProgressTime < THROTTLE_MS) {
+          return;
+        }
+
+        lastProgressTime = now;
+        lastStage = stage;
+        await writeLine({ type: 'progress', stage, ...(message && { message }) });
+      };
+
+      const startTime = Date.now();
+      const beforeMemory = getMemoryUsage();
+
+      // Process file or repository with progress reporting
+      let result: PackResult;
+      if (validatedData.file) {
+        result = await processZipFile(validatedData.file, validatedData.format, sanitizedOptions, sendProgress);
+      } else {
+        result = await processRemoteRepo(
+          validatedData.url as string,
+          validatedData.format,
+          sanitizedOptions,
+          sendProgress,
+        );
+      }
+
+      // Log operation result with memory usage
+      const afterMemory = getMemoryUsage();
+      const memoryDiff = calculateMemoryDiff(beforeMemory, afterMemory);
+
+      logInfo('Pack operation completed', {
+        requestId,
+        format: validatedData.format,
+        repository: result.metadata.repository,
+        duration: formatLatencyForDisplay(startTime),
+        inputType: validatedData.file ? 'file' : validatedData.url ? 'url' : 'unknown',
+        clientInfo: {
+          ip: clientInfo.ip,
+          userAgent: clientInfo.userAgent,
+        },
+        memory: {
+          before: beforeMemory,
+          after: afterMemory,
+          diff: memoryDiff,
+        },
+        metrics: {
+          totalFiles: result.metadata.summary?.totalFiles,
+          totalCharacters: result.metadata.summary?.totalCharacters,
+          totalTokens: result.metadata.summary?.totalTokens,
+        },
+      });
+
+      // Send the final result
+      await writeLine({ type: 'result', data: result });
+    } catch (error) {
+      logError('Pack operation failed', error instanceof Error ? error : new Error('Unknown error'), {
+        requestId,
+      });
+
+      const { handlePackError } = await import('../utils/errorHandler.js');
+      const appError = handlePackError(error);
+
+      await writeLine({ type: 'error', message: appError.message });
+    }
+  });
 };
diff --git a/website/server/src/domains/pack/processZipFile.ts b/website/server/src/domains/pack/processZipFile.ts
index 2ba5daef9..306016940 100644
--- a/website/server/src/domains/pack/processZipFile.ts
+++ b/website/server/src/domains/pack/processZipFile.ts
@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { unzip } from 'fflate';
 import { type CliOptions, runDefaultAction, setLogLevel } from 'repomix';
-import type { PackOptions, PackResult } from '../../types.js';
+import type { PackOptions, PackProgressCallback, PackResult } from '../../types.js';
 import { AppError } from '../../utils/errorHandler.js';
 import { logMemoryUsage } from '../../utils/logger.js';
 import { cleanupTempDirectory, copyOutputToCurrentDirectory, createTempDirectory } from './utils/fileUtils.js';
@@ -20,7 +20,12 @@ const ZIP_SECURITY_LIMITS = {
 /**
  * Process an uploaded ZIP file
  */
-export async function processZipFile(file: File, format: string, options: PackOptions): Promise<PackResult> {
+export async function processZipFile(
+  file: File,
+  format: string,
+  options: PackOptions,
+  onProgress?: PackProgressCallback,
+): Promise<PackResult> {
   if (!file) {
     throw new AppError('File is required for file processing', 400);
   }
@@ -58,10 +63,15 @@ export async function processZipFile(file: File, format: string, options: PackOp
     });
 
     // Extract the ZIP file to the temporary directory with enhanced security checks
+    await onProgress?.('extracting');
     await extractZipWithSecurity(file, tempDirPath);
 
     // Execute default action on the extracted directory
-    const result = await runDefaultAction([tempDirPath], tempDirPath, cliOptions);
+    await onProgress?.('processing');
+    const packProgressCallback = (message: string) => {
+      return onProgress?.('processing', message);
+    };
+    const result = await runDefaultAction([tempDirPath], tempDirPath, cliOptions, packProgressCallback);
     await copyOutputToCurrentDirectory(tempDirPath, process.cwd(), result.config.output.filePath);
     const { packResult } = result;
 
diff --git a/website/server/src/domains/pack/remoteRepo.ts b/website/server/src/domains/pack/remoteRepo.ts
index ca44de9bf..b61819cf4 100644
--- a/website/server/src/domains/pack/remoteRepo.ts
+++ b/website/server/src/domains/pack/remoteRepo.ts
@@ -1,13 +1,37 @@
+import { execFile } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
-import { type CliOptions, runCli } from 'repomix';
-import type { PackOptions, PackResult } from '../../types.js';
+import { promisify } from 'node:util';
+import { type CliOptions, parseRemoteValue, runDefaultAction } from 'repomix';
+import type { PackOptions, PackProgressCallback, PackResult } from '../../types.js';
 import { AppError } from '../../utils/errorHandler.js';
 import { logMemoryUsage } from '../../utils/logger.js';
 import { generateCacheKey } from './utils/cache.js';
+import { cleanupTempDirectory, copyOutputToCurrentDirectory, createTempDirectory } from './utils/fileUtils.js';
 import { cache } from './utils/sharedInstance.js';
 
-export async function processRemoteRepo(repoUrl: string, format: string, options: PackOptions): Promise<PackResult> {
+const execFileAsync = promisify(execFile);
+
+async function cloneRepository(repoUrl: string, destPath: string, branch?: string): Promise<void> {
+  const args = ['clone', '--depth', '1', '--single-branch'];
+  if (branch) {
+    args.push('--branch', branch);
+  }
+  args.push('--', repoUrl, destPath);
+
+  try {
+    await execFileAsync('git', args, { timeout: 60_000, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+  } catch {
+    throw new AppError('Failed to clone repository.\nThe repository may not be public or the URL may be invalid.', 500);
+  }
+}
+
+export async function processRemoteRepo(
+  repoUrl: string,
+  format: string,
+  options: PackOptions,
+  onProgress?: PackProgressCallback,
+): Promise<PackResult> {
   if (!repoUrl) {
     throw new AppError('Repository URL is required for remote processing', 400);
   }
@@ -16,16 +40,20 @@ export async function processRemoteRepo(repoUrl: string, format: string, options
   const cacheKey = generateCacheKey(repoUrl, format, options, 'url');
 
   // Check if the result is already cached
+  await onProgress?.('cache-check');
   const cachedResult = await cache.get(cacheKey);
   if (cachedResult) {
     return cachedResult;
   }
 
+  // Clone the repository
+  await onProgress?.('cloning');
+  const parsed = parseRemoteValue(repoUrl);
+  const tempDirPath = await createTempDirectory();
   const outputFilePath = `repomix-output-${randomUUID()}.txt`;
 
-  // Create CLI options with correct mapping
+  // Create CLI options for runDefaultAction (no 'remote' needed since we clone ourselves)
   const cliOptions = {
-    remote: repoUrl,
     output: outputFilePath,
     style: format,
     parsableStyle: options.outputParsable,
@@ -39,7 +67,8 @@ export async function processRemoteRepo(repoUrl: string, format: string, options
     topFilesLen: 10,
     include: options.includePatterns,
     ignore: options.ignorePatterns,
-    quiet: true, // Enable quiet mode to suppress output
+    quiet: true,
+    skipLocalConfig: true, // Prevent loading config files from untrusted cloned repositories
   } as CliOptions;
 
   try {
@@ -49,11 +78,16 @@ export async function processRemoteRepo(repoUrl: string, format: string, options
       format: format,
     });
 
-    // Execute remote action
-    const result = await runCli(['.'], process.cwd(), cliOptions);
-    if (!result) {
-      throw new AppError('Remote action failed to return a result', 500);
-    }
+    // Clone the repository to temp directory
+    await cloneRepository(parsed.repoUrl, tempDirPath, parsed.remoteBranch);
+
+    // Process the cloned repository
+    await onProgress?.('processing');
+    const packProgressCallback = (message: string) => {
+      return onProgress?.('processing', message);
+    };
+    const result = await runDefaultAction([tempDirPath], tempDirPath, cliOptions, packProgressCallback);
+    await copyOutputToCurrentDirectory(tempDirPath, process.cwd(), result.config.output.filePath);
     const { packResult } = result;
 
     // Read the generated file
@@ -83,7 +117,7 @@ export async function processRemoteRepo(repoUrl: string, format: string, options
           .map(([path, charCount]) => ({
             path,
             charCount: charCount as number,
-            selected: true, // Default to selected for initial packing
+            selected: true,
           }))
           .sort((a, b) => b.charCount - a.charCount),
       },
@@ -103,6 +137,9 @@ export async function processRemoteRepo(repoUrl: string, format: string, options
     return packResultData;
   } catch (error) {
     console.error('Error in remote repository processing:', error);
+    if (error instanceof AppError) {
+      throw error;
+    }
     if (error instanceof Error) {
       throw new AppError(
         `Remote repository processing failed.\nThe repository may not be public or there may be an issue with Repomix.\n\n${error.message}`,
@@ -114,12 +151,11 @@ export async function processRemoteRepo(repoUrl: string, format: string, options
       500,
     );
   } finally {
-    // Clean up the output file
+    await cleanupTempDirectory(tempDirPath);
     try {
       await fs.unlink(outputFilePath);
-    } catch (err) {
+    } catch {
       // Ignore file deletion errors
-      console.warn('Failed to cleanup output file:', err);
     }
   }
 }
diff --git a/website/server/src/types.ts b/website/server/src/types.ts
index 6b2baabb6..d66971f3a 100644
--- a/website/server/src/types.ts
+++ b/website/server/src/types.ts
@@ -49,3 +49,8 @@ export interface PackResult {
 export interface ErrorResponse {
   error: string;
 }
+
+// Progress streaming types
+export type PackProgressStage = 'cache-check' | 'cloning' | 'repository-fetch' | 'extracting' | 'processing';
+
+export type PackProgressCallback = (stage: PackProgressStage, message?: string) => void | Promise<void>;