agent-browser-loop 0.2.2 → 0.3.1

package/src/daemon.ts

@@ -3,6 +3,7 @@ import * as net from "node:net";
 import * as os from "node:os";
 import * as path from "node:path";
 import { z } from "zod";
+import { VERSION } from "./version";
 import { type AgentBrowserOptions, createBrowser } from "./browser";
 import {
   type Command,
@@ -19,7 +20,9 @@ import {
   waitConditionSchema,
 } from "./commands";
 import { createIdGenerator } from "./id";
+import { saveProfile } from "./profiles";
 import { formatStateText } from "./state";
+import type { StorageState } from "./types";
 
 // ============================================================================
 // Daemon Protocol
@@ -37,6 +40,10 @@ const browserOptionsSchema = z
     captureNetwork: z.boolean().optional(),
     networkLogLimit: z.number().optional(),
     storageStatePath: z.string().optional(),
+    // Profile to load and save back on close
+    profile: z.string().optional(),
+    // If true, don't save profile on close (read-only)
+    noSave: z.boolean().optional(),
   })
   .optional();
 
@@ -120,6 +127,10 @@ type DaemonSession = {
   lastUsed: number;
   busy: boolean;
   options: AgentBrowserOptions;
+  // Profile name to save back on close (if set)
+  profile?: string;
+  // If true, don't save profile on close
+  noSave?: boolean;
 };
 
 // ============================================================================
@@ -147,6 +158,25 @@ export function getConfigPath(): string {
   return path.join(DAEMON_DIR, "daemon.config.json");
 }
 
