@stacksjs/buddy 0.70.45 → 0.70.54

package/dist/src/commands/cd.d.ts

@@ -0,0 +1,20 @@
+import type { CLI } from '@stacksjs/types';
+/**
+ * `buddy cd <name>` — resolve the absolute path of a Stacks project by name.
+ *
+ * A child process can't mutate its parent shell's cwd, so this command
+ * prints the resolved path to stdout rather than calling `chdir()`. Users
+ * who want true `cd` behavior add a shell wrapper to their rc:
+ *
+ *   bcd() { eval "$(buddy cd "$1" --eval)"; }
+ *
+ * Then `bcd my-project` actually changes the shell's directory.
+ *
+ * The underlying scan (`findStacksProjects`) excludes `~/Documents`,
+ * `~/Library`, `~/Pictures`, `~/.Trash` by default. Users with projects
+ * outside `~/` can point the scan at a specific root via `--root <dir>`
+ * or the `STACKS_PROJECTS_ROOT` env var.
+ *
+ * stacksjs/stacks#527.
+ */
+export declare function cd(buddy: CLI): void;

package/dist/src/commands/deploy.d.ts

@@ -1,2 +1,105 @@
 import type { CLI } from '@stacksjs/types';
+/**
+ * Resolve (and decrypt) the deploy-target's environment file into a flat
+ * key/value map, so its values can be shipped to the server as each site's
+ * systemd `.env` content.
+ *
+ * ts-cloud's `buildSiteDeployScript` treats `site.env` as the COMPLETE
+ * content of the deployed `.env` — it doesn't read or merge in anything
+ * from the packaged release tarball (ts-cloud is a generic deploy tool; it
+ * has no idea `.env.production`/dotenvx encryption exist, that's entirely a
+ * Stacks convention). Left unaddressed, every Hetzner site deploys with
+ * ONLY whatever's in that site's own `env` override (often nothing at all)
+ * — confirmed against a real deploy (stacksjs/status#1 Phase 9): the `main`
+ * site (no `env` override) came up logging "loaded 0 variables from .env",
+ * and `api` (which only declares `{ HOST, APP_ENV }` to force the loopback
+ * bind) came up with just those 2 keys and none of its real production
+ * config, failing config validation on the still-`encrypted:...` APP_ENV
+ * ciphertext it never had a chance to decrypt (no DOTENV_PRIVATE_KEY_* in
+ * that 2-key set).
+ *
+ * Returns `{}` (not an error) when the file doesn't exist or fails to
+ * parse — an app with no `.env.production` yet shouldn't block deploying
+ * with whatever `site.env` overrides it does have.
+ */
+export declare function resolveDeployEnvValues(environment: 'production' | 'staging' | 'development'): Promise<Record<string, string>>;
+/**
+ * Merge the deploy-target's resolved env values underneath each site's own
+ * explicit `env` overrides, stripping a general `PORT` when the site
+ * declares its own `port` (the generated systemd unit already sets
+ * `Environment=PORT=${site.port}` — see buildSiteDeployScript in ts-cloud —
+ * so a leftover PORT in the shipped `.env` would otherwise silently win
+ * over it once the app's own dotenv loading applies file values on top of
+ * the process env).
+ */
+export declare function mergeSiteDeployEnv(sites: Record<string, any>, resolvedDeployEnv: Record<string, string>): Record<string, any>;
+/**
+ * Make the site model environment-aware. For a non-production environment that
+ * declares a `domainPrefix` (staging → `staging`, development → `dev`), every
+ * site's public domain becomes `<prefix>.<domain>`, and URL values that point at
+ * those hosts (APP_URL, OAuth redirect URLs, redirect targets, …) are rewritten
+ * to match — so one config drives prod + staging + dev from their own branches
+ * without duplicating site blocks. Only `//<host>` URL occurrences are rewritten;
+ * bare `user@host` (e.g. mail identities) is left alone. Production is untouched.
+ */
+export declare function applyEnvironmentToSites(sites: Record<string, any>, environment: string, config: any): Record<string, any>;
+/**
+ * Loopback-bound server-app sites (e.g. the `api` site: env.HOST=127.0.0.1,
+ * reached only through `buddy serve`'s same-origin /api proxy on :3000 —
+ * stacksjs/stacks#1950) must NOT have their port opened to the internet.
+ * ts-cloud's Hetzner provisioning opens EVERY numeric `site.port` to
+ * 0.0.0.0/0 + ::/0 (collectUpstreamPorts → buildHetznerFirewallRules), which
+ * would leave only the process bind between the public internet and the full
+ * bun-router API. Hand the provision step a copy of the config with those
+ * ports stripped — the unmodified config still drives deployAllComputeSites,
+ * so the systemd unit (ExecStart, Environment=PORT) is unaffected.
+ *
+ * Domain-less sites only: a loopback site WITH a domain feeds the rpx
+ * gateway's route table (which proxies to 127.0.0.1:port on-box), so its
+ * port declaration is left alone.
+ */
+export declare function scrubLoopbackSitePortsForFirewall(tsCloudConfig: any): any;
+/**
+ * Everything is MERGE-based so a shared mail server keeps every other tenant's
+ * domains, keys, users, and forward rules untouched. Best-effort — a hiccup is
+ * logged, never fails the release. Returns what the DNS step needs (mail host +
+ * DKIM public key), or null when there is nothing to reconcile / it failed.
+ */
+export declare function provisionMailTenant(ip: string, logger: typeof log): Promise<MailTenantResult | null>;
+/**
+ * Publish the mail DNS for a hosted domain via Porkbun (idempotent delete+create
+ * per record): MX → the mail host, SPF authorizing the box IP, the domain's DKIM
+ * public key at `mail._domainkey`, and a DMARC policy. Best-effort — logged, not
+ * thrown. No-op without Porkbun credentials (the records are printed to add by
+ * hand). MX targets the shared mail host (`mail.stacksjs.com`), so no per-domain
+ * mail A record or extra TLS SAN is needed.
+ */
+export declare function reconcileMailDns(res: MailTenantResult, ip: string, logger: typeof log): Promise<void>;
 export declare function deploy(buddy: CLI): void;
