@say8425/cc-statusline 3.1.0 → 3.2.0

package/dist/index.js

@@ -19,41 +19,29 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/diff-server/config.ts
 import { homedir } from "os";
 import { join } from "path";
-function resolveDiffPort(env = process.env) {
+var DEFAULT_DIFF_PORT = 49573, resolveDiffPort = (env = process.env) => {
   const raw = env.CC_STATUSLINE_DIFF_PORT;
   if (!raw)
     return DEFAULT_DIFF_PORT;
   const n = Number.parseInt(raw, 10);
   return Number.isInteger(n) && n > 0 && n < 65536 ? n : DEFAULT_DIFF_PORT;
-}
-function isDiffViewerDisabled(env = process.env) {
-  return env.CC_STATUSLINE_DIFF_DISABLE === "1";
-}
-function getCacheDir(env = process.env) {
+}, isDiffViewerDisabled = (env = process.env) => env.CC_STATUSLINE_DIFF_DISABLE === "1", getCacheDir = (env = process.env) => {
   const base = env.XDG_CACHE_HOME || join(env.HOME || homedir(), ".cache");
   return join(base, "cc-statusline");
-}
-var DEFAULT_DIFF_PORT = 49573;
+};
 var init_config = () => {};
 
 // src/diff-server/token.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join as join2 } from "path";
-function getTokenPath(env = process.env) {
-  return join2(getCacheDir(env), "diff-server.token");
-}
-function generateToken() {
-  return crypto.randomUUID().replaceAll("-", "");
-}
-function readTokenSync(env = process.env) {
+var getTokenPath = (env = process.env) => join2(getCacheDir(env), "diff-server.token"), generateToken = () => crypto.randomUUID().replaceAll("-", ""), readTokenSync = (env = process.env) => {
   try {
     const value = readFileSync(getTokenPath(env), "utf8").trim();
     return value || null;
   } catch {
     return null;
   }
-}
-function ensureToken(env = process.env) {
+}, ensureToken = (env = process.env) => {
   const existing = readTokenSync(env);
   if (existing)
     return existing;
@@ -61,36 +49,49 @@ function ensureToken(env = process.env) {
   mkdirSync(getCacheDir(env), { recursive: true, mode: 448 });
   writeFileSync(getTokenPath(env), token, { mode: 384 });
   return token;
-}
+};
 var init_token = __esm(() => {
   init_config();
 });
 
+// src/diff-server/mapLimit.ts
+var mapWithLimit = async (items, limit, fn) => {
+  const results = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      results[index] = await fn(items[index], index);
+    }
+  };
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, () => worker());
+  await Promise.all(workers);
+  return results;
+};
+
 // src/diff-server/diff.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { isAbsolute, join as join4, resolve } from "path";
 var {$ } = globalThis.Bun;
