@rallycry/conveyor-agent 10.7.2 → 10.7.4

package/dist/{chunk-DDDLYATP.js → chunk-WJWMLZKR.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,
@@ -1937,6 +1891,7 @@ async function restoreOnBoot(bundle, cwd) {
 import { z } from "zod";
 import { z as z2 } from "zod";
 var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
+var FABLE_MODEL = "claude-fable-5";
 var TUI_KINDS = ["claude-code", "opencode"];
 var MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024;
 var EMBED_THRESHOLD_IMAGES = 5 * 1024 * 1024;
@@ -2502,7 +2457,7 @@ var ListMyLiveSessionsRequestSchema = z2.object({
   /** Admin-only: list another member's sessions instead of the caller's. */
   targetUserId: z2.string().optional()
 });
-var ListActiveSessionUsersRequestSchema = z2.object({
+var ListProjectSessionGroupsRequestSchema = z2.object({
   projectId: z2.string()
 });
 var GetProjectAvailableTuisRequestSchema = z2.object({
@@ -4239,7 +4194,50 @@ function seedWorkspaceTrust(config, trustCwd) {
   config.projects = projects;
   return true;
 }
-function planClaudeJsonSeed(existingRaw, trustCwd) {
+var FABLE_MODEL_OPTION = {
+  value: `${FABLE_MODEL}[1m]`,
+  label: "Fable",
+  description: "Fable 5 - most capable for your hardest and longest-running tasks"
+};
+function seedFableModelOption(config) {
+  const cache = Array.isArray(config.additionalModelOptionsCache) ? config.additionalModelOptionsCache : [];
+  const hasFable = cache.some((entry) => {
+    if (typeof entry !== "object" || entry === null) return false;
+    const value = entry.value;
+    return typeof value === "string" && value.toLowerCase().includes("fable");
+  });
+  if (hasFable) return false;
+  config.additionalModelOptionsCache = [...cache, { ...FABLE_MODEL_OPTION }];
+  return true;
+}
+function normalizeOauthIdentity(record) {
+  const organizationUuid = typeof record.organizationUuid === "string" && record.organizationUuid !== "" ? record.organizationUuid : void 0;
+  const accountUuid = typeof record.accountUuid === "string" && record.accountUuid !== "" ? record.accountUuid : void 0;
+  if (!organizationUuid && !accountUuid) return null;
+  return { organizationUuid, accountUuid };
+}
+function extractOauthIdentity(config) {
+  return normalizeOauthIdentity(asRecord(config.oauthAccount));
+}
+function seedFableConsent(config, fallbackIdentity) {
+  const identity = extractOauthIdentity(config) ?? fallbackIdentity;
+  if (!identity) return false;
+  const consent = asRecord(config.fableOverageConsentV2);
+  let changed = false;
+  const keys = [
+    ...identity.organizationUuid ? [identity.organizationUuid] : [],
+    ...identity.accountUuid ? [`acct:${identity.accountUuid}`] : []
+  ];
+  for (const key of keys) {
+    if (consent[key] !== true) {
+      consent[key] = true;
+      changed = true;
+    }
+  }
+  if (changed) config.fableOverageConsentV2 = consent;
+  return changed;
+}
+function planClaudeJsonSeed(existingRaw, trustCwd, oauthIdentity) {
   const config = parseClaudeJson(existingRaw);
   const isFresh = Object.keys(config).length === 0;
   let changed = false;
@@ -4258,13 +4256,56 @@ function planClaudeJsonSeed(existingRaw, trustCwd) {
   if (trustCwd && seedWorkspaceTrust(config, trustCwd)) {
     changed = true;
   }
+  if (seedFableModelOption(config)) {
+    changed = true;
+  }
+  if (seedFableConsent(config, oauthIdentity ?? null)) {
+    changed = true;
+  }
   return changed ? JSON.stringify(config) : null;
 }
+function conveyorOauthMarkerPath() {
+  return join3(claudeConfigHome(), "conveyor-oauth-account.json");
+}
+function parseOauthIdentity(raw) {
+  if (!raw || raw.trim() === "") return null;
+  try {
+    return normalizeOauthIdentity(asRecord(JSON.parse(raw)));
+  } catch {
+    return null;
+  }
+}
+async function persistOauthIdentityMarker(configIdentity, markerIdentity) {
+  try {
+    if (!configIdentity) return;
+    if (markerIdentity !== null && markerIdentity.organizationUuid === configIdentity.organizationUuid && markerIdentity.accountUuid === configIdentity.accountUuid) {
+      return;
+    }
+    await mkdir2(claudeConfigHome(), { recursive: true });
+    const verified = await writeWithReadBackRetry(
+      fsWriteIo(conveyorOauthMarkerPath()),
+      JSON.stringify(configIdentity)
+    );
+    if (verified) {
+      process.stderr.write("[conveyor-agent] persisted oauth identity marker for fable consent\n");
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[conveyor-agent] oauth identity marker write failed: ${message}
+`);
+  }
+}
 async function ensureClaudeOnboarding(env = process.env, trustCwd) {
   try {
     if (!isConveyorCloudEnv(env)) return;
     const path4 = claudeJsonPath();
-    const contents = planClaudeJsonSeed(await readRaw(path4), trustCwd);
+    const existingRaw = await readRaw(path4);
+    const markerIdentity = parseOauthIdentity(await readRaw(conveyorOauthMarkerPath()));
+    await persistOauthIdentityMarker(
+      extractOauthIdentity(parseClaudeJson(existingRaw)),
+      markerIdentity
+    );
+    const contents = planClaudeJsonSeed(existingRaw, trustCwd, markerIdentity);
     if (contents === null) return;
     const verified = await writeWithReadBackRetry(fsWriteIo(path4), contents);
     if (verified) {
@@ -4302,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;
@@ -4401,7 +4442,7 @@ function sleep3(ms) {
 }
 async function transcriptSize(path4) {
   try {
-    return (await stat3(path4)).size;
+    return (await stat2(path4)).size;
   } catch {
     return 0;
   }
@@ -5519,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;
@@ -5593,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;
@@ -5615,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;
@@ -7219,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 = {
@@ -7246,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}`);
         }
@@ -9647,6 +9688,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";
@@ -9760,6 +9871,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;
@@ -9777,8 +9889,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");
@@ -9789,6 +9902,7 @@ var PortDiscovery = class {
     this.timer.unref?.();
   }
   stop() {
+    this.stopped = true;
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
@@ -9984,13 +10098,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 };
@@ -10055,16 +10172,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.
@@ -10180,7 +10299,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 ──────────────────────────────────────────────────────
@@ -10574,7 +10693,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();
@@ -10786,7 +10905,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 {
@@ -10885,28 +11004,83 @@ function loadConveyorConfig() {
 
 // src/setup/commands.ts
 import { spawn as spawn2, execSync } from "child_process";
-function runSetupCommand(cmd, cwd, onOutput) {
+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], {
       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);
     });
   });
 }
@@ -10983,6 +11157,7 @@ export {
   resolveSessionStart,
   sampleKeyUsage,
   awaitGitReady,
+  PortDiscovery,
   uploadSnapshotToGcs,
   captureSnapshot,
   startPeriodic,
@@ -10993,9 +11168,10 @@ export {
   loadForwardPorts,
   buildSessionPreviewPorts,
   loadConveyorConfig,
+  terminateProcessGroup,
   runSetupCommand,
   runAuthTokenCommand,
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-DDDLYATP.js.map
+//# sourceMappingURL=chunk-WJWMLZKR.js.map