remote-codex 0.11.20 → 0.11.22

package/apps/supervisor-api/dist/index.js

@@ -11,7 +11,7 @@ import fs27 from "fs";
 import Fastify from "fastify";
 import multipart from "@fastify/multipart";
 import websocket from "@fastify/websocket";
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import fs26 from "fs";
 import path28 from "path";
 import { ZodError } from "zod";
@@ -11658,7 +11658,8 @@ var DEFAULT_CLAUDE_MODELS = [
       { reasoningEffort: "low", description: "Low effort" },
       { reasoningEffort: "medium", description: "Medium effort" },
       { reasoningEffort: "high", description: "High effort" },
-      { reasoningEffort: "xhigh", description: "Extra high effort" }
+      { reasoningEffort: "xhigh", description: "Extra high effort" },
+      { reasoningEffort: "max", description: "Maximum effort" }
     ],
     defaultReasoningEffort: "medium"
   },
@@ -11673,7 +11674,24 @@ var DEFAULT_CLAUDE_MODELS = [
       { reasoningEffort: "low", description: "Low effort" },
       { reasoningEffort: "medium", description: "Medium effort" },
       { reasoningEffort: "high", description: "High effort" },
-      { reasoningEffort: "xhigh", description: "Extra high effort" }
+      { reasoningEffort: "xhigh", description: "Extra high effort" },
+      { reasoningEffort: "max", description: "Maximum effort" }
+    ],
+    defaultReasoningEffort: "medium"
+  },
+  {
+    id: "fable",
+    model: "fable",
+    displayName: "Claude Fable",
+    description: "Claude Code Fable model alias.",
+    isDefault: false,
+    hidden: false,
+    supportedReasoningEfforts: [
+      { reasoningEffort: "low", description: "Low effort" },
+      { reasoningEffort: "medium", description: "Medium effort" },
+      { reasoningEffort: "high", description: "High effort" },
+      { reasoningEffort: "xhigh", description: "Extra high effort" },
+      { reasoningEffort: "max", description: "Maximum effort" }
     ],
     defaultReasoningEffort: "medium"
   },
@@ -11688,7 +11706,8 @@ var DEFAULT_CLAUDE_MODELS = [
       { reasoningEffort: "low", description: "Low effort" },
       { reasoningEffort: "medium", description: "Medium effort" },
       { reasoningEffort: "high", description: "High effort" },
-      { reasoningEffort: "xhigh", description: "Extra high effort" }
+      { reasoningEffort: "xhigh", description: "Extra high effort" },
+      { reasoningEffort: "max", description: "Maximum effort" }
     ],
     defaultReasoningEffort: "medium"
   },
