added basic generator to show loaded files

Author: kfirstri

src/cli/commands/site/deploy.ts

@@ -6,42 +6,40 @@ import { deploySite } from "@core/site/index.js";
 import { runCommand, runTask } from "../../utils/index.js";
 
 async function deployAction(): Promise<void> {
-  // 1. Load project config
   const { project } = await readProjectConfig();
 
-  // 2. Validate site configuration exists
   if (!project.site?.outputDirectory) {
-    log.error(
-      "No site configuration found. Please add a 'site.outputDirectory' to your config.jsonc"
+    throw new Error(
+      "No site configuration found. Please add 'site.outputDirectory' to your config.jsonc"
     );
-    process.exit(1);
   }
 
   const outputDir = resolve(project.root, project.site.outputDirectory);
 
-  // 3. Confirm with user
   const shouldDeploy = await confirm({
     message: `Deploy site from ${project.site.outputDirectory}?`,
   });
 
   if (isCancel(shouldDeploy) || !shouldDeploy) {
     log.warn("Deployment cancelled");
-    process.exit(0);
+    return;
   }
 
-  // 4. Deploy to Base44
   const result = await runTask(
-    "Deploying site...",
-    async () => {
-      return await deploySite(outputDir);
+    "Reading site files...",
+    async (updateMessage) => {
+      return await deploySite(outputDir, (progress) => {
+        updateMessage(
+          `Reading files (${progress.current}/${progress.total}): ${progress.path}`
+        );
+      });
     },
     {
       successMessage: "Site deployed successfully",
-      errorMessage: "Failed to deploy site",
+      errorMessage: "Deployment failed",
     }
   );
 
-  // 5. Display the deployed URL
   log.success(`Site deployed to: ${result.url}`);
 }
 

src/cli/utils/runTask.ts

@@ -5,11 +5,13 @@ import { spinner } from "@clack/prompts";
  * The spinner is automatically started, and stopped on both success and error.
  *
  * @param startMessage - Message to show when spinner starts
- * @param operation - The async operation to execute
+ * @param operation - The async operation to execute. Receives an updateMessage function
+ *                    to update the spinner text during long-running operations.
  * @param options - Optional configuration for success/error messages
  * @returns The result of the operation
  *
  * @example
+ * // Simple usage
  * const data = await runTask(
  *   "Fetching data...",
  *   async () => {
@@ -21,10 +23,24 @@ import { spinner } from "@clack/prompts";
  *     errorMessage: "Failed to fetch data",
  *   }
  * );
+ *
+ * @example
+ * // With progress updates
+ * const result = await runTask(
+ *   "Processing files...",
+ *   async (updateMessage) => {
+ *     for (const file of files) {
+ *       updateMessage(`Processing ${file.name}...`);
+ *       await process(file);
+ *     }
+ *     return files.length;
+ *   },
+ *   { successMessage: "All files processed" }
+ * );
  */
 export async function runTask<T>(
   startMessage: string,
-  operation: () => Promise<T>,
+  operation: (updateMessage: (message: string) => void) => Promise<T>,
   options?: {
     successMessage?: string;
     errorMessage?: string;
@@ -33,8 +49,10 @@ export async function runTask<T>(
   const s = spinner();
   s.start(startMessage);
 
+  const updateMessage = (message: string) => s.message(message);
+
   try {
-    const result = await operation();
+    const result = await operation(updateMessage);
     s.stop(options?.successMessage || startMessage);
     return result;
   } catch (error) {

src/core/site/api.ts

@@ -5,21 +5,17 @@ import type { SiteFile, DeployResponse } from "./schema.js";
  *
  * @param files - Array of files with base64-encoded content to upload
  * @returns Deploy response with the site URL
- *
- * @example
- * const files = await readSiteFiles("./dist");
- * const { url } = await uploadSite(files);
  */
 export async function uploadSite(files: SiteFile[]): Promise<DeployResponse> {
   // TODO: Implement actual FormData upload to Base44 API
   // The endpoint will accept multipart/form-data with all files
   // and return the deployed site URL
 
   // Placeholder implementation - simulate API call
-  await Promise.resolve();
+  await new Promise((resolve) => setTimeout(resolve, 2000));
 
   // Log file count for debugging (remove when implementing real API)
-  console.log(`[Placeholder] Would upload ${files.length} files`);
+  // console.log(`[Placeholder] Would upload ${files.length} files`);
 
   return {
     url: "https://example.base44.app",

src/core/site/config.ts

@@ -3,41 +3,49 @@ import { join } from "node:path";
 import { globby } from "globby";
 import type { SiteFile } from "./schema.js";
 
-/**
- * Reads all files from a site output directory and encodes them as base64.
- *
- * @param outputDir - The directory containing built site files (e.g., "dist")
- * @returns Array of SiteFile objects with relative paths and base64 content
- *
- * @example
- * const files = await readSiteFiles("./dist");
- * // files = [{ path: "index.html", content: "PGh0bWw+..." }, ...]
- */
-export async function readSiteFiles(outputDir: string): Promise<SiteFile[]> {
-  // Glob all files (not directories) in the output directory
-  const filePaths = await globby("**/*", {
+async function readSiteFile(
+  outputDir: string,
+  relativePath: string
+): Promise<SiteFile> {
+  const absolutePath = join(outputDir, relativePath);
+  const buffer = await readFile(absolutePath);
+  const content = buffer.toString("base64");
+
+  await new Promise((resolve) => setTimeout(resolve, 20));
+
+  return {
+    path: relativePath,
+    content,
+  };
+}
+
+export async function getSiteFilePaths(outputDir: string): Promise<string[]> {
+  return await globby("**/*", {
     cwd: outputDir,
     onlyFiles: true,
     absolute: false,
   });
+}
 
-  if (filePaths.length === 0) {
-    return [];
+/**
+ * Reads site files one by one, yielding each file as it's read.
+ * Useful for showing progress during file reading.
+ *
+ * @param outputDir - The directory containing built site files
+ * @param filePaths - Array of relative file paths to read
+ * @yields Each file as it's read
+ *
+ * @example
+ * const paths = await getSiteFilePaths("./dist");
+ * for await (const file of readSiteFilesStream("./dist", paths)) {
+ *   console.log(`Read: ${file.path}`);
+ * }
+ */
+export async function* readSiteFilesStream(
+  outputDir: string,
+  filePaths: string[]
+): AsyncGenerator<SiteFile> {
+  for (const relativePath of filePaths) {
+    yield await readSiteFile(outputDir, relativePath);
   }
-
-  // Read each file and encode as base64
-  const files = await Promise.all(
-    filePaths.map(async (relativePath): Promise<SiteFile> => {
-      const absolutePath = join(outputDir, relativePath);
-      const buffer = await readFile(absolutePath);
-      const content = buffer.toString("base64");
-
-      return {
-        path: relativePath,
-        content,
-      };
-    })
-  );
-
-  return files;
 }

src/core/site/deploy.ts

@@ -1,27 +1,51 @@
-import type { DeployResponse } from "./schema.js";
-import { readSiteFiles } from "./config.js";
+import type { SiteFile, DeployResponse } from "./schema.js";
+import { getSiteFilePaths, readSiteFilesStream } from "./config.js";
 import { uploadSite } from "./api.js";
 
+export interface DeploySiteProgress {
+  total: number;
+  current: number;
+  path: string;
+}
+
 /**
  * Deploys a site from the given output directory to Base44 hosting.
- * Reads all files, validates, and uploads to the API.
+ * Reads files one by one with progress callback, validates, and uploads to the API.
  *
  * @param outputDir - The directory containing built site files (e.g., "./dist")
+ * @param onProgress - Optional callback called for each file read
  * @returns Deploy response with the site URL
  * @throws Error if no files found in the output directory
  *
  * @example
- * const { url } = await deploySite("./dist");
- * console.log(`Deployed to: ${url}`);
+ * const { url } = await deploySite("./dist", (progress) => {
+ *   console.log(`Reading ${progress.current}/${progress.total}: ${progress.path}`);
+ * });
  */
-export async function deploySite(outputDir: string): Promise<DeployResponse> {
-  const files = await readSiteFiles(outputDir);
+export async function deploySite(
+  outputDir: string,
+  onProgress?: (progress: DeploySiteProgress) => void
+): Promise<DeployResponse> {
+  const filePaths = await getSiteFilePaths(outputDir);
 
-  if (files.length === 0) {
+  if (filePaths.length === 0) {
     throw new Error(
       `No files found in output directory: ${outputDir}. Make sure to build your project first.`
     );
   }
 
+  const files: SiteFile[] = [];
+  let current = 0;
+
+  for await (const file of readSiteFilesStream(outputDir, filePaths)) {
+    current++;
+    onProgress?.({
+      total: filePaths.length,
+      current,
+      path: file.path,
+    });
+    files.push(file);
+  }
+
   return await uploadSite(files);
 }