deepspace 0.4.1 → 0.4.3

package/dist/cli.js

@@ -3,14 +3,14 @@
 // src/cli/cli.ts
 import { defineCommand as defineCommand19, runMain } from "citty";
 import { execSync as execSync5 } from "child_process";
-import { readFileSync as readFileSync11, existsSync as existsSync14 } from "fs";
-import { dirname as dirname2, join as join16 } from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync12 } from "fs";
+import { dirname as dirname3, join as join14 } from "path";
 import { fileURLToPath } from "url";
 
 // src/cli/commands/login.ts
 import { defineCommand } from "citty";
 import { writeFileSync as writeFileSync2, mkdirSync } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { homedir } from "os";
 import { exec } from "child_process";
 import { platform } from "os";
@@ -35,7 +35,11 @@ function createSpinner() {
 }
 
 // src/cli/env.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/cli/lib/wrangler-env.ts
+import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { parse as parseToml } from "smol-toml";
 
@@ -92,6 +96,57 @@ function sanitizeAppName(raw) {
   return raw.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
 }
 
+// src/cli/lib/wrangler-env.ts
+function resolveAppNameForEnv(config, envName) {
+  if (!envName) {
+    return resolveAppName(config.name);
+  }
+  const envBlock = config.env?.[envName];
+  if (!envBlock) {
+    return {
+      ok: false,
+      reason: `wrangler.toml: no [env.${envName}] block found. Add one with a distinct \`name\` to deploy this environment.`
+    };
+  }
+  if (typeof envBlock.name !== "string" || envBlock.name.trim() === "") {
+    return {
+      ok: false,
+      reason: `wrangler.toml: [env.${envName}].name is missing. Set a distinct app name (e.g. "${typeof config.name === "string" ? config.name : "myapp"}-${envName}") so this environment doesn't overwrite the default.`
+    };
+  }
+  if (envBlock.name === config.name) {
+    return {
+      ok: false,
+      reason: `wrangler.toml: [env.${envName}].name "${envBlock.name}" is the same as the top-level name. Pick a distinct name (e.g. "${config.name}-${envName}") so deploys don't collide.`
+    };
+  }
+  return resolveAppName(envBlock.name);
+}
+function devVarsPathFor(appDir, envName) {
+  return envName ? join(appDir, `.dev.vars.${envName}`) : join(appDir, ".dev.vars");
+}
+var WranglerConfigError = class extends Error {
+  constructor(path, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`wrangler.toml: malformed TOML at ${path}: ${detail}`);
+    this.path = path;
+    this.cause = cause;
+    this.name = "WranglerConfigError";
+  }
+};
+function readWranglerConfig(appDir) {
+  const path = join(appDir, "wrangler.toml");
+  const raw = readFileSync(path, "utf-8");
+  try {
+    return parseToml(raw);
+  } catch (err) {
+    throw new WranglerConfigError(path, err);
+  }
+}
+function hasWranglerConfig(appDir) {
+  return existsSync(join(appDir, "wrangler.toml"));
+}
+
 // src/cli/env.ts
 var ENV_URLS = {
   auth: "https://auth.deep.space",
@@ -115,19 +170,18 @@ async function fetchPublicKey(authUrl) {
   }
   return data.publicKey;
 }
