@stacksjs/cloud 0.58.51 → 0.58.52

package/dist/index.js

@@ -1,15 +1,4 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
 // src/helpers.ts
 import {CloudFormation} from "@aws-sdk/client-cloudformation";
 import {CloudWatchLogsClient, DeleteLogGroupCommand, DescribeLogGroupsCommand} from "@aws-sdk/client-cloudwatch-logs";
@@ -21,7 +10,7 @@ import {Lambda} from "@aws-sdk/client-lambda";
 import {ContactType, Route53Domains} from "@aws-sdk/client-route-53-domains";
 import {ListBucketsCommand, S3} from "@aws-sdk/client-s3";
 import {config as config2} from "@stacksjs/config";
-import {err, handleError as handleError2, ok} from "@stacksjs/error-handling";
+import {err, handleError, ok} from "@stacksjs/error-handling";
 import {log} from "@stacksjs/logging";
 import {path as p} from "@stacksjs/path";
 import {rimraf} from "@stacksjs/utils";
@@ -127,6 +116,7 @@ async function deleteJumpBox(stackName) {
   const jumpBoxId = await getJumpBoxInstanceId();
   if (!jumpBoxId)
     return err("Jump-box not found");
+  log.info(`Deleting jump-box ${jumpBoxId}...`);
   return await deleteEc2Instance(jumpBoxId, stackName);
 }
 async function deleteIamUsers() {
@@ -150,7 +140,7 @@ async function deleteIamUsers() {
   });
   await Promise.all(promises).catch((error) => {
     console.error(`Error deleting user: ${error}`);
-    return err(handleError2("Error deleting Stacks IAM users", error));
+    return err(handleError("Error deleting Stacks IAM users", error));
   });
   return ok(`Stacks IAM users deleted for team ${teamName}`);
 }
@@ -168,39 +158,39 @@ async function deleteStacksBuckets() {
       log.info(`Finished listing bucket ${bucketName} objects`);
       if (objects.Contents) {
         log.info("Deleting bucket objects...");
-        await Promise.all(objects.Contents.map((object) => s3.deleteObject({ Bucket: bucketName, Key: object.Key || "" }).catch((error) => handleError2(error))));
+        await Promise.all(objects.Contents.map((object) => s3.deleteObject({ Bucket: bucketName, Key: object.Key || "" }).catch((error) => handleError(error))));
         log.info(`Finished deleting objects from bucket ${bucketName}`);
       }
       log.info(`Deleting bucket ${bucketName} versions...`);
       try {
         const versions = await s3.listObjectVersions({ Bucket: bucketName });
         if (versions.Versions) {
-          await Promise.all(versions.Versions.map((version) => s3.deleteObject({ Bucket: bucketName, Key: version.Key || "", VersionId: version.VersionId }))).catch((error) => handleError2(error));
+          await Promise.all(versions.Versions.map((version) => s3.deleteObject({ Bucket: bucketName, Key: version.Key || "", VersionId: version.VersionId }))).catch((error) => handleError(error));
           log.info(`Finished deleting versions from bucket ${bucketName}`);
         }
         log.info(`Deleting bucket ${bucketName} delete markers...`);
         if (versions.DeleteMarkers) {
-          await Promise.all(versions.DeleteMarkers.map((marker) => s3.deleteObject({ Bucket: bucketName, Key: marker.Key || "", VersionId: marker.VersionId }))).catch((error) => handleError2(error));
+          await Promise.all(versions.DeleteMarkers.map((marker) => s3.deleteObject({ Bucket: bucketName, Key: marker.Key || "", VersionId: marker.VersionId }))).catch((error) => handleError(error));
           log.info(`Finished deleting delete markers from bucket ${bucketName}`);
         }
         const uploads = await s3.listMultipartUploads({ Bucket: bucketName });
         if (uploads.Uploads) {
           log.info("Aborting bucket multipart uploads...");
-          await Promise.all(uploads.Uploads.map((upload) => s3.abortMultipartUpload({ Bucket: bucketName, Key: upload.Key || "", UploadId: upload.UploadId }))).catch((error) => handleError2(error));
+          await Promise.all(uploads.Uploads.map((upload) => s3.abortMultipartUpload({ Bucket: bucketName, Key: upload.Key || "", UploadId: upload.UploadId }))).catch((error) => handleError(error));
           log.info(`Finished aborting multipart uploads from bucket ${bucketName}`);
         }
-        await s3.deleteBucket({ Bucket: bucketName }).catch((error) => handleError2(error));
+        await s3.deleteBucket({ Bucket: bucketName }).catch((error) => handleError(error));
         log.info(`Bucket ${bucketName} deleted`);
       } catch (error) {
         log.info(`Error listing bucket ${bucketName} versions`, error);
       }
     });
     await Promise.all(promises).catch((error) => {
-      return err(handleError2("Error deleting stacks buckets", error));
+      return err(handleError("Error deleting stacks buckets", error));
     });
     return ok("Stacks buckets deleted");
   } catch (error) {
-    return err(handleError2("Error deleting stacks buckets", error));
+    return err(handleError("Error deleting stacks buckets", error));
   }
 }
 async function deleteStacksFunctions() {
@@ -215,7 +205,7 @@ async function deleteStacksFunctions() {
       log.info("Function is replicated, skipping...");
       return ok("CloudFront is still deleting the some functions. Try again later.");
     }
-    return err(handleError2("Error deleting stacks functions", error));
+    return err(handleError("Error deleting stacks functions", error));
   });
   return ok("Stacks functions deleted");
 }