-async function isGitRepo(repo) {
+var BUILD_CONCURRENCY = 8, isGitRepo = async (repo) => {
   try {
     const out = await $`git -C ${repo} rev-parse --is-inside-work-tree 2>/dev/null`.text();
     return out.trim() === "true";
   } catch {
     return false;
   }
-}
-async function refExists(repo, ref) {
+}, refExists = async (repo, ref) => {
   const r = await $`git -C ${repo} rev-parse --verify --quiet ${ref}`.nothrow().quiet();
   return r.exitCode === 0;
-}
-async function prBaseName(repo) {
+}, prBaseName = async (repo) => {
   try {
     const out = await $`gh pr view --json baseRefName -q .baseRefName`.cwd(repo).nothrow().quiet().text();
     return out.trim() || null;
   } catch {
     return null;
   }
-}
-async function defaultBranchName(repo) {
+}, defaultBranchName = async (repo) => {
   const r = await $`git -C ${repo} rev-parse --abbrev-ref origin/HEAD 2>/dev/null`.nothrow().quiet();
   if (r.exitCode !== 0)
     return null;
@@ -99,8 +100,7 @@ async function defaultBranchName(repo) {
     return null;
   const name = t.slice("origin/".length);
   return name && name !== "HEAD" ? name : null;
-}
-async function resolveBaseRef(repo) {
+}, resolveBaseRef = async (repo) => {
   const named = await prBaseName(repo) ?? await defaultBranchName(repo);
   const candidates = named ? [`origin/${named}`, named] : ["origin/main", "origin/master", "main", "master"];
   for (const ref of candidates) {
@@ -110,19 +110,16 @@ async function resolveBaseRef(repo) {
     }
   }
   return { base: named, ref: null };
-}
-async function showBytes(repo, rev, path) {
+}, showBytes = async (repo, rev, path) => {
   const buf = await $`git -C ${repo} show ${`${rev}:${path}`} 2>/dev/null`.nothrow().arrayBuffer();
   return new Uint8Array(buf);
-}
-function readWorkingBytes(repo, path) {
+}, readWorkingBytes = (repo, path) => {
   try {
     return new Uint8Array(readFileSync2(join4(repo, path)));
   } catch {
     return new Uint8Array;
   }
-}
-async function buildFile(repo, base, status, name, oldName) {
+}, buildFile = async (repo, base, status, name, oldName) => {
   const oldBytes = status === "added" || status === "untracked" ? new Uint8Array : await showBytes(repo, base, oldName ?? name);
   const newBytes = status === "deleted" ? new Uint8Array : readWorkingBytes(repo, name);
   const binary = oldBytes.includes(0) || newBytes.includes(0);
@@ -133,14 +130,32 @@ async function buildFile(repo, base, status, name, oldName) {
     status,
     binary,
     oldContents: binary ? "" : decoder.decode(oldBytes),
-    newContents: binary ? "" : decoder.decode(newBytes)
+    newContents: binary ? "" : decoder.decode(newBytes),
+    ...binary ? {
+      blobVersion: `${Bun.hash(oldBytes).toString(36)}.${Bun.hash(newBytes).toString(36)}`
+    } : {}
   };
-}
-async function getDiffFiles(repo, opts = {}) {
-  const base = opts.mode === "base" && opts.ref ? (await $`git -C ${repo} merge-base ${opts.ref} HEAD 2>/dev/null`.nothrow().text()).trim() : "HEAD";
+}, resolveDiffBaseRev = async (repo, opts) => opts.mode === "base" && opts.ref ? (await $`git -C ${repo} merge-base ${opts.ref} HEAD 2>/dev/null`.nothrow().text()).trim() : "HEAD", getFileBytes = async (repo, path, side, opts = {}) => {
+  const root = resolve(repo);
+  const target = resolve(root, path);
+  if (!path || isAbsolute(path) || target !== root && !target.startsWith(`${root}/`)) {
+    return null;
+  }
+  if (side === "new") {
+    const bytes2 = readWorkingBytes(repo, path);
+    return bytes2.length > 0 ? bytes2 : null;
+  }
+  const base = await resolveDiffBaseRev(repo, opts);
+  if (!base)
+    return null;
+  const bytes = await showBytes(repo, base, path);
+  return bytes.length > 0 ? bytes : null;
+}, getDiffFiles = async (repo, opts = {}) => {
+  const base = await resolveDiffBaseRev(repo, opts);
   const files = [];
   if (base) {
     const nameStatus = await $`git -C ${repo} diff --name-status ${base} 2>/dev/null`.nothrow().text();
+    const specs = [];
     for (const line of nameStatus.split(`
 `)) {
       if (!line.trim())
@@ -148,34 +163,64 @@ async function getDiffFiles(repo, opts = {}) {
       const parts = line.split("\t");
       const code = parts[0] ?? "";
       if (code.startsWith("R")) {
-        files.push(await buildFile(repo, base, "renamed", parts[2] ?? "", parts[1]));
+        specs.push({
+          status: "renamed",
+          name: parts[2] ?? "",
+          oldName: parts[1]
+        });
       } else if (code.startsWith("A")) {
-        files.push(await buildFile(repo, base, "added", parts[1] ?? ""));
+        specs.push({ status: "added", name: parts[1] ?? "" });
       } else if (code.startsWith("D")) {
-        files.push(await buildFile(repo, base, "deleted", parts[1] ?? ""));
+        specs.push({ status: "deleted", name: parts[1] ?? "" });
       } else {
-        files.push(await buildFile(repo, base, "modified", parts[1] ?? ""));
+        specs.push({ status: "modified", name: parts[1] ?? "" });
       }
     }
+    files.push(...await mapWithLimit(specs, BUILD_CONCURRENCY, (spec) => buildFile(repo, base, spec.status, spec.name, spec.oldName)));
   }
   if (opts.untracked) {
     const listed = await $`git -C ${repo} ls-files --others --exclude-standard 2>/dev/null`.nothrow().text();
-    for (const path of listed.split(`
-`).map((s) => s.trim()).filter(Boolean)) {
-      files.push(await buildFile(repo, base, "untracked", path));
-    }
+    const paths = listed.split(`
+`).map((s) => s.trim()).filter(Boolean);
+    files.push(...await mapWithLimit(paths, BUILD_CONCURRENCY, (path) => buildFile(repo, base, "untracked", path)));
   }
   return files;
-}
+};
 var init_diff = () => {};
 
+// src/diff-server/imageTypes.ts
+var IMAGE_MIME, extensionOf = (name) => {
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0 || dot === name.length - 1)
+    return null;
+  return name.slice(dot + 1).toLowerCase();
+}, isImagePath = (name) => {
+  const ext = extensionOf(name);
+  return ext !== null && ext in IMAGE_MIME;
+}, imageContentType = (name) => {
+  const ext = extensionOf(name);
+  return ext && IMAGE_MIME[ext] || "application/octet-stream";
+};
+var init_imageTypes = __esm(() => {
+  IMAGE_MIME = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    avif: "image/avif",
+    bmp: "image/bmp",
+    ico: "image/x-icon"
+  };
+});
+
 // src/diff-server/server.ts
 var exports_server = {};
 __export(exports_server, {
   startDiffServer: () => startDiffServer
 });
