@episoda/cli 0.2.178 → 0.2.180

package/dist/daemon/daemon-process.js

@@ -3046,7 +3046,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.178",
+      version: "0.2.180",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3072,6 +3072,7 @@ var require_package = __commonJS({
       author: "Episoda",
       license: "MIT",
       dependencies: {
+        "@lydell/node-pty": "1.2.0-beta.3",
         chalk: "^4.1.2",
         commander: "^11.1.0",
         ora: "^5.4.1",
@@ -3082,8 +3083,8 @@ var require_package = __commonJS({
       },
       optionalDependencies: {
         "@anthropic-ai/claude-code": "^2.0.0",
-        "@openai/codex": "^0.86.0",
-        "@modelcontextprotocol/server-github": "^0.6.0"
+        "@modelcontextprotocol/server-github": "^0.6.0",
+        "@openai/codex": "^0.86.0"
       },
       devDependencies: {
         "@episoda/core": "workspace:*",
@@ -12299,6 +12300,91 @@ async function getConfigForApi() {
   }
   return (0, import_core13.loadConfig)();
 }
+function stripGitCredentials(repoUrl) {
+  try {
+    const parsed = new URL(repoUrl);
+    if (parsed.protocol !== "https:") {
+      return repoUrl;
+    }
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.toString();
+  } catch {
+    return repoUrl;
+  }
+}
+function withGitHubInstallationToken(repoUrl, token) {
+  try {
+    const parsed = new URL(stripGitCredentials(repoUrl));
+    if (parsed.protocol !== "https:" || parsed.hostname !== "github.com") {
+      return repoUrl;
+    }
+    parsed.username = "x-access-token";
+    parsed.password = token;
+    return parsed.toString();
+  } catch {
+    return repoUrl;
+  }
+}
+async function getFreshGithubRepoUrl(repoUrl, projectId) {
+  if (!repoUrl.startsWith("https://")) {
+    return repoUrl;
+  }
+  let parsed;
+  try {
+    parsed = new URL(repoUrl);
+  } catch {
+    return repoUrl;
+  }
+  if (parsed.hostname !== "github.com") {
+    return repoUrl;
+  }
+  const config = await getConfigForApi();
+  if (!config?.access_token) {
+    return repoUrl;
+  }
+  const apiUrl = config.api_url || "https://episoda.dev";
+  const headers = {
+    "Authorization": `Bearer ${config.access_token}`,
+    "Content-Type": "application/json",
+    "User-Agent": "episoda-cli"
+  };
+  if (config.workspace_id) headers["x-workspace-id"] = config.workspace_id;
+  if (config.workspace_slug) headers["x-workspace-uid"] = config.workspace_slug;
+  if (config.project_id) headers["x-project-id"] = config.project_id;
+  if (config.project_slug) headers["x-project-uid"] = config.project_slug;
+  try {
+    const response = await fetch(`${apiUrl}/api/github/installation-token`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ project_id: projectId })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      console.warn(`[Worktree] EP1435: Failed to refresh GitHub installation token (${response.status}): ${body}`);
+      return repoUrl;
+    }
+    const payload = await response.json();
+    const token = payload?.data?.token || payload?.token;
+    if (!token) {
+      console.warn("[Worktree] EP1435: Token refresh response missing token");
+      return repoUrl;
+    }
+    return withGitHubInstallationToken(repoUrl, token);
+  } catch (error) {
+    console.warn(`[Worktree] EP1435: Could not refresh GitHub installation token: ${error.message}`);
+    return repoUrl;
+  }
+}
+async function readOriginUrl(bareRepoPath) {
+  try {
+    const { stdout } = await execAsync2(`git -C "${bareRepoPath}" config --get remote.origin.url`);
+    const value = stdout.trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
 var execAsync2 = (0, import_util2.promisify)(import_child_process14.exec);
 function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
   if (process.env.EPISODA_MODE !== "cloud") {
@@ -12377,14 +12463,15 @@ async function handleWorktreeCreate(request2) {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
     const bareRepoPath = path28.join(projectPath, ".bare");
     const gitEnv = projectId ? { ...process.env, EPISODA_PROJECT_ID: projectId } : process.env;
+    const refreshedRepoUrl = await getFreshGithubRepoUrl(repoUrl, projectId);
     if (!fs28.existsSync(bareRepoPath)) {
       console.log(`[Worktree] K1273: Project not found, cloning lazily...`);
-      console.log(`[Worktree]   Repo URL: ${repoUrl.replace(/\/\/[^@]*@/, "//***@")}`);
+      console.log(`[Worktree]   Repo URL: ${stripGitCredentials(refreshedRepoUrl)}`);
       const episodaDir = path28.join(projectPath, ".episoda");
       fs28.mkdirSync(episodaDir, { recursive: true });
       try {
         console.log(`[Worktree] K1273: Starting git clone...`);
-        await execAsync2(`git clone --bare "${repoUrl}" "${bareRepoPath}"`, { env: gitEnv });
+        await execAsync2(`git clone --bare "${refreshedRepoUrl}" "${bareRepoPath}"`, { env: gitEnv });
         console.log(`[Worktree] K1273: Clone successful`);
         await execAsync2(`git -C "${bareRepoPath}" config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"`, { env: gitEnv });
         const configPath = path28.join(episodaDir, "config.json");
@@ -12406,6 +12493,17 @@ async function handleWorktreeCreate(request2) {
         };
       }
     } else {
+      const currentOriginUrl = await readOriginUrl(bareRepoPath);
+      const sourceUrl = currentOriginUrl || refreshedRepoUrl;
+      const refreshedOriginUrl = await getFreshGithubRepoUrl(sourceUrl, projectId);
+      if (refreshedOriginUrl !== sourceUrl) {
+        try {
+          await execAsync2(`git -C "${bareRepoPath}" remote set-url origin "${refreshedOriginUrl}"`, { env: gitEnv });
+          console.log("[Worktree] EP1435: Refreshed bare repo origin URL with a fresh installation token");
+        } catch (setUrlError) {
+          console.warn(`[Worktree] EP1435: Failed to refresh origin URL: ${setUrlError.message}`);
+        }
+      }
       console.log(`[Worktree] EP1373: Project exists, skipping handler-level fetch (manager handles narrow fetch)`);
     }
     const manager = new WorktreeManager(projectPath);
@@ -12772,6 +12870,113 @@ async function handleProjectSetup(params) {
   }
 }
 
+// src/daemon/handlers/pty-handler.ts
+var pty = __toESM(require("@lydell/node-pty"));
+var INACTIVITY_TIMEOUT_MS3 = 30 * 60 * 1e3;
+var sessions = /* @__PURE__ */ new Map();
+async function handlePtySpawn(payload, client) {
+  const { moduleUid, agent_run_id, command, args, env, cwd, cols = 220, rows = 50 } = payload;
+  if (sessions.has(agent_run_id)) {
+    console.warn(`[PTY] Session already exists for agent_run_id ${agent_run_id}, ignoring spawn`);
+    return;
+  }
+  console.log(`[PTY] Spawning PTY for ${moduleUid} / ${agent_run_id}: ${command} ${args.join(" ")}`);
+  let proc;
+  try {
+    proc = pty.spawn(command, args, {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd: cwd || process.cwd(),
+      env: { ...process.env, ...env || {} }
+    });
+  } catch (err) {
+    console.error(`[PTY] Failed to spawn PTY for ${agent_run_id}:`, err);
+    await client.send({
+      type: "pty_exit",
+      moduleUid,
+      agent_run_id,
+      code: -1,
+      durationMs: 0
+    });
+    return;
+  }
+  const session = {
+    pty: proc,
+    moduleUid,
+    agent_run_id,
+    startedAt: Date.now(),
+    lastOutputAt: Date.now(),
+    watchdogTimer: null
+  };
+  sessions.set(agent_run_id, session);
+  const resetWatchdog = () => {
+    session.lastOutputAt = Date.now();
+    if (session.watchdogTimer) clearTimeout(session.watchdogTimer);
+    session.watchdogTimer = setTimeout(() => {
+      console.warn(`[PTY] Inactivity timeout for ${agent_run_id} after ${INACTIVITY_TIMEOUT_MS3 / 6e4}m \u2014 sending SIGTERM`);
+      try {
+        proc.kill();
+      } catch {
+      }
+    }, INACTIVITY_TIMEOUT_MS3);
+  };
+  resetWatchdog();
+  proc.onData((data) => {
+    resetWatchdog();
+    client.send({
+      type: "pty_data",
+      moduleUid,
+      agent_run_id,
+      data
+    }).catch((err) => {
+      console.error(`[PTY] Failed to send pty_data for ${agent_run_id}:`, err.message);
+    });
+  });
+  proc.onExit(({ exitCode }) => {
+    const durationMs = Date.now() - session.startedAt;
+    if (session.watchdogTimer) clearTimeout(session.watchdogTimer);
+    console.log(`[PTY] Process exited for ${agent_run_id} with code ${exitCode} after ${durationMs}ms`);
+    sessions.delete(agent_run_id);
+    client.send({
+      type: "pty_exit",
+      moduleUid,
+      agent_run_id,
+      code: exitCode,
+      durationMs
+    }).catch((err) => {
+      console.error(`[PTY] Failed to send pty_exit for ${agent_run_id}:`, err.message);
+    });
+  });
+}
+function handlePtyResize(payload) {
+  const { agent_run_id, cols, rows } = payload;
+  const session = sessions.get(agent_run_id);
+  if (!session) {
+    console.warn(`[PTY] No session found for resize: ${agent_run_id}`);
+    return;
+  }
+  try {
+    session.pty.resize(cols, rows);
+  } catch (err) {
+    console.error(`[PTY] Resize error for ${agent_run_id}:`, err);
+  }
+}
+function handlePtyKill(payload) {
+  const { agent_run_id } = payload;
+  const session = sessions.get(agent_run_id);
+  if (!session) {
+    console.warn(`[PTY] No session found for kill: ${agent_run_id}`);
+    return;
+  }
+  try {
+    session.pty.kill();
+  } catch {
+  }
+  sessions.delete(agent_run_id);
+  console.log(`[PTY] Killed session ${agent_run_id}`);
+}
+
 // src/utils/dev-server.ts
 var import_child_process15 = require("child_process");
 var import_core14 = __toESM(require_dist());
@@ -13553,8 +13758,8 @@ var UpdateManager = class _UpdateManager {
   getActiveAgentSessionCount() {
     try {
       const agentManager = getAgentControlPlane();
-      const sessions = agentManager.getAllSessions();
-      return sessions.filter((session) => ["starting", "running", "stopping"].includes(session.status)).length;
+      const sessions2 = agentManager.getAllSessions();
+      return sessions2.filter((session) => ["starting", "running", "stopping"].includes(session.status)).length;
     } catch {
       return 0;
     }
@@ -14553,6 +14758,7 @@ var ProjectMessageRouter = class {
     this.registerCommandHandler(context);
     this.registerRemoteCommandHandler(context);
     this.registerTunnelCommandHandler(context);
+    this.registerPtyCommandHandler(context);
   }
   registerCommandHandler({ projectId, projectPath, client, gitExecutor }) {
     client.on("command", async (message) => {
@@ -14801,6 +15007,30 @@ var ProjectMessageRouter = class {
       }
     });
   }
+  // EP1441: PTY lifecycle handler
+  registerPtyCommandHandler({ projectId, client }) {
+    client.on("pty_spawn", async (message) => {
+      if (message.type === "pty_spawn") {
+        const payload = message.payload;
+        console.log(`[Daemon] EP1441: Received pty_spawn for ${projectId}: ${payload.agent_run_id}`);
+        client.updateActivity();
+        await handlePtySpawn(payload, client);
+      }
+    });
+    client.on("pty_resize", (message) => {
+      if (message.type === "pty_resize") {
+        const payload = message.payload;
+        handlePtyResize(payload);
+      }
+    });
+    client.on("pty_kill", (message) => {
+      if (message.type === "pty_kill") {
+        const payload = message.payload;
+        console.log(`[Daemon] EP1441: Received pty_kill for agent_run_id ${payload.agent_run_id}`);
+        handlePtyKill(payload);
+      }
+    });
+  }
 };
 
 // src/daemon/daemon-api-client.ts