@rallycry/conveyor-agent 5.12.0 → 5.13.0

package/dist/{chunk-SQJJL2PU.js → chunk-4RFYCO2T.js}

@@ -230,6 +230,18 @@ var ConveyorConnection = class _ConveyorConnection {
           resolve2();
         }
       });
+      this.socket.on("disconnect", (reason) => {
+        process.stderr.write(`[conveyor] Socket disconnected: ${reason}
+`);
+      });
+      this.socket.io.on("reconnect", (attempt) => {
+        process.stderr.write(`[conveyor] Reconnected after ${attempt} attempt(s)
+`);
+      });
+      this.socket.io.on("reconnect_error", (err) => {
+        process.stderr.write(`[conveyor] Reconnection error: ${err.message}
+`);
+      });
       this.socket.io.on("reconnect_attempt", () => {
         attempts++;
         if (!settled && attempts >= maxInitialAttempts) {
@@ -557,6 +569,18 @@ var ProjectConnection = class {
           resolve2();
         }
       });
+      this.socket.on("disconnect", (reason) => {
+        process.stderr.write(`[conveyor] Project socket disconnected: ${reason}
+`);
+      });
+      this.socket.io.on("reconnect", (attempt) => {
+        process.stderr.write(`[conveyor] Project socket reconnected after ${attempt} attempt(s)
+`);
+      });
+      this.socket.io.on("reconnect_error", (err) => {
+        process.stderr.write(`[conveyor] Project socket reconnection error: ${err.message}
+`);
+      });
       this.socket.io.on("reconnect_attempt", () => {
         attempts++;
         if (!settled && attempts >= maxInitialAttempts) {
@@ -733,9 +757,32 @@ var ProjectConnection = class {
 };
 
 // src/runner/worktree.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import { existsSync } from "fs";
 import { join } from "path";
+
+// src/runner/git-utils.ts
+import { execSync as execSync2 } from "child_process";
+function hasUncommittedChanges(cwd) {
+  const status = execSync2("git status --porcelain", {
+    cwd,
+    stdio: ["ignore", "pipe", "ignore"]
+  }).toString().trim();
+  return status.length > 0;
+}
+function getCurrentBranch(cwd) {
+  try {
+    const branch = execSync2("git branch --show-current", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/runner/worktree.ts
 var WORKTREE_DIR = ".worktrees";
 function ensureWorktree(projectDir, taskId, branch) {
   if (projectDir.includes(`/${WORKTREE_DIR}/`)) {
@@ -744,8 +791,11 @@ function ensureWorktree(projectDir, taskId, branch) {
   const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
   if (existsSync(worktreePath)) {
     if (branch) {
+      if (hasUncommittedChanges(worktreePath)) {
+        return worktreePath;
+      }
       try {
-        execSync2(`git checkout --detach origin/${branch}`, {
+        execSync3(`git checkout --detach origin/${branch}`, {
           cwd: worktreePath,
           stdio: "ignore"
         });
@@ -755,17 +805,39 @@ function ensureWorktree(projectDir, taskId, branch) {
     return worktreePath;
   }
   const ref = branch ? `origin/${branch}` : "HEAD";
-  execSync2(`git worktree add --detach "${worktreePath}" ${ref}`, {
+  execSync3(`git worktree add --detach "${worktreePath}" ${ref}`, {
     cwd: projectDir,
     stdio: "ignore"
   });
   return worktreePath;
 }
+function detachWorktreeBranch(projectDir, branch) {
+  try {
+    const output = execSync3("git worktree list --porcelain", {
+      cwd: projectDir,
+      encoding: "utf-8"
+    });
+    const entries = output.split("\n\n");
+    for (const entry of entries) {
+      const lines = entry.trim().split("\n");
+      const worktreeLine = lines.find((l) => l.startsWith("worktree "));
+      const branchLine = lines.find((l) => l.startsWith("branch "));
+      if (!worktreeLine || branchLine !== `branch refs/heads/${branch}`) continue;
+      const worktreePath = worktreeLine.replace("worktree ", "");
+      if (!worktreePath.includes(`/${WORKTREE_DIR}/`)) continue;
+      try {
+        execSync3("git checkout --detach", { cwd: worktreePath, stdio: "ignore" });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
 function removeWorktree(projectDir, taskId) {
   const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
   if (!existsSync(worktreePath)) return;
   try {
-    execSync2(`git worktree remove "${worktreePath}" --force`, {
+    execSync3(`git worktree remove "${worktreePath}" --force`, {
       cwd: projectDir,
       stdio: "ignore"
     });
@@ -801,10 +873,10 @@ function loadConveyorConfig(_workspaceDir) {
 }
 
 // src/setup/codespace.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function unshallowRepo(workspaceDir) {
   try {
-    execSync3("git fetch --unshallow", {
+    execSync4("git fetch --unshallow", {
       cwd: workspaceDir,
       stdio: "ignore",
       timeout: 6e4
@@ -842,7 +914,7 @@ function errorMeta(error) {
 
 // src/runner/agent-runner.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 
 // src/execution/event-handlers.ts
 function safeVoid(promise, context) {
@@ -3476,6 +3548,47 @@ async function executeSetupConfig(config, runnerConfig, connection, setupLog) {
 async function checkoutTaskBranch(runnerConfig, connection, callbacks, setupLog) {
   const taskBranch = process.env.CONVEYOR_TASK_BRANCH;
   if (!taskBranch) return true;
+  const currentBranch = getCurrentBranch(runnerConfig.workspaceDir);
+  if (currentBranch === taskBranch) {
+    pushSetupLog(setupLog, `[conveyor] Already on ${taskBranch}, skipping checkout`);
+    connection.sendEvent({
+      type: "setup_output",
+      stream: "stdout",
+      data: `Already on branch ${taskBranch}, skipping checkout
+`
+    });
+    try {
+      await runSetupCommand(
+        `git fetch origin ${taskBranch}`,
+        runnerConfig.workspaceDir,
+        (stream, data) => {
+          connection.sendEvent({ type: "setup_output", stream, data });
+        }
+      );
+    } catch {
+    }
+    return true;
+  }
+  let didStash = false;
+  if (hasUncommittedChanges(runnerConfig.workspaceDir)) {
+    pushSetupLog(setupLog, `[conveyor] Uncommitted changes detected, stashing before checkout`);
+    connection.sendEvent({
+      type: "setup_output",
+      stream: "stdout",
+      data: "Uncommitted changes detected \u2014 stashing before branch switch\n"
+    });
+    try {
+      await runSetupCommand(
+        `git stash push -m "conveyor-auto-stash"`,
+        runnerConfig.workspaceDir,
+        (stream, data) => {
+          connection.sendEvent({ type: "setup_output", stream, data });
+        }
+      );
+      didStash = true;
+    } catch {
+    }
+  }
   pushSetupLog(setupLog, `[conveyor] Switching to task branch ${taskBranch}...`);
   connection.sendEvent({
     type: "setup_output",
@@ -3495,6 +3608,19 @@ async function checkoutTaskBranch(runnerConfig, connection, callbacks, setupLog)
       }
     );
     pushSetupLog(setupLog, `[conveyor] Switched to ${taskBranch}`);
+    if (didStash) {
+      try {
+        await runSetupCommand("git stash pop", runnerConfig.workspaceDir, (stream, data) => {
+          connection.sendEvent({ type: "setup_output", stream, data });
+        });
+        pushSetupLog(setupLog, `[conveyor] Restored stashed changes`);
+      } catch {
+        pushSetupLog(
+          setupLog,
+          `[conveyor] Warning: stash pop had conflicts \u2014 agent may need to resolve`
+        );
+      }
+    }
     return true;
   } catch (error) {
     const message = `Failed to checkout ${taskBranch}: ${error instanceof Error ? error.message : "unknown error"}`;
@@ -3839,12 +3965,22 @@ var AgentRunner = class {
   }
   checkoutWorktreeBranch() {
     if (!this.worktreeActive || !this.taskContext?.githubBranch) return;
+    const branch = this.taskContext.githubBranch;
+    const cwd = this.config.workspaceDir;
+    if (getCurrentBranch(cwd) === branch) return;
     try {
-      const branch = this.taskContext.githubBranch;
-      execSync4(`git fetch origin ${branch} && git checkout ${branch}`, {
-        cwd: this.config.workspaceDir,
-        stdio: "ignore"
-      });
+      let didStash = false;
+      if (hasUncommittedChanges(cwd)) {
+        execSync5(`git stash push -m "conveyor-auto-stash"`, { cwd, stdio: "ignore" });
+        didStash = true;
+      }
+      execSync5(`git fetch origin ${branch} && git checkout ${branch}`, { cwd, stdio: "ignore" });
+      if (didStash) {
+        try {
+          execSync5("git stash pop", { cwd, stdio: "ignore" });
+        } catch {
+        }
+      }
     } catch {
     }
   }
@@ -4132,12 +4268,12 @@ var AgentRunner = class {
 
 // src/runner/project-runner.ts
 import { fork } from "child_process";
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 import * as path from "path";
 import { fileURLToPath } from "url";
 
 // src/runner/commit-watcher.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 var logger3 = createServiceLogger("CommitWatcher");
 var CommitWatcher = class {
   constructor(config, callbacks) {
@@ -4169,7 +4305,7 @@ var CommitWatcher = class {
     this.isSyncing = false;
   }
   getLocalHeadSha() {
-    return execSync5("git rev-parse HEAD", {
+    return execSync6("git rev-parse HEAD", {
       cwd: this.config.projectDir,
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
@@ -4177,12 +4313,12 @@ var CommitWatcher = class {
   poll() {
     if (!this.branch || this.isSyncing) return;
     try {
-      execSync5(`git fetch origin ${this.branch} --quiet`, {
+      execSync6(`git fetch origin ${this.branch} --quiet`, {
         cwd: this.config.projectDir,
         stdio: "ignore",
         timeout: 3e4
       });
-      const remoteSha = execSync5(`git rev-parse origin/${this.branch}`, {
+      const remoteSha = execSync6(`git rev-parse origin/${this.branch}`, {
         cwd: this.config.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim();
@@ -4203,12 +4339,12 @@ var CommitWatcher = class {
     let latestMessage = "";
     let latestAuthor = "";
     try {
-      const countOutput = execSync5(`git rev-list --count ${previousSha}..origin/${this.branch}`, {
+      const countOutput = execSync6(`git rev-list --count ${previousSha}..origin/${this.branch}`, {
         cwd: this.config.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim();
       commitCount = parseInt(countOutput, 10) || 1;
-      const logOutput = execSync5(`git log -1 --format="%s|||%an" origin/${this.branch}`, {
+      const logOutput = execSync6(`git log -1 --format="%s|||%an" origin/${this.branch}`, {
         cwd: this.config.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim();
@@ -5008,13 +5144,20 @@ function setupWorkDir(projectDir, assignment) {
     workDir = projectDir;
   }
   if (branch && branch !== devBranch) {
-    try {
-      execSync6(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
-    } catch {
+    if (hasUncommittedChanges(workDir)) {
+      logger6.warn("Uncommitted changes in work dir, skipping checkout", {
+        taskId: shortId,
+        branch
+      });
+    } else {
       try {
-        execSync6(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+        execSync7(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
       } catch {
-        logger6.warn("Could not checkout branch", { taskId: shortId, branch });
+        try {
+          execSync7(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+        } catch {
+          logger6.warn("Could not checkout branch", { taskId: shortId, branch });
+        }
       }
     }
   }
@@ -5119,9 +5262,20 @@ var ProjectRunner = class {
   checkoutWorkspaceBranch() {
     const workspaceBranch = process.env.CONVEYOR_WORKSPACE_BRANCH;
     if (!workspaceBranch) return;
+    const currentBranch = this.getCurrentBranch();
+    if (currentBranch === workspaceBranch) {
+      logger6.info("Already on workspace branch", { workspaceBranch });
+      return;
+    }
+    if (hasUncommittedChanges(this.projectDir)) {
+      logger6.warn("Uncommitted changes detected, skipping workspace branch checkout", {
+        workspaceBranch
+      });
+      return;
+    }
     try {
-      execSync6(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
-      execSync6(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      execSync7(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      execSync7(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
       logger6.info("Checked out workspace branch", { workspaceBranch });
     } catch (err) {
       logger6.warn("Failed to checkout workspace branch, continuing on current branch", {
@@ -5209,39 +5363,20 @@ var ProjectRunner = class {
     this.executeStartCommand();
   }
   getEnvironmentStatus() {
-    let currentBranch = "unknown";
-    try {
-      currentBranch = execSync6("git branch --show-current", {
-        cwd: this.projectDir,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).toString().trim();
-    } catch {
-    }
     return {
       setupComplete: this.setupComplete,
       startCommandRunning: this.startCommandRunning,
-      currentBranch,
+      currentBranch: this.getCurrentBranch() ?? "unknown",
       previewPort: Number(process.env.CONVEYOR_PREVIEW_PORT) || null
     };
   }
   getCurrentBranch() {
-    try {
-      return execSync6("git branch --show-current", {
-        cwd: this.projectDir,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).toString().trim() || null;
-    } catch {
-      return null;
-    }
+    return getCurrentBranch(this.projectDir);
   }
   // oxlint-disable-next-line max-lines-per-function, complexity -- sequential sync steps with per-step error handling
   async smartSync(previousSha, newSha, branch) {
     const stepsRun = [];
-    const status = execSync6("git status --porcelain", {
-      cwd: this.projectDir,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
-    if (status) {
+    if (hasUncommittedChanges(this.projectDir)) {
       this.connection.emitEvent({
         type: "commit_watch_warning",
         message: "Working tree has uncommitted changes. Auto-pull skipped."
@@ -5251,7 +5386,7 @@ var ProjectRunner = class {
     await this.killStartCommand();
     this.connection.emitEnvSwitchProgress({ step: "pull", status: "running" });
     try {
-      execSync6(`git pull origin ${branch}`, {
+      execSync7(`git pull origin ${branch}`, {
         cwd: this.projectDir,
         stdio: "pipe",
         timeout: 6e4
@@ -5267,7 +5402,7 @@ var ProjectRunner = class {
     }
     let changedFiles = [];
     try {
-      changedFiles = execSync6(`git diff --name-only ${previousSha}..${newSha}`, {
+      changedFiles = execSync7(`git diff --name-only ${previousSha}..${newSha}`, {
         cwd: this.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim().split("\n").filter(Boolean);
@@ -5297,7 +5432,7 @@ var ProjectRunner = class {
       if (needsInstall) {
         this.connection.emitEnvSwitchProgress({ step: "install", status: "running" });
         try {
-          execSync6("bun install", { cwd: this.projectDir, timeout: 12e4, stdio: "pipe" });
+          execSync7("bun install", { cwd: this.projectDir, timeout: 12e4, stdio: "pipe" });
           stepsRun.push("install");
           this.connection.emitEnvSwitchProgress({ step: "install", status: "success" });
         } catch (err) {
@@ -5309,12 +5444,12 @@ var ProjectRunner = class {
       if (needsPrisma) {
         this.connection.emitEnvSwitchProgress({ step: "prisma", status: "running" });
         try {
-          execSync6("bunx prisma generate", {
+          execSync7("bunx prisma generate", {
             cwd: this.projectDir,
             timeout: 6e4,
             stdio: "pipe"
           });
-          execSync6("bunx prisma db push --accept-data-loss", {
+          execSync7("bunx prisma db push --accept-data-loss", {
             cwd: this.projectDir,
             timeout: 6e4,
             stdio: "pipe"
@@ -5337,14 +5472,15 @@ var ProjectRunner = class {
     try {
       this.connection.emitEnvSwitchProgress({ step: "fetch", status: "running" });
       try {
-        execSync6("git fetch origin", { cwd: this.projectDir, stdio: "pipe" });
+        execSync7("git fetch origin", { cwd: this.projectDir, stdio: "pipe" });
       } catch {
         logger6.warn("Git fetch failed during branch switch");
       }
       this.connection.emitEnvSwitchProgress({ step: "fetch", status: "success" });
+      detachWorktreeBranch(this.projectDir, branch);
       this.connection.emitEnvSwitchProgress({ step: "checkout", status: "running" });
       try {
-        execSync6(`git checkout ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
+        execSync7(`git checkout ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
       } catch (err) {
         const message = err instanceof Error ? err.message : "Checkout failed";
         this.connection.emitEnvSwitchProgress({ step: "checkout", status: "error", message });
@@ -5352,7 +5488,7 @@ var ProjectRunner = class {
         return;
       }
       try {
-        execSync6(`git pull origin ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
+        execSync7(`git pull origin ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
       } catch {
         logger6.warn("Git pull failed during branch switch", { branch });
       }
@@ -5491,7 +5627,7 @@ var ProjectRunner = class {
     }
     try {
       try {
-        execSync6("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
+        execSync7("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
       } catch {
         logger6.warn("Git fetch failed", { taskId: shortId });
       }
@@ -5665,4 +5801,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-SQJJL2PU.js.map
+//# sourceMappingURL=chunk-4RFYCO2T.js.map