-import { resolve } from "path";
-async function resolveBaseCached(repo) {
+import { resolve as resolve2 } from "path";
+var BASE_TTL_MS = 1e4, baseCache, resolveBaseCached = async (repo) => {
   const now = Date.now();
   const hit = baseCache.get(repo);
   if (hit && now - hit.at < BASE_TTL_MS)
@@ -183,9 +228,8 @@ async function resolveBaseCached(repo) {
   const value = await resolveBaseRef(repo);
   baseCache.set(repo, { value, at: now });
   return value;
-}
-function createHandler(cfg) {
-  const viewerRoot = resolve(cfg.viewerDir);
+}, createHandler = (cfg) => {
+  const viewerRoot = resolve2(cfg.viewerDir);
   return async (req) => {
     const url = new URL(req.url);
     if (url.pathname === "/api/ping") {
@@ -217,8 +261,33 @@ function createHandler(cfg) {
         }
       });
     }
+    if (url.pathname === "/api/blob") {
+      if (url.searchParams.get("token") !== cfg.token) {
+        return new Response("forbidden", { status: 403 });
+      }
+      const repo = url.searchParams.get("repo") ?? "";
+      if (!repo || !await isGitRepo(repo)) {
+        return new Response("not a git repository", { status: 400 });
+      }
+      const path = url.searchParams.get("path") ?? "";
+      if (!isImagePath(path)) {
+        return new Response("not found", { status: 404 });
+      }
+      const side = url.searchParams.get("side") === "old" ? "old" : "new";
+      const mode = url.searchParams.get("mode") === "base" ? "base" : "working";
+      const ref = mode === "base" ? (await resolveBaseCached(repo)).ref : null;
+      const bytes = await getFileBytes(repo, path, side, mode === "base" && ref ? { mode, ref } : {});
+      if (!bytes)
+        return new Response("not found", { status: 404 });
+      return new Response(bytes, {
+        headers: {
+          "content-type": imageContentType(path),
+          "cache-control": "no-store"
+        }
+      });
+    }
     const rel = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const filePath = resolve(viewerRoot, rel);
+    const filePath = resolve2(viewerRoot, rel);
     if (filePath !== viewerRoot && !filePath.startsWith(`${viewerRoot}/`)) {
       return new Response("forbidden", { status: 403 });
     }
@@ -228,8 +297,7 @@ function createHandler(cfg) {
     }
     return new Response("not found", { status: 404 });
   };
-}
-function startDiffServer(opts) {
+}, startDiffServer = (opts) => {
   const env = opts.env ?? process.env;
   const token = ensureToken(env);
   let lastActivity = Date.now();
@@ -253,23 +321,23 @@ function startDiffServer(opts) {
     }, 60000);
     idleTimer.unref?.();
   }
