tau-coding-agent 0.1.3 → 0.1.5

package/extensions/{interlude.ts → stash.ts}

@@ -1,16 +1,19 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 
 const DEFAULT_SHORTCUTS = ["alt+x"] as const;
-const STATUS_KEY = "interlude";
-const KEYBINDINGS_PATH = path.join(os.homedir(), ".pi", "agent", "keybindings.json");
+const STATUS_KEY = "stash";
+const KEYBINDINGS_PATH = path.join(getAgentDir(), "keybindings.json");
 
 type ShortcutConfig = string | string[] | undefined;
 
 type KeybindingsConfig = {
-  interlude?: ShortcutConfig;
+  stash?: ShortcutConfig;
   [key: string]: unknown;
 };
 
@@ -37,9 +40,9 @@ function normalizeShortcuts(value: ShortcutConfig): string[] {
   return normalized.length > 0 ? [...new Set(normalized)] : [...DEFAULT_SHORTCUTS];
 }
 
-export default function interludeExtension(pi: ExtensionAPI): void {
+export default function stashExtension(pi: ExtensionAPI): void {
   const keybindings = readKeybindings(KEYBINDINGS_PATH);
-  const shortcuts = normalizeShortcuts(keybindings.interlude);
+  const shortcuts = normalizeShortcuts(keybindings.stash);
 
   let stashedDraft: string | null = null;
   let armed = false;
@@ -52,7 +55,7 @@ export default function interludeExtension(pi: ExtensionAPI): void {
     if (!ctx.hasUI) return;
 
     if (armed && stashedDraft !== null) {
-      ctx.ui.setStatus(STATUS_KEY, `interlude (${shortcutLabel()})`);
+      ctx.ui.setStatus(STATUS_KEY, `stash (${shortcutLabel()})`);
       return;
     }
 
@@ -80,7 +83,7 @@ export default function interludeExtension(pi: ExtensionAPI): void {
 
     if (armed && stashedDraft !== null) {
       restoreDraft(ctx);
-      ctx.ui.notify("Interlude draft restored", "info");
+      ctx.ui.notify("Stashed draft restored", "info");
       return;
     }
 
@@ -101,8 +104,7 @@ export default function interludeExtension(pi: ExtensionAPI): void {
 
   for (const shortcut of shortcuts) {
     pi.registerShortcut(shortcut as never, {
-      description:
-        "Stash the current message draft, send one interlude message, then restore the draft",
+      description: "Stash the current message draft, send one message, then restore it",
       handler: async (ctx) => {
         stashOrRestore(ctx);
       },

package/extensions/tool-display-mode.ts

@@ -1,7 +1,8 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import {
+  getAgentDir,
+  type AppKeybinding,
   CustomEditor,
   createBashToolDefinition,
   createFindToolDefinition,
@@ -16,8 +17,15 @@ import {
   type ToolDefinition,
   type ToolInfo,
   type ToolRenderResultOptions,
-} from "@mariozechner/pi-coding-agent";
-import { Container, Text, type Component, type EditorTheme, type TUI } from "@mariozechner/pi-tui";
+} from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Text,
+  type AutocompleteProvider,
+  type Component,
+  type EditorComponent,
+  type Focusable,
+} from "@earendil-works/pi-tui";
 
 // --- Constants ---
 
@@ -46,11 +54,22 @@ type ToolName = keyof typeof TOOL_FACTORIES;
 type AnyToolDefinition = ToolDefinition<any, any, any>;
 type AnyToolRenderContext = Parameters<NonNullable<AnyToolDefinition["renderResult"]>>[3];
 type JsonObject = Record<string, unknown>;
+type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
 
 type ToolDisplayModeConfig = {
   mode: Mode;
 };
 
+type CustomEditorLike = EditorComponent &
+  Partial<Focusable> & {
+    actionHandlers?: Map<AppKeybinding, () => void>;
+    onEscape?: () => void;
+    onCtrlD?: () => void;
+    onPasteImage?: () => void;
+    onExtensionShortcut?: (data: string) => boolean;
+    isShowingAutocomplete?: () => boolean;
+  };
+
 // --- Config ---
 
 function emptyConfig(): ToolDisplayModeConfig {
@@ -58,8 +77,7 @@ function emptyConfig(): ToolDisplayModeConfig {
 }
 
 function getConfigPath(): string {
-  const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
-  return path.join(agentDir, CONFIG_FILE);
+  return path.join(getAgentDir(), CONFIG_FILE);
 }
 
 function isObject(value: unknown): value is JsonObject {
@@ -242,11 +260,11 @@ function renderMinimalResult(
       break;
   }
 
-  return renderMinimalText(theme, "muted", `→ ${summary}`);
+  return renderMinimalText(theme, "muted", `↳ ${summary}`);
 }
 
 function renderMinimalText(theme: Theme, color: "error" | "muted", text: string): Text {
-  return new Text(theme.fg(color, `\n${text}`), 0, 0);
+  return new Text(theme.fg(color, text), 0, 0);
 }
 
 function bashSummary(result: AgentToolResult<any>): string {
@@ -328,29 +346,152 @@ function emptyComponent(): Container {
 
 // --- Editor ---
 
-class ToolDisplayEditor extends CustomEditor {
+class ToolDisplayEditor implements EditorComponent, Focusable {
+  readonly actionHandlers: Map<AppKeybinding, () => void>;
+  private readonly customBase: CustomEditorLike;
+  private fallbackFocused = false;
+  private fallbackOnEscape?: () => void;
+  private fallbackOnCtrlD?: () => void;
+  private fallbackOnPasteImage?: () => void;
+  private fallbackOnExtensionShortcut?: (data: string) => boolean;
+
   constructor(
-    tui: TUI,
-    theme: EditorTheme,
+    private readonly base: EditorComponent,
     private readonly appKeybindings: KeybindingsManager,
     private readonly cycleMode: () => void,
   ) {
-    super(tui, theme, appKeybindings);
+    this.customBase = base as CustomEditorLike;
+    this.actionHandlers = this.customBase.actionHandlers ?? new Map();
+  }
+
+  get focused(): boolean {
+    return this.customBase.focused ?? this.fallbackFocused;
+  }
+
+  set focused(value: boolean) {
+    this.fallbackFocused = value;
+    if ("focused" in this.customBase) this.customBase.focused = value;
+  }
+
+  get onSubmit(): ((text: string) => void) | undefined {
+    return this.base.onSubmit;
+  }
+
+  set onSubmit(handler: ((text: string) => void) | undefined) {
+    this.base.onSubmit = handler;
+  }
+
+  get onChange(): ((text: string) => void) | undefined {
+    return this.base.onChange;
+  }
+
+  set onChange(handler: ((text: string) => void) | undefined) {
+    this.base.onChange = handler;
+  }
+
+  get wantsKeyRelease(): boolean | undefined {
+    return this.base.wantsKeyRelease;
+  }
+
+  get borderColor(): ((str: string) => string) | undefined {
+    return this.base.borderColor;
+  }
+
+  set borderColor(handler: ((str: string) => string) | undefined) {
+    this.base.borderColor = handler;
+  }
+
+  get onEscape(): (() => void) | undefined {
+    return this.customBase.onEscape ?? this.fallbackOnEscape;
+  }
+
+  set onEscape(handler: (() => void) | undefined) {
+    this.fallbackOnEscape = handler;
+    if ("onEscape" in this.customBase) this.customBase.onEscape = handler;
+  }
+
+  get onCtrlD(): (() => void) | undefined {
+    return this.customBase.onCtrlD ?? this.fallbackOnCtrlD;
+  }
+
+  set onCtrlD(handler: (() => void) | undefined) {
+    this.fallbackOnCtrlD = handler;
+    if ("onCtrlD" in this.customBase) this.customBase.onCtrlD = handler;
+  }
+
+  get onPasteImage(): (() => void) | undefined {
+    return this.customBase.onPasteImage ?? this.fallbackOnPasteImage;
   }
 
-  override handleInput(data: string): void {
+  set onPasteImage(handler: (() => void) | undefined) {
+    this.fallbackOnPasteImage = handler;
+    if ("onPasteImage" in this.customBase) this.customBase.onPasteImage = handler;
+  }
+
+  get onExtensionShortcut(): ((data: string) => boolean) | undefined {
+    return this.customBase.onExtensionShortcut ?? this.fallbackOnExtensionShortcut;
+  }
+
+  set onExtensionShortcut(handler: ((data: string) => boolean) | undefined) {
+    this.fallbackOnExtensionShortcut = handler;
+    if ("onExtensionShortcut" in this.customBase) this.customBase.onExtensionShortcut = handler;
+  }
+
+  getText(): string {
+    return this.base.getText();
+  }
+
+  setText(text: string): void {
+    this.base.setText(text);
+  }
+
+  addToHistory(text: string): void {
+    this.base.addToHistory?.(text);
+  }
+
+  insertTextAtCursor(text: string): void {
+    this.base.insertTextAtCursor?.(text);
+  }
+
+  getExpandedText(): string {
+    return this.base.getExpandedText?.() ?? this.base.getText();
+  }
+
+  setAutocompleteProvider(provider: AutocompleteProvider): void {
+    this.base.setAutocompleteProvider?.(provider);
+  }
+
+  setPaddingX(padding: number): void {
+    this.base.setPaddingX?.(padding);
+  }
+
+  setAutocompleteMaxVisible(maxVisible: number): void {
+    this.base.setAutocompleteMaxVisible?.(maxVisible);
+  }
+
+  render(width: number): string[] {
+    return this.base.render(width);
+  }
+
+  invalidate(): void {
+    this.base.invalidate();
+  }
+
+  handleInput(data: string): void {
     if (this.appKeybindings.matches(data, "app.tools.expand")) {
       this.cycleMode();
       return;
     }
 
-    super.handleInput(data);
+    this.base.handleInput(data);
   }
 }
 
 export default function toolDisplayModeExtension(pi: ExtensionAPI): void {
   let mode: Mode = DEFAULT_MODE;
   let registeredToolRenderers = false;
+  let installedEditorFactory: EditorFactory | undefined;
+  let previousEditorFactory: EditorFactory | undefined;
   const toolCache = new Map<string, Partial<Record<ToolName, AnyToolDefinition>>>();
 
   const setMode = (ctx: ExtensionContext, next: Mode): void => {
@@ -379,9 +520,24 @@ export default function toolDisplayModeExtension(pi: ExtensionAPI): void {
     applyMode(ctx, mode);
     if (!ctx.hasUI) return;
 
-    ctx.ui.setEditorComponent(
-      (tui, theme, keybindings) =>
-        new ToolDisplayEditor(tui, theme, keybindings, () => setMode(ctx, nextMode(mode))),
-    );
+    if (ctx.ui.getEditorComponent() === installedEditorFactory) return;
+
+    previousEditorFactory = ctx.ui.getEditorComponent();
+    installedEditorFactory = (tui, theme, keybindings) => {
+      const baseEditor =
+        previousEditorFactory?.(tui, theme, keybindings) ??
+        new CustomEditor(tui, theme, keybindings);
+      return new ToolDisplayEditor(baseEditor, keybindings, () => setMode(ctx, nextMode(mode)));
+    };
+    ctx.ui.setEditorComponent(installedEditorFactory);
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    if (ctx.hasUI && ctx.ui.getEditorComponent() === installedEditorFactory) {
+      ctx.ui.setEditorComponent(previousEditorFactory);
+    }
+
+    installedEditorFactory = undefined;
+    previousEditorFactory = undefined;
   });
 }

package/extensions/usage/anthropic.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   clampPercent,
   formatCurrency,

package/extensions/usage/github-copilot.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   clampPercent,
   formatCount,

package/extensions/usage/index.ts

@@ -1,5 +1,9 @@
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { BorderedLoader } from "@mariozechner/pi-coding-agent";
+import {
+  BorderedLoader,
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import {
   Key,
   matchesKey,
@@ -7,7 +11,7 @@ import {
   type TUI,
   truncateToWidth,
   visibleWidth,
-} from "@mariozechner/pi-tui";
+} from "@earendil-works/pi-tui";
 import { createReadStream, type Dirent } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -31,7 +35,7 @@ import type {
 } from "./types.js";
 
 const ALL_TAB_ID = "all";
-const SESSION_ROOT = path.join(os.homedir(), ".pi", "agent", "sessions");
+const SESSION_ROOT = path.join(getAgentDir(), "sessions");
 const RANGE_DAYS = [7, 30, 90] as const;
 const FILE_PARSE_CONCURRENCY = 16;
 
@@ -2205,7 +2209,7 @@ export default function usageBreakdownExtension(pi: ExtensionAPI) {
     handler: async (_args, ctx: ExtensionContext) => {
       const liveUsageAvailability = await getLiveUsageAvailabilityMap(ctx);
 
-      if (!ctx.hasUI) {
+      if (ctx.mode !== "tui") {
         const [data, liveUsage] = await Promise.all([
           computeBreakdown(liveUsageAvailability, undefined),
           fetchLiveUsage(SUPPORTED_PROVIDERS, liveUsageAvailability, ctx, undefined),

package/extensions/usage/minimax.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   clampPercent,
   formatCount,

package/extensions/usage/openai-codex.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   clampPercent,
   formatCurrency,

package/extensions/usage/openrouter.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   formatCurrency,
   HttpError,

package/extensions/usage/providers.ts

@@ -1,6 +1,5 @@
 import anthropicProvider from "./anthropic.js";
 import githubCopilotProvider from "./github-copilot.js";
-import googleGeminiCliProvider from "./google-gemini-cli.js";
 import minimaxProvider from "./minimax.js";
 import openAICodexProvider from "./openai-codex.js";
 import openRouterProvider from "./openrouter.js";
@@ -11,7 +10,6 @@ export const SUPPORTED_PROVIDERS: readonly UsageProviderDefinition[] = [
   openAICodexProvider,
   anthropicProvider,
   githubCopilotProvider,
-  googleGeminiCliProvider,
   openRouterProvider,
   zaiProvider,
   minimaxProvider,

package/extensions/usage/types.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 export interface RGB {
   r: number;
@@ -10,7 +10,6 @@ export type SupportedProviderId =
   | "openai-codex"
   | "anthropic"
   | "github-copilot"
-  | "google-gemini-cli"
   | "openrouter"
   | "zai"
   | "minimax";

package/extensions/usage/zai.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   clampPercent,
   formatCount,

package/extensions/websearch/README.md

@@ -16,7 +16,7 @@ Current routes:
 
 Optional config file:
 
-- `~/.pi/websearch.json`
+- `~/.pi/agent/websearch.json`
 
 Example:
 

package/extensions/websearch/browser/chromium.ts

@@ -1,11 +1,13 @@
-import { execFileSync } from "node:child_process";
-import { createDecipheriv, createHash, pbkdf2Sync } from "node:crypto";
-import { existsSync, readdirSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { createDecipheriv, createHash, pbkdf2 } from "node:crypto";
+import { readdir } from "node:fs/promises";
 import { DatabaseSync } from "node:sqlite";
 import os from "node:os";
 import path from "node:path";
+import { promisify } from "node:util";
 
 import type { BrowserCookie, BrowserProfile } from "../types.js";
+import { pathExists } from "./fs.js";
 import { withSqliteSnapshot } from "./sqlite.js";
 
 const MACOS_BROWSER_CONFIGS: ChromiumBrowserConfig[] = [
@@ -72,6 +74,8 @@ interface ChromiumBrowserConfig {
   secretToolApp?: string;
 }
 
+const execFileAsync = promisify(execFile);
+const pbkdf2Async = promisify(pbkdf2);
 const passwordCache = new Map<string, string | null>();
 
 function browserConfigs(): ChromiumBrowserConfig[] {
@@ -80,13 +84,15 @@ function browserConfigs(): ChromiumBrowserConfig[] {
   return [];
 }
 
-export function discoverChromiumProfiles(preferredProfileName?: string): BrowserProfile[] {
+export async function discoverChromiumProfiles(
+  preferredProfileName?: string,
+): Promise<BrowserProfile[]> {
   const profiles: BrowserProfile[] = [];
 
   for (const config of browserConfigs()) {
-    if (!existsSync(config.baseDir)) continue;
+    if (!(await pathExists(config.baseDir))) continue;
 
-    const candidates = ["Default", ...discoverProfileDirectories(config.baseDir)];
+    const candidates = ["Default", ...(await discoverProfileDirectories(config.baseDir))];
     const seen = new Set<string>();
     for (const directoryName of candidates) {
       if (!directoryName || seen.has(directoryName)) continue;
@@ -94,7 +100,7 @@ export function discoverChromiumProfiles(preferredProfileName?: string): Browser
 
       const profilePath = path.join(config.baseDir, directoryName);
       const cookiesPath = path.join(profilePath, "Cookies");
-      if (!existsSync(cookiesPath)) continue;
+      if (!(await pathExists(cookiesPath))) continue;
 
       profiles.push({
         family: "chromium",
@@ -136,9 +142,9 @@ function isPreferredChromiumProfile(
   return profile.profileName === preferredProfileName;
 }
 
-function discoverProfileDirectories(baseDir: string): string[] {
+async function discoverProfileDirectories(baseDir: string): Promise<string[]> {
   try {
-    return readdirSync(baseDir, { withFileTypes: true })
+    return (await readdir(baseDir, { withFileTypes: true }))
       .filter((entry) => entry.isDirectory())
       .map((entry) => entry.name)
       .filter((name) => name === "Default" || /^Profile\s+\d+$/.test(name));
@@ -147,27 +153,28 @@ function discoverProfileDirectories(baseDir: string): string[] {
   }
 }
 
-export function loadChromiumCookies(profile: BrowserProfile): BrowserCookie[] {
+export async function loadChromiumCookies(profile: BrowserProfile): Promise<BrowserCookie[]> {
   const browserConfig = browserConfigs().find((config) =>
     profile.profilePath.startsWith(config.baseDir),
   );
   if (!browserConfig) return [];
 
-  const password = readBrowserPassword(browserConfig);
+  const cookiesPath = path.join(profile.profilePath, "Cookies");
+  if (!(await pathExists(cookiesPath))) return [];
+
+  const password = await readBrowserPassword(browserConfig);
   if (!password) return [];
 
-  const keyMaterial = pbkdf2Sync(
+  const keyMaterial = await pbkdf2Async(
     password,
     "saltysalt",
     process.platform === "darwin" ? 1003 : 1,
     16,
     "sha1",
   );
-  const cookiesPath = path.join(profile.profilePath, "Cookies");
-  if (!existsSync(cookiesPath)) return [];
 
   try {
-    return withSqliteSnapshot(cookiesPath, "websearch-chromium", (tempDbPath) => {
+    return await withSqliteSnapshot(cookiesPath, "websearch-chromium", (tempDbPath) => {
       const db = new DatabaseSync(tempDbPath, { readOnly: true });
       try {
         const rows = db
@@ -277,7 +284,7 @@ function stripHostKeyDigest(buffer: Buffer, hostKey: string | null): Buffer {
   return buffer.subarray(0, 32).equals(digest) ? buffer.subarray(32) : buffer;
 }
 
-function readBrowserPassword(config: ChromiumBrowserConfig): string | null {
+async function readBrowserPassword(config: ChromiumBrowserConfig): Promise<string | null> {
   const cacheKey = `${config.name}:${config.baseDir}`;
   if (passwordCache.has(cacheKey)) {
     return passwordCache.get(cacheKey) ?? null;
@@ -286,9 +293,13 @@ function readBrowserPassword(config: ChromiumBrowserConfig): string | null {
   let password: string | null = null;
   if (process.platform === "darwin") {
     if (!config.keychainAccount || !config.keychainService) return null;
-    password = readMacKeychainPassword(config.name, config.keychainAccount, config.keychainService);
+    password = await readMacKeychainPassword(
+      config.name,
+      config.keychainAccount,
+      config.keychainService,
+    );
   } else if (process.platform === "linux") {
-    password = readLinuxPassword(config.secretToolApp);
+    password = await readLinuxPassword(config.secretToolApp);
   }
 
   if (password) {
@@ -297,33 +308,33 @@ function readBrowserPassword(config: ChromiumBrowserConfig): string | null {
   return password;
 }
 
-function readMacKeychainPassword(
+async function readMacKeychainPassword(
   browserName: string,
   account: string,
   service: string,
-): string | null {
+): Promise<string | null> {
   try {
-    return (
-      execFileSync("security", ["find-generic-password", "-w", "-a", account, "-s", service], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }).trim() || null
+    const { stdout } = await execFileAsync(
+      "security",
+      ["find-generic-password", "-w", "-a", account, "-s", service],
+      { encoding: "utf8" },
     );
+    return stdout.trim() || null;
   } catch {
     throw new Error(`Could not read ${browserName} cookie decryption password from Keychain.`);
   }
 }
 
-function readLinuxPassword(secretToolApp?: string): string | null {
+async function readLinuxPassword(secretToolApp?: string): Promise<string | null> {
   if (!secretToolApp) return "peanuts";
 
   try {
-    return (
-      execFileSync("secret-tool", ["lookup", "application", secretToolApp], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }).trim() || "peanuts"
+    const { stdout } = await execFileAsync(
+      "secret-tool",
+      ["lookup", "application", secretToolApp],
+      { encoding: "utf8" },
     );
+    return stdout.trim() || "peanuts";
   } catch {
     return "peanuts";
   }

package/extensions/websearch/browser/discovery.ts

@@ -11,32 +11,34 @@ import type {
 const COOKIE_CACHE_TTL_MS = 30_000;
 const cookieCache = new Map<string, { cookies: BrowserCookie[]; expiresAt: number }>();
 
-export function discoverProfiles(
+export async function discoverProfiles(
   browserFamilies: WebsearchBrowserFamily[],
   preferredProfiles: WebsearchConfig["profiles"],
-): BrowserProfile[] {
+): Promise<BrowserProfile[]> {
   const profiles: BrowserProfile[] = [];
 
   for (const family of browserFamilies) {
     if (family === "firefox") {
-      profiles.push(...discoverFirefoxProfiles(preferredProfiles.firefox));
+      profiles.push(...(await discoverFirefoxProfiles(preferredProfiles.firefox)));
       continue;
     }
 
-    profiles.push(...discoverChromiumProfiles(preferredProfiles.chromium));
+    profiles.push(...(await discoverChromiumProfiles(preferredProfiles.chromium)));
   }
 
   return profiles;
 }
 
-export function loadCookies(profile: BrowserProfile): BrowserCookie[] {
+export async function loadCookies(profile: BrowserProfile): Promise<BrowserCookie[]> {
   const cacheKey = `${profile.family}:${profile.profilePath}`;
   const cached = cookieCache.get(cacheKey);
   if (cached && cached.expiresAt > Date.now()) return cached.cookies;
   if (cached) cookieCache.delete(cacheKey);
 
   const cookies =
-    profile.family === "firefox" ? loadFirefoxCookies(profile) : loadChromiumCookies(profile);
+    profile.family === "firefox"
+      ? await loadFirefoxCookies(profile)
+      : await loadChromiumCookies(profile);
 
   if (cookies.length > 0) {
     cookieCache.set(cacheKey, {
@@ -48,11 +50,11 @@ export function loadCookies(profile: BrowserProfile): BrowserCookie[] {
   return cookies;
 }
 
-export function createBrowserSession(
+export async function createBrowserSession(
   profile: BrowserProfile,
   domains: string[],
-): BrowserSession | null {
-  const cookies = loadCookies(profile).filter((cookie) => {
+): Promise<BrowserSession | null> {
+  const cookies = (await loadCookies(profile)).filter((cookie) => {
     return domains.some((domain) => matchesBrowserDomain(domain, cookie.domain));
   });
   if (cookies.length === 0) return null;