@episoda/cli 0.2.163 → 0.2.164

package/dist/daemon/daemon-process.js

@@ -343,6 +343,8 @@ var require_git_executor = __commonJS({
             case "delete_branch":
               return await this.executeDeleteBranch(command, cwd, options);
             // EP597: Read operations for production local dev mode
+            case "list_branches":
+              return await this.executeListBranches(cwd, options);
             case "branch_exists":
               return await this.executeBranchExists(command, cwd, options);
             case "branch_has_commits":
@@ -632,6 +634,65 @@ var require_git_executor = __commonJS({
         args.push(command.branch);
         return await this.runGitCommand(args, cwd, options);
       }
+      /**
+       * List local branches with remote-tracking signal and current branch marker.
+       */
+      async executeListBranches(cwd, options) {
+        try {
+          const timeout = options?.timeout || 1e4;
+          const branchMap = /* @__PURE__ */ new Map();
+          const addBranch = (name, attrs) => {
+            const normalized = name.trim();
+            if (!normalized)
+              return;
+            const existing = branchMap.get(normalized);
+            if (existing) {
+              existing.current = existing.current || !!attrs?.current;
+              existing.remote = existing.remote || !!attrs?.remote;
+              return;
+            }
+            branchMap.set(normalized, {
+              name: normalized,
+              current: !!attrs?.current,
+              remote: !!attrs?.remote
+            });
+          };
+          const statusResult = await this.executeStatus(cwd, options);
+          const currentBranch = statusResult.success ? statusResult.details?.branchName : void 0;
+          try {
+            const { stdout } = await execAsync3(`git for-each-ref --format='%(refname:short)' refs/heads`, { cwd, timeout });
+            stdout.split("\n").map((line) => line.trim()).filter(Boolean).forEach((name) => addBranch(name, { current: name === currentBranch }));
+          } catch {
+          }
+          try {
+            const { stdout } = await execAsync3(`git for-each-ref --format='%(refname:short)' refs/remotes/origin`, { cwd, timeout });
+            stdout.split("\n").map((line) => line.trim()).filter(Boolean).forEach((refName) => {
+              if (refName === "origin/HEAD")
+                return;
+              const normalized = refName.startsWith("origin/") ? refName.slice("origin/".length) : refName;
+              addBranch(normalized, { remote: true, current: normalized === currentBranch });
+            });
+          } catch {
+          }
+          if (currentBranch && currentBranch !== "HEAD") {
+            addBranch(currentBranch, { current: true });
+          }
+          const branches = Array.from(branchMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+          return {
+            success: true,
+            details: {
+              branchName: currentBranch,
+              branches
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to list branches"
+          };
+        }
+      }
       /**
        * EP597: Execute branch_exists command
        * Checks if a branch exists locally and/or remotely
@@ -2153,6 +2214,8 @@ var require_websocket_client = __commonJS({
         this.osArch = deviceInfo?.osArch;
         this.daemonPid = deviceInfo?.daemonPid;
         this.cliVersion = deviceInfo?.cliVersion;
+        this.cliPackageName = deviceInfo?.cliPackageName;
+        this.capabilities = deviceInfo?.capabilities;
         this.environment = deviceInfo?.environment;
         this.containerId = deviceInfo?.containerId;
         this.isDisconnecting = false;
@@ -2192,6 +2255,8 @@ var require_websocket_client = __commonJS({
                 type: "auth",
                 token,
                 version: this.cliVersion || version_1.VERSION,
+                cliPackageName: this.cliPackageName,
+                capabilities: this.capabilities,
                 environment: this.environment,
                 machineId,
                 containerId: this.containerId,
@@ -2511,6 +2576,8 @@ var require_websocket_client = __commonJS({
             osArch: this.osArch,
             daemonPid: this.daemonPid,
             cliVersion: this.cliVersion,
+            cliPackageName: this.cliPackageName,
+            capabilities: this.capabilities,
             environment: this.environment,
             containerId: this.containerId
           }).then(() => {
@@ -2911,7 +2978,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.163",
+      version: "0.2.164",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -7527,7 +7594,7 @@ ${message}`;
               const args2 = parts.slice(1);
               let env;
               if (server.name === "github") {
-                env = { ...baseEnv };
+                env = void 0;
               } else {
                 env = {
                   ...baseEnv,
@@ -8620,8 +8687,8 @@ var WorktreeManager = class _WorktreeManager {
     const allWorktrees = this.listWorktrees();
     const activeSet = new Set(activeModuleUids);
     const orphaned = allWorktrees.filter((w) => !activeSet.has(w.moduleUid));
-    const valid = allWorktrees.filter((w) => activeSet.has(w.moduleUid));
-    return { orphaned, valid };
+    const valid3 = allWorktrees.filter((w) => activeSet.has(w.moduleUid));
+    return { orphaned, valid: valid3 };
   }
   /**
    * Update last accessed timestamp for a worktree
@@ -8656,7 +8723,7 @@ var WorktreeManager = class _WorktreeManager {
    */
   async validateWorktrees() {
     const config = this.readConfig();
-    const valid = [];
+    const valid3 = [];
     const stale = [];
     const orphaned = [];
     const listResult = await this.gitExecutor.execute({
@@ -8667,7 +8734,7 @@ var WorktreeManager = class _WorktreeManager {
     );
     for (const worktree of config?.worktrees || []) {
       if (actualWorktrees.has(worktree.worktreePath)) {
-        valid.push(worktree);
+        valid3.push(worktree);
         actualWorktrees.delete(worktree.worktreePath);
       } else {
         stale.push(worktree);
@@ -8678,7 +8745,7 @@ var WorktreeManager = class _WorktreeManager {
         orphaned.push(wpath);
       }
     }
-    return { valid, stale, orphaned };
+    return { valid: valid3, stale, orphaned };
   }
   /**
    * EP1190: Clean up non-module worktrees (like 'main')
@@ -11551,6 +11618,18 @@ async function deleteWorktree(config, moduleUid) {
 // src/daemon/package-manager.ts
 var fs21 = __toESM(require("fs"));
 var path22 = __toESM(require("path"));
+function pnpmCommand(args) {
+  return [
+    "if command -v pnpm >/dev/null 2>&1; then",
+    `  pnpm ${args}`,
+    "elif command -v corepack >/dev/null 2>&1; then",
+    `  corepack pnpm ${args}`,
+    "else",
+    '  echo "[setup] ERROR: pnpm is not installed and corepack is unavailable" >&2',
+    "  exit 127",
+    "fi"
+  ].join(" ");
+}
 var PACKAGE_MANAGERS = {
   javascript: [
     {
@@ -11572,7 +11651,7 @@ var PACKAGE_MANAGERS = {
         return null;
       },
       config: {
-        installCmd: "pnpm install --frozen-lockfile",
+        installCmd: pnpmCommand("install --frozen-lockfile"),
         cacheEnvVar: "PNPM_HOME"
       }
     },
@@ -11604,7 +11683,7 @@ var PACKAGE_MANAGERS = {
       name: "pnpm",
       detector: (p) => fs21.existsSync(path22.join(p, "package.json")) ? "package.json (no lockfile - defaulting to pnpm)" : null,
       config: {
-        installCmd: "pnpm install",
+        installCmd: pnpmCommand("install"),
         cacheEnvVar: "PNPM_HOME"
       }
     }
@@ -11752,7 +11831,7 @@ async function autoDetectSetupScript(worktreePath) {
 function getBuildPackagesCommand(packageManagerName) {
   switch (packageManagerName) {
     case "pnpm":
-      return "pnpm run build:packages";
+      return 'if command -v pnpm >/dev/null 2>&1; then pnpm run build:packages; elif command -v corepack >/dev/null 2>&1; then corepack pnpm run build:packages; else echo "[setup] ERROR: pnpm is not installed and corepack is unavailable" >&2; exit 127; fi';
     case "yarn":
       return "yarn build:packages";
     case "npm":
@@ -12771,6 +12850,7 @@ var fs25 = __toESM(require("fs"));
 var path26 = __toESM(require("path"));
 var import_child_process18 = require("child_process");
 var import_core17 = __toESM(require_dist());
+var semver2 = __toESM(require("semver"));
 
 // src/utils/update-checker.ts
 var import_child_process17 = require("child_process");
@@ -12781,6 +12861,7 @@ var import_core16 = __toESM(require_dist());
 
 // src/utils/update-checker.ts
 var PACKAGE_NAME = "@episoda/cli";
+var LEGACY_PACKAGE_NAME = "episoda";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 function isFileLinkedInstall() {
   try {
@@ -12853,6 +12934,39 @@ function getInstalledVersion() {
     return null;
   }
 }
+function getLegacyInstalledVersion() {
+  try {
+    const output = (0, import_child_process17.execSync)(`npm list -g ${LEGACY_PACKAGE_NAME} --json`, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    }).toString();
+    const data = JSON.parse(output);
+    return data?.dependencies?.[LEGACY_PACKAGE_NAME]?.version || null;
+  } catch {
+    return null;
+  }
+}
+function detectCliInstallChannel(embeddedVersion) {
+  const scopedVersion = getInstalledVersion();
+  const legacyVersion = getLegacyInstalledVersion();
+  const effectiveVersion = scopedVersion || legacyVersion || embeddedVersion || null;
+  return {
+    scopedVersion,
+    legacyVersion,
+    legacyOnly: !scopedVersion && !!legacyVersion,
+    effectiveVersion
+  };
+}
+function resolveEffectiveCliVersion(embeddedVersion) {
+  const installedVersion = detectCliInstallChannel(embeddedVersion).effectiveVersion;
+  if (!installedVersion) {
+    return embeddedVersion;
+  }
+  if (semver.valid(installedVersion) && semver.valid(embeddedVersion)) {
+    return semver.gt(installedVersion, embeddedVersion) ? installedVersion : embeddedVersion;
+  }
+  return installedVersion === embeddedVersion ? embeddedVersion : installedVersion;
+}
 
 // src/daemon/update-manager.ts
 var UpdateManager = class _UpdateManager {
@@ -12875,6 +12989,19 @@ var UpdateManager = class _UpdateManager {
     // 4 hours
     this.MAX_UPDATE_ATTEMPTS = 3;
   }
+  /**
+   * Prefer installed CLI version when it's newer than embedded bundle metadata.
+   * This avoids update churn when daemon bundle version lags package install version.
+   */
+  getEffectiveCurrentVersion() {
+    return resolveEffectiveCliVersion(this.currentVersion);
+  }
+  isTargetVersionNewer(targetVersion, currentVersion) {
+    if (semver2.valid(targetVersion) && semver2.valid(currentVersion)) {
+      return semver2.gt(targetVersion, currentVersion);
+    }
+    return targetVersion !== currentVersion;
+  }
   /**
    * Start periodic update checks (every 4 hours).
    * Does nothing if EPISODA_CLI_PIN_VERSION is set.
@@ -12919,7 +13046,8 @@ var UpdateManager = class _UpdateManager {
       return;
     }
     try {
-      const result = await checkForUpdates(this.currentVersion);
+      const effectiveCurrentVersion = this.getEffectiveCurrentVersion();
+      const result = await checkForUpdates(effectiveCurrentVersion);
       if (result.updateAvailable) {
         await this.applyUpdateIfIdle(result.latestVersion, "startup");
       }
@@ -12941,8 +13069,9 @@ var UpdateManager = class _UpdateManager {
   }
   async applyUpdateIfIdle(targetVersion, source) {
     if (this.updateInProgress) return;
-    if (targetVersion === this.currentVersion) {
-      console.log(`[Daemon] EP1324: Already running version ${targetVersion}, skipping update`);
+    const effectiveCurrentVersion = this.getEffectiveCurrentVersion();
+    if (!this.isTargetVersionNewer(targetVersion, effectiveCurrentVersion)) {
+      console.log(`[Daemon] EP1390: Skipping update target=${targetVersion}, current=${effectiveCurrentVersion} (source=${source})`);
       return;
     }
     if (this.lastFailedUpdateVersion === targetVersion && this.updateFailedAttempts >= _UpdateManager.MAX_UPDATE_ATTEMPTS) {
@@ -12952,12 +13081,12 @@ var UpdateManager = class _UpdateManager {
     const activeAgentSessions = this.getActiveAgentSessionCount();
     if (activeAgentSessions > 0) {
       this.pendingUpdateVersion = targetVersion;
-      console.log(`[Daemon] EP1319: Update available (${this.currentVersion} \u2192 ${targetVersion}) but ${activeAgentSessions} active agent session(s) \u2014 deferring`);
+      console.log(`[Daemon] EP1319: Update available (${effectiveCurrentVersion} \u2192 ${targetVersion}) but ${activeAgentSessions} active agent session(s) \u2014 deferring`);
       return;
     }
-    const currentInstalled = getInstalledVersion();
-    if (currentInstalled && currentInstalled === targetVersion) {
-      console.log(`[Daemon] EP1343: Already installed version ${targetVersion} (embedded: ${this.currentVersion}), skipping update`);
+    const latestEffectiveCurrent = this.getEffectiveCurrentVersion();
+    if (!this.isTargetVersionNewer(targetVersion, latestEffectiveCurrent)) {
+      console.log(`[Daemon] EP1390: Update no longer needed target=${targetVersion}, current=${latestEffectiveCurrent}`);
       return;
     }
     this.updateInProgress = true;
@@ -12983,6 +13112,14 @@ var UpdateManager = class _UpdateManager {
         stdio: ["ignore", logFd, logFd],
         env: { ...process.env, EPISODA_DAEMON_MODE: "1" }
       });
+      if (!child.pid) {
+        try {
+          fs25.closeSync(logFd);
+        } catch {
+        }
+        this.recordUpdateFailure(targetVersion, "Failed to spawn replacement daemon (missing pid)");
+        return;
+      }
       child.unref();
       const pidPath = getPidFilePath();
       fs25.writeFileSync(pidPath, child.pid.toString(), "utf-8");
@@ -13019,7 +13156,8 @@ var UpdateManager = class _UpdateManager {
       return;
     }
     try {
-      const result = await checkForUpdates(this.currentVersion);
+      const effectiveCurrentVersion = this.getEffectiveCurrentVersion();
+      const result = await checkForUpdates(effectiveCurrentVersion);
       if (!result.updateAvailable) {
         if (this.pendingUpdateVersion) {
           console.log(`[Daemon] EP1319: Pending update to ${this.pendingUpdateVersion} is no longer needed (already current)`);
@@ -13679,6 +13817,52 @@ var ConnectionManager = class {
   }
 };
 
+// src/daemon/ws-endpoint.ts
+var DEFAULT_API_URL = "https://episoda.dev";
+var CANONICAL_PROD_WS_HOST = "ws.episoda.dev";
+var PRODUCTION_API_HOSTS = /* @__PURE__ */ new Set([
+  "episoda.dev",
+  "www.episoda.dev",
+  "api.episoda.dev"
+]);
+function parseApiUrl(rawUrl) {
+  try {
+    return new URL(rawUrl);
+  } catch {
+    return new URL(DEFAULT_API_URL);
+  }
+}
+function resolveDaemonWsEndpoint(config, env = process.env) {
+  if (config.ws_url) {
+    return {
+      wsUrl: config.ws_url,
+      source: "config.ws_url",
+      serverUrl: config.project_settings?.local_server_url || config.api_url || env.EPISODA_API_URL || DEFAULT_API_URL
+    };
+  }
+  if (env.EPISODA_WS_URL) {
+    return {
+      wsUrl: env.EPISODA_WS_URL,
+      source: "env.EPISODA_WS_URL",
+      serverUrl: config.project_settings?.local_server_url || config.api_url || env.EPISODA_API_URL || DEFAULT_API_URL
+    };
+  }
+  const rawServerUrl = config.project_settings?.local_server_url || config.api_url || env.EPISODA_API_URL || DEFAULT_API_URL;
+  const serverUrl = parseApiUrl(rawServerUrl);
+  const wsProtocol = serverUrl.protocol === "https:" ? "wss:" : "ws:";
+  const useCanonicalProdHost = PRODUCTION_API_HOSTS.has(serverUrl.hostname);
+  const wsHostname = useCanonicalProdHost ? CANONICAL_PROD_WS_HOST : serverUrl.hostname;
+  const explicitPort = env.EPISODA_WS_PORT?.trim();
+  const inheritedServerPort = !useCanonicalProdHost ? serverUrl.port : "";
+  const wsPort = explicitPort || inheritedServerPort;
+  const wsUrl = wsPort ? `${wsProtocol}//${wsHostname}:${wsPort}` : `${wsProtocol}//${wsHostname}`;
+  return {
+    wsUrl,
+    source: "derived",
+    serverUrl: serverUrl.toString()
+  };
+}
+
 // src/daemon/project-message-router.ts
 var import_core19 = __toESM(require_dist());
 var path28 = __toESM(require("path"));
@@ -14182,7 +14366,7 @@ function getBuildPackagesCommand2(installCmd) {
   const runner = installCmd?.command?.[0];
   switch (runner) {
     case "pnpm":
-      return "pnpm run build:packages";
+      return 'if command -v pnpm >/dev/null 2>&1; then pnpm run build:packages; elif command -v corepack >/dev/null 2>&1; then corepack pnpm run build:packages; else echo "[setup] ERROR: pnpm is not installed and corepack is unavailable" >&2; exit 127; fi';
     case "yarn":
       return "yarn build:packages";
     case "npm":
@@ -14217,10 +14401,11 @@ var Daemon = class _Daemon {
     // 2 minutes
     // EP1360: Per-session monotonic event seq for daemon→platform stream gap detection.
     this.agentEventSeq = /* @__PURE__ */ new Map();
+    this.cliRuntimeVersion = resolveEffectiveCliVersion(packageJson.version);
     this.ipcServer = new IPCServer();
     this.connectionManager = new ConnectionManager();
     this.ipcRouter = new IPCRouter(this, this.ipcServer);
-    this.updateManager = new UpdateManager(this, packageJson.version, __filename);
+    this.updateManager = new UpdateManager(this, this.cliRuntimeVersion, __filename);
     this.healthOrchestrator = new HealthOrchestrator(this);
     this.daemonCore = new DaemonCore(this);
     this.projectMessageRouter = new ProjectMessageRouter({
@@ -14485,23 +14670,15 @@ var Daemon = class _Daemon {
     if (!config || !config.access_token) {
       throw new Error("No access token found. Please run: episoda auth");
     }
-    let serverUrl = config.api_url || process.env.EPISODA_API_URL || "https://episoda.dev";
-    if (config.project_settings?.local_server_url) {
-      serverUrl = config.project_settings.local_server_url;
-      console.log(`[Daemon] Using cached server URL: ${serverUrl}`);
-    }
-    let wsUrl;
-    if (config.ws_url) {
-      wsUrl = config.ws_url;
-      console.log(`[Daemon] Using configured ws_url: ${wsUrl}`);
-    } else {
-      const serverUrlObj = new URL(serverUrl);
-      const wsProtocol = serverUrlObj.protocol === "https:" ? "wss:" : "ws:";
-      const wsHostname = serverUrlObj.hostname === "episoda.dev" ? "ws.episoda.dev" : serverUrlObj.hostname;
-      const wsPort = process.env.EPISODA_WS_PORT;
-      wsUrl = wsPort ? `${wsProtocol}//${wsHostname}:${wsPort}` : `${wsProtocol}//${wsHostname}`;
+    const wsEndpoint = resolveDaemonWsEndpoint(config);
+    if (wsEndpoint.source === "config.ws_url") {
+      console.log(`[Daemon] Using configured ws_url: ${wsEndpoint.wsUrl}`);
+    } else if (wsEndpoint.source === "env.EPISODA_WS_URL") {
+      console.log(`[Daemon] Using EPISODA_WS_URL override: ${wsEndpoint.wsUrl}`);
+    } else if (config.project_settings?.local_server_url) {
+      console.log(`[Daemon] Using cached server URL: ${wsEndpoint.serverUrl}`);
     }
-    console.log(`[Daemon] Connecting to ${wsUrl} for project ${projectId}...`);
+    console.log(`[Daemon] Connecting to ${wsEndpoint.wsUrl} for project ${projectId} (source: ${wsEndpoint.source})...`);
     const client = new import_core22.EpisodaClient();
     const gitExecutor = new import_core22.GitExecutor();
     const connection = {
@@ -14995,12 +15172,15 @@ var Daemon = class _Daemon {
       const modeConfig = getDaemonModeConfig();
       const environment = modeConfig.mode;
       const containerId = process.env.EPISODA_CONTAINER_ID;
-      await client.connect(wsUrl, config.access_token, this.machineId, {
+      const capabilities = ["worktree_create_v1"];
+      await client.connect(wsEndpoint.wsUrl, config.access_token, this.machineId, {
         hostname: os12.hostname(),
         osPlatform: os12.platform(),
         osArch: os12.arch(),
         daemonPid,
-        cliVersion: packageJson.version,
+        cliVersion: this.cliRuntimeVersion,
+        cliPackageName: packageJson.name,
+        capabilities,
         environment,
         containerId
       });