@duckmind/dm-windows-x64 0.63.0 → 0.63.4

package/extensions/dm-web-access/gemini-url-context.js

@@ -0,0 +1,97 @@
+import { activityMonitor } from "./activity.js";
+import { CredentialResolutionError } from "./credential-source.js";
+import { getApiKey, getVersionedApiBase, fetchGeminiApi, isGatewayConfigured, DEFAULT_MODEL } from "./gemini-api.js";
+import { isGeminiAdcAvailable } from "./gemini-adc.js";
+import { isGeminiWebAvailable, queryWithCookies } from "./gemini-web.js";
+import { extractHeadingTitle } from "./extract.js";
+const EXTRACTION_PROMPT = `Extract the complete readable content from this URL as clean markdown.
+Include the page title, all text content, code blocks, and tables.
+Do not summarize — extract the full content.
+
+URL: `;
+function shouldRethrow(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return err instanceof CredentialResolutionError || message.startsWith("Failed to parse ");
+}
+export async function extractWithUrlContext(url, signal) {
+  const requestSignal = AbortSignal.any([
+    AbortSignal.timeout(60000),
+    ...signal ? [signal] : []
+  ]);
+  const apiKey = isGeminiAdcAvailable() ? null : await getApiKey(requestSignal);
+  if (!apiKey && !isGatewayConfigured() && !isGeminiAdcAvailable())
+    return null;
+  const activityId = activityMonitor.logStart({ type: "api", query: `url_context: ${url}` });
+  try {
+    const model = DEFAULT_MODEL;
+    const body = {
+      contents: [{ role: "user", parts: [{ text: EXTRACTION_PROMPT + url }] }],
+      tools: [{ url_context: {} }]
+    };
+    const res = await fetchGeminiApi(`${getVersionedApiBase()}/models/${model}:generateContent`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: requestSignal
+    }, apiKey);
+    if (!res.ok) {
+      activityMonitor.logComplete(activityId, res.status);
+      return null;
+    }
+    const data = await res.json();
+    activityMonitor.logComplete(activityId, res.status);
+    const metadata = data.candidates?.[0]?.url_context_metadata;
+    if (metadata?.url_metadata?.length) {
+      const status = metadata.url_metadata[0].url_retrieval_status;
+      if (status === "URL_RETRIEVAL_STATUS_UNSAFE" || status === "URL_RETRIEVAL_STATUS_ERROR") {
+        return null;
+      }
+    }
+    const content = data.candidates?.[0]?.content?.parts?.map((p) => p.text).filter(Boolean).join(`
+`) ?? "";
+    if (!content || content.length < 50)
+      return null;
+    const title = extractTitleFromContent(content, url);
+    return { url, title, content, error: null };
+  } catch (err) {
+    if (shouldRethrow(err))
+      throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.toLowerCase().includes("abort")) {
+      activityMonitor.logComplete(activityId, 0);
+    } else {
+      activityMonitor.logError(activityId, message);
+    }
+    return null;
+  }
+}
+export async function extractWithGeminiWeb(url, signal) {
+  const cookies = await isGeminiWebAvailable();
+  if (!cookies)
+    return null;
+  const activityId = activityMonitor.logStart({ type: "api", query: `gemini_web: ${url}` });
+  try {
+    const text = await queryWithCookies(EXTRACTION_PROMPT + url, cookies, {
+      signal,
+      timeoutMs: 60000
+    });
+    activityMonitor.logComplete(activityId, 200);
+    if (!text || text.length < 50)
+      return null;
+    const title = extractTitleFromContent(text, url);
+    return { url, title, content: text, error: null };
+  } catch (err) {
+    if (shouldRethrow(err))
+      throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.toLowerCase().includes("abort")) {
+      activityMonitor.logComplete(activityId, 0);
+    } else {
+      activityMonitor.logError(activityId, message);
+    }
+    return null;
+  }
+}
+function extractTitleFromContent(text, url) {
+  return extractHeadingTitle(text) ?? (new URL(url).pathname.split("/").pop() || url);
+}

package/extensions/dm-web-access/gemini-web-config.js