@@ -231,7 +221,7 @@ async function deleteLogGroups() {
     }
     return ok("Log groups deleted");
   } catch (error) {
-    return err(handleError2("Error deleting log groups", error));
+    return err(handleError("Error deleting log groups", error));
   }
 }
 async function deleteParameterStore() {
@@ -244,7 +234,7 @@ async function deleteParameterStore() {
     return ok("No stacks parameters found");
   const promises = stacksParameters.map((param) => ssm.deleteParameter({ Name: param.Name || "" }));
   await Promise.all(promises).catch((error) => {
-    return err(handleError2("Error deleting parameter store", error));
+    return err(handleError("Error deleting parameter store", error));
   });
   return ok("Parameter store deleted");
 }
@@ -255,7 +245,7 @@ async function deleteCdkRemnants() {
       p.cloudPath("cdk.context.json")
     ]));
   } catch (error) {
-    return err(handleError2("Error deleting CDK remnants", error));
+    return err(handleError("Error deleting CDK remnants", error));
   }
 }
 async function hasBeenDeployed() {
@@ -264,7 +254,7 @@ async function hasBeenDeployed() {
     const response = await s3.send(new ListBucketsCommand({}));
     return ok(response.Buckets?.some((bucket) => bucket.Name?.includes(config2.app.name?.toLocaleLowerCase() || "stacks")) || false);
   } catch (error) {
-    return err(handleError2("Error checking if the app has been deployed", error));
+    return err(handleError("Error checking if the app has been deployed", error));
   }
 }
 async function getJumpBoxInstanceProfileName() {
@@ -488,729 +478,10 @@ class AiStack {
 // src/cloud/cdn.ts
 import {Duration as Duration2, Fn, CfnOutput as Output2, aws_cloudfront as cloudfront, aws_cloudfront_origins as origins, aws_route53 as route53, aws_route53_targets as targets} from "aws-cdk-lib";
 import {config as config6} from "@stacksjs/config";
-
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/files.ts
-import {detectIndent, detectNewline} from "@stacksjs/strings";
-import {dirname, join as join2, path as p2} from "@stacksjs/path";
-
-// /home/runner/work/stacks/stacks/storage/framework/core/arrays/src/helpers.ts
-import {clamp} from "@stacksjs/utils";
-// /home/runner/work/stacks/stacks/storage/framework/core/arrays/src/contains.ts
-function contains(needle, haystack) {
-  return haystack.some((hay) => needle.includes(hay));
-}
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/fs.ts
-import {mkdirSync, writeFileSync} from "fs";
-import * as fs from "fs-extra";
-import {pathExists as existsSync} from "fs-extra";
-async function exists(path2) {
-  return await existsSync(path2);
-}
-
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/files.ts
-async function readJsonFile(name, cwd) {
-  const file = await readTextFile(name, cwd);
-  const data = JSON.parse(file.data);
-  const indent = detectIndent(file.data).indent;
-  const newline = detectNewline(file.data);
-  return { ...file, data, indent, newline };
-}
-async function readPackageJson(name, cwd) {
-  const file = await readJsonFile(name, cwd);
-  return file.data;
-}
-async function writeFile(path3, data) {
-  if (typeof path3 === "string") {
-    const dirPath = dirname(path3);
-    if (!await existsSync(dirPath))
-      await createFolder(dirPath);
-    return await Bun.write(Bun.file(path3), data);
-  }
-  return await Bun.write(path3, data);
-}
-async function writeJsonFile(file) {
-  let json = JSON.stringify(file.data, undefined, file.indent);
-  if (file.newline)
-    json += file.newline;
-  return writeTextFile({ ...file, data: json });
-}
-function readTextFile(name, cwd) {
-  return new Promise((resolve, reject) => {
-    let filePath;
-    if (cwd)
-      filePath = join2(cwd, name);
-    else
-      filePath = name;
-    fs.readFile(filePath, "utf8", (err2, text) => {
-      if (err2) {
-        reject(err2);
-      } else {
-        resolve({
-          path: filePath,
-          data: text
-        });
-      }
-    });
-  });
-}
-async function writeTextFile(file) {
-  return await Bun.write(file.path, file.data);
-}
-function isFile(path3) {
-  return fs.existsSync(path3);
-}
-function doesExist(path3) {
-  return !isFile(path3) || !isFolder(path3);
-}
-function doesNotExist(path3) {
-  return !isFile(path3) && !isFolder(path3);
-}
-function hasFiles(folder) {
-  try {
-    return fs.readdirSync(folder).length > 0;
-  } catch (err2) {
-    return false;
-  }
-}
-function hasComponents() {
-  return hasFiles(p2.componentsPath());
-}
-function hasFunctions() {
-  return hasFiles(p2.functionsPath());
-}
-function deleteFiles(dir, exclude = []) {
-  if (fs.existsSync(dir)) {
-    fs.readdirSync(dir).forEach((file) => {
-      const p3 = join2(dir, file);
-      if (fs.statSync(p3).isDirectory()) {
-        if (fs.readdirSync(p3).length === 0)
-          fs.rmSync(p3, { recursive: true, force: true });
-        else
-          deleteFiles(p3, exclude);
-      } else if (!contains(p3, exclude)) {
-        fs.rmSync(p3);
-      }
-    });
-  }
-}
-function getFiles(dir, exclude = []) {
-  let results = [];
-  const list = fs.readdirSync(dir);
-  list.forEach((file) => {
-    file = join2(dir, file);
-    const stat = fs.statSync(file);
-    if (stat && stat.isDirectory())
-      results = results.concat(getFiles(file, exclude));
-    else if (!contains(file, exclude))
-      results.push(file);
-  });
-  return results;
-}
-function put(path3, contents) {
-  const dirPath = dirname(path3);
-  if (!fs.existsSync(dirPath))
-    fs.mkdirSync(dirPath, { recursive: true });
-  fs.writeFileSync(path3, contents, "utf-8");
-}
-async function get(path3) {
-  return Bun.file(path3).text();
-}
-var files = {
-  readJsonFile,
-  readPackageJson,
-  readTextFile,
-  writeJsonFile,
-  writeTextFile,
-  isFile,
-  hasFiles,
-  hasComponents,
-  hasFunctions,
-  deleteFiles,
-  getFiles,
-  put,
-  get
-};
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/folders.ts
-import {join as join3} from "@stacksjs/path";
-function isFolder2(path4) {
-  try {
-    return fs.statSync(path4).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function isDirectory(path4) {
-  return isFolder2(path4);
-}
-function isDir(path4) {
-  return isFolder2(path4);
-}
-function doesFolderExist(path4) {
-  return fs.existsSync(path4);
-}
-function createFolder2(dir) {
-  return new Promise((resolve, reject) => {
-    fs.mkdirs(dir, (err2) => {
-      if (err2)
-        reject(err2);
-      else
-        resolve();
-    });
-  });
-}
-function getFolders(dir) {
-  return fs.readdirSync(dir).filter((file) => {
-    return fs.statSync(join3(dir, file)).isDirectory();
-  });
-}
-var folders = {
-  isFolder: isFolder2,
-  doesFolderExist,
-  createFolder: createFolder2,
-  getFolders
-};
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/hash.ts
-import {path as p3} from "@stacksjs/path";
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/helpers.ts
-import {fileURLToPath} from "url";
-import {dirname as dirname2} from "@stacksjs/path";
-function updateConfigFile(filePath, newConfig) {
-  return new Promise((resolve, reject) => {
-    const config5 = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    for (const key in newConfig)
-      config5[key] = newConfig[key];
-    try {
-      fs.writeFileSync(filePath, JSON.stringify(config5, null, 2));
-      resolve();
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-var __dirname = "/home/runner/work/stacks/stacks/storage/framework/core/storage/src";
-var _dirname = typeof __dirname !== "undefined" ? __dirname : dirname2(fileURLToPath(import.meta.url));
-var helpers3 = {
-  _dirname,
-  updateConfigFile
-};
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/copy.ts
-import {join as join4} from "@stacksjs/path";
-function copy(src, dest, exclude = []) {
-  if (Array.isArray(src)) {
-    src.forEach((file) => {
-      copy(file, dest, exclude);
-    });
-  } else {
-    if (fs.statSync(src).isDirectory())
-      copyFolder(src, dest, exclude);
-    else
-      copyFile(src, dest);
-  }
-}
-function copyFile(src, dest) {
-  fs.copyFileSync(src, dest);
-}
-function copyFolder(src, dest, exclude = []) {
-  if (!fs.existsSync(dest))
-    fs.mkdirSync(dest, { recursive: true });
-  if (fs.existsSync(src)) {
-    fs.readdirSync(src).forEach((file) => {
-      if (!contains(join4(src, file), exclude)) {
-        const srcPath = join4(src, file);
-        const destPath = join4(dest, file);
-        if (fs.statSync(srcPath).isDirectory())
-          copyFolder(srcPath, destPath, exclude);
-        else
-          fs.copyFileSync(srcPath, destPath);
-      }
-    });
-  }
-}
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/glob.ts
-import {default as default2} from "fast-glob";
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/delete.ts
-import {err as err2, ok as ok2} from "@stacksjs/error-handling";
-import {italic, log as log2} from "@stacksjs/cli";
-function deleteFolder(path7) {
-  return new Promise((resolve, reject) => {
-    try {
-      if (isFolder2(path7)) {
-        fs.rmSync(path7, { recursive: true, force: true });
-        return resolve(ok2(`Deleted ${path7}`));
-      }
-      return resolve(ok2(`Path ${path7} was not a directory`));
-    } catch (error) {
-      return reject(err2(error));
-    }
-  });
-}
-async function isDirectoryEmpty(path7) {
-  return new Promise((resolve, reject) => {
-    try {
-      if (fs.statSync(path7).isDirectory()) {
-        if (fs.readdirSync(path7).length === 0)
-          return resolve(ok2(true));
-        else
-          return resolve(ok2(false));
-      }
-      return resolve(ok2(false));
-    } catch (error) {
-      return reject(err2(error));
-    }
-  });
-}
-async function deleteEmptyFolder(path7) {
-  return new Promise((resolve, reject) => {
-    try {
-      if (fs.statSync(path7).isDirectory()) {
-        if (fs.readdirSync(path7).length === 0) {
-          fs.rmSync(path7, { recursive: true, force: true });
-          return resolve(ok2(`Deleted ${path7}`));
-        } else {
-          return resolve(ok2(`Path ${path7} was not empty`));
-        }
-      }
-      return resolve(ok2(`Path ${path7} was not a directory`));
-    } catch (error) {
-      return reject(err2(error));
-    }
-  });
-}
-async function deleteEmptyFolders(dir) {
-  try {
-    if (!fs.existsSync(dir))
-      return ok2(`Path ${dir} does not exist`);
-    const files3 = fs.readdirSync(dir);
-    for (const file of files3) {
-      const p4 = join(dir, file);
-      if (isFolder2(p4)) {
-        if (fs.readdirSync(p4).length === 0)
-          fs.rmSync(p4, { recursive: true, force: true });
-        else
-          await deleteEmptyFolders(p4);
-      }
-    }
-    return ok2(`Deleted empty folders located in ${dir}`);
-  } catch (error) {
-    return err2(error);
-  }
-}
-function deleteFile(path7) {
-  return new Promise((resolve, reject) => {
-    try {
-      if (isFile(path7)) {
-        fs.rmSync(path7, { recursive: true, force: true });
-        return resolve(ok2(`Deleted ${path7}`));
-      }
-      return resolve(ok2(`Path ${path7} was not a file`));
-    } catch (error) {
-      return reject(err2(error));
-    }
-  });
-}
-async function deleteGlob(path7) {
-  if (!path7.includes("*"))
-    return err2(handleError(`Path ${path7} does not contain a glob`));
-  const directories = await default2([path7], { onlyDirectories: true });
-  for (const directory of directories) {
-    const result = await deleteFolder(directory);
-    if (result.isErr()) {
-      log2.error(result.error);
-      return result;
-    }
-    log2.info(`Deleted ${italic(directory)}`);
-  }
-  return ok2(`Deleted ${directories.length} directories`);
-}
-async function del(path7) {
-  if (isFile(path7))
-    return await deleteFile(path7);
-  if (isFolder2(path7))
-    return await deleteFolder(path7);
-  if (path7.includes("*"))
-    return await deleteGlob(path7);
-  return err2(handleError(`Path ${path7} cannot be deleted due to an unhandled condition. Please report this issue.`));
-}
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/zip.ts
-import {runCommand} from "@stacksjs/cli";
-async function zip(from, to, options) {
-  const toPath = to || "archive.zip";
-  const fromPath = Array.isArray(from) ? from.join(" ") : from;
-  if (Array.isArray(from))
-    return runCommand(`zip -r ${toPath} ${fromPath}`, options);
-  return runCommand(`zip -r ${to} ${from}`, options);
-}
-async function unzip(paths) {
-  if (Array.isArray(paths))
-    return runCommand(`unzip ${paths.join(" ")}`);
-  return runCommand(`unzip ${paths}`);
-}
-function archive(paths) {
-  return zip(paths);
-}
-function unarchive(paths) {
-  return unzip(paths);
-}
-function compress(paths) {
-  return zip(paths);
-}
-function decompress(paths) {
-  return unzip(paths);
-}
-function gzipSync(data, options) {
-  return Bun.gzipSync(data, options);
-}
-function gunzipSync(data) {
-  return Bun.gunzipSync(data);
-}
-function deflateSync(data, options) {
-  return Bun.deflateSync(data, options);
-}
-function inflateSync(data) {
-  return Bun.inflateSync(data);
-}
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/storage.ts
-var exports_storage = {};
-__export(exports_storage, {
-  zip: () => {
-    {
-      return zip;
-    }
-  },
-  writeTextFile: () => {
-    {
-      return writeTextFile;
-    }
-  },
-  writeJsonFile: () => {
-    {
-      return writeJsonFile;
-    }
-  },
-  writeFileSync: () => {
-    {
-      return writeFileSync;
-    }
-  },
-  writeFile: () => {
-    {
-      return writeFile;
-    }
-  },
-  updateConfigFile: () => {
-    {
-      return updateConfigFile;
-    }
-  },
-  unzip: () => {
-    {
-      return unzip;
-    }
-  },
-  unarchive: () => {
-    {
-      return unarchive;
-    }
-  },
-  setVisibility: () => {
-    {
-      return setVisibility;
-    }
-  },
-  rename: () => {
-    {
-      return rename;
-    }
-  },
-  readTextFile: () => {
-    {
-      return readTextFile;
-    }
-  },
-  readPackageJson: () => {
-    {
-      return readPackageJson;
-    }
-  },
-  readJsonFile: () => {
-    {
-      return readJsonFile;
-    }
-  },
-  put: () => {
-    {
-      return put;
-    }
-  },
-  move: () => {
-    {
-      return move2;
-    }
-  },
-  mkdirSync: () => {
-    {
-      return mkdirSync;
-    }
-  },
-  isFolder: () => {
-    {
-      return isFolder2;
-    }
-  },
-  isFile: () => {
-    {
-      return isFile;
-    }
-  },
-  isDirectoryEmpty: () => {
-    {
-      return isDirectoryEmpty;
-    }
-  },
-  isDirectory: () => {
-    {
-      return isDirectory;
-    }
-  },
-  isDir: () => {
-    {
-      return isDir;
-    }
-  },
-  inflateSync: () => {
-    {
-      return inflateSync;
-    }
-  },
-  helpers: () => {
-    {
-      return helpers3;
-    }
-  },
-  hasFunctions: () => {
-    {
-      return hasFunctions;
-    }
-  },
-  hasFiles: () => {
-    {
-      return hasFiles;
-    }
-  },
-  hasComponents: () => {
-    {
-      return hasComponents;
-    }
-  },
-  gzipSync: () => {
-    {
-      return gzipSync;
-    }
-  },
-  gunzipSync: () => {
-    {
-      return gunzipSync;
-    }
-  },
-  getFolders: () => {
-    {
-      return getFolders;
-    }
-  },
-  getFiles: () => {
-    {
-      return getFiles;
-    }
-  },
-  get: () => {
-    {
-      return get;
-    }
-  },
-  fs: () => {
-    {
-      return fs;
-    }
-  },
-  folders: () => {
-    {
-      return folders;
-    }
-  },
-  files: () => {
-    {
-      return files;
-    }
-  },
-  existsSync: () => {
-    {
-      return existsSync;
-    }
-  },
-  exists: () => {
-    {
-      return exists;
-    }
-  },
-  doesNotExist: () => {
-    {
-      return doesNotExist;
-    }
-  },
-  doesFolderExist: () => {
-    {
-      return doesFolderExist;
-    }
-  },
-  doesExist: () => {
-    {
-      return doesExist;
-    }
-  },
-  deleteGlob: () => {
-    {
-      return deleteGlob;
-    }
-  },
-  deleteFolder: () => {
-    {
-      return deleteFolder;
-    }
-  },
-  deleteFiles: () => {
-    {
-      return deleteFiles;
-    }
-  },
-  deleteFile: () => {
-    {
-      return deleteFile;
-    }
-  },
-  deleteEmptyFolders: () => {
-    {
-      return deleteEmptyFolders;
-    }
-  },
-  deleteEmptyFolder: () => {
-    {
-      return deleteEmptyFolder;
-    }
-  },
-  del: () => {
-    {
-      return del;
-    }
-  },
-  deflateSync: () => {
-    {
-      return deflateSync;
-    }
-  },
-  decompress: () => {
-    {
-      return decompress;
-    }
-  },
-  createFolder: () => {
-    {
-      return createFolder2;
-    }
-  },
-  copyFolder: () => {
-    {
-      return copyFolder;
-    }
-  },
-  copyFile: () => {
-    {
-      return copyFile;
-    }
-  },
-  copy: () => {
-    {
-      return copy;
-    }
-  },
-  compress: () => {
-    {
-      return compress;
-    }
-  },
-  archive: () => {
-    {
-      return archive;
-    }
-  },
-  _dirname: () => {
-    {
-      return _dirname;
-    }
-  }
-});
-
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/move.ts
-import {err as err3, ok as ok3} from "@stacksjs/error-handling";
-import {log as log3} from "@stacksjs/logging";
-import {path as path8} from "@stacksjs/path";
-async function move2(src, dest, options) {
-  try {
-    if (Array.isArray(src)) {
-      const operations = src.map(async (file) => {
-        const from2 = file;
-        const to2 = path8.resolve(dest, path8.basename(file));
-        const result2 = await rename(from2, to2, options);
-        if (result2.isErr()) {
-          log3.error(result2.error);
-          return err3(handleError(result2.error.message, result2.error));
-        }
-      });
-      await Promise.all(operations);
-      return ok3({ message: "Files moved successfully" });
-    }
-    const from = src;
-    const to = dest;
-    const result = await rename(from, to, options);
-    if (result.isErr()) {
-      log3.error(result.error);
-      return err3(handleError(result.error));
-    }
-    return ok3({ message: "File moved successfully" });
-  } catch (error) {
-    return err3(handleError(error));
-  }
-}
-async function rename(from, to, options) {
-  return new Promise((resolve, reject) => {
-    try {
-      const dir = path8.dirname(to);
-      if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-      if (!fs.existsSync(from))
-        return reject(err3(new Error(`File or directory does not exist: ${from}`)));
-      if (fs.existsSync(to)) {
-        if (!options?.overwrite)
-          return reject(err3(new Error(`File or directory already exists: ${to}`)));
-        fs.unlinkSync(to);
-      }
-      fs.renameSync(from, to);
-      return resolve(ok3({ message: "File moved successfully" }));
-    } catch (error) {
-      if (error.code === "ENOENT")
-        log3.error("File or directory does not exist\n\n", error);
-      else
-        log3.error(error);
-      return reject(err3(new Error(error)));
-    }
-  });
-}
-// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/visibility.ts
-function setVisibility() {
-  return "wip";
-}
-// src/cloud/cdn.ts
-import {path as p4} from "@stacksjs/path";
+import {hasFiles} from "@stacksjs/storage";
+import {path as p2} from "@stacksjs/path";
 import {env as env2} from "@stacksjs/env";
+import * as kinesis from "aws-cdk-lib/aws-kinesis";
 
 class CdnStack {
   distribution;
@@ -1218,6 +489,7 @@ class CdnStack {
   cdnCachePolicy;
   apiCachePolicy;
   vanityUrl;
+  realtimeLogConfig;
   props;
   constructor(scope, props) {
     this.props = props;
@@ -1230,6 +502,28 @@ class CdnStack {
       maxTtl: config6.cloud.cdn?.maxTtl ? Duration2.seconds(config6.cloud.cdn.maxTtl) : undefined,
       cookieBehavior: this.getCookieBehavior(config6.cloud.cdn?.cookieBehavior)
     });
+    const logStream = new kinesis.Stream(scope, "StacksCdnRealtimeLogStream", {
+      streamName: "StacksCdnRealtimeLogStream",
+      retentionPeriod: Duration2.days(1),
+      shardCount: 1,
+      encryption: kinesis.StreamEncryption.UNENCRYPTED
+    });
+    this.realtimeLogConfig = new cloudfront.RealtimeLogConfig(scope, "StacksRealTimeLogConfig", {
+      endPoints: [
+        cloudfront.Endpoint.fromKinesisStream(logStream)
+      ],
+      fields: [
+        "timestamp",
+        "c-ip",
+        "cs-method",
+        "cs-uri-stem",
+        "cs-uri-query",
+        "cs-referer",
+        "cs-user-agent",
+        "sc-status"
+      ],
+      samplingRate: 100
+    });
     this.distribution = new cloudfront.Distribution(scope, "Cdn", {
       domainNames: [props.domain],
       defaultRootObject: "index.html",
@@ -1257,7 +551,8 @@ class CdnStack {
         allowedMethods: this.allowedMethods(),
         cachedMethods: this.cachedMethods(),
         viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-        cachePolicy: this.cdnCachePolicy
+        cachePolicy: this.cdnCachePolicy,
+        realtimeLogConfig: this.realtimeLogConfig
       },
       additionalBehaviors: this.additionalBehaviors(scope, props),
       errorResponses: [
@@ -1351,10 +646,10 @@ class CdnStack {
     return config6.cloud.api?.deploy;
   }
   apiBehaviorOptions(scope, props) {
-    const hostname = Fn.select(2, Fn.split("/", props.webServerUrl.url));
-    const origin = (path10 = "/api") => {
+    const hostname = `api.${props.domain}`;
+    const origin = () => {
       return new origins.HttpOrigin(hostname, {
-        originPath: path10,
+        originPath: "/",
         protocolPolicy: cloudfront.OriginProtocolPolicy.HTTPS_ONLY
       });
     };
@@ -1365,15 +660,17 @@ class CdnStack {
         allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
         cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,
         cachePolicy: this.setApiCachePolicy(scope),
-        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS
+        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+        realtimeLogConfig: this.realtimeLogConfig
       },
       "/api/*": {
-        origin: origin("/api/*"),
+        origin: origin(),
         compress: true,
         allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
         cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,
         cachePolicy: this.apiCachePolicy,
-        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS
+        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+        realtimeLogConfig: this.realtimeLogConfig
       }
     };
   }
@@ -1388,7 +685,8 @@ class CdnStack {
         allowedMethods: this.allowedMethodsFromString(config6.cloud.cdn?.allowedMethods),
         cachedMethods: this.cachedMethodsFromString(config6.cloud.cdn?.cachedMethods),
         viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-        cachePolicy: cloudfront.CachePolicy.CACHING_OPTIMIZED
+        cachePolicy: cloudfront.CachePolicy.CACHING_OPTIMIZED,
+        realtimeLogConfig: this.realtimeLogConfig
       },
       "/docs/*": {
         origin: new origins.S3Origin(props.publicBucket, {
@@ -1399,7 +697,8 @@ class CdnStack {
         allowedMethods: this.allowedMethodsFromString(config6.cloud.cdn?.allowedMethods),
         cachedMethods: this.cachedMethodsFromString(config6.cloud.cdn?.cachedMethods),
         viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-        cachePolicy: cloudfront.CachePolicy.CACHING_OPTIMIZED
+        cachePolicy: cloudfront.CachePolicy.CACHING_OPTIMIZED,
+        realtimeLogConfig: this.realtimeLogConfig
       }
     };
   }
@@ -1423,7 +722,8 @@ class CdnStack {
         compress: false,
         allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
         viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-        cachePolicy: aiCachePolicy
+        cachePolicy: aiCachePolicy,
+        realtimeLogConfig: this.realtimeLogConfig
       },
       "/ai/summary": {
         origin: new origins.HttpOrigin(summaryHostname, {
@@ -1433,7 +733,8 @@ class CdnStack {
         compress: false,
         allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
         viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-        cachePolicy: aiCachePolicy
+        cachePolicy: aiCachePolicy,
+        realtimeLogConfig: this.realtimeLogConfig
       }
     };
   }
@@ -1455,7 +756,8 @@ class CdnStack {
           cookieBehavior: cloudfront.CacheCookieBehavior.none(),
           headerBehavior: cloudfront.CacheHeaderBehavior.none(),
           queryStringBehavior: cloudfront.CacheQueryStringBehavior.none()
-        })
+        }),
+        realtimeLogConfig: this.realtimeLogConfig
       }
     };
   }
@@ -1466,13 +768,14 @@ class CdnStack {
     return config6.cloud.cli;
   }
   shouldDeployDocs() {
-    return hasFiles(p4.projectPath("docs"));
+    return hasFiles(p2.projectPath("docs"));
   }
   additionalBehaviors(scope, props) {
     let behaviorOptions = {};
     if (this.shouldDeployApi()) {
       const keysToRemove = ["_HANDLER", "_X_AMZN_TRACE_ID", "AWS_REGION", "AWS_EXECUTION_ENV", "AWS_LAMBDA_FUNCTION_NAME", "AWS_LAMBDA_FUNCTION_MEMORY_SIZE", "AWS_LAMBDA_FUNCTION_VERSION", "AWS_LAMBDA_INITIALIZATION_TYPE", "AWS_LAMBDA_LOG_GROUP_NAME", "AWS_LAMBDA_LOG_STREAM_NAME", "AWS_ACCESS_KEY", "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN", "AWS_LAMBDA_RUNTIME_API", "LAMBDA_TASK_ROOT", "LAMBDA_RUNTIME_DIR", "_"];
       keysToRemove.forEach((key) => delete env2[key]);
+      behaviorOptions = this.apiBehaviorOptions(scope, props);
     }
     if (this.shouldDeployDocs() && !config6.app.docMode) {
       behaviorOptions = {
@@ -1563,13 +866,19 @@ class DnsStack {
       zone: this.zone,
       target: route532.RecordTarget.fromAlias(new targets2.BucketWebsiteTarget(wwwBucket))
     });
+    new route532.ARecord(scope, "StoreAliasRecord", {
+      recordName: `store.${props.domain}`,
+      zone: this.zone,
+      target: route532.RecordTarget.fromIpAddresses("137.66.37.136")
+    });
   }
 }
 
 // src/cloud/docs.ts
 import {AssetHashType, CfnOutput as Output4, RemovalPolicy as RemovalPolicy2, aws_lambda as lambda3} from "aws-cdk-lib";
 import {config as config8} from "@stacksjs/config";
-import {path as p5} from "@stacksjs/path";
+import {path as p3} from "@stacksjs/path";
+import {storage as storage3} from "@stacksjs/storage";
 import {originRequestFunctionHash} from "@stacksjs/utils";
 
 class DocsStack {
@@ -1581,14 +890,14 @@ class DocsStack {
       description: "The Stacks Origin Request function that prettifies URLs",
       runtime: lambda3.Runtime.NODEJS_18_X,
       handler: "dist/origin-request.handler",
-      code: lambda3.Code.fromAsset(p5.corePath("cloud/dist.zip"), {
+      code: lambda3.Code.fromAsset(p3.corePath("cloud/dist.zip"), {
         assetHash: originRequestFunctionHash,
         assetHashType: AssetHashType.CUSTOM
       })
     });
     const cfnOriginRequestFunction = this.originRequestFunction.node.defaultChild;
     cfnOriginRequestFunction.applyRemovalPolicy(RemovalPolicy2.RETAIN);
-    if (!config8.app.docMode && exports_storage.hasFiles(p5.projectPath("docs"))) {
+    if (!config8.app.docMode && storage3.hasFiles(p3.projectPath("docs"))) {
       new Output4(scope, "DocsUrl", {
         value: `https://${props.domain}/${docsPrefix}`,
         description: "The URL of the deployed documentation"
@@ -1749,7 +1058,7 @@ class SecurityStack {
       },
       rules: this.getFirewallRules()
     };
-    this.firewall = new wafv2.CfnWebACL(scope, "WebFirewall", options);
+    this.firewall = new wafv2.CfnWebACL(scope, "StacksWebFirewall", options);
     Tags2.of(this.firewall).add("Name", "waf-cloudfront", { priority: 300 });
     Tags2.of(this.firewall).add("Purpose", "CloudFront", { priority: 300 });
     Tags2.of(this.firewall).add("CreatedBy", "CloudFormation", { priority: 300 });
@@ -2317,26 +1626,26 @@ class PermissionsStack {
 }
 
 // src/cloud/compute.ts
-import {Duration as Duration6, CfnOutput as Output6, RemovalPolicy as RemovalPolicy8, aws_ec2 as ec23, aws_ecs as ecs, aws_secretsmanager as secretsmanager} from "aws-cdk-lib";
-import {path as p6} from "@stacksjs/path";
+import {Duration as Duration6, CfnOutput as Output6, RemovalPolicy as RemovalPolicy8, aws_ec2 as ec23, aws_ecs as ecs, aws_route53 as route535, aws_route53_targets as route53Targets, aws_secretsmanager as secretsmanager} from "aws-cdk-lib";
+import {path as p4} from "@stacksjs/path";
 import {env as env6} from "@stacksjs/env";
 import {LogGroup} from "aws-cdk-lib/aws-logs";
 import * as elbv2 from "aws-cdk-lib/aws-elasticloadbalancingv2";
 
 class ComputeStack {
   lb;
-  apiServer;
-  apiServerUrl;
+  cluster;
+  taskDefinition;
   constructor(scope, props) {
     const vpc = props.vpc;
     const fileSystem = props.fileSystem;
     if (!fileSystem)
       throw new Error("The file system is missing. Please make sure it was created properly.");
-    const cluster = new ecs.Cluster(scope, "StacksCluster", {
+    this.cluster = new ecs.Cluster(scope, "StacksCluster", {
       clusterName: `${props.slug}-${props.appEnv}-web-server-cluster`,
       vpc
     });
-    const taskDefinition = new ecs.FargateTaskDefinition(scope, "TaskDefinition", {
+    this.taskDefinition = new ecs.FargateTaskDefinition(scope, "TaskDefinition", {
       family: `${props.appName}-${props.appEnv}-api`,
       memoryLimitMiB: 512,
       cpu: 256,
@@ -2344,18 +1653,18 @@ class ComputeStack {
         cpuArchitecture: ecs.CpuArchitecture.ARM64
       }
     });
-    const container = taskDefinition.addContainer("WebServerContainer", {
+    const container = this.taskDefinition.addContainer("WebServerContainer", {
       containerName: `${props.appName}-${props.appEnv}-api`,
-      image: ecs.ContainerImage.fromAsset(p6.frameworkPath("server")),
+      image: ecs.ContainerImage.fromAsset(p4.frameworkPath("server")),
       logging: new ecs.AwsLogDriver({
-        streamPrefix: `${props.appName}-${props.appEnv}-web`,
+        streamPrefix: `${props.appName}-${props.appEnv}-web-server-logs`,
         logGroup: new LogGroup(scope, "StacksApiLogs", {
-          logGroupName: "/ecs/stacks-api",
+          logGroupName: "/aws/ecs/stacks-api",
           removalPolicy: RemovalPolicy8.DESTROY
         })
       }),
       healthCheck: {
-        command: ["CMD-SHELL", "curl -f http://localhost:3000/health || exit 1"],
+        command: ["CMD-SHELL", "curl -f http://localhost:3000/api/health || exit 1"],
         interval: Duration6.seconds(10),
         timeout: Duration6.seconds(5),
         retries: 3,
@@ -2377,8 +1686,8 @@ class ComputeStack {
       description: "Access to the public facing load balancer"
     });
     serviceSecurityGroup.addIngressRule(publicLoadBalancerSG, ec23.Port.allTraffic(), "Ingress from the public ALB");
-    serviceSecurityGroup.addIngressRule(publicLoadBalancerSG, ec23.Port.allTraffic(), "Ingress from the public ALB");
     this.lb = new elbv2.ApplicationLoadBalancer(scope, "ApplicationLoadBalancer", {
+      http2Enabled: true,
       loadBalancerName: `${props.appName}-${props.appEnv}-alb`,
       vpc,
       vpcSubnets: {
@@ -2391,14 +1700,20 @@ class ComputeStack {
       idleTimeout: Duration6.seconds(30),
       securityGroup: publicLoadBalancerSG
     });
+    new route535.ARecord(scope, "ApiDomainAliasRecord", {
+      zone: props.zone,
+      recordName: "api",
+      target: route535.RecordTarget.fromAlias(new route53Targets.LoadBalancerTarget(this.lb))
+    });
     const serviceTargetGroup = new elbv2.ApplicationTargetGroup(scope, "ServiceTargetGroup", {
+      targetGroupName: `${props.appName}-${props.appEnv}-api-tg`,
       vpc,
       targetType: elbv2.TargetType.IP,
       protocol: elbv2.ApplicationProtocol.HTTP,
       port: 3000,
       healthCheck: {
         interval: Duration6.seconds(6),
-        path: "/",
+        path: "/api/health",
         protocol: elbv2.Protocol.HTTP,
         timeout: Duration6.seconds(5),
         healthyThresholdCount: 2,
@@ -2407,9 +1722,9 @@ class ComputeStack {
     });
     const service = new ecs.FargateService(scope, "StacksApiService", {
       serviceName: `${props.appName}-${props.appEnv}-api-service`,
-      cluster,
-      taskDefinition,
-      desiredCount: 2,
+      cluster: this.cluster,
+      taskDefinition: this.taskDefinition,
+      desiredCount: 1,
       assignPublicIp: true,
       maxHealthyPercent: 200,
       vpcSubnets: vpc.selectSubnets({
@@ -2421,13 +1736,18 @@ class ComputeStack {
     });
     service.attachToApplicationTargetGroup(serviceTargetGroup);
     publicLoadBalancerSG.addIngressRule(ec23.Peer.anyIpv4(), ec23.Port.allTraffic());
+    this.lb.addListener("HttpsListener", {
+      port: 443,
+      certificates: [props.certificate],
+      defaultAction: elbv2.ListenerAction.forward([serviceTargetGroup])
+    });
     this.lb.addListener("HttpListener", {
       port: 80,
       defaultAction: elbv2.ListenerAction.forward([serviceTargetGroup])
     });
     props.fileSystem.connections.allowFromAnyIpv4(ec23.Port.tcp(2049));
     const volumeName = `${props.slug}-${props.appEnv}-efs`;
-    taskDefinition.addVolume({
+    this.taskDefinition.addVolume({
       name: volumeName,
       efsVolumeConfiguration: {
         fileSystemId: props.fileSystem.fileSystemId
@@ -2473,6 +1793,43 @@ class ComputeStack {
   }
 }
 
+// src/cloud/queue.ts
+import {aws_ec2 as ec24} from "aws-cdk-lib";
+import {Rule, Schedule} from "aws-cdk-lib/aws-events";
+import {EcsTask} from "aws-cdk-lib/aws-events-targets";
+
+class QueueStack {
+  constructor(scope, props) {
+    const rule = new Rule(scope, "Rule", {
+      ruleName: `${props.appName}-${props.appEnv}-queue`,
+      schedule: Schedule.cron({ minute: "*", hour: "*", month: "*", weekDay: "*", year: "*" })
+    });
+    rule.addTarget(new EcsTask({
+      cluster: props.cluster,
+      taskDefinition: props.taskDefinition,
+      containerOverrides: [
+        {
+          containerName: `${props.appName}-${props.appEnv}-api`,
+          environment: [
+            {
+              name: "QUEUE_WORKER",
+              value: "true"
+            },
+            {
+              name: "JOB",
+              value: "DummyJob.ts"
+            }
+          ]
+        }
+      ],
+      retryAttempts: 3,
+      subnetSelection: {
+        subnetType: ec24.SubnetType.PUBLIC
+      }
+    }));
+  }
+}
+
 // src/cloud/index.ts
 class Cloud extends Stack2 {
   constructor(scope, id, props) {
@@ -2482,7 +1839,7 @@ class Cloud extends Stack2 {
       ...props,
       zone: dns2.zone
     });
-    const storage4 = new StorageStack(this, {
+    const storage5 = new StorageStack(this, {
       ...props,
       kmsKey: security2.kmsKey
     });
@@ -2512,27 +1869,31 @@ class Cloud extends Stack2 {
         zone: dns2.zone,
         certificate: security2.certificate
       });
+      new QueueStack(this, {
+        ...props,
+        cluster: api.cluster,
+        taskDefinition: api.taskDefinition
+      });
     }
     const ai2 = new AiStack(this, props);
-    const cli4 = new CliStack(this, props);
+    const cli2 = new CliStack(this, props);
     const cdn2 = new CdnStack(this, {
       ...props,
-      publicBucket: storage4.publicBucket,
-      logBucket: storage4.logBucket,
+      publicBucket: storage5.publicBucket,
+      logBucket: storage5.logBucket,
       certificate: security2.certificate,
       firewall: security2.firewall,
       originRequestFunction: docs2.originRequestFunction,
       zone: dns2.zone,
-      cliSetupUrl: cli4.cliSetupUrl,
+      cliSetupUrl: cli2.cliSetupUrl,
       askAiUrl: ai2.askAiUrl,
       summarizeAiUrl: ai2.summarizeAiUrl,
-      webServer: api?.apiServer,
-      webServerUrl: api?.apiServerUrl
+      lb: api?.lb
     });
     new DeploymentStack(this, {
       ...props,
-      publicBucket: storage4.publicBucket,
-      privateBucket: storage4.privateBucket,
+      publicBucket: storage5.publicBucket,
+      privateBucket: storage5.privateBucket,
       cdn: cdn2.distribution
     });
   }
@@ -2577,7 +1938,7 @@ var request = new Request;
 import {extname} from "path";
 import {URL} from "url";
 async function serverResponse(req) {
-  console.log("serverResponse", req);
+  console.log("serverResponse", JSON.stringify(req));
   const routesList = await route.getRoutes();
   const url = new URL(req.url);
   const foundRoute = routesList.find((route2) => {
@@ -2585,7 +1946,7 @@ async function serverResponse(req) {
     return pattern.test(url.pathname);
   });
   if (!foundRoute)
-    return new Response("Not found", { status: 404 });
+    return new Response("Pretty 404 page coming soon", { status: 404 });
   addRouteParamsAndQuery(url, foundRoute);
   executeMiddleware(foundRoute);
   return execute(foundRoute, req, { statusCode: foundRoute?.statusCode });
@@ -2688,32 +2049,32 @@ class Router {
       paramNames: []
     });
   }
-  get(path14, callback) {
-    this.addRoute("GET", path14, callback, 200);
+  get(path7, callback) {
+    this.addRoute("GET", path7, callback, 200);
     return this;
   }
-  post(path14, callback) {
-    this.addRoute("POST", path14, callback, 201);
+  post(path7, callback) {
+    this.addRoute("POST", path7, callback, 201);
     return this;
   }
-  view(path14, callback) {
-    this.addRoute("GET", path14, callback, 200);
+  view(path7, callback) {
+    this.addRoute("GET", path7, callback, 200);
     return this;
   }
-  redirect(path14, callback, _status) {
-    this.addRoute("GET", path14, callback, 302);
+  redirect(path7, callback, _status) {
+    this.addRoute("GET", path7, callback, 302);
     return this;
   }
-  delete(path14, callback) {
-    this.addRoute("DELETE", path14, callback, 204);
+  delete(path7, callback) {
+    this.addRoute("DELETE", path7, callback, 204);
     return this;
   }
-  patch(path14, callback) {
-    this.addRoute("PATCH", path14, callback, 202);
+  patch(path7, callback) {
+    this.addRoute("PATCH", path7, callback, 202);
     return this;
   }
-  put(path14, callback) {
-    this.addRoute("PUT", path14, callback, 202);
+  put(path7, callback) {
+    this.addRoute("PUT", path7, callback, 202);
     return this;
   }
   group(options, callback) {