gencow 0.1.259 → 0.1.260

package/lib/cloud-targets.mjs

@@ -47,6 +47,14 @@ export function resolveProdAppTarget({ explicitAppId = null, prodApp = null, acc
   return { appId: prodApp };
 }
 
+// Single rule for the implicit prod environment: an explicit app id that is this project's
+// prod app selects the prod environment even without --prod. Every command that picks a
+// cloud app (cloud targets, deploy) must use this helper instead of repeating the condition.
+export function resolveImplicitProdEnvironment({ explicitApp = false, envTarget = "dev", appId = null, prodApp = null }) {
+  if (explicitApp && envTarget === "dev" && prodApp && appId === prodApp) return "prod";
+  return envTarget;
+}
+
 // Shared human message for a failed prod target; falls back to the call site's own text.
 export function describeProdTargetFailure(result, fallbackMessage) {
   if (result?.reason === "explicit_app_not_prod_app") {
@@ -81,10 +89,12 @@ export function resolveCloudAppTarget(restArgs, options = {}) {
   if (projectTargets.invalid) {
     return { error: "MIGRATION_PROJECT_CONFIG_INVALID" };
   }
-  // The project's own prod app id names the prod environment even without --prod.
-  if (explicitApp && envTarget === "dev" && projectTargets.prodApp && appId === projectTargets.prodApp) {
-    envTarget = "prod";
-  }
+  envTarget = resolveImplicitProdEnvironment({
+    explicitApp,
+    envTarget,
+    appId,
+    prodApp: projectTargets.prodApp,
+  });
   if (!appId) {
     appId = envTarget === "prod" ? projectTargets.prodApp : projectTargets.appId;
   }

package/lib/db-command.mjs

@@ -17,22 +17,36 @@ import { createDbCheckCommand, createDbPushCommand } from "./db-push-command.mjs
 import { logEnvFileOperationWithType } from "./backend-env-resolver.mjs";
 import { runDrizzleGenerateWithFallback } from "./drizzle-generate.mjs";
 import { BOLD, CYAN, DIM, GREEN, RED, RESET, error, info, log, success, warn } from "./output.mjs";
-import { describeProdTargetFailure, resolveProdAppTarget } from "./cloud-targets.mjs";
+import {
+  describeProdTargetFailure,
+  resolveImplicitProdEnvironment,
+  resolveProdAppTarget,
+} from "./cloud-targets.mjs";
 import { platformFetch, requireCreds } from "./platform-client.mjs";
 import { readProjectMetadata } from "./project-context.mjs";
 
 export function resolveDbCloudTarget(args, gencowJson = null) {
-  const isProd = args.includes("--prod");
   let explicitAppId = null;
+  let hasExplicitApp = false;
   let platformUrl = null;
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--app" || args[i] === "-a") {
       explicitAppId = args[i + 1] ?? null;
+      hasExplicitApp = true;
       i++;
     }
   }
 
+  // Same implicit prod rule as deploy and static: an --app naming the project's prodApp is prod even without --prod.
+  const isProd =
+    resolveImplicitProdEnvironment({
+      explicitApp: hasExplicitApp,
+      envTarget: args.includes("--prod") ? "prod" : "dev",
+      appId: explicitAppId,
+      prodApp: gencowJson?.prodApp || null,
+    }) === "prod";
+
   if (gencowJson) {
     platformUrl = gencowJson.platformUrl || null;
     if (isProd) {

package/lib/deploy-prepared-source.mjs

@@ -0,0 +1,37 @@
+import { unlinkSync } from "fs";
+
+// Local-only backend source preparation for a first `deploy --prod`. Every step here
+// reads the project on disk (capability check, migration generation, codegen, the
+// packaging audits and the bundle with its round-trip check). It runs once, before the
+// production app is created, so a rejection leaves no remote app behind.
+export async function prepareBackendSourceForProdCreate(
+  runtime,
+  { forceDeploy = false, requestId = null } = {},
+) {
+  if ((await runtime.preflightBackendCapability?.()) === false) return null;
+  const generatorVersion = await runtime.prepareDeployProjectSource?.({ existingBundleMode: false });
+  const packageResult = await runtime.packageDeployProject({
+    forceDeploy,
+    existingBundleMode: false,
+    requestId,
+    sourcePrepared: true,
+    preparedGeneratorVersion: generatorVersion,
+  });
+  if (!packageResult) return null;
+  return { runtime, generatorVersion, packageResult };
+}
+
+// Drops the temporary bundle file and codegen output of a prepared source that did not
+// reach the backend deploy (which otherwise releases them itself). Safe to call twice.
+export function releasePreparedBackendSource(prepared, { unlinkSyncImpl = unlinkSync } = {}) {
+  if (!prepared) return;
+  const tmpBundle = prepared.packageResult?.tmpBundle;
+  if (tmpBundle) {
+    try {
+      unlinkSyncImpl(tmpBundle);
+    } catch {
+      /* already removed */
+    }
+  }
+  prepared.runtime?.cleanupPreparedDeploySource?.();
+}

package/lib/deploy-runtime.mjs

@@ -19,6 +19,11 @@ import { detectStaticDeployBackend, preflightStaticDeployArtifact } from "./stat
 import { formatCommandError } from "./cli-command-runner.mjs";
 import { readJsonObjectResponse } from "./http-response-json.mjs";
 import { ensureProductionDeployTarget } from "./deploy-prod-target.mjs";
+import {
+  prepareBackendSourceForProdCreate,
+  releasePreparedBackendSource,
+} from "./deploy-prepared-source.mjs";
+import { resolveImplicitProdEnvironment } from "./cloud-targets.mjs";
 
 export function parseDeployArgs(deployArgs) {
   const parsed = {
@@ -183,14 +188,6 @@ function showUnknownDeployArgument(arg, { errorImpl = error, infoImpl = info, lo
   infoImpl("  gencow static [dir]           Deploy static files only");
 }
 
-// Returns the prepared backend source, or null when the capability check rejected it
-// (the rejection is already rendered and exit is already requested).
-async function prepareBackendSourceForProdCreate(runtime) {
-  if ((await runtime.preflightBackendCapability?.()) === false) return null;
-  const generatorVersion = await runtime.prepareDeployProjectSource?.({ existingBundleMode: false });
-  return { runtime, generatorVersion };
-}
-
 async function runRollbackDeploy({
   appId,
   envTarget,
@@ -432,6 +429,14 @@ export function createDeployCommand({
       resolvePathImpl,
     });
     let { appId, displayName, gencowJsonPath, prodAppId, projectDir } = context;
+    // Same environment rule as cloud-targets.mjs: --app <project prod app> deploys to prod even without --prod.
+    // Every branch below (static, rollback, existing-bundle, backend) reads this promoted environment.
+    parsed.envTarget = resolveImplicitProdEnvironment({
+      explicitApp: Boolean(parsed.appId),
+      envTarget: parsed.envTarget,
+      appId: parsed.appId,
+      prodApp: prodAppId,
+    });
     const rootAppId = appId;
     appId = resolveEnvironmentDeployTarget({ appId, envTarget: parsed.envTarget, prodAppId });
     const backendProjectRoot = projectDir ?? projectRoot;
@@ -524,14 +529,20 @@ export function createDeployCommand({
           region: parsed.region,
           prepareLocalSource: preparesBackendSource
             ? async () => {
-                preparedSource = await prepareBackendSourceForProdCreate(backendDeployRuntime);
+                preparedSource = await prepareBackendSourceForProdCreate(backendDeployRuntime, {
+                  forceDeploy: parsed.forceDeploy,
+                  requestId: parsed.requestId,
+                });
                 return preparedSource !== null;
               }
             : null,
         });
       } finally {
-        // Prepared codegen output is temporary; drop it when no production app was created.
-        if (!prodTarget) backendDeployRuntime.cleanupPreparedDeploySource?.();
+        // Prepared codegen output and bundle are temporary; drop them when no production app was created.
+        if (!prodTarget) {
+          backendDeployRuntime.cleanupPreparedDeploySource?.();
+          releasePreparedBackendSource(preparedSource, { unlinkSyncImpl });
+        }
       }
       if (!prodTarget) return;
       appId = prodTarget;
@@ -544,64 +555,69 @@ export function createDeployCommand({
     }
 
     if (parsed.staticDeploy) {
-      await runStaticDeployFlow({
-        appId,
-        preparedSource,
-        backendRoot: backendProjectRoot,
-        creds,
-        displayName,
-        envTarget: parsed.envTarget,
-        forceDeploy: parsed.forceDeploy,
-        requestId: parsed.requestId,
-        resumeStaticOnly: parsed.resumeRequested,
-        gencowJsonPath,
-        hasDetectedBackend,
-        selectedClient,
-        staticDirArg: resolvedStaticDirArg,
-        staticArtifactPreflight,
-        createDeployPackageRuntimeForCwd,
-        cwdImpl,
-        deployPackageRuntime: backendDeployRuntime,
-        errorImpl,
-        existsSyncImpl,
-        exitImpl,
-        infoImpl,
-        logImpl,
-        resolvePathImpl,
-        runStaticDeployRuntimeImpl,
-        unlinkSyncImpl,
-        writeFileSyncImpl,
-        prepareReleaseAttempt: prepareReleaseAttemptImpl
-          ? ({ appId: activeAppId, sourceRoot }) =>
-              prepareReleaseAttemptImpl({
-                root: sourceRoot || backendProjectRoot,
-                sourceRootKind: "fullstack",
-                components: ["backend", "static"],
-                cliVersion,
-                creds,
-                appId: activeAppId,
-                environment: parsed.envTarget,
-                requestId: parsed.requestId,
-                platformFetchImpl,
-                capabilityTimeoutMs: 15_000,
-                allowCapabilityTimeoutFallback: true,
-                warnImpl,
-              })
-          : undefined,
-        failReleaseAttempt: failReleaseAttemptImpl
-          ? ({ appId: activeAppId, attemptId, failureStage, failureCode }) =>
-              failReleaseAttemptImpl({
-                creds,
-                appId: activeAppId,
-                attemptId,
-                environment: parsed.envTarget,
-                failureStage,
-                failureCode,
-                platformFetchImpl,
-              })
-          : undefined,
-        successImpl,
-      });
+      try {
+        await runStaticDeployFlow({
+          appId,
+          preparedSource,
+          backendRoot: backendProjectRoot,
+          creds,
+          displayName,
+          envTarget: parsed.envTarget,
+          forceDeploy: parsed.forceDeploy,
+          requestId: parsed.requestId,
+          resumeStaticOnly: parsed.resumeRequested,
+          gencowJsonPath,
+          hasDetectedBackend,
+          selectedClient,
+          staticDirArg: resolvedStaticDirArg,
+          staticArtifactPreflight,
+          createDeployPackageRuntimeForCwd,
+          cwdImpl,
+          deployPackageRuntime: backendDeployRuntime,
+          errorImpl,
+          existsSyncImpl,
+          exitImpl,
+          infoImpl,
+          logImpl,
+          resolvePathImpl,
+          runStaticDeployRuntimeImpl,
+          unlinkSyncImpl,
+          writeFileSyncImpl,
+          prepareReleaseAttempt: prepareReleaseAttemptImpl
+            ? ({ appId: activeAppId, sourceRoot }) =>
+                prepareReleaseAttemptImpl({
+                  root: sourceRoot || backendProjectRoot,
+                  sourceRootKind: "fullstack",
+                  components: ["backend", "static"],
+                  cliVersion,
+                  creds,
+                  appId: activeAppId,
+                  environment: parsed.envTarget,
+                  requestId: parsed.requestId,
+                  platformFetchImpl,
+                  capabilityTimeoutMs: 15_000,
+                  allowCapabilityTimeoutFallback: true,
+                  warnImpl,
+                })
+            : undefined,
+          failReleaseAttempt: failReleaseAttemptImpl
+            ? ({ appId: activeAppId, attemptId, failureStage, failureCode }) =>
+                failReleaseAttemptImpl({
+                  creds,
+                  appId: activeAppId,
+                  attemptId,
+                  environment: parsed.envTarget,
+                  failureStage,
+                  failureCode,
+                  platformFetchImpl,
+                })
+            : undefined,
+          successImpl,
+        });
+      } finally {
+        // The static flow can return before the backend deploy consumes the prepared source.
+        releasePreparedBackendSource(preparedSource, { unlinkSyncImpl });
+      }
       return 0;
     }
 

package/lib/deploy-static-fullstack-runtime.mjs

@@ -125,22 +125,25 @@ export async function deployBackendPackage({
       });
       if (!activeAppId) return null;
     } else {
-      if (!preparedSource) {
+      if (preparedSource) {
+        // Local preparation and packaging already ran once, before the production create.
+        packageResult = preparedSource.packageResult;
+      } else {
         if ((await activePackageRuntime.preflightBackendCapability?.()) === false) return null;
-      }
-      const preparedGeneratorVersion = preparedSource
-        ? preparedSource.generatorVersion
-        : await activePackageRuntime.prepareDeployProjectSource?.({ existingBundleMode });
-      packageResult = await activePackageRuntime.packageDeployProject({
-        forceDeploy,
-        existingBundleMode,
-        requestId,
-        sourcePrepared: true,
-        preparedGeneratorVersion,
-      });
-      if (!packageResult) {
-        await markAttemptFailed("package", "PACKAGE_FAILED");
-        return null;
+        const preparedGeneratorVersion = await activePackageRuntime.prepareDeployProjectSource?.({
+          existingBundleMode,
+        });
+        packageResult = await activePackageRuntime.packageDeployProject({
+          forceDeploy,
+          existingBundleMode,
+          requestId,
+          sourcePrepared: true,
+          preparedGeneratorVersion,
+        });
+        if (!packageResult) {
+          await markAttemptFailed("package", "PACKAGE_FAILED");
+          return null;
+        }
       }
 
       activeAppId = await activePackageRuntime.createCloudAppIfNeeded({

package/lib/static-command.mjs

@@ -3,7 +3,11 @@ import { isAbsolute, resolve } from "path";
 
 import { readProjectDisplayName } from "./cli-project-runtime.mjs";
 import { formatCommandError } from "./cli-command-runner.mjs";
-import { describeProdTargetFailure, resolveProdAppTarget } from "./cloud-targets.mjs";
+import {
+  describeProdTargetFailure,
+  resolveImplicitProdEnvironment,
+  resolveProdAppTarget,
+} from "./cloud-targets.mjs";
 import {
   getCliInvocationSelection,
   resolveProjectMetadataPath,
@@ -291,8 +295,14 @@ export function createStaticCommand(options = {}) {
         return;
       }
     }
-    let deployTarget = parsed.isProd ? prodAppId || appId : appId;
-    const envTarget = parsed.isProd ? "prod" : "dev";
+    // Same environment rule as deploy (cloud-targets.mjs): --app <project prod app> is prod even without --prod.
+    const envTarget = resolveImplicitProdEnvironment({
+      explicitApp: Boolean(parsed.appId),
+      envTarget: parsed.isProd ? "prod" : "dev",
+      appId: parsed.appId,
+      prodApp: prodAppId,
+    });
+    let deployTarget = envTarget === "prod" ? prodAppId || appId : appId;
 
     if (parsed.isProd && !prodAppId) {
       deployTarget = await ensureStaticProductionTarget({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencow",
-  "version": "0.1.259",
+  "version": "0.1.260",
   "description": "Gencow — AI Backend Engine",
   "type": "module",
   "bin": {
@@ -41,10 +41,10 @@
     "better-auth": "1.7.11",
     "postgres": "^3.4.9",
     "@gencow/client": "0.2.8",
-    "@gencow/shared": "0.0.0",
+    "@gencow/react": "0.2.8",
     "@gencow/core": "0.1.47",
-    "@gencow/server": "0.1.3",
-    "@gencow/react": "0.2.8"
+    "@gencow/shared": "0.0.0",
+    "@gencow/server": "0.1.3"
   },
   "scripts": {
     "build": "node scripts/bundle-core.mjs && node scripts/bundle-shared.mjs && node scripts/bundle-server.mjs",