agent-browser-loop 0.1.0 → 0.2.0

package/src/daemon.ts

@@ -18,21 +18,56 @@ import {
   type WaitCondition,
   waitConditionSchema,
 } from "./commands";
+import { createIdGenerator } from "./id";
 import { formatStateText } from "./state";
 
 // ============================================================================
 // Daemon Protocol
 // ============================================================================
 
+const browserOptionsSchema = z
+  .object({
+    headless: z.boolean().optional(),
+    executablePath: z.string().optional(),
+    useSystemChrome: z.boolean().optional(),
+    viewportWidth: z.number().optional(),
+    viewportHeight: z.number().optional(),
+    userDataDir: z.string().optional(),
+    timeout: z.number().optional(),
+    captureNetwork: z.boolean().optional(),
+    networkLogLimit: z.number().optional(),
+    storageStatePath: z.string().optional(),
+  })
+  .optional();
+
 const requestSchema = z.discriminatedUnion("type", [
+  // Session management
+  z.object({
+    type: z.literal("create"),
+    id: z.string(),
+    sessionId: z.literal("default").optional(), // Only "default" is allowed as explicit ID
+    options: browserOptionsSchema,
+  }),
+  z.object({
+    type: z.literal("list"),
+    id: z.string(),
+  }),
+  z.object({
+    type: z.literal("close"),
+    id: z.string(),
+    sessionId: z.string(),
+  }),
+  // Session operations (require sessionId, default to "default")
   z.object({
     type: z.literal("command"),
     id: z.string(),
+    sessionId: z.string().optional(),
     command: commandSchema,
   }),
   z.object({
     type: z.literal("act"),
     id: z.string(),
+    sessionId: z.string().optional(),
     actions: z.array(stepActionSchema),
     haltOnError: z.boolean().optional(),
     includeState: z.boolean().optional(),
@@ -42,6 +77,7 @@ const requestSchema = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("wait"),
     id: z.string(),
+    sessionId: z.string().optional(),
     condition: waitConditionSchema,
     timeoutMs: z.number().optional(),
     includeState: z.boolean().optional(),
@@ -51,6 +87,7 @@ const requestSchema = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("state"),
     id: z.string(),
+    sessionId: z.string().optional(),
     options: getStateOptionsSchema.optional(),
     format: z.enum(["json", "text"]).optional(),
   }),
@@ -73,6 +110,18 @@ interface DaemonResponse {
   error?: string;
 }
 
+// ============================================================================
+// Session Types
+// ============================================================================
+
+type DaemonSession = {
+  id: string;
+  browser: ReturnType<typeof createBrowser>;
+  lastUsed: number;
+  busy: boolean;
+  options: AgentBrowserOptions;
+};
+
 // ============================================================================
 // Path Utilities
 // ============================================================================
@@ -85,24 +134,25 @@ function ensureDaemonDir(): void {
   }
 }
 
-export function getSocketPath(session = "default"): string {
-  return path.join(DAEMON_DIR, `${session}.sock`);
+// Unified daemon paths (single socket for all sessions)
+export function getSocketPath(): string {
+  return path.join(DAEMON_DIR, "daemon.sock");
 }
 
-export function getPidPath(session = "default"): string {
-  return path.join(DAEMON_DIR, `${session}.pid`);
+export function getPidPath(): string {
+  return path.join(DAEMON_DIR, "daemon.pid");
 }
 
-export function getConfigPath(session = "default"): string {
-  return path.join(DAEMON_DIR, `${session}.config.json`);
+export function getConfigPath(): string {
+  return path.join(DAEMON_DIR, "daemon.config.json");
 }
 
 // ============================================================================
 // Daemon Status
 // ============================================================================
 
-export function isDaemonRunning(session = "default"): boolean {
-  const pidPath = getPidPath(session);
+export function isDaemonRunning(): boolean {
+  const pidPath = getPidPath();
   if (!fs.existsSync(pidPath)) {
     return false;
   }
@@ -114,15 +164,15 @@ export function isDaemonRunning(session = "default"): boolean {
     return true;
   } catch {
     // Process doesn't exist, clean up stale files
-    cleanupDaemonFiles(session);
+    cleanupDaemonFiles();
     return false;
   }
 }
 
-export function cleanupDaemonFiles(session = "default"): void {
-  const socketPath = getSocketPath(session);
-  const pidPath = getPidPath(session);
-  const configPath = getConfigPath(session);
+export function cleanupDaemonFiles(): void {
+  const socketPath = getSocketPath();
+  const pidPath = getPidPath();
+  const configPath = getConfigPath();
 
   try {
     if (fs.existsSync(socketPath)) fs.unlinkSync(socketPath);
@@ -140,41 +190,118 @@ export function cleanupDaemonFiles(session = "default"): void {
 // ============================================================================
 
 export interface DaemonOptions {
-  session?: string;
-  browserOptions?: AgentBrowserOptions;
+  defaultBrowserOptions?: AgentBrowserOptions;
+  sessionTtlMs?: number;
 }
 
+const DEFAULT_SESSION_TTL_MS = 30 * 60 * 1000; // 30 minutes
+
 export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
-  const session = options.session ?? "default";
-  const socketPath = getSocketPath(session);
-  const pidPath = getPidPath(session);
-  const configPath = getConfigPath(session);
+  const socketPath = getSocketPath();
+  const pidPath = getPidPath();
+  const configPath = getConfigPath();
 
   ensureDaemonDir();
-  cleanupDaemonFiles(session);
+  cleanupDaemonFiles();
 
-  // Create and start browser
-  const browser = createBrowser(options.browserOptions);
-  await browser.start();
+  // Multi-session state
+  const sessions = new Map<string, DaemonSession>();
+  const idGenerator = createIdGenerator();
+  const defaultOptions = options.defaultBrowserOptions ?? {};
+  const sessionTtl = options.sessionTtlMs ?? DEFAULT_SESSION_TTL_MS;
 
   let shuttingDown = false;
   // biome-ignore lint/style/useConst: assigned separately for hoisting in shutdown()
   let server: net.Server;
+  // biome-ignore lint/style/useConst: assigned separately for cleanup
+  let cleanupTimer: ReturnType<typeof setInterval>;
+
+  // Session helpers
+  async function createSession(
+    sessionId?: string,
+    browserOptions?: AgentBrowserOptions,
+  ): Promise<DaemonSession> {
+    const id = sessionId ?? idGenerator.next();
+    if (sessions.has(id)) {
+      throw new Error(`Session already exists: ${id}`);
+    }
+    const mergedOptions = { ...defaultOptions, ...browserOptions };
+    const browser = createBrowser(mergedOptions);
+    await browser.start();
+    const session: DaemonSession = {
+      id,
+      browser,
+      lastUsed: Date.now(),
+      busy: false,
+      options: mergedOptions,
+    };
+    sessions.set(id, session);
+    return session;
+  }
+
+  function getSession(sessionId: string): DaemonSession {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return session;
+  }
 
-  const shutdown = () => {
+  function getOrDefaultSession(sessionId?: string): DaemonSession {
+    const id = sessionId ?? "default";
+    const session = sessions.get(id);
+    if (!session) {
+      throw new Error(
+        `Session not found: ${id}. Use 'open' command to create a session first.`,
+      );
+    }
+    return session;
+  }
+
+  async function closeSession(sessionId: string): Promise<void> {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    await session.browser.stop();
+    sessions.delete(sessionId);
+    idGenerator.release(sessionId);
+  }
+
+  const shutdown = async () => {
     if (shuttingDown) return;
     shuttingDown = true;
+    clearInterval(cleanupTimer);
     server.close();
-    cleanupDaemonFiles(session);
-    browser.stop().finally(() => {
-      process.kill(process.pid, "SIGKILL");
-    });
-    // Failsafe: force kill after 2 seconds
-    setTimeout(() => {
-      process.kill(process.pid, "SIGKILL");
-    }, 2000);
+    // Close all sessions
+    for (const session of sessions.values()) {
+      try {
+        await session.browser.stop();
+      } catch {}
+    }
+    sessions.clear();
+    cleanupDaemonFiles();
+    process.kill(process.pid, "SIGKILL");
   };
 
+  // Session TTL cleanup
+  cleanupTimer = setInterval(
+    async () => {
+      if (sessionTtl <= 0) return;
+      const now = Date.now();
+      for (const [id, session] of sessions) {
+        if (now - session.lastUsed > sessionTtl && !session.busy) {
+          try {
+            await session.browser.stop();
+          } catch {}
+          sessions.delete(id);
+          idGenerator.release(id);
+        }
+      }
+    },
+    Math.max(10_000, Math.floor(sessionTtl / 2)),
+  );
+
   server = net.createServer((socket) => {
     let buffer = "";
 
@@ -202,7 +329,16 @@ export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
               error: `Invalid request: ${parseResult.error.message}`,
             };
           } else {
-            response = await handleRequest(browser, parseResult.data);
+            response = await handleRequest(
+              parseResult.data,
+              sessions,
+              createSession,
+              getSession,
+              getOrDefaultSession,
+              closeSession,
+              idGenerator,
+              defaultOptions,
+            );
 
             // Handle shutdown
             if (parseResult.data.type === "shutdown") {
@@ -210,19 +346,6 @@ export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
               shutdown();
               return;
             }
-
-            // Handle close command - shutdown daemon
-            if (
-              parseResult.data.type === "command" &&
-              parseResult.data.command.type === "close"
-            ) {
-              socket.write(JSON.stringify(response) + "\n");
-              if (!shuttingDown) {
-                shuttingDown = true;
-                setTimeout(() => shutdown(), 100);
-              }
-              return;
-            }
           }
         } catch (err) {
           response = {
@@ -243,7 +366,7 @@ export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
 
   // Write PID and config
   fs.writeFileSync(pidPath, process.pid.toString());
-  fs.writeFileSync(configPath, JSON.stringify(options.browserOptions ?? {}));
+  fs.writeFileSync(configPath, JSON.stringify(options));
 
   // Start listening
   server.listen(socketPath, () => {
@@ -252,29 +375,29 @@ export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
 
   server.on("error", (err) => {
     console.error("Daemon server error:", err);
-    cleanupDaemonFiles(session);
+    cleanupDaemonFiles();
     process.exit(1);
   });
 
   // Handle shutdown signals
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  process.on("SIGHUP", shutdown);
+  process.on("SIGINT", () => shutdown());
+  process.on("SIGTERM", () => shutdown());
+  process.on("SIGHUP", () => shutdown());
 
   process.on("uncaughtException", (err) => {
     console.error("Uncaught exception:", err);
-    cleanupDaemonFiles(session);
+    cleanupDaemonFiles();
     process.exit(1);
   });
 
   process.on("unhandledRejection", (reason) => {
     console.error("Unhandled rejection:", reason);
-    cleanupDaemonFiles(session);
+    cleanupDaemonFiles();
     process.exit(1);
   });
 
   process.on("exit", () => {
-    cleanupDaemonFiles(session);
+    cleanupDaemonFiles();
   });
 
   // Keep alive
@@ -282,8 +405,17 @@ export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
 }
 
 async function handleRequest(
-  browser: ReturnType<typeof createBrowser>,
   request: DaemonRequest,
+  sessions: Map<string, DaemonSession>,
+  createSession: (
+    sessionId?: string,
+    options?: AgentBrowserOptions,
+  ) => Promise<DaemonSession>,
+  getSession: (sessionId: string) => DaemonSession,
+  getOrDefaultSession: (sessionId?: string) => DaemonSession,
+  closeSession: (sessionId: string) => Promise<void>,
+  idGenerator: ReturnType<typeof createIdGenerator>,
+  defaultOptions: AgentBrowserOptions,
 ): Promise<DaemonResponse> {
   const { id } = request;
 
@@ -297,86 +429,160 @@ async function handleRequest(
         return { id, success: true, data: { status: "shutting_down" } };
       }
 
-      case "command": {
-        const result = await executeCommand(browser, request.command);
-        return { id, success: true, data: result };
-      }
-
-      case "act": {
-        const results = await executeActions(browser, request.actions, {
-          haltOnError: request.haltOnError ?? true,
-        });
-
-        let state: unknown;
-        let stateText: string | undefined;
-
-        if (request.includeState || request.includeStateText !== false) {
-          const currentState = await browser.getState(request.stateOptions);
-          if (request.includeState) {
-            state = currentState;
-          }
-          if (request.includeStateText !== false) {
-            stateText = formatStateText(currentState);
-          }
-        }
-
-        const hasError = results.some((r) => r.error != null);
-
+      case "create": {
+        const session = await createSession(request.sessionId, request.options);
         return {
           id,
           success: true,
-          data: {
-            results,
-            state,
-            stateText,
-            text: formatStepText({ results, stateText }),
-            error: hasError ? "One or more actions failed" : undefined,
-          },
+          data: { sessionId: session.id },
         };
       }
 
-      case "wait": {
-        await executeWait(browser, request.condition, {
-          timeoutMs: request.timeoutMs,
+      case "list": {
+        const sessionList = Array.from(sessions.values()).map((s) => {
+          const state = s.browser.getLastState();
+          return {
+            id: s.id,
+            url: state?.url ?? "about:blank",
+            title: state?.title ?? "",
+            busy: s.busy,
+            lastUsed: s.lastUsed,
+          };
         });
+        return { id, success: true, data: { sessions: sessionList } };
+      }
 
-        let state: unknown;
-        let stateText: string | undefined;
+      case "close": {
+        await closeSession(request.sessionId);
+        return { id, success: true, data: { closed: request.sessionId } };
+      }
 
-        if (request.includeState || request.includeStateText !== false) {
-          const currentState = await browser.getState(request.stateOptions);
-          if (request.includeState) {
-            state = currentState;
+      case "command": {
+        const session = getOrDefaultSession(request.sessionId);
+        session.busy = true;
+        session.lastUsed = Date.now();
+        try {
+          const result = await executeCommand(session.browser, request.command);
+          // Handle close command - close the session
+          if (request.command.type === "close") {
+            await closeSession(session.id);
           }
-          if (request.includeStateText !== false) {
-            stateText = formatStateText(currentState);
+          return { id, success: true, data: result };
+        } finally {
+          if (sessions.has(session.id)) {
+            session.busy = false;
+            session.lastUsed = Date.now();
           }
         }
+      }
 
-        return {
-          id,
-          success: true,
-          data: {
-            state,
-            stateText,
-            text: formatWaitText({ condition: request.condition, stateText }),
-          },
-        };
+      case "act": {
+        const session = getOrDefaultSession(request.sessionId);
+        session.busy = true;
+        session.lastUsed = Date.now();
+        try {
+          const results = await executeActions(
+            session.browser,
+            request.actions,
+            {
+              haltOnError: request.haltOnError ?? true,
+            },
+          );
+
+          let state: unknown;
+          let stateText: string | undefined;
+
+          if (request.includeState || request.includeStateText !== false) {
+            const currentState = await session.browser.getState(
+              request.stateOptions,
+            );
+            if (request.includeState) {
+              state = currentState;
+            }
+            if (request.includeStateText !== false) {
+              stateText = formatStateText(currentState);
+            }
+          }
+
+          const hasError = results.some((r) => r.error != null);
+
+          return {
+            id,
+            success: true,
+            data: {
+              results,
+              state,
+              stateText,
+              text: formatStepText({ results, stateText }),
+              error: hasError ? "One or more actions failed" : undefined,
+            },
+          };
+        } finally {
+          session.busy = false;
+          session.lastUsed = Date.now();
+        }
       }
 
-      case "state": {
-        const currentState = await browser.getState(request.options);
-        const format = request.format ?? "text";
+      case "wait": {
+        const session = getOrDefaultSession(request.sessionId);
+        session.busy = true;
+        session.lastUsed = Date.now();
+        try {
+          await executeWait(session.browser, request.condition, {
+            timeoutMs: request.timeoutMs,
+          });
+
+          let state: unknown;
+          let stateText: string | undefined;
+
+          if (request.includeState || request.includeStateText !== false) {
+            const currentState = await session.browser.getState(
+              request.stateOptions,
+            );
+            if (request.includeState) {
+              state = currentState;
+            }
+            if (request.includeStateText !== false) {
+              stateText = formatStateText(currentState);
+            }
+          }
 
-        if (format === "text") {
           return {
             id,
             success: true,
-            data: { text: formatStateText(currentState) },
+            data: {
+              state,
+              stateText,
+              text: formatWaitText({ condition: request.condition, stateText }),
+            },
           };
+        } finally {
+          session.busy = false;
+          session.lastUsed = Date.now();
         }
+      }
 
-        return { id, success: true, data: { state: currentState } };
+      case "state": {
+        const session = getOrDefaultSession(request.sessionId);
+        session.busy = true;
+        session.lastUsed = Date.now();
+        try {
+          const currentState = await session.browser.getState(request.options);
+          const format = request.format ?? "text";
+
+          if (format === "text") {
+            return {
+              id,
+              success: true,
+              data: { text: formatStateText(currentState) },
+            };
+          }
+
+          return { id, success: true, data: { state: currentState } };
+        } finally {
+          session.busy = false;
+          session.lastUsed = Date.now();
+        }
       }
     }
   } catch (err) {
@@ -394,9 +600,11 @@ async function handleRequest(
 
 export class DaemonClient {
   private socketPath: string;
+  private sessionId?: string;
 
-  constructor(session = "default") {
-    this.socketPath = getSocketPath(session);
+  constructor(sessionId?: string) {
+    this.socketPath = getSocketPath();
+    this.sessionId = sessionId;
   }
 
   private async send(request: DaemonRequest): Promise<DaemonResponse> {
@@ -435,6 +643,16 @@ export class DaemonClient {
     });
   }
 
+  /** Set the session ID for subsequent requests */
+  setSession(sessionId: string): void {
+    this.sessionId = sessionId;
+  }
+
+  /** Get the current session ID */
+  getSessionId(): string | undefined {
+    return this.sessionId;
+  }
+
   async ping(): Promise<boolean> {
     try {
       const response = await this.send({ type: "ping", id: "ping" });
@@ -444,10 +662,41 @@ export class DaemonClient {
     }
   }
 
-  async command(command: Command): Promise<DaemonResponse> {
+  /** Create a new session, returns the session ID */
+  async create(options?: {
+    sessionId?: "default"; // Only "default" is allowed as explicit ID
+    browserOptions?: AgentBrowserOptions;
+  }): Promise<DaemonResponse> {
+    return this.send({
+      type: "create",
+      id: `create-${Date.now()}`,
+      sessionId: options?.sessionId,
+      options: options?.browserOptions,
+    });
+  }
+
+  /** List all sessions */
+  async list(): Promise<DaemonResponse> {
+    return this.send({
+      type: "list",
+      id: `list-${Date.now()}`,
+    });
+  }
+
+  /** Close a specific session */
+  async closeSession(sessionId: string): Promise<DaemonResponse> {
+    return this.send({
+      type: "close",
+      id: `close-${Date.now()}`,
+      sessionId,
+    });
+  }
+
+  async command(command: Command, sessionId?: string): Promise<DaemonResponse> {
     return this.send({
       type: "command",
       id: `cmd-${Date.now()}`,
+      sessionId: sessionId ?? this.sessionId,
       command,
     });
   }
@@ -455,39 +704,46 @@ export class DaemonClient {
   async act(
     actions: StepAction[],
     options: {
+      sessionId?: string;
       haltOnError?: boolean;
       includeState?: boolean;
       includeStateText?: boolean;
       stateOptions?: z.infer<typeof getStateOptionsSchema>;
     } = {},
   ): Promise<DaemonResponse> {
+    const { sessionId, ...rest } = options;
     return this.send({
       type: "act",
       id: `act-${Date.now()}`,
+      sessionId: sessionId ?? this.sessionId,
       actions,
-      ...options,
+      ...rest,
     });
   }
 
   async wait(
     condition: WaitCondition,
     options: {
+      sessionId?: string;
       timeoutMs?: number;
       includeState?: boolean;
       includeStateText?: boolean;
       stateOptions?: z.infer<typeof getStateOptionsSchema>;
     } = {},
   ): Promise<DaemonResponse> {
+    const { sessionId, ...rest } = options;
     return this.send({
       type: "wait",
       id: `wait-${Date.now()}`,
+      sessionId: sessionId ?? this.sessionId,
       condition,
-      ...options,
+      ...rest,
     });
   }
 
   async state(
     options: {
+      sessionId?: string;
       format?: "json" | "text";
       stateOptions?: z.infer<typeof getStateOptionsSchema>;
     } = {},
@@ -495,6 +751,7 @@ export class DaemonClient {
     return this.send({
       type: "state",
       id: `state-${Date.now()}`,
+      sessionId: options.sessionId ?? this.sessionId,
       options: options.stateOptions,
       format: options.format,
     });
@@ -505,13 +762,19 @@ export class DaemonClient {
   }
 
   async screenshot(options?: {
+    sessionId?: string;
     fullPage?: boolean;
     path?: string;
   }): Promise<DaemonResponse> {
     return this.send({
       type: "command",
       id: `screenshot-${Date.now()}`,
-      command: { type: "screenshot", ...options },
+      sessionId: options?.sessionId ?? this.sessionId,
+      command: {
+        type: "screenshot",
+        fullPage: options?.fullPage,
+        path: options?.path,
+      },
     });
   }
 }
@@ -520,30 +783,67 @@ export class DaemonClient {
 // Daemon Spawner
 // ============================================================================
 
+/**
+ * Ensure daemon is running and return a client.
+ * If sessionId is provided, set the client to use that session.
+ * If createIfMissing is true (default), create the "default" session if it doesn't exist.
+ */
 export async function ensureDaemon(
-  session = "default",
+  sessionId = "default",
   browserOptions?: AgentBrowserOptions,
+  options?: { createIfMissing?: boolean },
 ): Promise<DaemonClient> {
-  const client = new DaemonClient(session);
+  const client = new DaemonClient(sessionId);
+  const createIfMissing = options?.createIfMissing ?? true;
 
-  // Check if already running
-  if (isDaemonRunning(session)) {
+  // Check if daemon is already running
+  if (isDaemonRunning()) {
     // Verify it's responsive
     if (await client.ping()) {
+      // Daemon is running, check if session exists or create default
+      if (createIfMissing && sessionId === "default") {
+        const listResp = await client.list();
+        if (listResp.success) {
+          const sessions = (
+            listResp.data as { sessions: Array<{ id: string }> }
+          ).sessions;
+          const exists = sessions.some((s) => s.id === sessionId);
+          if (!exists) {
+            // Create the default session
+            const createResp = await client.create({
+              sessionId: "default",
+              browserOptions,
+            });
+            if (!createResp.success) {
+              throw new Error(`Failed to create session: ${createResp.error}`);
+            }
+          }
+        }
+      }
       return client;
     }
     // Not responsive, clean up
-    cleanupDaemonFiles(session);
+    cleanupDaemonFiles();
   }
 
   // Spawn new daemon
-  await spawnDaemon(session, browserOptions);
+  await spawnDaemon(browserOptions);
 
   // Wait for daemon to be ready
   const maxAttempts = 50; // 5 seconds
   for (let i = 0; i < maxAttempts; i++) {
     await new Promise((r) => setTimeout(r, 100));
     if (await client.ping()) {
+      // Create the initial default session
+      if (createIfMissing && sessionId === "default") {
+        const createResp = await client.create({
+          sessionId: "default",
+          browserOptions,
+        });
+        if (!createResp.success) {
+          throw new Error(`Failed to create session: ${createResp.error}`);
+        }
+      }
       return client;
     }
   }
@@ -551,17 +851,62 @@ export async function ensureDaemon(
   throw new Error("Failed to start daemon");
 }
 
-async function spawnDaemon(
-  session: string,
+/**
+ * Ensure daemon is running and create a NEW session with auto-generated ID.
+ * Returns the client with the new session ID set.
+ */
+export async function ensureDaemonNewSession(
   browserOptions?: AgentBrowserOptions,
+): Promise<DaemonClient> {
+  const client = new DaemonClient();
+
+  // Check if daemon is already running
+  if (isDaemonRunning()) {
+    if (await client.ping()) {
+      // Create new session with auto-generated ID
+      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;
+    }
+    cleanupDaemonFiles();
+  }
+
+  // Spawn new daemon
+  await spawnDaemon(browserOptions);
+
+  // Wait for 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()) {
+      // Create new session with auto-generated ID
+      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 start daemon");
+}
+
+async function spawnDaemon(
+  defaultBrowserOptions?: AgentBrowserOptions,
 ): Promise<void> {
-  const configPath = getConfigPath(session);
+  const configPath = getConfigPath();
   ensureDaemonDir();
 
   // Write config for daemon to read
   fs.writeFileSync(
     configPath,
-    JSON.stringify({ session, browserOptions: browserOptions ?? {} }),
+    JSON.stringify({ defaultBrowserOptions: defaultBrowserOptions ?? {} }),
   );
 
   // Spawn detached process
@@ -569,14 +914,7 @@ async function spawnDaemon(
 
   const child = spawn(
     process.execPath,
-    [
-      "--bun",
-      import.meta.dirname + "/daemon-entry.ts",
-      "--session",
-      session,
-      "--config",
-      configPath,
-    ],
+    ["--bun", import.meta.dirname + "/daemon-entry.ts", "--config", configPath],
     {
       detached: true,
       stdio: "ignore",
@@ -597,29 +935,27 @@ if (
 ) {
   // Parse args
   const args = process.argv.slice(2);
-  let session = "default";
   let configPath: string | undefined;
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--session" && args[i + 1]) {
-      session = args[i + 1];
-      i++;
-    } else if (args[i] === "--config" && args[i + 1]) {
+    if (args[i] === "--config" && args[i + 1]) {
       configPath = args[i + 1];
       i++;
     }
   }
 
-  let browserOptions: AgentBrowserOptions = {};
+  let daemonOptions: DaemonOptions = {};
   if (configPath && fs.existsSync(configPath)) {
     try {
       const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-      browserOptions = config.browserOptions ?? {};
-      session = config.session ?? session;
+      daemonOptions = {
+        defaultBrowserOptions: config.defaultBrowserOptions ?? {},
+        sessionTtlMs: config.sessionTtlMs,
+      };
     } catch {}
   }
 
-  startDaemon({ session, browserOptions }).catch((err) => {
+  startDaemon(daemonOptions).catch((err) => {
     console.error("Failed to start daemon:", err);
     process.exit(1);
   });