optikit 1.0.1

package/.history/src/commands/cleanProjectIos_20241023182237.ts

@@ -0,0 +1,64 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+const COMMAND_TIMEOUT_MS = 600000; // Set timeout duration to 10 minutes (10 * 60 * 1000 ms)
+
+function execWithTimeout(command: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`Command timed out after ${timeout / 1000} seconds: ${command}`));
+    }, COMMAND_TIMEOUT_MS);
+
+    execInIos(command)
+      .then(() => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        resolve();
+      })
+      .catch((error) => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        reject(error);
+      });
+  });
+}
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execWithTimeout("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execWithTimeout("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execWithTimeout("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execWithTimeout("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      await execWithTimeout("pod install --repo-update", COMMAND_TIMEOUT_MS);
+      console.log(chalk.yellow("Installed pods with repo update."));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023182239.ts

@@ -0,0 +1,64 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+const COMMAND_TIMEOUT_MS = 600000; // Set timeout duration to 10 minutes (10 * 60 * 1000 ms)
+
+function execWithTimeout(command: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`Command timed out after ${timeout / 1000} seconds: ${command}`));
+    }, COMMAND_TIMEOUT_MS);
+
+    execInIos(command)
+      .then(() => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        resolve();
+      })
+      .catch((error) => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        reject(error);
+      });
+  });
+}
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execWithTimeout("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execWithTimeout("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execWithTimeout("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execWithTimeout("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      await execWithTimeout("pod install --repo-update");
+      console.log(chalk.yellow("Installed pods with repo update."));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023182256.ts

@@ -0,0 +1,64 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+const COMMAND_TIMEOUT_MS = 600000; // Set timeout duration to 10 minutes (10 * 60 * 1000 ms)
+
+function execWithTimeout(command: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`Command timed out after ${COMMAND_TIMEOUT_MS / 1000} seconds: ${command}`));
+    }, COMMAND_TIMEOUT_MS);
+
+    execInIos(command)
+      .then(() => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        resolve();
+      })
+      .catch((error) => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        reject(error);
+      });
+  });
+}
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execWithTimeout("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execWithTimeout("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execWithTimeout("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execWithTimeout("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      await execWithTimeout("pod install --repo-update");
+      console.log(chalk.yellow("Installed pods with repo update."));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023183254.ts

@@ -0,0 +1,65 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+const COMMAND_TIMEOUT_MS = 600000; // Set timeout duration to 10 minutes (10 * 60 * 1000 ms)
+
+function execWithTimeout(command: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`Command timed out after ${COMMAND_TIMEOUT_MS / 1000} seconds: ${command}`));
+    }, COMMAND_TIMEOUT_MS);
+
+    execInIos(command)
+      .then(() => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        resolve();
+      })
+      .catch((error) => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        reject(error);
+      });
+  });
+}
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execWithTimeout("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execWithTimeout("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execWithTimeout("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execWithTimeout("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      const installOutput = await execWithTimeout("pod install --repo-update --verbose", COMMAND_TIMEOUT_MS);
+      console.log(chalk.yellow("Installed pods with repo update."));
+      console.log(chalk.blue(`Pod install output: ${installOutput}`)); 
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023183257.ts

@@ -0,0 +1,65 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+const COMMAND_TIMEOUT_MS = 600000; // Set timeout duration to 10 minutes (10 * 60 * 1000 ms)
+
+function execWithTimeout(command: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`Command timed out after ${COMMAND_TIMEOUT_MS / 1000} seconds: ${command}`));
+    }, COMMAND_TIMEOUT_MS);
+
+    execInIos(command)
+      .then(() => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        resolve();
+      })
+      .catch((error) => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        reject(error);
+      });
+  });
+}
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execWithTimeout("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execWithTimeout("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execWithTimeout("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execWithTimeout("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      const installOutput = await execWithTimeout("pod install --repo-update --verbose");
+      console.log(chalk.yellow("Installed pods with repo update."));
+      console.log(chalk.blue(`Pod install output: ${installOutput}`)); 
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023183347.ts

@@ -0,0 +1,64 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+const COMMAND_TIMEOUT_MS = 600000; // Set timeout duration to 10 minutes (10 * 60 * 1000 ms)
+
+function execWithTimeout(command: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`Command timed out after ${COMMAND_TIMEOUT_MS / 1000} seconds: ${command}`));
+    }, COMMAND_TIMEOUT_MS);
+
+    execInIos(command)
+      .then(() => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        resolve();
+      })
+      .catch((error) => {
+        clearTimeout(COMMAND_TIMEOUT_MS);
+        reject(error);
+      });
+  });
+}
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execWithTimeout("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execWithTimeout("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execWithTimeout("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execWithTimeout("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      await execWithTimeout("pod install --repo-update");
+      console.log(chalk.yellow("Installed pods with repo update."));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023184055.ts

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execWithTimeout("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execWithTimeout("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execWithTimeout("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execWithTimeout("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      await execWithTimeout("pod install --repo-update");
+      console.log(chalk.yellow("Installed pods with repo update."));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023184057.ts

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execWithTimeout("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execWithTimeout("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execWithTimeout("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execInIos("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      await execWithTimeout("pod install --repo-update");
+      console.log(chalk.yellow("Installed pods with repo update."));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023184059.ts

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execWithTimeout("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execInIos("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execInIos("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execInIos("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      await execWithTimeout("pod install --repo-update");
+      console.log(chalk.yellow("Installed pods with repo update."));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023184101.ts

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execInIos("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execInIos("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execInIos("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execInIos("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      await execWithTimeout("pod install --repo-update");
+      console.log(chalk.yellow("Installed pods with repo update."));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023184102.ts

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+
+export async function cleanIosProject() {
+    try {
+      const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  
+      if (!fs.existsSync(xcodeProjPath)) {
+        throw new Error("No Xcode project found in the ios directory.");
+      }
+  
+      console.log(chalk.green("Running clean for iOS project..."));
+  
+      await execInIos("rm -rf Podfile.lock");
+      console.log(chalk.yellow("Removed Podfile.lock."));
+  
+      await execInIos("pod deintegrate");
+      console.log(chalk.yellow("Deintegrated pods."));
+  
+      // Clean CocoaPods cache
+      await execInIos("pod cache clean --all");
+      console.log(chalk.yellow("Cleaned CocoaPods cache."));
+  
+      // Update CocoaPods repositories
+      console.log(chalk.green("Updating CocoaPods repositories..."));
+      await execInIos("pod repo update");
+      console.log(chalk.yellow("Updated CocoaPods repositories."));
+  
+      console.log(chalk.green("Installing pods with repo update..."));
+      await execInIos("pod install --repo-update");
+      console.log(chalk.yellow("Installed pods with repo update."));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else if (typeof error === "string") {
+        console.error(chalk.red(`Error: ${error}`));
+      } else {
+        console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+      }
+    }
+  }

package/.history/src/commands/cleanProjectIos_20241023232407.ts

@@ -0,0 +1,69 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { execInIos, iosDirectory } from "../utils/execHelpers.js";
+
+// Path to the Flutter.xcframework
+const FLUTTER_XCFRAMEWORK_PATH = path.join(
+  process.cwd(),
+  "flutter",
+  "bin",
+  "cache",
+  "artifacts",
+  "engine",
+  "ios",
+  "Flutter.xcframework"
+);
+
+// Check if the Flutter.xcframework exists
+async function checkFlutterArtifacts() {
+  if (!fs.existsSync(FLUTTER_XCFRAMEWORK_PATH)) {
+    console.log(chalk.yellow("Flutter.xcframework not found. Running 'flutter precache --ios'..."));
+    await execInIos("flutter precache --ios");
+    console.log(chalk.green("Flutter.xcframework has been downloaded."));
+  } else {
+    console.log(chalk.green("Flutter.xcframework exists."));
+  }
+}
+
+export async function cleanIosProject() {
+  try {
+    const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+
+    if (!fs.existsSync(xcodeProjPath)) {
+      throw new Error("No Xcode project found in the ios directory.");
+    }
+
+    console.log(chalk.green("Running clean for iOS project..."));
+
+    // Check for Flutter artifacts before proceeding
+    await checkFlutterArtifacts();
+
+    await execInIos("rm -rf Podfile.lock");
+    console.log(chalk.yellow("Removed Podfile.lock."));
+
+    await execInIos("pod deintegrate");
+    console.log(chalk.yellow("Deintegrated pods."));
+
+    // Clean CocoaPods cache
+    await execInIos("pod cache clean --all");
+    console.log(chalk.yellow("Cleaned CocoaPods cache."));
+
+    // Update CocoaPods repositories
+    console.log(chalk.green("Updating CocoaPods repositories..."));
+    await execInIos("pod repo update");
+    console.log(chalk.yellow("Updated CocoaPods repositories."));
+
+    console.log(chalk.green("Installing pods with repo update..."));
+    await execInIos("pod install --repo-update");
+    console.log(chalk.yellow("Installed pods with repo update."));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+    } else if (typeof error === "string") {
+      console.error(chalk.red(`Error: ${error}`));
+    } else {
+      console.error(chalk.red(`Unknown error: ${JSON.stringify(error)}`));
+    }
+  }
+}