@stacksjs/buddy 0.70.88 → 0.70.90

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/extension.d.ts

@@ -0,0 +1,8 @@
+import type { CLI } from '@stacksjs/types';
+/**
+ * `buddy extension:*` — build & package MV3 browser extensions from the
+ * project's `config/extension.ts` (see @stacksjs/browser-extension). Zero
+ * per-project build scripts: the framework owns the manifest, bundling, and
+ * packaging.
+ */
+export declare function extension(buddy: CLI): void;

package/dist/commands/extension.js

@@ -0,0 +1,78 @@
+import process from "node:process";
+import { log } from "@stacksjs/cli";
+export function extension(buddy) {
+  const load = async () => {
+    const { loadExtensionConfig } = await import("@stacksjs/browser-extension"), config = await loadExtensionConfig(process.cwd());
+    if (!config) {
+      log.error("No extension config found. Create `config/extension.ts` exporting `defineExtension({ \u2026 })`.");
+      process.exit(1);
+    }
+    const pkg = await Bun.file(`${process.cwd()}/package.json`).json().catch(() => ({}));
+    return { config, version: pkg.version ?? "0.0.0" };
+  };
+  buddy.command("extension:build", "Build the browser extension (Chrome + Firefox) from config/extension.ts").option("--target <target>", "Build a single target (chrome | firefox); omit to build all").option("--version <version>", "Override the extension version (defaults to package.json)").action(async (options) => {
+    const { buildExtension, buildAllTargets } = await import("@stacksjs/browser-extension"), { config, version } = await load(), v = options.version ?? version;
+    if (options.target) {
+      const { outdir } = await buildExtension(config, { target: options.target, version: v });
+      log.success(`Built ${config.name} ${v} (${options.target}) \u2192 ${outdir}`);
+    } else {
+      await buildAllTargets(config, { version: v });
+      log.success(`Built ${config.name} ${v} for ${(config.targets ?? ["chrome", "firefox"]).join(", ")}`);
+    }
+  });
+  buddy.command("extension:init", "Scaffold a browser extension (config/extension.ts + starter background/content/pages)").option("--name <name>", "Extension display name").action(async (options) => {
+    const { existsSync } = await import("node:fs"), { mkdir, writeFile } = await import("node:fs/promises"), { dirname, join } = await import("node:path"), cwd = process.cwd(), name = options.name ?? "My Extension", write = async (rel, content) => {
+      const abs = join(cwd, rel);
+      if (existsSync(abs)) {
+        log.info(`skip (exists): ${rel}`);
+        return;
+      }
+      await mkdir(dirname(abs), { recursive: !0 });
+      await writeFile(abs, content);
+      log.success(`created ${rel}`);
+    };
+    await write("config/extension.ts", `import { defineExtension } from '@stacksjs/browser-extension'
+
+export default defineExtension({
+  name: ${JSON.stringify(name)},
+  description: 'A browser extension built with Stacks.',
+  targets: ['chrome', 'firefox'],
+  background: 'src/background/index.ts',
+  content: [
+    { entry: 'src/content/index.ts', matches: ['<all_urls>'], runAt: 'document_start' },
+  ],
+  pages: {
+    popup: { template: 'pages/popup.stx', script: 'src/ui/popup.ts' },
+  },
+  icons: { 16: 'icons/icon-16.png', 48: 'icons/icon-48.png', 128: 'icons/icon-128.png' },
+  public: 'public',
+  manifest: {
+    permissions: ['storage', 'tabs'],
+  },
+})
+`);
+    await write("src/background/index.ts", `// Background service worker (MV3).
+console.log('[${name}] background ready')
+`);
+    await write("src/content/index.ts", `// Content script \u2014 runs on matched pages.
+console.log('[${name}] content script loaded')
+`);
+    await write("src/ui/popup.ts", `// Popup script.
+console.log('[${name}] popup')
+`);
+    await write("pages/popup.stx", `<div class="popup">
+  <h1>${name}</h1>
+  <p>Edit pages/popup.stx to build your popup.</p>
+  <script src="/popup.js"></script>
+</div>
+`);
+    log.info("Next: add icons under public/icons, then `buddy extension:build`.");
+  });
+  buddy.command("extension:package", "Build + zip the browser extension into store-ready archives").option("--target <target>", "Package a single target (chrome | firefox); omit to package all").option("--version <version>", "Override the extension version (defaults to package.json)").action(async (options) => {
+    const { packageExtension } = await import("@stacksjs/browser-extension"), { config, version } = await load(), v = options.version ?? version, targets = options.target ? [options.target] : config.targets ?? ["chrome", "firefox"];
+    for (const target of targets) {
+      const out = await packageExtension(config, { target, version: v });
+      log.success(`Packaged ${config.name} (${target}) \u2192 ${out}`);
+    }
+  });
+}