+/**
+ * Use console.log for clean output without timestamps
+ * @defaultValue
+ * ```ts
+ * {
+ *   info: (...args: any[]) => unknown,
+ *   success: (...args: any[]) => unknown,
+ *   warn: (...args: any[]) => unknown,
+ *   error: (...args: any[]) => unknown,
+ *   debug: (...args: any[]) => unknown
+ * }
+ * ```
+ */
+declare const log: {
+  info: (...args: any[]) => unknown;
+  success: (...args: any[]) => unknown;
+  warn: (...args: any[]) => unknown;
+  error: (...args: any[]) => unknown;
+  debug: (...args: any[]) => unknown
+};
+/** What a mail-tenant reconcile resolved + provisioned, for the DNS step. */
+export declare interface MailTenantResult {
+  domain: string
+  mailHost: string
+  dkimPubB64?: string
+  created: Array<{ address: string, password: string }>
+}

package/dist/src/commands/dev.d.ts

@@ -1,3 +1,10 @@
 import type { CLI, DevOptions } from '@stacksjs/types';
 export declare function dev(buddy: CLI): void;
 export declare function startDevelopmentServer(_options: DevOptions, _startTime?: number): Promise<void>;
+declare type DevelopmentRpx = typeof import('@stacksjs/rpx');
+type RpxProxySpec = {
+  id: string
+  from: string
+  to: string
+  pathRewrites?: Array<{ from: string, to: string, stripPrefix?: boolean }>
+}

package/dist/src/commands/features.d.ts