+export function getVersionPath(): string {
+  return path.join(DAEMON_DIR, "daemon.version");
+}
+
+/**
+ * Get the version of the currently running daemon (if any)
+ */
+export function getDaemonVersion(): string | null {
+  const versionPath = getVersionPath();
+  if (!fs.existsSync(versionPath)) {
+    return null;
+  }
+  try {
+    return fs.readFileSync(versionPath, "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+
 // ============================================================================
 // Daemon Status
 // ============================================================================
@@ -173,6 +203,7 @@ export function cleanupDaemonFiles(): void {
   const socketPath = getSocketPath();
   const pidPath = getPidPath();
   const configPath = getConfigPath();
+  const versionPath = getVersionPath();
 
   try {
     if (fs.existsSync(socketPath)) fs.unlinkSync(socketPath);
@@ -183,6 +214,9 @@ export function cleanupDaemonFiles(): void {
   try {
     if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
   } catch {}
+  try {
+    if (fs.existsSync(versionPath)) fs.unlinkSync(versionPath);
+  } catch {}
 }
 
 // ============================================================================
@@ -200,10 +234,14 @@ export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
   const socketPath = getSocketPath();
   const pidPath = getPidPath();
   const configPath = getConfigPath();
+  const versionPath = getVersionPath();
 
   ensureDaemonDir();
   cleanupDaemonFiles();
 
+  // Write version file so CLI can detect version mismatch
+  fs.writeFileSync(versionPath, VERSION);
+
   // Multi-session state
   const sessions = new Map<string, DaemonSession>();
   const idGenerator = createIdGenerator();
@@ -219,13 +257,17 @@ export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
   // Session helpers
   async function createSession(
     sessionId?: string,
-    browserOptions?: AgentBrowserOptions,
+    browserOptions?: AgentBrowserOptions & {
+      profile?: string;
+      noSave?: boolean;
+    },
   ): Promise<DaemonSession> {
     const id = sessionId ?? idGenerator.next();
     if (sessions.has(id)) {
       throw new Error(`Session already exists: ${id}`);
     }
-    const mergedOptions = { ...defaultOptions, ...browserOptions };
+    const { profile, noSave, ...restOptions } = browserOptions ?? {};
+    const mergedOptions = { ...defaultOptions, ...restOptions };
     const browser = createBrowser(mergedOptions);
     await browser.start();
     const session: DaemonSession = {
@@ -234,6 +276,8 @@ export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
       lastUsed: Date.now(),
       busy: false,
       options: mergedOptions,
+      profile,
+      noSave,
     };
     sessions.set(id, session);
     return session;
@@ -250,14 +294,34 @@ export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
     return session;
   }
 
-  async function closeSession(sessionId: string): Promise<void> {
+  async function closeSession(
+    sessionId: string,
+  ): Promise<{ profileSaved?: string }> {
     const session = sessions.get(sessionId);
     if (!session) {
       throw new Error(`Session not found: ${sessionId}`);
     }
+
+    let profileSaved: string | undefined;
+
+    // Save profile if one was loaded and noSave is not set
+    if (session.profile && !session.noSave) {
+      try {
+        const storageState =
+          (await session.browser.saveStorageState()) as StorageState;
+        saveProfile(session.profile, storageState);
+        profileSaved = session.profile;
+      } catch (err) {
+        // Log but don't fail the close
+        console.error(`Failed to save profile ${session.profile}:`, err);
+      }
+    }
+
     await session.browser.stop();
     sessions.delete(sessionId);
     idGenerator.release(sessionId);
+
+    return { profileSaved };
   }
 
   const shutdown = async () => {
@@ -398,10 +462,10 @@ async function handleRequest(
   sessions: Map<string, DaemonSession>,
   createSession: (
     sessionId?: string,
-    options?: AgentBrowserOptions,
+    options?: AgentBrowserOptions & { profile?: string; noSave?: boolean },
   ) => Promise<DaemonSession>,
   getOrDefaultSession: (sessionId?: string) => DaemonSession,
-  closeSession: (sessionId: string) => Promise<void>,
+  closeSession: (sessionId: string) => Promise<{ profileSaved?: string }>,
 ): Promise<DaemonResponse> {
   const { id } = request;
 
@@ -439,8 +503,12 @@ async function handleRequest(
       }
 
       case "close": {
-        await closeSession(request.sessionId);
-        return { id, success: true, data: { closed: request.sessionId } };
+        const { profileSaved } = await closeSession(request.sessionId);
+        return {
+          id,
+          success: true,
+          data: { closed: request.sessionId, profileSaved },
+        };
       }
 
       case "command": {
@@ -451,7 +519,12 @@ async function handleRequest(
           const result = await executeCommand(session.browser, request.command);
           // Handle close command - close the session
           if (request.command.type === "close") {
-            await closeSession(session.id);
+            const { profileSaved } = await closeSession(session.id);
+            return {
+              id,
+              success: true,
+              data: { ...((result as object) ?? {}), profileSaved },
+            };
           }
           return { id, success: true, data: result };
         } finally {
@@ -769,6 +842,34 @@ export class DaemonClient {
 // Daemon Spawner
 // ============================================================================
 
+/**
+ * Force restart the daemon by shutting down any existing one
+ */
+async function forceRestartDaemon(
+  browserOptions?: AgentBrowserOptions,
+): Promise<void> {
+  const client = new DaemonClient();
+
+  // Try to gracefully shutdown existing daemon
+  if (isDaemonRunning()) {
+    try {
+      if (await client.ping()) {
+        await client.shutdown();
+        // Wait a bit for shutdown
+        await new Promise((r) => setTimeout(r, 200));
+      }
+    } catch {
+      // Ignore errors during shutdown
+    }
+  }
+
+  // Clean up any stale files
+  cleanupDaemonFiles();
+
+  // Spawn fresh daemon
+  await spawnDaemon(browserOptions);
+}
+
 /**
  * Ensure daemon is running and return a client.
  * If sessionId is provided, set the client to use that session.
@@ -784,6 +885,41 @@ export async function ensureDaemon(
 
   // Check if daemon is already running
   if (isDaemonRunning()) {
+    // Check for version mismatch - force restart if versions don't match
+    const daemonVersion = getDaemonVersion();
+    if (daemonVersion && daemonVersion !== VERSION) {
+      // If we're not allowed to create sessions, tell user to re-open
+      if (!createIfMissing) {
+        throw new Error(
+          `Daemon was upgraded (${daemonVersion} -> ${VERSION}). Please run 'agent-browser open <url>' to start a new session.`,
+        );
+      }
+
+      console.log(
+        `Daemon version mismatch (daemon: ${daemonVersion}, cli: ${VERSION}), restarting...`,
+      );
+      await forceRestartDaemon(browserOptions);
+
+      // Wait for new daemon to be ready
+      const maxAttempts = 50;
+      for (let i = 0; i < maxAttempts; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        if (await client.ping()) {
+          if (sessionId === "default") {
+            const createResp = await client.create({
+              sessionId: "default",
+              browserOptions,
+            });
+            if (!createResp.success) {
+              throw new Error(`Failed to create session: ${createResp.error}`);
+            }
+          }
+          return client;
+        }
+      }
+      throw new Error("Failed to restart daemon after version mismatch");
+    }
+
     // Verify it's responsive
     if (await client.ping()) {
       // Daemon is running, check if session exists or create default
@@ -848,6 +984,32 @@ export async function ensureDaemonNewSession(
 
   // Check if daemon is already running
   if (isDaemonRunning()) {
+    // Check for version mismatch - force restart if versions don't match
+    const daemonVersion = getDaemonVersion();
+    if (daemonVersion && daemonVersion !== VERSION) {
+      console.log(
+        `Daemon version mismatch (daemon: ${daemonVersion}, cli: ${VERSION}), restarting...`,
+      );
+      await forceRestartDaemon(browserOptions);
+
+      // Wait for new daemon to be ready and create session
+      const maxAttempts = 50;
+      for (let i = 0; i < maxAttempts; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        if (await client.ping()) {
+          const createResp = await client.create({ browserOptions });
+          if (!createResp.success) {
+            throw new Error(`Failed to create session: ${createResp.error}`);
+          }
+          const newSessionId = (createResp.data as { sessionId: string })
+            .sessionId;
+          client.setSession(newSessionId);
+          return client;
+        }
+      }
+      throw new Error("Failed to restart daemon after version mismatch");
+    }
+
     if (await client.ping()) {
       // Create new session with auto-generated ID
       const createResp = await client.create({ browserOptions });

package/src/index.ts

@@ -30,11 +30,30 @@ export {
   DaemonClient,
   type DaemonOptions,
   ensureDaemon,
+  getDaemonVersion,
   getPidPath,
   getSocketPath,
+  getVersionPath,
   isDaemonRunning,
   startDaemon,
 } from "./daemon";
+// Version
+export { VERSION } from "./version";
+// Profiles
+export {
+  deleteProfile,
+  importProfile,
+  listProfiles,
+  loadProfile,
+  loadStorageState,
+  type Profile,
+  type ProfileInfo,
+  type ProfileMeta,
+  resolveProfilePath,
+  resolveStorageStateOption,
+  saveProfile,
+  touchProfile,
+} from "./profiles";
 export type { ElementSelectors, StoredElementRef } from "./ref-store";
 // Ref store for server-side element reference management
 export { ElementRefStore } from "./ref-store";