bod-cli 0.10.1 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bod-cli",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "type": "module",
   "bin": {
     "bod": "./src/cli.ts"

package/src/commands/deploy.ts

@@ -138,13 +138,60 @@ function branchToSubdomain(branch: string, domain: string, productionBranch: str
   return `${sanitized}--${domain}`
 }
 
+/**
+ * A transport-level failure (socket reset, DNS blip, 5xx/429 from the edge) as opposed to a
+ * definitive answer from the server. `BodClient.request` throws `METHOD /path → <status>: body`
+ * for HTTP errors and lets fetch's own errors (`socket connection was closed unexpectedly`, …)
+ * propagate as-is — so anything without a 4xx status marker is retryable.
+ */
+function isTransientError(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err)
+  const status = msg.match(/→ (\d{3}):/)?.[1]
+  if (!status) return true // fetch threw — never reached the server, or the reply was cut off
+  return status === '408' || status === '429' || status.startsWith('5')
+}
+
+/**
+ * The poll loop only OBSERVES a deployment the server already accepted — a dead poll socket says
+ * nothing about whether the deploy succeeded. So transient reads are retried instead of aborting
+ * the command. Deliberately NOT in `BodClient`: the deploy upload/POST are non-idempotent and must
+ * not be blindly replayed.
+ */
+async function getWithRetry<T>(client: BodClient, path: string, attempts = 4): Promise<T> {
+  let lastErr: unknown
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await client.get<T>(path)
+    } catch (err) {
+      lastErr = err
+      if (!isTransientError(err) || i === attempts - 1) throw err
+      const backoff = 1000 * 2 ** i // 1s, 2s, 4s
+      console.log(chalk.dim(`  (poll transport hiccup: ${err instanceof Error ? err.message : err} — retrying in ${backoff / 1000}s)`))
+      await Bun.sleep(backoff)
+    }
+  }
+  throw lastErr
+}
+
 async function pollDeploy(client: BodClient, appId: string, since: number, instanceCaps?: { baseDomain?: string | null }, localConfig?: { localDomain?: string; caddyPort?: number } | null) {
   console.log(chalk.dim('Waiting for deployment...'))
   let lastStatus = ''
   let lastLogTs = since
   for (let i = 0; i < 120; i++) {
     await Bun.sleep(2000)
-    const detail = await client.get<any>(`/apps/${appId}`)
+    let detail: any
+    try {
+      detail = await getWithRetry<any>(client, `/apps/${appId}`)
+    } catch (err) {
+      if (!isTransientError(err)) throw err
+      // The deploy was accepted; we simply lost the ability to watch it. Failing here would report
+      // a healthy deploy as broken — and, worse, make a genuinely broken one look identical.
+      // Verify the deployed app itself (smoke test / `bod apps status`) — that is the real gate.
+      console.log(chalk.yellow(`⚠ Lost contact with the API while watching the deployment (${err instanceof Error ? err.message : err}).`))
+      console.log(chalk.yellow('  The deployment was accepted and is still running server-side — this is a POLL failure, not a deploy failure.'))
+      console.log(chalk.yellow('  Verify with "bod apps status" or by hitting the app.'))
+      return
+    }
     const deps = detail.deployments ?? []
     const latest = deps.find((d: any) => (d.createdAt ?? 0) >= since)
     if (!latest) continue