@everystack/cli 0.4.6 → 0.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/cli",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "CLI and OTA updates for Expo apps on everystack",
   "license": "AGPL-3.0-only",
   "author": "Scalable Technology, Inc. <licensing@scalable.technology>",
@@ -82,7 +82,7 @@
     "structured-headers": "1.0.1",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
-    "@everystack/model": "0.4.1"
+    "@everystack/model": "0.4.2"
   },
   "peerDependencies": {
     "@everystack/server": ">=0.1.0",

package/src/cli/commands/db-apply.ts

@@ -35,6 +35,7 @@ import { resolveDbSource, createUrlRunner, connectingVia, type DbSource } from '
 import { resolveConfig, opsFunction } from '../config.js';
 import { invokeAction, lambdaQueryRunner } from '../aws.js';
 import { executeApplyPlan, type ApplyPlanResult } from '../apply-execute.js';
+import { pgDumpPreflightError } from './db-backup.js';
 import { step, success, fail, info, warn } from '../output.js';
 
 // The apply core lives in apply-execute.ts (shared with the ops Lambda's
@@ -116,6 +117,19 @@ async function applyPlanViaStage(
 
   info(`plan ${planHash(plan).slice(0, 12)}: ${plan.fromFingerprint.slice(0, 12)} → ${plan.toFingerprint.slice(0, 12)} (${plan.executable} statement(s)${plan.destructive ? `, ${plan.destructive} destructive` : ''})`);
 
+  // A destructive staged apply snapshots via db:backup INSIDE the Lambda, before the DDL. Preflight
+  // that capability HERE so a missing/incompatible pg_dump layer fails fast with the install remedy —
+  // not deep in the ceremony after the authority check, the way it once surfaced mid-apply.
+  if (plan.destructive > 0) {
+    step('Preflighting the pg_dump layer (the destructive apply snapshots before the DDL)...');
+    const probe: any = await invokeAction(region, fn, 'db:backup:probe', {}).catch((err: any) => ({ error: err?.message ?? String(err) }));
+    const remedy = pgDumpPreflightError(probe);
+    if (remedy) {
+      fail(`Cannot take the pre-apply snapshot — the destructive plan was NOT applied.\n${remedy}`);
+      process.exit(1);
+    }
+  }
+
   try {
     // Descent — the fast-forward rule needs the git checkout, so the CLI
     // decides it (the Lambda has no checkout). Read the stage's state read-only

package/src/cli/commands/db-backup.ts

@@ -48,7 +48,7 @@ export async function dbBackupProbeCommand(flags: Record<string, string>): Promi
 
   if (result?.error) {
     fail(result.error);
-    info('Build + publish the layer with scripts/build-pgdump-layer.sh, export PGDUMP_LAYER_ARN, then redeploy.');
+    info('Install @everystack/pg-tools and redeploy — the layer attaches automatically. For a bring-your-own layer, pass pgDumpLayer(..., { layerArn }) in sst.config.ts.');
     process.exit(1);
   }
 
@@ -71,7 +71,7 @@ export async function dbBackupProbeCommand(flags: Record<string, string>): Promi
 export function pgDumpPreflightError(probe: any): string | null {
   if (!probe || probe.error) {
     const detail = probe?.error ?? 'the pg_dump layer probe returned no result';
-    return `${detail}\nBuild + publish the layer with scripts/build-pgdump-layer.sh, export PGDUMP_LAYER_ARN, then redeploy.`;
+    return `${detail}\nInstall @everystack/pg-tools and redeploy — the layer attaches automatically. For a bring-your-own layer, pass pgDumpLayer(..., { layerArn }) in sst.config.ts.`;
   }
   if (probe.compatible === false) {
     return `pg_dump ${probe.pgDump ?? '(unknown)'} (major ${probe.pgDumpMajor}) is older than the server (major ${probe.serverMajor}) — it will refuse to dump (no bypass exists). Rebuild the layer with pg_dump >= ${probe.serverMajor}.`;

package/src/cli/commands/db-snapshot.ts

@@ -23,7 +23,9 @@ function resolveInstanceId(config: CliConfig, flags: Record<string, string>): st
   if (!id || id === 'placeholder') {
     fail(
       'No RDS instance id available. db:snapshot needs an RDS instance.\n' +
-      '  - If your DB is RDS: redeploy so the `databaseInstanceId` output is present, or pass --instance <id>.\n' +
+      '  - If your DB is RDS: add `databaseInstanceId: database.id` to the outputs return block in\n' +
+      '    sst.config.ts and redeploy (run db:snapshot from the app directory so .sst/outputs.json is\n' +
+      '    readable), or pass --instance <id>.\n' +
       '  - If your DB is not RDS (Aurora, a container, self-hosted): use `everystack db:backup` for a portable logical backup.',
     );
     process.exit(1);

package/src/cli/commands/deploy.ts

@@ -11,7 +11,7 @@
  */
 
 import { spawn } from 'node:child_process';
-import { step, success, fail, info } from '../output.js';
+import { step, success, fail, info, warn } from '../output.js';
 import { invalidateCachedConfig } from '../discover.js';
 import { resolveConfig } from '../config.js';
 import { probeDeployedFunctions } from '../deploy-probe.js';
@@ -22,14 +22,31 @@ export function buildDeployArgs(flags: Record<string, string>): string[] {
   return ['sst', 'deploy', '--stage', stage];
 }
 
+/**
+ * The environment the sst child receives: the FULL ambient environment plus color. The wrapper
+ * forwards everything so a consumer's own sst.config.ts env reads behave the same run directly or
+ * through `everystack deploy`. (This contract was pinned when the pg_dump layer depended on
+ * PGDUMP_LAYER_ARN reaching sst — now deprecated: the layer ships via @everystack/pg-tools +
+ * pgDumpLayer() and reads no ambient env at deploy.)
+ */
+export function deployEnv(base: Record<string, string | undefined>): Record<string, string | undefined> {
+  return { ...base, FORCE_COLOR: '1' };
+}
+
 export async function deployCommand(flags: Record<string, string>): Promise<void> {
   const stage = flags.stage || 'dev';
   const args = buildDeployArgs(flags);
 
   step(`Deploying stage "${stage}"...`);
+  // PGDUMP_LAYER_ARN is deprecated: the layer now ships via @everystack/pg-tools and pgDumpLayer()
+  // needs no env var. Still forwarded to sst for one more minor (pgDumpLayer honors it as an alias),
+  // then removed — surface it loudly so the operator migrates off it.
+  if (process.env.PGDUMP_LAYER_ARN) {
+    warn('PGDUMP_LAYER_ARN is DEPRECATED and will be removed next minor. The pg_dump layer now ships via @everystack/pg-tools + pgDumpLayer() with no env var. Drop it once your sst.config.ts uses pgDumpLayer().');
+  }
   await new Promise<void>((resolve) => {
     // `npx` resolves the consumer's local sst (the same way the export step runs expo).
-    const child = spawn('npx', args, { stdio: 'inherit', env: { ...process.env, FORCE_COLOR: '1' } });
+    const child = spawn('npx', args, { stdio: 'inherit', env: deployEnv(process.env) as NodeJS.ProcessEnv });
     child.on('close', (code) => {
       if (code === 0) {
         resolve();
@@ -65,5 +82,8 @@ export async function deployCommand(flags: Record<string, string>): Promise<void
     info(`Skipped the post-deploy probe: ${err?.message ?? err}`);
   }
 
-  info('Next: `everystack db:migrate --stage ' + stage + '` to apply migrations, `everystack update` to publish the app bundle.');
+  // The 0.4 flow: schema changes ride db:plan → db:apply. Migration-based apps still have
+  // db:migrate, but the copy-paste hint must advertise the canonical path — this exact
+  // line got copied into consumer runbooks with the retired verb.
+  info('Next: schema changes via `everystack db:plan --stage ' + stage + '` → `db:apply`; `everystack update` to publish the app bundle.');
 }

package/src/cli/config.ts

@@ -52,6 +52,35 @@ interface SstOutputs {
   backupsBucket?: string;
 }
 
+/**
+ * Merge deploy-stable fields from a local .sst/outputs.json into a discovered config.
+ * Discovery finds live resources (functions, buckets) but cannot see plain stack outputs
+ * like `databaseInstanceId` — a consumer's fresh deploy DID add the output and
+ * `db:snapshot --stage` still failed, because the discovery path never carried it.
+ * Only fields that are stable across deploys are merged (an instance id never rotates
+ * the way a Lambda hash does), so a stale outputs file cannot poison the live discovery.
+ */
+export function enrichConfigFromOutputs(
+  config: CliConfig,
+  outputs: Partial<SstOutputs> | null,
+): CliConfig {
+  if (!outputs) return config;
+  return {
+    ...config,
+    ...(config.databaseInstanceId ? {} : outputs.databaseInstanceId ? { databaseInstanceId: outputs.databaseInstanceId } : {}),
+  };
+}
+
+/** Best-effort read of the local .sst/outputs.json; null when absent/unreadable. */
+async function readLocalOutputs(): Promise<Partial<SstOutputs> | null> {
+  try {
+    const raw = await fs.readFile(path.resolve('.sst', 'outputs.json'), 'utf8');
+    return JSON.parse(raw) as Partial<SstOutputs>;
+  } catch {
+    return null;
+  }
+}
+
 export async function resolveConfig(stage?: string): Promise<CliConfig> {
   const region = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
 
@@ -66,7 +95,7 @@ export async function resolveConfig(stage?: string): Promise<CliConfig> {
 
     // Check cache first
     const cached = await getCachedConfig(stage);
-    if (cached) return cached;
+    if (cached) return enrichConfigFromOutputs(cached, await readLocalOutputs());
 
     step(`Discovering resources for stage "${stage}"...`);
     const appName = await parseAppName();
@@ -74,7 +103,7 @@ export async function resolveConfig(stage?: string): Promise<CliConfig> {
 
     // Cache for future fast lookups
     await setCachedConfig(stage, config);
-    return config;
+    return enrichConfigFromOutputs(config, await readLocalOutputs());
   }
 
   // Default: read .sst/outputs.json (unchanged behavior)

package/src/cli/index.ts

@@ -339,7 +339,7 @@ Usage:
   everystack deploy            [--stage <name>]  Deploy infrastructure (wraps sst deploy — no need to know SST)
   everystack update            --branch <name> --message <msg> [--platform ios|android|web|all] [--stage <name>] [--skip-export]
   everystack update            --channel <name> --message <msg> [--platform ios|android|web|all] [--stage <name>] [--skip-export]
-  everystack db:migrate        [--stage <name>]  Run database migrations on deployed Lambda
+  everystack db:migrate        [--stage <name>]  Run drizzle migrations (legacy — Models apps use db:plan → db:apply)
   everystack db:seed           [--stage <name>]  Seed database on deployed Lambda (dev only)
   everystack db:reset          [--stage <name>]  Drop all schemas + re-run migrations (dev only)
   everystack db:psql           --stage <name>  Interactive ADMIN psql (IAM-gated; resolves the admin URL in-process)

package/src/cli/runbook/sections.ts

@@ -136,7 +136,12 @@ function deploy(r: ProjectReality): Block {
     '- `everystack channels list` — see the channels that exist.',
   ];
   if (r.hasDatabase) {
-    lines.push('', 'After a deploy that includes new migrations: `everystack db:migrate --stage <name>`.');
+    lines.push(
+      '',
+      r.migrationMode === 'everystack'
+        ? 'After a deploy, schema changes land via `everystack db:plan --stage <name>` → `db:apply`.'
+        : 'After a deploy that includes new migrations: `everystack db:migrate --stage <name>`.',
+    );
   }
   return gen('deploy', lines);
 }
@@ -222,7 +227,12 @@ function database(r: ProjectReality): Block {
     '## Database operations',
     '',
     ...flow,
-    '- `everystack db:migrate --stage <name>` — apply migrations on the deployed Lambda',
+    // db:migrate is the RETIRED verb for everystack-mode apps (plan → apply is the flow);
+    // advertising it here got copied into consumer runbooks verbatim. Migration-based
+    // apps still get it — it is their flow.
+    ...(r.migrationMode === 'everystack'
+      ? []
+      : ['- `everystack db:migrate --stage <name>` — apply migrations on the deployed Lambda']),
     '- `everystack db:seed --stage dev` — seed the database (dev only)',
     '- `everystack db:psql --stage dev` — psql into the stage database (credentials never exposed)',
     '- `everystack db:doctor` — verify the security posture (RLS, roles, search_path)',