@ulpi/browse 1.0.1 → 1.0.2

package/dist/browse.mjs

@@ -127,7 +127,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@ulpi/browse",
-      version: "1.0.1",
+      version: "1.0.2",
       repository: {
         type: "git",
         url: "https://github.com/ulpi-io/browse"
@@ -181,6 +181,7 @@ var require_package = __commonJS({
       devDependencies: {
         "@types/better-sqlite3": "^7.0.0",
         "@types/node": "^25.5.0",
+        "@vitest/coverage-v8": "^4.1.0",
         esbuild: "^0.25.0",
         tsx: "^4.0.0",
         typescript: "^5.9.3",
@@ -452,7 +453,31 @@ stderr: ${stderrData.slice(0, 2e3)}` : "")
 });
 
 // src/buffers.ts
-var SessionBuffers;
+var buffers_exports = {};
+__export(buffers_exports, {
+  SessionBuffers: () => SessionBuffers,
+  addConsoleEntry: () => addConsoleEntry,
+  addNetworkEntry: () => addNetworkEntry,
+  consoleBuffer: () => consoleBuffer,
+  consoleTotalAdded: () => consoleTotalAdded,
+  networkBuffer: () => networkBuffer,
+  networkTotalAdded: () => networkTotalAdded
+});
+function addConsoleEntry(entry) {
+  if (consoleBuffer.length >= DEFAULTS.BUFFER_HIGH_WATER_MARK) {
+    consoleBuffer.shift();
+  }
+  consoleBuffer.push(entry);
+  consoleTotalAdded++;
+}
+function addNetworkEntry(entry) {
+  if (networkBuffer.length >= DEFAULTS.BUFFER_HIGH_WATER_MARK) {
+    networkBuffer.shift();
+  }
+  networkBuffer.push(entry);
+  networkTotalAdded++;
+}
+var SessionBuffers, consoleBuffer, networkBuffer, consoleTotalAdded, networkTotalAdded;
 var init_buffers = __esm({
   "src/buffers.ts"() {
     "use strict";
@@ -480,10 +505,39 @@ var init_buffers = __esm({
         this.networkTotalAdded++;
       }
     };
+    consoleBuffer = [];
+    networkBuffer = [];
+    consoleTotalAdded = 0;
+    networkTotalAdded = 0;
+  }
+});
+
+// src/sanitize.ts
+function sanitizeName(name) {
+  const sanitized = name.replace(/[\/\\]/g, "_").replace(/\.\./g, "_");
+  if (!sanitized || /^[._]+$/.test(sanitized)) {
+    throw new Error(`Invalid name: "${name}"`);
+  }
+  return sanitized;
+}
+var init_sanitize = __esm({
+  "src/sanitize.ts"() {
+    "use strict";
   }
 });
 
 // src/browser-manager.ts
+var browser_manager_exports = {};
+__export(browser_manager_exports, {
+  BrowserManager: () => BrowserManager,
+  deleteProfile: () => deleteProfile,
+  getProfileDir: () => getProfileDir,
+  listDevices: () => listDevices,
+  listProfiles: () => listProfiles,
+  resolveDevice: () => resolveDevice
+});
+import * as path4 from "path";
+import * as fs4 from "fs";
 import { chromium, devices as playwrightDevices } from "playwright";
 function resolveDevice(name) {
   const alias = DEVICE_ALIASES[name.toLowerCase()];
@@ -512,11 +566,49 @@ function listDevices() {
   ]);
   return [...all].sort();
 }
+function getProfileDir(localDir, name) {
+  const sanitized = sanitizeName(name);
+  if (!sanitized) throw new Error("Invalid profile name");
+  return path4.join(localDir, "profiles", sanitized);
+}
+function listProfiles(localDir) {
+  const profilesDir = path4.join(localDir, "profiles");
+  if (!fs4.existsSync(profilesDir)) return [];
+  return fs4.readdirSync(profilesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+    const dir = path4.join(profilesDir, d.name);
+    const stat = fs4.statSync(dir);
+    let totalSize = 0;
+    try {
+      const files = fs4.readdirSync(dir, { recursive: true, withFileTypes: true });
+      for (const f of files) {
+        if (f.isFile()) {
+          try {
+            totalSize += fs4.statSync(path4.join(f.parentPath || f.path || dir, f.name)).size;
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    const sizeMB = (totalSize / 1024 / 1024).toFixed(1);
+    return {
+      name: d.name,
+      size: `${sizeMB}MB`,
+      lastUsed: stat.mtime.toISOString().split("T")[0]
+    };
+  });
+}
+function deleteProfile(localDir, name) {
+  const dir = getProfileDir(localDir, name);
+  if (!fs4.existsSync(dir)) throw new Error(`Profile "${name}" not found`);
+  fs4.rmSync(dir, { recursive: true, force: true });
+}
 var DEVICE_ALIASES, CUSTOM_DEVICES, BrowserManager;
 var init_browser_manager = __esm({
   "src/browser-manager.ts"() {
     "use strict";
     init_buffers();
+    init_sanitize();
     DEVICE_ALIASES = {
       "iphone": "iPhone 15",
       "iphone-12": "iPhone 12",
@@ -626,6 +718,8 @@ var init_browser_manager = __esm({
       domainFilter = null;
       // Whether this instance owns (and should close) the Browser process
       ownsBrowser = false;
+      // Whether this instance uses a persistent browser context (profile mode)
+      isPersistent = false;
       constructor(buffers) {
         this.buffers = buffers || new SessionBuffers();
       }
@@ -668,7 +762,66 @@ var init_browser_manager = __esm({
         });
         await this.newTab();
       }
+      /**
+       * Launch with a persistent browser profile directory.
+       * Data (cookies, localStorage, cache) persists across restarts.
+       * The context IS the browser — closing it closes everything.
+       */
+      async launchPersistent(profileDir, onCrash) {
+        let context;
+        try {
+          context = await chromium.launchPersistentContext(profileDir, {
+            headless: process.env.BROWSE_HEADED !== "1",
+            viewport: { width: 1920, height: 1080 },
+            ...this.customUserAgent ? { userAgent: this.customUserAgent } : {}
+          });
+        } catch (err) {
+          if (err.message?.includes("Failed to launch") || err.message?.includes("Target closed")) {
+            const fs16 = await import("fs");
+            console.error(`[browse] Profile directory corrupted, recreating: ${profileDir}`);
+            fs16.rmSync(profileDir, { recursive: true, force: true });
+            context = await chromium.launchPersistentContext(profileDir, {
+              headless: process.env.BROWSE_HEADED !== "1",
+              viewport: { width: 1920, height: 1080 }
+            });
+          } else {
+            throw err;
+          }
+        }
+        this.context = context;
+        this.browser = context.browser();
+        this.isPersistent = true;
+        this.ownsBrowser = true;
+        if (this.browser) {
+          this.browser.on("disconnected", () => {
+            if (onCrash) onCrash();
+          });
+        }
+        const pages = context.pages();
+        if (pages.length > 0) {
+          for (const page of pages) {
+            const tabId = this.nextTabId++;
+            this.wirePageEvents(page);
+            this.pages.set(tabId, page);
+            this.activeTabId = tabId;
+          }
+        } else {
+          await this.newTab();
+        }
+      }
       async close() {
+        if (this.isPersistent) {
+          this.pages.clear();
+          this.tabSnapshots.clear();
+          this.refMap.clear();
+          if (this.context) {
+            await this.context.close().catch(() => {
+            });
+            this.context = null;
+            this.browser = null;
+          }
+          return;
+        }
         for (const [, page] of this.pages) {
           await page.close().catch(() => {
           });
@@ -690,6 +843,9 @@ var init_browser_manager = __esm({
       isHealthy() {
         return this.browser !== null && this.browser.isConnected();
       }
+      getIsPersistent() {
+        return this.isPersistent;
+      }
       // ─── Tab Management ────────────────────────────────────────
       async newTab(url) {
         if (!this.context) throw new Error("Browser not launched");
@@ -950,6 +1106,11 @@ var init_browser_manager = __esm({
        * Cannot preserve: localStorage/sessionStorage (bound to old context).
        */
       async recreateContext(contextOptions) {
+        if (this.isPersistent) {
+          throw new Error(
+            "Cannot change device/viewport/user-agent in profile mode \u2014 profiles use a fixed browser context. Use --session instead."
+          );
+        }
         if (!this.browser) return;
         if (this.videoRecording && !contextOptions.recordVideo) {
           contextOptions = {
@@ -1149,8 +1310,8 @@ var init_browser_manager = __esm({
       // ─── Video Recording ──────────────────────────────────────
       async startVideoRecording(dir) {
         if (this.videoRecording) throw new Error("Video recording already active");
-        const fs15 = await import("fs");
-        fs15.mkdirSync(dir, { recursive: true });
+        const fs16 = await import("fs");
+        fs16.mkdirSync(dir, { recursive: true });
         this.videoRecording = { dir, startedAt: Date.now() };
         const viewport = this.currentDevice?.viewport || { width: 1920, height: 1080 };
         await this.recreateContext({
@@ -1425,24 +1586,10 @@ var init_domain_filter = __esm({
   }
 });
 
-// src/sanitize.ts
-function sanitizeName(name) {
-  const sanitized = name.replace(/[\/\\]/g, "_").replace(/\.\./g, "_");
-  if (!sanitized || /^[._]+$/.test(sanitized)) {
-    throw new Error(`Invalid name: "${name}"`);
-  }
-  return sanitized;
-}
-var init_sanitize = __esm({
-  "src/sanitize.ts"() {
-    "use strict";
-  }
-});
-
 // src/encryption.ts
 import * as crypto from "crypto";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function resolveEncryptionKey(localDir) {
   const envKey = process.env.BROWSE_ENCRYPTION_KEY;
   if (envKey) {
@@ -1451,13 +1598,13 @@ function resolveEncryptionKey(localDir) {
     }
     return Buffer.from(envKey, "hex");
   }
-  const keyPath = path4.join(localDir, ".encryption-key");
-  if (fs4.existsSync(keyPath)) {
-    const hex = fs4.readFileSync(keyPath, "utf-8").trim();
+  const keyPath = path5.join(localDir, ".encryption-key");
+  if (fs5.existsSync(keyPath)) {
+    const hex = fs5.readFileSync(keyPath, "utf-8").trim();
     return Buffer.from(hex, "hex");
   }
   const key = crypto.randomBytes(32);
-  fs4.writeFileSync(keyPath, key.toString("hex") + "\n", { mode: 384 });
+  fs5.writeFileSync(keyPath, key.toString("hex") + "\n", { mode: 384 });
   return key;
 }
 function encrypt(plaintext, key) {
@@ -1497,8 +1644,8 @@ __export(session_persist_exports, {
   loadSessionState: () => loadSessionState,
   saveSessionState: () => saveSessionState
 });
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 async function saveSessionState(sessionDir, context, encryptionKey) {
   try {
     const state = await context.storageState();
@@ -1510,20 +1657,20 @@ async function saveSessionState(sessionDir, context, encryptionKey) {
     } else {
       content = json;
     }
-    fs5.mkdirSync(sessionDir, { recursive: true });
-    fs5.writeFileSync(path5.join(sessionDir, STATE_FILENAME), content, { mode: 384 });
+    fs6.mkdirSync(sessionDir, { recursive: true });
+    fs6.writeFileSync(path6.join(sessionDir, STATE_FILENAME), content, { mode: 384 });
   } catch (err) {
     console.log(`[session-persist] Warning: failed to save state: ${err.message}`);
   }
 }
 async function loadSessionState(sessionDir, context, encryptionKey) {
-  const statePath = path5.join(sessionDir, STATE_FILENAME);
-  if (!fs5.existsSync(statePath)) {
+  const statePath = path6.join(sessionDir, STATE_FILENAME);
+  if (!fs6.existsSync(statePath)) {
     return false;
   }
   let stateData;
   try {
-    const raw = fs5.readFileSync(statePath, "utf-8");
+    const raw = fs6.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.encrypted) {
       if (!encryptionKey) {
@@ -1579,24 +1726,24 @@ async function loadSessionState(sessionDir, context, encryptionKey) {
   }
 }
 function hasPersistedState(sessionDir) {
-  return fs5.existsSync(path5.join(sessionDir, STATE_FILENAME));
+  return fs6.existsSync(path6.join(sessionDir, STATE_FILENAME));
 }
 function cleanOldStates(localDir, maxAgeDays) {
   const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1e3;
   const now = Date.now();
   let deleted = 0;
-  const statesDir = path5.join(localDir, "states");
-  if (fs5.existsSync(statesDir)) {
+  const statesDir = path6.join(localDir, "states");
+  if (fs6.existsSync(statesDir)) {
     try {
-      const entries = fs5.readdirSync(statesDir);
+      const entries = fs6.readdirSync(statesDir);
       for (const entry of entries) {
         if (!entry.endsWith(".json")) continue;
-        const filePath = path5.join(statesDir, entry);
+        const filePath = path6.join(statesDir, entry);
         try {
-          const stat = fs5.statSync(filePath);
+          const stat = fs6.statSync(filePath);
           if (!stat.isFile()) continue;
           if (now - stat.mtimeMs > maxAgeMs) {
-            fs5.unlinkSync(filePath);
+            fs6.unlinkSync(filePath);
             deleted++;
           }
         } catch (_) {
@@ -1605,23 +1752,23 @@ function cleanOldStates(localDir, maxAgeDays) {
     } catch (_) {
     }
   }
-  const sessionsDir = path5.join(localDir, "sessions");
-  if (fs5.existsSync(sessionsDir)) {
+  const sessionsDir = path6.join(localDir, "sessions");
+  if (fs6.existsSync(sessionsDir)) {
     try {
-      const sessionDirs = fs5.readdirSync(sessionsDir);
+      const sessionDirs = fs6.readdirSync(sessionsDir);
       for (const dir of sessionDirs) {
-        const dirPath = path5.join(sessionsDir, dir);
+        const dirPath = path6.join(sessionsDir, dir);
         try {
-          const dirStat = fs5.statSync(dirPath);
+          const dirStat = fs6.statSync(dirPath);
           if (!dirStat.isDirectory()) continue;
         } catch (_) {
           continue;
         }
-        const statePath = path5.join(dirPath, STATE_FILENAME);
+        const statePath = path6.join(dirPath, STATE_FILENAME);
         try {
-          const stat = fs5.statSync(statePath);
+          const stat = fs6.statSync(statePath);
           if (now - stat.mtimeMs > maxAgeMs) {
-            fs5.unlinkSync(statePath);
+            fs6.unlinkSync(statePath);
             deleted++;
           }
         } catch (_) {
@@ -1642,8 +1789,8 @@ var init_session_persist = __esm({
 });
 
 // src/session-manager.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 var SessionManager;
 var init_session_manager = __esm({
   "src/session-manager.ts"() {
@@ -1706,8 +1853,8 @@ var init_session_manager = __esm({
           }
           return session;
         }
-        const outputDir = path6.join(this.localDir, "sessions", sanitizeName(sessionId));
-        fs6.mkdirSync(outputDir, { recursive: true });
+        const outputDir = path7.join(this.localDir, "sessions", sanitizeName(sessionId));
+        fs7.mkdirSync(outputDir, { recursive: true });
         const buffers = new SessionBuffers();
         const manager = new BrowserManager(buffers);
         await manager.launchWithBrowser(this.browser);
@@ -1843,7 +1990,7 @@ var read_exports = {};
 __export(read_exports, {
   handleReadCommand: () => handleReadCommand
 });
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 async function handleReadCommand(command, args, bm, buffers) {
   const page = bm.getPage();
   const evalCtx = await bm.getFrameContext() || page;
@@ -1938,8 +2085,8 @@ async function handleReadCommand(command, args, bm, buffers) {
     case "eval": {
       const filePath = args[0];
       if (!filePath) throw new Error("Usage: browse eval <js-file>");
-      if (!fs7.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
-      const code = fs7.readFileSync(filePath, "utf-8");
+      if (!fs8.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+      const code = fs8.readFileSync(filePath, "utf-8");
       const result = await evalCtx.evaluate(code);
       return typeof result === "object" ? JSON.stringify(result, null, 2) : String(result ?? "");
     }
@@ -2190,7 +2337,7 @@ var write_exports = {};
 __export(write_exports, {
   handleWriteCommand: () => handleWriteCommand
 });
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 async function rebuildRoutes(context, bm, domainFilter) {
   await context.unrouteAll();
   for (const r of bm.getUserRoutes()) {
@@ -2394,14 +2541,14 @@ async function handleWriteCommand(command, args, bm, domainFilter) {
         const file = args[1];
         if (!file) throw new Error("Usage: browse cookie export <file>");
         const cookies = await page.context().cookies();
-        fs8.writeFileSync(file, JSON.stringify(cookies, null, 2));
+        fs9.writeFileSync(file, JSON.stringify(cookies, null, 2));
         return `Exported ${cookies.length} cookie(s) to ${file}`;
       }
       if (cookieStr === "import") {
         const file = args[1];
         if (!file) throw new Error("Usage: browse cookie import <file>");
-        if (!fs8.existsSync(file)) throw new Error(`File not found: ${file}`);
-        const cookies = JSON.parse(fs8.readFileSync(file, "utf-8"));
+        if (!fs9.existsSync(file)) throw new Error(`File not found: ${file}`);
+        const cookies = JSON.parse(fs9.readFileSync(file, "utf-8"));
         if (!Array.isArray(cookies)) throw new Error("Cookie file must contain a JSON array of cookie objects");
         await page.context().addCookies(cookies);
         return `Imported ${cookies.length} cookie(s) from ${file}`;
@@ -2468,7 +2615,7 @@ Note: Cookies and tab URLs preserved. localStorage/sessionStorage were reset (Pl
       const [selector, ...filePaths] = args;
       if (!selector || filePaths.length === 0) throw new Error("Usage: browse upload <selector> <file1> [file2] ...");
       for (const fp of filePaths) {
-        if (!fs8.existsSync(fp)) throw new Error(`File not found: ${fp}`);
+        if (!fs9.existsSync(fp)) throw new Error(`File not found: ${fp}`);
       }
       const resolved = bm.resolveRef(selector);
       if ("locator" in resolved) {
@@ -3535,11 +3682,11 @@ var init_lib = __esm({
           }
         }
       },
-      addToPath: function addToPath(path12, added, removed, oldPosInc, options) {
-        var last = path12.lastComponent;
+      addToPath: function addToPath(path13, added, removed, oldPosInc, options) {
+        var last = path13.lastComponent;
         if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
           return {
-            oldPos: path12.oldPos + oldPosInc,
+            oldPos: path13.oldPos + oldPosInc,
             lastComponent: {
               count: last.count + 1,
               added,
@@ -3549,7 +3696,7 @@ var init_lib = __esm({
           };
         } else {
           return {
-            oldPos: path12.oldPos + oldPosInc,
+            oldPos: path13.oldPos + oldPosInc,
             lastComponent: {
               count: 1,
               added,
@@ -3607,7 +3754,7 @@ var init_lib = __esm({
       tokenize: function tokenize(value) {
         return Array.from(value);
       },
-      join: function join8(chars) {
+      join: function join9(chars) {
         return chars.join("");
       },
       postProcess: function postProcess(changeObjects) {
@@ -3772,14 +3919,14 @@ var policy_exports = {};
 __export(policy_exports, {
   PolicyChecker: () => PolicyChecker
 });
-import * as fs9 from "fs";
-import * as path7 from "path";
+import * as fs10 from "fs";
+import * as path8 from "path";
 function findFileUpward(filename) {
   let dir = process.cwd();
   for (let i = 0; i < 20; i++) {
-    const candidate = path7.join(dir, filename);
-    if (fs9.existsSync(candidate)) return candidate;
-    const parent = path7.dirname(dir);
+    const candidate = path8.join(dir, filename);
+    if (fs10.existsSync(candidate)) return candidate;
+    const parent = path8.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -3807,10 +3954,10 @@ var init_policy = __esm({
       reload() {
         if (!this.filePath) return;
         try {
-          const stat = fs9.statSync(this.filePath);
+          const stat = fs10.statSync(this.filePath);
           if (stat.mtimeMs === this.lastMtime) return;
           this.lastMtime = stat.mtimeMs;
-          const raw = fs9.readFileSync(this.filePath, "utf-8");
+          const raw = fs10.readFileSync(this.filePath, "utf-8");
           this.policy = JSON.parse(raw);
         } catch {
         }
@@ -4029,8 +4176,8 @@ var auth_vault_exports = {};
 __export(auth_vault_exports, {
   AuthVault: () => AuthVault
 });
-import * as fs10 from "fs";
-import * as path8 from "path";
+import * as fs11 from "fs";
+import * as path9 from "path";
 async function autoDetectSelector(page, field) {
   if (field === "username") {
     const candidates2 = [
@@ -4088,11 +4235,11 @@ var init_auth_vault = __esm({
       authDir;
       encryptionKey;
       constructor(localDir) {
-        this.authDir = path8.join(localDir, "auth");
+        this.authDir = path9.join(localDir, "auth");
         this.encryptionKey = resolveEncryptionKey(localDir);
       }
       save(name, url, username, password, selectors) {
-        fs10.mkdirSync(this.authDir, { recursive: true });
+        fs11.mkdirSync(this.authDir, { recursive: true });
         const { ciphertext, iv, authTag } = encrypt(password, this.encryptionKey);
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const credential = {
@@ -4109,15 +4256,15 @@ var init_auth_vault = __esm({
           createdAt: now,
           updatedAt: now
         };
-        const filePath = path8.join(this.authDir, `${sanitizeName(name)}.json`);
-        fs10.writeFileSync(filePath, JSON.stringify(credential, null, 2), { mode: 384 });
+        const filePath = path9.join(this.authDir, `${sanitizeName(name)}.json`);
+        fs11.writeFileSync(filePath, JSON.stringify(credential, null, 2), { mode: 384 });
       }
       load(name) {
-        const filePath = path8.join(this.authDir, `${sanitizeName(name)}.json`);
-        if (!fs10.existsSync(filePath)) {
+        const filePath = path9.join(this.authDir, `${sanitizeName(name)}.json`);
+        if (!fs11.existsSync(filePath)) {
           throw new Error(`Credential "${name}" not found. Run "browse auth list" to see saved credentials.`);
         }
-        return JSON.parse(fs10.readFileSync(filePath, "utf-8"));
+        return JSON.parse(fs11.readFileSync(filePath, "utf-8"));
       }
       async login(name, bm) {
         const cred = this.load(name);
@@ -4138,11 +4285,11 @@ var init_auth_vault = __esm({
         return `Logged in as ${cred.username} at ${page.url()}`;
       }
       list() {
-        if (!fs10.existsSync(this.authDir)) return [];
-        const files = fs10.readdirSync(this.authDir).filter((f) => f.endsWith(".json"));
+        if (!fs11.existsSync(this.authDir)) return [];
+        const files = fs11.readdirSync(this.authDir).filter((f) => f.endsWith(".json"));
         return files.map((f) => {
           try {
-            const data = JSON.parse(fs10.readFileSync(path8.join(this.authDir, f), "utf-8"));
+            const data = JSON.parse(fs11.readFileSync(path9.join(this.authDir, f), "utf-8"));
             return {
               name: data.name,
               url: data.url,
@@ -4156,11 +4303,11 @@ var init_auth_vault = __esm({
         }).filter(Boolean);
       }
       delete(name) {
-        const filePath = path8.join(this.authDir, `${sanitizeName(name)}.json`);
-        if (!fs10.existsSync(filePath)) {
+        const filePath = path9.join(this.authDir, `${sanitizeName(name)}.json`);
+        if (!fs11.existsSync(filePath)) {
           throw new Error(`Credential "${name}" not found.`);
         }
-        fs10.unlinkSync(filePath);
+        fs11.unlinkSync(filePath);
       }
     };
   }
@@ -4177,15 +4324,15 @@ __export(cookie_import_exports, {
 import Database from "better-sqlite3";
 import { spawn as spawn2 } from "child_process";
 import * as crypto2 from "crypto";
-import * as fs11 from "fs";
-import * as path9 from "path";
+import * as fs12 from "fs";
+import * as path10 from "path";
 import * as os2 from "os";
 function findInstalledBrowsers() {
-  const appSupport = path9.join(os2.homedir(), "Library", "Application Support");
+  const appSupport = path10.join(os2.homedir(), "Library", "Application Support");
   return BROWSER_REGISTRY.filter((b) => {
-    const dbPath = path9.join(appSupport, b.dataDir, "Default", "Cookies");
+    const dbPath = path10.join(appSupport, b.dataDir, "Default", "Cookies");
     try {
-      return fs11.existsSync(dbPath);
+      return fs12.existsSync(dbPath);
     } catch {
       return false;
     }
@@ -4268,9 +4415,9 @@ function validateProfile(profile) {
 }
 function getCookieDbPath(browser2, profile) {
   validateProfile(profile);
-  const appSupport = path9.join(os2.homedir(), "Library", "Application Support");
-  const dbPath = path9.join(appSupport, browser2.dataDir, profile, "Cookies");
-  if (!fs11.existsSync(dbPath)) {
+  const appSupport = path10.join(os2.homedir(), "Library", "Application Support");
+  const dbPath = path10.join(appSupport, browser2.dataDir, profile, "Cookies");
+  if (!fs12.existsSync(dbPath)) {
     throw new CookieImportError(
       `${browser2.name} is not installed (no cookie database at ${dbPath})`,
       "not_installed"
@@ -4297,32 +4444,32 @@ function openDb(dbPath, browserName) {
 function openDbFromCopy(dbPath, browserName) {
   const tmpPath = `/tmp/browse-cookies-${browserName.toLowerCase()}-${crypto2.randomUUID()}.db`;
   try {
-    fs11.copyFileSync(dbPath, tmpPath);
+    fs12.copyFileSync(dbPath, tmpPath);
     const walPath = dbPath + "-wal";
     const shmPath = dbPath + "-shm";
-    if (fs11.existsSync(walPath)) fs11.copyFileSync(walPath, tmpPath + "-wal");
-    if (fs11.existsSync(shmPath)) fs11.copyFileSync(shmPath, tmpPath + "-shm");
+    if (fs12.existsSync(walPath)) fs12.copyFileSync(walPath, tmpPath + "-wal");
+    if (fs12.existsSync(shmPath)) fs12.copyFileSync(shmPath, tmpPath + "-shm");
     const db = new Database(tmpPath, { readonly: true });
     const origClose = db.close.bind(db);
     db.close = (() => {
       origClose();
       try {
-        fs11.unlinkSync(tmpPath);
+        fs12.unlinkSync(tmpPath);
       } catch {
       }
       try {
-        fs11.unlinkSync(tmpPath + "-wal");
+        fs12.unlinkSync(tmpPath + "-wal");
       } catch {
       }
       try {
-        fs11.unlinkSync(tmpPath + "-shm");
+        fs12.unlinkSync(tmpPath + "-shm");
       } catch {
       }
     });
     return db;
   } catch {
     try {
-      fs11.unlinkSync(tmpPath);
+      fs12.unlinkSync(tmpPath);
     } catch {
     }
     throw new CookieImportError(
@@ -4620,7 +4767,7 @@ var init_record_export = __esm({
 });
 
 // src/commands/meta.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2, currentSession) {
   switch (command) {
     // ─── Tabs ──────────────────────────────────────────
@@ -4702,7 +4849,7 @@ async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2,
           const lines = entries.map(
             (e) => `[${new Date(e.timestamp).toISOString()}] [${e.level}] ${e.text}`
           ).join("\n") + "\n";
-          fs12.appendFileSync(consolePath, lines);
+          fs13.appendFileSync(consolePath, lines);
           buffers.lastConsoleFlushed = buffers.consoleTotalAdded;
         }
         const newNetworkCount = buffers.networkTotalAdded - buffers.lastNetworkFlushed;
@@ -4712,7 +4859,7 @@ async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2,
           const lines = entries.map(
             (e) => `[${new Date(e.timestamp).toISOString()}] ${e.method} ${e.url} \u2192 ${e.status || "pending"} (${e.duration || "?"}ms, ${e.size || "?"}B)`
           ).join("\n") + "\n";
-          fs12.appendFileSync(networkPath, lines);
+          fs13.appendFileSync(networkPath, lines);
           buffers.lastNetworkFlushed = buffers.networkTotalAdded;
         }
       }
@@ -4729,22 +4876,22 @@ async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2,
       const statesDir = `${LOCAL_DIR}/states`;
       const statePath = `${statesDir}/${name}.json`;
       if (subcommand === "list") {
-        if (!fs12.existsSync(statesDir)) return "(no saved states)";
-        const files = fs12.readdirSync(statesDir).filter((f) => f.endsWith(".json"));
+        if (!fs13.existsSync(statesDir)) return "(no saved states)";
+        const files = fs13.readdirSync(statesDir).filter((f) => f.endsWith(".json"));
         if (files.length === 0) return "(no saved states)";
         const lines = [];
         for (const file of files) {
           const fp = `${statesDir}/${file}`;
-          const stat = fs12.statSync(fp);
+          const stat = fs13.statSync(fp);
           lines.push(`  ${file.replace(".json", "")}  ${stat.size}B  ${new Date(stat.mtimeMs).toISOString()}`);
         }
         return lines.join("\n");
       }
       if (subcommand === "show") {
-        if (!fs12.existsSync(statePath)) {
+        if (!fs13.existsSync(statePath)) {
           throw new Error(`State file not found: ${statePath}`);
         }
-        const data = JSON.parse(fs12.readFileSync(statePath, "utf-8"));
+        const data = JSON.parse(fs13.readFileSync(statePath, "utf-8"));
         const cookieCount = data.cookies?.length || 0;
         const originCount = data.origins?.length || 0;
         const storageItems = (data.origins || []).reduce((sum, o) => sum + (o.localStorage?.length || 0), 0);
@@ -4769,15 +4916,15 @@ async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2,
         const context = bm.getContext();
         if (!context) throw new Error("No browser context");
         const state = await context.storageState();
-        fs12.mkdirSync(statesDir, { recursive: true });
-        fs12.writeFileSync(statePath, JSON.stringify(state, null, 2), { mode: 384 });
+        fs13.mkdirSync(statesDir, { recursive: true });
+        fs13.writeFileSync(statePath, JSON.stringify(state, null, 2), { mode: 384 });
         return `State saved: ${statePath}`;
       }
       if (subcommand === "load") {
-        if (!fs12.existsSync(statePath)) {
+        if (!fs13.existsSync(statePath)) {
           throw new Error(`State file not found: ${statePath}. Run "browse state save ${name}" first.`);
         }
-        const stateData = JSON.parse(fs12.readFileSync(statePath, "utf-8"));
+        const stateData = JSON.parse(fs13.readFileSync(statePath, "utf-8"));
         const context = bm.getContext();
         if (!context) throw new Error("No browser context");
         const warnings = [];
@@ -4936,9 +5083,9 @@ ${legend.join("\n")}`;
       try {
         for (const vp of viewports) {
           await page.setViewportSize({ width: vp.width, height: vp.height });
-          const path12 = `${prefix}-${vp.name}.png`;
-          await page.screenshot({ path: path12, fullPage: true });
-          results.push(`${vp.name} (${vp.width}x${vp.height}): ${path12}`);
+          const path13 = `${prefix}-${vp.name}.png`;
+          await page.screenshot({ path: path13, fullPage: true });
+          results.push(`${vp.name} (${vp.width}x${vp.height}): ${path13}`);
         }
       } finally {
         if (originalViewport) {
@@ -5082,13 +5229,13 @@ ${legend.join("\n")}`;
       const diffArgs = args.filter((a) => a !== "--full");
       const baseline = diffArgs[0];
       if (!baseline) throw new Error("Usage: browse screenshot-diff <baseline> [current] [--threshold 0.1] [--full]");
-      if (!fs12.existsSync(baseline)) throw new Error(`Baseline file not found: ${baseline}`);
+      if (!fs13.existsSync(baseline)) throw new Error(`Baseline file not found: ${baseline}`);
       let thresholdPct = 0.1;
       const threshIdx = diffArgs.indexOf("--threshold");
       if (threshIdx !== -1 && diffArgs[threshIdx + 1]) {
         thresholdPct = parseFloat(diffArgs[threshIdx + 1]);
       }
-      const baselineBuffer = fs12.readFileSync(baseline);
+      const baselineBuffer = fs13.readFileSync(baseline);
       let currentBuffer;
       let currentPath;
       for (let i = 1; i < diffArgs.length; i++) {
@@ -5102,8 +5249,8 @@ ${legend.join("\n")}`;
         }
       }
       if (currentPath) {
-        if (!fs12.existsSync(currentPath)) throw new Error(`Current screenshot not found: ${currentPath}`);
-        currentBuffer = fs12.readFileSync(currentPath);
+        if (!fs13.existsSync(currentPath)) throw new Error(`Current screenshot not found: ${currentPath}`);
+        currentBuffer = fs13.readFileSync(currentPath);
       } else {
         const page = bm.getPage();
         currentBuffer = await page.screenshot({ fullPage: isFullPageDiff });
@@ -5113,7 +5260,7 @@ ${legend.join("\n")}`;
       const extIdx = baseline.lastIndexOf(".");
       const diffPath = extIdx > 0 ? baseline.slice(0, extIdx) + "-diff" + baseline.slice(extIdx) : baseline + "-diff.png";
       if (!result.passed && result.diffImage) {
-        fs12.writeFileSync(diffPath, result.diffImage);
+        fs13.writeFileSync(diffPath, result.diffImage);
       }
       return [
         `Pixels: ${result.totalPixels}`,
@@ -5249,7 +5396,7 @@ ${legend.join("\n")}`;
         const { formatAsHar: formatAsHar2 } = await Promise.resolve().then(() => (init_har(), har_exports));
         const har = formatAsHar2(sessionBuffers.networkBuffer, recording.startTime);
         const harPath = args[1] || (currentSession ? `${currentSession.outputDir}/recording.har` : `${LOCAL_DIR}/browse-recording.har`);
-        fs12.writeFileSync(harPath, JSON.stringify(har, null, 2));
+        fs13.writeFileSync(harPath, JSON.stringify(har, null, 2));
         const entryCount = har.log.entries.length;
         return `HAR saved: ${harPath} (${entryCount} entries)`;
       }
@@ -5469,13 +5616,52 @@ Manual: npm install -g @ulpi/browse`;
         }
         const filePath = args[2];
         if (filePath) {
-          fs12.writeFileSync(filePath, output);
+          fs13.writeFileSync(filePath, output);
           return `Exported ${steps.length} steps as ${format}: ${filePath}`;
         }
         return output;
       }
       throw new Error("Usage: browse record start | stop | status | export browse|replay [path]");
     }
+    // ─── Profile Management ────────────────────────────────
+    case "profile": {
+      const subcommand = args[0];
+      if (!subcommand) throw new Error("Usage: browse profile list | delete <name> | clean [--older-than <days>]");
+      if (subcommand === "list") {
+        const { listProfiles: listProfiles2 } = await Promise.resolve().then(() => (init_browser_manager(), browser_manager_exports));
+        const profiles = listProfiles2(LOCAL_DIR);
+        if (profiles.length === 0) return "No profiles found";
+        return profiles.map((p) => `${p.name}  ${p.size}  last used: ${p.lastUsed}`).join("\n");
+      }
+      if (subcommand === "delete") {
+        const name = args[1];
+        if (!name) throw new Error("Usage: browse profile delete <name>");
+        const { deleteProfile: deleteProfile2 } = await Promise.resolve().then(() => (init_browser_manager(), browser_manager_exports));
+        deleteProfile2(LOCAL_DIR, name);
+        return `Profile "${name}" deleted`;
+      }
+      if (subcommand === "clean") {
+        const { listProfiles: listProfiles2, deleteProfile: deleteProfile2 } = await Promise.resolve().then(() => (init_browser_manager(), browser_manager_exports));
+        let maxDays = 7;
+        const olderIdx = args.indexOf("--older-than");
+        if (olderIdx !== -1 && args[olderIdx + 1]) {
+          maxDays = parseInt(args[olderIdx + 1], 10);
+          if (isNaN(maxDays)) throw new Error("Usage: browse profile clean --older-than <days>");
+        }
+        const profiles = listProfiles2(LOCAL_DIR);
+        const cutoff = /* @__PURE__ */ new Date();
+        cutoff.setDate(cutoff.getDate() - maxDays);
+        let cleaned = 0;
+        for (const p of profiles) {
+          if (new Date(p.lastUsed) < cutoff) {
+            deleteProfile2(LOCAL_DIR, p.name);
+            cleaned++;
+          }
+        }
+        return cleaned > 0 ? `Cleaned ${cleaned} profile(s) older than ${maxDays} days` : "No profiles to clean";
+      }
+      throw new Error("Usage: browse profile list | delete <name> | clean [--older-than <days>]");
+    }
     default:
       throw new Error(`Unknown meta command: ${command}`);
   }
@@ -5494,8 +5680,8 @@ var init_meta = __esm({
 
 // src/server.ts
 var server_exports = {};
-import * as fs13 from "fs";
-import * as path10 from "path";
+import * as fs14 from "fs";
+import * as path11 from "path";
 import * as crypto3 from "crypto";
 import * as http from "http";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -5531,9 +5717,13 @@ function validateAuth(req) {
   const header = req.headers.get("authorization");
   return header === `Bearer ${AUTH_TOKEN}`;
 }
-function flushAllBuffers(sessionManager2, final = false) {
-  for (const session of sessionManager2.getAllSessions()) {
-    flushSessionBuffers(session, final);
+function flushAllBuffers(sm, final = false) {
+  if (sm) {
+    for (const session of sm.getAllSessions()) {
+      flushSessionBuffers(session, final);
+    }
+  } else if (profileSession) {
+    flushSessionBuffers(profileSession, final);
   }
 }
 function flushSessionBuffers(session, final) {
@@ -5547,7 +5737,7 @@ function flushSessionBuffers(session, final) {
     const lines = newEntries.map(
       (e) => `[${new Date(e.timestamp).toISOString()}] [${e.level}] ${e.text}`
     ).join("\n") + "\n";
-    fs13.appendFileSync(consolePath, lines);
+    fs14.appendFileSync(consolePath, lines);
     buffers.lastConsoleFlushed = buffers.consoleTotalAdded;
   }
   let newNetworkCount = buffers.networkTotalAdded - buffers.lastNetworkFlushed;
@@ -5572,7 +5762,7 @@ function flushSessionBuffers(session, final) {
       const lines = prefix.map(
         (e) => `[${new Date(e.timestamp).toISOString()}] ${e.method} ${e.url} \u2192 ${e.status || "pending"} (${e.duration || "?"}ms, ${e.size || "?"}B)`
       ).join("\n") + "\n";
-      fs13.appendFileSync(networkPath, lines);
+      fs14.appendFileSync(networkPath, lines);
       buffers.lastNetworkFlushed += prefixLen;
     }
   }
@@ -5686,7 +5876,7 @@ async function handleCommand(body, session, opts) {
     } else if (WRITE_COMMANDS.has(command)) {
       result = await handleWriteCommand(command, args, session.manager, session.domainFilter);
     } else if (META_COMMANDS.has(command)) {
-      result = await handleMetaCommand(command, args, session.manager, shutdown, sessionManager, session);
+      result = await handleMetaCommand(command, args, session.manager, shutdown, sessionManager ?? void 0, session);
     } else {
       const error = `Unknown command: ${command}`;
       const hint = `Available commands: ${[...READ_COMMANDS, ...WRITE_COMMANDS, ...META_COMMANDS].sort().join(", ")}`;
@@ -5745,18 +5935,23 @@ async function shutdown() {
   clearInterval(flushInterval);
   clearInterval(sessionCleanupInterval);
   flushAllBuffers(sessionManager, true);
-  await sessionManager.closeAll();
-  if (browser && !isRemoteBrowser) {
-    browser.removeAllListeners("disconnected");
-    await browser.close().catch(() => {
+  if (profileSession) {
+    await profileSession.manager.close().catch(() => {
     });
+  } else if (sessionManager) {
+    await sessionManager.closeAll();
+    if (browser && !isRemoteBrowser) {
+      browser.removeAllListeners("disconnected");
+      await browser.close().catch(() => {
+      });
+    }
   }
   await activeRuntime?.close?.().catch(() => {
   });
   try {
-    const currentState = JSON.parse(fs13.readFileSync(STATE_FILE, "utf-8"));
+    const currentState = JSON.parse(fs14.readFileSync(STATE_FILE, "utf-8"));
     if (currentState.pid === process.pid || currentState.token === AUTH_TOKEN) {
-      fs13.unlinkSync(STATE_FILE);
+      fs14.unlinkSync(STATE_FILE);
     }
   } catch {
   }
@@ -5768,38 +5963,65 @@ async function start() {
   const runtime = await getRuntime(runtimeName);
   activeRuntime = runtime;
   console.log(`[browse] Runtime: ${runtime.name}`);
-  const cdpUrl = process.env.BROWSE_CDP_URL;
-  if (cdpUrl) {
-    browser = await runtime.chromium.connectOverCDP(cdpUrl);
-    isRemoteBrowser = true;
-    console.log(`[browse] Connected to remote Chrome via CDP: ${cdpUrl}`);
-  } else if (runtime.browser) {
-    browser = runtime.browser;
-    browser.on("disconnected", () => {
+  const profileName = process.env.BROWSE_PROFILE;
+  if (profileName) {
+    const { BrowserManager: BrowserManager2, getProfileDir: getProfileDir2 } = await Promise.resolve().then(() => (init_browser_manager(), browser_manager_exports));
+    const { SessionBuffers: SessionBuffers2 } = await Promise.resolve().then(() => (init_buffers(), buffers_exports));
+    const profileDir = getProfileDir2(LOCAL_DIR2, profileName);
+    fs14.mkdirSync(profileDir, { recursive: true });
+    const bm = new BrowserManager2();
+    await bm.launchPersistent(profileDir, () => {
       if (isShuttingDown) return;
-      console.error("[browse] Browser disconnected. Shutting down.");
+      console.error("[browse] Chromium disconnected (profile mode). Shutting down.");
       shutdown();
     });
+    const outputDir = path11.join(LOCAL_DIR2, "sessions", profileName);
+    fs14.mkdirSync(outputDir, { recursive: true });
+    profileSession = {
+      id: profileName,
+      manager: bm,
+      buffers: new SessionBuffers2(),
+      domainFilter: null,
+      recording: null,
+      outputDir,
+      lastActivity: Date.now(),
+      createdAt: Date.now()
+    };
+    console.log(`[browse] Profile mode: "${profileName}" (${profileDir})`);
   } else {
-    const launchOptions = { headless: process.env.BROWSE_HEADED !== "1" };
-    if (DEBUG_PORT > 0) {
-      launchOptions.args = [`--remote-debugging-port=${DEBUG_PORT}`];
-    }
-    const proxyServer = process.env.BROWSE_PROXY;
-    if (proxyServer) {
-      launchOptions.proxy = { server: proxyServer };
-      if (process.env.BROWSE_PROXY_BYPASS) {
-        launchOptions.proxy.bypass = process.env.BROWSE_PROXY_BYPASS;
+    const cdpUrl = process.env.BROWSE_CDP_URL;
+    if (cdpUrl) {
+      browser = await runtime.chromium.connectOverCDP(cdpUrl);
+      isRemoteBrowser = true;
+      console.log(`[browse] Connected to remote Chrome via CDP: ${cdpUrl}`);
+    } else if (runtime.browser) {
+      browser = runtime.browser;
+      browser.on("disconnected", () => {
+        if (isShuttingDown) return;
+        console.error("[browse] Browser disconnected. Shutting down.");
+        shutdown();
+      });
+    } else {
+      const launchOptions = { headless: process.env.BROWSE_HEADED !== "1" };
+      if (DEBUG_PORT > 0) {
+        launchOptions.args = [`--remote-debugging-port=${DEBUG_PORT}`];
       }
+      const proxyServer = process.env.BROWSE_PROXY;
+      if (proxyServer) {
+        launchOptions.proxy = { server: proxyServer };
+        if (process.env.BROWSE_PROXY_BYPASS) {
+          launchOptions.proxy.bypass = process.env.BROWSE_PROXY_BYPASS;
+        }
+      }
+      browser = await runtime.chromium.launch(launchOptions);
+      browser.on("disconnected", () => {
+        if (isShuttingDown) return;
+        console.error("[browse] Chromium disconnected. Shutting down.");
+        shutdown();
+      });
     }
-    browser = await runtime.chromium.launch(launchOptions);
-    browser.on("disconnected", () => {
-      if (isShuttingDown) return;
-      console.error("[browse] Chromium disconnected. Shutting down.");
-      shutdown();
-    });
+    sessionManager = new SessionManager(browser, LOCAL_DIR2);
   }
-  sessionManager = new SessionManager(browser, LOCAL_DIR2);
   const startTime = Date.now();
   const server = nodeServe({
     port,
@@ -5807,11 +6029,20 @@ async function start() {
     fetch: async (req) => {
       const url = new URL(req.url);
       if (url.pathname === "/health") {
-        const healthy = !isShuttingDown && browser.isConnected();
+        let healthy;
+        let sessionCount;
+        if (profileSession) {
+          healthy = !isShuttingDown && !!profileSession.manager.getContext();
+          sessionCount = 1;
+        } else {
+          healthy = !isShuttingDown && !!browser && browser.isConnected();
+          sessionCount = sessionManager ? sessionManager.getSessionCount() : 0;
+        }
         return new Response(JSON.stringify({
           status: healthy ? "healthy" : "unhealthy",
           uptime: Math.floor((Date.now() - startTime) / 1e3),
-          sessions: sessionManager.getSessionCount()
+          sessions: sessionCount,
+          ...profileName ? { profile: profileName } : {}
         }), {
           status: 200,
           headers: { "Content-Type": "application/json" }
@@ -5825,15 +6056,21 @@ async function start() {
       }
       if (url.pathname === "/command" && req.method === "POST") {
         const body = await req.json();
-        const sessionId = req.headers.get("x-browse-session") || "default";
-        const allowedDomains = req.headers.get("x-browse-allowed-domains") || void 0;
-        const session = await sessionManager.getOrCreate(sessionId, allowedDomains);
+        let session;
+        if (profileSession) {
+          session = profileSession;
+          session.lastActivity = Date.now();
+        } else {
+          const sessionId = req.headers.get("x-browse-session") || "default";
+          const allowedDomains = req.headers.get("x-browse-allowed-domains") || void 0;
+          session = await sessionManager.getOrCreate(sessionId, allowedDomains);
+        }
         const stateFilePath = req.headers.get("x-browse-state");
         if (stateFilePath) {
           const context = session.manager.getContext();
           if (context) {
             try {
-              const stateData = JSON.parse(fs13.readFileSync(stateFilePath, "utf-8"));
+              const stateData = JSON.parse(fs14.readFileSync(stateFilePath, "utf-8"));
               if (stateData.cookies?.length) {
                 await context.addCookies(stateData.cookies);
               }
@@ -5860,17 +6097,20 @@ async function start() {
     port,
     token: AUTH_TOKEN,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    serverPath: path10.resolve(path10.dirname(fileURLToPath2(import.meta.url)), "server.ts")
+    serverPath: path11.resolve(path11.dirname(fileURLToPath2(import.meta.url)), "server.ts")
   };
+  if (profileName) {
+    state.profile = profileName;
+  }
   if (DEBUG_PORT > 0) {
     state.debugPort = DEBUG_PORT;
   }
-  fs13.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), { mode: 384 });
+  fs14.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), { mode: 384 });
   console.log(`[browse] Server running on http://127.0.0.1:${port} (PID: ${process.pid})`);
   console.log(`[browse] State file: ${STATE_FILE}`);
   console.log(`[browse] Idle timeout: ${IDLE_TIMEOUT_MS / 1e3}s`);
 }
-var AUTH_TOKEN, DEBUG_PORT, BROWSE_PORT, BROWSE_INSTANCE, INSTANCE_SUFFIX, LOCAL_DIR2, STATE_FILE, IDLE_TIMEOUT_MS, sessionManager, browser, activeRuntime, isShuttingDown, isRemoteBrowser, policyChecker, READ_COMMANDS, WRITE_COMMANDS, META_COMMANDS, RECORDING_SKIP, PAGE_CONTENT_COMMANDS, BOUNDARY_NONCE, flushInterval, sessionCleanupInterval;
+var AUTH_TOKEN, DEBUG_PORT, BROWSE_PORT, BROWSE_INSTANCE, INSTANCE_SUFFIX, LOCAL_DIR2, STATE_FILE, IDLE_TIMEOUT_MS, sessionManager, browser, profileSession, activeRuntime, isShuttingDown, isRemoteBrowser, policyChecker, READ_COMMANDS, WRITE_COMMANDS, META_COMMANDS, RECORDING_SKIP, PAGE_CONTENT_COMMANDS, BOUNDARY_NONCE, flushInterval, sessionCleanupInterval;
 var init_server = __esm({
   "src/server.ts"() {
     "use strict";
@@ -5889,6 +6129,9 @@ var init_server = __esm({
     LOCAL_DIR2 = process.env.BROWSE_LOCAL_DIR || "/tmp";
     STATE_FILE = process.env.BROWSE_STATE_FILE || `${LOCAL_DIR2}/browse-server${INSTANCE_SUFFIX}.json`;
     IDLE_TIMEOUT_MS = parseInt(process.env.BROWSE_IDLE_TIMEOUT || String(DEFAULTS.IDLE_TIMEOUT_MS), 10);
+    sessionManager = null;
+    browser = null;
+    profileSession = null;
     isShuttingDown = false;
     isRemoteBrowser = false;
     policyChecker = new PolicyChecker();
@@ -5986,7 +6229,8 @@ var init_server = __esm({
       "record",
       "cookie-import",
       "doctor",
-      "upgrade"
+      "upgrade",
+      "profile"
     ]);
     RECORDING_SKIP = /* @__PURE__ */ new Set([
       "record",
@@ -6017,10 +6261,19 @@ var init_server = __esm({
     process.on("SIGTERM", shutdown);
     process.on("SIGINT", shutdown);
     flushInterval = setInterval(() => {
-      if (sessionManager) flushAllBuffers(sessionManager);
+      if (sessionManager || profileSession) flushAllBuffers(sessionManager);
     }, DEFAULTS.BUFFER_FLUSH_INTERVAL_MS);
     sessionCleanupInterval = setInterval(async () => {
-      if (!sessionManager || isShuttingDown) return;
+      if (isShuttingDown) return;
+      if (profileSession) {
+        const idleMs = Date.now() - profileSession.lastActivity;
+        if (idleMs > IDLE_TIMEOUT_MS) {
+          console.log(`[browse] Profile session idle for ${IDLE_TIMEOUT_MS / 1e3}s \u2014 shutting down`);
+          shutdown();
+        }
+        return;
+      }
+      if (!sessionManager) return;
       const closed = await sessionManager.closeIdleSessions(IDLE_TIMEOUT_MS, (session) => flushSessionBuffers(session, true));
       for (const id of closed) {
         console.log(`[browse] Session "${id}" idle for ${IDLE_TIMEOUT_MS / 1e3}s \u2014 closed`);
@@ -6039,8 +6292,8 @@ var init_server = __esm({
 
 // src/cli.ts
 init_constants();
-import * as fs14 from "fs";
-import * as path11 from "path";
+import * as fs15 from "fs";
+import * as path12 from "path";
 import { spawn as spawn3 } from "child_process";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
@@ -6083,7 +6336,8 @@ var cliFlags = {
   headed: false,
   stateFile: "",
   maxOutput: 0,
-  cdpUrl: ""
+  cdpUrl: "",
+  profile: ""
 };
 var stateFileApplied = false;
 var BROWSE_PORT2 = parseInt(process.env.BROWSE_PORT || "0", 10);
@@ -6092,50 +6346,50 @@ var INSTANCE_SUFFIX2 = BROWSE_PORT2 ? `-${BROWSE_PORT2}` : BROWSE_INSTANCE2 ? `-
 function resolveLocalDir() {
   if (process.env.BROWSE_LOCAL_DIR) {
     try {
-      fs14.mkdirSync(process.env.BROWSE_LOCAL_DIR, { recursive: true });
+      fs15.mkdirSync(process.env.BROWSE_LOCAL_DIR, { recursive: true });
     } catch {
     }
     return process.env.BROWSE_LOCAL_DIR;
   }
   let dir = process.cwd();
   for (let i = 0; i < 20; i++) {
-    if (fs14.existsSync(path11.join(dir, ".git")) || fs14.existsSync(path11.join(dir, ".claude"))) {
-      const browseDir = path11.join(dir, ".browse");
+    if (fs15.existsSync(path12.join(dir, ".git")) || fs15.existsSync(path12.join(dir, ".claude"))) {
+      const browseDir = path12.join(dir, ".browse");
       try {
-        fs14.mkdirSync(browseDir, { recursive: true });
-        const gi = path11.join(browseDir, ".gitignore");
-        if (!fs14.existsSync(gi)) {
-          fs14.writeFileSync(gi, "*\n");
+        fs15.mkdirSync(browseDir, { recursive: true });
+        const gi = path12.join(browseDir, ".gitignore");
+        if (!fs15.existsSync(gi)) {
+          fs15.writeFileSync(gi, "*\n");
         }
       } catch {
       }
       return browseDir;
     }
-    const parent = path11.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return "/tmp";
 }
 var LOCAL_DIR3 = resolveLocalDir();
-var STATE_FILE2 = process.env.BROWSE_STATE_FILE || path11.join(LOCAL_DIR3, `browse-server${INSTANCE_SUFFIX2}.json`);
+var STATE_FILE2 = process.env.BROWSE_STATE_FILE || path12.join(LOCAL_DIR3, `browse-server${INSTANCE_SUFFIX2}.json`);
 var MAX_START_WAIT = 8e3;
 var LOCK_FILE = STATE_FILE2 + ".lock";
 var LOCK_STALE_MS = DEFAULTS.LOCK_STALE_THRESHOLD_MS;
 var __filename_cli = fileURLToPath3(import.meta.url);
-var __dirname_cli = path11.dirname(__filename_cli);
+var __dirname_cli = path12.dirname(__filename_cli);
 function resolveServerScript(env = process.env, metaDir = __dirname_cli) {
   if (env.BROWSE_SERVER_SCRIPT) {
     return env.BROWSE_SERVER_SCRIPT;
   }
   if (metaDir.startsWith("/")) {
-    const direct = path11.resolve(metaDir, "server.ts");
-    if (fs14.existsSync(direct)) {
+    const direct = path12.resolve(metaDir, "server.ts");
+    if (fs15.existsSync(direct)) {
       return direct;
     }
   }
   const selfPath = fileURLToPath3(import.meta.url);
-  if (fs14.existsSync(selfPath)) {
+  if (fs15.existsSync(selfPath)) {
     return "__self__";
   }
   throw new Error(
@@ -6145,7 +6399,7 @@ function resolveServerScript(env = process.env, metaDir = __dirname_cli) {
 var SERVER_SCRIPT = resolveServerScript();
 function readState() {
   try {
-    const data = fs14.readFileSync(STATE_FILE2, "utf-8");
+    const data = fs15.readFileSync(STATE_FILE2, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -6161,7 +6415,7 @@ function isProcessAlive(pid) {
 }
 async function listInstances() {
   try {
-    const files = fs14.readdirSync(LOCAL_DIR3).filter(
+    const files = fs15.readdirSync(LOCAL_DIR3).filter(
       (f) => f.startsWith("browse-server") && f.endsWith(".json") && !f.endsWith(".lock")
     );
     if (files.length === 0) {
@@ -6171,7 +6425,7 @@ async function listInstances() {
     let found = false;
     for (const file of files) {
       try {
-        const data = JSON.parse(fs14.readFileSync(path11.join(LOCAL_DIR3, file), "utf-8"));
+        const data = JSON.parse(fs15.readFileSync(path12.join(LOCAL_DIR3, file), "utf-8"));
         if (!data.pid || !data.port) continue;
         const alive = isProcessAlive(data.pid);
         let status = "dead";
@@ -6194,7 +6448,7 @@ async function listInstances() {
         found = true;
         if (!alive) {
           try {
-            fs14.unlinkSync(path11.join(LOCAL_DIR3, file));
+            fs15.unlinkSync(path12.join(LOCAL_DIR3, file));
           } catch {
           }
         }
@@ -6217,15 +6471,15 @@ function isBrowseProcess(pid) {
 }
 function acquireLock() {
   try {
-    fs14.writeFileSync(LOCK_FILE, String(process.pid), { flag: "wx" });
+    fs15.writeFileSync(LOCK_FILE, String(process.pid), { flag: "wx" });
     return true;
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const stat = fs14.statSync(LOCK_FILE);
+        const stat = fs15.statSync(LOCK_FILE);
         if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
           try {
-            fs14.unlinkSync(LOCK_FILE);
+            fs15.unlinkSync(LOCK_FILE);
           } catch {
           }
           return acquireLock();
@@ -6239,7 +6493,7 @@ function acquireLock() {
 }
 function releaseLock() {
   try {
-    fs14.unlinkSync(LOCK_FILE);
+    fs15.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -6256,7 +6510,7 @@ async function startServer() {
       }
       await sleep(100);
     }
-    if (!fs14.existsSync(LOCK_FILE) || fs14.readFileSync(LOCK_FILE, "utf-8").trim() !== String(process.pid)) {
+    if (!fs15.existsSync(LOCK_FILE) || fs15.readFileSync(LOCK_FILE, "utf-8").trim() !== String(process.pid)) {
       const state = readState();
       if (state && isProcessAlive(state.pid)) return state;
       throw new Error("Server failed to start (another process is starting it)");
@@ -6266,13 +6520,13 @@ async function startServer() {
     try {
       const oldState = readState();
       if (oldState && !isProcessAlive(oldState.pid)) {
-        fs14.unlinkSync(STATE_FILE2);
+        fs15.unlinkSync(STATE_FILE2);
       }
     } catch {
     }
     const selfPath = fileURLToPath3(import.meta.url);
     const spawnCmd = SERVER_SCRIPT === "__self__" ? [process.execPath, selfPath] : [process.execPath, "--import", "tsx", SERVER_SCRIPT];
-    const spawnEnv = { ...process.env, __BROWSE_SERVER_MODE: "1", BROWSE_LOCAL_DIR: LOCAL_DIR3, BROWSE_INSTANCE: BROWSE_INSTANCE2, ...cliFlags.headed ? { BROWSE_HEADED: "1" } : {}, ...cliFlags.cdpUrl ? { BROWSE_CDP_URL: cliFlags.cdpUrl } : {} };
+    const spawnEnv = { ...process.env, __BROWSE_SERVER_MODE: "1", BROWSE_LOCAL_DIR: LOCAL_DIR3, BROWSE_INSTANCE: BROWSE_INSTANCE2, ...cliFlags.headed ? { BROWSE_HEADED: "1" } : {}, ...cliFlags.cdpUrl ? { BROWSE_CDP_URL: cliFlags.cdpUrl } : {}, ...cliFlags.profile ? { BROWSE_PROFILE: cliFlags.profile } : {} };
     const proc = spawn3(spawnCmd[0], spawnCmd.slice(1), {
       stdio: ["ignore", "ignore", "pipe"],
       env: spawnEnv,
@@ -6339,7 +6593,7 @@ async function ensureServer() {
   }
   if (state) {
     try {
-      fs14.unlinkSync(STATE_FILE2);
+      fs15.unlinkSync(STATE_FILE2);
     } catch {
     }
   }
@@ -6349,21 +6603,21 @@ async function ensureServer() {
 }
 function cleanOrphanedServers() {
   try {
-    const files = fs14.readdirSync(LOCAL_DIR3);
+    const files = fs15.readdirSync(LOCAL_DIR3);
     for (const file of files) {
       if (!file.startsWith("browse-server") || !file.endsWith(".json") || file.endsWith(".lock")) continue;
-      const filePath = path11.join(LOCAL_DIR3, file);
+      const filePath = path12.join(LOCAL_DIR3, file);
       if (filePath === STATE_FILE2) continue;
       try {
-        const data = JSON.parse(fs14.readFileSync(filePath, "utf-8"));
+        const data = JSON.parse(fs15.readFileSync(filePath, "utf-8"));
         if (!data.pid) {
-          fs14.unlinkSync(filePath);
+          fs15.unlinkSync(filePath);
           continue;
         }
         const suffixMatch = file.match(/browse-server-(\d+)\.json$/);
         if (suffixMatch && data.port === parseInt(suffixMatch[1], 10) && isProcessAlive(data.pid)) continue;
         if (!isProcessAlive(data.pid)) {
-          fs14.unlinkSync(filePath);
+          fs15.unlinkSync(filePath);
           continue;
         }
         if (isBrowseProcess(data.pid)) {
@@ -6374,7 +6628,7 @@ function cleanOrphanedServers() {
         }
       } catch {
         try {
-          fs14.unlinkSync(filePath);
+          fs15.unlinkSync(filePath);
         } catch {
         }
       }
@@ -6475,7 +6729,7 @@ async function sendCommand(state, command, args, retries = 0, sessionId) {
           await sleep(300);
         }
         try {
-          fs14.unlinkSync(STATE_FILE2);
+          fs15.unlinkSync(STATE_FILE2);
         } catch {
         }
         if (command === "restart") {
@@ -6523,7 +6777,7 @@ async function main() {
   function findCommandIndex(a) {
     for (let i = 0; i < a.length; i++) {
       if (!a[i].startsWith("-")) return i;
-      if (a[i] === "--session" || a[i] === "--allowed-domains" || a[i] === "--cdp" || a[i] === "--state") i++;
+      if (a[i] === "--session" || a[i] === "--allowed-domains" || a[i] === "--cdp" || a[i] === "--state" || a[i] === "--profile") i++;
     }
     return a.length;
   }
@@ -6538,6 +6792,21 @@ async function main() {
     args.splice(sessionIdx, 2);
   }
   sessionId = sessionId || process.env.BROWSE_SESSION || config.session || void 0;
+  let profileName;
+  const profileIdx = args.indexOf("--profile");
+  if (profileIdx !== -1 && profileIdx < findCommandIndex(args)) {
+    profileName = args[profileIdx + 1];
+    if (!profileName || profileName.startsWith("-")) {
+      console.error("Usage: browse --profile <name> <command> [args...]");
+      process.exit(1);
+    }
+    args.splice(profileIdx, 2);
+  }
+  profileName = profileName || process.env.BROWSE_PROFILE || void 0;
+  if (sessionId && profileName) {
+    console.error("Cannot use --profile and --session together. Profiles use their own Chromium; sessions share one.");
+    process.exit(1);
+  }
   let jsonMode = false;
   const jsonIdx = args.indexOf("--json");
   if (jsonIdx !== -1 && jsonIdx < findCommandIndex(args)) {
@@ -6636,6 +6905,7 @@ async function main() {
   cliFlags.stateFile = stateFile;
   cliFlags.maxOutput = maxOutput;
   cliFlags.cdpUrl = cdpUrl;
+  cliFlags.profile = profileName || "";
   if (args[0] === "version" || args[0] === "--version" || args[0] === "-V") {
     const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
     console.log(pkg.version);
@@ -6704,6 +6974,7 @@ Setup:          install-skill [path]
 
 Options:
   --session <id>           Named session (isolates tabs, refs, cookies)
+  --profile <name>         Persistent browser profile (own Chromium, full state persistence)
   --json                   Wrap output as {success, data, command}
   --content-boundaries     Wrap page content in nonce-delimited markers
   --allowed-domains <d,d>  Block navigation/resources outside allowlist
@@ -6743,7 +7014,7 @@ Refs:           After 'snapshot', use @e1, @e2... as selectors:
 }
 if (process.env.__BROWSE_SERVER_MODE === "1") {
   Promise.resolve().then(() => init_server());
-} else if (process.argv[1] && fs14.realpathSync(process.argv[1]) === fs14.realpathSync(__filename_cli)) {
+} else if (process.argv[1] && fs15.realpathSync(process.argv[1]) === fs15.realpathSync(__filename_cli)) {
   main().catch((err) => {
     console.error(`[browse] ${err.message}`);
     process.exit(1);