@rallycry/conveyor-agent 5.9.2 → 5.9.4

package/dist/{chunk-X2QE27GN.js → chunk-N3TSLBSH.js}

@@ -1,3 +1,62 @@
+// src/setup/commands.ts
+import { spawn, execSync } from "child_process";
+function runSetupCommand(cmd, cwd, onOutput) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn("sh", ["-c", cmd], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    child.stdout.on("data", (chunk) => {
+      onOutput("stdout", chunk.toString());
+    });
+    child.stderr.on("data", (chunk) => {
+      onOutput("stderr", chunk.toString());
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`Setup command exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+var AUTH_TOKEN_TIMEOUT_MS = 3e4;
+function runAuthTokenCommand(cmd, userEmail, cwd) {
+  try {
+    const output = execSync(`${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,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    env: { ...process.env }
+  });
+  child.stdout.on("data", (chunk) => {
+    onOutput("stdout", chunk.toString());
+  });
+  child.stderr.on("data", (chunk) => {
+    onOutput("stderr", chunk.toString());
+  });
+  child.unref();
+  return child;
+}
+
 // src/connection/task-connection.ts
 import { io } from "socket.io-client";
 
@@ -161,6 +220,10 @@ var ConveyorConnection = class _ConveyorConnection {
       this.socket.on("agentRunner:runStartCommand", () => {
         if (this.runStartCommandCallback) this.runStartCommandCallback();
       });
+      this.socket.on(
+        "agentRunner:runAuthTokenCommand",
+        (data, cb) => this.handleRunAuthTokenCommand(data.userEmail, cb)
+      );
       this.socket.on("connect", () => {
         if (!settled) {
           settled = true;
@@ -260,6 +323,33 @@ var ConveyorConnection = class _ConveyorConnection {
   onRunStartCommand(callback) {
     this.runStartCommandCallback = callback;
   }
+  handleRunAuthTokenCommand(userEmail, cb) {
+    try {
+      if (process.env.CODESPACES !== "true") {
+        cb({ ok: false, error: "Auth token command only available in codespace environments" });
+        return;
+      }
+      const authCmd = process.env.CONVEYOR_AUTH_TOKEN_COMMAND;
+      if (!authCmd) {
+        cb({ ok: false, error: "CONVEYOR_AUTH_TOKEN_COMMAND not configured" });
+        return;
+      }
+      const token = runAuthTokenCommand(authCmd, userEmail, this.config.workspaceDir);
+      if (!token) {
+        cb({
+          ok: false,
+          error: `Auth token command returned empty output. Command: ${authCmd}, Working Dir: ${this.config.workspaceDir}`
+        });
+        return;
+      }
+      cb({ ok: true, token });
+    } catch (error) {
+      cb({
+        ok: false,
+        error: error instanceof Error ? error.message : "Auth token command failed"
+      });
+    }
+  }
   emitModeChanged(agentMode) {
     if (!this.socket) return;
     this.socket.emit("agentRunner:modeChanged", { agentMode });
@@ -272,10 +362,6 @@ 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 });
@@ -509,7 +595,7 @@ var ProjectConnection = class {
 };
 
 // src/runner/worktree.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import { existsSync } from "fs";
 import { join } from "path";
 var WORKTREE_DIR = ".worktrees";
@@ -521,7 +607,7 @@ function ensureWorktree(projectDir, taskId, branch) {
   if (existsSync(worktreePath)) {
     if (branch) {
       try {
-        execSync(`git checkout --detach origin/${branch}`, {
+        execSync2(`git checkout --detach origin/${branch}`, {
           cwd: worktreePath,
           stdio: "ignore"
         });
@@ -531,7 +617,7 @@ function ensureWorktree(projectDir, taskId, branch) {
     return worktreePath;
   }
   const ref = branch ? `origin/${branch}` : "HEAD";
-  execSync(`git worktree add --detach "${worktreePath}" ${ref}`, {
+  execSync2(`git worktree add --detach "${worktreePath}" ${ref}`, {
     cwd: projectDir,
     stdio: "ignore"
   });
@@ -541,7 +627,7 @@ function removeWorktree(projectDir, taskId) {
   const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
   if (!existsSync(worktreePath)) return;
   try {
-    execSync(`git worktree remove "${worktreePath}" --force`, {
+    execSync2(`git worktree remove "${worktreePath}" --force`, {
       cwd: projectDir,
       stdio: "ignore"
     });
@@ -552,7 +638,6 @@ function removeWorktree(projectDir, taskId) {
 // src/setup/config.ts
 import { readFile } from "fs/promises";
 import { join as join2 } from "path";
-var CONVEYOR_CONFIG_PATH = ".conveyor/config.json";
 var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
 async function loadForwardPorts(workspaceDir) {
   try {
@@ -563,87 +648,20 @@ async function loadForwardPorts(workspaceDir) {
     return [];
   }
 }
-async function loadConveyorConfig(workspaceDir) {
+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) {
     return {
       setupCommand: envSetup,
       startCommand: envStart,
-      previewPort: envPort ? Number(envPort) : void 0,
-      authTokenCommand: envAuth
+      previewPort: envPort ? Number(envPort) : void 0
     };
   }
-  try {
-    const raw = await readFile(join2(workspaceDir, CONVEYOR_CONFIG_PATH), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed.setupCommand || parsed.startCommand) return parsed;
-  } catch {
-  }
   return null;
 }
 
-// src/setup/commands.ts
-import { spawn, execSync as execSync2 } from "child_process";
-function runSetupCommand(cmd, cwd, onOutput) {
-  return new Promise((resolve2, reject) => {
-    const child = spawn("sh", ["-c", cmd], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env }
-    });
-    child.stdout.on("data", (chunk) => {
-      onOutput("stdout", chunk.toString());
-    });
-    child.stderr.on("data", (chunk) => {
-      onOutput("stderr", chunk.toString());
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve2();
-      } else {
-        reject(new Error(`Setup command exited with code ${code}`));
-      }
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-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,
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: true,
-    env: { ...process.env }
-  });
-  child.stdout.on("data", (chunk) => {
-    onOutput("stdout", chunk.toString());
-  });
-  child.stderr.on("data", (chunk) => {
-    onOutput("stderr", chunk.toString());
-  });
-  child.unref();
-  return child;
-}
-
 // src/setup/codespace.ts
 import { execSync as execSync3 } from "child_process";
 function unshallowRepo(workspaceDir) {
@@ -977,6 +995,8 @@ async function processResultCase(event, host, context, startTime, state) {
 }
 async function processEvents(events, context, host) {
   const startTime = Date.now();
+  let lastStatusEmit = Date.now();
+  const STATUS_REEMIT_INTERVAL_MS = 5e3;
   const state = {
     sessionIdStored: false,
     isTyping: false,
@@ -989,6 +1009,11 @@ async function processEvents(events, context, host) {
   };
   for await (const event of events) {
     if (host.isStopped()) break;
+    const now = Date.now();
+    if (now - lastStatusEmit >= STATUS_REEMIT_INTERVAL_MS) {
+      host.connection.emitStatus("running");
+      lastStatusEmit = now;
+    }
     if (host.pendingModeRestart) {
       stopTypingIfNeeded(host, state.isTyping);
       return { retriable: false, modeRestart: true };
@@ -1179,7 +1204,8 @@ function buildPropertyInstructions(context) {
   if (context.projectTags && context.projectTags.length > 0) {
     parts.push(``, `Available project tags:`);
     for (const tag of context.projectTags) {
-      parts.push(`- ID: "${tag.id}", Name: "${tag.name}"`);
+      const desc = tag.description ? ` \u2014 ${tag.description}` : "";
+      parts.push(`- ID: "${tag.id}", Name: "${tag.name}"${desc}`);
     }
   }
   return parts;
@@ -1426,7 +1452,6 @@ Your responses are sent directly to the task chat \u2014 the team sees everythin
 }
 
 // src/execution/prompt-builder.ts
-var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["InProgress", "ReviewPR", "ReviewDev", "ReviewLive"]);
 function formatFileSize(bytes) {
   if (bytes === void 0) return "";
   if (bytes < 1024) return `${bytes}B`;
@@ -1439,16 +1464,16 @@ function findLastAgentMessageIndex2(history) {
   }
   return -1;
 }
-function detectRelaunchScenario(context) {
+function detectRelaunchScenario(context, trustChatHistory = false) {
   const lastAgentIdx = findLastAgentMessageIndex2(context.chatHistory);
   if (lastAgentIdx === -1) return "fresh";
-  const hasPriorWork = !!context.githubPRUrl || !!context.claudeSessionId || ACTIVE_STATUSES.has(context.status ?? "");
+  const hasPriorWork = !!context.githubPRUrl || !!context.claudeSessionId || trustChatHistory;
   if (!hasPriorWork) return "fresh";
   const messagesAfterAgent = context.chatHistory.slice(lastAgentIdx + 1);
   const hasNewUserMessages = messagesAfterAgent.some((m) => m.role === "user");
   return hasNewUserMessages ? "feedback_relaunch" : "idle_relaunch";
 }
-function buildRelaunchWithSession(mode, context) {
+function buildRelaunchWithSession(mode, context, agentMode) {
   const scenario = detectRelaunchScenario(context);
   if (!context.claudeSessionId || scenario === "fresh") return null;
   const parts = [];
@@ -1494,9 +1519,18 @@ Address the requested changes. Do NOT re-investigate the codebase from scratch o
       `You were relaunched but no new instructions have been given since your last run.`,
       `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
       `Run \`git log --oneline -10\` to review what you already committed.`,
-      `Review the current state of the codebase and verify everything is working correctly.`,
-      `Reply with a brief status update (visible in chat), then wait for further instructions.`
+      `Review the current state of the codebase and verify everything is working correctly.`
     );
+    if (agentMode === "auto" || agentMode === "building") {
+      parts.push(
+        `If work is incomplete, continue implementing the plan. When finished, commit, push, and use mcp__conveyor__create_pull_request to open a PR.`,
+        `Do NOT go idle or wait for instructions \u2014 you are in auto mode.`
+      );
+    } else {
+      parts.push(
+        `Reply with a brief status update (visible in chat), then wait for further instructions.`
+      );
+    }
     if (context.githubPRUrl) {
       parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
     }
@@ -1711,10 +1745,19 @@ function buildInstructions(mode, context, scenario, agentMode) {
       parts.push(
         `You were relaunched but no new instructions have been given since your last run.`,
         `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
-        `Run \`git log --oneline -10\` to review what you already committed, then verify the current state is correct.`,
-        `Reply with a brief status update summarizing where things stand (visible in chat).`,
-        `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
+        `Run \`git log --oneline -10\` to review what you already committed, then verify the current state is correct.`
       );
+      if (agentMode === "auto" || agentMode === "building") {
+        parts.push(
+          `If work is incomplete, continue implementing the plan. When finished, commit, push, and use mcp__conveyor__create_pull_request to open a PR.`,
+          `Do NOT go idle or wait for instructions \u2014 you are in auto mode.`
+        );
+      } else {
+        parts.push(
+          `Reply with a brief status update summarizing where things stand (visible in chat).`,
+          `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
+        );
+      }
       if (context.githubPRUrl) {
         parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
       }
@@ -1727,10 +1770,11 @@ function buildInstructions(mode, context, scenario, agentMode) {
 function buildInitialPrompt(mode, context, isAuto, agentMode) {
   const isPackRunner = mode === "pm" && !!isAuto && !!context.isParentTask;
   if (!isPackRunner) {
-    const sessionRelaunch = buildRelaunchWithSession(mode, context);
+    const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode);
     if (sessionRelaunch) return sessionRelaunch;
   }
-  const scenario = detectRelaunchScenario(context);
+  const isPm = mode === "pm";
+  const scenario = detectRelaunchScenario(context, isPm);
   const body = buildTaskBody(context);
   const instructions = isPackRunner ? buildPackRunnerInstructions(context, scenario) : buildInstructions(mode, context, scenario, agentMode);
   return [...body, ...instructions].join("\n");
@@ -3010,6 +3054,16 @@ ${message}`);
 }
 async function runSetupSafe(runnerConfig, connection, callbacks, setupLog, _effectiveAgentMode, setState) {
   await setState("setup");
+  if (process.env.CONVEYOR_FROM_PROJECT_RUNNER === "true") {
+    const config2 = await loadConveyorConfig(runnerConfig.workspaceDir);
+    const setupEvent = {
+      type: "setup_complete",
+      previewPort: config2?.previewPort ?? void 0
+    };
+    connection.sendEvent(setupEvent);
+    await callbacks.onEvent(setupEvent);
+    return { ok: true, conveyorConfig: config2 };
+  }
   const ports = await loadForwardPorts(runnerConfig.workspaceDir);
   if (ports.length > 0 && process.env.CODESPACE_NAME) {
     const visibility = ports.map((p) => `${p}:public`).join(" ");
@@ -3048,17 +3102,6 @@ The agent cannot start until this is resolved.`
     return { ok: false, conveyorConfig: 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 rerunStartCommand(conveyorConfig, runnerConfig, connection, setupLog) {
   if (!conveyorConfig.startCommand) return;
   pushSetupLog(setupLog, `$ ${conveyorConfig.startCommand} &  (background, re-trigger)`);
@@ -3288,9 +3331,6 @@ var AgentRunner = class {
     }
     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();
@@ -3844,7 +3884,8 @@ function spawnChildAgent(assignment, workDir) {
       CONVEYOR_USE_WORKTREE: "false",
       CONVEYOR_AGENT_MODE: isAuto ? "auto" : "",
       CONVEYOR_IS_AUTO: isAuto ? "true" : "false",
-      CONVEYOR_USE_SANDBOX: useSandbox === true ? "true" : "false"
+      CONVEYOR_USE_SANDBOX: useSandbox === true ? "true" : "false",
+      CONVEYOR_FROM_PROJECT_RUNNER: "true"
     },
     cwd: workDir,
     stdio: ["pipe", "pipe", "pipe", "ipc"]
@@ -4102,17 +4143,17 @@ var FileCache = class {
 };
 
 export {
+  runSetupCommand,
+  runStartCommand,
   ConveyorConnection,
   ProjectConnection,
   ensureWorktree,
   removeWorktree,
   loadConveyorConfig,
-  runSetupCommand,
-  runStartCommand,
   createServiceLogger,
   errorMeta,
   AgentRunner,
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-X2QE27GN.js.map
+//# sourceMappingURL=chunk-N3TSLBSH.js.map