@rallycry/conveyor-agent 4.10.1 → 5.0.0

package/dist/{chunk-XRB3VPXH.js → chunk-DODEEME6.js}

@@ -272,6 +272,10 @@ var ConveyorConnection = class _ConveyorConnection {
     if (!this.socket) return;
     this.socket.emit("agentRunner:statusUpdate", { status });
   }
+  emitAuthToken(token) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:authToken", { token });
+  }
   emitRateLimitPause(resetsAt) {
     if (!this.socket) return;
     this.socket.emit("agentRunner:rateLimitPause", { resetsAt });
@@ -560,6 +564,18 @@ async function loadForwardPorts(workspaceDir) {
   }
 }
 async function loadConveyorConfig(workspaceDir) {
+  const envSetup = process.env.CONVEYOR_SETUP_COMMAND;
+  const envStart = process.env.CONVEYOR_START_COMMAND;
+  const envPort = process.env.CONVEYOR_PREVIEW_PORT;
+  const envAuth = process.env.CONVEYOR_AUTH_TOKEN_COMMAND;
+  if (envSetup || envStart || envAuth) {
+    return {
+      setupCommand: envSetup,
+      startCommand: envStart,
+      previewPort: envPort ? Number(envPort) : void 0,
+      authTokenCommand: envAuth
+    };
+  }
   try {
     const raw = await readFile(join2(workspaceDir, CONVEYOR_CONFIG_PATH), "utf-8");
     const parsed = JSON.parse(raw);
@@ -570,7 +586,7 @@ async function loadConveyorConfig(workspaceDir) {
 }
 
 // src/setup/commands.ts
-import { spawn } from "child_process";
+import { spawn, execSync as execSync2 } from "child_process";
 function runSetupCommand(cmd, cwd, onOutput) {
   return new Promise((resolve2, reject) => {
     const child = spawn("sh", ["-c", cmd], {
@@ -596,6 +612,21 @@ function runSetupCommand(cmd, cwd, onOutput) {
     });
   });
 }
+var AUTH_TOKEN_TIMEOUT_MS = 3e4;
+function runAuthTokenCommand(cmd, userEmail, cwd) {
+  try {
+    const output = execSync2(`${cmd} ${JSON.stringify(userEmail)}`, {
+      cwd,
+      timeout: AUTH_TOKEN_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: { ...process.env }
+    });
+    const token = output.toString().trim();
+    return token || null;
+  } catch {
+    return null;
+  }
+}
 function runStartCommand(cmd, cwd, onOutput) {
   const child = spawn("sh", ["-c", cmd], {
     cwd,
@@ -614,17 +645,17 @@ function runStartCommand(cmd, cwd, onOutput) {
 }
 
 // src/setup/codespace.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function initRtk() {
   try {
-    execSync2("rtk --version", { stdio: "ignore" });
-    execSync2("rtk init --global --auto-patch", { stdio: "ignore" });
+    execSync3("rtk --version", { stdio: "ignore" });
+    execSync3("rtk init --global --auto-patch", { stdio: "ignore" });
   } catch {
   }
 }
 function unshallowRepo(workspaceDir) {
   try {
-    execSync2("git fetch --unshallow", {
+    execSync3("git fetch --unshallow", {
       cwd: workspaceDir,
       stdio: "ignore",
       timeout: 6e4
@@ -633,9 +664,36 @@ 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 execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 
 // src/execution/event-processor.ts
 function epochSecondsToISO(value) {
@@ -2820,6 +2878,74 @@ 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 rebasePullBranch(runnerConfig, connection, callbacks, setupLog) {
+  const pullBranch = process.env.CONVEYOR_PULL_BRANCH;
+  if (!pullBranch) return true;
+  pushSetupLog(setupLog, `[conveyor] Rebasing onto latest ${pullBranch}...`);
+  connection.sendEvent({
+    type: "setup_output",
+    stream: "stdout",
+    data: `Rebasing onto latest ${pullBranch}...
+`
+  });
+  try {
+    await runSetupCommand(
+      `git fetch origin ${pullBranch} && git rebase origin/${pullBranch}`,
+      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] Rebase complete`);
+    return true;
+  } catch (error) {
+    const message = `Failed to rebase onto ${pullBranch}: ${error instanceof Error ? error.message : "unknown error"}`;
+    connection.sendEvent({ type: "setup_error", message });
+    await callbacks.onEvent({ type: "setup_error", message });
+    connection.postChatMessage(
+      `Failed to rebase onto latest \`${pullBranch}\`. There may be conflicts between the task branch and dev.
+
+${message}`
+    );
+    return false;
+  }
+}
 async function runSetupSafe(runnerConfig, connection, callbacks, setupLog, effectiveAgentMode, setState) {
   await setState("setup");
   const ports = await loadForwardPorts(runnerConfig.workspaceDir);
@@ -2831,18 +2957,24 @@ 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 };
+  }
+  if (!await rebasePullBranch(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 });
@@ -2851,13 +2983,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}`
       );
@@ -2897,6 +3029,17 @@ The agent cannot start until this is resolved.`
     return { ok: false, deferredStartConfig: null };
   }
 }
+function runAuthTokenSafe(config, connection, taskContext) {
+  const authCmd = process.env.CONVEYOR_AUTH_TOKEN_COMMAND;
+  if (!authCmd || !taskContext.userEmail) return;
+  try {
+    const token = runAuthTokenCommand(authCmd, taskContext.userEmail, config.workspaceDir);
+    if (token) {
+      connection.emitAuthToken(token);
+    }
+  } catch {
+  }
+}
 function runDeferredStartCommand(deferredStartConfig, runnerConfig, connection, setupLog) {
   if (!deferredStartConfig?.startCommand) return;
   pushSetupLog(setupLog, `$ ${deferredStartConfig.startCommand} &  (background, deferred)`);
@@ -3022,6 +3165,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 {
@@ -3125,6 +3269,9 @@ var AgentRunner = class {
     initRtk();
     this.tryInitWorktree();
     if (!await this.fetchAndInitContext()) return;
+    if (process.env.CODESPACES === "true" && this.taskContext) {
+      runAuthTokenSafe(this.config, this.connection, this.taskContext);
+    }
     this.tryPostContextWorktree();
     this.checkoutWorktreeBranch();
     await this.executeInitialMode();
@@ -3181,7 +3328,7 @@ var AgentRunner = class {
     if (!this.worktreeActive || !this.taskContext?.githubBranch) return;
     try {
       const branch = this.taskContext.githubBranch;
-      execSync3(`git fetch origin ${branch} && git checkout ${branch}`, {
+      execSync4(`git fetch origin ${branch} && git checkout ${branch}`, {
         cwd: this.config.workspaceDir,
         stdio: "ignore"
       });
@@ -3200,8 +3347,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;
@@ -3291,7 +3440,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() {
@@ -3299,18 +3453,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);
@@ -3341,9 +3494,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.`
         );
@@ -3458,12 +3611,13 @@ var AgentRunner = class {
 
 // src/runner/project-runner.ts
 import { fork } from "child_process";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import * as path from "path";
 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 = [];
@@ -3516,7 +3670,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) {
@@ -3524,13 +3678,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 };
 }
@@ -3604,10 +3758,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."
@@ -3620,6 +3771,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;
@@ -3637,12 +3789,12 @@ function setupWorkDir(projectDir, assignment) {
   }
   if (branch && branch !== devBranch) {
     try {
-      execSync4(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
+      execSync5(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
     } catch {
       try {
-        execSync4(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+        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 });
       }
     }
   }
@@ -3680,13 +3832,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;
@@ -3715,17 +3867,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());
@@ -3736,21 +3888,22 @@ 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;
     }
     try {
       try {
-        execSync4("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
+        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);
@@ -3761,12 +3914,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);
@@ -3775,10 +3928,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"}`
@@ -3789,7 +3942,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)) {
@@ -3809,7 +3962,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;
@@ -3834,7 +3987,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;
@@ -3914,8 +4067,10 @@ export {
   loadConveyorConfig,
   runSetupCommand,
   runStartCommand,
+  createServiceLogger,
+  errorMeta,
   AgentRunner,
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-XRB3VPXH.js.map
+//# sourceMappingURL=chunk-DODEEME6.js.map