@vybestack/llxprt-code-core 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/utils/browser-profile-discovery.ts

@@ -0,0 +1,358 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type { BrowserKind } from './secure-browser-launcher.js';
+import { envOr } from './env.js';
+
+/**
+ * A discovered browser profile.
+ */
+export interface DiscoveredBrowserProfile {
+  /**
+   * Browser-specific profile selector: Chrome profile directory, Firefox
+   * profile name (for `-P`) or absolute profile path (for `-profile`).
+   */
+  directoryName: string;
+  displayName: string;
+}
+
+/**
+ * Options for profile discovery. All filesystem access is injectable
+ * so tests never touch real disk.
+ */
+export interface DiscoverBrowserProfilesOptions {
+  platform?: NodeJS.Platform;
+  userDataDir?: string;
+  homeDir?: string;
+  fileExists?: (p: string) => boolean;
+  readFile?: (p: string) => string;
+}
+
+interface ChromeLocalState {
+  profile?: {
+    info_cache?: Record<string, { name?: string } | undefined>;
+  };
+}
+
+/**
+ * Resolve the Chrome user data directory for the given platform.
+ */
+function chromeUserDataDir(
+  platformName: NodeJS.Platform,
+  homeDir: string,
+): string {
+  switch (platformName) {
+    case 'darwin':
+      return path.join(
+        homeDir,
+        'Library',
+        'Application Support',
+        'Google',
+        'Chrome',
+      );
+    case 'win32':
+      return path.join(
+        envOr(process.env.LOCALAPPDATA, path.join(homeDir, 'AppData', 'Local')),
+        'Google',
+        'Chrome',
+        'User Data',
+      );
+    case 'linux':
+    case 'freebsd':
+    case 'openbsd':
+      return path.join(homeDir, '.config', 'google-chrome');
+    default:
+      throw new Error(`Unsupported platform for Chrome: ${platformName}`);
+  }
+}
+
+/**
+ * Resolve the Firefox profile root directory for the given platform.
+ */
+function firefoxProfileRoot(
+  platformName: NodeJS.Platform,
+  homeDir: string,
+): string {
+  switch (platformName) {
+    case 'darwin':
+      return path.join(homeDir, 'Library', 'Application Support', 'Firefox');
+    case 'win32':
+      return path.join(
+        envOr(process.env.APPDATA, path.join(homeDir, 'AppData', 'Roaming')),
+        'Mozilla',
+        'Firefox',
+      );
+    case 'linux':
+    case 'freebsd':
+    case 'openbsd':
+      return path.join(homeDir, '.mozilla', 'firefox');
+    default:
+      throw new Error(`Unsupported platform for Firefox: ${platformName}`);
+  }
+}
+
+/**
+ * Discover Chrome profiles by reading the Local State JSON file.
+ */
+function discoverChromeProfiles(
+  opts: Required<
+    Omit<DiscoverBrowserProfilesOptions, 'platform' | 'userDataDir' | 'homeDir'>
+  > & {
+    userDataDir: string;
+  },
+): DiscoveredBrowserProfile[] {
+  const localStatePath = path.join(opts.userDataDir, 'Local State');
+
+  if (!opts.fileExists(localStatePath)) {
+    return [];
+  }
+
+  let raw: string;
+  try {
+    raw = opts.readFile(localStatePath);
+  } catch {
+    return [];
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+
+  // JSON.parse can return null, primitives, or arrays for valid-but-unexpected
+  // content; only an object with a profile.info_cache shape is usable.
+  if (typeof parsed !== 'object' || parsed === null) {
+    return [];
+  }
+  const localState = parsed as ChromeLocalState;
+  const infoCache = localState.profile?.info_cache;
+  if (!infoCache || typeof infoCache !== 'object') {
+    return [];
+  }
+
+  const profiles: DiscoveredBrowserProfile[] = [];
+  for (const [directoryName, info] of Object.entries(infoCache)) {
+    if (!info || typeof info !== 'object') {
+      continue;
+    }
+    const displayName = info.name ?? directoryName;
+    profiles.push({ directoryName, displayName });
+  }
+
+  return profiles;
+}
+
+interface FirefoxProfileEntry {
+  name?: string;
+  path?: string;
+}
+
+/**
+ * Parse a Firefox profiles.ini file into profile entries.
+ *
+ * Each `[Profile*]` section contributes an entry built from its `Name=` and
+ * `Path=` keys. Sections that yield neither a name nor a path are skipped.
+ */
+function parseFirefoxProfilesIni(iniContent: string): FirefoxProfileEntry[] {
+  const entries: FirefoxProfileEntry[] = [];
+
+  const sections = splitIniSections(iniContent);
+  for (const section of sections) {
+    if (!/^Profile\d+$/i.test(section.header)) {
+      continue;
+    }
+    const entry = buildFirefoxEntry(section.lines);
+    if (entry.name || entry.path) {
+      entries.push(entry);
+    }
+  }
+
+  return entries;
+}
+
+interface IniSection {
+  header: string;
+  lines: string[];
+}
+
+/**
+ * Group raw ini lines into sections keyed by their `[header]`.
+ * Lines before the first header are dropped.
+ */
+function splitIniSections(iniContent: string): IniSection[] {
+  const sections: IniSection[] = [];
+  let current: IniSection | null = null;
+
+  for (const line of iniContent.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      current = { header: trimmed.slice(1, -1), lines: [] };
+      sections.push(current);
+    } else if (current) {
+      current.lines.push(trimmed);
+    }
+  }
+
+  return sections;
+}
+
+/**
+ * Build a Firefox profile entry from a section's key=value lines.
+ */
+function buildFirefoxEntry(lines: string[]): FirefoxProfileEntry {
+  const entry: FirefoxProfileEntry = {};
+  for (const trimmed of lines) {
+    const parsed = parseIniKeyValue(trimmed);
+    if (!parsed) {
+      continue;
+    }
+    if (parsed.key === 'Name') {
+      entry.name = parsed.value;
+    } else if (parsed.key === 'Path') {
+      entry.path = parsed.value;
+    }
+  }
+  return entry;
+}
+
+function parseIniKeyValue(
+  line: string,
+): { key: string; value: string } | undefined {
+  const eqIndex = line.indexOf('=');
+  if (eqIndex === -1) {
+    return undefined;
+  }
+  return {
+    key: line.slice(0, eqIndex).trim(),
+    value: line.slice(eqIndex + 1).trim(),
+  };
+}
+
+function resolveRelativeFirefoxProfilePath(
+  rootDir: string,
+  profilePath: string,
+): string | undefined {
+  const resolvedRoot = path.resolve(rootDir);
+  const resolvedProfile = path.resolve(resolvedRoot, profilePath);
+  const relativePath = path.relative(resolvedRoot, resolvedProfile);
+  if (
+    relativePath === '..' ||
+    relativePath.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relativePath)
+  ) {
+    return undefined;
+  }
+  return resolvedProfile;
+}
+
+/**
+ * Discover Firefox profiles by reading profiles.ini.
+ */
+function discoverFirefoxProfiles(
+  rootDir: string,
+  opts: Required<
+    Omit<DiscoverBrowserProfilesOptions, 'platform' | 'userDataDir' | 'homeDir'>
+  >,
+): DiscoveredBrowserProfile[] {
+  const iniPath = path.join(rootDir, 'profiles.ini');
+
+  if (!opts.fileExists(iniPath)) {
+    return [];
+  }
+
+  let raw: string;
+  try {
+    raw = opts.readFile(iniPath);
+  } catch {
+    return [];
+  }
+
+  const entries = parseFirefoxProfilesIni(raw);
+
+  const profiles: DiscoveredBrowserProfile[] = [];
+  for (const entry of entries) {
+    // Firefox's -P flag selects a profile by its Name (the [Profile*]
+    // "Name=" key), not by its on-disk Path. When the two differ (which they
+    // do whenever the user renamed a profile or Firefox relocated it),
+    // passing the Path would fail to select the intended profile, so prefer
+    // Name. Fall back to Path only for entries that omit a Name entirely;
+    // profiles.ini stores Path as a relative reference (e.g.
+    // "Profiles/abcd.default"), so resolve it against rootDir to produce a
+    // usable, unambiguous selector instead of a brittle relative fragment.
+    let directoryName = entry.name;
+    if (!directoryName && entry.path) {
+      directoryName = path.isAbsolute(entry.path)
+        ? entry.path
+        : resolveRelativeFirefoxProfilePath(rootDir, entry.path);
+    }
+    if (directoryName) {
+      profiles.push({
+        directoryName,
+        displayName: entry.name ?? directoryName,
+      });
+    }
+  }
+
+  return profiles;
+}
+
+/**
+ * Discover browser profiles for the specified browser kind.
+ *
+ * All filesystem access is injectable via opts so tests never touch real disk.
+ * When opts are omitted, real node:fs and os.homedir() and process.platform
+ * are used.
+ *
+ * @param browser The browser kind to discover profiles for
+ * @param opts Optional injectable filesystem and platform overrides
+ * @returns Array of discovered profiles (empty if none found or errors occur)
+ */
+export function discoverBrowserProfiles(
+  browser: BrowserKind,
+  opts?: DiscoverBrowserProfilesOptions,
+): DiscoveredBrowserProfile[] {
+  const platformName = opts?.platform ?? process.platform;
+  const homeDir = opts?.homeDir ?? os.homedir();
+  const fileExists = opts?.fileExists ?? existsSync;
+  const readFile = opts?.readFile ?? ((p: string) => readFileSync(p, 'utf-8'));
+
+  const fsOpts = { fileExists, readFile };
+
+  switch (browser) {
+    case 'chrome': {
+      // An unsupported platform surfaces as a thrown error from
+      // chromeUserDataDir; discovery is best-effort, so degrade to an empty
+      // list rather than crashing the calling command.
+      try {
+        const userDataDir =
+          opts?.userDataDir ?? chromeUserDataDir(platformName, homeDir);
+        return discoverChromeProfiles({ ...fsOpts, userDataDir });
+      } catch {
+        return [];
+      }
+    }
+
+    case 'firefox': {
+      try {
+        const rootDir = firefoxProfileRoot(platformName, homeDir);
+        return discoverFirefoxProfiles(rootDir, fsOpts);
+      } catch {
+        return [];
+      }
+    }
+
+    case 'safari':
+      return [{ directoryName: 'Default', displayName: 'Safari' }];
+
+    default:
+      return [];
+  }
+}

