@rallycry/conveyor-agent 10.7.3 → 10.7.5

package/dist/{chunk-UOHROQ6A.js → chunk-CWTQXS34.js}

@@ -1540,52 +1540,6 @@ async function backupOtherBranches(cwd, currentBranch) {
   return count;
 }
 
-// src/setup/git-ready.ts
-import { access, stat } from "fs/promises";
-var DEFAULT_FAILED_PATH = "/workspaces/.conveyor-git-failed";
-var DEFAULT_TIMEOUT_MS = 6e5;
-var DEFAULT_POLL_MS = 200;
-async function fileExists(path4) {
-  try {
-    await access(path4);
-    const s = await stat(path4);
-    return s.isFile();
-  } catch {
-    return false;
-  }
-}
-function awaitGitReady(opts = {}) {
-  const markerPath = opts.markerPath ?? process.env.CONVEYOR_GIT_READY_MARKER;
-  if (!markerPath) {
-    return Promise.resolve("not-gated");
-  }
-  const failedPath = opts.failedPath ?? process.env.CONVEYOR_GIT_FAILED_MARKER ?? DEFAULT_FAILED_PATH;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const pollMs = opts.pollMs ?? DEFAULT_POLL_MS;
-  opts.onLog?.(`waiting for workspace git (marker=${markerPath})`);
-  return pollForMarkers(markerPath, failedPath, timeoutMs, pollMs, opts.onLog);
-}
-async function pollForMarkers(markerPath, failedPath, timeoutMs, pollMs, onLog) {
-  const deadline = Date.now() + timeoutMs;
-  for (; ; ) {
-    if (await fileExists(markerPath)) {
-      onLog?.("workspace git ready");
-      return "ready";
-    }
-    if (await fileExists(failedPath)) {
-      onLog?.("workspace git preparation failed (marker present)");
-      return "failed";
-    }
-    if (Date.now() >= deadline) {
-      onLog?.(`workspace git not ready after ${timeoutMs}ms \u2014 giving up`);
-      return "timeout";
-    }
-    await new Promise((resolve) => {
-      setTimeout(resolve, pollMs);
-    });
-  }
-}
-
 // src/runner/work-preservation/index.ts
 import { rm as rm3 } from "fs/promises";
 
