gencow 0.1.223 → 0.1.225

package/lib/app-command.mjs

@@ -17,7 +17,6 @@ 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";
@@ -28,7 +27,6 @@ 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);
@@ -37,13 +35,6 @@ 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";
 }
@@ -146,9 +137,6 @@ 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(),
@@ -171,38 +159,28 @@ 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.`,
     );
-    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,
+    let timeoutHandle;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+      timeoutHandle = setTimeoutImpl(() => {
+        controller.abort(timeoutError);
+        reject(timeoutError);
+      }, boundedAppCreateTimeoutMs);
     });
-  }
-
-  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 });
+    try {
+      const request = (async () => {
+        const response = await rpcMutationImpl(creds, "apps.create", { name }, { signal: controller.signal });
         return { response, data: await readJsonObjectResponse(response) };
-      },
-      setTimeoutImpl,
-      timeoutError,
-      timeoutMs: boundedAppDeleteRequestTimeoutMs,
-    });
+      })();
+      return await Promise.race([request, timeoutPromise]);
+    } finally {
+      clearTimeoutImpl(timeoutHandle);
+    }
   }
 
   return async function app(subcmd, ...rest) {
@@ -364,16 +342,8 @@ ${dashboardLine}
 
       infoImpl(`Deleting app "${name}"...`);
       const requestId = createDeleteRequestIdImpl();
-      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;
-      }
+      const delRes = await rpcMutationImpl(creds, "apps.delete", { name, requestId });
+      let delData = await readJsonObjectResponse(delRes);
       if (!isExactAppDeleteResponse(delData, name)) {
         const operationResult = await pollAppDeleteOperation({
           creds,

package/lib/app-delete-operation.mjs

@@ -1,7 +1,6 @@
 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",
@@ -27,38 +26,6 @@ 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;
@@ -137,18 +104,12 @@ 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);
@@ -160,25 +121,13 @@ 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 { statusData, statusRes } = await requestDeleteStatus({
-        clearTimeoutImpl,
-        createAbortControllerImpl,
-        creds,
+      const statusRes = await rpcQueryImpl(creds, "apps.deleteStatus", {
         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.
@@ -208,10 +157,7 @@ export async function pollAppDeleteOperation({
       transportFailures += 1;
       // The durable receipt remains authoritative across transient polling failures.
     }
-    if (attempt + 1 < pollAttempts) {
-      const remainingAfterRequestMs = deadlineAt - nowImpl();
-      if (remainingAfterRequestMs > 0) await sleepImpl(Math.min(pollIntervalMs, remainingAfterRequestMs));
-    }
+    if (attempt + 1 < pollAttempts) await sleepImpl(pollIntervalMs);
   }
 
   const pollingUnavailable = successfulPollResponses === 0 && transportFailures > 0;

package/lib/deploy-package-runtime.mjs

@@ -20,6 +20,7 @@ import { buildDeployClaimFromArchive } from "./deploy-package-claim.mjs";
 import { renderDeployFailureDiagnosticLines } from "./deploy-failure-diagnostic.mjs";
 import { readJsonObjectResponse } from "./http-response-json.mjs";
 import { pollAcceptedDeploymentOperation } from "./deployment-operation-poll.mjs";
+import { submitDeploymentWithIdempotentRetry } from "./deployment-admission-retry.mjs";
 import { acquireDeployReceipt, releaseDeployReceipt } from "./deploy-receipt-store.mjs";
 import { CYAN, DIM, RED, RESET, YELLOW, error, info, log, success, warn } from "./output.mjs";
 import { platformFetch, rpcMutation } from "./platform-client.mjs";
@@ -42,36 +43,6 @@ import {
 import { detectProjectConfigFile, warnProjectConfigSelectionOnce } from "./project-config-selection.mjs";
 import { writeCanonicalDeployBundle } from "./deploy-bundle-staging.mjs";
 
-const INITIAL_DEPLOYMENT_ADMISSION_ATTEMPTS = 3;
-
-function isRetryableInitialDeploymentAdmission(response) {
-  return Number.isInteger(response?.status) && response.status >= 500 && response.status <= 599;
-}
-
-/**
- * A deploy claim is an idempotency key.  Before the Platform returns the
- * operation receipt, a transport/5xx outcome is intentionally ambiguous;
- * resubmit only that same claim a bounded number of times rather than making
- * the customer invent a second operation.
- */
-export async function submitDeploymentWithIdempotentRetry({
-  submit,
-  sleepImpl = (ms) => new Promise((resolveDelay) => setTimeout(resolveDelay, ms)),
-}) {
-  let response;
-  for (let attempt = 1; attempt <= INITIAL_DEPLOYMENT_ADMISSION_ATTEMPTS; attempt += 1) {
-    response = await submit();
-    if (
-      !isRetryableInitialDeploymentAdmission(response) ||
-      attempt === INITIAL_DEPLOYMENT_ADMISSION_ATTEMPTS
-    ) {
-      return response;
-    }
-    await sleepImpl(250 * attempt);
-  }
-  return response;
-}
-
 async function loadProjectConfigDefault(options) {
   const { loadConfig } = await import("./cli-project-runtime.mjs");
   return loadConfig(options);

package/lib/deployment-admission-retry.mjs

@@ -0,0 +1,31 @@
+const INITIAL_DEPLOYMENT_ADMISSION_ATTEMPTS = 3;
+
+function isRetryableInitialDeploymentAdmission(response) {
+  return Number.isInteger(response?.status) && response.status >= 500 && response.status <= 599;
+}
+
+/**
+ * A deploy claim is an idempotency key. Before Platform returns an operation
+ * receipt, retry only the same claim after an ambiguous transport or 5xx
+ * outcome; do not create replacement work.
+ */
+export async function submitDeploymentWithIdempotentRetry({
+  submit,
+  sleepImpl = (ms) => new Promise((resolveDelay) => setTimeout(resolveDelay, ms)),
+}) {
+  let response;
+  for (let attempt = 1; attempt <= INITIAL_DEPLOYMENT_ADMISSION_ATTEMPTS; attempt += 1) {
+    try {
+      response = await submit();
+    } catch (error) {
+      if (attempt === INITIAL_DEPLOYMENT_ADMISSION_ATTEMPTS) throw error;
+      await sleepImpl(250 * attempt);
+      continue;
+    }
+    if (!isRetryableInitialDeploymentAdmission(response) || attempt === INITIAL_DEPLOYMENT_ADMISSION_ATTEMPTS) {
+      return response;
+    }
+    await sleepImpl(250 * attempt);
+  }
+  return response;
+}

package/lib/deployment-operation-poll.mjs

@@ -2,6 +2,7 @@ import { readJsonObjectResponse } from "./http-response-json.mjs";
 
 const PENDING_STATES = new Set(["accepted", "queued", "running"]);
 const TERMINAL_STATES = new Set(["succeeded", "failed", "blocked", "cancelled"]);
+const TERMINAL_FAILURE_STATES = new Set(["failed", "blocked"]);
 const OPERATION_ID = /^[1-9][0-9]*$/u;
 const CORRELATION_ID = /^[A-Za-z0-9_-]{8,128}$/u;
 const APP_NAME = /^[a-z0-9][a-z0-9-]{0,62}$/u;
@@ -63,12 +64,24 @@ function isNonterminalResponse(response, body, identity) {
   );
 }
 
-function isTransientPinnedOperationRead(response, expected) {
+function isMatchingTerminalPinnedFailure(response, identity, expected) {
   return (
     expected.operationId !== null &&
     Number.isInteger(response?.status) &&
     response.status >= 500 &&
-    response.status <= 599
+    response.status <= 599 &&
+    TERMINAL_FAILURE_STATES.has(identity.state) &&
+    identityIsValid(identity, expected, false)
+  );
+}
+
+function isTransientPinnedOperationRead(response, identity, expected) {
+  return (
+    expected.operationId !== null &&
+    Number.isInteger(response?.status) &&
+    response.status >= 500 &&
+    response.status <= 599 &&
+    !isMatchingTerminalPinnedFailure(response, identity, expected)
   );
 }
 
@@ -134,6 +147,12 @@ export async function pollAcceptedDeploymentOperation({
         platformFetch(creds, expected.pollUrl, { method: "GET", signal: controller.signal }),
         timedOut,
       ]);
+    } catch {
+      // The operation identity was already sealed by the accepted response.
+      // A transport failure while observing it is not that operation's
+      // terminal result. Present it as a transient pinned read so the loop
+      // keeps polling the same receipt until its declared client deadline.
+      return { ok: false, status: 503, statusText: "Service Unavailable" };
     } finally {
       if (timer !== undefined) deadlineClearTimeoutImpl(timer);
     }
@@ -165,7 +184,7 @@ export async function pollAcceptedDeploymentOperation({
     // Once the server has sealed the operation identity, a gateway/database
     // read failure cannot safely be presented as that operation's terminal
     // result. Keep polling the same receipt; never submit a second deploy.
-    if (isTransientPinnedOperationRead(response, expected)) {
+    if (isTransientPinnedOperationRead(response, identity, expected)) {
       if (nowImpl() >= deadlineMs) return pendingResponse();
       const retryAfter = Number(response.headers?.get?.("Retry-After"));
       const retryDelayMs =

package/lib/platform-client.mjs

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

package/lib/static-deploy-command.mjs

@@ -47,7 +47,17 @@ export async function postStaticDeployWithTransientProxyRetry({
 }) {
   let response;
   for (let attempt = 0; ; attempt += 1) {
-    response = await send();
+    try {
+      response = await send();
+    } catch (error) {
+      // `send` closes over one immutable deploy claim (and, when enabled, one
+      // release attempt). Replaying it is admission observation, not a new
+      // static deployment. Keep this bounded; the final transport error is
+      // still reported to the caller without inventing a terminal outcome.
+      if (attempt >= retryDelaysMs.length) throw error;
+      await delayImpl(retryDelaysMs[attempt]);
+      continue;
+    }
     if (!(await isBodylessTransientStaticDeployResponse(response)) || attempt >= retryDelaysMs.length) {
       return response;
     }
@@ -446,14 +456,19 @@ export function createStaticDeployRuntime({
           setTimeoutImpl,
         });
       }
-    } catch (caught) {
-      await markAttemptFailed("deploy", "DEPLOY_TRANSPORT_FAILED");
+    } catch {
+      // No response means the canonical deployment may already exist. Do not
+      // let this observer terminalize its release attempt; retain the same
+      // claim/attempt so a normal retry converges through the executor owner.
       try {
         unlinkSyncImpl(tmpBundle);
       } catch {
         /* ignore */
       }
-      throw caught;
+      errorImpl("Static deployment admission is temporarily unavailable. Retry the same command.");
+      infoImpl("Code: PLATFORM_DEPLOYMENT_ADMISSION_UNAVAILABLE");
+      exitImpl(1);
+      return;
     }
 
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencow",
-  "version": "0.1.223",
+  "version": "0.1.225",
   "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/core": "0.1.43"
+    "@gencow/react": "0.2.7"
   },
   "scripts": {
     "prebuild": "pnpm --filter @gencow/migration-contract run build && pnpm --filter @gencow/server run build",