@stacksjs/buddy 0.70.59 → 0.70.60

package/dist/commands/env.js

@@ -0,0 +1,246 @@
+import process from "node:process";
+import { log, onUnknownSubcommand } from "@stacksjs/cli";
+import { decryptEnv, encryptEnv, getEnv, getKeypair, rotateKeypair, setEnv } from "@stacksjs/env";
+import { ExitCode } from "@stacksjs/types";
+export function env(buddy) {
+  const descriptions = {
+    env: "Interact with your environment variables",
+    get: "Get an environment variable",
+    set: "Set an environment variable",
+    encrypt: "Encrypt a value",
+    decrypt: "Decrypt a value",
+    check: "Check environment configuration and validate setup",
+    pretty: "Pretty print the result",
+    stdout: "Output the result to stdout",
+    keypair: "Generate a keypair",
+    fileKeys: "The path to the file containing the keys",
+    excludeKey: "The key to exclude from encryption",
+    rotate: "Rotate a keypair",
+    format: "The format to output the result (json, shell, eval)",
+    all: "Get all environment variables",
+    file: "The environment file to use",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("env:get [key]", descriptions.get).option("-f, --file [file]", descriptions.file, { default: "" }).option("--format [format]", descriptions.format, { default: "json" }).option("-a, --all", descriptions.all, { default: !1 }).option("-p, --pretty", descriptions.pretty, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy env:get SECRET").example("buddy env:get SECRET --file .env.production").example("buddy env:get --all --pretty").example("buddy env:get --format shell").example("buddy env:get --format eval").example("buddy env:get --format json").action(async (key, options) => {
+    log.debug("Running `buddy env:get` ...", options);
+    const result = getEnv(key, {
+      file: options.file,
+      keysFile: options.fileKeys,
+      all: options.all,
+      format: options.format,
+      prettyPrint: options.pretty
+    });
+    if (result.success) {
+      console.log(result.output);
+      process.exit(ExitCode.Success);
+    } else {
+      console.error(result.error);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("env:set [key] [value]", descriptions.set).option("-f, --file [file]", descriptions.file, { default: "" }).option("-fk, --file-keys [fileKeys]", descriptions.fileKeys, { default: "" }).option("--plain", "Don't encrypt the value", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy env:set SECRET=value").example("buddy env:set SECRET value").example("buddy env:set SECRET value --file .env.production").example("buddy env:set SECRET value --plain").action(async (key, value, options) => {
+    log.debug("Running `buddy env:set` ...", options);
+    if (!key || !value) {
+      console.error("Both key and value are required");
+      process.exit(ExitCode.FatalError);
+    }
+    const result = setEnv(key, value, {
+      file: options.file,
+      keysFile: options.fileKeys,
+      plain: options.plain
+    });
+    if (result.success) {
+      console.log(result.output);
+      process.exit(ExitCode.Success);
+    } else {
+      console.error(result.error);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("env:encrypt [key]", descriptions.encrypt).option("-f, --file [file]", descriptions.file, { default: "" }).option("-fk, --file-keys [fileKeys]", descriptions.fileKeys, { default: "" }).option("-o, --stdout", descriptions.stdout, { default: !1 }).option("-ek, --exclude-key [excludeKey]", descriptions.excludeKey, { default: "" }).example("buddy env:encrypt").example("buddy env:encrypt --file .env.production").example('buddy env:encrypt -k "SECRET_*"').action(async (key, options) => {
+    log.debug("Running `buddy env:encrypt` ...", options);
+    const result = encryptEnv({
+      file: options.file,
+      keysFile: options.fileKeys,
+      key,
+      excludeKey: options.excludeKey,
+      stdout: options.stdout
+    });
+    if (result.success) {
+      console.log(result.output);
+      process.exit(ExitCode.Success);
+    } else {
+      console.error(result.error);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("env:decrypt [key]", descriptions.decrypt).option("-f, --file [file]", descriptions.file, { default: "" }).option("-fk, --file-keys [fileKeys]", descriptions.fileKeys, { default: "" }).option("-o, --stdout", descriptions.stdout, { default: !1 }).example("buddy env:decrypt").example("buddy env:decrypt --file .env.production").example('buddy env:decrypt -k "SECRET_*"').action(async (key, options) => {
+    log.debug("Running `buddy env:decrypt` ...", options);
+    const result = decryptEnv({
+      file: options.file,
+      keysFile: options.fileKeys,
+      key,
+      stdout: options.stdout
+    });
+    if (result.success) {
+      console.log(result.output);
+      process.exit(ExitCode.Success);
+    } else {
+      console.error(result.error);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("env:keypair [key]", descriptions.keypair).option("-f, --file [file]", descriptions.file, { default: "" }).option("-fk, --file-keys [fileKeys]", descriptions.fileKeys, { default: "" }).option("--format [format]", descriptions.format, { default: "json" }).example("buddy env:keypair").example("buddy env:keypair --file .env.production").example("buddy env:keypair DOTENV_PRIVATE_KEY").action(async (key, options) => {
+    log.debug("Running `buddy env:keypair` ...", options);
+    const result = getKeypair(key, {
+      file: options.file,
+      keysFile: options.fileKeys,
+      format: options.format
+    });
+    if (result.success) {
+      console.log(result.output);
+      process.exit(ExitCode.Success);
+    } else {
+      console.error(result.error);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("env:rotate [key]", descriptions.rotate).option("-f, --file [file]", descriptions.file, { default: "" }).option("-fk, --file-keys [fileKeys]", descriptions.fileKeys, { default: "" }).option("-o, --stdout", descriptions.stdout, { default: !1 }).option("-ek, --exclude-key [excludeKey]", descriptions.excludeKey, { default: "" }).example("buddy env:rotate").example("buddy env:rotate --file .env.production").action(async (key, options) => {
+    log.debug("Running `buddy env:rotate` ...", options);
+    const result = rotateKeypair({
+      file: options.file,
+      keysFile: options.fileKeys,
+      key,
+      excludeKey: options.excludeKey,
+      stdout: options.stdout
+    });
+    if (result.success) {
+      console.log(result.output);
+      process.exit(ExitCode.Success);
+    } else {
+      console.error(result.error);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("env:check", descriptions.check).option("-f, --file [file]", descriptions.file, { default: "" }).option("--verbose", descriptions.verbose, { default: !1 }).example("buddy env:check").example("buddy env:check --file .env.production").action(async (options) => {
+    log.debug("Running `buddy env:check` ...", options);
+    const { bold, dim, green, red, yellow, intro } = await import("@stacksjs/cli"), { storage } = await import("@stacksjs/storage"), { existsSync } = await import("node:fs"), { resolve } = await import("node:path");
+    await intro("buddy env:check");
+    const checks = [], envFile = options.file || ".env", envPath = resolve(process.cwd(), envFile);
+    if (existsSync(envPath)) {
+      checks.push({
+        name: `${envFile} file`,
+        status: "pass",
+        message: "Found"
+      });
+      try {
+        const envContent = await storage.readTextFile(envPath), lines = String(envContent).split(`
+`).filter((line) => line.trim() && !line.startsWith("#")), varCount = lines.length;
+        checks.push({
+          name: "Environment variables",
+          status: "pass",
+          message: `${varCount} variables defined`
+        });
+        if (lines.some((line) => line.startsWith("APP_KEY="))) {
+          const appKeyLine = lines.find((line) => line.startsWith("APP_KEY=")), eq = appKeyLine?.indexOf("=") ?? -1, appKeyValue = (eq >= 0 ? appKeyLine.slice(eq + 1) : "").trim().replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
+          if (appKeyValue && appKeyValue.length > 0)
+            checks.push({
+              name: "APP_KEY",
+              status: "pass",
+              message: "Set"
+            });
+          else
+            checks.push({
+              name: "APP_KEY",
+              status: "warn",
+              message: "Empty (run: buddy key:generate)"
+            });
+        } else
+          checks.push({
+            name: "APP_KEY",
+            status: "warn",
+            message: "Not found (run: buddy key:generate)"
+          });
+        const hasPublicKey = lines.some((line) => line.startsWith("DOTENV_PUBLIC_KEY=")), hasPrivateKey = lines.some((line) => line.startsWith("DOTENV_PRIVATE_KEY="));
+        if (hasPublicKey && hasPrivateKey)
+          checks.push({
+            name: "Encryption keys",
+            status: "pass",
+            message: "Public and private keys configured"
+          });
+        else if (hasPublicKey || hasPrivateKey)
+          checks.push({
+            name: "Encryption keys",
+            status: "warn",
+            message: "Incomplete keypair (run: buddy env:keypair)"
+          });
+        else
+          checks.push({
+            name: "Encryption keys",
+            status: "warn",
+            message: "Not configured (optional)"
+          });
+      } catch (error) {
+        checks.push({
+          name: `${envFile} content`,
+          status: "fail",
+          message: `Cannot read file: ${error}`
+        });
+      }
+    } else
+      checks.push({
+        name: `${envFile} file`,
+        status: "fail",
+        message: "Not found"
+      });
+    const keysPath = resolve(process.cwd(), ".env.keys");
+    if (existsSync(keysPath))
+      checks.push({
+        name: ".env.keys file",
+        status: "pass",
+        message: "Found"
+      });
+    else
+      checks.push({
+        name: ".env.keys file",
+        status: "warn",
+        message: "Not found (optional for encryption)"
+      });
+    console.log("");
+    console.log(bold("Environment Configuration Check:"));
+    console.log(dim("\u2500".repeat(60)));
+    console.log("");
+    let hasFailures = !1, hasWarnings = !1;
+    for (const check of checks) {
+      let statusIcon = "", statusColor = (text) => text;
+      if (check.status === "pass") {
+        statusIcon = "\u2713";
+        statusColor = green;
+      } else if (check.status === "warn") {
+        statusIcon = "\u26A0";
+        statusColor = yellow;
+        hasWarnings = !0;
+      } else {
+        statusIcon = "\u2717";
+        statusColor = red;
+        hasFailures = !0;
+      }
+      console.log(`${statusColor(statusIcon)} ${bold(check.name.padEnd(25))} ${dim(check.message)}`);
+    }
+    console.log("");
+    console.log(dim("\u2500".repeat(60)));
+    console.log("");
+    if (hasFailures) {
+      console.log(red("\u2717 Some critical checks failed. Please address the issues above."));
+      process.exit(ExitCode.FatalError);
+    } else if (hasWarnings) {
+      console.log(yellow("\u26A0 Some checks have warnings. Your environment should work but may have issues."));
+      process.exit(ExitCode.Success);
+    } else {
+      console.log(green("\u2713 All checks passed! Your environment configuration looks healthy."));
+      process.exit(ExitCode.Success);
+    }
+  });
+  onUnknownSubcommand(buddy, "env");
+}

package/dist/commands/features.js

@@ -0,0 +1,422 @@
+import { existsSync } from "node:fs";
+import { cp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import process from "node:process";
+import { frameworkPath, projectPath } from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+export const FEATURE_NAMES = [
+  "dashboard",
+  "commerce",
+  "cms",
+  "marketing",
+  "monitoring",
+  "realtime",
+  "queue"
+], FEATURE_FILES = {
+  cms: [
+    "app/Actions/Cms/",
+    "app/Actions/Dashboard/Content/",
+    "app/Models/Content/",
+    "app/Models/Tag.ts",
+    "app/Models/Comment.ts",
+    "resources/views/dashboard/content/"
+  ],
+  commerce: [
+    "app/Actions/Commerce/",
+    "app/Actions/Dashboard/Commerce/",
+    "app/Models/commerce/",
+    "resources/components/Dashboard/Commerce/",
+    "resources/views/dashboard/commerce/"
+  ],
+  dashboard: [
+    "app/Actions/Dashboard/",
+    "resources/components/Dashboard/",
+    "resources/views/dashboard/",
+    "routes/dashboard.ts",
+    "routes/dashboard-api.ts"
+  ],
+  marketing: [
+    "app/Actions/Dashboard/Marketing/",
+    "app/Models/Campaign.ts",
+    "app/Models/CampaignSend.ts",
+    "app/Models/EmailList.ts",
+    "app/Models/EmailListSubscriber.ts",
+    "app/Models/SocialPost.ts",
+    "resources/components/Marketing/",
+    "resources/views/dashboard/marketing/"
+  ],
+  monitoring: [
+    "app/Actions/Monitoring/",
+    "app/Actions/TestErrorAction.ts",
+    "app/Models/Error.ts",
+    "functions/monitoring/",
+    "resources/views/dashboard/monitoring/",
+    "resources/views/dashboard/errors/"
+  ],
+  realtime: [
+    "app/Actions/Realtime/",
+    "app/Actions/Dashboard/Realtime/",
+    "app/Models/realtime/",
+    "app/Broadcasts/",
+    "functions/realtime/",
+    "resources/views/dashboard/realtime/"
+  ],
+  queue: [
+    "app/Actions/Queue/",
+    "app/Actions/Dashboard/Jobs/",
+    "app/Jobs/",
+    "app/Models/Job.ts",
+    "app/Models/FailedJob.ts",
+    "functions/jobs.ts",
+    "resources/views/dashboard/queue/",
+    "resources/views/dashboard/jobs/"
+  ]
+}, FEATURE_TABLES = {
+  cms: ["posts", "pages", "comments", "tags", "authors", "categories"],
+  commerce: [
+    "products",
+    "product_variants",
+    "product_units",
+    "manufacturers",
+    "orders",
+    "order_items",
+    "carts",
+    "cart_items",
+    "payments",
+    "payment_methods",
+    "payment_products",
+    "payment_transactions",
+    "customers",
+    "subscribers",
+    "subscriber_emails",
+    "subscriptions",
+    "gift_cards",
+    "coupons",
+    "transactions",
+    "reviews",
+    "drivers",
+    "delivery_routes",
+    "digital_deliveries",
+    "shipping_methods",
+    "shipping_rates",
+    "shipping_zones",
+    "license_keys",
+    "loyalty_points",
+    "loyalty_rewards",
+    "print_devices",
+    "receipts",
+    "tax_rates",
+    "waitlist_products",
+    "waitlist_restaurants"
+  ],
+  dashboard: [
+    "boards",
+    "board_columns",
+    "cards",
+    "card_labels",
+    "card_assignees",
+    "card_comments",
+    "labels",
+    "ci_run_states",
+    "ci_runner_samples",
+    "ci_runner_alert_states",
+    "requests",
+    "logs"
+  ],
+  marketing: [],
+  monitoring: ["errors"],
+  realtime: ["websockets"],
+  queue: ["jobs", "failed_jobs"]
+};
+export function migrationTable(filename) {
+  const inMatch = filename.match(/-in-([a-z0-9_]+)\.sql$/i);
+  if (inMatch)
+    return inMatch[1];
+  const createMatch = filename.match(/-create-([a-z0-9_]+)-table\.sql$/i);
+  if (createMatch)
+    return createMatch[1];
+  const alterMatch = filename.match(/-alter-([a-z0-9_]+)-/i);
+  if (alterMatch)
+    return alterMatch[1];
+  return null;
+}
+export function migrationFeature(filename) {
+  const table = migrationTable(filename);
+  if (!table)
+    return null;
+  for (const f of FEATURE_NAMES)
+    if (FEATURE_TABLES[f].includes(table))
+      return f;
+  return null;
+}
+export function featurePathsPresent(feature, root = projectPath()) {
+  return FEATURE_FILES[feature].filter((rel) => existsSync(`${root}/${rel}`));
+}
+export async function deleteFeatureFiles(feature, root = projectPath()) {
+  const removed = [];
+  for (const rel of FEATURE_FILES[feature]) {
+    const full = `${root}/${rel}`;
+    if (!existsSync(full))
+      continue;
+    await rm(full, { recursive: !0, force: !0 });
+    removed.push(rel);
+  }
+  return removed;
+}
+export async function copyFeatureFiles(feature, options = {}) {
+  const source = options.source ?? frameworkPath("defaults"), target = options.target ?? projectPath(), force = options.force === !0, copied = [], skipped = [];
+  for (const rel of FEATURE_FILES[feature]) {
+    const sourceFull = join(source, rel);
+    if (!existsSync(sourceFull)) {
+      skipped.push(rel);
+      continue;
+    }
+    const targetFull = join(target, rel);
+    if (existsSync(targetFull) && !force) {
+      skipped.push(rel);
+      continue;
+    }
+    await cp(sourceFull, targetFull, { recursive: !0, force });
+    copied.push(rel);
+  }
+  return { copied, skipped };
+}
+const FEATURE_DESCRIPTIONS = {
+  dashboard: "Admin SPA shell + Activity/Log/Request/Deployment/Notification dashboards.",
+  commerce: "Order/Cart/Product/Customer/Coupon/GiftCard/Shipping + storefront API.",
+  cms: "Post/Page/Author/Comment/Tag models + content edit dashboards.",
+  marketing: "/api/email/subscribe, /api/contact, Campaign/EmailList/SocialPost.",
+  monitoring: "Error model + error-tracking views and actions.",
+  realtime: "WebSocket broadcaster + Websocket model + realtime-stats actions.",
+  queue: "Job + FailedJob models + queue dashboard pages."
+}, STARTER_TEMPLATES = {
+  dashboard: `import type { DashboardConfig } from '@stacksjs/types'
+
+/**
+ * **Dashboard Configuration**
+ *
+ * Top-level feature gate plus per-section visibility toggles for the
+ * \`buddy dev --dashboard\` sidebar. Userland models in \`app/Models/\`
+ * always appear regardless of these flags.
+ */
+export default {
+  enabled: true,
+
+  sections: {
+    library: { enabled: true },
+    content: { enabled: true },
+    commerce: { enabled: true },
+    marketing: { enabled: true },
+    analytics: { enabled: true },
+    management: { enabled: true },
+    utilities: { enabled: true },
+    data: {
+      dashboard: { enabled: true },
+      activity: { enabled: true },
+      users: { enabled: true },
+      teams: { enabled: true },
+      subscribers: { enabled: true },
+      allModels: { enabled: true },
+    },
+  },
+} satisfies DashboardConfig
+`,
+  commerce: `import type { CommerceConfig } from '@stacksjs/types'
+
+/**
+ * **Commerce Configuration**
+ *
+ * Controls the commerce feature bundle (Order, Cart, Product, Customer,
+ * Coupon, GiftCard, Receipt, Shipping models + storefront API).
+ */
+export default {
+  enabled: true,
+
+  /** Default storefront currency (ISO 4217). */
+  currency: 'USD',
+
+  /** Default tax rate applied when a product/region rule doesn't override. */
+  defaultTaxRate: 0,
+} satisfies CommerceConfig
+`,
+  cms: `import type { CmsConfig } from '@stacksjs/types'
+
+/**
+ * **CMS Configuration**
+ *
+ * Controls the CMS feature bundle (Post, Page, Author, Comment, Tag,
+ * Category models + content-edit dashboards).
+ */
+export default {
+  enabled: true,
+} satisfies CmsConfig
+`,
+  marketing: `import type { MarketingConfig } from '@stacksjs/types'
+
+/**
+ * **Marketing Configuration**
+ *
+ * Controls the marketing feature bundle (\`/api/email/subscribe\`,
+ * \`/api/contact\`, Campaign / EmailList / SocialPost).
+ */
+export default {
+  enabled: true,
+} satisfies MarketingConfig
+`,
+  monitoring: `import type { MonitoringConfig } from '@stacksjs/types'
+
+/**
+ * **Monitoring Configuration**
+ *
+ * Controls the monitoring feature bundle (Error model + error-tracking
+ * views and actions).
+ */
+export default {
+  enabled: true,
+} satisfies MonitoringConfig
+`,
+  realtime: `import type { RealtimeConfig } from '@stacksjs/types'
+
+/**
+ * **Realtime Configuration**
+ *
+ * Controls the realtime feature bundle (WebSocket broadcaster + Websocket
+ * model + realtime-stats actions). The full set of options (driver, server,
+ * channels, etc.) is documented at @stacksjs/realtime; this starter
+ * template just flips the feature on.
+ */
+export default {
+  enabled: true,
+} satisfies RealtimeConfig
+`,
+  queue: `import type { QueueConfig } from '@stacksjs/types'
+
+/**
+ * **Queue Configuration**
+ *
+ * Controls the queue feature bundle (Job + FailedJob models + queue
+ * dashboard pages). The full set of options (drivers, connections, worker
+ * concurrency, etc.) is documented at @stacksjs/queue; this starter
+ * template ships the \`sync\` driver so jobs execute immediately in dev.
+ */
+export default {
+  enabled: true,
+
+  default: 'sync',
+
+  connections: {
+    sync: { driver: 'sync' },
+  },
+
+  failed: {
+    driver: 'database',
+    table: 'failed_jobs',
+  },
+} satisfies QueueConfig
+`
+};
+export async function setFeatureEnabled(feature, enabled, options) {
+  const path = options.root ? join(options.root, `config/${feature}.ts`) : projectPath(`config/${feature}.ts`), file = Bun.file(path);
+  if (!await file.exists()) {
+    if (!options.createIfMissing)
+      return "missing";
+    await Bun.write(path, STARTER_TEMPLATES[feature]);
+    return "created";
+  }
+  const src = await file.text(), enabledRegex = /(^|\{)(\s*)enabled\s*:\s*(true|false)(\s*,?)/m;
+  if (enabledRegex.test(src)) {
+    const replaced = src.replace(enabledRegex, (_full, anchor, ws, current, trailing) => {
+      if (current === String(enabled))
+        return `${anchor}${ws}enabled: ${current}${trailing}`;
+      return `${anchor}${ws}enabled: ${enabled}${trailing}`;
+    });
+    if (replaced === src)
+      return "unchanged";
+    await Bun.write(path, replaced);
+    return "flipped";
+  }
+  const insertRegex = /(export default\s*\{)/;
+  if (!insertRegex.test(src))
+    throw Error(`Could not locate \`export default {\` in ${path} \u2014 please add \`enabled: ${enabled}\` manually.`);
+  const next = src.replace(insertRegex, `$1
+  enabled: ${enabled},`);
+  await Bun.write(path, next);
+  return "flipped";
+}
+export async function uninstallAllFeatures(options = {}) {
+  const root = options.root ?? projectPath(), results = [];
+  for (const feature of FEATURE_NAMES) {
+    const configOutcome = await setFeatureEnabled(feature, !1, { createIfMissing: !1, root }), filesRemoved = await deleteFeatureFiles(feature, root);
+    results.push({ feature, configOutcome, filesRemoved });
+  }
+  return results;
+}
+function registerInstallPair(buddy, feature) {
+  const desc = FEATURE_DESCRIPTIONS[feature], configRel = `config/${feature}.ts`;
+  buddy.command(`${feature}:install`, `Activate the ${feature} feature bundle. ${desc}`).option("--force", `Overwrite any existing ${feature} files in the project (default skips existing paths so the install is idempotent).`).action(async (options) => {
+    try {
+      switch (await setFeatureEnabled(feature, !0, { createIfMissing: !0 })) {
+        case "created":
+          console.log(`\u2713 Created ${configRel} with '${feature}' enabled.`);
+          break;
+        case "flipped":
+          console.log(`\u2713 Enabled '${feature}' in ${configRel}.`);
+          break;
+        case "unchanged":
+          console.log(`\u2713 '${feature}' is already enabled in ${configRel}.`);
+          break;
+      }
+      const { copied } = await copyFeatureFiles(feature, { force: options.force === !0 });
+      if (copied.length > 0) {
+        console.log(`\u2713 Copied ${copied.length} stamped path(s) from framework defaults:`);
+        for (const path of copied)
+          console.log(`    - ${path}`);
+      } else if (featurePathsPresent(feature).length > 0)
+        console.log(`  \u2192 ${feature} scaffolding already in place \u2014 use --force to overwrite.`);
+      console.log(`  \u2192 next ./buddy dev will boot with ${feature} loaded.`);
+      process.exit(ExitCode.Success);
+    } catch (err) {
+      console.error(`\u2717 Failed to install ${feature}:`, err);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command(`${feature}:uninstall`, `Deactivate the ${feature} feature bundle.`).option("--keep-files", `Don't delete the ${feature} scaffolding (action/model/view files). Flip the flag only.`).action(async (options) => {
+    try {
+      switch (await setFeatureEnabled(feature, !1, { createIfMissing: !1 })) {
+        case "missing":
+          console.log(`\u2713 '${feature}' is already disabled (${configRel} is absent).`);
+          break;
+        case "flipped":
+          console.log(`\u2713 Disabled '${feature}' in ${configRel}. Custom config preserved.`);
+          break;
+        case "unchanged":
+          console.log(`\u2713 '${feature}' is already disabled in ${configRel}.`);
+          break;
+        case "created":
+          console.log(`\u2717 Unexpected create on uninstall for ${feature}; please re-run with --force or report this bug.`);
+          break;
+      }
+      if (options.keepFiles) {
+        const stillPresent = featurePathsPresent(feature);
+        if (stillPresent.length > 0)
+          console.log(`  \u2192 ${stillPresent.length} stamped path(s) preserved (--keep-files).`);
+      } else {
+        const removed = await deleteFeatureFiles(feature);
+        if (removed.length > 0) {
+          console.log(`\u2713 Removed ${removed.length} stamped path(s):`);
+          for (const path of removed)
+            console.log(`    - ${path}`);
+        }
+      }
+      console.log(`  \u2192 next ./buddy dev will boot without ${feature}.`);
+      process.exit(ExitCode.Success);
+    } catch (err) {
+      console.error(`\u2717 Failed to uninstall ${feature}:`, err);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+}
+export function features(buddy) {
+  for (const feature of FEATURE_NAMES)
+    registerInstallPair(buddy, feature);
+}