package/src/utils/env.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Return the given environment variable value when it is present and non-empty,
+ * otherwise return the fallback. An explicitly-empty (or whitespace-only)
+ * value is treated as absent so that misconfigured environment variables fall
+ * back to the default instead of producing malformed partial paths.
+ */
+export function envOr(value: string | undefined, fallback: string): string {
+  return value?.trim() ? value : fallback;
+}

package/src/utils/events.ts

@@ -103,6 +103,7 @@ export enum CoreEvent {
   ExternalEditorClosed = 'external-editor-closed',
   McpClientUpdate = 'mcp-client-update',
   SettingsChanged = 'settings-changed',
+  FolderTrustChanged = 'folder-trust-changed',
 }
 
 export class CoreEventEmitter extends EventEmitter {
@@ -143,6 +144,27 @@ export class CoreEventEmitter extends EventEmitter {
     this.emit(CoreEvent.SettingsChanged);
   }
 
+  /**
+   * Notifies subscribers that the effective folder-trust state has changed
+   * during the active session (e.g. via the permissions dialog).
+   */
+  emitFolderTrustChanged(trusted: boolean): void {
+    const failures: unknown[] = [];
+    for (const listener of this.rawListeners(CoreEvent.FolderTrustChanged)) {
+      try {
+        listener.call(this, trusted);
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (failures.length === 1) {
+      throw failures[0];
+    }
+    if (failures.length > 1) {
+      throw new AggregateError(failures, 'Folder trust listeners failed');
+    }
+  }
+
   /**
    * Flushes buffered messages. Call this immediately after primary UI listener
    * subscribes.
@@ -184,6 +206,10 @@ export class CoreEventEmitter extends EventEmitter {
     listener: (payload: OutputPayload) => void,
   ): this;
   override on(event: CoreEvent.SettingsChanged, listener: () => void): this;
+  override on(
+    event: CoreEvent.FolderTrustChanged,
+    listener: (trusted: boolean) => void,
+  ): this;
   override on(
     event: CoreEvent.McpClientUpdate,
     listener: (payload: McpClientUpdatePayload) => void,
@@ -224,6 +250,10 @@ export class CoreEventEmitter extends EventEmitter {
     listener: (payload: OutputPayload) => void,
   ): this;
   override off(event: CoreEvent.SettingsChanged, listener: () => void): this;
+  override off(
+    event: CoreEvent.FolderTrustChanged,
+    listener: (trusted: boolean) => void,
+  ): this;
   override off(
     event: CoreEvent.McpClientUpdate,
     listener: (payload: McpClientUpdatePayload) => void,
@@ -259,6 +289,7 @@ export class CoreEventEmitter extends EventEmitter {
   override emit(event: CoreEvent.Output, payload: OutputPayload): boolean;
   override emit(event: CoreEvent.ExternalEditorClosed): boolean;
   override emit(event: CoreEvent.SettingsChanged): boolean;
+  override emit(event: CoreEvent.FolderTrustChanged, trusted: boolean): boolean;
   override emit(
     event: CoreEvent.McpClientUpdate,
     payload: McpClientUpdatePayload,

package/src/utils/fileUtils.ts

@@ -269,8 +269,18 @@ export async function detectFileType(
     return 'svg';
   }
 
+  // mime-db maps the FreeHand family (.fh, .fh4, .fh5, .fh7, .fhc) to
+  // image/x-freehand, but these extensions are commonly shader/source text.
+  // Exclude them from the image short-circuit below so they fall through to
+  // content-based detection (text or binary).
+  const freehandExtensions = ['.fh', '.fh4', '.fh5', '.fh7', '.fhc'];
+
   const lookedUpMimeType = mime.lookup(filePath); // Returns false if not found, or the mime type string
-  if (typeof lookedUpMimeType === 'string' && lookedUpMimeType !== '') {
+  if (
+    typeof lookedUpMimeType === 'string' &&
+    lookedUpMimeType !== '' &&
+    !freehandExtensions.includes(ext)
+  ) {
     if (lookedUpMimeType.startsWith('image/')) {
       return 'image';
     }

package/src/utils/retry.ts

@@ -245,14 +245,13 @@ export function isNetworkTransientError(error: unknown): boolean {
 export function isRetryableError(error: Error | unknown): boolean {
   // PRIORITY 0: Self-classifying aggregate errors (e.g. the load balancer
   // LoadBalancerFailoverError). An aggregate-of-failures has already computed
-  // its own retryability from EACH underlying backend failure, so it is
+  // its own retryability from its underlying backend failures, so it is
   // authoritative. Its human-readable message flattens the child messages,
   // which means the message-based heuristics below (network-transient, overload)
   // would otherwise re-interpret a sibling backend's text and override the
-  // precise per-child decision (e.g. a mixed "socket hang up" + HTTP 400
-  // aggregate must NOT be retried). Identified structurally — a `failures`
+  // precise per-child decision. Identified structurally — a `failures`
   // array plus a boolean `isRetryable` — so core does not import from
-  // providers. (issue #2450)
+  // providers. (issue #2450, updated #2712)
   if (
     typeof error === 'object' &&
     error !== null &&