gencow 0.1.221 → 0.1.223

package/lib/app-command.mjs

@@ -17,6 +17,7 @@ import {
 import { pollAppDeleteOperation } from "./app-delete-operation.mjs";
 import { appResponseError } from "./app-response-error.mjs";
 import { readJsonObjectResponse, readJsonValueResponse } from "./http-response-json.mjs";
+import { runWithAbortDeadline } from "./request-deadline.mjs";
 import { BOLD, CYAN, DIM, GREEN, RED, RESET, error, info, log, success, warn } from "./output.mjs";
 import { loadCreds, rpcMutation, rpcQuery, saveCreds, requireCreds } from "./platform-client.mjs";
 import { resolveProjectMetadataPath, resolveProjectSelection } from "./project-context.mjs";
@@ -27,6 +28,7 @@ import { updateEnvLocalUrl } from "./cli-project-runtime.mjs";
 const DEFAULT_DELETE_POLL_ATTEMPTS = 120;
 const DELETE_POLL_INTERVAL_MS = 1_000;
 const DEFAULT_APP_CREATE_TIMEOUT_MS = 60_000;
+const DEFAULT_APP_DELETE_REQUEST_TIMEOUT_MS = 20_000;
 
 function resolveAppCreateTimeoutMs(value) {
   const parsed = Number(value);
@@ -35,6 +37,13 @@ function resolveAppCreateTimeoutMs(value) {
     : DEFAULT_APP_CREATE_TIMEOUT_MS;
 }
 
+function resolveAppDeleteRequestTimeoutMs(value) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 100 && parsed <= 600_000
+    ? parsed
+    : DEFAULT_APP_DELETE_REQUEST_TIMEOUT_MS;
+}
+
 function appResponseStatus(response) {
   return Number.isSafeInteger(response?.status) ? `HTTP ${response.status}` : "unknown HTTP status";
 }
@@ -137,6 +146,9 @@ async function confirmDelete(name) {
 
 export function createAppCommand({
   appCreateTimeoutMs = resolveAppCreateTimeoutMs(process.env.GENCOW_APP_CREATE_TIMEOUT_MS),
+  appDeleteRequestTimeoutMs = resolveAppDeleteRequestTimeoutMs(
+    process.env.GENCOW_APP_DELETE_REQUEST_TIMEOUT_MS,
+  ),
   clearTimeoutImpl = clearTimeout,
   confirmDeleteImpl = confirmDelete,
   createAbortControllerImpl = () => new AbortController(),
@@ -159,28 +171,38 @@ export function createAppCommand({
   warnImpl = warn,
 }) {
   const boundedAppCreateTimeoutMs = resolveAppCreateTimeoutMs(appCreateTimeoutMs);
+  const boundedAppDeleteRequestTimeoutMs = resolveAppDeleteRequestTimeoutMs(appDeleteRequestTimeoutMs);
 
   async function requestAppCreate(creds, name) {
-    const controller = createAbortControllerImpl();
     const timeoutError = new Error(
       `App creation request timed out after ${boundedAppCreateTimeoutMs}ms. Please try again.`,
     );
-    let timeoutHandle;
-    const timeoutPromise = new Promise((_resolve, reject) => {
-      timeoutHandle = setTimeoutImpl(() => {
-        controller.abort(timeoutError);
-        reject(timeoutError);
-      }, boundedAppCreateTimeoutMs);
+    return runWithAbortDeadline({
+      clearTimeoutImpl,
+      createAbortControllerImpl,
+      request: async (signal) => {
+        const response = await rpcMutationImpl(creds, "apps.create", { name }, { signal });
+        return { response, data: await readJsonObjectResponse(response) };
+      },
+      setTimeoutImpl,
+      timeoutError,
+      timeoutMs: boundedAppCreateTimeoutMs,
     });
-    try {
-      const request = (async () => {
-        const response = await rpcMutationImpl(creds, "apps.create", { name }, { signal: controller.signal });
+  }
+
+  async function requestAppDelete(creds, name, requestId) {
+    const timeoutError = new Error("App deletion request timed out");
+    return runWithAbortDeadline({
+      clearTimeoutImpl,
+      createAbortControllerImpl,
+      request: async (signal) => {
+        const response = await rpcMutationImpl(creds, "apps.delete", { name, requestId }, { signal });
         return { response, data: await readJsonObjectResponse(response) };
-      })();
-      return await Promise.race([request, timeoutPromise]);
-    } finally {
-      clearTimeoutImpl(timeoutHandle);
-    }
+      },
+      setTimeoutImpl,
+      timeoutError,
+      timeoutMs: boundedAppDeleteRequestTimeoutMs,
+    });
   }
 
   return async function app(subcmd, ...rest) {
@@ -342,8 +364,16 @@ ${dashboardLine}
 
       infoImpl(`Deleting app "${name}"...`);
       const requestId = createDeleteRequestIdImpl();
-      const delRes = await rpcMutationImpl(creds, "apps.delete", { name, requestId });
-      let delData = await readJsonObjectResponse(delRes);
+      let delRes;
+      let delData;
+      try {
+        ({ response: delRes, data: delData } = await requestAppDelete(creds, name, requestId));
+      } catch {
+        errorImpl(
+          "App deletion request did not complete. Its operation outcome is unknown; retry the same app delete to inspect it.\nCode: APP_DELETE_REQUEST_UNAVAILABLE",
+        );
+        return 1;
+      }
       if (!isExactAppDeleteResponse(delData, name)) {
         const operationResult = await pollAppDeleteOperation({
           creds,

package/lib/app-delete-operation.mjs

@@ -1,6 +1,7 @@
 import { isExactAppDeleteResponse } from "./app-response-contract.mjs";
 import { APP_DELETE_OPERATION_PATTERN } from "./app-response-error.mjs";
 import { readJsonObjectResponse } from "./http-response-json.mjs";
+import { runWithAbortDeadline } from "./request-deadline.mjs";
 
 const APP_DELETE_ACTIVE_STATES = new Set([
   "accepted",
@@ -26,6 +27,38 @@ const APP_DELETE_RESPONSE_STATES = new Set([
 const CORRELATION_ID_PATTERN = /^[A-Za-z0-9_-]{8,128}$/u;
 const DIAGNOSTIC_CODE_PATTERN = /^[A-Za-z][A-Za-z0-9_]{2,127}$/u;
 const APP_ID_PATTERN = /^(?=.{3,63}$)[a-z][a-z0-9]*(?:-[a-z0-9]+){2,7}$/u;
+const DEFAULT_DELETE_OPERATION_TIMEOUT_MS = 120_000;
+const DEFAULT_DELETE_STATUS_REQUEST_TIMEOUT_MS = 10_000;
+
+function resolveTimeoutMs(value, fallback) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 1 && parsed <= 600_000 ? parsed : fallback;
+}
+
+async function requestDeleteStatus({
+  clearTimeoutImpl,
+  createAbortControllerImpl,
+  creds,
+  name,
+  operationId,
+  requestTimeoutMs,
+  rpcQueryImpl,
+  setTimeoutImpl,
+}) {
+  const timeoutError = new Error("App deletion status request timed out");
+  timeoutError.name = "AbortError";
+  return runWithAbortDeadline({
+    clearTimeoutImpl,
+    createAbortControllerImpl,
+    request: async (signal) => {
+      const statusRes = await rpcQueryImpl(creds, "apps.deleteStatus", { name, operationId }, { signal });
+      return { statusRes, statusData: await readJsonObjectResponse(statusRes) };
+    },
+    setTimeoutImpl,
+    timeoutError,
+    timeoutMs: requestTimeoutMs,
+  });
+}
 
 function isAllowedStatusPath(value, operationId, expectedAppId) {
   if (value === undefined) return true;
@@ -104,12 +137,18 @@ function isMatchingTerminalFailureResponse(value, accepted, expectedAppId) {
 }
 
 export async function pollAppDeleteOperation({
+  clearTimeoutImpl = clearTimeout,
+  createAbortControllerImpl = () => new AbortController(),
   creds,
   initialBody,
   name,
+  nowImpl = Date.now,
+  operationTimeoutMs = DEFAULT_DELETE_OPERATION_TIMEOUT_MS,
   pollAttempts,
   pollIntervalMs,
+  requestTimeoutMs = DEFAULT_DELETE_STATUS_REQUEST_TIMEOUT_MS,
   rpcQueryImpl,
+  setTimeoutImpl = setTimeout,
   sleepImpl,
 }) {
   const accepted = parseAppDeleteOperationEnvelope(initialBody, name);
@@ -121,13 +160,25 @@ export async function pollAppDeleteOperation({
   let latest = accepted;
   let successfulPollResponses = 0;
   let transportFailures = 0;
+  const deadlineAt = nowImpl() + resolveTimeoutMs(operationTimeoutMs, DEFAULT_DELETE_OPERATION_TIMEOUT_MS);
+  const boundedRequestTimeoutMs = resolveTimeoutMs(
+    requestTimeoutMs,
+    DEFAULT_DELETE_STATUS_REQUEST_TIMEOUT_MS,
+  );
   for (let attempt = 0; attempt < pollAttempts; attempt += 1) {
+    const remainingMs = deadlineAt - nowImpl();
+    if (remainingMs <= 0) break;
     try {
-      const statusRes = await rpcQueryImpl(creds, "apps.deleteStatus", {
+      const { statusData, statusRes } = await requestDeleteStatus({
+        clearTimeoutImpl,
+        createAbortControllerImpl,
+        creds,
         name,
         operationId: accepted.operationId,
+        requestTimeoutMs: Math.min(boundedRequestTimeoutMs, remainingMs),
+        rpcQueryImpl,
+        setTimeoutImpl,
       });
-      const statusData = await readJsonObjectResponse(statusRes);
       // A lifecycle operation is durable.  A transient 5xx while the status
       // query is being served must not turn that durable receipt into a client
       // contract failure or abandon the operation's correlation identity.
@@ -157,7 +208,10 @@ export async function pollAppDeleteOperation({
       transportFailures += 1;
       // The durable receipt remains authoritative across transient polling failures.
     }
-    if (attempt + 1 < pollAttempts) await sleepImpl(pollIntervalMs);
+    if (attempt + 1 < pollAttempts) {
+      const remainingAfterRequestMs = deadlineAt - nowImpl();
+      if (remainingAfterRequestMs > 0) await sleepImpl(Math.min(pollIntervalMs, remainingAfterRequestMs));
+    }
   }
 
   const pollingUnavailable = successfulPollResponses === 0 && transportFailures > 0;

package/lib/platform-client.mjs

@@ -96,10 +96,11 @@ export async function platformFetch(creds, path, opts = {}) {
   });
 }
 
-export async function rpcQuery(creds, queryName, args = {}) {
+export async function rpcQuery(creds, queryName, args = {}, requestOptions = {}) {
   return platformFetch(creds, "/api/query", {
+    ...requestOptions,
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers: { ...requestOptions.headers, "Content-Type": "application/json" },
     body: JSON.stringify({ name: queryName, args }),
   });
 }

package/lib/request-deadline.mjs

@@ -0,0 +1,22 @@
+export async function runWithAbortDeadline({
+  clearTimeoutImpl = clearTimeout,
+  createAbortControllerImpl = () => new AbortController(),
+  request,
+  setTimeoutImpl = setTimeout,
+  timeoutError,
+  timeoutMs,
+}) {
+  const controller = createAbortControllerImpl();
+  let timeoutHandle;
+  const deadline = new Promise((_resolve, reject) => {
+    timeoutHandle = setTimeoutImpl(() => {
+      controller.abort(timeoutError);
+      reject(timeoutError);
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([request(controller.signal), deadline]);
+  } finally {
+    clearTimeoutImpl(timeoutHandle);
+  }
+}

package/lib/static-deploy-command.mjs

@@ -21,8 +21,38 @@ import { pollAcceptedDeploymentOperation } from "./deployment-operation-poll.mjs
 import { writeProjectMetadata } from "./deploy-project-metadata.mjs";
 
 function shouldPreserveFinalizeAttempt(error) {
-  return error?.retryable === true ||
-    error?.message === "APP_SERVING_ROUTE_COMMIT_PENDING";
+  return error?.retryable === true || error?.message === "APP_SERVING_ROUTE_COMMIT_PENDING";
+}
+
+const TRANSIENT_STATIC_DEPLOY_PROXY_STATUSES = new Set([502, 503, 504]);
+
+async function isBodylessTransientStaticDeployResponse(response) {
+  if (
+    !TRANSIENT_STATIC_DEPLOY_PROXY_STATUSES.has(response?.status) ||
+    typeof response?.clone !== "function"
+  ) {
+    return false;
+  }
+  try {
+    return (await readJsonObjectResponse(response.clone())) === null;
+  } catch {
+    return false;
+  }
+}
+
+export async function postStaticDeployWithTransientProxyRetry({
+  send,
+  retryDelaysMs = [250, 500, 1_000],
+  delayImpl = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+}) {
+  let response;
+  for (let attempt = 0; ; attempt += 1) {
+    response = await send();
+    if (!(await isBodylessTransientStaticDeployResponse(response)) || attempt >= retryDelaysMs.length) {
+      return response;
+    }
+    await delayImpl(retryDelaysMs[attempt]);
+  }
 }
 
 export function resolveStaticDeployDir({
@@ -178,6 +208,8 @@ export function createStaticDeployRuntime({
   resolvePathImpl = resolve,
   setTimeoutImpl = setTimeout,
   statSyncImpl = statSync,
+  staticDeployRetryDelayImpl = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  staticDeployRetryDelaysMs,
   successImpl = success,
   tarCreateImpl,
   unlinkSyncImpl = unlinkSync,
@@ -383,22 +415,27 @@ export function createStaticDeployRuntime({
     infoImpl("Deploying static files...");
     let deployRes;
     try {
-      deployRes = await platformFetchImpl(creds, `/platform/apps/${appId}/deploy-static`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/octet-stream",
-          "X-Deploy-Local-Dir": cwd,
-          "X-Gencow-Deploy-Claim": deployClaim.header,
-          "X-Gencow-Deploy-Protocol": "1",
-          "X-Gencow-CLI-Version": deployClaim.claim.generatedBy.version,
-          ...(releaseAttemptId
-            ? {
-                "X-Gencow-Release-Attempt-Id": releaseAttemptId,
-                "X-Gencow-Release-Environment": opts.envTarget || "dev",
-              }
-            : {}),
-        },
-        body: bundleBuffer,
+      deployRes = await postStaticDeployWithTransientProxyRetry({
+        send: () =>
+          platformFetchImpl(creds, `/platform/apps/${appId}/deploy-static`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/octet-stream",
+              "X-Deploy-Local-Dir": cwd,
+              "X-Gencow-Deploy-Claim": deployClaim.header,
+              "X-Gencow-Deploy-Protocol": "1",
+              "X-Gencow-CLI-Version": deployClaim.claim.generatedBy.version,
+              ...(releaseAttemptId
+                ? {
+                    "X-Gencow-Release-Attempt-Id": releaseAttemptId,
+                    "X-Gencow-Release-Environment": opts.envTarget || "dev",
+                  }
+                : {}),
+            },
+            body: bundleBuffer,
+          }),
+        retryDelaysMs: staticDeployRetryDelaysMs,
+        delayImpl: staticDeployRetryDelayImpl,
       });
       if (deployRes.status === 202) {
         deployRes = await pollAcceptedDeploymentOperation({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencow",
-  "version": "0.1.221",
+  "version": "0.1.223",
   "description": "Gencow — AI Backend Engine",
   "type": "module",
   "bin": {
@@ -33,9 +33,9 @@
   "devDependencies": {
     "@types/node": "^25.9.5",
     "better-auth": "^1.6.23",
-    "@gencow/core": "0.1.43",
     "@gencow/client": "0.2.7",
-    "@gencow/react": "0.2.7"
+    "@gencow/react": "0.2.7",
+    "@gencow/core": "0.1.43"
   },
   "scripts": {
     "prebuild": "pnpm --filter @gencow/migration-contract run build && pnpm --filter @gencow/server run build",