episoda 0.2.24 → 0.2.26

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 fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs11.access(rebaseMergePath);
+              await fs12.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs11.access(rebaseApplyPath);
+                await fs12.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1611,9 +1611,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs11.access(command.path);
+            await fs12.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 fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs11.access(command.path);
+            await fs12.access(command.path);
           } catch {
             return {
               success: false,
@@ -1819,10 +1819,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path13 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path14 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs11.access(command.path);
+            await fs12.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1831,9 +1831,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path13.dirname(command.path);
+          const parentDir = path14.dirname(command.path);
           try {
-            await fs11.mkdir(parentDir, { recursive: true });
+            await fs12.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 fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path13 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path14 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path13.join(currentPath, ".bare");
-            const episodaDir = path13.join(currentPath, ".episoda");
+            const bareDir = path14.join(currentPath, ".bare");
+            const episodaDir = path14.join(currentPath, ".episoda");
             try {
-              await fs11.access(bareDir);
-              await fs11.access(episodaDir);
+              await fs12.access(bareDir);
+              await fs12.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path13.dirname(currentPath);
+              const parentPath = path14.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2485,31 +2485,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig6;
     exports2.saveConfig = saveConfig3;
     exports2.validateToken = validateToken;
-    var fs11 = __importStar(require("fs"));
-    var path13 = __importStar(require("path"));
+    var fs12 = __importStar(require("fs"));
+    var path14 = __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 || path13.join(os3.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path14.join(os3.homedir(), ".episoda");
     }
     function getConfigPath4(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path13.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
+      return path14.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path13.dirname(configPath);
-      const isNew = !fs11.existsSync(dir);
+      const dir = path14.dirname(configPath);
+      const isNew = !fs12.existsSync(dir);
       if (isNew) {
-        fs11.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs12.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path13.join(dir, ".nosync");
-        if (isNew || !fs11.existsSync(nosyncPath)) {
+        const nosyncPath = path14.join(dir, ".nosync");
+        if (isNew || !fs12.existsSync(nosyncPath)) {
           try {
-            fs11.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs12.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 (!fs11.existsSync(fullPath)) {
+      if (!fs12.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs11.readFileSync(fullPath, "utf8");
+        const content = fs12.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);
-        fs11.writeFileSync(fullPath, content, { mode: 384 });
+        fs12.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -3125,9 +3125,9 @@ async function getDevServerStatus() {
 }
 
 // src/commands/dev.ts
-var import_child_process2 = require("child_process");
-var path5 = __toESM(require("path"));
-var fs4 = __toESM(require("fs"));
+var import_child_process3 = require("child_process");
+var path6 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
 
 // src/utils/port-check.ts
 var net2 = __toESM(require("net"));
@@ -3784,7 +3784,7 @@ async function fetchProjectPath(config, projectId) {
     return null;
   }
 }
-async function syncProjectPath(config, projectId, path13) {
+async function syncProjectPath(config, projectId, path14) {
   if (!config.device_id || !config.access_token) {
     return false;
   }
@@ -3797,7 +3797,7 @@ async function syncProjectPath(config, projectId, path13) {
         "Authorization": `Bearer ${config.access_token}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ path: path13 })
+      body: JSON.stringify({ path: path14 })
     });
     if (!response.ok) {
       console.debug(`[MachineSettings] syncProjectPath failed: ${response.status} ${response.statusText}`);
@@ -3809,11 +3809,35 @@ async function syncProjectPath(config, projectId, path13) {
   }
 }
 
+// src/utils/bootstrap.ts
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+async function extractBootstrapScripts(bareRepoPath, projectPath) {
+  const scriptsDir = path5.join(projectPath, ".episoda", "scripts");
+  const scriptPath = path5.join(scriptsDir, "api-helper.sh");
+  if (fs4.existsSync(scriptPath)) {
+    return false;
+  }
+  fs4.mkdirSync(scriptsDir, { recursive: true });
+  try {
+    const scriptContent = (0, import_child_process2.execSync)(
+      `git --git-dir="${bareRepoPath}" show main:scripts/api-helper.sh`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    fs4.writeFileSync(scriptPath, scriptContent, { mode: 493 });
+    return true;
+  } catch (error) {
+    console.log("[bootstrap] Could not extract api-helper.sh:", error);
+    return false;
+  }
+}
+
 // src/commands/dev.ts
 var CONNECTION_MAX_RETRIES = 3;
 function findGitRoot(startDir) {
   try {
-    const result = (0, import_child_process2.execSync)("git rev-parse --show-toplevel", {
+    const result = (0, import_child_process3.execSync)("git rev-parse --show-toplevel", {
       cwd: startDir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3869,12 +3893,12 @@ async function devCommand(options = {}) {
     }
     let projectPath;
     const serverPath = await fetchProjectPath(config, config.project_id);
-    if (serverPath && fs4.existsSync(serverPath)) {
+    if (serverPath && fs5.existsSync(serverPath)) {
       projectPath = serverPath;
       status.debug(`Using server-synced project path: ${projectPath}`);
     } else {
       const detectedRoot = findGitRoot(options.cwd || process.cwd());
-      projectPath = detectedRoot || path5.resolve(options.cwd || process.cwd());
+      projectPath = detectedRoot || path6.resolve(options.cwd || process.cwd());
       if (detectedRoot) {
         status.debug(`Detected project root: ${projectPath}`);
       } else {
@@ -3895,6 +3919,11 @@ async function devCommand(options = {}) {
       status.info("");
       process.exit(1);
     }
+    const bareRepoPath = path6.join(projectPath, ".bare");
+    const scriptsExtracted = await extractBootstrapScripts(bareRepoPath, projectPath);
+    if (scriptsExtracted) {
+      status.success("\u2713 Bootstrap scripts extracted");
+    }
     let daemonPid = isDaemonRunning();
     if (!daemonPid) {
       status.info("Starting Episoda daemon...");
@@ -3987,7 +4016,7 @@ async function runDevServer(command, cwd, autoRestart) {
   let shuttingDown = false;
   const startServer = () => {
     status.info(`Starting dev server: ${command.join(" ")}`);
-    devProcess = (0, import_child_process2.spawn)(command[0], command.slice(1), {
+    devProcess = (0, import_child_process3.spawn)(command[0], command.slice(1), {
       cwd,
       stdio: ["inherit", "inherit", "inherit"],
       shell: true
@@ -4040,33 +4069,33 @@ Received ${signal}, shutting down...`);
 
 // src/commands/auth.ts
 var os = __toESM(require("os"));
-var fs6 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
-var import_child_process4 = require("child_process");
+var fs7 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+var import_child_process5 = require("child_process");
 var import_core6 = __toESM(require_dist());
 
 // src/daemon/machine-id.ts
-var fs5 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_core5 = __toESM(require_dist());
 function isValidUUID(str) {
   const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   return uuidRegex.test(str);
 }
 async function getMachineId() {
-  const machineIdPath = path6.join((0, import_core5.getConfigDir)(), "machine-id");
+  const machineIdPath = path7.join((0, import_core5.getConfigDir)(), "machine-id");
   try {
-    if (fs5.existsSync(machineIdPath)) {
-      const existingId = fs5.readFileSync(machineIdPath, "utf-8").trim();
+    if (fs6.existsSync(machineIdPath)) {
+      const existingId = fs6.readFileSync(machineIdPath, "utf-8").trim();
       if (existingId) {
         if (isValidUUID(existingId)) {
           return existingId;
         }
         console.log("[MachineId] Migrating legacy machine ID to UUID format...");
         const newUUID = generateMachineId();
-        fs5.writeFileSync(machineIdPath, newUUID, "utf-8");
+        fs6.writeFileSync(machineIdPath, newUUID, "utf-8");
         console.log(`[MachineId] Migrated: ${existingId} \u2192 ${newUUID}`);
         return newUUID;
       }
@@ -4075,11 +4104,11 @@ async function getMachineId() {
   }
   const machineId = generateMachineId();
   try {
-    const dir = path6.dirname(machineIdPath);
-    if (!fs5.existsSync(dir)) {
-      fs5.mkdirSync(dir, { recursive: true });
+    const dir = path7.dirname(machineIdPath);
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
     }
-    fs5.writeFileSync(machineIdPath, machineId, "utf-8");
+    fs6.writeFileSync(machineIdPath, machineId, "utf-8");
   } catch (error) {
     console.error("Warning: Could not save machine ID to disk:", error);
   }
@@ -4088,7 +4117,7 @@ async function getMachineId() {
 function getHardwareUUID() {
   try {
     if (process.platform === "darwin") {
-      const output = (0, import_child_process3.execSync)(
+      const output = (0, import_child_process4.execSync)(
         `ioreg -d2 -c IOPlatformExpertDevice | awk -F\\" '/IOPlatformUUID/{print $(NF-1)}'`,
         { encoding: "utf-8", timeout: 5e3 }
       ).trim();
@@ -4096,20 +4125,20 @@ function getHardwareUUID() {
         return output;
       }
     } else if (process.platform === "linux") {
-      if (fs5.existsSync("/etc/machine-id")) {
-        const machineId = fs5.readFileSync("/etc/machine-id", "utf-8").trim();
+      if (fs6.existsSync("/etc/machine-id")) {
+        const machineId = fs6.readFileSync("/etc/machine-id", "utf-8").trim();
         if (machineId && machineId.length > 0) {
           return machineId;
         }
       }
-      if (fs5.existsSync("/var/lib/dbus/machine-id")) {
-        const dbusId = fs5.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim();
+      if (fs6.existsSync("/var/lib/dbus/machine-id")) {
+        const dbusId = fs6.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim();
         if (dbusId && dbusId.length > 0) {
           return dbusId;
         }
       }
     } else if (process.platform === "win32") {
-      const output = (0, import_child_process3.execSync)("wmic csproduct get uuid", {
+      const output = (0, import_child_process4.execSync)("wmic csproduct get uuid", {
         encoding: "utf-8",
         timeout: 5e3
       });
@@ -4548,7 +4577,7 @@ async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
       resolve4(false);
     }, expiresIn * 1e3);
     const url = `${apiUrl}/api/oauth/authorize-stream?device_code=${deviceCode}`;
-    const curlProcess = (0, import_child_process4.spawn)("curl", ["-N", url]);
+    const curlProcess = (0, import_child_process5.spawn)("curl", ["-N", url]);
     let buffer = "";
     curlProcess.stdout.on("data", (chunk) => {
       buffer += chunk.toString();
@@ -4652,7 +4681,7 @@ function openBrowser(url) {
       break;
   }
   try {
-    (0, import_child_process4.spawn)(command, args, {
+    (0, import_child_process5.spawn)(command, args, {
       detached: true,
       stdio: "ignore"
     }).unref();
@@ -4663,17 +4692,17 @@ function openBrowser(url) {
 async function installGitCredentialHelper(apiUrl) {
   try {
     const homeDir = os.homedir();
-    const episodaBinDir = path7.join(homeDir, ".episoda", "bin");
-    const helperPath = path7.join(episodaBinDir, "git-credential-episoda");
-    fs6.mkdirSync(episodaBinDir, { recursive: true });
+    const episodaBinDir = path8.join(homeDir, ".episoda", "bin");
+    const helperPath = path8.join(episodaBinDir, "git-credential-episoda");
+    fs7.mkdirSync(episodaBinDir, { recursive: true });
     const scriptContent = generateCredentialHelperScript(apiUrl);
-    fs6.writeFileSync(helperPath, scriptContent, { mode: 493 });
+    fs7.writeFileSync(helperPath, scriptContent, { mode: 493 });
     try {
-      fs6.accessSync(helperPath, fs6.constants.X_OK);
+      fs7.accessSync(helperPath, fs7.constants.X_OK);
     } catch {
     }
     try {
-      const allHelpers = (0, import_child_process4.execSync)("git config --global --get-all credential.helper", {
+      const allHelpers = (0, import_child_process5.execSync)("git config --global --get-all credential.helper", {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim().split("\n");
@@ -4682,7 +4711,7 @@ async function installGitCredentialHelper(apiUrl) {
       }
     } catch {
     }
-    (0, import_child_process4.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
+    (0, import_child_process5.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -4700,19 +4729,19 @@ function updateShellProfile(binDir) {
   }
   const homeDir = os.homedir();
   const profiles = [
-    path7.join(homeDir, ".bashrc"),
-    path7.join(homeDir, ".zshrc"),
-    path7.join(homeDir, ".profile")
+    path8.join(homeDir, ".bashrc"),
+    path8.join(homeDir, ".zshrc"),
+    path8.join(homeDir, ".profile")
   ];
   const exportLine = `export PATH="${binDir}:$PATH"  # Added by episoda auth`;
   for (const profile of profiles) {
     try {
-      if (fs6.existsSync(profile)) {
-        const content = fs6.readFileSync(profile, "utf8");
+      if (fs7.existsSync(profile)) {
+        const content = fs7.readFileSync(profile, "utf8");
         if (content.includes(".episoda/bin")) {
           continue;
         }
-        fs6.appendFileSync(profile, `
+        fs7.appendFileSync(profile, `
 # Episoda CLI
 ${exportLine}
 `);
@@ -4724,9 +4753,9 @@ ${exportLine}
 
 // src/commands/connect.ts
 var os2 = __toESM(require("os"));
-var fs7 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
-var import_child_process5 = require("child_process");
+var fs8 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+var import_child_process6 = require("child_process");
 var import_core7 = __toESM(require_dist());
 async function connectCommand(options) {
   const { code } = options;
@@ -4800,13 +4829,13 @@ async function exchangeUserCode(apiUrl, userCode, machineId) {
 async function installGitCredentialHelper2(apiUrl) {
   try {
     const homeDir = os2.homedir();
-    const episodaBinDir = path8.join(homeDir, ".episoda", "bin");
-    const helperPath = path8.join(episodaBinDir, "git-credential-episoda");
-    fs7.mkdirSync(episodaBinDir, { recursive: true });
+    const episodaBinDir = path9.join(homeDir, ".episoda", "bin");
+    const helperPath = path9.join(episodaBinDir, "git-credential-episoda");
+    fs8.mkdirSync(episodaBinDir, { recursive: true });
     const scriptContent = generateCredentialHelperScript(apiUrl);
-    fs7.writeFileSync(helperPath, scriptContent, { mode: 493 });
+    fs8.writeFileSync(helperPath, scriptContent, { mode: 493 });
     try {
-      const allHelpers = (0, import_child_process5.execSync)("git config --global --get-all credential.helper", {
+      const allHelpers = (0, import_child_process6.execSync)("git config --global --get-all credential.helper", {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim().split("\n");
@@ -4815,7 +4844,7 @@ async function installGitCredentialHelper2(apiUrl) {
       }
     } catch {
     }
-    (0, import_child_process5.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
+    (0, import_child_process6.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -4833,19 +4862,19 @@ function updateShellProfile2(binDir) {
   }
   const homeDir = os2.homedir();
   const profiles = [
-    path8.join(homeDir, ".bashrc"),
-    path8.join(homeDir, ".zshrc"),
-    path8.join(homeDir, ".profile")
+    path9.join(homeDir, ".bashrc"),
+    path9.join(homeDir, ".zshrc"),
+    path9.join(homeDir, ".profile")
   ];
   const exportLine = `export PATH="${binDir}:$PATH"  # Added by episoda`;
   for (const profile of profiles) {
     try {
-      if (fs7.existsSync(profile)) {
-        const content = fs7.readFileSync(profile, "utf8");
+      if (fs8.existsSync(profile)) {
+        const content = fs8.readFileSync(profile, "utf8");
         if (content.includes(".episoda/bin")) {
           continue;
         }
-        fs7.appendFileSync(profile, `
+        fs8.appendFileSync(profile, `
 # Episoda CLI
 ${exportLine}
 `);
@@ -5036,25 +5065,24 @@ async function stopCommand(options = {}) {
 }
 
 // src/commands/clone.ts
-var fs9 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
-var import_child_process6 = require("child_process");
+var fs10 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 var import_core10 = __toESM(require_dist());
 
 // src/daemon/project-tracker.ts
-var fs8 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 var import_core9 = __toESM(require_dist());
 function getProjectsFilePath() {
-  return path9.join((0, import_core9.getConfigDir)(), "projects.json");
+  return path10.join((0, import_core9.getConfigDir)(), "projects.json");
 }
 function readProjects() {
   const projectsPath = getProjectsFilePath();
   try {
-    if (!fs8.existsSync(projectsPath)) {
+    if (!fs9.existsSync(projectsPath)) {
       return { projects: [] };
     }
-    const content = fs8.readFileSync(projectsPath, "utf-8");
+    const content = fs9.readFileSync(projectsPath, "utf-8");
     const data = JSON.parse(content);
     if (!data.projects || !Array.isArray(data.projects)) {
       console.warn("Invalid projects.json structure, resetting");
@@ -5069,11 +5097,11 @@ function readProjects() {
 function writeProjects(data) {
   const projectsPath = getProjectsFilePath();
   try {
-    const dir = path9.dirname(projectsPath);
-    if (!fs8.existsSync(dir)) {
-      fs8.mkdirSync(dir, { recursive: true });
+    const dir = path10.dirname(projectsPath);
+    if (!fs9.existsSync(dir)) {
+      fs9.mkdirSync(dir, { recursive: true });
     }
-    fs8.writeFileSync(projectsPath, JSON.stringify(data, null, 2), "utf-8");
+    fs9.writeFileSync(projectsPath, JSON.stringify(data, null, 2), "utf-8");
   } catch (error) {
     throw new Error(`Failed to write projects.json: ${error}`);
   }
@@ -5097,7 +5125,7 @@ function addProject2(projectId, projectPath, options) {
     console.log(`[ProjectTracker] Replacing project entry: ${existingById.path} -> ${projectPath}`);
     data.projects.splice(existingByIdIndex, 1);
   }
-  const projectName = path9.basename(projectPath);
+  const projectName = path10.basename(projectPath);
   const newProject = {
     id: projectId,
     path: projectPath,
@@ -5131,9 +5159,9 @@ async function cloneCommand(slugArg, options = {}) {
   }
   const apiUrl = options.apiUrl || config.api_url || "https://episoda.dev";
   const projectPath = getProjectPath(workspaceSlug, projectSlug);
-  if (fs9.existsSync(projectPath)) {
-    const bareRepoPath = path10.join(projectPath, ".bare");
-    if (fs9.existsSync(bareRepoPath)) {
+  if (fs10.existsSync(projectPath)) {
+    const bareRepoPath = path11.join(projectPath, ".bare");
+    if (fs10.existsSync(bareRepoPath)) {
       status.warning(`Project already cloned at ${projectPath}`);
       status.info("");
       status.info("Next steps:");
@@ -5165,7 +5193,7 @@ Please configure a repository in the project settings on episoda.dev.`
   status.info("");
   status.info("Creating project directory...");
   const episodaRoot = getEpisodaRoot();
-  fs9.mkdirSync(projectPath, { recursive: true });
+  fs10.mkdirSync(projectPath, { recursive: true });
   status.success(`\u2713 Created ${projectPath}`);
   status.info("Cloning repository (bare)...");
   try {
@@ -5203,9 +5231,9 @@ Please configure a repository in the project settings on episoda.dev.`
     status.info("  3. episoda checkout {moduleUid}  # e.g., episoda checkout EP100");
     status.info("");
   } catch (error) {
-    if (fs9.existsSync(projectPath)) {
+    if (fs10.existsSync(projectPath)) {
       try {
-        fs9.rmSync(projectPath, { recursive: true, force: true });
+        fs10.rmSync(projectPath, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5278,20 +5306,6 @@ ${errorBody}`
   }
   return data;
 }
-async function extractBootstrapScripts(bareRepoPath, projectPath) {
-  const scriptsDir = path10.join(projectPath, ".episoda", "scripts");
-  fs9.mkdirSync(scriptsDir, { recursive: true });
-  try {
-    const scriptContent = (0, import_child_process6.execSync)(
-      `git --git-dir="${bareRepoPath}" show main:scripts/api-helper.sh`,
-      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-    );
-    const scriptPath = path10.join(scriptsDir, "api-helper.sh");
-    fs9.writeFileSync(scriptPath, scriptContent, { mode: 493 });
-  } catch (error) {
-    console.log("[clone] Could not extract api-helper.sh:", error);
-  }
-}
 
 // src/commands/checkout.ts
 var import_core11 = __toESM(require_dist());
@@ -5471,7 +5485,7 @@ async function updateModuleCheckout(apiUrl, moduleId, accessToken, branchName) {
 }
 
 // src/commands/release.ts
-var path11 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var import_core12 = __toESM(require_dist());
 async function releaseCommand(moduleUid, options = {}) {
   if (!moduleUid || !moduleUid.match(/^EP\d+$/)) {
@@ -5518,7 +5532,7 @@ Commit or stash your changes first, or use --force to discard them.`
       );
     }
   }
-  const currentPath = path11.resolve(process.cwd());
+  const currentPath = path12.resolve(process.cwd());
   if (currentPath.startsWith(existing.worktreePath)) {
     status.warning("You are inside the worktree being released.");
     status.info(`Please cd to ${projectRoot} first.`);
@@ -5592,8 +5606,8 @@ async function updateModuleRelease(apiUrl, projectId, workspaceSlug, moduleUid,
 }
 
 // src/commands/list.ts
-var fs10 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var import_chalk2 = __toESM(require("chalk"));
 var import_core13 = __toESM(require_dist());
 async function listCommand(subcommand, options = {}) {
@@ -5605,7 +5619,7 @@ async function listCommand(subcommand, options = {}) {
 }
 async function listProjects(options) {
   const episodaRoot = getEpisodaRoot();
-  if (!fs10.existsSync(episodaRoot)) {
+  if (!fs11.existsSync(episodaRoot)) {
     status.info("No projects cloned yet.");
     status.info("");
     status.info("Clone a project with:");
@@ -5613,12 +5627,12 @@ async function listProjects(options) {
     return;
   }
   const projects = [];
-  const workspaces = fs10.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+  const workspaces = fs11.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
   for (const workspace of workspaces) {
-    const workspacePath = path12.join(episodaRoot, workspace.name);
-    const projectDirs = fs10.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+    const workspacePath = path13.join(episodaRoot, workspace.name);
+    const projectDirs = fs11.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
     for (const projectDir of projectDirs) {
-      const projectPath = path12.join(workspacePath, projectDir.name);
+      const projectPath = path13.join(workspacePath, projectDir.name);
       if (await isWorktreeProject(projectPath)) {
         const manager = new WorktreeManager(projectPath);
         await manager.initialize();