@stacksjs/actions 0.70.88 → 0.70.91

package/dist/setup/ssl.d.ts

@@ -0,0 +1,38 @@
+import type { CliOptions } from '@stacksjs/types';
+/**
+ * Check if a domain is in the hosts file
+ */
+export declare function isDomainInHosts(domain: string): boolean;
+/**
+ * Add a domain to the hosts file (requires sudo on Unix)
+ */
+export declare function addDomainToHosts(domain: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Check if SSL certificates exist for a domain
+ */
+export declare function sslCertificatesExist(domain: string): boolean;
+/**
+ * Check if a certificate is trusted (macOS only for now)
+ */
+export declare function isCertificateTrusted(domain: string): boolean;
+/**
+ * Trust a certificate on macOS
+ */
+export declare function trustCertificate(domain: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Generate SSL certificates for a domain using rpx
+ */
+export declare function generateCertificates(domain: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Complete SSL setup for development
+ */
+export declare function setupSSL(options?: SSLSetupOptions): Promise<boolean>;
+/**
+ * Check if SSL setup is complete for a domain
+ */
+export declare function isSSLSetupComplete(domain: string): boolean;
+export declare interface SSLSetupOptions extends CliOptions {
+  domain?: string
+  skipHosts?: boolean
+  skipTrust?: boolean
+}

package/dist/setup/ssl.js

@@ -0,0 +1,271 @@
+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.d.ts

@@ -0,0 +1,4 @@
+import type { StackInstallOptions, StackListEntry, StackManifestEntry, StackUninstallOptions } from '@stacksjs/types';
+export declare function installStack(options: StackInstallOptions): Promise<StackManifestEntry | null>;
+export declare function uninstallStack(options: StackUninstallOptions): Promise<boolean>;
+export declare function listStacks(): Promise<StackListEntry[]>;

package/dist/stacks.js

@@ -0,0 +1,265 @@
+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;
+}

package/dist/templates.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Code generation templates for the make command
+ *
+ * These templates use the {0}, {1}, etc. format for template substitution
+ * which works with the @stacksjs/strings template function
+ */
+export declare const CODE_TEMPLATES: {
+  action: string;
+  actionWithValidation: string;
+  actionWithAuth: string;
+  actionWithBoth: string;
+  component: string;
+  page: string;
+  function: string;
+  language: string;
+  notification: string;
+  mail: string;
+  mailTemplate: string;
+  middleware: string;
+  model: string;
+  migration: string;
+  stackPackageJson: string;
+  job: string;
+  event: string;
+  listener: string;
+  command: string
+};
+export type TemplateKey = keyof typeof CODE_TEMPLATES;