@stacksjs/buddy 0.70.59 → 0.70.60

package/dist/commands/saas.js

@@ -0,0 +1,25 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function saas(buddy) {
+  const descriptions = {
+    stripe: "Sets up stripe products in the dashboard",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("stripe:setup", descriptions.stripe).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy stripe:setup` ...", options);
+    const perf = await intro("buddy stripe:setup"), result = await runAction(Action.StripeSetup, options);
+    if (result.isErr) {
+      await outro("While running the stripe:setup command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Stripe products created successfully", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+}

package/dist/commands/schedule.js

@@ -0,0 +1,61 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function schedule(buddy) {
+  const descriptions = {
+    project: "Target a specific project",
+    schedule: "Run the scheduler",
+    verbose: "Enable verbose output",
+    list: "List all registered scheduled tasks with their next run time",
+    status: "Show currently-held overlap locks (this-process only)"
+  };
+  buddy.command("schedule:run", descriptions.schedule).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy schedule:run` ...", options);
+    const perf = await intro("buddy schedule:run"), result = await runAction(Action.ScheduleRun, options);
+    if (result.isErr) {
+      await outro("While running the schedule:run command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("schedule:list", descriptions.list).action(async () => {
+    try {
+      await import(`${process.cwd()}/routes/scheduler.ts`).catch(() => {
+        log.warn("[schedule:list] no routes/scheduler.ts found \u2014 registry will be empty unless tasks were registered elsewhere");
+      });
+      const { Schedule } = await import("@stacksjs/scheduler"), jobs = Schedule.listJobs();
+      if (jobs.length === 0) {
+        log.info("No scheduled tasks registered.");
+        process.exit(ExitCode.Success);
+      }
+      const nameWidth = Math.max(4, ...jobs.map((j) => j.name.length)), patternWidth = Math.max(7, ...jobs.map((j) => (j.pattern ?? "").length));
+      log.info(`${"NAME".padEnd(nameWidth)}  ${"PATTERN".padEnd(patternWidth)}  TIMEZONE                   NEXT RUN (UTC)`);
+      for (const j of jobs) {
+        const next = j.nextRun ? j.nextRun.toISOString() : "\u2014";
+        log.info(`${j.name.padEnd(nameWidth)}  ${(j.pattern ?? "").padEnd(patternWidth)}  ${(j.timezone ?? "UTC").padEnd(25)}  ${next}`);
+      }
+      process.exit(ExitCode.Success);
+    } catch (err) {
+      log.error(`[schedule:list] failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("schedule:status", descriptions.status).action(async () => {
+    try {
+      const { Schedule } = await import("@stacksjs/scheduler"), held = Schedule.listLocks();
+      if (held.length === 0)
+        log.info("No in-process scheduler locks held.");
+      else {
+        log.info(`Held locks (${held.length}):`);
+        for (const name of held)
+          log.info(`  \u2022 ${name}`);
+      }
+      process.exit(ExitCode.Success);
+    } catch (err) {
+      log.error(`[schedule:status] failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+}

package/dist/commands/search.js

@@ -0,0 +1,84 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function search(buddy) {
+  const descriptions = {
+    import: "Indexes database data to search engine",
+    flush: "Flushes all data from search engine",
+    settings: "Update index settings",
+    list: "List index settings",
+    model: "Target a specific model",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("search-engine:update", descriptions.import).option("-m, --model [model]", descriptions.model, { default: "" }).option("-f, --flush [flush]", descriptions.flush, { default: !1 }).option("-s, --settings [settings]", descriptions.settings, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).action(async (options) => {
+    log.debug("Running `search-engine:update` ...", options);
+    let actionString = Action.SearchEngineImport, introString = "search-engine:update";
+    if (options.model) {
+      actionString = Action.SearchEngineImport;
+      introString = `search-engine:update --model ${options.model}`;
+    }
+    if (options.settings) {
+      actionString = Action.SearchEnginePushSettings;
+      introString = "search-engine:update --settings";
+    }
+    if (options.flush) {
+      actionString = Action.SearchEngineFlush;
+      introString = "search-engine:update --flush";
+    }
+    const perf = await intro(introString), result = await runAction(actionString, options);
+    if (result.isErr) {
+      await outro("While running the search-engine:update command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Successfully imported model data to search engine.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+  });
+  buddy.command("search-engine:settings", descriptions.list).option("-m, --model [model]", descriptions.model, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    if (!options.model)
+      log.error("Missing required option --model");
+    log.debug("Running `search-engine:settings` ...", options);
+    const perf = await intro("search-engine:settings"), result = await runAction(Action.SearchEngineListSettings, options);
+    if (result.isErr) {
+      await outro("While running the search-engine:settings command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Successfully listed search engine index settings.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("search:reindex [model]", "Re-index a model (Scout-style alias for search-engine:update)").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (model, options) => {
+    const opts = { ...options, model: model ?? "" };
+    log.debug("Running `search:reindex` ...", opts);
+    const perf = await intro(`search:reindex${model ? ` ${model}` : ""}`), result = await runAction(Action.SearchEngineImport, opts);
+    if (result.isErr) {
+      await outro("While running the search:reindex command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro(model ? `Reindexed ${model}.` : "Reindexed all searchable models.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("search:flush [model]", "Delete all documents from a model index (Scout-style alias)").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (model, options) => {
+    const opts = { ...options, model: model ?? "", flush: !0 };
+    log.debug("Running `search:flush` ...", opts);
+    const perf = await intro(`search:flush${model ? ` ${model}` : ""}`), result = await runAction(Action.SearchEngineFlush, opts);
+    if (result.isErr) {
+      await outro("While running the search:flush command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro(model ? `Flushed ${model} from search.` : "Flushed all model indices.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+}

package/dist/commands/seed.js

@@ -0,0 +1,71 @@
+import process from "node:process";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { ExitCode } from "@stacksjs/types";
+export function seed(buddy) {
+  const descriptions = {
+    seed: "Seed your database",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("seed", descriptions.seed).alias("db:seed").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-c, --class [class]", "Run a specific seeder class from database/seeders/", { default: "" }).option("--allow-protected", "Seed auth/oauth models even on a non-fresh DB (will invalidate live tokens)", { default: !1 }).option("--fresh", "Truncate tables before seeding", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy seed` ...", options);
+    const perf = await intro("buddy seed");
+    if (options.class) {
+      const { injectGlobalAutoImports } = await import("@stacksjs/server");
+      await injectGlobalAutoImports();
+      const { runClassSeeders } = await import("@stacksjs/database"), result = await runClassSeeders({ class: options.class });
+      await outro(`Class seeders: ran=${result.ran.length}, skipped=${result.skipped.length}`, { startTime: perf, useSeconds: !0 });
+      process.exit(result.ran.length > 0 ? ExitCode.Success : ExitCode.FatalError);
+    }
+    const { injectGlobalAutoImports } = await import("@stacksjs/server");
+    await injectGlobalAutoImports();
+    const { runClassSeeders, listSeedableModels } = await import("@stacksjs/database"), { path } = await import("@stacksjs/path"), { fs } = await import("@stacksjs/storage"), seedableModels = await listSeedableModels(), seedersDir = path.projectPath("database/seeders"), existingSeederFiles = fs.existsSync(seedersDir) ? new Set(fs.readdirSync(seedersDir).filter((f) => f.endsWith(".ts"))) : new Set, unmigratedModels = seedableModels.filter((m) => !existingSeederFiles.has(`${m.name}Seeder.ts`));
+    if (unmigratedModels.length > 0)
+      log.warn(`[seed] ${unmigratedModels.length} model(s) declare the deprecated \`useSeeder\` trait but have no class seeder file: ${unmigratedModels.map((m) => m.name).join(", ")}. ` + "The auto-walker has been removed (stacksjs/stacks#1919) \u2014 these models will NOT seed. " + "Run `./buddy seed:scaffold` to codemod a class seeder per model and strip the trait (stacksjs/stacks#1929), then re-run `./buddy seed`.");
+    const classResult = await runClassSeeders(), APP_ENV = process.env.APP_ENV || "local", ran = classResult.ran.length;
+    await outro(`Seeded your ${APP_ENV} database. Class seeders: ran=${ran}, skipped=${classResult.skipped.length}.`, { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("seed:scaffold", "Generate class seeders for every model with a useSeeder trait (codemod for stacksjs/stacks#1919)").option("--force", "Overwrite existing seeder files", { default: !1 }).option("--dry-run", "Print what would be generated without writing files", { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy seed:scaffold");
+    try {
+      const { scaffoldClassSeedersFromModels } = await import("@stacksjs/database"), result = await scaffoldClassSeedersFromModels({
+        force: options.force,
+        dryRun: options.dryRun
+      }), generated = result.generated.length, alreadyThere = result.skipped.filter((s) => s.reason === "already-exists").length, stripped = result.strippedTrait.length, errors = result.errors.length;
+      for (const g of result.generated)
+        console.log(`  + ${g.model} \u2192 ${g.file}`);
+      for (const s of result.skipped.filter((s) => s.reason === "already-exists"))
+        console.log(`  \xB7 ${s.model}: seeder exists (pass --force to overwrite)`);
+      for (const t of result.strippedTrait)
+        console.log(`  - ${t.model}: removed useSeeder trait from model`);
+      for (const t of result.traitStripSkipped)
+        log.warn(`  ! ${t.model}: useSeeder value couldn't be auto-removed \u2014 strip it manually (${t.file})`);
+      for (const e of result.errors)
+        log.warn(`  ! ${e.model}: ${e.error}`);
+      const verb = options.dryRun ? "would generate" : "generated", strippedVerb = options.dryRun ? "would strip" : "stripped";
+      await outro(`Seeder scaffold: ${verb} ${generated}, skipped ${alreadyThere} existing, ${strippedVerb} ${stripped} trait(s), ${errors} error(s).`, { startTime: perf, useSeconds: !0 });
+      process.exit(errors > 0 && generated === 0 ? ExitCode.FatalError : ExitCode.Success);
+    } catch (err) {
+      await outro("seed:scaffold failed", { startTime: perf, useSeconds: !0 }, err);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("seed:roles", "Seed default RBAC role packs (admin, dev, client)").alias("roles:seed").action(async () => {
+    const perf = await intro("buddy seed:roles");
+    try {
+      const { seedDefaultRoles } = await import("@stacksjs/auth"), result = await seedDefaultRoles();
+      if (result.created.length === 0 && result.skipped.length > 0)
+        await outro(`All ${result.skipped.length} default role packs already exist \u2014 nothing to do.`, { startTime: perf, useSeconds: !0 });
+      else {
+        const createdNames = result.created.map((r) => r.name).join(", ");
+        await outro(`Created ${result.created.length} role pack(s): ${createdNames}. Skipped ${result.skipped.length} existing.`, { startTime: perf, useSeconds: !0 });
+      }
+      process.exit(ExitCode.Success);
+    } catch (err) {
+      await outro("Failed to seed default roles. Most often: migrations haven't run yet (try `./buddy migrate` first).", { startTime: perf, useSeconds: !0 }, err);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  onUnknownSubcommand(buddy, "seed");
+}

package/dist/commands/serve.js

@@ -0,0 +1,176 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import { log } from "@stacksjs/cli";
+globalThis.requestContext = {
+  cookie(name) {
+    return globalThis.__stxServeCookies?.[name] ?? null;
+  },
+  url() {
+    return globalThis.__stxServeSearch ?? "";
+  }
+};
+function parseCookies(req) {
+  const out = {}, header = req.headers.get("cookie") || "";
+  if (!header)
+    return out;
+  for (const part of header.split(";")) {
+    const trimmed = part.trim(), eq = trimmed.indexOf("=");
+    if (eq === -1)
+      continue;
+    const k = trimmed.slice(0, eq).trim(), v = trimmed.slice(eq + 1).trim();
+    if (!k)
+      continue;
+    try {
+      out[k] = decodeURIComponent(v);
+    } catch {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+export function serve(buddy) {
+  buddy.command("serve", "Start the production HTTP server (STX views + /api proxy + coming-soon/maintenance gate)").option("-p, --port <port>", "Port to listen on (defaults to PORT env or 3000)").option("--verbose", "Enable verbose output", { default: !1 }).action(async (options) => {
+    if (options?.port)
+      process.env.PORT = String(options.port);
+    process.env.APP_ENV = process.env.APP_ENV || "production";
+    const port = Number(process.env.PORT) || 3000, { config, overridesReady } = await import("@stacksjs/config");
+    await overridesReady;
+    const { injectGlobalAutoImports } = await import("@stacksjs/server");
+    await injectGlobalAutoImports();
+    let stxServe;
+    const serveCandidates = [
+      join(homedir(), "Code/Tools/stx/packages/bun-plugin/dist/serve.js"),
+      join(process.cwd(), "pantry/bun-plugin-stx/dist/serve.js")
+    ];
+    for (const entry of serveCandidates)
+      try {
+        if (existsSync(entry)) {
+          ({ serve: stxServe } = await import(entry));
+          break;
+        }
+      } catch {}
+    ({ serve: stxServe } = await import("bun-plugin-stx/serve"));
+    const stxModule = await resolveVendoredStxModule(), { site: siteConfig, i18n: i18nConfig } = await loadStxSiteConfig(), userViewsPath = "resources/views", defaultsResources = resolveDefaultsResources(), defaultViewsPath = join(defaultsResources, "views"), userLayoutsPath = existsSync("resources/views/layouts") ? "resources/views/layouts" : "resources/layouts", userComponentsPath = existsSync("resources/views/components") ? "resources/views/components" : "resources/components", apiBase = process.env.API_URL || `http://127.0.0.1:${Number(process.env.PORT_API) || config.ports?.api || 3008}`;
+    log.info(`Starting production server on port ${port}...`);
+    await stxServe({
+      patterns: [userViewsPath, defaultViewsPath],
+      port,
+      autoIncrementPort: !1,
+      reusePort: ["production", "staging", "development"].includes((process.env.APP_ENV || "").toLowerCase()),
+      componentsDir: join(defaultsResources, "components"),
+      layoutsDir: userLayoutsPath,
+      partialsDir: userComponentsPath,
+      fallbackLayoutsDir: join(defaultsResources, "layouts"),
+      fallbackPartialsDir: defaultViewsPath,
+      quiet: options?.verbose !== !0,
+      ...stxModule && { stxModule },
+      ...i18nConfig && { i18n: i18nConfig },
+      ...siteConfig?.url && { site: siteConfig },
+      onRequest: async (req) => {
+        const { maintenanceGate, isApiBoundRequest, proxyToBackend } = await import("@stacksjs/server"), gated = await maintenanceGate(req);
+        if (gated)
+          return gated;
+        const url = new URL(req.url);
+        if (isApiBoundRequest(req, url.pathname))
+          try {
+            return await proxyToBackend(req, apiBase);
+          } catch (error) {
+            log.error(`API proxy to ${apiBase} failed: ${error.message}`);
+            return new Response("Bad Gateway", { status: 502 });
+          }
+        globalThis.__stxServeSearch = url.search;
+        globalThis.__stxServeCookies = parseCookies(req);
+        return;
+      }
+    });
+    log.success(`Production server listening on http://0.0.0.0:${port}`);
+  });
+}
+export function serveApi(buddy) {
+  buddy.command("serve:api", "Start the production API server (bun-router routes the frontend proxies /api to)").option("-p, --port <port>", "Port to listen on (defaults to PORT env or 3008)").action(async (options) => {
+    if (options?.port)
+      process.env.PORT = String(options.port);
+    process.env.APP_ENV = process.env.APP_ENV || "production";
+    await import("@stacksjs/actions/serve/api");
+  });
+}
+function resolveDefaultsResources() {
+  const vendored = "storage/framework/defaults/resources";
+  if (existsSync(vendored))
+    return vendored;
+  try {
+    const pkgJson = Bun.resolveSync("@stacksjs/defaults/package.json", process.cwd());
+    return join(dirname(pkgJson), "resources");
+  } catch {
+    return vendored;
+  }
+}
+async function resolveVendoredStxModule() {
+  const candidates = [
+    join(homedir(), "Code/Tools/stx/packages/stx/dist/index.js"),
+    join(process.cwd(), "pantry/@stacksjs/stx/dist/index.js")
+  ];
+  for (const entry of candidates)
+    try {
+      if (existsSync(entry))
+        return await import(entry);
+    } catch {}
+  try {
+    return await import("@stacksjs/stx");
+  } catch {}
+  return;
+}
+function fallbackI18nFromSite(site) {
+  const locales = site.i18n.locales, defaultLocale = site.i18n.defaultLocale ?? locales[0];
+  return {
+    locales,
+    defaultLocale,
+    labels: site.i18n.labels ?? Object.fromEntries(locales.map((c) => [c, c.toUpperCase()])),
+    translations: {},
+    pickerSelector: site.i18n.pickerSelector ?? "#lang-picker"
+  };
+}
+async function resolveSiteI18n(site) {
+  const resolverPaths = [
+    join(homedir(), "Code/Tools/stx/packages/stx/src/site-builder/i18n.ts"),
+    join(homedir(), "Code/Tools/stx/packages/stx/dist/index.js"),
+    join(process.cwd(), "pantry/@stacksjs/stx/dist/index.js")
+  ];
+  for (const resolverPath of resolverPaths)
+    try {
+      if (!existsSync(resolverPath))
+        continue;
+      const resolved = await import(resolverPath);
+      if (typeof resolved.resolveI18n !== "function")
+        continue;
+      const i18n = resolved.resolveI18n(site, process.cwd());
+      if (i18n)
+        return i18n;
+    } catch {}
+  try {
+    const resolved = await import("@stacksjs/stx");
+    if (typeof resolved.resolveI18n === "function") {
+      const i18n = resolved.resolveI18n(site, process.cwd());
+      if (i18n)
+        return i18n;
+    }
+  } catch {}
+  return fallbackI18nFromSite(site);
+}
+async function loadStxSiteConfig() {
+  const sitePath = join(process.cwd(), "site.config.ts");
+  if (!existsSync(sitePath))
+    return {};
+  try {
+    const site = (await import(sitePath)).default;
+    if (!site)
+      return {};
+    if (!site.i18n)
+      return { site };
+    const i18n = await resolveSiteI18n(site);
+    return { site, i18n };
+  } catch {}
+  return {};
+}

package/dist/commands/setup.js

@@ -0,0 +1,203 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import process from "node:process";
+import { runAction, setupSSL } from "@stacksjs/actions";
+import { log, onUnknownSubcommand, runCommand } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { handleError } from "@stacksjs/error-handling";
+import { path as p } from "@stacksjs/path";
+import { copyFile, storage } from "@stacksjs/storage";
+import { ExitCode } from "@stacksjs/types";
+function getTimeoutMs(envVar, fallbackMs) {
+  const value = Number(process.env[envVar]);
+  if (Number.isFinite(value) && value > 0)
+    return value;
+  return fallbackMs;
+}
+const PANTRY_CHECK_TIMEOUT_MS = getTimeoutMs("PANTRY_CHECK_TIMEOUT_MS", 15000), PANTRY_INSTALL_TIMEOUT_MS = getTimeoutMs("PANTRY_INSTALL_TIMEOUT_MS", 600000), PANTRY_DEPENDENCIES_TIMEOUT_MS = getTimeoutMs("PANTRY_DEPENDENCIES_TIMEOUT_MS", 1200000), KEYGEN_TIMEOUT_MS = getTimeoutMs("KEYGEN_TIMEOUT_MS", 120000), AWS_CONFIG_TIMEOUT_MS = getTimeoutMs("AWS_CONFIG_TIMEOUT_MS", 900000);
+export function setup(buddy) {
+  const descriptions = {
+    setup: "This command ensures your project is setup correctly",
+    ssl: "Setup SSL certificates and hosts file for HTTPS development",
+    ohMyZsh: "Enable Oh My Zsh",
+    aws: "Ensures AWS is connected to the project",
+    project: "Target a specific project",
+    verbose: "Enable verbose output",
+    domain: "Custom domain to setup (defaults to APP_URL)",
+    skipHosts: "Skip adding domain to hosts file",
+    skipTrust: "Skip trusting the certificate",
+    skipAws: "Skip AWS configuration during setup",
+    skipKeygen: "Skip generating an application key during setup"
+  };
+  buddy.command("setup", descriptions.setup).alias("ensure").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--skip-aws", descriptions.skipAws, { default: !1 }).option("--skip-keygen", descriptions.skipKeygen, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy setup` ...", options);
+    await ensurePantryInstalled();
+    await optimizePantryDeps();
+    await initializeProject(options);
+  });
+  buddy.command("setup:ssl", descriptions.ssl).alias("ssl:setup").option("-d, --domain [domain]", descriptions.domain).option("--skip-hosts", descriptions.skipHosts, { default: !1 }).option("--skip-trust", descriptions.skipTrust, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy setup:ssl` ...", options);
+    if (!await setupSSL({
+      domain: options.domain,
+      skipHosts: options.skipHosts,
+      skipTrust: options.skipTrust,
+      verbose: options.verbose
+    })) {
+      log.warn("SSL setup completed with warnings");
+      log.info("You may need to manually trust certificates or update hosts file");
+    }
+  });
+  buddy.command("setup:oh-my-zsh", descriptions.ohMyZsh).alias("upgrade:oh-my-zsh").option("--verbose", descriptions.verbose, { default: !1 }).action(async (_options) => {
+    log.debug("Running `buddy setup:oh-my-zsh` ...", _options);
+    const result = await runAction(Action.UpgradeShell);
+    if (result.isErr) {
+      log.error(result.error);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  onUnknownSubcommand(buddy, "setup");
+}
+async function isPantryInstalled() {
+  if ((await runCommand("pantry --version", {
+    silent: !0,
+    timeoutMs: PANTRY_CHECK_TIMEOUT_MS
+  })).isOk)
+    return !0;
+  return !1;
+}
+async function installPantry() {
+  const result = await runCommand(p.frameworkPath("scripts/pantry-install"), {
+    timeoutMs: PANTRY_INSTALL_TIMEOUT_MS
+  });
+  if (result.isOk)
+    return;
+  handleError(result.error);
+  process.exit(ExitCode.FatalError);
+}
+export async function ensurePantryInstalled() {
+  if (!await isPantryInstalled())
+    await installPantry();
+}
+export async function ensurePantryDependencies(cwd) {
+  log.info("Installing Pantry dependencies...");
+  const result = await runCommand("pantry install", {
+    cwd,
+    timeoutMs: PANTRY_DEPENDENCIES_TIMEOUT_MS
+  });
+  if (result.isOk) {
+    log.success("Installed Pantry dependencies");
+    return;
+  }
+  handleError(result.error);
+  process.exit(ExitCode.FatalError);
+}
+function hasAppKey(cwd) {
+  const envPath = join(cwd, ".env");
+  if (!existsSync(envPath))
+    return !1;
+  return /^APP_KEY=.+$/m.test(readFileSync(envPath, "utf-8"));
+}
+export async function ensureAppKey(cwd) {
+  if (hasAppKey(cwd)) {
+    log.success("APP_KEY existed");
+    return;
+  }
+  const keyResult = await runCommand("./buddy key:generate", {
+    cwd,
+    timeoutMs: KEYGEN_TIMEOUT_MS
+  });
+  if (keyResult.isErr) {
+    handleError(keyResult.error);
+    process.exit(ExitCode.FatalError);
+  }
+  log.success("Generated application key");
+}
+async function initializeProject(options) {
+  const cwd = options.cwd || p.projectPath();
+  await ensurePantryDependencies(cwd);
+  await ensureEnvIsSet(options);
+  if (!options.skipKeygen)
+    await ensureAppKey(cwd);
+  if (!options.skipAws) {
+    log.info("Ensuring AWS is connected...");
+    const awsResult = await runCommand("./buddy configure:aws", {
+      cwd,
+      timeoutMs: AWS_CONFIG_TIMEOUT_MS
+    });
+    if (awsResult.isErr) {
+      handleError(awsResult.error);
+      process.exit(ExitCode.FatalError);
+    }
+    log.success("Configured AWS");
+  }
+  log.success("Project is setup");
+  log.info("Happy coding! \uD83D\uDC99");
+}
+const DB_CONNECTION_PACKAGES = {
+  postgres: "postgresql.org",
+  mysql: "mysql.com",
+  sqlite: "sqlite.org"
+};
+function detectDbPackage(cwd) {
+  const envPath = join(cwd, ".env"), envExamplePath = join(cwd, ".env.example"), filePath = existsSync(envPath) ? envPath : existsSync(envExamplePath) ? envExamplePath : void 0;
+  if (!filePath)
+    return;
+  const match = readFileSync(filePath, "utf-8").match(/^DB_CONNECTION=(.+)$/m);
+  if (!match)
+    return;
+  const value = match[1].trim().replace(/['"]/g, "");
+  return DB_CONNECTION_PACKAGES[value];
+}
+export async function optimizePantryDeps() {
+  const cwd = p.projectPath(), depsConfigPath = join(cwd, "config", "deps.ts");
+  if (!existsSync(depsConfigPath)) {
+    log.debug("No config/deps.ts found, skipping dependency optimization");
+    return;
+  }
+  let configDeps = {};
+  try {
+    const mod = await import(depsConfigPath), config = mod.config || mod.default;
+    if (config?.dependencies)
+      configDeps = { ...config.dependencies };
+  } catch (err) {
+    log.debug("Could not load config/deps.ts, skipping dependency optimization");
+    return;
+  }
+  const dbPackage = detectDbPackage(cwd);
+  if (dbPackage) {
+    if (!Object.keys(configDeps).some((key) => key === dbPackage || key.startsWith(`${dbPackage}/`))) {
+      log.info(`Detected DB_CONNECTION requires ${dbPackage}, adding to dependencies`);
+      configDeps[dbPackage] = "*";
+    }
+  }
+  const lines = [
+    "# Auto-generated from config/deps.ts and .env sniffing.",
+    "# This file is regenerated on each `buddy setup` run.",
+    "#",
+    "# To learn more, please visit:",
+    "# https://stacksjs.com/docs/dependency-management",
+    "",
+    "dependencies:"
+  ];
+  for (const [pkg, version] of Object.entries(configDeps))
+    lines.push(`  ${pkg}: ${version}`);
+  const depsYamlPath = join(cwd, "deps.yaml");
+  writeFileSync(depsYamlPath, `${lines.join(`
+`)}
+`);
+  log.success("Generated deps.yaml from config/deps.ts");
+}
+export async function ensureEnvIsSet(options) {
+  log.info("Ensuring .env exists...");
+  const cwd = options.cwd || p.projectPath(), envPath = `${cwd}/.env`, envExamplePath = `${cwd}/.env.example`;
+  if (storage.doesNotExist(envPath)) {
+    try {
+      copyFile(envExamplePath, envPath);
+    } catch (error) {
+      handleError(error);
+      process.exit(ExitCode.FatalError);
+    }
+    log.success(".env created");
+  } else
+    log.success(".env existed");
+}

package/dist/commands/share.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function share(buddy: CLI): void;