@@ -0,0 +1,172 @@
+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.
+ */
+export declare const FEATURE_FILES: {
+  cms: readonly ['app/Actions/Cms/', 'app/Actions/Dashboard/Content/', 'app/Models/Content/', 'app/Models/Tag.ts', 'app/Models/Comment.ts', 'resources/views/dashboard/content/'];
+  commerce: readonly ['app/Actions/Commerce/', 'app/Actions/Dashboard/Commerce/', 'app/Models/commerce/', 'resources/components/Dashboard/Commerce/', 'resources/views/dashboard/commerce/'];
+  dashboard: readonly ['app/Actions/Dashboard/', 'resources/components/Dashboard/', 'resources/views/dashboard/', 'routes/dashboard.ts', 'routes/dashboard-api.ts'];
+  marketing: readonly ['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: readonly ['app/Actions/Monitoring/', 'app/Actions/TestErrorAction.ts', 'app/Models/Error.ts', 'functions/monitoring/', 'resources/views/dashboard/monitoring/', 'resources/views/dashboard/errors/'];
+  realtime: readonly ['app/Actions/Realtime/', 'app/Actions/Dashboard/Realtime/', 'app/Models/realtime/', 'app/Broadcasts/', 'functions/realtime/', 'resources/views/dashboard/realtime/'];
+  queue: readonly ['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/']
+};
+/**
+ * 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".
+ */
+export declare const FEATURE_TABLES: {
+  cms: readonly ['posts', 'pages', 'comments', 'tags', 'authors', 'categories'];
+  commerce: readonly ['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: readonly ['boards', 'board_columns', 'cards', 'card_labels', 'card_assignees', 'card_comments', 'labels', 'ci_run_states', 'ci_runner_samples', 'ci_runner_alert_states', 'requests', 'logs'];
+  marketing: never[];
+  monitoring: readonly ['errors'];
+  realtime: readonly ['websockets'];
+  queue: readonly ['jobs', 'failed_jobs']
+};
+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';

package/dist/src/commands/index.d.ts

@@ -1,6 +1,7 @@
 export * from './about';
 export * from './auth';
 export * from './build';
+export * from './cd';
 export * from './changelog';
 export * from './clean';
 export * from './cloud';
@@ -16,6 +17,7 @@ export * from './doctor';
 export * from './domains';
 export * from './email';
 export * from './env';
+export * from './features';
 export * from './fresh';
 export * from './generate';
 export * from './http';
@@ -26,6 +28,7 @@ export * from './list';
 export * from './mail';
 export * from './make';
 export * from './migrate';
+export * from './migrate-project';
 export * from './outdated';
 export * from './phone';
 export * from './ports';
@@ -39,6 +42,7 @@ export * from './saas';
 export * from './schedule';
 export * from './search';
 export * from './seed';
+export * from './serve';
 export * from './setup';
 export * from './sms';
 export * from './telemetry';

package/dist/src/commands/migrate-project.d.ts

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

package/dist/src/commands/serve.d.ts

@@ -0,0 +1,25 @@
+import type { CLI } from '@stacksjs/types';
+/**` requests (and any non-GET/HEAD verb) are
+ * reverse-proxied to the API process — mirroring the dev views server — so
+ * scaffolded `fetch('/api/...')` calls behave identically in production
+ * (stacksjs/stacks#1950). The API runs as a separate process
+ * (core/actions/src/serve/api.ts), deployed as a second systemd service via
+ * the `api` site in config/cloud.ts. Override `API_URL` when the API lives
+ * on another host, or `PORT_API` when only the port differs.
+ *
+ * This is the entry the Hetzner deploy runs as a systemd service
+ * (`bun storage/framework/core/buddy/src/cli.ts serve`).
+ */
+export declare function serve(buddy: CLI): void;
+/**
+ * `buddy serve:api` — boot the production API server (bun-router routes).
+ *
+ * The twin of `buddy serve`: where that serves the STX frontend, this runs the
+ * loopback API the frontend proxies `/api` + non-GET requests to. The entry
+ * (`@stacksjs/actions/serve/api`) is resolved through the module graph, so it
+ * works whether the framework is vendored at `storage/framework/core` OR only
+ * installed under `node_modules/@stacksjs/actions`. This keeps deployments from
+ * having to hardcode a `storage/framework/core/...` path in their `start`
+ * command — `./buddy serve:api` resolves the framework wherever it lives.
+ */
+export declare function serveApi(buddy: CLI): void;

package/dist/src/migrators/index.d.ts

@@ -0,0 +1,12 @@
+import type { Driver, MigrationReport, MigrateProjectRequest } from './types';
+export type { MigrateProjectRequest, MigrationReport, ReportEntry } from './types';
+export declare function runMigrator(req: MigrateProjectRequest): Promise<MigrationReport>;
+/**
+ * Render a migration report as a Markdown checklist suitable for
+ * writing to `MIGRATION_REPORT.md` in the target project.
+ */
+export declare function renderReport(report: MigrationReport): string;
+export declare const DRIVERS: {
+  laravel: unknown;
+  rails: unknown
+};

package/dist/src/migrators/laravel/index.d.ts

@@ -0,0 +1,2 @@
+import type { Driver } from '../types';
+export declare const laravelDriver: Driver;

package/dist/src/migrators/laravel/migrations.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Parse a Laravel migration file. Returns `null` when no
+ * `Schema::create(...)` block is found (e.g. drop migrations,
+ * data-only migrations, alter-table migrations — those are deferred
+ * to a separate emitter once the create paths land).
+ */
+export declare function parseLaravelMigration(source: string): ParsedMigration | null;
+/**
+ * Lift Laravel's `YYYY_MM_DD_HHMMSS_create_<table>_table.php` filename
+ * into the `0000000NNN-create-<table>-table.sql` form the Stacks
+ * migration runner expects. The numeric prefix preserves ordering
+ * across the existing Stacks migrations directory — callers should
+ * pass a `sequence` that starts above whatever's already there.
+ */
+export declare function laravelFilenameToStacks(filename: string, sequence: number, table: string): string;
+/**
+ * Laravel migration → Stacks SQL translator.
+ *
+ * Laravel migrations are PHP classes whose `up()` calls
+ * `Schema::create(table, fn (Blueprint $t) => { ... })`. We don't
+ * parse arbitrary PHP — we recognise the common Blueprint DSL by
+ * regex and emit a CREATE TABLE statement that the Stacks runner can
+ * consume.
+ *
+ * Strategy:
+ *   1. Find the `Schema::create('table', function (...) { BODY })` block.
+ *   2. Tokenise BODY line-by-line, each line a `$table->method(args)->modifier()...;` chain.
+ *   3. Map the leading method to a SQLite column type.
+ *   4. Translate modifiers (`->nullable()`, `->unique()`, `->default(...)`, `->index()`)
+ *      into column constraints (or post-table CREATE INDEX statements).
+ *
+ * Anything unrecognised gets logged in the report as `// SKIPPED:` and
+ * the user can hand-port it.
+ */
+export declare interface ParsedMigration {
+  table: string
+  sql: string
+  skipped: string[]
+}
+declare interface Column {
+  name: string
+  type: string
+  nullable: boolean
+  unique: boolean
+  primaryKey: boolean
+  autoIncrement: boolean
+  defaultValue: string | null
+  index: boolean
+}
+declare type ParsedLine = | { kind: 'columns', columns: Column[], indexes?: { name: string, columns: string[], unique: boolean }[] }
+  | { kind: 'index', index: { name: string, columns: string[], unique: boolean } }
+  | { kind: 'skip' }

package/dist/src/migrators/laravel/models.d.ts

@@ -0,0 +1,34 @@
+export declare function parseLaravelModel(source: string): ParsedModel | null;
+/**
+ * Laravel Eloquent → Stacks `defineModel({})` translator.
+ *
+ * Eloquent models are PHP classes that lean on convention plus a few
+ * `protected $foo = ...` properties to describe schema and behaviour.
+ * We pull the bits we need by regex:
+ *
+ *   - class name                 → model `name`
+ *   - protected $table           → `table`
+ *   - protected $fillable        → which attributes are `fillable: true`
+ *   - protected $casts           → which attributes get a typed
+ *                                  validation rule
+ *   - hasMany/hasOne/belongsTo   → relationship hints in the report
+ *
+ * Anything else (scopes, accessors, mutators, observers) gets dropped
+ * with a note in the migration report. The user can re-add them by
+ * hand from the Stacks docs.
+ */
+export declare interface ParsedModel {
+  className: string
+  table: string
+  fillable: string[]
+  hidden: string[]
+  casts: Record<string, string>
+  relationships: ParsedRelationship[]
+  tsSource: string
+  notes: string[]
+}
+export declare interface ParsedRelationship {
+  name: string
+  kind: 'belongsTo' | 'hasMany' | 'hasOne' | 'belongsToMany'
+  target: string
+}

package/dist/src/migrators/rails/index.d.ts

@@ -0,0 +1,2 @@
+import type { Driver } from '../types';
+export declare const railsDriver: Driver;

package/dist/src/migrators/types.d.ts

@@ -0,0 +1,44 @@
+export declare interface MigrateProjectRequest {
+  source: string
+  target: string
+  from: SourceFramework
+  dryRun?: boolean
+}
+/**
+ * A single output produced (or attempted) by a driver. Drivers append
+ * one `ReportEntry` per source file they touch so the report reads
+ * like a checklist of what was translated.
+ */
+export declare interface ReportEntry {
+  source: string
+  target: string
+  status: 'translated' | 'copied' | 'skipped' | 'failed'
+  note?: string
+}
+export declare interface MigrationReport {
+  source: string
+  target: string
+  from: SourceFramework
+  startedAt: string
+  finishedAt: string
+  entries: ReportEntry[]
+}
+export declare interface Driver {
+  readonly name: SourceFramework
+  migrate: (req: MigrateProjectRequest) => Promise<ReportEntry[]>
+}
+/**
+ * Shared types for the `./buddy migrate:project` migrators (Laravel,
+ * Rails, …). Each driver consumes a source-project root and emits
+ * Stacks-shaped files under a target root, returning a structured
+ * report so the CLI can show the user what landed and what got
+ * skipped.
+ *
+ * The migration is intentionally best-effort. The drivers prioritise
+ * the high-value 80% (schema → migrations, models, env) and surface
+ * unrecognised constructs as `skipped` entries rather than throwing —
+ * a partial port the user can clean up beats a full failure mid-run.
+ *
+ * stacksjs/stacks#1241.
+ */
+export type SourceFramework = 'laravel' | 'rails';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/buddy",
   "type": "module",
-  "version": "0.70.45",
+  "version": "0.70.54",
   "description": "Meet Buddy. The Stacks runtime.",
   "author": "Chris Breuer",
   "contributors": [
@@ -96,13 +96,14 @@
     "@stacksjs/collections": "^0.70.23",
     "@stacksjs/config": "^0.70.23",
     "@stacksjs/database": "^0.70.23",
-    "@stacksjs/desktop": "^0.70.23",
+    "@stacksjs/desktop": "^0.2.82",
     "@stacksjs/dns": "^0.70.23",
     "@stacksjs/email": "^0.70.23",
     "@stacksjs/enums": "^0.70.23",
     "@stacksjs/error-handling": "^0.70.23",
     "@stacksjs/events": "^0.70.23",
     "@stacksjs/git": "^0.70.23",
+    "@stacksjs/gitit": "^0.2.5",
     "@stacksjs/health": "^0.70.23",
     "@stacksjs/dnsx": "^0.2.3",
     "@stacksjs/httx": "^0.1.10",
@@ -115,7 +116,7 @@
     "@stacksjs/payments": "^0.70.23",
     "@stacksjs/realtime": "^0.70.23",
     "@stacksjs/router": "^0.70.23",
-    "@stacksjs/rpx": "^0.11.2",
+    "@stacksjs/rpx": "^0.11.13",
     "@stacksjs/search-engine": "^0.70.23",
     "@stacksjs/security": "^0.70.23",
     "@stacksjs/server": "^0.70.23",
@@ -127,7 +128,7 @@
     "@stacksjs/ui": "^0.70.23",
     "@stacksjs/utils": "^0.70.23",
     "@stacksjs/validation": "^0.70.23",
-    "@stacksjs/ts-cloud": "^0.2.15"
+    "@stacksjs/ts-cloud": "^0.7.12"
   },
   "devDependencies": {
     "better-dx": "^0.2.12"

package/dist/package.json

@@ -1 +0,0 @@
-