episoda 0.2.26 → 0.2.28

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 fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs12.access(rebaseMergePath);
+              await fs13.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs12.access(rebaseApplyPath);
+                await fs13.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1611,9 +1611,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs12.access(command.path);
+            await fs13.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1664,9 +1664,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs12.access(command.path);
+            await fs13.access(command.path);
           } catch {
             return {
               success: false,
@@ -1819,10 +1819,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path14 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path15 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs12.access(command.path);
+            await fs13.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1831,9 +1831,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path14.dirname(command.path);
+          const parentDir = path15.dirname(command.path);
           try {
-            await fs12.mkdir(parentDir, { recursive: true });
+            await fs13.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync(
@@ -1876,22 +1876,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path14 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs13 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path15 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path14.join(currentPath, ".bare");
-            const episodaDir = path14.join(currentPath, ".episoda");
+            const bareDir = path15.join(currentPath, ".bare");
+            const episodaDir = path15.join(currentPath, ".episoda");
             try {
-              await fs12.access(bareDir);
-              await fs12.access(episodaDir);
+              await fs13.access(bareDir);
+              await fs13.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path14.dirname(currentPath);
+              const parentPath = path15.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2485,31 +2485,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig6;
     exports2.saveConfig = saveConfig3;
     exports2.validateToken = validateToken;
-    var fs12 = __importStar(require("fs"));
-    var path14 = __importStar(require("path"));
+    var fs13 = __importStar(require("fs"));
+    var path15 = __importStar(require("path"));
     var os3 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir5() {
-      return process.env.EPISODA_CONFIG_DIR || path14.join(os3.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path15.join(os3.homedir(), ".episoda");
     }
     function getConfigPath4(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path14.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
+      return path15.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path14.dirname(configPath);
-      const isNew = !fs12.existsSync(dir);
+      const dir = path15.dirname(configPath);
+      const isNew = !fs13.existsSync(dir);
       if (isNew) {
-        fs12.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs13.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path14.join(dir, ".nosync");
-        if (isNew || !fs12.existsSync(nosyncPath)) {
+        const nosyncPath = path15.join(dir, ".nosync");
+        if (isNew || !fs13.existsSync(nosyncPath)) {
           try {
-            fs12.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs13.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2521,11 +2521,11 @@ var require_auth = __commonJS({
     }
     async function loadConfig6(configPath) {
       const fullPath = getConfigPath4(configPath);
-      if (!fs12.existsSync(fullPath)) {
+      if (!fs13.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs12.readFileSync(fullPath, "utf8");
+        const content = fs13.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2538,7 +2538,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs12.writeFileSync(fullPath, content, { mode: 384 });
+        fs13.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2649,7 +2649,7 @@ var require_dist = __commonJS({
 
 // src/index.ts
 var import_commander = require("commander");
-var import_core14 = __toESM(require_dist());
+var import_core15 = __toESM(require_dist());
 
 // src/commands/dev.ts
 var import_core4 = __toESM(require_dist());
@@ -3671,8 +3671,8 @@ var WorktreeManager = class _WorktreeManager {
     console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
     console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
     try {
-      const { execSync: execSync7 } = require("child_process");
-      execSync7(script, {
+      const { execSync: execSync9 } = require("child_process");
+      execSync9(script, {
         cwd: worktree.worktreePath,
         stdio: "inherit",
         timeout: TIMEOUT_MINUTES * 60 * 1e3,
@@ -3706,8 +3706,8 @@ var WorktreeManager = class _WorktreeManager {
     console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
     console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
     try {
-      const { execSync: execSync7 } = require("child_process");
-      execSync7(script, {
+      const { execSync: execSync9 } = require("child_process");
+      execSync9(script, {
         cwd: worktree.worktreePath,
         stdio: "inherit",
         timeout: TIMEOUT_MINUTES * 60 * 1e3,
@@ -3784,7 +3784,7 @@ async function fetchProjectPath(config, projectId) {
     return null;
   }
 }
-async function syncProjectPath(config, projectId, path14) {
+async function syncProjectPath(config, projectId, path15) {
   if (!config.device_id || !config.access_token) {
     return false;
   }
@@ -3797,7 +3797,7 @@ async function syncProjectPath(config, projectId, path14) {
         "Authorization": `Bearer ${config.access_token}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ path: path14 })
+      body: JSON.stringify({ path: path15 })
     });
     if (!response.ok) {
       console.debug(`[MachineSettings] syncProjectPath failed: ${response.status} ${response.statusText}`);
@@ -5333,6 +5333,56 @@ async function fetchWithRetry(url, options, maxRetries = 3) {
   throw lastError || new Error("Request failed after retries");
 }
 
+// src/utils/env-setup.ts
+var fs11 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
+async function fetchEnvVars(apiUrl, accessToken) {
+  try {
+    const url = `${apiUrl}/api/cli/env-vars`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      console.warn(`[env-setup] Failed to fetch env vars: ${response.status}`);
+      return {};
+    }
+    const data = await response.json();
+    const envVars = data.env_vars || {};
+    console.log(`[env-setup] Fetched ${Object.keys(envVars).length} env vars from server`);
+    return envVars;
+  } catch (error) {
+    console.warn("[env-setup] Error fetching env vars:", error instanceof Error ? error.message : error);
+    return {};
+  }
+}
+function writeEnvFile(targetPath, envVars) {
+  if (Object.keys(envVars).length === 0) {
+    return;
+  }
+  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 envPath = path12.join(targetPath, ".env");
+  fs11.writeFileSync(envPath, envContent, { mode: 384 });
+  console.log(`[env-setup] Wrote ${Object.keys(envVars).length} env vars to ${envPath}`);
+}
+async function setupWorktreeEnv(worktreePath, apiUrl, accessToken) {
+  const envVars = await fetchEnvVars(apiUrl, accessToken);
+  if (Object.keys(envVars).length === 0) {
+    return false;
+  }
+  writeEnvFile(worktreePath, envVars);
+  return true;
+}
+
 // src/commands/checkout.ts
 async function checkoutCommand(moduleUid, options = {}) {
   if (!moduleUid || !moduleUid.match(/^EP\d+$/)) {
@@ -5412,6 +5462,20 @@ The .bare directory or .episoda/config.json may be missing.`
   }
   status.success("\u2713 Worktree created");
   status.info("");
+  try {
+    status.info("Configuring environment...");
+    const envWritten = await setupWorktreeEnv(result.worktreePath, apiUrl, config.access_token);
+    if (envWritten) {
+      status.success("\u2713 Environment configured");
+    }
+    status.info("");
+  } catch (error) {
+    status.warning("Could not configure environment variables");
+    if (error instanceof Error) {
+      status.warning(`  ${error.message}`);
+    }
+    status.info("");
+  }
   const branchWasGenerated = !moduleDetails.branch_name;
   try {
     await updateModuleCheckout(
@@ -5485,7 +5549,7 @@ async function updateModuleCheckout(apiUrl, moduleId, accessToken, branchName) {
 }
 
 // src/commands/release.ts
-var path12 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 var import_core12 = __toESM(require_dist());
 async function releaseCommand(moduleUid, options = {}) {
   if (!moduleUid || !moduleUid.match(/^EP\d+$/)) {
@@ -5532,7 +5596,7 @@ Commit or stash your changes first, or use --force to discard them.`
       );
     }
   }
-  const currentPath = path12.resolve(process.cwd());
+  const currentPath = path13.resolve(process.cwd());
   if (currentPath.startsWith(existing.worktreePath)) {
     status.warning("You are inside the worktree being released.");
     status.info(`Please cd to ${projectRoot} first.`);
@@ -5606,8 +5670,8 @@ async function updateModuleRelease(apiUrl, projectId, workspaceSlug, moduleUid,
 }
 
 // src/commands/list.ts
-var fs11 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 var import_chalk2 = __toESM(require("chalk"));
 var import_core13 = __toESM(require_dist());
 async function listCommand(subcommand, options = {}) {
@@ -5619,7 +5683,7 @@ async function listCommand(subcommand, options = {}) {
 }
 async function listProjects(options) {
   const episodaRoot = getEpisodaRoot();
-  if (!fs11.existsSync(episodaRoot)) {
+  if (!fs12.existsSync(episodaRoot)) {
     status.info("No projects cloned yet.");
     status.info("");
     status.info("Clone a project with:");
@@ -5627,12 +5691,12 @@ async function listProjects(options) {
     return;
   }
   const projects = [];
-  const workspaces = fs11.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+  const workspaces = fs12.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
   for (const workspace of workspaces) {
-    const workspacePath = path13.join(episodaRoot, workspace.name);
-    const projectDirs = fs11.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+    const workspacePath = path14.join(episodaRoot, workspace.name);
+    const projectDirs = fs12.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
     for (const projectDir of projectDirs) {
-      const projectPath = path13.join(workspacePath, projectDir.name);
+      const projectPath = path14.join(workspacePath, projectDir.name);
       if (await isWorktreeProject(projectPath)) {
         const manager = new WorktreeManager(projectPath);
         await manager.initialize();
@@ -5733,8 +5797,184 @@ async function listWorktrees(options) {
   console.log("");
 }
 
+// src/commands/update.ts
+var import_child_process8 = require("child_process");
+var import_core14 = __toESM(require_dist());
+
+// src/utils/update-checker.ts
+var import_child_process7 = require("child_process");
+var semver = __toESM(require("semver"));
+var PACKAGE_NAME = "episoda";
+var NPM_REGISTRY = "https://registry.npmjs.org";
+async function checkForUpdates(currentVersion) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(`${NPM_REGISTRY}/${PACKAGE_NAME}/latest`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return { currentVersion, latestVersion: currentVersion, updateAvailable: false };
+    }
+    const data = await response.json();
+    const latestVersion = data.version;
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: semver.gt(latestVersion, currentVersion)
+    };
+  } catch (error) {
+    return { currentVersion, latestVersion: currentVersion, updateAvailable: false, offline: true };
+  }
+}
+function getInstalledVersion() {
+  try {
+    const output = (0, import_child_process7.execSync)(`npm list -g ${PACKAGE_NAME} --json`, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    }).toString();
+    const data = JSON.parse(output);
+    return data?.dependencies?.[PACKAGE_NAME]?.version || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/update.ts
+async function isDaemonRunning2() {
+  try {
+    const daemonStatus = await getStatus();
+    return !!daemonStatus;
+  } catch {
+    return false;
+  }
+}
+function stopDaemon2() {
+  try {
+    (0, import_child_process8.execSync)("episoda stop", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function startDaemon2() {
+  try {
+    const child = (0, import_child_process8.spawn)("episoda", ["dev"], {
+      detached: true,
+      stdio: "ignore",
+      shell: process.platform === "win32"
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function performUpdate() {
+  try {
+    (0, import_child_process8.execSync)("npm update -g episoda", {
+      stdio: "pipe",
+      timeout: 12e4
+      // 2 minute timeout
+    });
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("EACCES") || message.includes("permission denied")) {
+      return {
+        success: false,
+        error: "Permission denied. Try running with sudo:\n  sudo npm update -g episoda"
+      };
+    }
+    return { success: false, error: message };
+  }
+}
+async function updateCommand(options = {}) {
+  const currentVersion = import_core14.VERSION;
+  status.info(`Current version: ${currentVersion}`);
+  status.info("Checking for updates...");
+  const result = await checkForUpdates(currentVersion);
+  if (result.offline) {
+    status.warning("\u26A0 Could not check for updates (offline or network error)");
+    status.info(`  Current version: ${currentVersion}`);
+    status.info("");
+    status.info("Check your internet connection and try again.");
+    return;
+  }
+  if (!result.updateAvailable) {
+    status.success(`\u2713 Already up to date (${currentVersion})`);
+    return;
+  }
+  status.info(`Update available: ${result.currentVersion} \u2192 ${result.latestVersion}`);
+  if (options.check) {
+    status.info("");
+    status.info('Run "episoda update" to install the update.');
+    return;
+  }
+  if (!options.yes) {
+    status.info("");
+    status.info("To update, run:");
+    status.info("  episoda update -y");
+    status.info("");
+    status.info("Or with daemon restart:");
+    status.info("  episoda update -y --restart");
+    return;
+  }
+  const daemonWasRunning = options.restart ? await isDaemonRunning2() : false;
+  if (options.restart && daemonWasRunning) {
+    status.info("Stopping daemon before update...");
+    if (!stopDaemon2()) {
+      status.warning("Could not stop daemon gracefully, continuing with update...");
+    }
+  }
+  status.info("Updating...");
+  const updateResult = performUpdate();
+  if (!updateResult.success) {
+    status.error(`\u2717 Update failed: ${updateResult.error}`);
+    if (options.restart && daemonWasRunning) {
+      status.info("Restarting daemon...");
+      startDaemon2();
+    }
+    process.exit(1);
+  }
+  const installedVersion = getInstalledVersion();
+  if (installedVersion && installedVersion !== result.latestVersion) {
+    status.warning(`\u26A0 Update completed but version mismatch detected`);
+    status.info(`  Expected: ${result.latestVersion}`);
+    status.info(`  Installed: ${installedVersion}`);
+    status.info("");
+    status.info("Try running manually: npm update -g episoda");
+  } else if (installedVersion) {
+    status.success(`\u2713 Updated to ${installedVersion}`);
+  } else {
+    status.success(`\u2713 Updated to ${result.latestVersion}`);
+  }
+  if (options.restart && daemonWasRunning) {
+    status.info("Restarting daemon...");
+    await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+    if (startDaemon2()) {
+      status.success("\u2713 Daemon restarted");
+      status.info("");
+      status.info('Run "episoda status" to verify connection.');
+    } else {
+      status.warning("Could not restart daemon automatically.");
+      status.info('Run "episoda dev" to start the daemon.');
+    }
+  } else if (options.restart) {
+    status.info("Daemon was not running, skipping restart.");
+  } else {
+    const daemonRunning = await isDaemonRunning2();
+    if (daemonRunning) {
+      status.info("");
+      status.info("Note: Restart the daemon to use the new version:");
+      status.info("  episoda stop && episoda dev");
+    }
+  }
+}
+
 // src/index.ts
-import_commander.program.name("episoda").description("Episoda CLI - local development with git worktree isolation").version(import_core14.VERSION);
+import_commander.program.name("episoda").description("Episoda CLI - local development with git worktree isolation").version(import_core15.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);
@@ -5790,6 +6030,14 @@ import_commander.program.command("disconnect").description("Disconnect from epis
     process.exit(1);
   }
 });
+import_commander.program.command("update").description("Check for updates and optionally install them").option("-y, --yes", "Auto-update without prompting").option("--check", "Just check for updates, do not install").option("--restart", "Restart daemon after update if it was running").action(async (options) => {
+  try {
+    await updateCommand(options);
+  } catch (error) {
+    status.error(`Update failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
 import_commander.program.command("clone").description("Clone a project for multi-module development").argument("<workspace/project>", "Workspace and project slug (e.g., my-team/my-project)").option("--api-url <url>", "API URL (default: https://episoda.dev)").action(async (slug, options) => {
   try {
     await cloneCommand(slug, options);