package/dist/commands/features.d.ts

@@ -0,0 +1,180 @@
+import type { CLI } from '@stacksjs/types';
+/**
+ * Parse a migration filename like `0000000045-create-posts-table.sql` or
+ * `0000000085-alter-posts-author_id.sql` to extract the table name it
+ * acts on. Returns `null` for filenames that don't match the
+ * recognised `create-<table>-table` / `alter-<table>-` shapes — those
+ * pass through the gate unchanged.
+ *
+ * Index migrations (`create-<table>_<col>_unique-index-in-<table>.sql`)
+ * use the trailing `-in-<table>.sql` segment as the source of truth
+ * since the leading segment includes the index name. The other
+ * forms read the table from the segment immediately after the verb.
+ */
+export declare function migrationTable(filename: string): string | null;
+/**
+ * Returns the feature that owns the given migration filename, or `null`
+ * if the migration isn't claimed by any feature (in which case it
+ * always runs). Used by the migration runner's gating pass.
+ */
+export declare function migrationFeature(filename: string): FeatureName | null;
+/**
+ * Returns the subset of a feature's manifest paths that currently exist
+ * on disk under `root` (defaults to `projectPath()`). Used by both the
+ * uninstall delete and the doctor orphan check.
+ */
+export declare function featurePathsPresent(feature: FeatureName, root?: string): string[];
+/**
+ * Recursively delete every file/dir listed in the feature's manifest under
+ * `root` (defaults to `projectPath()`). Missing entries are skipped
+ * silently — the operation is safe to re-run. Returns the list of paths
+ * actually removed so the caller can print a useful summary.
+ */
+export declare function deleteFeatureFiles(feature: FeatureName, root?: string): Promise<string[]>;
+/**
+ * Copy every path listed in the feature's manifest from the framework
+ * defaults tree (`storage/framework/defaults/<path>`) into the project
+ * root (`<project>/<path>`). Missing source entries are skipped — not
+ * every feature owns every manifest slot (e.g. `cms` doesn't ship a
+ * `resources/components/Dashboard/Commerce/` dir, so that entry is
+ * absent from its source). Existing target paths are also skipped by
+ * default so re-running install on an existing project is idempotent.
+ *
+ * Returns the list of paths actually copied. See stacksjs/stacks#1854.
+ */
+export declare function copyFeatureFiles(feature: FeatureName, options?: CopyFeatureFilesOptions): Promise<{ copied: string[], skipped: string[] }>;
+/**
+ * Flip the top-level `enabled` field in `config/<feature>.ts` to the
+ * desired value. Returns:
+ *
+ *   - 'created'   — file did not exist and we scaffolded it (install only)
+ *   - 'flipped'   — file existed; `enabled` was on the opposite value
+ *   - 'unchanged' — file existed; `enabled` already matched
+ *   - 'missing'   — file did not exist and `createIfMissing` was false
+ *                   (uninstall path: nothing to do, feature is already off)
+ *
+ * Pass `options.root` to target a project directory other than the
+ * caller's working tree — `./buddy new --minimal` uses this to disable
+ * features in the freshly-cloned project path before the user has cd'd
+ * into it.
+ */
+export declare function setFeatureEnabled(feature: FeatureName, enabled: boolean, options: { createIfMissing: boolean, root?: string }): Promise<SetFeatureEnabledOutcome>;
+/**
+ * Disable every feature in `FEATURE_NAMES` at once — flips
+ * `config/<feature>.ts` enabled flags to `false` and removes the
+ * stamped scaffolding under the project root.
+ *
+ * Used by `./buddy new --minimal` to turn the kitchen-sink template
+ * `@stacksjs/gitit` clones into a bare-bones starter. Individual
+ * `<feature>:install` commands re-enable + re-stamp on demand.
+ *
+ * Pass `root` to target a project directory other than `projectPath()`;
+ * the create command uses this because `./buddy new` runs from the
+ * user's cwd while the freshly-cloned project lives at `<cwd>/<name>`.
+ *
+ * Safe to re-run — both halves of each per-feature step are idempotent.
+ */
+export declare function uninstallAllFeatures(options?: { root?: string }): Promise<UninstallAllFeaturesResult[]>;
+export declare function features(buddy: CLI): void;
+/**
+ * Feature install / uninstall commands.
+ *
+ * Each framework feature bundle (dashboard, commerce, cms, marketing,
+ * monitoring, realtime, queue) lives in its own `config/<feature>.ts`
+ * file. Running `./buddy <feature>:install` flips that file's top-level
+ * `enabled` to `true` (scaffolding the file from a starter template if it's
+ * missing). `./buddy <feature>:uninstall` flips the flag back to `false`
+ * AND removes the feature's stamped action/model/view files from the
+ * project (pass `--keep-files` to preserve them); the config file itself
+ * is preserved so any custom driver/credential settings survive a future
+ * reinstall.
+ *
+ * The framework loaders (`orm/index.ts` eager-load, `defaults/bootstrap.ts`
+ * route registration, action prefetch) consult `feature(name)` at boot and
+ * skip anything whose flag is off — so an app with only `auth` activated
+ * never pays the cost of importing 70+ Commerce models or registering
+ * hundreds of dashboard routes it doesn't use.
+ *
+ * Auth is intentionally not in this list: it has its own scaffolding
+ * pipeline (`buddy auth:setup`) which handles migrations + personal-access
+ * client setup beyond a simple `enabled` flip.
+ *
+ * Mirrors Laravel's `php artisan passport:install` / `horizon:install`
+ * pattern: features are inert dead code on disk until installed.
+ */
+export declare const FEATURE_NAMES: readonly ['dashboard', 'commerce', 'cms', 'marketing', 'monitoring', 'realtime', 'queue'];
+/**
+ * Per-feature stamped file/directory manifest. Paths are relative to the
+ * project root and mirror the layout that `./buddy new` lays down. Entries
+ * ending in `/` are directory trees (recursive remove on uninstall); bare
+ * paths are single files.
+ *
+ * Manifests intentionally overlap where features share scaffolding —
+ * `dashboard` claims the umbrella `app/Actions/Dashboard/` even though
+ * `app/Actions/Dashboard/Content/` is also claimed by `cms`. Both the
+ * uninstall delete and the doctor orphan check are idempotent
+ * (already-gone paths are skipped silently), so the overlap is safe.
+ *
+ * Adding a new file to one of these directories does **not** require a
+ * manifest update — directory entries are recursive. Only add an entry
+ * when a feature introduces a new top-level path the framework didn't
+ * already claim.
+ * @defaultValue
+ * ```ts
+ * {
+ *   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/', ]
+ * }
+ * ```
+ */
+export declare const FEATURE_FILES: Record<FeatureName, readonly string[]>;
+/**
+ * Per-feature database table ownership (stacksjs/stacks#1854).
+ *
+ * Stacks generates SQL migrations from model files, so each feature's
+ * tables map 1:1 with the models in its `FEATURE_FILES.app/Models/...`
+ * entries. Listed here explicitly rather than derived at runtime so
+ * additions are visible in a single grep-able place and the migration
+ * gate doesn't depend on filesystem scanning at boot.
+ *
+ * The migration runner consults this when `config.<feature>.enabled =
+ * false`: matching `*-create-<table>-table.sql` (and `*-alter-<table>-*.sql`)
+ * files get hidden for the duration of the run, so a project that
+ * never installed CMS doesn't materialize `posts`, `pages`,
+ * `comments`, etc. on `./buddy migrate`.
+ *
+ * Tables on this list are scoped to a single feature. Tables shared
+ * across features (none today, but `categories` could end up here)
+ * should stay out of the manifest until that's resolved — the runner
+ * defaults to "run unless owned by a disabled feature".
+ * @defaultValue
+ * ```ts
+ * {
+ *   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 declare const FEATURE_TABLES: Record<FeatureName, readonly string[]>;
+export declare interface CopyFeatureFilesOptions {
+  force?: boolean
+  source?: string
+  target?: string
+}
+export declare interface UninstallAllFeaturesResult {
+  feature: FeatureName
+  configOutcome: SetFeatureEnabledOutcome
+  filesRemoved: string[]
+}
+export type FeatureName = (typeof FEATURE_NAMES)[number];
+export type SetFeatureEnabledOutcome = 'created' | 'flipped' | 'unchanged' | 'missing';