@stacksjs/actions 0.70.87 → 0.70.90

package/dist/setup/ssl.js

@@ -1,2 +1,271 @@
-// @bun
-import{Fa as a,Ga as b,Ha as c,Ia as d,Ja as e,Ka as f,La as g,Ma as h}from"../chunk-n5eqwhck.js";import"../chunk-h3d81wrg.js";export{e as trustCertificate,c as sslCertificatesExist,g as setupSSL,h as isSSLSetupComplete,a as isDomainInHosts,d as isCertificateTrusted,f as generateCertificates,b as addDomainToHosts};
+import { execSync, spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { log } from "@stacksjs/cli";
+const HOSTS_FILE = process.platform === "win32" ? path.join(process.env.windir || "C:\\Windows", "System32", "drivers", "etc", "hosts") : "/etc/hosts", SSL_DIR = path.join(os.homedir(), ".stacks", "ssl");
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === !0 && process.stdout.isTTY === !0;
+}
+function getSudoPassword() {
+  return process.env.SUDO_PASSWORD;
+}
+function canRunSudo() {
+  return isInteractiveTerminal() || !!getSudoPassword();
+}
+export function isDomainInHosts(domain) {
+  try {
+    const hostsContent = fs.readFileSync(HOSTS_FILE, "utf-8");
+    return hostsContent.includes(`127.0.0.1 ${domain}`) || hostsContent.includes(`::1 ${domain}`);
+  } catch {
+    if (process.platform !== "win32") {
+      const sudoPassword = getSudoPassword();
+      if (sudoPassword)
+        try {
+          const result = execSync(`echo '${sudoPassword}' | sudo -S cat "${HOSTS_FILE}" 2>/dev/null`, { encoding: "utf-8" });
+          return result.includes(`127.0.0.1 ${domain}`) || result.includes(`::1 ${domain}`);
+        } catch {
+          return !1;
+        }
+    }
+    return !1;
+  }
+}
+export async function addDomainToHosts(domain, verbose) {
+  if (isDomainInHosts(domain)) {
+    if (verbose)
+      log.info(`${domain} already in hosts file`);
+    return !0;
+  }
+  const hostsEntry = `
+# Added by Stacks
+127.0.0.1 ${domain}
+::1 ${domain}
+`;
+  if (process.platform === "win32") {
+    log.warn("Please add this to your hosts file manually:");
+    log.warn(`127.0.0.1 ${domain}`);
+    log.warn(`::1 ${domain}`);
+    log.warn(`File location: ${HOSTS_FILE}`);
+    return !1;
+  }
+  if (!canRunSudo()) {
+    if (verbose) {
+      log.warn(`Cannot add ${domain} to hosts file (non-interactive mode and no SUDO_PASSWORD set)`);
+      log.info("Run `buddy setup:ssl` in a terminal or set SUDO_PASSWORD environment variable");
+    }
+    return !1;
+  }
+  const sudoPassword = getSudoPassword();
+  return new Promise((resolve) => {
+    let child;
+    if (sudoPassword)
+      child = spawn("sh", ["-c", `echo '${sudoPassword}' | sudo -S sh -c "echo '${hostsEntry}' >> '${HOSTS_FILE}'"`], {
+        stdio: ["pipe", "inherit", "inherit"]
+      });
+    else
+      child = spawn("sudo", ["sh", "-c", `echo '${hostsEntry}' >> "${HOSTS_FILE}"`], {
+        stdio: "inherit"
+      });
+    child.on("close", (code) => {
+      if (code === 0) {
+        if (verbose)
+          log.success(`Added ${domain} to hosts file`);
+        resolve(!0);
+      } else {
+        if (verbose) {
+          log.error(`Failed to add ${domain} to hosts file`);
+          log.warn(`Manually add: 127.0.0.1 ${domain}`);
+        }
+        resolve(!1);
+      }
+    });
+    child.on("error", () => {
+      log.error("Failed to run sudo command");
+      resolve(!1);
+    });
+  });
+}
+export function sslCertificatesExist(domain) {
+  const certPath = path.join(SSL_DIR, `${domain}.crt`), keyPath = path.join(SSL_DIR, `${domain}.key`), caPath = path.join(SSL_DIR, `${domain}.ca.crt`);
+  return fs.existsSync(certPath) && fs.existsSync(keyPath) && fs.existsSync(caPath);
+}
+export function isCertificateTrusted(domain) {
+  if (process.platform !== "darwin")
+    return !0;
+  const certPath = path.join(SSL_DIR, `${domain}.crt`);
+  if (!fs.existsSync(certPath))
+    return !1;
+  try {
+    const fingerprint = execSync(`openssl x509 -noout -fingerprint -sha256 -in "${certPath}"`, { encoding: "utf-8" }), eqIdx = fingerprint.indexOf("="), fingerprintValue = eqIdx >= 0 ? fingerprint.slice(eqIdx + 1).trim() : "";
+    if (!fingerprintValue)
+      return !1;
+    return execSync("security find-certificate -a -Z -p | openssl x509 -noout -fingerprint -sha256 2>/dev/null || true", { encoding: "utf-8" }).includes(fingerprintValue);
+  } catch {
+    return !1;
+  }
+}
+export async function trustCertificate(domain, verbose) {
+  const caCertPath = path.join(SSL_DIR, `${domain}.ca.crt`), certPath = path.join(SSL_DIR, `${domain}.crt`);
+  if (!fs.existsSync(caCertPath)) {
+    log.error(`CA certificate not found: ${caCertPath}`);
+    return !1;
+  }
+  if (isCertificateTrusted(domain)) {
+    if (verbose)
+      log.info("Certificate is already trusted, skipping trust step");
+    return !0;
+  }
+  if (!canRunSudo()) {
+    if (verbose) {
+      log.warn("Cannot trust certificate (non-interactive mode and no SUDO_PASSWORD set)");
+      log.info("Run `buddy setup:ssl` in a terminal or set SUDO_PASSWORD environment variable");
+    }
+    return !1;
+  }
+  const sudoPassword = getSudoPassword();
+  if (process.platform === "darwin")
+    return new Promise((resolve) => {
+      const combinedCommand = `security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain '${caCertPath}' && security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain '${certPath}'`;
+      let child;
+      if (sudoPassword)
+        child = spawn("sh", ["-c", `echo '${sudoPassword}' | sudo -S sh -c "${combinedCommand}"`], {
+          stdio: ["pipe", "inherit", "inherit"]
+        });
+      else
+        child = spawn("sudo", ["sh", "-c", combinedCommand], {
+          stdio: "inherit"
+        });
+      child.on("close", (code) => {
+        if (code === 0) {
+          try {
+            execSync(`security add-trusted-cert -d -r trustRoot -k ~/Library/Keychains/login.keychain-db "${certPath}" 2>/dev/null || true`);
+          } catch {}
+          resolve(!0);
+        } else {
+          if (verbose) {
+            log.warn("Could not trust certificate automatically");
+            log.info(`  sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain "${caCertPath}"`);
+          }
+          resolve(!1);
+        }
+      });
+      child.on("error", () => {
+        log.error("Failed to run sudo command");
+        resolve(!1);
+      });
+    });
+  else if (process.platform === "linux")
+    return new Promise((resolve) => {
+      const linuxCommands = `mkdir -p /usr/local/share/ca-certificates/stacks && cp '${caCertPath}' /usr/local/share/ca-certificates/stacks/ && update-ca-certificates`;
+      let child;
+      if (sudoPassword)
+        child = spawn("sh", ["-c", `echo '${sudoPassword}' | sudo -S sh -c "${linuxCommands}"`], {
+          stdio: ["pipe", "inherit", "inherit"]
+        });
+      else
+        child = spawn("sudo", ["sh", "-c", linuxCommands], {
+          stdio: "inherit"
+        });
+      child.on("close", (code) => {
+        if (code === 0) {
+          log.success("Certificate trusted");
+          resolve(!0);
+        } else {
+          log.warn("Could not trust certificate automatically");
+          resolve(!1);
+        }
+      });
+      child.on("error", () => resolve(!1));
+    });
+  else if (process.platform === "win32") {
+    log.warn("Please manually trust the certificate in Windows:");
+    log.warn(`  1. Double-click: ${caCertPath}`);
+    log.warn('  2. Click "Install Certificate"');
+    log.warn('  3. Select "Local Machine" and place in "Trusted Root Certification Authorities"');
+    return !1;
+  }
+  return !1;
+}
+export async function generateCertificates(domain, verbose) {
+  try {
+    const tlsxModule = await import("@stacksjs/tlsx"), { generateCertificate, createRootCA } = tlsxModule, _httpsConfig = tlsxModule.httpsConfig;
+    if (!fs.existsSync(SSL_DIR))
+      fs.mkdirSync(SSL_DIR, { recursive: !0 });
+    const config = {
+      domain,
+      hostCertCN: domain,
+      basePath: SSL_DIR,
+      caCertPath: path.join(SSL_DIR, `${domain}.ca.crt`),
+      certPath: path.join(SSL_DIR, `${domain}.crt`),
+      keyPath: path.join(SSL_DIR, `${domain}.key`),
+      altNameIPs: ["127.0.0.1", "::1"],
+      altNameURIs: ["localhost", domain],
+      organizationName: "Stacks Development",
+      countryName: "US",
+      stateName: "California",
+      localityName: "Playa Vista",
+      commonName: domain,
+      validityDays: 825,
+      verbose: verbose || !1,
+      subjectAltNames: [
+        { type: 2, value: domain },
+        { type: 2, value: `*.${domain.split(".").slice(1).join(".")}` },
+        { type: 2, value: "localhost" },
+        { type: 2, value: "*.localhost" }
+      ]
+    };
+    if (verbose)
+      log.info("Generating Root CA certificate...");
+    const caCert = await createRootCA(config);
+    if (verbose)
+      log.info(`Generating host certificate for ${domain}...`);
+    const hostCert = await generateCertificate({
+      ...config,
+      rootCA: {
+        certificate: caCert.certificate,
+        privateKey: caCert.privateKey
+      }
+    });
+    fs.writeFileSync(config.caCertPath, caCert.certificate);
+    fs.writeFileSync(config.certPath, hostCert.certificate);
+    fs.writeFileSync(config.keyPath, hostCert.privateKey);
+    if (verbose)
+      log.success(`SSL certificates generated for ${domain}`);
+    return !0;
+  } catch (error) {
+    log.error(`Failed to generate certificates: ${error}`);
+    return !1;
+  }
+}
+export async function setupSSL(options = {}) {
+  const domain = options.domain || process.env.APP_URL?.replace(/^https?:\/\//, "") || "stacks.localhost";
+  if (domain === "localhost" || domain.startsWith("localhost:")) {
+    log.info("Skipping SSL setup for localhost");
+    return !0;
+  }
+  let success = !0;
+  if (!options.skipHosts) {
+    if (!await addDomainToHosts(domain, options.verbose) && options.verbose)
+      log.warn("Hosts file not updated - you may need to add the entry manually");
+  }
+  if (!sslCertificatesExist(domain)) {
+    if (options.verbose)
+      log.info("Generating SSL certificates...");
+    if (!await generateCertificates(domain, options.verbose)) {
+      log.error("Failed to generate SSL certificates");
+      return !1;
+    }
+  }
+  if (!options.skipTrust && !isCertificateTrusted(domain)) {
+    if (!await trustCertificate(domain, options.verbose)) {
+      log.warn("Certificate not trusted - you may see browser warnings");
+      success = !1;
+    }
+  }
+  return success;
+}
+export function isSSLSetupComplete(domain) {
+  return isDomainInHosts(domain) && sslCertificatesExist(domain);
+}

package/dist/stacks.js

@@ -1,2 +1,265 @@
-// @bun
-import"./chunk-h3d81wrg.js";import{log as H}from"@stacksjs/logging";import{dirname as T,join as Z,projectPath as A,relative as m,stacksBackupPath as u,stacksLockPath as b}from"@stacksjs/path";import{copyFile as K,createFolder as R,deleteFile as g,deleteEmptyFolders as d,doesFolderExist as P,fs as J}from"@stacksjs/storage";var F=["app","config","database","resources","routes","public","locales"];async function L(){let z=b();try{if(J.existsSync(z)){let q=await Bun.file(z).text();return JSON.parse(q)}}catch{}return{version:1,generatedAt:new Date().toISOString(),stacks:{}}}async function D(z){let q=b(),W=T(q);if(!J.existsSync(W))await R(W);z.generatedAt=new Date().toISOString(),await Bun.write(q,JSON.stringify(z,null,2))}function y(z){let q=A("pantry"),W=Z(q,z);if(J.existsSync(Z(W,"package.json")))return W;let X=Z(q,"@stacksjs",z);if(J.existsSync(Z(X,"package.json")))return X;if(z.startsWith("@")){let Q=Z(q,z);if(J.existsSync(Z(Q,"package.json")))return Q}let M=["*/package.json","@*/*/package.json"];for(let Q of M){let Y=new Bun.Glob(Q);for(let $ of Y.scanSync({cwd:q,absolute:!0,onlyFiles:!0}))try{if(JSON.parse(J.readFileSync($,"utf-8"))?.stacks?.name===z)return T($)}catch{}}return null}function C(z,q){let W=[];if(!J.existsSync(z))return W;let X=J.readdirSync(z,{withFileTypes:!0});for(let M of X){let Q=Z(z,M.name);if(M.isDirectory())W.push(...C(Q,q));else W.push(m(q,Q))}return W}async function n(z){let{name:q,force:W=!1,dryRun:X=!1,verbose:M=!1}=z,Q=W?"overwrite":z.conflict??"skip";H.info(`Installing stack "${q}"...`);let Y=y(q);if(!Y)return H.error(`Stack "${q}" not found in pantry. Install it first with: bun add <package-name>`),null;let $,G;try{let V=await Bun.file(Z(Y,"package.json")).text();if($=JSON.parse(V),G=$.stacks,!G?.name)return H.error(`Package at "${Y}" does not have a valid "stacks" field in package.json`),null}catch(V){return H.error(`Failed to read stack package.json: ${V}`),null}let O=await L(),U=$.name||q;if(O.stacks[U]&&!W)return H.warn(`Stack "${G.name}" is already installed. Use --force to reinstall.`),O.stacks[U];let B=G.directories??F,w=[];for(let V of B){let E=Z(Y,V);if(J.existsSync(E)){let _=C(E,Y);w.push(..._)}}if(w.length===0)return H.warn(`Stack "${G.name}" has no files to install`),null;if(M)H.info(`Found ${w.length} file(s) to install`);let x=[],I=[];for(let V of w){let E=Z(Y,V),_=A(V);if(X){if(J.existsSync(_))if(H.info(`[dry-run] Would ${Q}: ${V}`),Q==="skip")I.push(V);else x.push(V);else H.info(`[dry-run] Would copy: ${V}`),x.push(V);continue}if(J.existsSync(_))switch(Q){case"skip":if(M)H.warn(`Skipping (file exists): ${V}`);I.push(V);continue;case"backup":{let f=u(G.name),v=Z(f,V),j=T(v);if(!J.existsSync(j))await R(j);if(K(_,v),M)H.info(`Backed up: ${V}`);break}case"overwrite":if(M)H.warn(`Overwriting: ${V}`);break}let S=T(_);if(!J.existsSync(S))await R(S);if(K(E,_),x.push(V),M)H.info(`Copied: ${V}`)}if(X)return H.info(`[dry-run] Would install ${x.length} file(s), skip ${I.length} file(s)`),null;let N={packageName:U,name:G.name,version:$.version||"0.0.0",installedAt:new Date().toISOString(),files:x,skipped:I,conflictStrategy:Q};return O.stacks[U]=N,await D(O),H.success(`Installed stack "${G.name}" (${x.length} file(s) copied, ${I.length} skipped)`),N}async function c(z){let{name:q,force:W=!1,verbose:X=!1}=z;H.info(`Uninstalling stack "${q}"...`);let M=await L(),Q=null,Y=null;for(let[O,U]of Object.entries(M.stacks))if(U.name===q||O===q){Q=O,Y=U;break}if(!Y||!Q)return H.error(`Stack "${q}" is not installed`),!1;let $=0;for(let O of Y.files){let U=A(O);if(!J.existsSync(U)){if(X)H.info(`Already removed: ${O}`);continue}if(!W){let B=y(q);if(B){let w=Z(B,O);if(J.existsSync(w)){let x=await Bun.file(w).text(),I=await Bun.file(U).text();if(x!==I){H.warn(`Skipping modified file: ${O} (use --force to remove)`);continue}}}}if(await g(U),$++,X)H.info(`Removed: ${O}`)}let G=u(Y.name);if(J.existsSync(G)&&P(G)){let O=C(G,G);for(let U of O){let B=Z(G,U),w=A(U),x=T(w);if(!J.existsSync(x))await R(x);if(K(B,w),X)H.info(`Restored from backup: ${U}`)}J.rmSync(G,{recursive:!0,force:!0})}for(let O of F){let U=A(O);if(J.existsSync(U))await d(U)}return delete M.stacks[Q],await D(M),H.success(`Uninstalled stack "${Y.name}" (${$} file(s) removed)`),!0}async function i(){let z=[],q=await L(),W=A("pantry");if(J.existsSync(W)){let X=["*/package.json","@*/*/package.json"];for(let M of X){let Q=new Bun.Glob(M);for(let Y of Q.scanSync({cwd:W,absolute:!0,onlyFiles:!0}))try{let $=J.readFileSync(Y,"utf-8"),G=JSON.parse($);if(!G?.stacks?.name)continue;let O=G.name,U=!!q.stacks[O],B=q.stacks[O];z.push({name:G.stacks.name,packageName:O,version:G.version||"0.0.0",description:G.stacks.description,installed:U,installedAt:B?.installedAt,fileCount:B?.files.length})}catch{}}}for(let[X,M]of Object.entries(q.stacks))if(!z.some((Q)=>Q.packageName===X))z.push({name:M.name,packageName:X,version:M.version,installed:!0,installedAt:M.installedAt,fileCount:M.files.length});return z}export{c as uninstallStack,i as listStacks,n as installStack};
+import { log } from "@stacksjs/logging";
+import { dirname, join, projectPath, relative, stacksBackupPath, stacksLockPath } from "@stacksjs/path";
+import { copyFile, createFolder, deleteFile, deleteEmptyFolders, doesFolderExist, fs } from "@stacksjs/storage";
+const STACK_DIRS = ["app", "config", "database", "resources", "routes", "public", "locales"];
+async function readStackLock() {
+  const lockPath = stacksLockPath();
+  try {
+    if (fs.existsSync(lockPath)) {
+      const content = await Bun.file(lockPath).text();
+      return JSON.parse(content);
+    }
+  } catch {}
+  return {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    stacks: {}
+  };
+}
+async function writeStackLock(lock) {
+  const lockPath = stacksLockPath(), lockDir = dirname(lockPath);
+  if (!fs.existsSync(lockDir))
+    await createFolder(lockDir);
+  lock.generatedAt = new Date().toISOString();
+  await Bun.write(lockPath, JSON.stringify(lock, null, 2));
+}
+function resolveStackPackagePath(name) {
+  const pantryDir = projectPath("pantry"), directPath = join(pantryDir, name);
+  if (fs.existsSync(join(directPath, "package.json")))
+    return directPath;
+  const scopedPath = join(pantryDir, "@stacksjs", name);
+  if (fs.existsSync(join(scopedPath, "package.json")))
+    return scopedPath;
+  if (name.startsWith("@")) {
+    const fullPath = join(pantryDir, name);
+    if (fs.existsSync(join(fullPath, "package.json")))
+      return fullPath;
+  }
+  const patterns = ["*/package.json", "@*/*/package.json"];
+  for (const pattern of patterns) {
+    const glob = new Bun.Glob(pattern);
+    for (const file of glob.scanSync({ cwd: pantryDir, absolute: !0, onlyFiles: !0 }))
+      try {
+        if (JSON.parse(fs.readFileSync(file, "utf-8"))?.stacks?.name === name)
+          return dirname(file);
+      } catch {}
+  }
+  return null;
+}
+function collectFiles(dir, baseDir) {
+  const files = [];
+  if (!fs.existsSync(dir))
+    return files;
+  const entries = fs.readdirSync(dir, { withFileTypes: !0 });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory())
+      files.push(...collectFiles(fullPath, baseDir));
+    else
+      files.push(relative(baseDir, fullPath));
+  }
+  return files;
+}
+export async function installStack(options) {
+  const { name, force = !1, dryRun = !1, verbose = !1 } = options, conflict = force ? "overwrite" : options.conflict ?? "skip";
+  log.info(`Installing stack "${name}"...`);
+  const stackPath = resolveStackPackagePath(name);
+  if (!stackPath) {
+    log.error(`Stack "${name}" not found in pantry. Install it first with: bun add <package-name>`);
+    return null;
+  }
+  let pkg, meta;
+  try {
+    const pkgContent = await Bun.file(join(stackPath, "package.json")).text();
+    pkg = JSON.parse(pkgContent);
+    meta = pkg.stacks;
+    if (!meta?.name) {
+      log.error(`Package at "${stackPath}" does not have a valid "stacks" field in package.json`);
+      return null;
+    }
+  } catch (error) {
+    log.error(`Failed to read stack package.json: ${error}`);
+    return null;
+  }
+  const lock = await readStackLock(), packageName = pkg.name || name;
+  if (lock.stacks[packageName] && !force) {
+    log.warn(`Stack "${meta.name}" is already installed. Use --force to reinstall.`);
+    return lock.stacks[packageName];
+  }
+  const dirsToScan = meta.directories ?? STACK_DIRS, allFiles = [];
+  for (const dir of dirsToScan) {
+    const dirPath = join(stackPath, dir);
+    if (fs.existsSync(dirPath)) {
+      const files = collectFiles(dirPath, stackPath);
+      allFiles.push(...files);
+    }
+  }
+  if (allFiles.length === 0) {
+    log.warn(`Stack "${meta.name}" has no files to install`);
+    return null;
+  }
+  if (verbose)
+    log.info(`Found ${allFiles.length} file(s) to install`);
+  const copiedFiles = [], skippedFiles = [];
+  for (const relPath of allFiles) {
+    const src = join(stackPath, relPath), dest = projectPath(relPath);
+    if (dryRun) {
+      if (fs.existsSync(dest)) {
+        log.info(`[dry-run] Would ${conflict}: ${relPath}`);
+        if (conflict === "skip")
+          skippedFiles.push(relPath);
+        else
+          copiedFiles.push(relPath);
+      } else {
+        log.info(`[dry-run] Would copy: ${relPath}`);
+        copiedFiles.push(relPath);
+      }
+      continue;
+    }
+    if (fs.existsSync(dest))
+      switch (conflict) {
+        case "skip":
+          if (verbose)
+            log.warn(`Skipping (file exists): ${relPath}`);
+          skippedFiles.push(relPath);
+          continue;
+        case "backup": {
+          const backupDir = stacksBackupPath(meta.name), backupDest = join(backupDir, relPath), backupDestDir = dirname(backupDest);
+          if (!fs.existsSync(backupDestDir))
+            await createFolder(backupDestDir);
+          copyFile(dest, backupDest);
+          if (verbose)
+            log.info(`Backed up: ${relPath}`);
+          break;
+        }
+        case "overwrite":
+          if (verbose)
+            log.warn(`Overwriting: ${relPath}`);
+          break;
+      }
+    const destDir = dirname(dest);
+    if (!fs.existsSync(destDir))
+      await createFolder(destDir);
+    copyFile(src, dest);
+    copiedFiles.push(relPath);
+    if (verbose)
+      log.info(`Copied: ${relPath}`);
+  }
+  if (dryRun) {
+    log.info(`[dry-run] Would install ${copiedFiles.length} file(s), skip ${skippedFiles.length} file(s)`);
+    return null;
+  }
+  const entry = {
+    packageName,
+    name: meta.name,
+    version: pkg.version || "0.0.0",
+    installedAt: new Date().toISOString(),
+    files: copiedFiles,
+    skipped: skippedFiles,
+    conflictStrategy: conflict
+  };
+  lock.stacks[packageName] = entry;
+  await writeStackLock(lock);
+  log.success(`Installed stack "${meta.name}" (${copiedFiles.length} file(s) copied, ${skippedFiles.length} skipped)`);
+  return entry;
+}
+export async function uninstallStack(options) {
+  const { name, force = !1, verbose = !1 } = options;
+  log.info(`Uninstalling stack "${name}"...`);
+  const lock = await readStackLock();
+  let entryKey = null, entry = null;
+  for (const [key, value] of Object.entries(lock.stacks))
+    if (value.name === name || key === name) {
+      entryKey = key;
+      entry = value;
+      break;
+    }
+  if (!entry || !entryKey) {
+    log.error(`Stack "${name}" is not installed`);
+    return !1;
+  }
+  let removedCount = 0;
+  for (const relPath of entry.files) {
+    const filePath = projectPath(relPath);
+    if (!fs.existsSync(filePath)) {
+      if (verbose)
+        log.info(`Already removed: ${relPath}`);
+      continue;
+    }
+    if (!force) {
+      const stackPath = resolveStackPackagePath(name);
+      if (stackPath) {
+        const srcPath = join(stackPath, relPath);
+        if (fs.existsSync(srcPath)) {
+          const srcContent = await Bun.file(srcPath).text(), destContent = await Bun.file(filePath).text();
+          if (srcContent !== destContent) {
+            log.warn(`Skipping modified file: ${relPath} (use --force to remove)`);
+            continue;
+          }
+        }
+      }
+    }
+    await deleteFile(filePath);
+    removedCount++;
+    if (verbose)
+      log.info(`Removed: ${relPath}`);
+  }
+  const backupDir = stacksBackupPath(entry.name);
+  if (fs.existsSync(backupDir) && doesFolderExist(backupDir)) {
+    const backupFiles = collectFiles(backupDir, backupDir);
+    for (const relPath of backupFiles) {
+      const backupSrc = join(backupDir, relPath), dest = projectPath(relPath), destDir = dirname(dest);
+      if (!fs.existsSync(destDir))
+        await createFolder(destDir);
+      copyFile(backupSrc, dest);
+      if (verbose)
+        log.info(`Restored from backup: ${relPath}`);
+    }
+    fs.rmSync(backupDir, { recursive: !0, force: !0 });
+  }
+  for (const dir of STACK_DIRS) {
+    const dirPath = projectPath(dir);
+    if (fs.existsSync(dirPath))
+      await deleteEmptyFolders(dirPath);
+  }
+  delete lock.stacks[entryKey];
+  await writeStackLock(lock);
+  log.success(`Uninstalled stack "${entry.name}" (${removedCount} file(s) removed)`);
+  return !0;
+}
+export async function listStacks() {
+  const entries = [], lock = await readStackLock(), pantryDir = projectPath("pantry");
+  if (fs.existsSync(pantryDir)) {
+    const patterns = ["*/package.json", "@*/*/package.json"];
+    for (const pattern of patterns) {
+      const glob = new Bun.Glob(pattern);
+      for (const file of glob.scanSync({ cwd: pantryDir, absolute: !0, onlyFiles: !0 }))
+        try {
+          const pkgContent = fs.readFileSync(file, "utf-8"), pkg = JSON.parse(pkgContent);
+          if (!pkg?.stacks?.name)
+            continue;
+          const packageName = pkg.name, installed = !!lock.stacks[packageName], lockEntry = lock.stacks[packageName];
+          entries.push({
+            name: pkg.stacks.name,
+            packageName,
+            version: pkg.version || "0.0.0",
+            description: pkg.stacks.description,
+            installed,
+            installedAt: lockEntry?.installedAt,
+            fileCount: lockEntry?.files.length
+          });
+        } catch {}
+    }
+  }
+  for (const [packageName, entry] of Object.entries(lock.stacks))
+    if (!entries.some((e) => e.packageName === packageName))
+      entries.push({
+        name: entry.name,
+        packageName,
+        version: entry.version,
+        installed: !0,
+        installedAt: entry.installedAt,
+        fileCount: entry.files.length
+      });
+  return entries;
+}