@rallycry/conveyor-agent 4.10.2 → 5.0.1

package/dist/{chunk-VJRAWAWQ.js → chunk-JI4AW4WX.js}

@@ -646,13 +646,6 @@ function runStartCommand(cmd, cwd, onOutput) {
 
 // src/setup/codespace.ts
 import { execSync as execSync3 } from "child_process";
-function initRtk() {
-  try {
-    execSync3("rtk --version", { stdio: "ignore" });
-    execSync3("rtk init --global --auto-patch", { stdio: "ignore" });
-  } catch {
-  }
-}
 function unshallowRepo(workspaceDir) {
   try {
     execSync3("git fetch --unshallow", {
@@ -664,6 +657,33 @@ function unshallowRepo(workspaceDir) {
   }
 }
 
+// src/utils/logger.ts
+import winston from "winston";
+var { combine, timestamp, printf, colorize } = winston.format;
+var customFormat = printf(({ level, message, timestamp: ts, service, ...meta }) => {
+  const svc = service ? `[${service}] ` : "";
+  const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
+  return `${ts} [${level}]: ${svc}${message}${metaStr}`;
+});
+var logger = winston.createLogger({
+  level: process.env.LOG_LEVEL ?? "info",
+  format: combine(timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), combine(colorize(), customFormat)),
+  transports: [new winston.transports.Console()]
+});
+function createServiceLogger(serviceName) {
+  return logger.child({ service: serviceName });
+}
+function errorMeta(error) {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      stack: error.stack,
+      ..."code" in error && typeof error.code === "string" ? { code: error.code } : {}
+    };
+  }
+  return { message: String(error) };
+}
+
 // src/runner/agent-runner.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { execSync as execSync4 } from "child_process";
@@ -2851,6 +2871,39 @@ async function executeSetupConfig(config, runnerConfig, connection, setupLog, ef
   }
   return deferredStartConfig;
 }
+async function checkoutTaskBranch(runnerConfig, connection, callbacks, setupLog) {
+  const taskBranch = process.env.CONVEYOR_TASK_BRANCH;
+  if (!taskBranch) return true;
+  pushSetupLog(setupLog, `[conveyor] Switching to task branch ${taskBranch}...`);
+  connection.sendEvent({
+    type: "setup_output",
+    stream: "stdout",
+    data: `Switching to task branch ${taskBranch}...
+`
+  });
+  try {
+    await runSetupCommand(
+      `git fetch origin ${taskBranch} && git checkout ${taskBranch}`,
+      runnerConfig.workspaceDir,
+      (stream, data) => {
+        connection.sendEvent({ type: "setup_output", stream, data });
+        for (const line of data.split("\n").filter(Boolean)) {
+          pushSetupLog(setupLog, `[${stream}] ${line}`);
+        }
+      }
+    );
+    pushSetupLog(setupLog, `[conveyor] Switched to ${taskBranch}`);
+    return true;
+  } catch (error) {
+    const message = `Failed to checkout ${taskBranch}: ${error instanceof Error ? error.message : "unknown error"}`;
+    connection.sendEvent({ type: "setup_error", message });
+    await callbacks.onEvent({ type: "setup_error", message });
+    connection.postChatMessage(`Failed to switch to task branch \`${taskBranch}\`.
+
+${message}`);
+    return false;
+  }
+}
 async function runSetupSafe(runnerConfig, connection, callbacks, setupLog, effectiveAgentMode, setState) {
   await setState("setup");
   const ports = await loadForwardPorts(runnerConfig.workspaceDir);
@@ -2862,18 +2915,21 @@ async function runSetupSafe(runnerConfig, connection, callbacks, setupLog, effec
       () => void 0
     );
   }