@@ -11737,7 +11756,7 @@ function mapModelInfo(model, index) {
     isDefault: index === 0,
     hidden: false,
     supportedReasoningEfforts: (model.supportedEffortLevels ?? []).map((effort) => ({
-      reasoningEffort: effort === "max" ? "xhigh" : effort,
+      reasoningEffort: effort,
       description: `${effort} effort`
     })),
     defaultReasoningEffort: model.supportsEffort ? "medium" : null
@@ -11747,6 +11766,7 @@ function withClaudeCodeModelAliases(models) {
   const output = [...models];
   const defaultSonnet = DEFAULT_CLAUDE_MODELS[0];
   const oneMillionSonnet = DEFAULT_CLAUDE_MODELS[1];
+  const fable = DEFAULT_CLAUDE_MODELS[2];
   const hasSonnetAlias = output.some((model) => model.model === "sonnet");
   if (!hasSonnetAlias) {
     output.unshift(defaultSonnet);
@@ -11754,6 +11774,9 @@ function withClaudeCodeModelAliases(models) {
   if (!output.some((model) => model.model === "sonnet[1m]")) {
     output.splice(1, 0, oneMillionSonnet);
   }
+  if (!output.some((model) => model.model === "fable")) {
+    output.splice(2, 0, fable);
+  }
   return output.map((model, index) => ({
     ...model,
     isDefault: index === 0
@@ -12112,7 +12135,7 @@ function queryOptionsForRuntime(input) {
     options.betas = ["context-1m-2025-08-07"];
   }
   if (input.reasoningEffort) {
-    const effort = input.reasoningEffort === "xhigh" ? "max" : input.reasoningEffort;
+    const effort = input.reasoningEffort;
     if (["low", "medium", "high", "xhigh", "max"].includes(effort)) {
       options.effort = effort;
     }
@@ -16814,6 +16837,13 @@ var ThreadLiveStateStore = class {
     const visibleTurnIds = new Set(visibleTurns.map((turn) => turn.id));
     return visibleTurnIds.has(reconciled.turnId) ? reconciled : null;
   }
+  getLiveItemsForTurn(localThreadId, turnId) {
+    if (!turnId) {
+      return null;
+    }
+    const current = this.threadLiveItems.get(localThreadId);
+    return current?.turnId === turnId ? current : null;
+  }
   upsertLiveItem(localThreadId, turnId, item) {
     const current = this.threadLiveItems.get(localThreadId);
     const currentItems = current?.turnId === turnId ? current.items : [];
@@ -17386,12 +17416,20 @@ var ThreadRuntimeEventProjector = class {
           lastError: null,
           lastTurnStartedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
+        liveState.setLiveItems(record.id, null);
         liveState.resetRecordedTurnItemOrder(record.id, turnId);
         for (const item of event.turn.items) {
-          liveState.recordTurnItemOrder(record.id, turnId, item.id);
+          const sequence = liveState.recordTurnItemOrder(record.id, turnId, item.id);
+          const eventTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const orderedLiveItem = {
+            ...withHistoryItemCreatedAt(item, eventTimestamp),
+            sequence
+          };
+          const transportLiveItem = deferHistoryItemDetailForTransport(orderedLiveItem);
+          callbacks.persistLiveHistoryItem(record.id, turnId, orderedLiveItem);
+          liveState.upsertLiveItem(record.id, turnId, transportLiveItem);
         }
         liveState.setLivePlan(record.id, null);
-        liveState.setLiveItems(record.id, null);
         if (shouldResetThreadContextUsageForTurnStart(callbacks.getThreadContextUsage(record.id))) {
           callbacks.resetThreadContextUsage(record.id, true);
         }
@@ -17529,6 +17567,7 @@ var ThreadRuntimeEventProjector = class {
           sequence,
           createdAt
         });
+        callbacks.invalidateThreadDetailCache(record.id);
         callbacks.emitThreadEvent("thread.output.delta", record.id, {
           turnId: displayTurnId,
           itemId: event.itemId,
@@ -18068,14 +18107,23 @@ var ThreadDetailAssembler = class {
     if (remoteSession.turns.length > 0 && remoteSession.turns.every((turn) => turn.items.length === 0)) {
       remoteSession = await this.input.callbacks.resumeRemoteSession(input.record);
     }
-    this.input.callbacks.updateThreadRecord(
-      input.record.id,
-      this.input.callbacks.buildThreadPatch(
-        remoteSession,
-        input.record.model,
-        input.record.reasoningEffort
-      )
+    const threadPatch = this.input.callbacks.buildThreadPatch(
+      remoteSession,
+      input.record.model,
+      input.record.reasoningEffort
     );
+    const activeDisplayTurnId = this.input.liveState.displayTurnIdForRuntimeTurn(
+      input.localThreadId,
+      input.record.providerTurnId
+    ) ?? input.record.providerTurnId;
+    const activeLiveItems = this.input.liveState.getLiveItemsForTurn(
+      input.localThreadId,
+      activeDisplayTurnId
+    );
+    if (input.record.providerTurnId && threadPatch.status === "idle" && activeLiveItems && activeLiveItems.items.length > 0) {
+      threadPatch.status = "running";
+    }
+    this.input.callbacks.updateThreadRecord(input.record.id, threadPatch);
     const updated = this.input.callbacks.getUpdatedThreadRecord(input.record.id);
     this.input.callbacks.syncAfterRemoteSession(updated.id, remoteSession);
     const deferredDetails = /* @__PURE__ */ new Map();
@@ -18091,9 +18139,16 @@ var ThreadDetailAssembler = class {
       remoteSession.turns
     );
     const visibleTurns = this.input.liveState.visibleRemoteTurns(input.localThreadId, remoteSession.turns).map((turn) => agentTurnToThreadTurnDto(turn, deferredDetails));
-    const orderedVisibleTurns = applyLiveAgentMessageOrderingHints(
+    const visibleTurnsWithActiveLiveTurn = appendActiveLiveTurnIfMissing(
       visibleTurns,
       input.localThreadId,
+      updated.providerTurnId,
+      this.input.liveState,
+      input.turnMetadataById
+    );
+    const orderedVisibleTurns = applyLiveAgentMessageOrderingHints(
+      visibleTurnsWithActiveLiveTurn,
+      input.localThreadId,
       this.input.liveState
     );
     const resolvedTurnMetadataById = resolveTurnMetadataByVisibleTurnId(
@@ -18223,6 +18278,26 @@ function applyLiveAgentMessageOrderingHints(turns, localThreadId, liveState) {
     } : turn;
   });
 }
+function appendActiveLiveTurnIfMissing(turns, localThreadId, providerTurnId, liveState, metadataById) {
+  const displayTurnId = liveState.displayTurnIdForRuntimeTurn(localThreadId, providerTurnId) ?? providerTurnId;
+  if (!displayTurnId || turns.some((turn) => turn.id === displayTurnId)) {
+    return turns;
+  }
+  const liveItems = liveState.getLiveItemsForTurn(localThreadId, displayTurnId);
+  if (!liveItems || liveItems.items.length === 0) {
+    return turns;
+  }
+  return [
+    ...turns,
+    {
+      id: displayTurnId,
+      startedAt: metadataById.get(displayTurnId)?.createdAt ?? null,
+      status: "inProgress",
+      error: null,
+      items: sortHistoryItemsBySequence(liveItems.items)
+    }
+  ];
+}
 function buildTurnDto(turn, metadata) {
   const tokenUsage = parseThreadTurnTokenUsageJson(metadata?.tokenUsageJson);
   const displayPrompt = metadata?.displayPrompt?.trim();
@@ -18321,6 +18396,7 @@ function normalizeReasoningEffort(value) {
     case "medium":
     case "high":
     case "xhigh":
+    case "max":
       return value;
     default:
       return null;
@@ -18336,6 +18412,7 @@ function normalizeReasoningEffort2(value) {
     case "medium":
     case "high":
     case "xhigh":
+    case "max":
       return value;
     default:
       return null;
@@ -18764,7 +18841,6 @@ var ThreadPromptTurnCoordinator = class {
     }
     updateThreadRecord(this.db, localThreadId, patch);
     this.liveState.setLivePlan(localThreadId, null);
-    this.liveState.setLiveItems(localThreadId, null);
     if (shouldResetThreadContextUsageForTurnStart(
       this.callbacks.getThreadContextUsage(localThreadId)
     )) {
@@ -19460,27 +19536,41 @@ var ThreadDeletionCoordinator = class {
 };
 
 // src/exports/thread-pdf-export.ts
-import { spawn as spawn2 } from "child_process";
 import fs11 from "fs";
-import os3 from "os";
+import { createRequire as createRequire3 } from "module";
 import path15 from "path";
-import { pathToFileURL as pathToFileURL3 } from "url";
 import puppeteer from "puppeteer-core";
 import { marked } from "marked";
 var MAX_TEXT_CHARS = 12e3;
 var MAX_COMMAND_OUTPUT_CHARS = 2400;
 var MAX_DETAIL_LINES = 8;
-var EXPORT_FONT_FAMILY = '"Segoe UI", "RemoteCodexCJK", "Microsoft YaHei", "DengXian", "SimSun", "Noto Sans CJK SC", "Noto Sans CJK", "DejaVu Sans", Arial, sans-serif';
-var EXPORT_MONO_FONT_FAMILY = '"SFMono-Regular", Consolas, "Liberation Mono", "DejaVu Sans Mono", "RemoteCodexCJK", monospace';
+var EXPORT_FONT_FAMILY = '"Noto Sans", "Noto Sans SC", "Segoe UI", "RemoteCodexCJK", "Microsoft YaHei", "DengXian", "SimSun", "Noto Sans CJK SC", "Noto Sans CJK", "DejaVu Sans", Arial, sans-serif';
+var EXPORT_MONO_FONT_FAMILY = '"SFMono-Regular", Consolas, "Liberation Mono", "DejaVu Sans Mono", "Noto Sans SC", "RemoteCodexCJK", monospace';
 var EMBEDDED_CJK_FONT_CANDIDATES = [
+  { path: "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc", format: "truetype", weight: 400 },
+  { path: "/usr/share/fonts/opentype/noto/NotoSansCJKsc-Regular.otf", format: "opentype", weight: 400 },
+  { path: "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc", format: "truetype", weight: 400 },
+  { path: "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc", format: "truetype", weight: 400 },
+  { path: "/System/Library/Fonts/PingFang.ttc", format: "truetype", weight: 400 },
+  { path: "/System/Library/Fonts/Supplemental/Arial Unicode.ttf", format: "truetype", weight: 400 },
   { path: "/mnt/c/Windows/Fonts/simhei.ttf", format: "truetype", weight: 400 },
   { path: "/mnt/c/Windows/Fonts/Deng.ttf", format: "truetype", weight: 400 },
   { path: "/mnt/c/Windows/Fonts/msyh.ttc", format: "truetype", weight: 400 }
 ];
+var BUNDLED_LATIN_FONT_CSS_FILES = [
+  { packageName: "@fontsource/noto-sans", cssFile: "latin-400.css" },
+  { packageName: "@fontsource/noto-sans", cssFile: "latin-700.css" }
+];
+var BUNDLED_CJK_FONT_CSS_FILES = [
+  { packageName: "@fontsource/noto-sans-sc", cssFile: "400.css" },
+  { packageName: "@fontsource/noto-sans-sc", cssFile: "700.css" }
+];
 var PUPPETEER_CHANNEL = "chrome";
 var PDF_EXPORT_TIMEOUT_MS = 45e3;
-var MAX_CHROME_STDERR_CHARS = 4e3;
-var embeddedCjkFontCss = null;
+var require2 = createRequire3(import.meta.url);
+var embeddedSystemCjkFontCss = null;
+var packageRootCache = /* @__PURE__ */ new Map();
+var fontFaceBlockCache = /* @__PURE__ */ new Map();
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
@@ -19489,21 +19579,21 @@ marked.use({
   breaks: true,
   gfm: true
 });
-function renderEmbeddedCjkFontCss() {
+function renderEmbeddedSystemCjkFontCss() {
   if (process.env.NODE_ENV === "test" || process.env.VITEST) {
     return "";
   }
-  if (embeddedCjkFontCss !== null) {
-    return embeddedCjkFontCss;
+  if (embeddedSystemCjkFontCss !== null) {
+    return embeddedSystemCjkFontCss;
   }
-  embeddedCjkFontCss = "";
+  embeddedSystemCjkFontCss = "";
   for (const candidate of EMBEDDED_CJK_FONT_CANDIDATES) {
     try {
       if (!fs11.existsSync(candidate.path)) {
         continue;
       }
       const font = fs11.readFileSync(candidate.path);
-      embeddedCjkFontCss = `
+      embeddedSystemCjkFontCss = `
       @font-face {
         font-family: "RemoteCodexCJK";
         src: url("data:font/${candidate.format};base64,${font.toString("base64")}") format("${candidate.format}");
@@ -19512,10 +19602,123 @@ function renderEmbeddedCjkFontCss() {
       }`;
       break;
     } catch {
-      embeddedCjkFontCss = "";
+      embeddedSystemCjkFontCss = "";
+    }
+  }
+  return embeddedSystemCjkFontCss;
+}
+function renderPdfEmbeddedFontCss(snapshot) {
+  if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+    return "";
+  }
+  const usedCodePoints = collectSnapshotCodePoints(snapshot);
+  const latinCss = BUNDLED_LATIN_FONT_CSS_FILES.flatMap((source) => renderBundledFontCss(source));
+  const cjkCss = BUNDLED_CJK_FONT_CSS_FILES.flatMap((source) => renderBundledFontCss(source, usedCodePoints));
+  const bundledCss = [...latinCss, ...cjkCss].join("\n");
+  const needsCjkFallback = containsCjkCodePoint(usedCodePoints) && cjkCss.length === 0;
+  return [bundledCss, needsCjkFallback ? renderEmbeddedSystemCjkFontCss() : ""].filter(Boolean).join("\n");
+}
+function collectSnapshotCodePoints(snapshot) {
+  const values = [
+    snapshot.thread.title,
+    snapshot.workspace.label,
+    snapshot.workspace.absPath,
+    snapshot.thread.model ?? "",
+    snapshot.exportedAt,
+    ...snapshot.turns.flatMap((turn) => [
+      turn.error ?? "",
+      turn.status,
+      turn.startedAt,
+      ...turn.items.flatMap((item) => [
+        item.text ?? "",
+        item.previewText ?? "",
+        item.detailText ?? "",
+        item.status ?? ""
+      ])
+    ])
+  ].filter((value) => typeof value === "string");
+  const codePoints = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    for (const character of value) {
+      codePoints.add(character.codePointAt(0));
+    }
+  }
+  return codePoints;
+}
+function containsCjkCodePoint(codePoints) {
+  for (const codePoint of codePoints) {
+    if (codePoint >= 13312 && codePoint <= 40959 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 131072 && codePoint <= 195103) {
+      return true;
     }
   }
-  return embeddedCjkFontCss;
+  return false;
+}
+function renderBundledFontCss(source, usedCodePoints) {
+  const packageRoot = resolvePackageRoot3(source.packageName);
+  const cssPath = path15.join(packageRoot, source.cssFile);
+  const blocks = getFontFaceBlocks(cssPath);
+  return blocks.filter((block) => !usedCodePoints || fontFaceIntersects(block.ranges, usedCodePoints)).map((block) => inlineFontFaceBlock(block, packageRoot)).filter(Boolean);
+}
+function resolvePackageRoot3(packageName) {
+  const cached = packageRootCache.get(packageName);
+  if (cached) {
+    return cached;
+  }
+  const packageRoot = path15.dirname(require2.resolve(`${packageName}/package.json`));
+  packageRootCache.set(packageName, packageRoot);
+  return packageRoot;
+}
+function getFontFaceBlocks(cssPath) {
+  const cached = fontFaceBlockCache.get(cssPath);
+  if (cached) {
+    return cached;
+  }
+  const css = fs11.readFileSync(cssPath, "utf8");
+  const blocks = Array.from(css.matchAll(/@font-face\s*{[\s\S]*?}/g)).map((match) => {
+    const block = match[0];
+    const fontPath = block.match(/url\((['"]?)(\.\/files\/[^)'"]+\.woff2)\1\)\s*format\((['"]?)woff2\3\)/)?.[2] ?? "";
+    return {
+      block,
+      fontPath,
+      ranges: parseUnicodeRanges(block.match(/unicode-range:\s*([^;]+);/)?.[1])
+    };
+  }).filter((block) => block.fontPath);
+  fontFaceBlockCache.set(cssPath, blocks);
+  return blocks;
+}
+function parseUnicodeRanges(value) {
+  if (!value) {
+    return [{ start: 0, end: 1114111 }];
+  }
+  return value.split(",").flatMap((part) => {
+    const match = part.trim().match(/^U\+([0-9a-f?]+)(?:-([0-9a-f]+))?$/i);
+    if (!match) {
+      return [];
+    }
+    const startText = match[1].replace(/\?/g, "0");
+    const endText = match[2] ?? match[1].replace(/\?/g, "F");
+    return [{
+      start: Number.parseInt(startText, 16),
+      end: Number.parseInt(endText, 16)
+    }];
+  });
+}
+function fontFaceIntersects(ranges, usedCodePoints) {
+  for (const codePoint of usedCodePoints) {
+    if (ranges.some((range) => codePoint >= range.start && codePoint <= range.end)) {
+      return true;
+    }
+  }
+  return false;
+}
+function inlineFontFaceBlock(block, packageRoot) {
+  const fontPath = path15.join(packageRoot, block.fontPath);
+  try {
+    const font = fs11.readFileSync(fontPath);
+    return block.block.replace(/font-display:\s*swap;/g, "font-display: block;").replace(/src:\s*[^;]+;/, `src: url("data:font/woff2;base64,${font.toString("base64")}") format("woff2");`);
+  } catch {
+    return "";
+  }
 }
 function formatDateTime(value) {
   if (!value) {
@@ -19878,7 +20081,7 @@ function totalPrice(snapshot) {
     0
   );
 }
-function renderThreadExportHtml(snapshot) {
+function renderThreadExportHtml(snapshot, options = {}) {
   const turnNumbers = snapshot.turns.map((turn) => snapshot.selectedTurnNumbers.get(turn.id)).filter((value) => typeof value === "number");
   const sortedTurnNumbers = [...turnNumbers].sort((left, right) => left - right);
   const isContiguous = sortedTurnNumbers.length > 1 && sortedTurnNumbers.every((value, index) => index === 0 || value === sortedTurnNumbers[index - 1] + 1);
@@ -19892,7 +20095,7 @@ function renderThreadExportHtml(snapshot) {
     <meta charset="utf-8" />
     <title>${escapeHtml(snapshot.thread.title)} transcript</title>
     <style>
-      ${renderEmbeddedCjkFontCss()}
+      ${options.embedFonts ? renderPdfEmbeddedFontCss(snapshot) : ""}
       @page { margin: 0.46in 0.45in 0.5in; }
       * { box-sizing: border-box; }
       body {
@@ -20179,7 +20382,6 @@ function renderThreadExportStandaloneHtml(snapshot) {
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>${escapeHtml(snapshot.thread.title)} transcript</title>
     <style>
-      ${renderEmbeddedCjkFontCss()}
       :root {
         color-scheme: light;
         --page: rgb(244 239 231);
@@ -20506,7 +20708,7 @@ endobj
 `
     );
   }
-  return renderPdfWithChromeCli(renderThreadExportHtml(snapshot));
+  return renderPdfWithChrome(renderThreadExportHtml(snapshot, { embedFonts: true }));
 }
 function resolvePdfBrowserExecutablePath() {
   try {
@@ -20522,88 +20724,52 @@ function resolvePdfBrowserExecutablePath() {
     );
   }
 }
-async function renderPdfWithChromeCli(html) {
+async function renderPdfWithChrome(html) {
   const executablePath = resolvePdfBrowserExecutablePath();
-  const tempDir = await fs11.promises.mkdtemp(path15.join(os3.tmpdir(), "remote-codex-pdf-"));
-  const htmlPath = path15.join(tempDir, "thread-export.html");
-  const pdfPath = path15.join(tempDir, "thread-export.pdf");
+  const browser = await puppeteer.launch({
+    executablePath,
+    headless: true,
+    timeout: PDF_EXPORT_TIMEOUT_MS,
+    args: [
+      "--disable-gpu",
+      "--disable-dev-shm-usage",
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      "--font-render-hinting=none"
+    ]
+  });
   try {
-    await fs11.promises.writeFile(htmlPath, html, "utf8");
-    await printHtmlToPdf({
-      executablePath,
-      htmlPath,
-      pdfPath
+    const page = await browser.newPage();
+    page.setDefaultTimeout(PDF_EXPORT_TIMEOUT_MS);
+    await page.setContent(html, {
+      waitUntil: "load",
+      timeout: PDF_EXPORT_TIMEOUT_MS
+    });
+    await page.evaluate(async () => {
+      const fonts = document.fonts;
+      if (fonts?.ready) {
+        await fonts.ready;
+      }
     });
-    const pdf = await fs11.promises.readFile(pdfPath);
+    const pdf = Buffer.from(await page.pdf({
+      format: "Letter",
+      margin: {
+        top: "0px",
+        right: "0px",
+        bottom: "0px",
+        left: "0px"
+      },
+      preferCSSPageSize: true,
+      printBackground: true,
+      timeout: PDF_EXPORT_TIMEOUT_MS
+    }));
     if (pdf.length === 0 || !pdf.subarray(0, 4).equals(Buffer.from("%PDF"))) {
       throw new Error("Chrome did not produce a valid PDF file.");
     }
     return pdf;
   } finally {
-    await fs11.promises.rm(tempDir, { force: true, recursive: true });
-  }
-}
-async function printHtmlToPdf(input) {
-  const args = [
-    "--headless",
-    "--disable-gpu",
-    "--disable-dev-shm-usage",
-    "--no-sandbox",
-    "--disable-setuid-sandbox",
-    "--font-render-hinting=none",
-    "--no-pdf-header-footer",
-    "--print-to-pdf-no-header",
-    `--print-to-pdf=${input.pdfPath}`,
-    pathToFileURL3(input.htmlPath).href
-  ];
-  await new Promise((resolve, reject) => {
-    const child = spawn2(input.executablePath, args, {
-      stdio: ["ignore", "ignore", "pipe"]
-    });
-    let settled = false;
-    let stderr = "";
-    const complete = (error) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timeout);
-      child.kill("SIGTERM");
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    };
-    const timeout = setTimeout(() => {
-      child.kill("SIGKILL");
-      complete(new Error(`Chrome PDF export timed out after ${PDF_EXPORT_TIMEOUT_MS}ms.`));
-    }, PDF_EXPORT_TIMEOUT_MS);
-    child.stderr.on("data", (chunk) => {
-      stderr = truncateChromeStderr(`${stderr}${chunk.toString("utf8")}`);
-      if (stderr.includes("bytes written to file")) {
-        complete();
-      }
-    });
-    child.on("error", (error) => {
-      complete(error);
-    });
-    child.on("close", (code, signal) => {
-      if (code === 0) {
-        complete();
-        return;
-      }
-      const reason = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
-      const detail = stderr ? ` ${stderr}` : "";
-      complete(new Error(`Chrome PDF export failed with ${reason}.${detail}`));
-    });
-  });
-}
-function truncateChromeStderr(value) {
-  if (value.length <= MAX_CHROME_STDERR_CHARS) {
-    return value;
+    await browser.close();
   }
-  return value.slice(value.length - MAX_CHROME_STDERR_CHARS);
 }
 
 // src/thread-turn-metadata.ts
@@ -20963,33 +21129,22 @@ async function resolveComparablePath2(absPath) {
   const resolvedParent = await resolveComparablePath2(parentPath);
   return path17.join(resolvedParent, path17.basename(resolved));
 }
-async function resolveImportedWorkspacePath(workspaceRoot, candidatePath) {
+async function resolveImportedWorkspacePath(candidatePath) {
   if (!path17.isAbsolute(candidatePath)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Imported session path must be absolute."
     });
   }
-  const resolvedRoot = await resolveComparablePath2(workspaceRoot);
-  const resolvedCandidate = await resolveComparablePath2(candidatePath);
-  const normalizedRoot = resolvedRoot.endsWith(path17.sep) ? resolvedRoot : `${resolvedRoot}${path17.sep}`;
-  if (resolvedCandidate !== resolvedRoot && !resolvedCandidate.startsWith(normalizedRoot)) {
-    throw new HttpError(403, {
-      code: "forbidden",
-      message: "Imported session path must stay within the configured workspace root."
-    });
-  }
-  return resolvedCandidate;
+  return resolveComparablePath2(candidatePath);
 }
 var ThreadImportCoordinator = class {
-  constructor(db, sessionCoordinator, workspaceRoot) {
+  constructor(db, sessionCoordinator, _workspaceRoot) {
     this.db = db;
     this.sessionCoordinator = sessionCoordinator;
-    this.workspaceRoot = workspaceRoot;
   }
   db;
   sessionCoordinator;
-  workspaceRoot;
   async importLocalThread(input) {
     const normalizedSessionId = input.sessionId.trim();
     if (!normalizedSessionId) {
@@ -21017,10 +21172,7 @@ var ThreadImportCoordinator = class {
         message: "Session not found on this machine."
       });
     }
-    const importedPath = await resolveImportedWorkspacePath(
-      this.workspaceRoot,
-      importSession.cwd
-    );
+    const importedPath = await resolveImportedWorkspacePath(importSession.cwd);
     let workspace = getWorkspaceRecordByPath(this.db, importedPath);
     if (!workspace) {
       workspace = createWorkspaceRecord(this.db, {
@@ -22247,7 +22399,7 @@ var ThreadService = class {
 
 // src/routes/agent-runtimes.ts
 import fs15 from "fs/promises";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import path18 from "path";
 import { fileURLToPath } from "url";
 import { z as z3 } from "zod";
@@ -22594,7 +22746,7 @@ function commandFailureMessage(command, result) {
 }
 function runShellCommand(command, timeoutMs = 0) {
   return new Promise((resolve) => {
-    const child = spawn3(command, {
+    const child = spawn2(command, {
       shell: true,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -22894,19 +23046,28 @@ async function registerSystemRoutes(app2) {
 import fs16 from "fs/promises";
 import path19 from "path";
 import { z as z5 } from "zod";
+var reasoningEffortValues = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
 var createThreadSchema = z5.object({
   workspaceId: z5.string().uuid(),
   title: z5.string().optional(),
   provider: agentBackendIdSchema.optional(),
   model: z5.string().min(1),
-  reasoningEffort: z5.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).nullable().optional(),
+  reasoningEffort: z5.enum(reasoningEffortValues).nullable().optional(),
   approvalMode: z5.enum(["yolo", "guarded"]).default("yolo")
 });
 var promptSchema = z5.object({
   prompt: z5.string().min(1),
   clientRequestId: z5.string().min(1).optional(),
   model: z5.string().min(1).optional(),
-  reasoningEffort: z5.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).nullable().optional(),
+  reasoningEffort: z5.enum(reasoningEffortValues).nullable().optional(),
   collaborationMode: z5.enum(["default", "plan"]).optional()
 });
 var promptAttachmentManifestEntrySchema = z5.object({
@@ -22920,7 +23081,7 @@ var updateThreadSchema = z5.object({
 });
 var updateThreadSettingsSchema = z5.object({
   model: z5.string().min(1).optional(),
-  reasoningEffort: z5.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).nullable().optional(),
+  reasoningEffort: z5.enum(reasoningEffortValues).nullable().optional(),
   fastMode: z5.boolean().optional(),
   collaborationMode: z5.enum(["default", "plan"]).optional()
 }).refine((body) => Object.keys(body).length > 0, {
@@ -23588,9 +23749,9 @@ async function deleteWorkspaceArtifact(record, artifactId) {
 }
 
 // src/workspace-file-service.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import fs18 from "fs/promises";
-import os4 from "os";
+import os3 from "os";
 import path21 from "path";
 var PREVIEW_DEFAULT_LIMIT_BYTES = 5e4;
 var WORKSPACE_UPLOAD_MAX_BYTES = 50 * 1024 * 1024;
@@ -23909,7 +24070,7 @@ async function createFolderZipFile(rootPath, folderPath) {
   endRecord.writeUInt32LE(centralSize, 12);
   endRecord.writeUInt32LE(offset, 16);
   endRecord.writeUInt16LE(0, 20);
-  const tempDir = await fs18.mkdtemp(path21.join(os4.tmpdir(), "remote-codex-folder-download-"));
+  const tempDir = await fs18.mkdtemp(path21.join(os3.tmpdir(), "remote-codex-folder-download-"));
   const zipPath = path21.join(tempDir, `${path21.basename(folderPath) || "workspace-folder"}.zip`);
   await fs18.writeFile(zipPath, Buffer.concat([...localParts, ...centralParts, endRecord]));
   return { zipPath, tempDir };
@@ -23954,7 +24115,7 @@ async function pathExists4(absPath) {
 }
 function cloneRepository(gitUrl, targetPath) {
   return new Promise((resolve, reject) => {
-    const child = spawn4("git", ["clone", gitUrl, targetPath], {
+    const child = spawn3("git", ["clone", gitUrl, targetPath], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     let stderr = "";
@@ -24822,7 +24983,7 @@ import fs22 from "fs/promises";
 
 // src/shell/shell-prompt.ts
 import fs21 from "fs/promises";
-import os5 from "os";
+import os4 from "os";
 import path24 from "path";
 function basenameFromPath2(filePath) {
   if (!filePath) {
@@ -24994,7 +25155,7 @@ async function ensureShellPromptInitScript(command) {
   const normalized = command.trim().toLowerCase();
   const extension = normalized === "zsh" ? "zsh" : "sh";
   const filePath = path24.join(
-    os5.tmpdir(),
+    os4.tmpdir(),
     `remote-codex-shell-prompt.${extension}`
   );
   await fs21.writeFile(filePath, buildShellPromptInitScriptContents(command), "utf8");
@@ -26154,7 +26315,7 @@ var BackendPluginHost = class {
 
 // src/shell/pty-shell-backend.ts
 import path26 from "path";
-import { spawn as spawn5 } from "@homebridge/node-pty-prebuilt-multiarch";
+import { spawn as spawn4 } from "@homebridge/node-pty-prebuilt-multiarch";
 
 // src/shell/default-shell.ts
 import fs24 from "fs";
@@ -26223,7 +26384,7 @@ var PtyShellBackend = class {
     if (this.sessions.has(input.sessionId)) {
       return;
     }
-    const pty = spawn5(this.shell, shellArgs(this.shell), {
+    const pty = spawn4(this.shell, shellArgs(this.shell), {
       name: "xterm-256color",
       cwd: input.cwd,
       cols: input.cols ?? 120,
@@ -27509,7 +27670,7 @@ function createServiceLifecycle() {
           message: "Build and restart requires a Remote Codex source checkout. Set REMOTE_CODEX_REPO_ROOT to the checkout path, or update the npm package with npm install -g remote-codex@latest."
         });
       }
-      const child = spawn6(process.execPath, [restartScript, "launch"], {
+      const child = spawn5(process.execPath, [restartScript, "launch"], {
         cwd: repoRoot,
         detached: true,
         env: process.env,