@rallycry/conveyor-agent 10.13.71 → 10.13.72

package/dist/index.js

@@ -1,7 +1,11 @@
+import {
+  SessionRunner,
+  unshallowRepo
+} from "./chunk-2SN32LM6.js";
+import "./chunk-XORJ6SII.js";
 import {
   AgentConnection,
   GIT_TIMEOUT_MS,
-  SessionRunner,
   flushPendingChanges,
   getCurrentBranch,
   hasUncommittedChanges,
@@ -10,11 +14,10 @@ import {
   loadForwardPorts,
   pushToOrigin,
   stageAndCommit,
-  unshallowRepo,
   updateRemoteToken,
   workspacePathExists
-} from "./chunk-7MMECTTJ.js";
-import "./chunk-QU53HND5.js";
+} from "./chunk-LSZ2KLJY.js";
+import "./chunk-WMMBAKPE.js";
 import "./chunk-IA45XHOA.js";
 import {
   getWorkbenchClient
@@ -22,11 +25,12 @@ import {
 import {
   workbenchEnabled
 } from "./chunk-KMB3BU4S.js";
+import "./chunk-3F4ZZKCA.js";
 import {
   runAuthTokenCommand,
   runSetupCommand,
   runStartCommand
-} from "./chunk-GJXAAPJ6.js";
+} from "./chunk-W4LZ7R6Z.js";
 import "./chunk-6Q6LQBWO.js";
 
 // src/runner/worktree.ts

package/dist/serve-boot-4N3FRXVQ.js

@@ -0,0 +1,225 @@
+import {
+  WorkspaceCommandSupervisor
+} from "./chunk-2L5THOWD.js";
+import {
+  AgentConnection,
+  CodespacePortVisibility,
+  DEFAULT_LIFECYCLE_CONFIG,
+  Lifecycle,
+  PortDiscovery,
+  awaitGitReady,
+  createServiceLogger,
+  ensureOnTaskBranch,
+  loadConveyorConfig
+} from "./chunk-LSZ2KLJY.js";
+import "./chunk-WMMBAKPE.js";
+import "./chunk-IA45XHOA.js";
+import "./chunk-EXQ6AHOY.js";
+import "./chunk-KMB3BU4S.js";
+import "./chunk-W4LZ7R6Z.js";
+import "./chunk-6Q6LQBWO.js";
+
+// src/runner/serve-session-runner.ts
+var ServeSessionRunner = class {
+  connection;
+  lifecycle;
+  config;
+  callbacks;
+  portDiscovery;
+  commandSupervisor;
+  git;
+  stopped = false;
+  stopResolver = null;
+  _finalState = null;
+  constructor(config, callbacks = {}, deps) {
+    this.config = config;
+    this.callbacks = callbacks;
+    this.connection = deps?.connection ?? new AgentConnection(config.connection);
+    const portVisibility = new CodespacePortVisibility();
+    this.portDiscovery = deps?.portDiscovery ?? new PortDiscovery({
+      report: (ports) => this.connection.reportDiscoveredPorts(ports),
+      onReported: (ports) => portVisibility.ensureVisible(ports.map(({ port }) => port))
+    });
+    this.commandSupervisor = deps?.commandSupervisor ?? new WorkspaceCommandSupervisor({
+      config: loadConveyorConfig(),
+      workspaceDir: config.workspaceDir,
+      connection: this.connection
+    });
+    this.git = deps?.git ?? {
+      awaitGitReady: (opts) => awaitGitReady(opts),
+      checkoutBranch: (cwd, branch) => ensureOnTaskBranch(cwd, branch)
+    };
+    this.lifecycle = new Lifecycle(
+      // No git flush and no usage sample: nothing here writes to the checkout,
+      // and the serving bundle selects no coding-agent key to measure.
+      {
+        ...DEFAULT_LIFECYCLE_CONFIG,
+        gitFlushIntervalMs: 0,
+        usageSampleIntervalMs: 0,
+        ...config.lifecycle
+      },
+      {
+        onHeartbeat: () => this.connection.sendHeartbeat(),
+        // Never armed (see the file header) — supplied because Lifecycle
+        // requires the full callback set.
+        onIdleTimeout: () => this.requestStop(),
+        onDormantTimeout: () => this.requestStop(),
+        onTokenRefresh: () => void this.connection.refreshTaskTokenFromBootstrap().catch(() => {
+        }),
+        onGitFlush: () => {
+        },
+        onUsageSample: () => {
+        }
+      }
+    );
+  }
+  get finalState() {
+    return this._finalState;
+  }
+  get isStopped() {
+    return this.stopped;
+  }
+  /** Connect, register the session, launch the start command, then hold open. */
+  async run() {
+    try {
+      await this.connection.connect();
+      this.connection.sendEvent({
+        type: "connected",
+        sessionId: this.config.connection.sessionId
+      });
+      this.connection.onStop(() => this.requestStop());
+      this.lifecycle.startHeartbeat();
+      this.lifecycle.startTokenRefresh();
+      await this.connection.call("connectAgent", {
+        sessionId: this.config.connection.sessionId
+      });
+      await this.portDiscovery.start().catch(() => {
+      });
+      if (this.stopped) {
+        this._finalState = "finished";
+        return;
+      }
+      const gitState = await this.git.awaitGitReady({
+        onLog: (m) => process.stderr.write(`[conveyor-agent] ${m}
+`)
+      });
+      if (this.stopped) {
+        this._finalState = "finished";
+        return;
+      }
+      if (gitState === "failed" || gitState === "timeout") {
+        throw new Error(
+          gitState === "failed" ? "Workspace git preparation failed (see pod logs)" : "Workspace git preparation timed out (see pod logs)"
+        );
+      }
+      const onBranch = await this.git.checkoutBranch(this.config.workspaceDir, this.config.branch);
+      if (this.stopped) {
+        this._finalState = "finished";
+        return;
+      }
+      if (!onBranch) {
+        throw new Error(
+          `Task-branch checkout failed for "${this.config.branch}"; refusing to serve base-branch code`
+        );
+      }
+      this.commandSupervisor.start();
+      this.commandSupervisor.notifyLoopReady?.();
+      await this.connection.emitStatus("idle");
+      this.callbacks.onEvent?.({ type: "serve_runner_started", taskId: this.config.taskId });
+      await this.waitUntilStopped();
+      this._finalState = "finished";
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[conveyor-agent] Serve runner failed: ${message}
+`);
+      this.connection.sendEvent({ type: "error", message });
+      this._finalState = "error";
+    } finally {
+      await this.shutdown();
+    }
+  }
+  /** External stop (SIGTERM/SIGINT or server session:stop). */
+  stop() {
+    this.requestStop();
+  }
+  requestStop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.portDiscovery.stop();
+    if (this.stopResolver) {
+      const resolve = this.stopResolver;
+      this.stopResolver = null;
+      resolve();
+    }
+  }
+  waitUntilStopped() {
+    if (this.stopped) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.stopResolver = resolve;
+    });
+  }
+  async shutdown() {
+    this.stopped = true;
+    this.portDiscovery.stop();
+    this.lifecycle.destroy();
+    await this.commandSupervisor.stop().catch(() => {
+    });
+    this.connection.sendEvent({ type: "shutdown", reason: this._finalState ?? "finished" });
+    this.connection.disconnect();
+  }
+};
+
+// src/runner/serve-boot.ts
+var logger = createServiceLogger("ServeBoot");
+function outcomeFor(runner) {
+  const errored = runner.finalState === "error";
+  return {
+    exitCode: errored ? 1 : 0,
+    reason: errored ? "error" : "clean",
+    finalState: runner.finalState ?? void 0
+  };
+}
+async function runServingSession(params) {
+  if (!params.sessionId) {
+    logger.error("Serving mode requires CONVEYOR_SESSION_ID");
+    return { exitCode: 1, reason: "error", finalState: "error" };
+  }
+  if (!params.branch) {
+    logger.error("Serving mode requires BRANCH (the card's branch to serve)");
+    return { exitCode: 1, reason: "error", finalState: "error" };
+  }
+  logger.info("Starting preview-only serving runner", {
+    taskId: params.taskId,
+    sessionId: params.sessionId,
+    branch: params.branch
+  });
+  const runner = new ServeSessionRunner(
+    {
+      connection: {
+        apiUrl: params.apiUrl,
+        taskToken: params.taskToken,
+        sessionId: params.sessionId,
+        runnerMode: "serving"
+      },
+      taskId: params.taskId,
+      workspaceDir: params.workspaceDir,
+      branch: params.branch
+    },
+    {
+      onEvent: (event) => {
+        logger.info("Serve runner event", { eventType: event.type });
+      }
+    }
+  );
+  const stop = () => {
+    params.onSignal?.();
+    runner.stop();
+  };
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  await runner.run();
+  return outcomeFor(runner);
+}
+export {
+  runServingSession
+};

package/dist/{server-CC7KUJOK.js → server-7XH7RYUX.js}

@@ -1,7 +1,8 @@
 import {
   startWorkbenchServer
-} from "./chunk-DOB2XE2I.js";
-import "./chunk-GJXAAPJ6.js";
+} from "./chunk-UBDSLM44.js";
+import "./chunk-3F4ZZKCA.js";
+import "./chunk-W4LZ7R6Z.js";
 import "./chunk-6Q6LQBWO.js";
 import "./chunk-6W6UZ4SJ.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "10.13.71",
+  "version": "10.13.72",
   "description": "Conveyor Agent Runner v10 - PTY harness for the task chat (SDK harness for audit/project-chat). Agent-as-User architecture with BaseService patterns. Works locally too.",
   "keywords": [
     "agent",