-function readAppName(appDir) {
-  const wranglerPath = join(appDir, "wrangler.toml");
-  if (!existsSync(wranglerPath)) {
+function readAppName(appDir, wranglerEnv) {
+  if (!hasWranglerConfig(appDir)) {
     throw new Error("No wrangler.toml found. Are you in a DeepSpace app directory?");
   }
-  const parsed = parseToml(readFileSync(wranglerPath, "utf-8"));
-  const resolved = resolveAppName(parsed.name);
-  if (!resolved.ok) {
-    throw new Error(`wrangler.toml: ${resolved.reason}`);
-  }
-  if (parsed.name !== resolved.name) {
+  const config = readWranglerConfig(appDir);
+  const resolved = resolveAppNameForEnv(config, wranglerEnv);
+  if (!resolved.ok) throw new Error(resolved.reason);
+  const rawName = wranglerEnv ? config.env?.[wranglerEnv]?.name : config.name;
+  if (rawName !== resolved.name) {
+    const where = wranglerEnv ? `[env.${wranglerEnv}].name` : "`name`";
     throw new Error(
-      `wrangler.toml: name "${parsed.name}" is not in canonical form. Update \`name\` to "${resolved.name}" and re-run.`
+      `wrangler.toml: ${where} "${rawName}" is not in canonical form. Update it to "${resolved.name}" and re-run.`
     );
   }
   return resolved.name;
@@ -187,10 +241,12 @@ var DEV_VARS_DIVIDER = "# --- not managed by the SDK; preserved across dev/test
 function extractCustomDevVars(content) {
   const lines = content.split("\n");
   const out = [];
+  let belowDivider = false;
   let i = 0;
   while (i < lines.length) {
     const line = lines[i];
     if (line.trim() === DEV_VARS_DIVIDER.trim()) {
+      belowDivider = true;
       i++;
       continue;
     }
@@ -215,7 +271,7 @@ function extractCustomDevVars(content) {
     } else {
       i++;
     }
-    if (!SDK_MANAGED_KEYS.has(key)) {
+    if (belowDivider || !SDK_MANAGED_KEYS.has(key)) {
       out.push(...block);
     }
   }
@@ -287,10 +343,10 @@ function parseDevVars(content) {
   }
   return result;
 }
-async function writeDevVars(appDir, env, ownerId, callerJwt) {
+async function writeDevVars(appDir, env, ownerId, callerJwt, wranglerEnv) {
   const urls = ENVS[env];
   const publicKey = await fetchPublicKey(urls.auth);
-  const appName = readAppName(appDir);
+  const appName = readAppName(appDir, wranglerEnv);
   const appOwnerJwt = await mintAppOwnerJwt(urls.auth, callerJwt, appName);
   const appIdentityToken = await fetchAppIdentityToken(urls.deploy, callerJwt, appName);
   const sdkVars = [
@@ -306,8 +362,8 @@ async function writeDevVars(appDir, env, ownerId, callerJwt) {
     // Production secrets never set this, so deployed apps 404 the route.
     `ALLOW_DEBUG_ROUTES=true`
   ].join("\n");
-  const devVarsPath = join(appDir, ".dev.vars");
-  const existing = existsSync(devVarsPath) ? readFileSync(devVarsPath, "utf-8") : "";
+  const devVarsPath = join2(appDir, wranglerEnv ? `.dev.vars.${wranglerEnv}` : ".dev.vars");
+  const existing = existsSync2(devVarsPath) ? readFileSync2(devVarsPath, "utf-8") : "";
   const custom = extractCustomDevVars(existing);
   const body = custom ? `${sdkVars}
 
@@ -431,10 +487,10 @@ async function pollForCompletion(sessionId, codeVerifier) {
   return null;
 }
 function storeCredentials(sessionToken, jwt) {
-  const dir = join2(homedir(), ".deepspace");
+  const dir = join3(homedir(), ".deepspace");
   mkdirSync(dir, { recursive: true, mode: 448 });
-  writeFileSync2(join2(dir, "session"), sessionToken, { mode: 384 });
-  writeFileSync2(join2(dir, "token"), jwt, { mode: 384 });
+  writeFileSync2(join3(dir, "session"), sessionToken, { mode: 384 });
+  writeFileSync2(join3(dir, "token"), jwt, { mode: 384 });
 }
 function openBrowser(url) {
   const cmd = platform() === "darwin" ? `open "${url}"` : platform() === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
@@ -473,20 +529,20 @@ async function doEmailLogin(email, password) {
 
 // src/cli/commands/logout.ts
 import { defineCommand as defineCommand2 } from "citty";
-import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir2 } from "os";
 var AUTH_URL2 = process.env.DEEPSPACE_AUTH_URL ?? ENVS.prod.auth;
-var DIR = join3(homedir2(), ".deepspace");
-var SESSION_PATH = join3(DIR, "session");
-var TOKEN_PATH = join3(DIR, "token");
+var DIR = join4(homedir2(), ".deepspace");
+var SESSION_PATH = join4(DIR, "session");
+var TOKEN_PATH = join4(DIR, "token");
 var logout_default = defineCommand2({
   meta: {
     name: "logout",
     description: "Sign out and remove cached credentials"
   },
   async run() {
-    const sessionToken = existsSync2(SESSION_PATH) ? readFileSync2(SESSION_PATH, "utf-8").trim() : null;
+    const sessionToken = existsSync3(SESSION_PATH) ? readFileSync3(SESSION_PATH, "utf-8").trim() : null;
     if (sessionToken) {
       try {
         await fetch(`${AUTH_URL2}/api/auth/sign-out`, {
@@ -501,7 +557,7 @@ var logout_default = defineCommand2({
     }
     let removed = 0;
     for (const path of [SESSION_PATH, TOKEN_PATH]) {
-      if (existsSync2(path)) {
+      if (existsSync3(path)) {
         rmSync(path);
         removed++;
       }
@@ -516,13 +572,12 @@ var logout_default = defineCommand2({
 
 // src/cli/commands/dev.ts
 import { defineCommand as defineCommand3 } from "citty";
-import { existsSync as existsSync6 } from "fs";
-import { join as join6, resolve as resolve2 } from "path";
+import { resolve as resolve3, basename } from "path";
 import spawn from "cross-spawn";
 
 // src/cli/auth.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/cli/jwt.ts
@@ -536,20 +591,20 @@ function decodeJwtPayload(token2) {
 
 // src/cli/auth.ts
 var AUTH_URL3 = process.env.DEEPSPACE_AUTH_URL ?? ENVS.prod.auth;
-var DIR2 = join4(homedir3(), ".deepspace");
-var SESSION_PATH2 = join4(DIR2, "session");
-var TOKEN_PATH2 = join4(DIR2, "token");
+var DIR2 = join5(homedir3(), ".deepspace");
+var SESSION_PATH2 = join5(DIR2, "session");
+var TOKEN_PATH2 = join5(DIR2, "token");
 async function ensureToken() {
-  if (existsSync3(TOKEN_PATH2)) {
-    const existing = readFileSync3(TOKEN_PATH2, "utf-8").trim();
+  if (existsSync4(TOKEN_PATH2)) {
+    const existing = readFileSync4(TOKEN_PATH2, "utf-8").trim();
     if (isTokenValid(existing)) {
       return existing;
     }
   }
-  if (!existsSync3(SESSION_PATH2)) {
+  if (!existsSync4(SESSION_PATH2)) {
     throw new Error("Not logged in. Run `deepspace login` first.");
   }
-  const sessionToken = readFileSync3(SESSION_PATH2, "utf-8").trim();
+  const sessionToken = readFileSync4(SESSION_PATH2, "utf-8").trim();
   const token2 = await exchangeSession(AUTH_URL3, sessionToken);
   if (!token2) {
     throw new Error("Session expired. Run `deepspace login` to re-authenticate.");
@@ -567,27 +622,86 @@ function isTokenValid(jwt) {
   }
 }
 
+// src/cli/lib/app-context.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join6, resolve, dirname } from "path";
+import { parse as parseToml2 } from "smol-toml";
+function detectAppName(cwd = process.cwd()) {
+  const wranglerPath = join6(resolve(cwd), "wrangler.toml");
+  if (!existsSync5(wranglerPath)) return null;
+  try {
+    const cfg = parseToml2(readFileSync5(wranglerPath, "utf-8"));
+    return typeof cfg.name === "string" && cfg.name.length > 0 ? cfg.name : null;
+  } catch {
+    return null;
+  }
+}
+function requireAppName(explicit, cwd) {
+  if (explicit) return explicit;
+  const detected = detectAppName(cwd);
+  if (detected) return detected;
+  throw new Error(
+    "No app specified. Pass --app <name>, or run from an app directory with a wrangler.toml."
+  );
+}
+function findAppDir(start = process.cwd()) {
+  let dir = resolve(start);
+  for (; ; ) {
+    if (existsSync5(join6(dir, "wrangler.toml"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function findChildApps(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync5(join6(dir, e.name, "wrangler.toml"))).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+function writeLaunchConfigIfMissing(appDir, appName, port) {
+  const launchPath = join6(appDir, ".claude", "launch.json");
+  if (existsSync5(launchPath)) return;
+  const config = {
+    version: "0.0.1",
+    configurations: [
+      {
+        name: appName,
+        runtimeExecutable: "npx",
+        runtimeArgs: ["deepspace", "dev", "--port", String(port)],
+        port
+      }
+    ]
+  };
+  try {
+    mkdirSync3(join6(appDir, ".claude"), { recursive: true });
+    writeFileSync4(launchPath, JSON.stringify(config, null, 2) + "\n");
+  } catch {
+  }
+}
+
 // src/cli/lib/install-status.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
 function ensureInstallReady(appDir) {
-  if (existsSync4(join5(appDir, "node_modules", "deepspace", "package.json"))) return;
-  const sentinelDir = join5(appDir, ".deepspace");
-  const errPath = join5(sentinelDir, "install.err");
-  const startedPath = join5(sentinelDir, "install.started");
-  const donePath = join5(sentinelDir, "install.done");
-  const logPath = join5(sentinelDir, "install.log");
-  if (existsSync4(errPath)) {
+  if (existsSync6(join7(appDir, "node_modules", "deepspace", "package.json"))) return;
+  const sentinelDir = join7(appDir, ".deepspace");
+  const errPath = join7(sentinelDir, "install.err");
+  const startedPath = join7(sentinelDir, "install.started");
+  const donePath = join7(sentinelDir, "install.done");
+  const logPath = join7(sentinelDir, "install.log");
+  if (existsSync6(errPath)) {
     console.error("Background install failed:");
-    console.error(readFileSync4(errPath, "utf-8").trimEnd());
-    if (existsSync4(logPath)) console.error(`
+    console.error(readFileSync6(errPath, "utf-8").trimEnd());
+    if (existsSync6(logPath)) console.error(`
 Full log: ${logPath}`);
     console.error("\nRun `npm install` (or `bun install`) manually, then retry.");
     process.exit(1);
   }
-  if (existsSync4(startedPath) && !existsSync4(donePath)) {
+  if (existsSync6(startedPath) && !existsSync6(donePath)) {
     console.error("Dependencies are still installing in the background.");
-    if (existsSync4(logPath)) console.error(`Tail progress: tail -f ${logPath}`);
+    if (existsSync6(logPath)) console.error(`Tail progress: tail -f ${logPath}`);
     console.error("Retry once it finishes.");
     process.exit(1);
   }
@@ -597,12 +711,12 @@ Full log: ${logPath}`);
 
 // src/cli/lib/preflight.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve2 } from "path";
 var DLL_NOT_FOUND = -1073741515;
 function preflightWindowsWorkerd(appDir) {
   if (process.platform !== "win32") return;
-  const workerdExe = resolve(
+  const workerdExe = resolve2(
     appDir,
     "node_modules",
     "@cloudflare",
@@ -610,7 +724,7 @@ function preflightWindowsWorkerd(appDir) {
     "bin",
     "workerd.exe"
   );
-  if (!existsSync5(workerdExe)) return;
+  if (!existsSync7(workerdExe)) return;
   try {
     execFileSync(workerdExe, ["--help"], { stdio: "pipe", timeout: 1e4 });
     return;
@@ -650,6 +764,11 @@ var dev_default = defineCommand3({
       description: "Use production workers (real auth, real API calls)",
       default: false
     },
+    env: {
+      type: "string",
+      description: "wrangler.toml [env.<name>] block to run (e.g. --env staging). Reads .dev.vars.<name> and applies the env's overrides at build time.",
+      required: false
+    },
     port: {
       type: "string",
       description: `Port to bind (default ${DEFAULT_PORT}, or $DEEPSPACE_PORT)`,
@@ -657,13 +776,23 @@ var dev_default = defineCommand3({
     }
   },
   async run({ args }) {
-    const appDir = resolve2(args.dir ?? ".");
     const env = args.prod ? "prod" : "dev";
+    const wranglerEnv = typeof args.env === "string" && args.env.trim() ? args.env.trim() : void 0;
     const port = resolvePort(args.port);
-    if (!existsSync6(join6(appDir, "wrangler.toml"))) {
-      console.error("No wrangler.toml found. Are you in a DeepSpace app directory?");
+    const start = resolve3(args.dir ?? ".");
+    const appDir = findAppDir(start);
+    if (!appDir) {
+      console.error(`No wrangler.toml found at or above ${start}.`);
+      const children = findChildApps(start);
+      if (children.length > 0) {
+        console.error("Did you mean to run inside one of these app directories?");
+        for (const c of children) console.error(`  cd ${c}`);
+      } else {
+        console.error("Run from a DeepSpace app directory (one containing wrangler.toml).");
+      }
       process.exit(1);
     }
+    writeLaunchConfigIfMissing(appDir, detectAppName(appDir) ?? basename(appDir), port);
     ensureInstallReady(appDir);
     let token2;
     try {
@@ -680,9 +809,10 @@ var dev_default = defineCommand3({
       process.exit(1);
     }
     console.log(`Logged in as ${payload.name ?? payload.email}`);
-    console.log(`Environment: ${env}`);
+    console.log(`Platform: ${env}`);
+    if (wranglerEnv) console.log(`Wrangler env: ${wranglerEnv}`);
     console.log(`Port: ${port}`);
-    await writeDevVars(appDir, env, payload.sub, token2);
+    await writeDevVars(appDir, env, payload.sub, token2, wranglerEnv);
     preflightWindowsWorkerd(appDir);
     console.log("Starting dev server...\n");
     const vite = spawn(
@@ -691,7 +821,15 @@ var dev_default = defineCommand3({
       {
         cwd: appDir,
         stdio: "inherit",
-        env: { ...process.env, DEEPSPACE_PORT: String(port) }
+        // CLOUDFLARE_ENV is what the Cloudflare Vite plugin keys off — it
+        // applies `[env.<name>]` overrides and loads `.dev.vars.<name>`
+        // instead of `.dev.vars`. Set only when --env was passed so the
+        // default invocation behaves exactly as before.
+        env: {
+          ...process.env,
+          DEEPSPACE_PORT: String(port),
+          ...wranglerEnv ? { CLOUDFLARE_ENV: wranglerEnv } : {}
+        }
       }
     );
     process.on("SIGINT", () => vite.kill());
@@ -873,8 +1011,7 @@ function isAlive(pid) {
 
 // src/cli/commands/test.ts
 import { defineCommand as defineCommand5 } from "citty";
-import { existsSync as existsSync7 } from "fs";
-import { join as join7, resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 import { sync as spawnSync3 } from "cross-spawn";
 
 // src/cli/lib/playwright.ts
@@ -921,11 +1058,19 @@ var test_default = defineCommand5({
     }
   },
   async run({ args }) {
-    const appDir = resolve3(".");
     const suite = args.suite ?? "default";
     const port = resolvePort3(args.port);
-    if (!existsSync7(join7(appDir, "wrangler.toml"))) {
-      console.error("No wrangler.toml found. Are you in a DeepSpace app directory?");
+    const start = resolve4(".");
+    const appDir = findAppDir(start);
+    if (!appDir) {
+      console.error(`No wrangler.toml found at or above ${start}.`);
+      const children = findChildApps(start);
+      if (children.length > 0) {
+        console.error("Did you mean to run inside one of these app directories?");
+        for (const c of children) console.error(`  cd ${c}`);
+      } else {
+        console.error("Run from a DeepSpace app directory (one containing wrangler.toml).");
+      }
       process.exit(1);
     }
     ensureInstallReady(appDir);
@@ -1012,7 +1157,7 @@ function resolvePort3(arg) {
 // src/cli/commands/screenshot.ts
 import { defineCommand as defineCommand6 } from "citty";
 import { sync as spawnSync4 } from "cross-spawn";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 var screenshot_default = defineCommand6({
   meta: {
     name: "screenshot",
@@ -1041,7 +1186,7 @@ var screenshot_default = defineCommand6({
     }
   },
   run({ args }) {
-    const appDir = resolve4(".");
+    const appDir = resolve5(".");
     ensurePlaywright(appDir);
     const playwrightArgs = ["playwright", "screenshot", args.url, args.output];
     if (args["full-page"]) playwrightArgs.push("--full-page");
@@ -1059,7 +1204,7 @@ var screenshot_default = defineCommand6({
 // src/cli/commands/test-accounts.ts
 import { defineCommand as defineCommand7 } from "citty";
 import * as p3 from "@clack/prompts";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
 import { join as join8 } from "path";
 import { homedir as homedir4 } from "os";
 var SESSION_COOKIE2 = "__Secure-better-auth.session_token";
@@ -1069,17 +1214,17 @@ var ACCOUNTS_PATH = join8(DIR3, "test-accounts.json");
 function loadAccounts() {
   if (!existsSync8(ACCOUNTS_PATH)) return [];
   try {
-    return JSON.parse(readFileSync5(ACCOUNTS_PATH, "utf-8"));
+    return JSON.parse(readFileSync7(ACCOUNTS_PATH, "utf-8"));
   } catch {
     return [];
   }
 }
 function saveAccounts(accounts) {
-  mkdirSync3(DIR3, { recursive: true });
-  writeFileSync4(ACCOUNTS_PATH, JSON.stringify(accounts, null, 2), { mode: 384 });
+  mkdirSync4(DIR3, { recursive: true });
+  writeFileSync5(ACCOUNTS_PATH, JSON.stringify(accounts, null, 2), { mode: 384 });
 }
 function sessionCookie() {
-  const token2 = readFileSync5(SESSION_PATH2, "utf-8").trim();
+  const token2 = readFileSync7(SESSION_PATH2, "utf-8").trim();
   return `${SESSION_COOKIE2}=${encodeURIComponent(token2)}`;
 }
 async function fetchRemoteAccounts() {
@@ -1346,9 +1491,9 @@ var test_accounts_default = defineCommand7({
 // src/cli/commands/deploy.ts
 import { defineCommand as defineCommand8 } from "citty";
 import { execSync as execSync2 } from "child_process";
-import { readFileSync as readFileSync6, readdirSync, existsSync as existsSync9 } from "fs";
-import { parse as parseToml2 } from "smol-toml";
-import { join as join9, resolve as resolve5, dirname } from "path";
+import { randomUUID } from "crypto";
+import { readFileSync as readFileSync8, readdirSync as readdirSync2, existsSync as existsSync9 } from "fs";
+import { join as join9, resolve as resolve6, dirname as dirname2 } from "path";
 import { pathToFileURL } from "url";
 import * as p4 from "@clack/prompts";
 
@@ -1599,6 +1744,59 @@ function formatDeployWorkerError(status2, error) {
 
 Underlying error: ${detail}`;
 }
+var MAX_GROUP_BYTES = 40 * 1024 * 1024;
+var GROUP_BYTES = (() => {
+  const raw = Number(process.env.DEEPSPACE_DEPLOY_GROUP_BYTES);
+  const v = Number.isInteger(raw) && raw > 0 ? raw : 3 * 1024 * 1024;
+  return Math.min(v, MAX_GROUP_BYTES);
+})();
+function packAssetGroups(assets, maxBytes) {
+  const groups = [];
+  let current = [];
+  let currentBytes = 2;
+  for (const a of assets) {
+    const entryBytes = Buffer.byteLength(JSON.stringify(a), "utf-8") + 1;
+    if (current.length > 0 && currentBytes + entryBytes > maxBytes) {
+      groups.push(current);
+      current = [];
+      currentBytes = 2;
+    }
+    current.push(a);
+    currentBytes += entryBytes;
+  }
+  if (current.length > 0) groups.push(current);
+  return groups;
+}
+async function postWithRetry(url, makeInit, { attempts = 4, retryServerErrors = true } = {}) {
+  let lastRes;
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      const res = await fetch(url, makeInit());
+      const isTransient = retryServerErrors && (res.status >= 500 || res.status === 408 || res.status === 429);
+      if (!isTransient) {
+        return res;
+      }
+      lastRes = res;
+    } catch (err) {
+      lastErr = err;
+    }
+    if (attempt < attempts) {
+      await new Promise((r) => setTimeout(r, Math.min(8e3, 500 * 2 ** (attempt - 1))));
+    }
+  }
+  if (lastRes) return lastRes;
+  throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
+async function abortStagedUpload(appName, uploadId, totalGroups, token2) {
+  try {
+    await fetch(
+      `${DEPLOY_URL}/api/deploy/${appName}/assets?uploadId=${uploadId}&totalGroups=${totalGroups}`,
+      { method: "DELETE", headers: { Authorization: `Bearer ${token2}` } }
+    );
+  } catch {
+  }
+}
 var deploy_default = defineCommand8({
   meta: {
     name: "deploy",
@@ -1609,31 +1807,38 @@ var deploy_default = defineCommand8({
       type: "positional",
       description: "App directory (default: current directory)",
       required: false
+    },
+    env: {
+      type: "string",
+      description: "wrangler.toml [env.<name>] block to deploy (e.g. --env staging). Omit to deploy the top-level config.",
+      required: false
     }
   },
   async run({ args }) {
-    const appDir = resolve5(args.dir ?? ".");
-    const wranglerPath = join9(appDir, "wrangler.toml");
-    if (!existsSync9(wranglerPath)) {
+    const appDir = resolve6(args.dir ?? ".");
+    const envName = typeof args.env === "string" && args.env.trim() ? args.env.trim() : void 0;
+    if (!hasWranglerConfig(appDir)) {
       console.error("No wrangler.toml found. Are you in a DeepSpace app directory?");
       process.exit(1);
     }
     ensureInstallReady(appDir);
     p4.intro("Deploying DeepSpace app");
-    const wranglerConfig = parseToml2(readFileSync6(wranglerPath, "utf-8"));
-    const nameRes = resolveAppName(wranglerConfig.name);
+    const wranglerConfig = readWranglerConfig(appDir);
+    const nameRes = resolveAppNameForEnv(wranglerConfig, envName);
     if (!nameRes.ok) {
-      p4.cancel(`wrangler.toml: ${nameRes.reason}`);
+      p4.cancel(nameRes.reason);
       process.exit(1);
     }
-    if (wranglerConfig.name !== nameRes.name) {
+    const declaredName = envName ? wranglerConfig.env?.[envName]?.name : wranglerConfig.name;
+    if (declaredName !== nameRes.name) {
+      const where = envName ? `[env.${envName}].name` : "`name`";
       p4.cancel(
-        `wrangler.toml: name "${wranglerConfig.name}" is not in canonical form. Update \`name\` to "${nameRes.name}" and re-run.`
+        `wrangler.toml: ${where} "${declaredName}" is not in canonical form. Update it to "${nameRes.name}" and re-run.`
       );
       process.exit(1);
     }
     const appName = nameRes.name;
-    p4.log.info(`App: ${appName}`);
+    p4.log.info(envName ? `App: ${appName}  (env: ${envName})` : `App: ${appName}`);
     let token2;
     try {
       token2 = await ensureToken();
@@ -1644,10 +1849,15 @@ var deploy_default = defineCommand8({
     const s = createSpinner();
     s.start("Building...");
     try {
-      execSync2("npx vite build", { cwd: appDir, stdio: "pipe" });
+      execSync2("npx vite build", {
+        cwd: appDir,
+        stdio: "pipe",
+        env: envName ? { ...process.env, CLOUDFLARE_ENV: envName } : process.env
+      });
     } catch (err) {
       s.stop("Build failed");
-      console.error(err.stderr?.toString() ?? err.message);
+      const detail = [err.stdout?.toString(), err.stderr?.toString()].filter(Boolean).join("\n").trim();
+      console.error(detail || err.message);
       process.exit(1);
     }
     s.stop("Built");
@@ -1656,16 +1866,23 @@ var deploy_default = defineCommand8({
       p4.cancel("Build output config not found at .wrangler/deploy/config.json");
       process.exit(1);
     }
-    const deployConfig = JSON.parse(readFileSync6(deployConfigPath, "utf-8"));
-    const outputWranglerPath = resolve5(dirname(deployConfigPath), deployConfig.configPath);
+    const deployConfig = JSON.parse(readFileSync8(deployConfigPath, "utf-8"));
+    const outputWranglerPath = resolve6(dirname2(deployConfigPath), deployConfig.configPath);
     if (!existsSync9(outputWranglerPath)) {
       p4.cancel(`Output wrangler.json not found at ${outputWranglerPath}`);
       process.exit(1);
     }
-    const outputConfig = JSON.parse(readFileSync6(outputWranglerPath, "utf-8"));
-    const workerDir = dirname(outputWranglerPath);
+    const outputConfig = JSON.parse(readFileSync8(outputWranglerPath, "utf-8"));
+    if (outputConfig.name && outputConfig.name !== appName) {
+      const envHint = envName ? ` (--env ${envName})` : "";
+      p4.cancel(
+        `Build output mismatch: expected name "${appName}"${envHint}, but the built wrangler.json declares "${outputConfig.name}". This usually means the Cloudflare Vite plugin didn't apply the requested env block. Check the plugin version and re-run.`
+      );
+      process.exit(1);
+    }
+    const workerDir = dirname2(outputWranglerPath);
     const workerBundlePath = join9(workerDir, outputConfig.main);
-    const clientDir = outputConfig.assets?.directory ? resolve5(workerDir, outputConfig.assets.directory) : null;
+    const clientDir = outputConfig.assets?.directory ? resolve6(workerDir, outputConfig.assets.directory) : null;
     if (!existsSync9(workerBundlePath)) {
       p4.cancel(`Worker bundle not found at ${workerBundlePath}`);
       process.exit(1);
@@ -1677,7 +1894,7 @@ var deploy_default = defineCommand8({
     s.start("Collecting assets...");
     const assets = collectAssets(clientDir);
     s.stop(`Collected ${assets.length} assets`);
-    const workerJs = readFileSync6(workerBundlePath, "utf-8");
+    const workerJs = readFileSync8(workerBundlePath, "utf-8");
     const doBindings = outputConfig.durable_objects?.bindings;
     const sqliteClasses = new Set(
       outputConfig.migrations?.flatMap((m) => m.new_sqlite_classes ?? []) ?? []
@@ -1704,10 +1921,10 @@ var deploy_default = defineCommand8({
         `Custom bindings: ${customBindings.map((b) => `${b.name} (${b.type})`).join(", ")}`
       );
     }
-    const devVarsPath = join9(appDir, ".dev.vars");
+    const devVarsPath = devVarsPathFor(appDir, envName);
     let userSecrets = {};
     if (existsSync9(devVarsPath)) {
-      const customSection = extractCustomDevVars(readFileSync6(devVarsPath, "utf-8"));
+      const customSection = extractCustomDevVars(readFileSync8(devVarsPath, "utf-8"));
       if (customSection) {
         try {
           userSecrets = parseDevVars(customSection);
@@ -1740,30 +1957,98 @@ var deploy_default = defineCommand8({
       p4.log.info(`App secrets (from .dev.vars): ${userSecretNames.join(", ")}`);
     }
     s.start(`Deploying to ${appName}.app.space...`);
-    const form = new FormData();
-    form.append("worker", new Blob([workerJs], { type: "application/javascript" }), "worker.js");
-    form.append("assets", JSON.stringify(assets));
-    if (doManifest) {
-      form.append("doManifest", JSON.stringify(doManifest));
-    }
-    if (customBindings.length) {
-      form.append("bindingManifest", JSON.stringify(customBindings));
-    }
-    if (userSecretNames.length) {
-      form.append("userSecrets", JSON.stringify(userSecrets));
-    }
     const extraRoutes = extractRunWorkerFirst(wranglerConfig);
     if (extraRoutes.length) {
-      form.append("extraRunWorkerFirst", JSON.stringify(extraRoutes));
       p4.log.info(`Custom worker-first routes: ${extraRoutes.join(", ")}`);
     }
-    const res = await fetch(`${DEPLOY_URL}/api/deploy/${appName}`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${token2}` },
-      body: form
-    });
+    const assetGroups = packAssetGroups(assets, GROUP_BYTES);
+    let inlineAssets = null;
+    let uploadId = null;
+    let totalGroups = 0;
+    if (assetGroups.length <= 1) {
+      inlineAssets = JSON.stringify(assets);
+    } else {
+      uploadId = randomUUID();
+      totalGroups = assetGroups.length;
+      try {
+        for (let i = 0; i < totalGroups; i++) {
+          const groupJson = JSON.stringify(assetGroups[i]);
+          s.message(`Uploading assets \u2014 group ${i + 1}/${totalGroups}...`);
+          const groupRes = await postWithRetry(
+            `${DEPLOY_URL}/api/deploy/${appName}/assets?uploadId=${uploadId}&groupIndex=${i}&totalGroups=${totalGroups}`,
+            () => ({
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${token2}`,
+                "Content-Type": "application/json"
+              },
+              body: groupJson
+            })
+          );
+          if (!groupRes.ok) {
+            const errBody = await groupRes.json().catch(() => ({}));
+            await abortStagedUpload(appName, uploadId, totalGroups, token2);
+            s.stop("Deploy failed");
+            p4.cancel(
+              `Asset upload failed on group ${i + 1}/${totalGroups}: ${errBody.error ?? `HTTP ${groupRes.status}`}`
+            );
+            process.exit(1);
+          }
+        }
+      } catch (err) {
+        await abortStagedUpload(appName, uploadId, totalGroups, token2);
+        s.stop("Deploy failed");
+        p4.cancel(`Asset upload failed (network): ${err?.message ?? err}`);
+        process.exit(1);
+      }
+      s.message(`Deploying to ${appName}.app.space...`);
+    }
+    const makeForm = () => {
+      const form = new FormData();
+      form.append("worker", new Blob([workerJs], { type: "application/javascript" }), "worker.js");
+      if (inlineAssets !== null) {
+        form.append("assets", inlineAssets);
+      } else {
+        form.append("uploadId", uploadId);
+        form.append("totalGroups", String(totalGroups));
+      }
+      if (doManifest) {
+        form.append("doManifest", JSON.stringify(doManifest));
+      }
+      if (customBindings.length) {
+        form.append("bindingManifest", JSON.stringify(customBindings));
+      }
+      if (userSecretNames.length) {
+        form.append("userSecrets", JSON.stringify(userSecrets));
+      }
+      if (extraRoutes.length) {
+        form.append("extraRunWorkerFirst", JSON.stringify(extraRoutes));
+      }
+      return form;
+    };
+    let res;
+    try {
+      res = await postWithRetry(
+        `${DEPLOY_URL}/api/deploy/${appName}`,
+        () => ({
+          method: "POST",
+          headers: { Authorization: `Bearer ${token2}` },
+          body: makeForm()
+        }),
+        // Commit runs a real deploy — don't retry its 5xx (could double-deploy);
+        // only a thrown fetch (dropped connection) is retried, and the staged
+        // groups survive on the worker until this request succeeds.
+        { retryServerErrors: false }
+      );
+    } catch (err) {
+      if (uploadId) await abortStagedUpload(appName, uploadId, totalGroups, token2);
+      s.stop("Deploy failed");
+      p4.cancel(`Deploy request failed: ${err?.message ?? err}`);
+      process.exit(1);
+    }
     const body = await res.json().catch(() => ({}));
     if (!res.ok || !body.success) {
+      if (uploadId) await abortStagedUpload(appName, uploadId, totalGroups, token2);
       s.stop("Deploy failed");
       p4.cancel(formatDeployWorkerError(res.status, body.error));
       process.exit(1);
@@ -2018,7 +2303,7 @@ async function waitForAssetsReady(url, timeoutMs) {
 function collectAssets(dir) {
   const assets = [];
   function walk(d, prefix) {
-    for (const entry of readdirSync(d, { withFileTypes: true })) {
+    for (const entry of readdirSync2(d, { withFileTypes: true })) {
       if (entry.name === ".assetsignore") continue;
       const full = join9(d, entry.name);
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -2027,7 +2312,7 @@ function collectAssets(dir) {
       } else {
         assets.push({
           path: "/" + rel,
-          contentBase64: readFileSync6(full).toString("base64")
+          contentBase64: readFileSync8(full).toString("base64")
         });
       }
     }
@@ -2038,9 +2323,6 @@ function collectAssets(dir) {
 
 // src/cli/commands/undeploy.ts
 import { defineCommand as defineCommand9 } from "citty";
-import { readFileSync as readFileSync7, existsSync as existsSync10 } from "fs";
-import { join as join10 } from "path";
-import { parse as parseToml3 } from "smol-toml";
 import * as p5 from "@clack/prompts";
 var DEPLOY_URL2 = process.env.DEEPSPACE_DEPLOY_URL ?? ENVS.prod.deploy;
 var undeploy_default = defineCommand9({
@@ -2053,15 +2335,25 @@ var undeploy_default = defineCommand9({
       type: "positional",
       description: "App name to undeploy (reads from wrangler.toml if omitted)",
       required: false
+    },
+    env: {
+      type: "string",
+      description: "wrangler.toml [env.<name>] block whose deployed app to remove (e.g. --env staging). Ignored if a positional name is given.",
+      required: false
     }
   },
   async run({ args }) {
     let appName = args.name;
+    const envName = typeof args.env === "string" && args.env.trim() ? args.env.trim() : void 0;
     if (!appName) {
-      const wranglerPath = join10(process.cwd(), "wrangler.toml");
-      if (existsSync10(wranglerPath)) {
-        const config = parseToml3(readFileSync7(wranglerPath, "utf-8"));
-        if (config.name) appName = config.name;
+      if (hasWranglerConfig(process.cwd())) {
+        const config = readWranglerConfig(process.cwd());
+        const nameRes = resolveAppNameForEnv(config, envName);
+        if (!nameRes.ok) {
+          p5.cancel(nameRes.reason);
+          process.exit(1);
+        }
+        appName = nameRes.name;
       }
     }
     if (!appName) {
@@ -2151,14 +2443,14 @@ var whoami_default = defineCommand10({
 
 // src/cli/commands/add.ts
 import { defineCommand as defineCommand11 } from "citty";
-import { existsSync as existsSync11 } from "fs";
-import { resolve as resolve6, join as join11 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { resolve as resolve7, join as join10 } from "path";
 import { execSync as execSync3 } from "child_process";
 function findScript(from) {
-  const inNodeModules = join11(from, "node_modules", "deepspace", "scripts", "add-feature.cjs");
-  if (existsSync11(inNodeModules)) return inNodeModules;
-  const inDotDeepspace = join11(from, ".deepspace", "scripts", "add-feature.cjs");
-  if (existsSync11(inDotDeepspace)) return inDotDeepspace;
+  const inNodeModules = join10(from, "node_modules", "deepspace", "scripts", "add-feature.cjs");
+  if (existsSync10(inNodeModules)) return inNodeModules;
+  const inDotDeepspace = join10(from, ".deepspace", "scripts", "add-feature.cjs");
+  if (existsSync10(inDotDeepspace)) return inDotDeepspace;
   return null;
 }
 var add_default = defineCommand11({
@@ -2190,14 +2482,14 @@ var add_default = defineCommand11({
     }
   },
   run({ args }) {
-    const appDir = resolve6(args.dir ?? ".");
+    const appDir = resolve7(args.dir ?? ".");
     ensureInstallReady(appDir);
     const script = findScript(appDir);
     if (!script) {
       console.error("Could not find the deepspace feature installer.");
       console.error("Looked in:");
-      console.error(`  ${join11(appDir, "node_modules", "deepspace", "scripts", "add-feature.cjs")}`);
-      console.error(`  ${join11(appDir, ".deepspace", "scripts", "add-feature.cjs")}`);
+      console.error(`  ${join10(appDir, "node_modules", "deepspace", "scripts", "add-feature.cjs")}`);
+      console.error(`  ${join10(appDir, ".deepspace", "scripts", "add-feature.cjs")}`);
       console.error("Are you in a DeepSpace app directory? Try `npm install` first.");
       process.exit(1);
     }
@@ -2221,8 +2513,8 @@ var add_default = defineCommand11({
 // src/cli/commands/skills.ts
 import { defineCommand as defineCommand12 } from "citty";
 import spawn2 from "cross-spawn";
-import { mkdirSync as mkdirSync4 } from "fs";
-import { join as join12 } from "path";
+import { mkdirSync as mkdirSync5 } from "fs";
+import { join as join11 } from "path";
 import { homedir as homedir5 } from "os";
 var SKILL_REPO = "deepdotspace/deepspace-skill";
 function runSkillsAdd(extraArgs) {
@@ -2241,7 +2533,7 @@ function runSkillsAdd(extraArgs) {
   });
 }
 function precreateClaudeDir(baseDir) {
-  mkdirSync4(join12(baseDir, ".claude"), { recursive: true });
+  mkdirSync5(join11(baseDir, ".claude"), { recursive: true });
 }
 var add = defineCommand12({
   meta: {
@@ -2298,31 +2590,6 @@ var skills_default = defineCommand12({
 // src/cli/commands/domain.ts
 import { defineCommand as defineCommand13 } from "citty";
 import { execSync as execSync4 } from "child_process";
-
-// src/cli/lib/app-context.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
-import { join as join13, resolve as resolve7 } from "path";
-import { parse as parseToml4 } from "smol-toml";
-function detectAppName(cwd = process.cwd()) {
-  const wranglerPath = join13(resolve7(cwd), "wrangler.toml");
-  if (!existsSync12(wranglerPath)) return null;
-  try {
-    const cfg = parseToml4(readFileSync8(wranglerPath, "utf-8"));
-    return typeof cfg.name === "string" && cfg.name.length > 0 ? cfg.name : null;
-  } catch {
-    return null;
-  }
-}
-function requireAppName(explicit, cwd) {
-  if (explicit) return explicit;
-  const detected = detectAppName(cwd);
-  if (detected) return detected;
-  throw new Error(
-    "No app specified. Pass --app <name>, or run from an app directory with a wrangler.toml."
-  );
-}
-
-// src/cli/commands/domain.ts
 var API_URL2 = process.env.DEEPSPACE_API_URL ?? ENVS.prod.api;
 async function api(token2, path, init) {
   const res = await fetch(`${API_URL2}${path}`, {
@@ -2690,8 +2957,9 @@ function flushAndExit(code) {
     process.stdout.write("", () => process.exit(code));
   });
 }
-async function fetchCatalog() {
-  const res = await fetch(`${API_URL3}/api/integrations`);
+async function fetchCatalog(opts = {}) {
+  const url = opts.summary ? `${API_URL3}/api/integrations?summary=1` : `${API_URL3}/api/integrations`;
+  const res = await fetch(url);
   if (!res.ok) {
     throw new Error(`Failed to fetch integration catalog (${res.status})`);
   }
@@ -2707,7 +2975,7 @@ function formatCurrency(value, currency) {
   return `${value} ${currency}`;
 }
 async function runList(args) {
-  const catalog = await fetchCatalog();
+  const catalog = await fetchCatalog({ summary: true });
   if (args.json) {
     process.stdout.write(JSON.stringify(catalog) + "\n");
     await flushAndExit(0);
@@ -3254,9 +3522,9 @@ var managed_repos_default = defineCommand16({
 
 // src/cli/commands/library.ts
 import { defineCommand as defineCommand17 } from "citty";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
-import { join as join14, resolve as resolve8 } from "path";
-import { parse as parseToml5 } from "smol-toml";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { join as join12, resolve as resolve8 } from "path";
+import { parse as parseToml3 } from "smol-toml";
 import * as p6 from "@clack/prompts";
 var DEFAULT_LIBRARY_APP = "deepdotspace-site";
 var publish = defineCommand17({
@@ -3333,11 +3601,11 @@ var publish = defineCommand17({
     let appName = typeof args.app === "string" && args.app.trim() ? args.app.trim() : void 0;
     if (!appName) {
       const appDir = resolve8(typeof args.dir === "string" && args.dir ? args.dir : ".");
-      const wranglerPath = join14(appDir, "wrangler.toml");
-      if (!existsSync13(wranglerPath)) {
+      const wranglerPath = join12(appDir, "wrangler.toml");
+      if (!existsSync11(wranglerPath)) {
         return die("No --app provided and no wrangler.toml found. Either pass --app <name> or run from your app's directory.");
       }
-      const cfg = parseToml5(readFileSync10(wranglerPath, "utf-8"));
+      const cfg = parseToml3(readFileSync10(wranglerPath, "utf-8"));
       const nameRes = resolveAppName(cfg.name);
       if (!nameRes.ok) return die(`wrangler.toml: ${nameRes.reason}`);
       appName = nameRes.name;
@@ -3470,9 +3738,9 @@ var library_default = defineCommand17({
 
 // src/cli/commands/admin.ts
 import { defineCommand as defineCommand18 } from "citty";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join15 } from "path";
+import { join as join13 } from "path";
 var AUTH_URL5 = process.env.DEEPSPACE_AUTH_URL ?? ENVS.prod.auth;
 var impersonate = defineCommand18({
   meta: {
@@ -3522,9 +3790,9 @@ var impersonate = defineCommand18({
       console.error(`Failed: ${data.error ?? `HTTP ${res.status}`}`);
       process.exit(1);
     }
-    const dir = join15(homedir6(), ".deepspace");
-    mkdirSync5(dir, { recursive: true });
-    writeFileSync5(TOKEN_PATH2, data.token, { mode: 384 });
+    const dir = join13(homedir6(), ".deepspace");
+    mkdirSync6(dir, { recursive: true });
+    writeFileSync6(TOKEN_PATH2, data.token, { mode: 384 });
     console.log(`Impersonating ${data.user.name ?? data.user.email ?? data.user.id}`);
     console.log(`Email:  ${data.user.email ?? "(none)"}`);
     console.log(`UserID: ${data.user.id}`);
@@ -3541,9 +3809,9 @@ var admin_default = defineCommand18({
 });
 
 // src/cli/cli.ts
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(readFileSync11(join16(__dirname, "..", "package.json"), "utf-8"));
-if (process.platform === "linux" && !process.env.SSL_CERT_FILE && existsSync14("/etc/ssl/certs/ca-certificates.crt")) {
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync11(join14(__dirname, "..", "package.json"), "utf-8"));
+if (process.platform === "linux" && !process.env.SSL_CERT_FILE && existsSync12("/etc/ssl/certs/ca-certificates.crt")) {
   process.env.SSL_CERT_FILE = "/etc/ssl/certs/ca-certificates.crt";
 }
 var create3 = defineCommand19({