-  function stop() {
+  const stop = () => {
     if (idleTimer)
       clearInterval(idleTimer);
     server.stop(true);
-  }
+  };
   return { server, token, stop };
-}
-var BASE_TTL_MS = 1e4, baseCache;
+};
 var init_server = __esm(() => {
   init_diff();
+  init_imageTypes();
   init_token();
   baseCache = new Map;
 });
 
 // src/index.ts
 init_config();
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/diff-server/ensure.ts
 init_config();
@@ -279,7 +347,7 @@ import { join as join3 } from "path";
 var ENSURE_TTL_MS = 5000;
 var LOCK_STALE_MS = 30000;
 var checkedAt = 0;
-async function probeOurServer(port) {
+var probeOurServer = async (port) => {
   try {
     const res = await fetch(`http://127.0.0.1:${port}/api/ping`, {
       signal: AbortSignal.timeout(150)
@@ -288,8 +356,8 @@ async function probeOurServer(port) {
   } catch {
     return false;
   }
-}
-function acquireSpawnLock(env) {
+};
+var acquireSpawnLock = (env) => {
   const lock = join3(getCacheDir(env), "diff-server.lock");
   mkdirSync2(getCacheDir(env), { recursive: true, mode: 448 });
   try {
@@ -305,8 +373,8 @@ function acquireSpawnLock(env) {
     } catch {}
     return false;
   }
-}
-function spawnDaemon(port, env) {
+};
+var spawnDaemon = (port, env) => {
   const execPath = process.execPath;
   const selfPath = Bun.main;
   Bun.spawn([
@@ -321,8 +389,8 @@ function spawnDaemon(port, env) {
     stdout: "ignore",
     stderr: "ignore"
   }).unref();
-}
-async function maybeSpawn(port, env, spawn = spawnDaemon) {
+};
+var maybeSpawn = async (port, env, spawn = spawnDaemon) => {
   try {
     if (await probeOurServer(port))
       return;
@@ -330,8 +398,8 @@ async function maybeSpawn(port, env, spawn = spawnDaemon) {
       return;
     spawn(port, env);
   } catch {}
-}
-async function ensureDiffServer(_repo, env = process.env, spawn = spawnDaemon) {
+};
+var ensureDiffServer = (_repo, env = process.env, spawn = spawnDaemon) => {
   if (isDiffViewerDisabled(env))
     return null;
   const port = resolveDiffPort(env);
@@ -342,10 +410,10 @@ async function ensureDiffServer(_repo, env = process.env, spawn = spawnDaemon) {
   }
   const token = readTokenSync(env);
   return token ? { port, token } : null;
-}
+};
 
 // src/diff-server/link.ts
-function buildDiffViewerUrl(params) {
+var buildDiffViewerUrl = (params) => {
   const query = new URLSearchParams({
     repo: params.repo,
     token: params.token
@@ -353,7 +421,7 @@ function buildDiffViewerUrl(params) {
   if (params.mode)
     query.set("mode", params.mode);
   return `http://127.0.0.1:${params.port}/?${query.toString()}`;
-}
+};
 
 // src/git/baseChanges.ts
 var {$: $2 } = globalThis.Bun;
@@ -367,31 +435,33 @@ var cache = {
   baseRef: {
     value: null,
     timestamp: 0
-  }
+  },
+  ultracode: { value: false, timestamp: 0 }
 };
 var CACHE_TTL = {
   branch: 5000,
   gitChanges: 0,
   prUrl: 30000,
   mainProjectName: 300000,
-  baseRef: 30000
+  baseRef: 30000,
+  ultracode: 5000
 };
 
 // src/git/baseChanges.ts
 init_diff();
 
 // src/git/shortstat.ts
-function parseShortstat(text) {
+var parseShortstat = (text) => {
   const [files, insertions, deletions] = [
     /(\d+) files?/g,
     /(\d+) insertions?/g,
     /(\d+) deletions?/g
   ].map((regex) => (text.match(regex) || []).reduce((sum, m) => sum + Number.parseInt(m, 10), 0));
   return { files, insertions, deletions };
-}
+};
 
 // src/git/baseChanges.ts
-async function getBaseChangesCached() {
+var getBaseChangesCached = async () => {
   try {
     let resolved = cache.baseRef.value;
     if (resolved === null || Date.now() - cache.baseRef.timestamp >= CACHE_TTL.baseRef) {
@@ -411,10 +481,10 @@ async function getBaseChangesCached() {
   } catch {
     return null;
   }
-}
+};
 // src/git/branch.ts
 var {$: $3 } = globalThis.Bun;
-async function getBranchCached() {
+var getBranchCached = async () => {
   if (Date.now() - cache.branch.timestamp < CACHE_TTL.branch) {
     return cache.branch.value;
   }
@@ -425,10 +495,10 @@ async function getBranchCached() {
   } catch {
     return cache.branch.value;
   }
-}
+};
 // src/git/changes.ts
 var {$: $4 } = globalThis.Bun;
-async function getGitChangesCached() {
+var getGitChangesCached = async () => {
   if (Date.now() - cache.gitChanges.timestamp < CACHE_TTL.gitChanges) {
     return cache.gitChanges;
   }
@@ -444,10 +514,10 @@ ${staged}`);
   } catch {
     return cache.gitChanges;
   }
-}
+};
 // src/git/pr.ts
 var {$: $5 } = globalThis.Bun;
-async function getPrUrlCached() {
+var getPrUrlCached = async () => {
   if (Date.now() - cache.prUrl.timestamp < CACHE_TTL.prUrl) {
     return cache.prUrl.value;
   }
@@ -458,10 +528,10 @@ async function getPrUrlCached() {
   } catch {
     return cache.prUrl.value;
   }
-}
+};
 // src/git/worktree.ts
 var {$: $6 } = globalThis.Bun;
-async function getMainProjectNameCached() {
+var getMainProjectNameCached = async () => {
   if (Date.now() - cache.mainProjectName.timestamp < CACHE_TTL.mainProjectName) {
     return cache.mainProjectName.value;
   }
@@ -479,7 +549,7 @@ async function getMainProjectNameCached() {
   } catch {
     return cache.mainProjectName.value;
   }
-}
+};
 // src/colors.ts
 var C = {
   RESET: "\x1B[0m",
@@ -492,32 +562,28 @@ var C = {
   WHITE: "\x1B[38;2;200;200;200m",
   UNDERLINE: "\x1B[4m"
 };
-function getUsageColor(pct) {
+var getUsageColor = (pct) => {
   if (pct < 50)
     return C.WHITE;
   if (pct < 80)
     return C.YELLOW;
   return C.RED;
-}
+};
 
 // src/format/formatNumber.ts
-function formatNumber(n) {
-  return n.toLocaleString("en-US");
-}
+var formatNumber = (n) => n.toLocaleString("en-US");
 // src/format/formatResetDate.ts
-function formatResetDate(date) {
+var formatResetDate = (date) => {
   const month = (date.getMonth() + 1).toString().padStart(2, "0");
   const day = date.getDate().toString().padStart(2, "0");
   const hours = date.getHours().toString().padStart(2, "0");
   const minutes = date.getMinutes().toString().padStart(2, "0");
   return `${month}/${day} ${hours}:${minutes}`;
-}
+};
 // src/format/formatTime.ts
-function formatTime(hours, mins) {
-  return `${hours.toString().padStart(2, "0")}:${mins.toString().padStart(2, "0")}`;
-}
+var formatTime = (hours, mins) => `${hours.toString().padStart(2, "0")}:${mins.toString().padStart(2, "0")}`;
 // src/render.ts
-function renderStatusLine(ctx) {
+var renderStatusLine = (ctx) => {
   const lines = [];
   const folder = ctx.claudeJson.workspace?.project_dir?.split("/").pop() || "";
   const sessionMs = ctx.claudeJson.cost?.total_duration_ms || 0;
@@ -544,6 +610,14 @@ function renderStatusLine(ctx) {
     const ctxColor = getUsageColor(contextPct);
     line2 += ` | ${ctxColor}\uD83E\uDDE0 ${formatNumber(totalTokens)} (${contextPct}%)${C.RESET}`;
   }
+  const modelName = ctx.claudeJson.model?.display_name;
+  if (modelName) {
+    const effortLevel = ctx.claudeJson.effort?.level;
+    let modelText = effortLevel ? `${modelName} ${effortLevel}` : modelName;
+    if (ctx.ultracode && effortLevel === "xhigh")
+      modelText += " \u26A1ultra";
+    line2 += ` | ${C.WHITE}\uD83E\uDD16 ${modelText}${C.RESET}`;
+  }
   lines.push(line2);
   if (ctx.rateLimits) {
     const parts = [];
@@ -593,27 +667,64 @@ function renderStatusLine(ctx) {
     lines.push(line4);
   }
   return lines;
-}
+};
 
 // src/stdin.ts
-async function readStdin() {
+var readStdin = async () => {
   const chunks = [];
   for await (const chunk of Bun.stdin.stream()) {
     chunks.push(chunk);
   }
   return Buffer.concat(chunks).toString("utf-8");
-}
+};
+
+// src/ultracode.ts
+import { readFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
+var MANAGED_SETTINGS_PATH = process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : process.platform === "win32" ? join5(process.env.ProgramData || "C:\\ProgramData", "ClaudeCode", "managed-settings.json") : "/etc/claude-code/managed-settings.json";
+var ultracodeSettingsPaths = (projectDir, homeDir) => {
+  const paths = [MANAGED_SETTINGS_PATH];
+  if (projectDir) {
+    paths.push(join5(projectDir, ".claude", "settings.local.json"), join5(projectDir, ".claude", "settings.json"));
+  }
+  paths.push(join5(homeDir, ".claude", "settings.json"));
+  return paths;
+};
+var resolveUltracodeFromFiles = async (paths) => {
+  const contents = await Promise.all(paths.map((path) => readFile(path, "utf8").catch(() => null)));
+  for (const content of contents) {
+    if (content === null)
+      continue;
+    try {
+      const parsed = JSON.parse(content);
+      if (typeof parsed === "object" && parsed !== null && "ultracode" in parsed && typeof parsed.ultracode === "boolean") {
+        return parsed.ultracode;
+      }
+    } catch {}
+  }
+  return false;
+};
+var getUltracodeCached = async (projectDir, homeDir = homedir2()) => {
+  if (Date.now() - cache.ultracode.timestamp < CACHE_TTL.ultracode) {
+    return cache.ultracode.value;
+  }
+  const value = await resolveUltracodeFromFiles(ultracodeSettingsPaths(projectDir, homeDir));
+  cache.ultracode = { value, timestamp: Date.now() };
+  return value;
+};
 
 // src/index.ts
-async function main() {
+var main = async () => {
   const claudeJson = JSON.parse(await readStdin() || "{}");
-  const [branch, gitChanges, prUrl, mainProjectName] = await Promise.all([
+  const repo = claudeJson.workspace?.project_dir || claudeJson.workspace?.current_dir || "";
+  const [branch, gitChanges, prUrl, mainProjectName, ultracode] = await Promise.all([
     getBranchCached(),
     getGitChangesCached(),
     getPrUrlCached(),
-    getMainProjectNameCached()
+    getMainProjectNameCached(),
+    getUltracodeCached(repo)
   ]);
-  const repo = claudeJson.workspace?.project_dir || claudeJson.workspace?.current_dir || "";
   const hasChanges = gitChanges.files > 0 || gitChanges.insertions > 0 || gitChanges.deletions > 0;
   let diffViewerUrl = null;
   let baseDiffViewerUrl = null;
@@ -622,7 +733,7 @@ async function main() {
     baseChanges = await getBaseChangesCached();
   }
   if (repo && (hasChanges || baseChanges)) {
-    const ensured = await ensureDiffServer(repo);
+    const ensured = ensureDiffServer(repo);
     if (ensured) {
       if (hasChanges) {
         diffViewerUrl = buildDiffViewerUrl({
@@ -646,6 +757,7 @@ async function main() {
     branch,
     gitChanges,
     prUrl,
+    ultracode,
     rateLimits: claudeJson.rate_limits ?? null,
     mainProjectName,
     diffViewerUrl,
@@ -655,13 +767,13 @@ async function main() {
   for (const line of lines) {
     console.log(line);
   }
-}
+};
 if (import.meta.main) {
   if (process.argv.includes("--diff-server")) {
     const { startDiffServer: startDiffServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
     startDiffServer2({
       port: resolveDiffPort(),
-      viewerDir: join5(import.meta.dir, "viewer")
+      viewerDir: join6(import.meta.dir, "viewer")
     });
   } else {
     main().catch(console.error);