@@ -1599,7 +1553,7 @@ function selectRestoreSource(probe) {
 // src/runner/work-preservation/snapshot-tar.ts
 import { execFile as execFile2 } from "child_process";
 import { createReadStream, createWriteStream } from "fs";
-import { mkdtemp, rm, stat as stat2, writeFile } from "fs/promises";
+import { mkdtemp, rm, stat, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import path from "path";
 import { pipeline } from "stream/promises";
@@ -1691,7 +1645,7 @@ async function buildSnapshotTar(cwd) {
     const tarPath = path.join(staging, "snapshot.tar.gz");
     await pipeline(createReadStream(rawTarPath), createGzip(), createWriteStream(tarPath));
     await rm(rawTarPath, { force: true });
-    const { size } = await stat2(tarPath);
+    const { size } = await stat(tarPath);
     return {
       tarPath,
       sizeBytes: size,
@@ -4389,7 +4343,7 @@ async function removeConveyorCredentials(env = process.env) {
 }
 
 // src/harness/pty/pty-support.ts
-import { stat as stat3 } from "fs/promises";
+import { stat as stat2 } from "fs/promises";
 var MAX_DIAGNOSTIC_OUTPUT = 4e3;
 var MAX_BETWEEN_TURN_BUFFER = 500;
 var SUBMIT_SETTLE_MS = 300;
@@ -4449,9 +4403,9 @@ function extractSpawn(mod) {
 }
 async function loadPtySpawn() {
   const mod = await import("node-pty");
-  const spawn3 = extractSpawn(mod);
-  if (!spawn3) throw new Error("node-pty: spawn export not found");
-  return spawn3;
+  const spawn2 = extractSpawn(mod);
+  if (!spawn2) throw new Error("node-pty: spawn export not found");
+  return spawn2;
 }
 function inheritedEnv(socketPath) {
   const env = {};
@@ -4488,7 +4442,7 @@ function sleep3(ms) {
 }
 async function transcriptSize(path4) {
   try {
-    return (await stat3(path4)).size;
+    return (await stat2(path4)).size;
   } catch {
     return 0;
   }
@@ -4953,8 +4907,8 @@ var PtySession = class {
       // server doesn't load).
       ...this.mcpConfigPath ? { mcpConfigPath: this.mcpConfigPath } : {}
     });
-    const spawn3 = await loadPtySpawn();
-    const pty = spawn3(spec.file, spec.args, {
+    const spawn2 = await loadPtySpawn();
+    const pty = spawn2(spec.file, spec.args, {
       name: "xterm-color",
       cols: this.cols,
       rows: this.rows,
@@ -5606,7 +5560,7 @@ function formatIncidents(incidents) {
 }
 
 // src/execution/tag-context-resolver.ts
-import { readFile as readFile2, readdir, stat as stat4 } from "fs/promises";
+import { readFile as readFile2, readdir, stat as stat3 } from "fs/promises";
 var TYPE_PRIORITY = { rule: 0, file: 1, folder: 2, doc: 3 };
 var SUMMARY_SCAN_CHARS = 4e3;
 var SUMMARY_MAX_CHARS = 160;
@@ -5680,7 +5634,7 @@ async function readFileSummary(filePath) {
     if (isBinaryPath(filePath)) return null;
     let mtimeMs;
     try {
-      const st = await stat4(filePath);
+      const st = await stat3(filePath);
       mtimeMs = st.mtimeMs;
     } catch {
       return null;
@@ -5702,7 +5656,7 @@ async function readFolderListing(folderPath) {
   try {
     let mtimeMs;
     try {
-      const st = await stat4(folderPath);
+      const st = await stat3(folderPath);
       mtimeMs = st.mtimeMs;
     } catch {
       return null;
@@ -7306,7 +7260,7 @@ function buildMutationTools(connection, config) {
 }
 
 // src/tools/attachment-tools.ts
-import { readFile as readFile3, stat as stat5 } from "fs/promises";
+import { readFile as readFile3, stat as stat4 } from "fs/promises";
 import { basename, extname, isAbsolute, join as join5 } from "path";
 import { z as z7 } from "zod";
 var IMAGE_MIME_BY_EXT = {
@@ -7333,7 +7287,7 @@ function buildUploadAttachmentTool(connection, config) {
             `Unsupported file type "${extname(filePath) || "(none)"}". Supported: ${Object.keys(IMAGE_MIME_BY_EXT).join(", ")}`
           );
         }
-        const info = await stat5(filePath).catch(() => null);
+        const info = await stat4(filePath).catch(() => null);
         if (!info?.isFile()) {
           return textResult(`File not found: ${filePath}`);
         }
@@ -9650,10 +9604,21 @@ function readAgentVersion() {
   return null;
 }
 
+// src/execution/usage-sampler.ts
+import { existsSync as existsSync3 } from "fs";
+
 // src/usage/parse-usage.ts
+var ESC = "\\u001b";
+var ANSI_CSI2 = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]`, "g");
+var ANSI_OSC = new RegExp(`${ESC}\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\)`, "g");
+var BAR_GLYPHS = /[─-▟]/g;
+function normalizeUsageText(stdout) {
+  return stdout.replace(ANSI_CSI2, "").replace(ANSI_OSC, "").replace(BAR_GLYPHS, " ").replace(/\r/g, "");
+}
 function parseUsageGauges(stdout) {
-  const session = stdout.match(/Current session:\s*(\d+(?:\.\d+)?)%\s*used/i);
-  const weekly = [...stdout.matchAll(/Current week[^:\n]*:\s*(\d+(?:\.\d+)?)%\s*used/gi)];
+  const text = normalizeUsageText(stdout);
+  const session = text.match(/Current session[^%\n]*?(\d+(?:\.\d+)?)\s*%(?:\s*used)?/i);
+  const weekly = [...text.matchAll(/Current week[^%\n]*?(\d+(?:\.\d+)?)\s*%(?:\s*used)?/gi)];
   return {
     sessionUsage: session ? Number(session[1]) / 100 : null,
     weeklyUsage: weekly.length ? Math.max(...weekly.map((m) => Number(m[1]))) / 100 : null
@@ -9661,54 +9626,116 @@ function parseUsageGauges(stdout) {
 }
 
 // src/usage/run-probe.ts
-import { spawn } from "child_process";
-var PROBE_TIMEOUT_MS = 15e3;
+var PROBE_TIMEOUT_MS = 3e4;
+var FIRST_SEND_MS = 5e3;
+var RESEND_INTERVAL_MS = 4e3;
+var MAX_SENDS = 5;
+var RENDER_SETTLE_MS = 900;
 function buildProbeEnv(env = process.env) {
-  const { CLAUDE_CODE_OAUTH_TOKEN: _oauth, ANTHROPIC_API_KEY: _apiKey, ...rest } = env;
-  return rest;
-}
-function runUsageProbe(binary = resolveClaudeBinary(), args = ["-p", "/usage"]) {
+  const clean = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") clean[key] = value;
+  }
+  delete clean.CLAUDE_CODE_OAUTH_TOKEN;
+  delete clean.ANTHROPIC_API_KEY;
+  return clean;
+}
+function panelRendering(buf) {
+  return /Current session/i.test(buf) && /%/.test(buf);
+}
+var UsageProbeRun = class {
+  constructor(resolve, timing) {
+    this.resolve = resolve;
+    this.timing = timing;
+  }
+  resolve;
+  timing;
+  buf = "";
+  settled = false;
+  sends = 0;
+  child = null;
+  hardTimer = null;
+  resendTimer = null;
+  settleTimer = null;
+  start(child, timeoutMs) {
+    this.child = child;
+    child.onData((data) => this.onData(data));
+    child.onExit(() => this.finishBestEffort());
+    this.hardTimer = setTimeout(() => this.finishBestEffort(), timeoutMs);
+    this.hardTimer.unref?.();
+    const first = setTimeout(() => this.trySend(), this.timing.firstSendMs);
+    first.unref?.();
+    this.resendTimer = setInterval(() => this.trySend(), this.timing.resendIntervalMs);
+    this.resendTimer.unref?.();
+  }
+  trySend() {
+    if (this.settled || this.sends >= MAX_SENDS) return;
+    this.sends += 1;
+    try {
+      this.child?.write("/usage\r");
+    } catch {
+    }
+  }
+  onData(chunk) {
+    this.buf += chunk;
+    if (this.settleTimer || !panelRendering(this.buf)) return;
+    this.settleTimer = setTimeout(() => this.finish(this.buf), this.timing.settleMs);
+  }
+  finishBestEffort() {
+    this.finish(panelRendering(this.buf) ? this.buf : "");
+  }
+  finish(out) {
+    if (this.settled) return;
+    this.settled = true;
+    if (this.hardTimer) clearTimeout(this.hardTimer);
+    if (this.resendTimer) clearInterval(this.resendTimer);
+    if (this.settleTimer) clearTimeout(this.settleTimer);
+    try {
+      this.child?.kill();
+    } catch {
+    }
+    this.resolve(out);
+  }
+};
+async function runUsageProbe(deps = {}) {
+  let spawn2 = deps.spawn;
+  if (!spawn2) {
+    try {
+      spawn2 = await loadPtySpawn();
+    } catch {
+      return "";
+    }
+  }
+  const binary = deps.binary ?? resolveClaudeBinary();
+  const cwd = deps.cwd ?? process.cwd();
+  const timeoutMs = deps.timeoutMs ?? PROBE_TIMEOUT_MS;
+  const timing = {
+    firstSendMs: deps.firstSendMs ?? FIRST_SEND_MS,
+    resendIntervalMs: deps.resendIntervalMs ?? RESEND_INTERVAL_MS,
+    settleMs: deps.settleMs ?? RENDER_SETTLE_MS
+  };
   return new Promise((resolve) => {
-    let stdout = "";
-    let settled = false;
-    const finish = (out) => {
-      if (settled) return;
-      settled = true;
-      resolve(out);
-    };
     let child;
     try {
-      child = spawn(binary, args, { stdio: ["ignore", "pipe", "ignore"], env: buildProbeEnv() });
+      child = spawn2(binary, [], {
+        name: "xterm-256color",
+        cols: 120,
+        rows: 45,
+        cwd,
+        env: buildProbeEnv()
+      });
     } catch {
-      finish("");
+      resolve("");
       return;
     }
-    const timer = setTimeout(() => {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-      finish("");
-    }, PROBE_TIMEOUT_MS);
-    timer.unref?.();
-    child.stdout?.on("data", (d) => {
-      stdout += d.toString();
-    });
-    child.on("error", () => {
-      clearTimeout(timer);
-      finish("");
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      finish(code === 0 ? stdout : "");
-    });
+    new UsageProbeRun(resolve, timing).start(child, timeoutMs);
   });
 }
 
 // src/execution/usage-sampler.ts
 var logger4 = createServiceLogger("usage-sampler");
-async function sampleKeyUsage(token, probe = runUsageProbe) {
-  if (!token) return [];
+async function sampleKeyUsage(token, probe = () => runUsageProbe(), hasSubscriptionCredentials = () => existsSync3(claudeCredentialsPath())) {
+  if (!token && !hasSubscriptionCredentials()) return [];
   try {
     const stdout = await probe();
     const { sessionUsage, weeklyUsage } = parseUsageGauges(stdout);
@@ -9734,6 +9761,76 @@ async function sampleKeyUsage(token, probe = runUsageProbe) {
   }
 }
 
+// src/setup/git-ready.ts
+import { access, stat as stat5 } from "fs/promises";
+var DEFAULT_FAILED_PATH = "/workspaces/.conveyor-git-failed";
+var DEFAULT_TIMEOUT_MS = 6e5;
+var DEFAULT_POLL_MS = 200;
+async function fileExists(path4) {
+  try {
+    await access(path4);
+    const s = await stat5(path4);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+function awaitGitReady(opts = {}) {
+  if (opts.signal?.aborted) return Promise.reject(abortError());
+  const markerPath = opts.markerPath ?? process.env.CONVEYOR_GIT_READY_MARKER;
+  if (!markerPath) {
+    return Promise.resolve("not-gated");
+  }
+  const failedPath = opts.failedPath ?? process.env.CONVEYOR_GIT_FAILED_MARKER ?? DEFAULT_FAILED_PATH;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const pollMs = opts.pollMs ?? DEFAULT_POLL_MS;
+  opts.onLog?.(`waiting for workspace git (marker=${markerPath})`);
+  return pollForMarkers(markerPath, failedPath, timeoutMs, pollMs, opts.onLog, opts.signal);
+}
+function abortError() {
+  const error = new Error("Operation aborted");
+  error.name = "AbortError";
+  return error;
+}
+function abortableDelay(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+  if (signal.aborted) return Promise.reject(abortError());
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function pollForMarkers(markerPath, failedPath, timeoutMs, pollMs, onLog, signal) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    if (signal?.aborted) throw abortError();
+    if (await fileExists(markerPath)) {
+      onLog?.("workspace git ready");
+      return "ready";
+    }
+    if (await fileExists(failedPath)) {
+      onLog?.("workspace git preparation failed (marker present)");
+      return "failed";
+    }
+    if (Date.now() >= deadline) {
+      onLog?.(`workspace git not ready after ${timeoutMs}ms \u2014 giving up`);
+      return "timeout";
+    }
+    await abortableDelay(pollMs, signal);
+  }
+}
+
 // src/runner/port-discovery.ts
 import { readFile as readFile4 } from "fs/promises";
 import { execFile as execFile3 } from "child_process";
@@ -9847,6 +9944,7 @@ var PortDiscovery = class {
   timer = null;
   ticking = false;
   disabled = false;
+  stopped = false;
   /** Set when the confirmed set changed (or a report failed) — cleared only
    *  after a successful report, so transient RPC failures retry next tick. */
   reportPending = false;
@@ -9864,8 +9962,9 @@ var PortDiscovery = class {
   }
   /** Take the baseline scan and start polling. Safe to call once. */
   async start() {
-    if (this.timer || this.disabled) return;
+    if (this.timer || this.disabled || this.stopped) return;
     const baseline = await this.scanSafe();
+    if (this.stopped) return;
     if (baseline === null) {
       this.disabled = true;
       this.log("Port discovery disabled: no listening-socket source available");
@@ -9876,6 +9975,7 @@ var PortDiscovery = class {
     this.timer.unref?.();
   }
   stop() {
+    this.stopped = true;
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
@@ -10071,13 +10171,16 @@ var SessionRunner = class _SessionRunner {
   /** Max consecutive gate-deferred ticks (~2 min each) before flushing anyway. */
   static MAX_GATE_SKIPS = 10;
   /** Runtime preview-port poller (v3 dynamic port discovery). */
-  portDiscovery = null;
+  portDiscovery;
   /** Main event-loop lag measurement, shared with the heartbeat worker. */
   loopLag = new LoopLagMonitor();
-  constructor(config, callbacks) {
+  constructor(config, callbacks, deps = {}) {
     this.config = config;
     this.callbacks = callbacks;
     this.connection = new AgentConnection(config.connection);
+    this.portDiscovery = deps.portDiscovery ?? new PortDiscovery({
+      report: (ports) => this.connection.reportDiscoveredPorts(ports)
+    });
     const initialMode = config.agentMode ?? (config.runnerMode === "pm" ? config.isAuto ? "auto" : "discovery" : "building");
     this.mode = new ModeController(initialMode, config.runnerMode, config.isAuto);
     const lifecycleConfig = { ...DEFAULT_LIFECYCLE_CONFIG, ...config.lifecycle };
@@ -10142,16 +10245,18 @@ var SessionRunner = class _SessionRunner {
         this.pendingMessages.push({ content: msg.content, userId: msg.userId });
       }
     }
-    this.portDiscovery = new PortDiscovery({
-      report: (ports) => this.connection.reportDiscoveredPorts(ports)
-    });
-    void this.portDiscovery.start().catch(() => {
-    });
+    if (this.stopped) return false;
+    try {
+      await this.portDiscovery.start();
+    } catch {
+    }
+    if (this.stopped) return false;
     const agentVersion = readAgentVersion();
     if (agentVersion) {
       this.connection.call("notifyAgentVersion", { sessionId: this.sessionId, agentVersion }).catch(() => {
       });
     }
+    return true;
   }
   /**
    * Run the main agent lifecycle: fetch context, resolve mode, execute, loop.
@@ -10267,7 +10372,7 @@ var SessionRunner = class _SessionRunner {
   }
   /** Convenience wrapper: connect() then run(). */
   async start() {
-    await this.connect();
+    if (!await this.connect()) return;
     await this.run();
   }
   // ── Core loop ──────────────────────────────────────────────────────
@@ -10661,7 +10766,7 @@ var SessionRunner = class _SessionRunner {
     this.queryBridge?.stop();
     void this.queryBridge?.dispose().catch(() => {
     });
-    this.portDiscovery?.stop();
+    this.portDiscovery.stop();
     this.loopLag.stop();
     this.lifecycle.destroy();
     this.connection.disconnect();
@@ -10873,7 +10978,7 @@ var SessionRunner = class _SessionRunner {
     process.stderr.write(`[conveyor-agent] Shutdown: reason=${finalState}
 `);
     this.connection.sendEvent({ type: "shutdown", reason: finalState });
-    this.portDiscovery?.stop();
+    this.portDiscovery.stop();
     this.loopLag.stop();
     this.lifecycle.destroy();
     try {
@@ -10971,29 +11076,84 @@ function loadConveyorConfig() {
 }
 
 // src/setup/commands.ts
-import { spawn as spawn2, execSync } from "child_process";
-function runSetupCommand(cmd, cwd, onOutput) {
+import { spawn, execSync } from "child_process";
+var PROCESS_TERMINATION_GRACE_MS = 5e3;
+function abortError2() {
+  const error = new Error("Operation aborted");
+  error.name = "AbortError";
+  return error;
+}
+function signalProcessGroup(child, signal) {
+  try {
+    if (child.pid) process.kill(-child.pid, signal);
+    else child.kill(signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  }
+}
+function terminateProcessGroup(child, graceMs = PROCESS_TERMINATION_GRACE_MS) {
+  if (child.exitCode !== null) return Promise.resolve();
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.removeListener("exit", finish);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signalProcessGroup(child, "SIGKILL");
+      finish();
+    }, graceMs);
+    timer.unref();
+    child.once("exit", finish);
+    signalProcessGroup(child, "SIGTERM");
+  });
+}
+function runSetupCommand(cmd, cwd, onOutput, signal) {
+  if (signal?.aborted) return Promise.reject(abortError2());
   return new Promise((resolve, reject) => {
-    const child = spawn2("sh", ["-c", cmd], {
+    const child = spawn("sh", ["-c", cmd], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
       env: { ...process.env }
     });
+    let settled = false;
+    let aborting = false;
+    const cleanup = () => signal?.removeEventListener("abort", onAbort);
+    const settle = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error) reject(error);
+      else resolve();
+    };
+    const onAbort = () => {
+      if (settled || aborting) return;
+      aborting = true;
+      void terminateProcessGroup(child).then(() => settle(abortError2()));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
     child.stdout.on("data", (chunk) => {
+      if (aborting || signal?.aborted) return;
       onOutput("stdout", chunk.toString());
     });
     child.stderr.on("data", (chunk) => {
+      if (aborting || signal?.aborted) return;
       onOutput("stderr", chunk.toString());
     });
     child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Setup command exited with code ${code}`));
-      }
+      if (aborting) return;
+      settle(code === 0 ? void 0 : new Error(`Setup command exited with code ${code}`));
     });
     child.on("error", (err) => {
-      reject(err);
+      if (!aborting) settle(err);
     });
   });
 }
@@ -11013,7 +11173,7 @@ function runAuthTokenCommand(cmd, userEmail, cwd) {
   }
 }
 function runStartCommand(cmd, cwd, onOutput) {
-  const child = spawn2("sh", ["-c", cmd], {
+  const child = spawn("sh", ["-c", cmd], {
     cwd,
     stdio: ["ignore", "pipe", "pipe"],
     detached: true,
@@ -11070,6 +11230,7 @@ export {
   resolveSessionStart,
   sampleKeyUsage,
   awaitGitReady,
+  PortDiscovery,
   uploadSnapshotToGcs,
   captureSnapshot,
   startPeriodic,
@@ -11080,9 +11241,10 @@ export {
   loadForwardPorts,
   buildSessionPreviewPorts,
   loadConveyorConfig,
+  terminateProcessGroup,
   runSetupCommand,
   runAuthTokenCommand,
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-UOHROQ6A.js.map
+//# sourceMappingURL=chunk-CWTQXS34.js.map