@rallycry/conveyor-agent 8.5.0 → 8.5.1

package/dist/{chunk-3T4SJEH6.js → chunk-WZCO64YR.js}

@@ -12,7 +12,7 @@ import {
   ensureClaudeCredentials,
   removeConveyorCredentials,
   sessionTranscriptPath
-} from "./chunk-63FTZOL5.js";
+} from "./chunk-6B545CHM.js";
 
 // src/setup/bootstrap.ts
 var BOOTSTRAP_TIMEOUT_MS = 3e4;
@@ -134,11 +134,13 @@ function applyBootstrapToEnv(config) {
 import { io } from "socket.io-client";
 var EVENT_BATCH_MS = 500;
 var MAX_EVENT_BUFFER = 5e3;
+var TOKEN_REFRESH_INTERVAL_MS = 6 * 60 * 60 * 1e3;
 var AgentConnection = class _AgentConnection {
   socket = null;
   config;
   eventBuffer = [];
   flushTimer = null;
+  tokenRefreshTimer = null;
   lastEmittedStatus = null;
   lastReportedStatus = null;
   droppedEventCount = 0;
@@ -202,6 +204,7 @@ var AgentConnection = class _AgentConnection {
     if (!this.config.apiUrl) {
       return Promise.reject(new Error("Cannot connect: apiUrl is empty"));
     }
+    this.startProactiveTokenRefresh();
     return new Promise((resolve2, reject) => {
       let settled = false;
       let attempts = 0;
@@ -316,6 +319,7 @@ var AgentConnection = class _AgentConnection {
     });
   }
   disconnect() {
+    this.stopProactiveTokenRefresh();
     void this.flushEvents();
     if (this.socket) {
       this.socket.io.reconnection(false);
@@ -399,7 +403,32 @@ var AgentConnection = class _AgentConnection {
     }
   }
   looksLikeAuthError(message) {
-    return /unauthor|forbid|auth|token/i.test(message);
+    return /unauthor|forbid|auth|token|session (?:not found|expired|invalid)|invalid session/i.test(
+      message
+    );
+  }
+  // ── Proactive task-token refresh ────────────────────────────────────────
+  //
+  // Socket.IO only re-presents the taskToken on a (re)connect handshake, and
+  // the server only re-validates the JWT then. So a token that expires while
+  // the socket stays connected goes unnoticed until the next RPC fails. Re-mint
+  // periodically from the bootstrap endpoint — refreshFromBootstrap() updates
+  // both this.config.taskToken and socket.auth.taskToken, so any later
+  // reconnect carries a fresh token. No-ops for project mode / missing
+  // codespace env, and is rate-limited to once/60s inside refreshFromBootstrap.
+  startProactiveTokenRefresh() {
+    if (this.tokenRefreshTimer) return;
+    this.tokenRefreshTimer = setInterval(() => {
+      void this.refreshTaskTokenFromBootstrap().catch(() => {
+      });
+    }, TOKEN_REFRESH_INTERVAL_MS);
+    this.tokenRefreshTimer.unref?.();
+  }
+  stopProactiveTokenRefresh() {
+    if (this.tokenRefreshTimer) {
+      clearInterval(this.tokenRefreshTimer);
+      this.tokenRefreshTimer = null;
+    }
   }
   drainPendingMessages(messages) {
     for (const msg of messages) {
@@ -1936,6 +1965,11 @@ var StopProjectBuildRequestSchema = z2.object({
   taskId: z2.string(),
   requestingUserId: z2.string().optional()
 });
+var CreateProjectReleaseRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskIds: z2.array(z2.string()).optional(),
+  requestingUserId: z2.string().optional()
+});
 var ApproveProjectMergePRRequestSchema = z2.object({
   projectId: z2.string(),
   childTaskId: z2.string(),
@@ -2011,6 +2045,22 @@ var GetProjectAttachmentRequestSchema = z2.object({
   /** Max bytes of text content to return from `offset`. Server default applies. */
   maxBytes: z2.number().int().positive().optional()
 });
+var RequestProjectFileUploadRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  fileName: z2.string().min(1).max(255),
+  mimeType: z2.string().min(1).max(128),
+  fileSize: z2.number().int().positive().max(MAX_FILE_SIZE_BYTES),
+  requestingUserId: z2.string().optional()
+});
+var ConfirmProjectFileUploadRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  fileId: z2.string(),
+  /** When set, the attachment is also posted to the task chat with this text. */
+  comment: z2.string().max(2e3).optional(),
+  requestingUserId: z2.string().optional()
+});
 var CreateProjectPullRequestRequestSchema = z2.object({
   projectId: z2.string(),
   taskId: z2.string(),
@@ -2035,6 +2085,16 @@ var RemoveProjectTaskReviewerRequestSchema = z2.object({
   userId: z2.string(),
   requestingUserId: z2.string().optional()
 });
+var ListProjectManualTestsRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string()
+});
+var SetProjectManualTestsRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  items: z2.array(z2.object({ title: z2.string().min(1) })).min(1),
+  requestingUserId: z2.string().optional()
+});
 var StartTaskAuditRequestSchema = z3.object({
   projectId: z3.string(),
   taskIds: z3.array(z3.string()).min(1)
@@ -8200,7 +8260,10 @@ var SessionRunner = class _SessionRunner {
 `);
     this.connection.sendEvent({ type: "shutdown", reason: finalState });
     this.lifecycle.destroy();
-    await this.setState(finalState);
+    try {
+      await this.setState(finalState);
+    } catch {
+    }
     this.connection.disconnect();
     this._finalState = finalState;
   }
@@ -8259,20 +8322,31 @@ var ProjectConnection = class {
     return this.socket?.connected ?? false;
   }
   // ── Typed service method call ──────────────────────────────────────────
-  call(method, payload) {
+  call(method, payload, opts) {
     const socket = this.requireSocket();
     return new Promise((resolve2, reject) => {
-      socket.emit(
-        `agentSessionService:${String(method)}`,
-        payload,
-        (response) => {
-          if (response.success && response.data !== void 0) {
-            resolve2(response.data);
-          } else {
-            reject(new Error(response.error ?? `Service call failed: ${String(method)}`));
-          }
+      const handleResponse = (response) => {
+        if (response.success && response.data !== void 0) {
+          resolve2(response.data);
+        } else {
+          reject(new Error(response.error ?? `Service call failed: ${String(method)}`));
         }
-      );
+      };
+      if (opts?.timeoutMs) {
+        socket.timeout(opts.timeoutMs).emit(
+          `agentSessionService:${String(method)}`,
+          payload,
+          (err, response) => {
+            if (err) {
+              reject(new Error(`Service call timed out: ${String(method)}`));
+            } else {
+              handleResponse(response);
+            }
+          }
+        );
+        return;
+      }
+      socket.emit(`agentSessionService:${String(method)}`, payload, handleResponse);
     });
   }
   // ── Connection lifecycle ───────────────────────────────────────────────
@@ -8330,8 +8404,13 @@ var ProjectConnection = class {
       this.flushTimer = null;
     }
     this.flushEvents();
-    this.socket?.disconnect();
-    this.socket = null;
+    if (this.socket) {
+      this.socket.io.reconnection(false);
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    this.reconnectCallbacks = [];
   }
   onReconnect(callback) {
     this.reconnectCallbacks.push(callback);
@@ -9928,6 +10007,10 @@ function spawnChildAgent(assignment, workDir) {
       CONVEYOR_MODE: mode,
       CONVEYOR_WORKSPACE: workDir,
       CONVEYOR_USE_WORKTREE: "false",
+      // The project runner flushes git for every child working tree after the
+      // kill (see ProjectRunner.stop), so the child skips its own shutdown
+      // flush — keeps SIGTERM teardown well inside the SIGKILL window.
+      CONVEYOR_SKIP_SHUTDOWN_GIT_FLUSH: "true",
       CONVEYOR_AGENT_MODE: effectiveAgentMode,
       CONVEYOR_IS_AUTO: isAuto ? "true" : "false",
       CONVEYOR_USE_SANDBOX: useSandbox === true ? "true" : "false",
@@ -10052,6 +10135,8 @@ function handleStopTask(taskId, activeAgents, projectDir) {
 // src/runner/project-runner.ts
 var logger10 = createServiceLogger("ProjectRunner");
 var HEARTBEAT_INTERVAL_MS = 3e4;
+var DISCONNECT_ACK_TIMEOUT_MS = 5e3;
+var SHUTDOWN_WATCHDOG_MS = 9e4;
 var ProjectRunner = class {
   connection;
   projectDir;
@@ -10135,11 +10220,17 @@ var ProjectRunner = class {
   }
   /** Best-effort WIP commit + push of every tracked working tree on shutdown.
    *  Iterates the main project dir plus any active agent worktrees so nothing
-   *  pending is lost when the pod is killed. Never throws. */
-  async flushGitOnShutdown() {
-    const dirs = /* @__PURE__ */ new Set([this.projectDir]);
-    for (const agent of this.activeAgents.values()) {
-      if (agent.worktreePath) dirs.add(agent.worktreePath);
+   *  pending is lost when the pod is killed. Never throws.
+   *
+   *  Callers that kill child agents first must snapshot the worktree dirs
+   *  BEFORE the kill — the child exit handler removes entries from
+   *  `activeAgents`, so reading it after the kill misses the worktrees. */
+  async flushGitOnShutdown(dirs) {
+    if (!dirs) {
+      dirs = /* @__PURE__ */ new Set([this.projectDir]);
+      for (const agent of this.activeAgents.values()) {
+        if (agent.worktreePath) dirs.add(agent.worktreePath);
+      }
     }
     for (const dir of dirs) {
       try {
@@ -10163,38 +10254,62 @@ var ProjectRunner = class {
     if (this.stopping) return;
     this.stopping = true;
     logger10.info("Shutting down");
-    this.commitWatcher.stop();
-    await killStartCommand(this.startCmd);
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
+    const watchdog = setTimeout(() => {
+      logger10.warn("Shutdown watchdog fired, forcing lifecycle resolution");
+      this.finishShutdown();
+    }, SHUTDOWN_WATCHDOG_MS);
+    watchdog.unref();
+    const flushDirs = /* @__PURE__ */ new Set([this.projectDir]);
+    for (const agent of this.activeAgents.values()) {
+      if (agent.worktreePath) flushDirs.add(agent.worktreePath);
     }
-    const stopPromises = [...this.activeAgents.keys()].map(
-      (key) => new Promise((resolve2) => {
-        const agent = this.activeAgents.get(key);
-        if (!agent) {
-          resolve2();
-          return;
-        }
-        agent.process.on("exit", () => resolve2());
-        handleStopTask(key, this.activeAgents, this.projectDir);
-      })
-    );
-    await Promise.race([
-      Promise.all(stopPromises),
-      new Promise((resolve2) => {
-        setTimeout(resolve2, STOP_TIMEOUT_MS + 5e3);
-      })
-    ]);
-    await this.flushGitOnShutdown();
     try {
-      await this.connection.call("disconnectProjectRunner", {
-        projectId: this.connection.projectId
-      });
+      this.commitWatcher.stop();
+      await killStartCommand(this.startCmd);
+      if (this.heartbeatTimer) {
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+      }
+      const stopPromises = [...this.activeAgents.keys()].map(
+        (key) => new Promise((resolve2) => {
+          const agent = this.activeAgents.get(key);
+          if (!agent) {
+            resolve2();
+            return;
+          }
+          agent.process.on("exit", () => resolve2());
+          handleStopTask(key, this.activeAgents, this.projectDir);
+        })
+      );
+      await Promise.race([
+        Promise.all(stopPromises),
+        new Promise((resolve2) => {
+          setTimeout(resolve2, STOP_TIMEOUT_MS + 5e3);
+        })
+      ]);
+      await this.flushGitOnShutdown(flushDirs);
+      try {
+        await this.connection.call(
+          "disconnectProjectRunner",
+          { projectId: this.connection.projectId },
+          { timeoutMs: DISCONNECT_ACK_TIMEOUT_MS }
+        );
+      } catch {
+      }
+      logger10.info("Shutdown complete");
+    } finally {
+      clearTimeout(watchdog);
+      this.finishShutdown();
+    }
+  }
+  /** Idempotent final step: tear down the socket and resolve the lifecycle
+   *  promise so start() returns. Called from stop()'s finally and from the
+   *  shutdown watchdog. */
+  finishShutdown() {
+    try {
+      this.connection.disconnect();
     } catch {
     }
-    this.connection.disconnect();
-    logger10.info("Shutdown complete");
     if (this.resolveLifecycle) {
       this.resolveLifecycle();
       this.resolveLifecycle = null;
@@ -10268,7 +10383,7 @@ var ProjectRunner = class {
   async handleAuditTags(request) {
     this.connection.emitStatus("busy");
     try {
-      const { handleTagAudit } = await import("./tag-audit-handler-PKYLDJHH.js");
+      const { handleTagAudit } = await import("./tag-audit-handler-3IFB7YDV.js");
       await handleTagAudit(request, this.connection, this.projectDir);
     } catch (error) {
       const msg = parseErrorMessage(error);
@@ -10291,7 +10406,7 @@ var ProjectRunner = class {
   async handleAuditTasks(request) {
     this.connection.emitStatus("busy");
     try {
-      const { handleTaskAudit } = await import("./task-audit-handler-WINYLZMU.js");
+      const { handleTaskAudit } = await import("./task-audit-handler-U5Q52YT2.js");
       await handleTaskAudit(request, this.connection, this.projectDir);
     } catch (error) {
       const msg = parseErrorMessage(error);
@@ -10432,4 +10547,4 @@ export {
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-3T4SJEH6.js.map
+//# sourceMappingURL=chunk-WZCO64YR.js.map