@@ -0,0 +1,84 @@
+import { existsSync, readFileSync } from "node:fs";
+import { getWebSearchConfigPath } from "./utils.js";
+const CONFIG_PATH = getWebSearchConfigPath();
+const BROWSER_COOKIE_PRESETS = ["helium", "chrome", "brave", "arc", "chromium", "edge"];
+let cachedConfig = null;
+export function normalizeChromeProfile(value) {
+  if (typeof value !== "string")
+    return;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : undefined;
+}
+function parseBrowserCookies(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`browserCookies in ${CONFIG_PATH} must be an object`);
+  }
+  const raw = value;
+  if ("profilePath" in raw) {
+    throw new Error(`browserCookies.profilePath is not supported; use a browser preset and profile directory name in ${CONFIG_PATH}`);
+  }
+  let browser;
+  if (raw.browser !== undefined) {
+    if (typeof raw.browser !== "string")
+      throw new Error(`browserCookies.browser in ${CONFIG_PATH} must be a supported browser name`);
+    const normalized = raw.browser.trim().toLowerCase();
+    const preset = BROWSER_COOKIE_PRESETS.find((candidate) => candidate === normalized);
+    if (!preset) {
+      throw new Error(`Unsupported browserCookies.browser ${JSON.stringify(raw.browser)} in ${CONFIG_PATH}`);
+    }
+    browser = preset;
+  }
+  if (raw.profile !== undefined && typeof raw.profile !== "string") {
+    throw new Error(`browserCookies.profile in ${CONFIG_PATH} must be a profile directory name`);
+  }
+  const profile = normalizeChromeProfile(raw.profile);
+  if (profile && (profile === "." || profile === ".." || profile.includes("/") || profile.includes("\\"))) {
+    throw new Error(`browserCookies.profile in ${CONFIG_PATH} must be a profile directory name, not a path`);
+  }
+  return { ...browser ? { browser } : {}, ...profile ? { profile } : {} };
+}
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const rawText = readFileSync(CONFIG_PATH, "utf-8");
+  let raw;
+  try {
+    raw = JSON.parse(rawText);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  if (raw.chromeProfile !== undefined) {
+    throw new Error(`chromeProfile in ${CONFIG_PATH} is no longer supported; use browserCookies.profile`);
+  }
+  cachedConfig = {
+    browserCookies: parseBrowserCookies(raw.browserCookies),
+    allowBrowserCookies: raw.allowBrowserCookies === true
+  };
+  return cachedConfig;
+}
+export function getBrowserCookieSelectionFromConfig() {
+  return { ...loadConfig().browserCookies };
+}
+export function isBrowserCookieAccessAllowed() {
+  if (process.env.DM_ALLOW_BROWSER_COOKIES === "1" || process.env.FEYNMAN_ALLOW_BROWSER_COOKIES === "1") {
+    return true;
+  }
+  if (!existsSync(CONFIG_PATH))
+    return false;
+  const rawText = readFileSync(CONFIG_PATH, "utf-8");
+  let raw;
+  try {
+    raw = JSON.parse(rawText);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  return raw.allowBrowserCookies === true;
+}

package/extensions/dm-web-access/gemini-web.js

@@ -0,0 +1,351 @@
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { getLastGoogleCookieDiagnostic, getLastGoogleCookieDiagnosticDetails, getGoogleCookies } from "./chrome-cookies.js";
+import { getBrowserCookieSelectionFromConfig, isBrowserCookieAccessAllowed, normalizeChromeProfile } from "./gemini-web-config.js";
+const GEMINI_APP_URL = "https://gemini.google.com/app";
+const GEMINI_STREAM_GENERATE_URL = "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate";
+const GEMINI_UPLOAD_URL = "https://content-push.googleapis.com/upload";
+const GEMINI_UPLOAD_PUSH_ID = "feeds/mcudyrk2a4khkz";
+const GOOGLE_LIST_ACCOUNTS_URL = "https://accounts.google.com/ListAccounts?gpsia=1&source=ChromiumBrowser&laf=b64bin&json=standard";
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+const MODEL_HEADER_NAME = "x-goog-ext-525001261-jspb";
+export const DEFAULT_GEMINI_WEB_MODEL = "gemini-3.1-pro";
+const MODEL_HEADERS = {
+  [DEFAULT_GEMINI_WEB_MODEL]: '[1,null,null,null,"9d8ca3786ebdfbea",null,null,0,[4]]',
+  "gemini-2.5-pro": '[1,null,null,null,"4af6c7f5da75d65d",null,null,0,[4]]',
+  "gemini-2.5-flash": '[1,null,null,null,"9ec249fc9ad08861",null,null,0,[4]]'
+};
+const REQUIRED_COOKIES = ["__Secure-1PSID", "__Secure-1PSIDTS"];
+let geminiFetchImpl = null;
+export function setGeminiFetchOverrideForTests(fetchImpl) {
+  geminiFetchOverride = fetchImpl;
+}
+let geminiFetchOverride = null;
+export const GEMINI_MAX_HEADER_SIZE = 4 * 1024 * 1024;
+export function createGeminiFetch(undiciImpl) {
+  const agent = new undiciImpl.EnvHttpProxyAgent({
+    allowH2: false,
+    connectTimeout: 30000,
+    maxHeaderSize: GEMINI_MAX_HEADER_SIZE,
+    pipelining: 1
+  });
+  return (input, init) => undiciImpl.fetch(input, { ...init, dispatcher: agent });
+}
+export async function resolveGeminiFetch() {
+  if (geminiFetchOverride)
+    return geminiFetchOverride;
+  if (geminiFetchImpl)
+    return geminiFetchImpl;
+  let undici;
+  try {
+    undici = await import("undici");
+  } catch {
+    geminiFetchImpl = fetch;
+    return geminiFetchImpl;
+  }
+  geminiFetchImpl = createGeminiFetch(undici);
+  return geminiFetchImpl;
+}
+export async function isGeminiWebAvailable(chromeProfile) {
+  if (!isBrowserCookieAccessAllowed())
+    return null;
+  const configured = getBrowserCookieSelectionFromConfig();
+  const result = await getGoogleCookies({
+    browser: configured.browser,
+    profile: normalizeChromeProfile(chromeProfile) ?? configured.profile,
+    requiredCookies: REQUIRED_COOKIES
+  });
+  if (!result)
+    return null;
+  return result.cookies;
+}
+export function getGeminiWebAvailabilityDiagnostic() {
+  return isBrowserCookieAccessAllowed() ? getLastGoogleCookieDiagnostic() : null;
+}
+export function getGeminiWebAvailabilityDiagnosticDetails() {
+  return isBrowserCookieAccessAllowed() ? getLastGoogleCookieDiagnosticDetails() : null;
+}
+export async function getActiveGoogleEmail(cookies) {
+  const cookieHeader = buildCookieHeader(cookies);
+  if (!cookieHeader)
+    return null;
+  try {
+    const html = await fetchWithCookieRedirects(GEMINI_APP_URL, cookieHeader, 10, AbortSignal.timeout(1e4));
+    const email = extractEmailFromGeminiHtml(html);
+    if (email)
+      return email;
+  } catch {}
+  try {
+    const response = await fetchWithCookieRedirects(GOOGLE_LIST_ACCOUNTS_URL, cookieHeader, 10, AbortSignal.timeout(1e4));
+    return extractEmailFromListAccounts(response);
+  } catch {
+    return null;
+  }
+}
+export async function queryWithCookies(prompt, cookieMap, options = {}) {
+  const model = options.model ?? DEFAULT_GEMINI_WEB_MODEL;
+  if (!MODEL_HEADERS[model]) {
+    throw new Error(`Gemini Web does not support model ${model}; configure Gemini API or choose a supported Gemini Web model.`);
+  }
+  const timeoutMs = options.timeoutMs ?? 120000;
+  let fullPrompt = prompt;
+  if (options.youtubeUrl) {
+    fullPrompt = `${fullPrompt}
+
+YouTube video: ${options.youtubeUrl}`;
+  }
+  const result = await runGeminiWebOnce(fullPrompt, cookieMap, model, options.files, timeoutMs, options.signal);
+  if (result.errorMessage)
+    throw new Error(result.errorMessage);
+  if (!result.text)
+    throw new Error("Gemini Web returned empty response");
+  return result.text;
+}
+async function runGeminiWebOnce(prompt, cookieMap, model, files, timeoutMs, signal) {
+  const effectiveSignal = withTimeout(signal, timeoutMs);
+  const cookieHeader = buildCookieHeader(cookieMap);
+  const accessToken = await fetchAccessToken(cookieHeader, effectiveSignal);
+  const uploaded = [];
+  if (files) {
+    for (const filePath of files) {
+      uploaded.push(await uploadFile(filePath, cookieHeader, effectiveSignal));
+    }
+  }
+  const fReq = buildFReqPayload(prompt, uploaded);
+  const params = new URLSearchParams;
+  params.set("at", accessToken);
+  params.set("f.req", fReq);
+  const res = await (await resolveGeminiFetch())(GEMINI_STREAM_GENERATE_URL, {
+    method: "POST",
+    redirect: "error",
+    headers: {
+      "content-type": "application/x-www-form-urlencoded;charset=utf-8",
+      host: "gemini.google.com",
+      origin: "https://gemini.google.com",
+      referer: "https://gemini.google.com/",
+      "x-same-domain": "1",
+      "user-agent": USER_AGENT,
+      cookie: cookieHeader,
+      [MODEL_HEADER_NAME]: MODEL_HEADERS[model]
+    },
+    body: params.toString(),
+    signal: effectiveSignal
+  });
+  const rawText = await res.text();
+  if (!res.ok) {
+    return { text: "", errorMessage: `Gemini request failed: ${res.status}` };
+  }
+  try {
+    return parseStreamGenerateResponse(rawText);
+  } catch (err) {
+    let errorCode;
+    try {
+      const json = JSON.parse(trimJsonEnvelope(rawText));
+      errorCode = extractErrorCode(json);
+    } catch {}
+    return {
+      text: "",
+      errorCode,
+      errorMessage: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function fetchAccessToken(cookieHeader, signal) {
+  const html = await fetchWithCookieRedirects(GEMINI_APP_URL, cookieHeader, 10, signal);
+  for (const key of ["SNlM0e", "thykhd"]) {
+    const match = html.match(new RegExp(`"${key}":"(.*?)"`));
+    if (match?.[1])
+      return match[1];
+  }
+  throw new Error("Unable to authenticate with Gemini. Make sure you're signed into gemini.google.com in a supported Chromium-based browser.");
+}
+async function fetchWithCookieRedirects(url, cookieHeader, maxRedirects, signal) {
+  let current = url;
+  const allowedOrigin = new URL(url).origin;
+  for (let i = 0;i <= maxRedirects; i++) {
+    const res = await (await resolveGeminiFetch())(current, {
+      headers: { "user-agent": USER_AGENT, cookie: cookieHeader },
+      redirect: "manual",
+      signal
+    });
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (location) {
+        const next = new URL(location, current);
+        if (next.origin !== allowedOrigin) {
+          throw new Error(`Refusing to send Google cookies across origins: ${allowedOrigin} -> ${next.origin}`);
+        }
+        current = next.toString();
+        continue;
+      }
+    }
+    return await res.text();
+  }
+  throw new Error(`Too many redirects (>${maxRedirects})`);
+}
+function extractEmailFromGeminiHtml(html) {
+  const patterns = [
+    /"oPEP7c"\s*:\s*"([^"]+)"/,
+    /aria-label="Google Account:[^"]*?\(([^)]+)\)"/,
+    /"displayEmail"\s*:\s*"([^"]+)"/,
+    /"defaultEmail"\s*:\s*"([^"]+)"/,
+    /"email"\s*:\s*"([^"]+)"/,
+    /"identifier"\s*:\s*"([^"]+)"/,
+    /"gaiaIdentifier"\s*:\s*"([^"]+)"/
+  ];
+  for (const pattern of patterns) {
+    const match = html.match(pattern);
+    const email = normalizeEmail(match?.[1]);
+    if (email)
+      return email;
+  }
+  return findFirstEmail(html);
+}
+function extractEmailFromListAccounts(text) {
+  const trimmed = text.replace(/^\)\]\}'\s*/, "");
+  try {
+    return findEmailInValue(JSON.parse(trimmed)) ?? findFirstEmail(trimmed);
+  } catch {
+    return findFirstEmail(trimmed);
+  }
+}
+function findEmailInValue(value) {
+  if (typeof value === "string")
+    return normalizeEmail(value);
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const email = findEmailInValue(item);
+      if (email)
+        return email;
+    }
+    return null;
+  }
+  if (value && typeof value === "object") {
+    for (const item of Object.values(value)) {
+      const email = findEmailInValue(item);
+      if (email)
+        return email;
+    }
+  }
+  return null;
+}
+function findFirstEmail(text) {
+  const normalized = decodeEmailEscapes(text);
+  const match = normalized.match(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i);
+  return match?.[0] ?? null;
+}
+function normalizeEmail(value) {
+  if (!value)
+    return null;
+  const normalized = decodeEmailEscapes(value.trim());
+  return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(normalized) ? normalized : null;
+}
+function decodeEmailEscapes(value) {
+  return value.replace(/\\u0040/gi, "@").replace(/\\x40/gi, "@").replace(/&#64;/gi, "@").replace(/&commat;/gi, "@").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+async function uploadFile(filePath, cookieHeader, signal) {
+  const data = readFileSync(filePath);
+  const fileName = basename(filePath);
+  const boundary = "----FormBoundary" + Math.random().toString(36).slice(2);
+  const header = `--${boundary}\r
+Content-Disposition: form-data; name="file"; filename="${fileName}"\r
+Content-Type: application/octet-stream\r
+\r
+`;
+  const footer = `\r
+--${boundary}--\r
+`;
+  const body = Buffer.concat([
+    Buffer.from(header, "utf-8"),
+    data,
+    Buffer.from(footer, "utf-8")
+  ]);
+  const res = await (await resolveGeminiFetch())(GEMINI_UPLOAD_URL, {
+    method: "POST",
+    redirect: "error",
+    headers: {
+      "content-type": `multipart/form-data; boundary=${boundary}`,
+      "push-id": GEMINI_UPLOAD_PUSH_ID,
+      "user-agent": USER_AGENT,
+      cookie: cookieHeader
+    },
+    body,
+    signal
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`File upload failed: ${res.status} (${text.slice(0, 200)})`);
+  }
+  return { id: await res.text(), name: fileName };
+}
+function buildFReqPayload(prompt, uploaded) {
+  const promptPayload = uploaded.length > 0 ? [prompt, 0, null, uploaded.map((file) => [[file.id, 1]])] : [prompt];
+  const innerList = [promptPayload, null, null];
+  return JSON.stringify([null, JSON.stringify(innerList)]);
+}
+function withTimeout(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function buildCookieHeader(cookieMap) {
+  return Object.entries(cookieMap).filter(([, value]) => typeof value === "string" && value.length > 0).map(([name, value]) => `${name}=${value}`).join("; ");
+}
+function getNestedValue(value, pathParts) {
+  let current = value;
+  for (const part of pathParts) {
+    if (current == null)
+      return;
+    if (!Array.isArray(current))
+      return;
+    current = current[part];
+  }
+  return current;
+}
+function trimJsonEnvelope(text) {
+  const start = text.indexOf("[");
+  const end = text.lastIndexOf("]");
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error("Gemini response did not contain a JSON payload.");
+  }
+  return text.slice(start, end + 1);
+}
+function extractErrorCode(responseJson) {
+  const code = getNestedValue(responseJson, [0, 5, 2, 0, 1, 0]);
+  return typeof code === "number" && code >= 0 ? code : undefined;
+}
+function extractCandidateText(candidate) {
+  const textRaw = getNestedValue(candidate, [1, 0]);
+  let text = typeof textRaw === "string" ? textRaw : "";
+  if (/^http:\/\/googleusercontent\.com\/card_content\/\d+/.test(text)) {
+    const alt = getNestedValue(candidate, [22, 0]);
+    if (typeof alt === "string" && alt.length > 0)
+      text = alt;
+  }
+  return text;
+}
+function parseStreamGenerateResponse(rawText) {
+  const responseJson = JSON.parse(trimJsonEnvelope(rawText));
+  const errorCode = extractErrorCode(responseJson);
+  const parts = Array.isArray(responseJson) ? responseJson : [];
+  let firstCandidateSeen = undefined;
+  let latestNonEmptyText = "";
+  for (let i = 0;i < parts.length; i++) {
+    const partBody = getNestedValue(parts[i], [2]);
+    if (!partBody || typeof partBody !== "string")
+      continue;
+    try {
+      const parsed = JSON.parse(partBody);
+      const candidateList = getNestedValue(parsed, [4]);
+      if (!Array.isArray(candidateList) || candidateList.length === 0)
+        continue;
+      const firstCandidate = candidateList[0];
+      if (firstCandidateSeen === undefined)
+        firstCandidateSeen = firstCandidate;
+      const text = extractCandidateText(firstCandidate);
+      if (text.length > 0)
+        latestNonEmptyText = text;
+    } catch {}
+  }
+  const text = latestNonEmptyText.length > 0 ? latestNonEmptyText : extractCandidateText(firstCandidateSeen);
+  return { text, errorCode };
+}

package/extensions/dm-web-access/github-api.js

@@ -0,0 +1,166 @@
+import { execFile } from "node:child_process";
+const MAX_TREE_ENTRIES = 200;
+const MAX_INLINE_FILE_CHARS = 1e5;
+let ghAvailable = null;
+let ghHintShown = false;
+export async function checkGhAvailable(signal) {
+  if (ghAvailable !== null)
+    return ghAvailable;
+  return new Promise((resolve) => {
+    execFile("gh", ["--version"], { timeout: 5000, ...signal ? { signal } : {} }, (err) => {
+      const available = !err;
+      if (!signal?.aborted)
+        ghAvailable = available;
+      resolve(available);
+    });
+  });
+}
+export function showGhHint() {
+  if (!ghHintShown) {
+    ghHintShown = true;
+    console.error("[dm-web-access] Install `gh` CLI for better GitHub repo access including private repos.");
+  }
+}
+export async function checkRepoSize(owner, repo) {
+  if (!await checkGhAvailable())
+    return null;
+  return new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}`, "--jq", ".size"], { timeout: 1e4 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      const kb = parseInt(stdout.trim(), 10);
+      resolve(Number.isNaN(kb) ? null : kb);
+    });
+  });
+}
+async function getDefaultBranch(owner, repo) {
+  if (!await checkGhAvailable())
+    return null;
+  return new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}`, "--jq", ".default_branch"], { timeout: 1e4 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      const branch = stdout.trim();
+      resolve(branch || null);
+    });
+  });
+}
+async function fetchTreeViaApi(owner, repo, ref) {
+  if (!await checkGhAvailable())
+    return null;
+  return new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}/git/trees/${ref}?recursive=1`, "--jq", ".tree[].path"], { timeout: 15000, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      const paths = stdout.trim().split(`
+`).filter(Boolean);
+      if (paths.length === 0) {
+        resolve(null);
+        return;
+      }
+      const truncated = paths.length > MAX_TREE_ENTRIES;
+      const display = paths.slice(0, MAX_TREE_ENTRIES).join(`
+`);
+      resolve(truncated ? display + `
+... (${paths.length} total entries)` : display);
+    });
+  });
+}
+async function fetchReadmeViaApi(owner, repo, ref) {
+  if (!await checkGhAvailable())
+    return null;
+  return new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}/readme?ref=${ref}`, "--jq", ".content"], { timeout: 1e4 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      try {
+        const decoded = Buffer.from(stdout.trim(), "base64").toString("utf-8");
+        resolve(decoded.length > 8192 ? decoded.slice(0, 8192) + `
+
+[README truncated at 8K chars]` : decoded);
+      } catch {
+        resolve(null);
+      }
+    });
+  });
+}
+async function fetchFileViaApi(owner, repo, path, ref) {
+  if (!await checkGhAvailable())
+    return null;
+  return new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}/contents/${path}?ref=${ref}`, "--jq", ".content"], { timeout: 1e4, maxBuffer: 2 * 1024 * 1024 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      try {
+        resolve(Buffer.from(stdout.trim(), "base64").toString("utf-8"));
+      } catch {
+        resolve(null);
+      }
+    });
+  });
+}
+export async function fetchViaApi(url, owner, repo, info, sizeNote) {
+  const ref = info.ref || await getDefaultBranch(owner, repo);
+  if (!ref)
+    return null;
+  const lines = [];
+  if (sizeNote) {
+    lines.push(sizeNote);
+    lines.push("");
+  }
+  if (info.type === "blob" && info.path) {
+    const content = await fetchFileViaApi(owner, repo, info.path, ref);
+    if (!content)
+      return null;
+    lines.push(`## ${info.path}`);
+    if (content.length > MAX_INLINE_FILE_CHARS) {
+      lines.push(content.slice(0, MAX_INLINE_FILE_CHARS));
+      lines.push(`
+[File truncated at 100K chars]`);
+    } else {
+      lines.push(content);
+    }
+    return {
+      url,
+      title: `${owner}/${repo} - ${info.path}`,
+      content: lines.join(`
+`),
+      error: null
+    };
+  }
+  const [tree, readme] = await Promise.all([
+    fetchTreeViaApi(owner, repo, ref),
+    fetchReadmeViaApi(owner, repo, ref)
+  ]);
+  if (!tree && !readme)
+    return null;
+  if (tree) {
+    lines.push("## Structure");
+    lines.push(tree);
+    lines.push("");
+  }
+  if (readme) {
+    lines.push("## README.md");
+    lines.push(readme);
+    lines.push("");
+  }
+  lines.push("This is an API-only view. Clone the repo or use `read`/`bash` for deeper exploration.");
+  const title = info.path ? `${owner}/${repo} - ${info.path}` : `${owner}/${repo}`;
+  return {
+    url,
+    title,
+    content: lines.join(`
+`),
+    error: null
+  };
+}