-  const pullBranch = process.env.CONVEYOR_PULL_BRANCH;
-  if (pullBranch) {
-    pushSetupLog(setupLog, `[conveyor] Merging latest from ${pullBranch}...`);
+  if (!await checkoutTaskBranch(runnerConfig, connection, callbacks, setupLog)) {
+    return { ok: false, deferredStartConfig: null };
+  }
+  const taskBranch = process.env.CONVEYOR_TASK_BRANCH;
+  if (taskBranch) {
+    pushSetupLog(setupLog, `[conveyor] Switching to task branch ${taskBranch}...`);
     connection.sendEvent({
       type: "setup_output",
       stream: "stdout",
-      data: `Merging latest from ${pullBranch}...
+      data: `Switching to task branch ${taskBranch}...
 `
     });
     try {
       await runSetupCommand(
-        `git fetch origin ${pullBranch} && git merge origin/${pullBranch} --no-edit`,
+        `git fetch origin ${taskBranch} && git checkout ${taskBranch}`,
         runnerConfig.workspaceDir,
         (stream, data) => {
           connection.sendEvent({ type: "setup_output", stream, data });
@@ -2882,13 +2938,13 @@ async function runSetupSafe(runnerConfig, connection, callbacks, setupLog, effec
           }
         }
       );
-      pushSetupLog(setupLog, `[conveyor] Merge complete`);
+      pushSetupLog(setupLog, `[conveyor] Switched to ${taskBranch}`);
     } catch (error) {
-      const message = `Failed to merge ${pullBranch}: ${error instanceof Error ? error.message : "unknown error"}`;
+      const message = `Failed to checkout ${taskBranch}: ${error instanceof Error ? error.message : "unknown error"}`;
       connection.sendEvent({ type: "setup_error", message });
       await callbacks.onEvent({ type: "setup_error", message });
       connection.postChatMessage(
-        `Failed to merge latest code from \`${pullBranch}\`. There may be conflicts between the prebuild branch and dev.
+        `Failed to switch to task branch \`${taskBranch}\`.
 
 ${message}`
       );
@@ -3064,6 +3120,7 @@ function buildQueryHost(deps) {
 }
 
 // src/runner/agent-runner.ts
+var logger2 = createServiceLogger("AgentRunner");
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
 var AgentRunner = class {
@@ -3164,7 +3221,6 @@ var AgentRunner = class {
       }
       this.deferredStartConfig = result.deferredStartConfig;
     }
-    initRtk();
     this.tryInitWorktree();
     if (!await this.fetchAndInitContext()) return;
     if (process.env.CODESPACES === "true" && this.taskContext) {
@@ -3245,8 +3301,10 @@ var AgentRunner = class {
         "Auto-nudge: Task is still In Progress with no PR. Prompting agent to continue..."
       );
       await this.setState("running");
+      const ctx = this.taskContext ?? fresh;
+      if (!ctx) return false;
       await this.runQuerySafe(
-        this.taskContext,
+        ctx,
         "You are in Auto mode and your task is still In Progress with no pull request. You MUST create a pull request before finishing. Use the create_pull_request tool now to open a PR for your changes. If you are blocked, explain what is preventing you from creating a PR."
       );
       return true;
@@ -3336,7 +3394,12 @@ var AgentRunner = class {
   handleRunStartCommand() {
     if (!this.deferredStartConfig?.startCommand || this.startCommandStarted) return;
     this.startCommandStarted = true;
-    runDeferredStartCommand(this.deferredStartConfig, this.config, this.connection, this.setupLog);
+    runDeferredStartCommand(
+      this.deferredStartConfig,
+      this.config,
+      this.connection,
+      this.setupLog
+    );
     this.deferredStartConfig = null;
   }
   logEffectiveSettings() {
@@ -3344,18 +3407,17 @@ var AgentRunner = class {
     const s = this.taskContext.agentSettings ?? this.config.agentSettings ?? {};
     const model = this.taskContext.model || this.config.model;
     const thinking = formatThinkingSetting(s.thinking);
-    const parts = [
-      `model=${model}`,
-      `mode=${this.config.mode ?? "task"}`,
-      `effort=${s.effort ?? "default"}`,
-      `thinking=${thinking}`,
-      `maxBudget=$${s.maxBudgetUsd ?? 50}`,
-      `maxTurns=${s.maxTurns ?? "unlimited"}`
-    ];
-    if (s.betas?.length) parts.push(`betas=${s.betas.join(",")}`);
-    if (s.disallowedTools?.length) parts.push(`disallowed=[${s.disallowedTools.join(",")}]`);
-    if (s.enableFileCheckpointing) parts.push(`checkpointing=on`);
-    console.log(`[conveyor-agent] ${parts.join(", ")}`);
+    logger2.info("Effective agent settings", {
+      model,
+      mode: this.config.mode ?? "task",
+      effort: s.effort ?? "default",
+      thinking,
+      maxBudget: s.maxBudgetUsd ?? 50,
+      maxTurns: s.maxTurns ?? "unlimited",
+      ...s.betas?.length ? { betas: s.betas } : {},
+      ...s.disallowedTools?.length ? { disallowedTools: s.disallowedTools } : {},
+      ...s.enableFileCheckpointing ? { checkpointing: "on" } : {}
+    });
   }
   injectHumanMessage(content, files) {
     const messageContent = buildMessageContent(content, files);
@@ -3386,9 +3448,9 @@ var AgentRunner = class {
       this.idleTimer = setTimeout(() => {
         this.clearIdleTimers();
         this.inputResolver = null;
-        console.log(
-          `[conveyor-agent] Idle for ${IDLE_TIMEOUT_MS / 6e4} minutes \u2014 shutting down.`
-        );
+        logger2.info("Idle timeout reached, shutting down", {
+          idleMinutes: IDLE_TIMEOUT_MS / 6e4
+        });
         this.connection.postChatMessage(
           `Agent idle for ${IDLE_TIMEOUT_MS / 6e4} minutes with no new messages \u2014 shutting down.`
         );
@@ -3509,6 +3571,7 @@ import { fileURLToPath } from "url";
 
 // src/runner/project-chat-handler.ts
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+var logger3 = createServiceLogger("ProjectChat");
 var FALLBACK_MODEL = "claude-sonnet-4-20250514";
 function buildSystemPrompt2(projectDir, agentCtx) {
   const parts = [];
@@ -3561,7 +3624,7 @@ function processContentBlock(block, responseParts, turnToolCalls) {
       input: inputStr.slice(0, 1e4),
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    console.log(`[project-chat] [tool_use] ${block.name}`);
+    logger3.debug("Tool use", { tool: block.name });
   }
 }
 async function fetchContext(connection) {
@@ -3569,13 +3632,13 @@ async function fetchContext(connection) {
   try {
     agentCtx = await connection.fetchAgentContext();
   } catch {
-    console.log("[project-chat] Could not fetch agent context, using defaults");
+    logger3.warn("Could not fetch agent context, using defaults");
   }
   let chatHistory = [];
   try {
     chatHistory = await connection.fetchChatHistory(30);
   } catch {
-    console.log("[project-chat] Could not fetch chat history, proceeding without it");
+    logger3.warn("Could not fetch chat history, proceeding without it");
   }
   return { agentCtx, chatHistory };
 }
@@ -3649,10 +3712,7 @@ async function handleProjectChatMessage(message, connection, projectDir) {
   try {
     await runChatQuery(message, connection, projectDir);
   } catch (error) {
-    console.error(
-      "[project-chat] Failed to handle message:",
-      error instanceof Error ? error.message : error
-    );
+    logger3.error("Failed to handle message", errorMeta(error));
     try {
       await connection.emitChatMessage(
         "I encountered an error processing your message. Please try again."
@@ -3665,6 +3725,7 @@ async function handleProjectChatMessage(message, connection, projectDir) {
 }
 
 // src/runner/project-runner.ts
+var logger4 = createServiceLogger("ProjectRunner");
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 var HEARTBEAT_INTERVAL_MS2 = 3e4;
@@ -3687,7 +3748,7 @@ function setupWorkDir(projectDir, assignment) {
       try {
         execSync5(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
       } catch {
-        console.log(`[task:${shortId}] Warning: could not checkout branch ${branch}`);
+        logger4.warn("Could not checkout branch", { taskId: shortId, branch });
       }
     }
   }
@@ -3725,13 +3786,13 @@ function spawnChildAgent(assignment, workDir) {
   child.stdout?.on("data", (data) => {
     const lines = data.toString().trimEnd().split("\n");
     for (const line of lines) {
-      console.log(`[task:${shortId}] ${line}`);
+      logger4.info(line, { taskId: shortId });
     }
   });
   child.stderr?.on("data", (data) => {
     const lines = data.toString().trimEnd().split("\n");
     for (const line of lines) {
-      console.error(`[task:${shortId}] ${line}`);
+      logger4.error(line, { taskId: shortId });
     }
   });
   return child;
@@ -3751,7 +3812,22 @@ var ProjectRunner = class {
       projectId: config.projectId
     });
   }
+  async checkoutWorkspaceBranch() {
+    const workspaceBranch = process.env.CONVEYOR_WORKSPACE_BRANCH;
+    if (!workspaceBranch) return;
+    try {
+      execSync5(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      execSync5(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      logger4.info("Checked out workspace branch", { workspaceBranch });
+    } catch (err) {
+      logger4.warn("Failed to checkout workspace branch, continuing on current branch", {
+        workspaceBranch,
+        ...errorMeta(err)
+      });
+    }
+  }
   async start() {
+    await this.checkoutWorkspaceBranch();
     await this.connection.connect();
     this.connection.onTaskAssignment((assignment) => {
       this.handleAssignment(assignment);
@@ -3760,17 +3836,17 @@ var ProjectRunner = class {
       this.handleStopTask(data.taskId);
     });
     this.connection.onShutdown(() => {
-      console.log("[project-runner] Received shutdown signal from server");
+      logger4.info("Received shutdown signal from server");
       void this.stop();
     });
     this.connection.onChatMessage((msg) => {
-      console.log("[project-runner] Received project chat message");
+      logger4.debug("Received project chat message");
       void handleProjectChatMessage(msg, this.connection, this.projectDir);
     });
     this.heartbeatTimer = setInterval(() => {
       this.connection.sendHeartbeat();
     }, HEARTBEAT_INTERVAL_MS2);
-    console.log("[project-runner] Connected, waiting for task assignments...");
+    logger4.info("Connected, waiting for task assignments");
     await new Promise((resolve2) => {
       this.resolveLifecycle = resolve2;
       process.on("SIGTERM", () => void this.stop());
@@ -3781,13 +3857,14 @@ var ProjectRunner = class {
     const { taskId, mode } = assignment;
     const shortId = taskId.slice(0, 8);
     if (this.activeAgents.has(taskId)) {
-      console.log(`[project-runner] Task ${shortId} already running, skipping`);
+      logger4.info("Task already running, skipping", { taskId: shortId });
       return;
     }
     if (this.activeAgents.size >= MAX_CONCURRENT) {
-      console.log(
-        `[project-runner] Max concurrent agents (${MAX_CONCURRENT}) reached, rejecting task ${shortId}`
-      );
+      logger4.warn("Max concurrent agents reached, rejecting task", {
+        maxConcurrent: MAX_CONCURRENT,
+        taskId: shortId
+      });
       this.connection.emitTaskStopped(taskId, "max_concurrent_reached");
       return;
     }
@@ -3795,7 +3872,7 @@ var ProjectRunner = class {
       try {
         execSync5("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
       } catch {
-        console.log(`[task:${shortId}] Warning: git fetch failed`);
+        logger4.warn("Git fetch failed", { taskId: shortId });
       }
       const { workDir, usesWorktree } = setupWorkDir(this.projectDir, assignment);
       const child = spawnChildAgent(assignment, workDir);
@@ -3806,12 +3883,12 @@ var ProjectRunner = class {
         usesWorktree
       });
       this.connection.emitTaskStarted(taskId);
-      console.log(`[project-runner] Started task ${shortId} in ${mode} mode at ${workDir}`);
+      logger4.info("Started task", { taskId: shortId, mode, workDir });
       child.on("exit", (code) => {
         this.activeAgents.delete(taskId);
         const reason = code === 0 ? "completed" : `exited with code ${code}`;
         this.connection.emitTaskStopped(taskId, reason);
-        console.log(`[project-runner] Task ${shortId} ${reason}`);
+        logger4.info("Task exited", { taskId: shortId, reason });
         if (code === 0 && usesWorktree) {
           try {
             removeWorktree(this.projectDir, taskId);
@@ -3820,10 +3897,10 @@ var ProjectRunner = class {
         }
       });
     } catch (error) {
-      console.error(
-        `[project-runner] Failed to start task ${shortId}:`,
-        error instanceof Error ? error.message : error
-      );
+      logger4.error("Failed to start task", {
+        taskId: shortId,
+        ...errorMeta(error)
+      });
       this.connection.emitTaskStopped(
         taskId,
         `start_failed: ${error instanceof Error ? error.message : "Unknown"}`
@@ -3834,7 +3911,7 @@ var ProjectRunner = class {
     const agent = this.activeAgents.get(taskId);
     if (!agent) return;
     const shortId = taskId.slice(0, 8);
-    console.log(`[project-runner] Stopping task ${shortId}`);
+    logger4.info("Stopping task", { taskId: shortId });
     agent.process.kill("SIGTERM");
     const timer = setTimeout(() => {
       if (this.activeAgents.has(taskId)) {
@@ -3854,7 +3931,7 @@ var ProjectRunner = class {
   async stop() {
     if (this.stopping) return;
     this.stopping = true;
-    console.log("[project-runner] Shutting down...");
+    logger4.info("Shutting down");
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
@@ -3879,7 +3956,7 @@ var ProjectRunner = class {
       })
     ]);
     this.connection.disconnect();
-    console.log("[project-runner] Shutdown complete");
+    logger4.info("Shutdown complete");
     if (this.resolveLifecycle) {
       this.resolveLifecycle();
       this.resolveLifecycle = null;
@@ -3959,8 +4036,10 @@ export {
   loadConveyorConfig,
   runSetupCommand,
   runStartCommand,
+  createServiceLogger,
+  errorMeta,
   AgentRunner,
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-VJRAWAWQ.js.map
+//# sourceMappingURL=chunk-JI4AW4WX.js.map