episoda 0.2.33 → 0.2.35

package/dist/index.js

@@ -1549,15 +1549,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs13.access(rebaseMergePath);
+              await fs15.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs13.access(rebaseApplyPath);
+                await fs15.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1611,9 +1611,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs13.access(command.path);
+            await fs15.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1667,9 +1667,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs13.access(command.path);
+            await fs15.access(command.path);
           } catch {
             return {
               success: false,
@@ -1822,10 +1822,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path15 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path17 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs13.access(command.path);
+            await fs15.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1834,9 +1834,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path15.dirname(command.path);
+          const parentDir = path17.dirname(command.path);
           try {
-            await fs13.mkdir(parentDir, { recursive: true });
+            await fs15.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync(
@@ -1879,22 +1879,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path15 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path17 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path15.join(currentPath, ".bare");
-            const episodaDir = path15.join(currentPath, ".episoda");
+            const bareDir = path17.join(currentPath, ".bare");
+            const episodaDir = path17.join(currentPath, ".episoda");
             try {
-              await fs13.access(bareDir);
-              await fs13.access(episodaDir);
+              await fs15.access(bareDir);
+              await fs15.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path15.dirname(currentPath);
+              const parentPath = path17.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2107,7 +2107,7 @@ var require_websocket_client = __commonJS({
           clearTimeout(this.reconnectTimeout);
           this.reconnectTimeout = void 0;
         }
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           const connectionTimeout = setTimeout(() => {
             if (this.ws) {
               this.ws.terminate();
@@ -2134,7 +2134,7 @@ var require_websocket_client = __commonJS({
                 daemonPid: this.daemonPid
               });
               this.startHeartbeat();
-              resolve4();
+              resolve5();
             });
             this.ws.on("pong", () => {
               if (this.heartbeatTimeoutTimer) {
@@ -2250,13 +2250,13 @@ var require_websocket_client = __commonJS({
         if (!this.ws || !this.isConnected) {
           throw new Error("WebSocket not connected");
         }
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           this.ws.send(JSON.stringify(message), (error) => {
             if (error) {
               console.error("[EpisodaClient] Failed to send message:", error);
               reject(error);
             } else {
-              resolve4();
+              resolve5();
             }
           });
         });
@@ -2485,34 +2485,34 @@ var require_auth = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getConfigDir = getConfigDir5;
     exports2.getConfigPath = getConfigPath4;
-    exports2.loadConfig = loadConfig6;
+    exports2.loadConfig = loadConfig9;
     exports2.saveConfig = saveConfig3;
     exports2.validateToken = validateToken;
-    var fs13 = __importStar(require("fs"));
-    var path15 = __importStar(require("path"));
-    var os3 = __importStar(require("os"));
+    var fs15 = __importStar(require("fs"));
+    var path17 = __importStar(require("path"));
+    var os4 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir5() {
-      return process.env.EPISODA_CONFIG_DIR || path15.join(os3.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path17.join(os4.homedir(), ".episoda");
     }
     function getConfigPath4(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path15.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
+      return path17.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path15.dirname(configPath);
-      const isNew = !fs13.existsSync(dir);
+      const dir = path17.dirname(configPath);
+      const isNew = !fs15.existsSync(dir);
       if (isNew) {
-        fs13.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs15.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path15.join(dir, ".nosync");
-        if (isNew || !fs13.existsSync(nosyncPath)) {
+        const nosyncPath = path17.join(dir, ".nosync");
+        if (isNew || !fs15.existsSync(nosyncPath)) {
           try {
-            fs13.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs15.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2522,13 +2522,13 @@ var require_auth = __commonJS({
         }
       }
     }
-    async function loadConfig6(configPath) {
+    async function loadConfig9(configPath) {
       const fullPath = getConfigPath4(configPath);
-      if (!fs13.existsSync(fullPath)) {
+      if (!fs15.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs13.readFileSync(fullPath, "utf8");
+        const content = fs15.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2541,7 +2541,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs13.writeFileSync(fullPath, content, { mode: 384 });
+        fs15.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2652,7 +2652,7 @@ var require_dist = __commonJS({
 
 // src/index.ts
 var import_commander = require("commander");
-var import_core15 = __toESM(require_dist());
+var import_core18 = __toESM(require_dist());
 
 // src/commands/dev.ts
 var import_core4 = __toESM(require_dist());
@@ -2989,7 +2989,7 @@ async function startDaemon() {
   const pid = child.pid;
   const pidPath = getPidFilePath();
   fs2.writeFileSync(pidPath, pid.toString(), "utf-8");
-  await new Promise((resolve4) => setTimeout(resolve4, 500));
+  await new Promise((resolve5) => setTimeout(resolve5, 500));
   const runningPid = isDaemonRunning();
   if (!runningPid) {
     throw new Error("Daemon failed to start");
@@ -3011,7 +3011,7 @@ async function stopDaemon(timeout = 5e3) {
     while (Date.now() - startTime < timeout) {
       try {
         process.kill(pid, 0);
-        await new Promise((resolve4) => setTimeout(resolve4, 100));
+        await new Promise((resolve5) => setTimeout(resolve5, 100));
       } catch (error) {
         const pidPath2 = getPidFilePath();
         if (fs2.existsSync(pidPath2)) {
@@ -3041,7 +3041,7 @@ var import_core2 = __toESM(require_dist());
 var getSocketPath = () => path3.join((0, import_core2.getConfigDir)(), "daemon.sock");
 var DEFAULT_TIMEOUT = 15e3;
 async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const socket = net.createConnection(getSocketPath());
     const requestId = crypto.randomUUID();
     let buffer = "";
@@ -3072,7 +3072,7 @@ async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
         clearTimeout(timeoutHandle);
         socket.end();
         if (response.success) {
-          resolve4(response.data);
+          resolve5(response.data);
         } else {
           reject(new Error(response.error || "Command failed"));
         }
@@ -3135,18 +3135,18 @@ var fs5 = __toESM(require("fs"));
 // src/utils/port-check.ts
 var net2 = __toESM(require("net"));
 async function isPortInUse(port) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const server = net2.createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve4(true);
+        resolve5(true);
       } else {
-        resolve4(false);
+        resolve5(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve4(false);
+      resolve5(false);
     });
     server.listen(port);
   });
@@ -3518,7 +3518,7 @@ var WorktreeManager = class _WorktreeManager {
                 const lockContent = fs3.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
-                  await new Promise((resolve4) => setTimeout(resolve4, retryInterval));
+                  await new Promise((resolve5) => setTimeout(resolve5, retryInterval));
                   continue;
                 }
               } catch {
@@ -3532,7 +3532,7 @@ var WorktreeManager = class _WorktreeManager {
           } catch {
             continue;
           }
-          await new Promise((resolve4) => setTimeout(resolve4, retryInterval));
+          await new Promise((resolve5) => setTimeout(resolve5, retryInterval));
           continue;
         }
         throw err;
@@ -3799,7 +3799,7 @@ async function fetchProjectPath(config, projectId) {
     return null;
   }
 }
-async function syncProjectPath(config, projectId, path15) {
+async function syncProjectPath(config, projectId, path17) {
   if (!config.device_id || !config.access_token) {
     return false;
   }
@@ -3812,7 +3812,7 @@ async function syncProjectPath(config, projectId, path15) {
         "Authorization": `Bearer ${config.access_token}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ path: path15 })
+      body: JSON.stringify({ path: path17 })
     });
     if (!response.ok) {
       console.debug(`[MachineSettings] syncProjectPath failed: ${response.status} ${response.statusText}`);
@@ -3903,7 +3903,7 @@ async function devCommand(options = {}) {
       const killedCount = killAllEpisodaProcesses();
       if (killedCount > 0) {
         status.info(`Cleaned up ${killedCount} stale process${killedCount > 1 ? "es" : ""}`);
-        await new Promise((resolve4) => setTimeout(resolve4, 2e3));
+        await new Promise((resolve5) => setTimeout(resolve5, 2e3));
       }
     }
     let projectPath;
@@ -3963,7 +3963,7 @@ async function devCommand(options = {}) {
     for (let retry = 0; retry < CONNECTION_MAX_RETRIES && !connected; retry++) {
       if (retry > 0) {
         status.info(`Retrying connection (attempt ${retry + 1}/${CONNECTION_MAX_RETRIES})...`);
-        await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+        await new Promise((resolve5) => setTimeout(resolve5, 1e3));
       }
       try {
         const result = await addProject(config.project_id, projectPath);
@@ -4586,10 +4586,10 @@ async function initiateDeviceFlow(apiUrl, machineId) {
   return await response.json();
 }
 async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const timeout = setTimeout(() => {
       status.error("Authorization timed out");
-      resolve4(false);
+      resolve5(false);
     }, expiresIn * 1e3);
     const url = `${apiUrl}/api/oauth/authorize-stream?device_code=${deviceCode}`;
     const curlProcess = (0, import_child_process5.spawn)("curl", ["-N", url]);
@@ -4615,26 +4615,26 @@ async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
           if (eventType === "authorized") {
             clearTimeout(timeout);
             curlProcess.kill();
-            resolve4(true);
+            resolve5(true);
             return;
           } else if (eventType === "denied") {
             clearTimeout(timeout);
             curlProcess.kill();
             status.error("Authorization denied by user");
-            resolve4(false);
+            resolve5(false);
             return;
           } else if (eventType === "expired") {
             clearTimeout(timeout);
             curlProcess.kill();
             status.error("Authorization code expired");
-            resolve4(false);
+            resolve5(false);
             return;
           } else if (eventType === "error") {
             const errorData = JSON.parse(data);
             clearTimeout(timeout);
             curlProcess.kill();
             status.error(`Authorization error: ${errorData.error_description || errorData.error || "Unknown error"}`);
-            resolve4(false);
+            resolve5(false);
             return;
           }
         } catch (error) {
@@ -4644,13 +4644,13 @@ async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
     curlProcess.on("error", (error) => {
       clearTimeout(timeout);
       status.error(`Failed to monitor authorization: ${error.message}`);
-      resolve4(false);
+      resolve5(false);
     });
     curlProcess.on("close", (code) => {
       clearTimeout(timeout);
       if (code !== 0 && code !== null) {
         status.error(`Authorization monitoring failed with code ${code}`);
-        resolve4(false);
+        resolve5(false);
       }
     });
   });
@@ -5406,7 +5406,7 @@ async function fetchWithRetry(url, options, maxRetries = 3) {
       lastError = error instanceof Error ? error : new Error("Network error");
     }
     if (attempt < maxRetries - 1) {
-      await new Promise((resolve4) => setTimeout(resolve4, Math.pow(2, attempt) * 1e3));
+      await new Promise((resolve5) => setTimeout(resolve5, Math.pow(2, attempt) * 1e3));
     }
   }
   throw lastError || new Error("Request failed after retries");
@@ -5989,7 +5989,7 @@ async function updateCommand(options = {}) {
   }
   if (options.restart && daemonWasRunning) {
     status.info("Restarting daemon...");
-    await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+    await new Promise((resolve5) => setTimeout(resolve5, 1e3));
     if (startDaemon2()) {
       status.success("\u2713 Daemon restarted");
       status.info("");
@@ -6010,8 +6010,534 @@ async function updateCommand(options = {}) {
   }
 }
 
+// src/commands/run.ts
+var import_child_process9 = require("child_process");
+var import_core15 = __toESM(require_dist());
+
+// src/utils/env-cache.ts
+var fs13 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+var DEFAULT_CACHE_TTL = 60;
+var CACHE_DIR = path15.join(os3.homedir(), ".episoda", "cache");
+function getCacheFilePath(projectId) {
+  return path15.join(CACHE_DIR, `env-vars-${projectId}.json`);
+}
+function ensureCacheDir() {
+  if (!fs13.existsSync(CACHE_DIR)) {
+    fs13.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+  }
+}
+function readCache(projectId) {
+  try {
+    const cacheFile = getCacheFilePath(projectId);
+    if (!fs13.existsSync(cacheFile)) {
+      return null;
+    }
+    const content = fs13.readFileSync(cacheFile, "utf-8");
+    const data = JSON.parse(content);
+    if (!data.vars || typeof data.vars !== "object" || !data.fetchedAt) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeCache(projectId, vars) {
+  try {
+    ensureCacheDir();
+    const cacheFile = getCacheFilePath(projectId);
+    const data = {
+      vars,
+      fetchedAt: Date.now(),
+      projectId
+    };
+    fs13.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
+  } catch (error) {
+    console.warn("[env-cache] Failed to write cache:", error instanceof Error ? error.message : error);
+  }
+}
+function isCacheValid(cache, ttlSeconds) {
+  const ageMs = Date.now() - cache.fetchedAt;
+  return ageMs < ttlSeconds * 1e3;
+}
+async function fetchEnvVarsWithCache(apiUrl, accessToken, options = {}) {
+  const {
+    noCache = false,
+    cacheTtl = DEFAULT_CACHE_TTL,
+    offline = false,
+    projectId = "default"
+  } = options;
+  if (offline) {
+    const cache = readCache(projectId);
+    if (cache && Object.keys(cache.vars).length > 0) {
+      return {
+        envVars: cache.vars,
+        fromCache: true,
+        cacheAge: Date.now() - cache.fetchedAt
+      };
+    }
+    throw new Error(
+      "Offline mode requires cached env vars, but no cache found.\nRun without --offline first to populate the cache."
+    );
+  }
+  if (!noCache) {
+    const cache = readCache(projectId);
+    if (cache && isCacheValid(cache, cacheTtl)) {
+      return {
+        envVars: cache.vars,
+        fromCache: true,
+        cacheAge: Date.now() - cache.fetchedAt
+      };
+    }
+  }
+  try {
+    const envVars = await fetchEnvVars(apiUrl, accessToken);
+    if (Object.keys(envVars).length > 0) {
+      writeCache(projectId, envVars);
+    }
+    return {
+      envVars,
+      fromCache: false
+    };
+  } catch (error) {
+    const cache = readCache(projectId);
+    if (cache && Object.keys(cache.vars).length > 0) {
+      const cacheAge = Date.now() - cache.fetchedAt;
+      console.warn(
+        `[env-cache] Failed to fetch env vars, using stale cache (${Math.round(cacheAge / 1e3)}s old)`
+      );
+      return {
+        envVars: cache.vars,
+        fromCache: true,
+        cacheAge
+      };
+    }
+    throw new Error(
+      `Failed to fetch environment variables: ${error instanceof Error ? error.message : error}
+No cached values available as fallback.`
+    );
+  }
+}
+
+// src/commands/run.ts
+async function runCommand(args, options = {}) {
+  if (args.length === 0) {
+    throw new Error(
+      "No command specified.\n\nUsage:\n  episoda run <command> [args...]\n  episoda run -- <command> [args...]\n\nExamples:\n  episoda run npm run dev\n  episoda run -- npm run dev --port 3001\n  episoda run python manage.py runserver"
+    );
+  }
+  const config = await (0, import_core15.loadConfig)();
+  if (!config || !config.access_token) {
+    throw new Error(
+      "Not authenticated. Please run `episoda auth` first."
+    );
+  }
+  const apiUrl = config.api_url || "https://episoda.dev";
+  const cacheOptions = {
+    noCache: options.noCache,
+    cacheTtl: options.cacheTtl,
+    offline: options.offline,
+    projectId: config.project_id
+  };
+  if (options.verbose) {
+    status.info("Fetching environment variables...");
+  }
+  const { envVars, fromCache, cacheAge } = await fetchEnvVarsWithCache(
+    apiUrl,
+    config.access_token,
+    cacheOptions
+  );
+  const varCount = Object.keys(envVars).length;
+  if (varCount === 0) {
+    status.warning("No environment variables found. Command will run with system env only.");
+  } else if (options.verbose) {
+    if (fromCache) {
+      status.info(`Using ${varCount} cached env vars (${Math.round(cacheAge / 1e3)}s old)`);
+    } else {
+      status.info(`Fetched ${varCount} env vars from server`);
+    }
+    status.info(`Variables: ${Object.keys(envVars).join(", ")}`);
+  }
+  const mergedEnv = {
+    ...process.env,
+    ...envVars
+  };
+  const [command, ...commandArgs] = args;
+  if (options.verbose) {
+    status.info(`Running: ${command} ${commandArgs.join(" ")}`);
+    status.info("");
+  }
+  const child = (0, import_child_process9.spawn)(command, commandArgs, {
+    stdio: "inherit",
+    env: mergedEnv,
+    shell: process.platform === "win32"
+    // Use shell on Windows for .cmd/.bat files
+  });
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  const signalHandlers = /* @__PURE__ */ new Map();
+  for (const signal of signals) {
+    const handler = () => {
+      if (child.pid) {
+        child.kill(signal);
+      }
+    };
+    signalHandlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  child.on("error", (error) => {
+    for (const [signal, handler] of signalHandlers) {
+      process.removeListener(signal, handler);
+    }
+    if (error.code === "ENOENT") {
+      status.error(`Command not found: ${command}`);
+      process.exit(127);
+    } else {
+      status.error(`Failed to start command: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  child.on("exit", (code, signal) => {
+    for (const [sig, handler] of signalHandlers) {
+      process.removeListener(sig, handler);
+    }
+    if (signal) {
+      process.exit(128 + (signalToNumber(signal) || 0));
+    } else {
+      process.exit(code ?? 1);
+    }
+  });
+}
+function signalToNumber(signal) {
+  const signalMap = {
+    SIGHUP: 1,
+    SIGINT: 2,
+    SIGQUIT: 3,
+    SIGTERM: 15
+  };
+  return signalMap[signal];
+}
+
+// src/commands/shell.ts
+var import_child_process10 = require("child_process");
+var import_core16 = __toESM(require_dist());
+async function shellCommand(shell, options = {}) {
+  const config = await (0, import_core16.loadConfig)();
+  if (!config || !config.access_token) {
+    throw new Error(
+      "Not authenticated. Please run `episoda auth` first."
+    );
+  }
+  const apiUrl = config.api_url || "https://episoda.dev";
+  const cacheOptions = {
+    noCache: options.noCache,
+    cacheTtl: options.cacheTtl,
+    offline: options.offline,
+    projectId: config.project_id
+  };
+  status.info("Fetching environment variables...");
+  const { envVars, fromCache, cacheAge } = await fetchEnvVarsWithCache(
+    apiUrl,
+    config.access_token,
+    cacheOptions
+  );
+  const varCount = Object.keys(envVars).length;
+  if (varCount === 0) {
+    status.warning("No environment variables found.");
+  } else if (fromCache) {
+    status.info(`Using ${varCount} cached env vars (${Math.round(cacheAge / 1e3)}s old)`);
+  } else {
+    status.info(`Fetched ${varCount} env vars from server`);
+  }
+  if (options.print) {
+    printExports(envVars);
+    return;
+  }
+  const targetShell = shell || process.env.SHELL || "/bin/bash";
+  status.info(`Opening ${targetShell} with ${varCount} environment variables...`);
+  status.info('Type "exit" to return to your normal shell.');
+  status.info("");
+  const mergedEnv = {
+    ...process.env,
+    ...envVars,
+    // Set a marker so users know they're in an episoda shell
+    EPISODA_SHELL: "1"
+  };
+  const child = (0, import_child_process10.spawn)(targetShell, [], {
+    stdio: "inherit",
+    env: mergedEnv
+  });
+  child.on("error", (error) => {
+    if (error.code === "ENOENT") {
+      status.error(`Shell not found: ${targetShell}`);
+      process.exit(127);
+    } else {
+      status.error(`Failed to start shell: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+function printExports(envVars) {
+  for (const [key, value] of Object.entries(envVars)) {
+    const escapedValue = value.replace(/'/g, "'\\''");
+    console.log(`export ${key}='${escapedValue}'`);
+  }
+}
+
+// src/commands/env.ts
+var fs14 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
+var readline = __toESM(require("readline"));
+var import_core17 = __toESM(require_dist());
+async function envListCommand(options = {}) {
+  const config = await (0, import_core17.loadConfig)();
+  if (!config || !config.access_token) {
+    throw new Error("Not authenticated. Please run `episoda auth` first.");
+  }
+  const apiUrl = config.api_url || "https://episoda.dev";
+  const url = `${apiUrl}/api/projects/${config.project_id}/env-vars`;
+  const response = await fetch(url, {
+    headers: {
+      "Authorization": `Bearer ${config.access_token}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to list env vars: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (!data.success || !data.env_vars) {
+    throw new Error("Failed to parse env vars response");
+  }
+  if (data.env_vars.length === 0) {
+    status.info("No environment variables configured.");
+    status.info("Add one with: episoda env set KEY=value");
+    return;
+  }
+  console.log("\nEnvironment Variables:");
+  console.log("\u2500".repeat(60));
+  for (const envVar of data.env_vars) {
+    const envBadge = envVar.environment === "all" ? "" : ` [${envVar.environment}]`;
+    const sealed = envVar.is_sealed ? " (sealed)" : "";
+    if (options.showValues) {
+      const preview = envVar.value_preview || "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+      console.log(`  ${envVar.key}${envBadge}${sealed} = ${preview}`);
+    } else {
+      console.log(`  ${envVar.key}${envBadge}${sealed}`);
+    }
+  }
+  console.log("");
+  console.log(`Total: ${data.env_vars.length} variable(s)`);
+  if (!options.showValues) {
+    console.log("\nTip: Use --show-values to see value previews");
+  }
+}
+async function envSetCommand(keyValue, options = {}) {
+  const config = await (0, import_core17.loadConfig)();
+  if (!config || !config.access_token) {
+    throw new Error("Not authenticated. Please run `episoda auth` first.");
+  }
+  const apiUrl = config.api_url || "https://episoda.dev";
+  let key;
+  let value;
+  const eqIndex = keyValue.indexOf("=");
+  if (eqIndex === -1) {
+    key = keyValue;
+    value = await promptForValue(key);
+  } else {
+    key = keyValue.slice(0, eqIndex);
+    value = keyValue.slice(eqIndex + 1);
+  }
+  if (!/^[A-Z][A-Z0-9_]*$/.test(key)) {
+    throw new Error(
+      `Invalid key format: ${key}
+Keys must be uppercase with underscores (e.g., API_KEY, DATABASE_URL)`
+    );
+  }
+  const url = `${apiUrl}/api/projects/${config.project_id}/env-vars`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${config.access_token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      key,
+      value,
+      environment: options.environment || "dev"
+    })
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    if (response.status === 409) {
+      status.info(`${key} already exists, updating...`);
+      await updateEnvVar(apiUrl, config.access_token, config.project_id, key, value);
+      return;
+    }
+    throw new Error(data.error?.message || `Failed to set env var: ${response.status}`);
+  }
+  status.success(`Set ${key} successfully`);
+}
+async function updateEnvVar(apiUrl, accessToken, projectId, key, value) {
+  const listUrl = `${apiUrl}/api/projects/${projectId}/env-vars`;
+  const listResponse = await fetch(listUrl, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!listResponse.ok) {
+    throw new Error("Failed to find existing env var for update");
+  }
+  const listData = await listResponse.json();
+  const existingVar = listData.env_vars?.find((v) => v.key === key);
+  if (!existingVar) {
+    throw new Error(`Env var ${key} not found for update`);
+  }
+  const updateUrl = `${apiUrl}/api/projects/${projectId}/env-vars/${existingVar.id}`;
+  const updateResponse = await fetch(updateUrl, {
+    method: "PATCH",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ value })
+  });
+  if (!updateResponse.ok) {
+    throw new Error(`Failed to update env var: ${updateResponse.status}`);
+  }
+  status.success(`Updated ${key} successfully`);
+}
+async function envRemoveCommand(key) {
+  const config = await (0, import_core17.loadConfig)();
+  if (!config || !config.access_token) {
+    throw new Error("Not authenticated. Please run `episoda auth` first.");
+  }
+  const apiUrl = config.api_url || "https://episoda.dev";
+  const listUrl = `${apiUrl}/api/projects/${config.project_id}/env-vars`;
+  const listResponse = await fetch(listUrl, {
+    headers: {
+      "Authorization": `Bearer ${config.access_token}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!listResponse.ok) {
+    throw new Error("Failed to list env vars");
+  }
+  const listData = await listResponse.json();
+  const existingVar = listData.env_vars?.find((v) => v.key === key);
+  if (!existingVar) {
+    throw new Error(`Env var ${key} not found`);
+  }
+  const deleteUrl = `${apiUrl}/api/projects/${config.project_id}/env-vars/${existingVar.id}`;
+  const deleteResponse = await fetch(deleteUrl, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${config.access_token}`
+    }
+  });
+  if (!deleteResponse.ok) {
+    throw new Error(`Failed to remove env var: ${deleteResponse.status}`);
+  }
+  status.success(`Removed ${key}`);
+}
+async function envPullCommand(options = {}) {
+  const config = await (0, import_core17.loadConfig)();
+  if (!config || !config.access_token) {
+    throw new Error("Not authenticated. Please run `episoda auth` first.");
+  }
+  const apiUrl = config.api_url || "https://episoda.dev";
+  status.info("Fetching environment variables...");
+  const envVars = await fetchEnvVars(apiUrl, config.access_token);
+  if (Object.keys(envVars).length === 0) {
+    status.warning("No environment variables found.");
+    return;
+  }
+  const header = [
+    "# AUTO-GENERATED by episoda env pull",
+    "# Do not edit - changes will be overwritten",
+    `# Source of truth: ${apiUrl}/settings/env-vars`,
+    `# Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "#",
+    "# To update: episoda env set KEY=value",
+    "# To refresh: episoda env pull",
+    ""
+  ].join("\n");
+  const envContent = Object.entries(envVars).map(([key, value]) => {
+    if (/[\s'"#$`\\]/.test(value) || value.includes("\n")) {
+      const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+      return `${key}="${escaped}"`;
+    }
+    return `${key}=${value}`;
+  }).join("\n") + "\n";
+  const fullContent = header + envContent;
+  if (options.stdout) {
+    console.log(fullContent);
+    return;
+  }
+  const filename = options.file || ".env";
+  const filepath = path16.resolve(process.cwd(), filename);
+  fs14.writeFileSync(filepath, fullContent, { mode: 384 });
+  status.success(`Wrote ${Object.keys(envVars).length} env vars to ${filename}`);
+}
+async function promptForValue(key) {
+  if (!process.stdin.isTTY) {
+    return new Promise((resolve5, reject) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      rl.question(`Enter value for ${key}: `, (answer) => {
+        rl.close();
+        resolve5(answer);
+      });
+      rl.on("close", () => {
+        reject(new Error("Input closed"));
+      });
+    });
+  }
+  return new Promise((resolve5, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    let value = "";
+    let resolved = false;
+    const cleanup = () => {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.removeListener("data", dataHandler);
+      rl.close();
+    };
+    const dataHandler = (char) => {
+      const str = char.toString();
+      if (str === "\n" || str === "\r" || str === "\r\n") {
+        resolved = true;
+        cleanup();
+        console.log("");
+        resolve5(value);
+      } else if (str === "") {
+        cleanup();
+        reject(new Error("Cancelled"));
+      } else if (str === "\x7F" || str === "\b") {
+        value = value.slice(0, -1);
+      } else {
+        value += str;
+      }
+    };
+    process.stdin.setRawMode(true);
+    process.stdout.write(`Enter value for ${key}: `);
+    process.stdin.on("data", dataHandler);
+  });
+}
+
 // src/index.ts
-import_commander.program.name("episoda").description("Episoda CLI - local development with git worktree isolation").version(import_core15.VERSION);
+import_commander.program.name("episoda").description("Episoda CLI - local development with git worktree isolation").version(import_core18.VERSION);
 import_commander.program.command("auth").description("Authenticate to Episoda via OAuth and configure CLI").option("--api-url <url>", "API URL (default: https://episoda.dev)").action(async (options) => {
   try {
     await authCommand(options);
@@ -6167,5 +6693,74 @@ function formatUptime(seconds) {
   const mins = Math.floor(seconds % 3600 / 60);
   return `${hours}h ${mins}m`;
 }
+import_commander.program.command("run").description("Run a command with environment variables injected from the database").argument("<command...>", "Command to run with injected env vars").option("--no-cache", "Force fresh fetch from server").option("--cache-ttl <seconds>", "Cache TTL in seconds (default: 60)", parseInt).option("--offline", "Use cached values only, no server call").option("--verbose", "Show fetched variable names").allowUnknownOption().action(async (commandArgs, options) => {
+  try {
+    const args = process.argv.slice(process.argv.indexOf("run") + 1);
+    const separatorIndex = args.indexOf("--");
+    let finalArgs;
+    if (separatorIndex >= 0) {
+      finalArgs = args.slice(separatorIndex + 1);
+    } else {
+      finalArgs = commandArgs.filter(
+        (arg) => !arg.startsWith("--no-cache") && !arg.startsWith("--cache-ttl") && !arg.startsWith("--offline") && !arg.startsWith("--verbose")
+      );
+    }
+    await runCommand(finalArgs, {
+      noCache: options.cache === false,
+      cacheTtl: options.cacheTtl,
+      offline: options.offline,
+      verbose: options.verbose
+    });
+  } catch (error) {
+    status.error(`Run failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("shell").description("Open an interactive shell with environment variables injected").argument("[shell]", "Shell to use (default: $SHELL)").option("--print", "Print export statements instead of opening shell").option("--no-cache", "Force fresh fetch from server").option("--cache-ttl <seconds>", "Cache TTL in seconds (default: 60)", parseInt).option("--offline", "Use cached values only").action(async (shell, options) => {
+  try {
+    await shellCommand(shell, {
+      print: options.print,
+      noCache: options.cache === false,
+      cacheTtl: options.cacheTtl,
+      offline: options.offline
+    });
+  } catch (error) {
+    status.error(`Shell failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+var envCmd = import_commander.program.command("env").description("Manage environment variables");
+envCmd.command("list").description("List environment variables").option("--show-values", "Show value previews (masked)").action(async (options) => {
+  try {
+    await envListCommand({ showValues: options.showValues });
+  } catch (error) {
+    status.error(`Env list failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+envCmd.command("set").description("Set an environment variable").argument("<key=value>", "KEY=value pair (omit value to prompt)").option("-e, --environment <env>", "Environment: all, dev, preview, prod (default: dev)").action(async (keyValue, options) => {
+  try {
+    await envSetCommand(keyValue, { environment: options.environment });
+  } catch (error) {
+    status.error(`Env set failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+envCmd.command("remove").description("Remove an environment variable").argument("<key>", "Variable key to remove").action(async (key) => {
+  try {
+    await envRemoveCommand(key);
+  } catch (error) {
+    status.error(`Env remove failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+envCmd.command("pull").description("Generate .env file from database (explicit file generation)").option("-f, --file <filename>", "Output filename (default: .env)").option("--stdout", "Print to stdout instead of file").action(async (options) => {
+  try {
+    await envPullCommand({ file: options.file, stdout: options.stdout });
+  } catch (error) {
+    status.error(`Env pull failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
 import_commander.program.parse();
 //# sourceMappingURL=index.js.map