@boxes-dev/dvb 0.2.44 → 0.2.46

package/dist/bin/dvb.cjs

@@ -423,7 +423,7 @@ var init_repo = __esm({
 });
 
 // ../core/src/sprites.ts
-var import_node_crypto, import_node_util, import_ws, SpritesApiError, logger, USE_INTERNAL_SERVICE_API, INTERNAL_SERVICE_SIGNAL_TIMEOUT_SECONDS, toWebSocketErrorInfo, toWsUrl, shellQuote, requestJson, listSprites, requestNdjson, writeFile, normalizeServiceRecord, readFile, openExecSocket, attachExecSocket, openProxySocket, listExecSessions, listServices, internalServicesRequest, createCheckpointInternal, listServicesInternal, getServiceInternal, createServiceInternal, startServiceInternal, stopServiceInternal, execCommand, createSpritesClient;
+var import_node_crypto, import_node_util, import_ws, SpritesApiError, logger, USE_INTERNAL_SERVICE_API, INTERNAL_SERVICE_SIGNAL_TIMEOUT_SECONDS, toWebSocketErrorInfo, toWsUrl, shellQuote, DEFAULT_SPRITES_HTTP_TIMEOUT_MS_IDEMPOTENT, DEFAULT_SPRITES_HTTP_TIMEOUT_MS_NON_IDEMPOTENT, DEFAULT_SPRITES_HTTP_MAX_ATTEMPTS, SPRITES_HTTP_RETRYABLE_STATUSES, delay, isIdempotentMethod, computeRetryDelayMs, isAbortError, getErrorCode, isRetryableFetchError, shouldRetrySpritesRequest, withSpritesRetry, requestJson, listSprites, requestNdjson, writeFile, normalizeServiceRecord, readFile, openExecSocket, attachExecSocket, openProxySocket, listExecSessions, listServices, internalServicesRequest, createCheckpointInternal, listServicesInternal, getServiceInternal, createServiceInternal, startServiceInternal, stopServiceInternal, execCommand, createSpritesClient;
 var init_sprites = __esm({
   "../core/src/sprites.ts"() {
     "use strict";
@@ -491,39 +491,126 @@ var init_sprites = __esm({
       return new URL(path26, `${protocol}//${base.host}`);
     };
     shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
-    requestJson = async (apiBaseUrl, token, method, path26, body) => {
-      const requestId = (0, import_node_crypto.randomUUID)();
-      const url = new URL(path26, apiBaseUrl);
-      const headers = {
-        authorization: `Bearer ${token}`,
-        "x-request-id": requestId
-      };
-      if (body) {
-        headers["content-type"] = "application/json";
-      }
-      const init = { method, headers };
-      if (body) {
-        init.body = JSON.stringify(body);
+    DEFAULT_SPRITES_HTTP_TIMEOUT_MS_IDEMPOTENT = 5e3;
+    DEFAULT_SPRITES_HTTP_TIMEOUT_MS_NON_IDEMPOTENT = 2e4;
+    DEFAULT_SPRITES_HTTP_MAX_ATTEMPTS = 5;
+    SPRITES_HTTP_RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 409, 425, 429, 500, 502, 503, 504]);
+    delay = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    isIdempotentMethod = (method) => {
+      const normalized = method.toUpperCase();
+      return normalized === "GET" || normalized === "HEAD" || normalized === "PUT" || normalized === "DELETE" || normalized === "OPTIONS";
+    };
+    computeRetryDelayMs = (attempt) => {
+      const base = 250;
+      const cap = 2500;
+      const exp = Math.min(cap, base * 2 ** Math.max(0, attempt - 1));
+      const jitter = Math.floor(Math.random() * 120);
+      return exp + jitter;
+    };
+    isAbortError = (error) => error instanceof Error && (error.name === "AbortError" || error.message.includes("aborted"));
+    getErrorCode = (error) => {
+      if (!error || typeof error !== "object") return void 0;
+      const record = error;
+      const code2 = record.code;
+      return typeof code2 === "string" || typeof code2 === "number" ? String(code2) : void 0;
+    };
+    isRetryableFetchError = (error) => {
+      if (isAbortError(error)) return true;
+      if (error instanceof TypeError) return true;
+      const code2 = getErrorCode(error);
+      return code2 === "ECONNRESET" || code2 === "ETIMEDOUT" || code2 === "EAI_AGAIN" || code2 === "ENOTFOUND" || code2 === "ECONNREFUSED";
+    };
+    shouldRetrySpritesRequest = (method, error) => {
+      if (!isIdempotentMethod(method)) return false;
+      if (error instanceof SpritesApiError) {
+        return SPRITES_HTTP_RETRYABLE_STATUSES.has(error.status);
+      }
+      return isRetryableFetchError(error);
+    };
+    withSpritesRetry = async (options) => {
+      const opId = (0, import_node_crypto.randomUUID)();
+      const timeoutMs = options.timeoutMs ?? (isIdempotentMethod(options.method) ? DEFAULT_SPRITES_HTTP_TIMEOUT_MS_IDEMPOTENT : DEFAULT_SPRITES_HTTP_TIMEOUT_MS_NON_IDEMPOTENT);
+      const maxAttemptsRaw = options.maxAttempts ?? DEFAULT_SPRITES_HTTP_MAX_ATTEMPTS;
+      const maxAttempts = isIdempotentMethod(options.method) ? Math.max(1, maxAttemptsRaw) : 1;
+      for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const requestId = (0, import_node_crypto.randomUUID)();
+        const controller = new AbortController();
+        const timeoutHandle = typeof timeoutMs === "number" && timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
+        try {
+          logger.info("sprites_request", {
+            opId,
+            attempt,
+            requestId,
+            method: options.method,
+            path: options.path,
+            timeoutMs
+          });
+          return await options.run(controller.signal, requestId);
+        } catch (error) {
+          const retryable = shouldRetrySpritesRequest(options.method, error);
+          const remaining = maxAttempts - attempt;
+          if (!retryable || remaining <= 0) {
+            throw error;
+          }
+          const delayMs = computeRetryDelayMs(attempt);
+          logger.warn("sprites_http_retry", {
+            opId,
+            attempt,
+            requestId,
+            method: options.method,
+            path: options.path,
+            timeoutMs,
+            delayMs,
+            remainingAttempts: remaining,
+            errorName: error instanceof Error ? error.name : void 0,
+            errorMessage: error instanceof Error ? error.message : String(error),
+            errorCode: getErrorCode(error),
+            ...error instanceof SpritesApiError ? { status: error.status } : {}
+          });
+          await delay(delayMs);
+        } finally {
+          if (timeoutHandle) clearTimeout(timeoutHandle);
+        }
       }
-      logger.info("sprites_request", { requestId, method, path: path26 });
-      const response = await fetch(url, init);
-      const text = await response.text();
-      logger.info("sprites_response", {
-        requestId,
+      throw new Error(`Sprites request failed: ${options.method} ${options.path}`);
+    };
+    requestJson = async (apiBaseUrl, token, method, path26, body) => {
+      return await withSpritesRetry({
         method,
         path: path26,
-        status: response.status
+        run: async (signal, requestId) => {
+          const url = new URL(path26, apiBaseUrl);
+          const headers = {
+            authorization: `Bearer ${token}`,
+            "x-request-id": requestId
+          };
+          if (body) {
+            headers["content-type"] = "application/json";
+          }
+          const init = { method, headers, signal };
+          if (body) {
+            init.body = JSON.stringify(body);
+          }
+          const response = await fetch(url, init);
+          const text = await response.text();
+          logger.info("sprites_response", {
+            requestId,
+            method,
+            path: path26,
+            status: response.status
+          });
+          if (!response.ok) {
+            const snippet = text.trim().slice(0, 200);
+            throw new SpritesApiError(response.status, method, path26, snippet);
+          }
+          if (!text) return null;
+          try {
+            return JSON.parse(text);
+          } catch {
+            return text;
+          }
+        }
       });
-      if (!response.ok) {
-        const snippet = text.trim().slice(0, 200);
-        throw new SpritesApiError(response.status, method, path26, snippet);
-      }
-      if (!text) return null;
-      try {
-        return JSON.parse(text);
-      } catch {
-        return text;
-      }
     };
     listSprites = async (apiBaseUrl, token, options) => {
       const params = new URLSearchParams();
@@ -564,88 +651,99 @@ var init_sprites = __esm({
       return response;
     };
     requestNdjson = async (apiBaseUrl, token, method, path26, body) => {
-      const requestId = (0, import_node_crypto.randomUUID)();
-      const url = new URL(path26, apiBaseUrl);
-      const headers = {
-        authorization: `Bearer ${token}`,
-        "x-request-id": requestId
-      };
-      if (body) {
-        headers["content-type"] = "application/json";
-      }
-      const init = { method, headers };
-      if (body) {
-        init.body = JSON.stringify(body);
-      }
-      logger.info("sprites_request", { requestId, method, path: path26 });
-      const response = await fetch(url, init);
-      logger.info("sprites_response", {
-        requestId,
+      return await withSpritesRetry({
         method,
         path: path26,
-        status: response.status
-      });
-      const text = await response.text();
-      if (!response.ok) {
-        const snippet = text.trim().slice(0, 200);
-        throw new SpritesApiError(response.status, method, path26, snippet);
-      }
-      const lines = text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-      const events = [];
-      for (const line of lines) {
-        try {
-          const parsed = JSON.parse(line);
-          if (Array.isArray(parsed)) {
-            for (const entry of parsed) {
-              if (entry && typeof entry === "object") {
-                events.push(entry);
-              } else {
-                events.push({ value: entry });
+        run: async (signal, requestId) => {
+          const url = new URL(path26, apiBaseUrl);
+          const headers = {
+            authorization: `Bearer ${token}`,
+            "x-request-id": requestId
+          };
+          if (body) {
+            headers["content-type"] = "application/json";
+          }
+          const init = { method, headers, signal };
+          if (body) {
+            init.body = JSON.stringify(body);
+          }
+          const response = await fetch(url, init);
+          logger.info("sprites_response", {
+            requestId,
+            method,
+            path: path26,
+            status: response.status
+          });
+          const text = await response.text();
+          if (!response.ok) {
+            const snippet = text.trim().slice(0, 200);
+            throw new SpritesApiError(response.status, method, path26, snippet);
+          }
+          const lines = text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+          const events = [];
+          for (const line of lines) {
+            try {
+              const parsed = JSON.parse(line);
+              if (Array.isArray(parsed)) {
+                for (const entry of parsed) {
+                  if (entry && typeof entry === "object") {
+                    events.push(entry);
+                  } else {
+                    events.push({ value: entry });
+                  }
+                }
+                continue;
               }
+              if (parsed && typeof parsed === "object") {
+                events.push(parsed);
+                continue;
+              }
+              events.push({ value: parsed });
+            } catch {
+              events.push({ raw: line });
             }
-            continue;
           }
-          if (parsed && typeof parsed === "object") {
-            events.push(parsed);
-            continue;
-          }
-          events.push({ value: parsed });
-        } catch {
-          events.push({ raw: line });
+          return events;
         }
-      }
-      return events;
+      });
     };
     writeFile = async (apiBaseUrl, token, name, remotePath, data) => {
-      const requestId = (0, import_node_crypto.randomUUID)();
       const path26 = `/v1/sprites/${name}/fs/write`;
       const url = new URL(path26, apiBaseUrl);
       url.searchParams.set("path", remotePath);
       url.searchParams.set("mkdir", "true");
-      logger.info("sprites_fs_write", {
-        requestId,
-        path: path26,
-        name,
-        remotePath,
-        size: data.length
-      });
-      const response = await fetch(url, {
+      await withSpritesRetry({
         method: "PUT",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/octet-stream",
-          "x-request-id": requestId
-        },
-        body: data
-      });
-      logger.info("sprites_fs_write_response", {
-        requestId,
         path: path26,
-        status: response.status
+        run: async (signal, requestId) => {
+          logger.info("sprites_fs_write", {
+            requestId,
+            path: path26,
+            name,
+            remotePath,
+            size: data.length
+          });
+          const response = await fetch(url, {
+            method: "PUT",
+            headers: {
+              authorization: `Bearer ${token}`,
+              "content-type": "application/octet-stream",
+              "x-request-id": requestId
+            },
+            body: data,
+            signal
+          });
+          logger.info("sprites_fs_write_response", {
+            requestId,
+            path: path26,
+            status: response.status
+          });
+          if (!response.ok) {
+            const snippet = (await response.text()).trim().slice(0, 200);
+            throw new SpritesApiError(response.status, "PUT", path26, snippet);
+          }
+        }
       });
-      if (!response.ok) {
-        throw new Error(`Sprites FS write failed: ${response.status}`);
-      }
     };
     normalizeServiceRecord = (entry) => {
       const rawName = entry.name;
@@ -676,38 +774,44 @@ var init_sprites = __esm({
       return service;
     };
     readFile = async (apiBaseUrl, token, name, options) => {
-      const requestId = (0, import_node_crypto.randomUUID)();
       const path26 = `/v1/sprites/${name}/fs/read`;
       const url = new URL(path26, apiBaseUrl);
       url.searchParams.set("path", options.path);
       if (options.workingDir) {
         url.searchParams.set("workingDir", options.workingDir);
       }
-      logger.info("sprites_fs_read", {
-        requestId,
-        path: path26,
-        name,
-        remotePath: options.path,
-        workingDir: options.workingDir
-      });
-      const response = await fetch(url, {
+      return await withSpritesRetry({
         method: "GET",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "x-request-id": requestId
-        }
-      });
-      logger.info("sprites_fs_read_response", {
-        requestId,
         path: path26,
-        status: response.status
+        run: async (signal, requestId) => {
+          logger.info("sprites_fs_read", {
+            requestId,
+            path: path26,
+            name,
+            remotePath: options.path,
+            workingDir: options.workingDir
+          });
+          const response = await fetch(url, {
+            method: "GET",
+            headers: {
+              authorization: `Bearer ${token}`,
+              "x-request-id": requestId
+            },
+            signal
+          });
+          logger.info("sprites_fs_read_response", {
+            requestId,
+            path: path26,
+            status: response.status
+          });
+          if (!response.ok) {
+            const snippet = (await response.text()).trim().slice(0, 200);
+            throw new SpritesApiError(response.status, "GET", path26, snippet);
+          }
+          const buffer = await response.arrayBuffer();
+          return new Uint8Array(buffer);
+        }
       });
-      if (!response.ok) {
-        const snippet = (await response.text()).trim().slice(0, 200);
-        throw new SpritesApiError(response.status, "GET", path26, snippet);
-      }
-      const buffer = await response.arrayBuffer();
-      return new Uint8Array(buffer);
     };
     openExecSocket = (apiBaseUrl, token, name, options) => {
       const url = toWsUrl(apiBaseUrl, `/v1/sprites/${name}/exec`);
@@ -931,7 +1035,7 @@ var init_sprites = __esm({
       await internalServicesRequest(apiBaseUrl, token, name, command);
       return [];
     };
-    execCommand = async (apiBaseUrl, token, name, cmd, requestId) => {
+    execCommand = async (apiBaseUrl, token, name, cmd, requestId, options) => {
       const path26 = `/v1/sprites/${name}/exec`;
       const url = toWsUrl(apiBaseUrl, path26);
       cmd.forEach((part) => url.searchParams.append("cmd", part));
@@ -942,11 +1046,28 @@ var init_sprites = __esm({
         const stderr = [];
         let exitCode = null;
         let resolved = false;
+        const timeoutMs = options?.timeoutMs;
+        const handshakeTimeoutMs = options?.handshakeTimeoutMs ?? (typeof timeoutMs === "number" ? Math.min(timeoutMs, 6e4) : void 0);
+        const timeoutHandle = typeof timeoutMs === "number" && timeoutMs > 0 ? setTimeout(() => {
+          if (resolved) return;
+          resolved = true;
+          logger.warn("sprites_exec_timeout", {
+            requestId,
+            path: path26,
+            timeoutMs
+          });
+          try {
+            ws.terminate();
+          } catch {
+          }
+          reject(new Error(`Exec websocket timed out after ${timeoutMs}ms`));
+        }, timeoutMs) : null;
         const ws = new import_ws.default(url.toString(), {
           headers: {
             Authorization: `Bearer ${token}`,
             "x-request-id": requestId
-          }
+          },
+          ...typeof handshakeTimeoutMs === "number" && handshakeTimeoutMs > 0 ? { handshakeTimeout: handshakeTimeoutMs } : {}
         });
         const readResponseSnippet = async (response, limit = 800) => new Promise((resolveBody) => {
           let body = "";
@@ -972,6 +1093,8 @@ var init_sprites = __esm({
               bodySnippet: snippet ? snippet.slice(0, 800) : void 0
             });
             if (!resolved) {
+              if (timeoutHandle) clearTimeout(timeoutHandle);
+              resolved = true;
               const suffix = snippet ? ` (${snippet.slice(0, 800)})` : "";
               reject(new Error(`Exec websocket error: Unexpected server response: ${status}${suffix}`));
             }
@@ -980,6 +1103,7 @@ var init_sprites = __esm({
         const finish = (code2) => {
           if (resolved) return;
           resolved = true;
+          if (timeoutHandle) clearTimeout(timeoutHandle);
           logger.info("sprites_exec_response", { requestId, path: path26, status: code2 });
           resolve({
             exitCode: code2,
@@ -1037,6 +1161,8 @@ var init_sprites = __esm({
             errorStack: errorInfo.stack
           });
           if (!resolved) {
+            if (timeoutHandle) clearTimeout(timeoutHandle);
+            resolved = true;
             reject(new Error(`Exec websocket error: ${errorMessage}`));
           }
         };
@@ -1091,7 +1217,7 @@ var init_sprites = __esm({
         await writeFile(apiBaseUrl, token, name, remotePath, data);
       },
       readFile: async (name, options) => readFile(apiBaseUrl, token, name, options),
-      exec: async (name, cmd) => {
+      exec: async (name, cmd, options) => {
         const requestId = (0, import_node_crypto.randomUUID)();
         logger.info("sprites_exec", {
           requestId,
@@ -1099,7 +1225,7 @@ var init_sprites = __esm({
           cmd,
           path: `/v1/sprites/${name}/exec`
         });
-        return execCommand(apiBaseUrl, token, name, cmd, requestId);
+        return execCommand(apiBaseUrl, token, name, cmd, requestId, options);
       },
       listExecSessions: async (name) => listExecSessions(apiBaseUrl, token, name),
       listServices: async (name) => USE_INTERNAL_SERVICE_API ? listServicesInternal(apiBaseUrl, token, name) : listServices(apiBaseUrl, token, name),
@@ -4726,27 +4852,27 @@ var init_authentication_manager = __esm({
           );
           return;
         }
-        let delay = Math.min(
+        let delay3 = Math.min(
           MAXIMUM_REFRESH_DELAY,
           (tokenValiditySeconds - this.refreshTokenLeewaySeconds) * 1e3
         );
-        if (delay <= 0) {
+        if (delay3 <= 0) {
           this.logger.warn(
             `Refetching auth token immediately, configured leeway ${this.refreshTokenLeewaySeconds}s is larger than the token's lifetime ${tokenValiditySeconds}s`
           );
-          delay = 0;
+          delay3 = 0;
         }
         const refetchTokenTimeoutId = setTimeout(() => {
           this._logVerbose("running scheduled token refetch");
           void this.refetchToken();
-        }, delay);
+        }, delay3);
         this.setAuthState({
           state: "waitingForScheduledRefetch",
           refetchTokenTimeoutId,
           config: this.authState.config
         });
         this._logVerbose(
-          `scheduled preemptive auth token refetching in ${delay}ms`
+          `scheduled preemptive auth token refetching in ${delay3}ms`
         );
       }
       // Protects against simultaneous calls to `setConfig`
@@ -19741,8 +19867,8 @@ var init_connect = __esm({
           pendingPortLogs.set(event.port, token2);
           const delays = [30, 60, 120, 200];
           void (async () => {
-            for (const delay of delays) {
-              await new Promise((resolve) => setTimeout(resolve, delay));
+            for (const delay3 of delays) {
+              await new Promise((resolve) => setTimeout(resolve, delay3));
               if (pendingPortLogs.get(event.port) !== token2) {
                 return;
               }
@@ -22317,7 +22443,7 @@ var init_weztermMux = __esm({
 });
 
 // src/devbox/commands/init/remote.ts
-var import_node_crypto10, DAEMON_DIR, DAEMON_TARBALL, DAEMON_BUNDLE_DIR, DAEMON_ENTRY, DAEMON_WRAPPER, DAEMON_SERVICE_NAME, DAEMON_CONFIG_FILE, DEFAULT_DAEMON_BASE_URL, DEFAULT_HEARTBEAT_MS, logger8, truncateTail, shellQuote3, expandHome2, execWithLog, writeRemoteFile, bootstrapDevbox, buildWeztermMuxConfig, buildWeztermMuxRunner, patchBashrc, writeRemoteCodexConfig, stageRemoteSetupArtifacts, resolveDaemonUrl, fetchDaemonBinary, buildDaemonConfig, isSameArgs, ensureSpriteDaemonService, installWeztermMux, ensureWeztermMuxService, hasWeztermMuxBinary, isWeztermMuxHealthy, installSpriteDaemon;
+var import_node_crypto10, DAEMON_DIR, DAEMON_TARBALL, DAEMON_BUNDLE_DIR, DAEMON_ENTRY, DAEMON_WRAPPER, DAEMON_SERVICE_NAME, DAEMON_CONFIG_FILE, DEFAULT_DAEMON_BASE_URL, DEFAULT_HEARTBEAT_MS, BOOTSTRAP_EXEC_TIMEOUT_MS, BOOTSTRAP_EXEC_RETRY_DELAY_MS, logger8, truncateTail, shellQuote3, expandHome2, execWithLog, isExecTimeoutError, delay2, writeRemoteFile, bootstrapDevbox, buildWeztermMuxConfig, buildWeztermMuxRunner, patchBashrc, writeRemoteCodexConfig, stageRemoteSetupArtifacts, resolveDaemonUrl, fetchDaemonBinary, buildDaemonConfig, isSameArgs, ensureSpriteDaemonService, installWeztermMux, ensureWeztermMuxService, hasWeztermMuxBinary, isWeztermMuxHealthy, installSpriteDaemon;
 var init_remote = __esm({
   "src/devbox/commands/init/remote.ts"() {
     "use strict";
@@ -22335,6 +22461,8 @@ var init_remote = __esm({
     DAEMON_CONFIG_FILE = `${DAEMON_DIR}/config.json`;
     DEFAULT_DAEMON_BASE_URL = process.env.SPRITE_DAEMON_BASE_URL?.trim() || "https://deploy-dev.boxes.dev";
     DEFAULT_HEARTBEAT_MS = 3e4;
+    BOOTSTRAP_EXEC_TIMEOUT_MS = 9e4;
+    BOOTSTRAP_EXEC_RETRY_DELAY_MS = 1e4;
     logger8 = createLogger("devbox-init");
     truncateTail = (value, maxChars) => {
       if (value.length <= maxChars) return value;
@@ -22348,7 +22476,7 @@ var init_remote = __esm({
       }
       return value;
     };
-    execWithLog = async (client, canonical, script, stage) => {
+    execWithLog = async (client, canonical, script, stage, options) => {
       const requestId = (0, import_node_crypto10.randomUUID)();
       const startedAt2 = Date.now();
       logger8.info("sprites_request", {
@@ -22358,7 +22486,11 @@ var init_remote = __esm({
         box: canonical,
         stage
       });
-      const result = await client.exec(canonical, ["/bin/bash", "-lc", script]);
+      const result = await client.exec(
+        canonical,
+        ["/bin/bash", "-lc", script],
+        options
+      );
       const durationMs = Date.now() - startedAt2;
       logger8.info("sprites_response", {
         requestId,
@@ -22378,6 +22510,8 @@ var init_remote = __esm({
       });
       return result;
     };
+    isExecTimeoutError = (error) => error instanceof Error && typeof error.message === "string" && error.message.startsWith("Exec websocket timed out after ");
+    delay2 = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     writeRemoteFile = async (client, canonical, path26, content, stage) => {
       const requestId = (0, import_node_crypto10.randomUUID)();
       logger8.info("sprites_request", {
@@ -22409,12 +22543,28 @@ var init_remote = __esm({
         "  sudo -n chown -R sprite:sprite /home/sprite/.devbox || true",
         "fi"
       ].join("\n");
-      const permsResult = await execWithLog(
+      let permsResult = await execWithLog(
         client,
         canonical,
         permissionsScript,
-        "bootstrap-permissions"
-      );
+        "bootstrap-permissions",
+        { timeoutMs: BOOTSTRAP_EXEC_TIMEOUT_MS }
+      ).catch(async (error) => {
+        if (!isExecTimeoutError(error)) throw error;
+        logger8.warn("sprites_exec_retry_after_timeout", {
+          stage: "bootstrap-permissions",
+          timeoutMs: BOOTSTRAP_EXEC_TIMEOUT_MS,
+          delayMs: BOOTSTRAP_EXEC_RETRY_DELAY_MS
+        });
+        await delay2(BOOTSTRAP_EXEC_RETRY_DELAY_MS);
+        return await execWithLog(
+          client,
+          canonical,
+          permissionsScript,
+          "bootstrap-permissions",
+          { timeoutMs: BOOTSTRAP_EXEC_TIMEOUT_MS }
+        );
+      });
       if (permsResult.exitCode !== 0) {
         const details = permsResult.stderr || permsResult.stdout || "";
         throw new Error(
@@ -22434,7 +22584,8 @@ var init_remote = __esm({
         client,
         canonical,
         ipv4PreferenceScript,
-        "bootstrap-ipv4-preference"
+        "bootstrap-ipv4-preference",
+        { timeoutMs: BOOTSTRAP_EXEC_TIMEOUT_MS }
       );
       if (ipv4Result.exitCode !== 0) {
         const details = ipv4Result.stderr || ipv4Result.stdout || "";
@@ -23079,30 +23230,34 @@ chmod 755 ${WEZTERM_MUX_RUNNER_PATH}`,
         DAEMON_CONFIG_FILE,
         Buffer.from(buildDaemonConfig(convexUrl, heartbeatToken))
       );
-      const result = await client.exec(spriteName, [
-        "/bin/bash",
-        "--noprofile",
-        "--norc",
-        "-e",
-        "-u",
-        "-o",
-        "pipefail",
-        "-c",
+      const result = await client.exec(
+        spriteName,
         [
-          `mkdir -p ${DAEMON_DIR}`,
-          `rm -rf ${DAEMON_BUNDLE_DIR}`,
-          `mkdir -p ${DAEMON_BUNDLE_DIR}`,
-          `tar -xzf ${DAEMON_TARBALL} -C ${DAEMON_BUNDLE_DIR}`,
-          `chmod 755 ${DAEMON_ENTRY} || true`,
-          `chmod 755 ${DAEMON_BUNDLE_DIR}/bin/* || true`,
+          "/bin/bash",
+          "--noprofile",
+          "--norc",
+          "-e",
+          "-u",
+          "-o",
+          "pipefail",
+          "-c",
           [
-            `${DAEMON_ENTRY} daemonctl install --json --timeout-ms 20000`,
-            `--tarball ${DAEMON_TARBALL}`,
-            `--release-sha ${release.sha256}`,
-            `--config-path ${DAEMON_CONFIG_FILE}`
-          ].join(" ")
-        ].join("\n")
-      ]);
+            `mkdir -p ${DAEMON_DIR}`,
+            `rm -rf ${DAEMON_BUNDLE_DIR}`,
+            `mkdir -p ${DAEMON_BUNDLE_DIR}`,
+            `tar -xzf ${DAEMON_TARBALL} -C ${DAEMON_BUNDLE_DIR}`,
+            `chmod 755 ${DAEMON_ENTRY} || true`,
+            `chmod 755 ${DAEMON_BUNDLE_DIR}/bin/* || true`,
+            [
+              `${DAEMON_ENTRY} daemonctl install --json --timeout-ms 20000`,
+              `--tarball ${DAEMON_TARBALL}`,
+              `--release-sha ${release.sha256}`,
+              `--config-path ${DAEMON_CONFIG_FILE}`
+            ].join(" ")
+          ].join("\n")
+        ],
+        { timeoutMs: 12e4 }
+      );
       if (result.exitCode !== 0) {
         throw new Error(result.stderr || result.stdout || "Daemon install failed.");
       }
@@ -23892,17 +24047,26 @@ var init_template = __esm({
 });
 
 // src/devbox/commands/init/codex/prompts.ts
-var import_promises23, import_node_path17, resolvePromptsDir, readPromptTemplate, loadPrompt, loadLocalEnvSecretsScanPrompt, loadLocalExternalScanPrompt, loadLocalExtraArtifactsScanPrompt, loadLocalServicesScanPrompt;
+var import_node_fs5, import_promises23, import_node_path17, resolvePromptsDir, readPromptTemplate, loadPrompt, loadLocalEnvSecretsScanPrompt, loadLocalExternalScanPrompt, loadLocalExtraArtifactsScanPrompt, loadLocalServicesScanPrompt;
 var init_prompts = __esm({
   "src/devbox/commands/init/codex/prompts.ts"() {
     "use strict";
+    import_node_fs5 = __toESM(require("node:fs"), 1);
     import_promises23 = __toESM(require("node:fs/promises"), 1);
     import_node_path17 = __toESM(require("node:path"), 1);
     init_template();
     resolvePromptsDir = () => {
-      const binPath = process.argv[1];
-      if (binPath) {
-        return import_node_path17.default.resolve(import_node_path17.default.dirname(binPath), "..", "prompts");
+      const argv1 = typeof process.argv[1] === "string" ? process.argv[1] : "";
+      if (argv1) {
+        try {
+          const real = import_node_fs5.default.realpathSync(argv1);
+          return import_node_path17.default.resolve(import_node_path17.default.dirname(real), "..", "prompts");
+        } catch {
+        }
+        try {
+          return import_node_path17.default.resolve(import_node_path17.default.dirname(argv1), "..", "prompts");
+        } catch {
+        }
       }
       return import_node_path17.default.resolve(process.cwd(), "prompts");
     };
@@ -24424,21 +24588,25 @@ fi`
 });
 
 // src/devbox/commands/init/codex/plan.ts
-var import_node_path18, import_promises24, resolveSchemaPath, writeSetupEnvSecretsSchema, writeSetupExternalSchema, writeSetupExtraArtifactsSchema, writeServicesSchema, isObject4, isServicesSelection, isSetupPlan, isSetupEnvSecretsPlan, isSetupExternalPlan, isSetupExtraArtifactsPlan, isServicesPlan, readSetupPlan, readSetupEnvSecretsPlan, readSetupExternalPlan, readSetupExtraArtifactsPlan, readServicesPlan, writeSetupPlan, mergeSetupScans;
+var import_node_path18, import_node_fs6, import_promises24, resolveSchemaPath, writeSetupEnvSecretsSchema, writeSetupExternalSchema, writeSetupExtraArtifactsSchema, writeServicesSchema, isObject4, isServicesSelection, isSetupPlan, isSetupEnvSecretsPlan, isSetupExternalPlan, isSetupExtraArtifactsPlan, isServicesPlan, readSetupPlan, readSetupEnvSecretsPlan, readSetupExternalPlan, readSetupExtraArtifactsPlan, readServicesPlan, writeSetupPlan, mergeSetupScans;
 var init_plan = __esm({
   "src/devbox/commands/init/codex/plan.ts"() {
     "use strict";
     import_node_path18 = __toESM(require("node:path"), 1);
+    import_node_fs6 = __toESM(require("node:fs"), 1);
     import_promises24 = __toESM(require("node:fs/promises"), 1);
     resolveSchemaPath = (fileName) => {
-      const binPath = process.argv[1];
-      if (binPath) {
-        return import_node_path18.default.resolve(
-          import_node_path18.default.dirname(binPath),
-          "..",
-          "codex",
-          fileName
-        );
+      const argv1 = typeof process.argv[1] === "string" ? process.argv[1] : "";
+      if (argv1) {
+        try {
+          const real = import_node_fs6.default.realpathSync(argv1);
+          return import_node_path18.default.resolve(import_node_path18.default.dirname(real), "..", "codex", fileName);
+        } catch {
+        }
+        try {
+          return import_node_path18.default.resolve(import_node_path18.default.dirname(argv1), "..", "codex", fileName);
+        } catch {
+        }
       }
       return import_node_path18.default.resolve(process.cwd(), "codex", fileName);
     };
@@ -24728,12 +24896,12 @@ ${bottom}
 });
 
 // src/devbox/commands/init/codex/local.ts
-var import_node_child_process9, import_node_fs5, import_promises25, import_node_path19, stripAnsi3, extractBoldText2, runCodexExec, runLocalSetupEnvSecretsScan, runLocalSetupExternalScan, runLocalSetupExtraArtifactsScan, runLocalServicesScan, toPosixPath, toRepoRelativePath, countSecretVars, buildEnvFileHint, buildExternalDependencyLabel, promptForPlanApproval, promptForServicesApproval;
+var import_node_child_process9, import_node_fs7, import_promises25, import_node_path19, stripAnsi3, extractBoldText2, runCodexExec, runLocalSetupEnvSecretsScan, runLocalSetupExternalScan, runLocalSetupExtraArtifactsScan, runLocalServicesScan, toPosixPath, toRepoRelativePath, countSecretVars, buildEnvFileHint, buildExternalDependencyLabel, promptForPlanApproval, promptForServicesApproval;
 var init_local = __esm({
   "src/devbox/commands/init/codex/local.ts"() {
     "use strict";
     import_node_child_process9 = require("node:child_process");
-    import_node_fs5 = require("node:fs");
+    import_node_fs7 = require("node:fs");
     import_promises25 = __toESM(require("node:fs/promises"), 1);
     import_node_path19 = __toESM(require("node:path"), 1);
     init_dist2();
@@ -24752,11 +24920,11 @@ var init_local = __esm({
       try {
         if (stdoutLogPath) {
           await import_promises25.default.mkdir(import_node_path19.default.dirname(stdoutLogPath), { recursive: true });
-          stdoutStream = (0, import_node_fs5.createWriteStream)(stdoutLogPath, { flags: "a" });
+          stdoutStream = (0, import_node_fs7.createWriteStream)(stdoutLogPath, { flags: "a" });
         }
         if (stderrLogPath) {
           await import_promises25.default.mkdir(import_node_path19.default.dirname(stderrLogPath), { recursive: true });
-          stderrStream = (0, import_node_fs5.createWriteStream)(stderrLogPath, { flags: "a" });
+          stderrStream = (0, import_node_fs7.createWriteStream)(stderrLogPath, { flags: "a" });
         }
       } catch {
         stdoutStream = null;
@@ -32199,7 +32367,7 @@ var init_cli = __esm({
 });
 
 // src/bin/dvb.ts
-var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
 var import_node_os11 = __toESM(require("node:os"), 1);
 var import_node_path26 = __toESM(require("node:path"), 1);
 init_src();
@@ -32257,8 +32425,8 @@ run().catch((error) => {
     if (homeDir) {
       try {
         const logDir = import_node_path26.default.join(resolveDevboxDir(homeDir), "wezterm");
-        import_node_fs6.default.mkdirSync(logDir, { recursive: true });
-        import_node_fs6.default.appendFileSync(
+        import_node_fs8.default.mkdirSync(logDir, { recursive: true });
+        import_node_fs8.default.appendFileSync(
           import_node_path26.default.join(logDir, "proxy.log"),
           `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
 `