feat(baoyu-fetch): add X session cookie sidecar and graceful Chrome lifecycle

Add cookie sidecar to export/restore X session cookies across runs.
Implement graceful Browser.close via WebSocket before falling back to kill.
Auto-detect and clean stale Chrome profile lock artifacts on launch failure.
Wait for X session readiness (auth_token + ct0) before auto-continuing login flows.

packages/baoyu-fetch/src/__tests__/profile.test.ts

@@ -2,7 +2,12 @@ import { afterEach, describe, expect, test } from "bun:test";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { ensureChromeProfileDir, resolveChromeProfileDir } from "../browser/profile";
+import {
+  ensureChromeProfileDir,
+  hasChromeLockArtifacts,
+  resolveChromeProfileDir,
+  shouldRetryChromeLaunchRecovery,
+} from "../browser/profile";
 
 const originalProfile = process.env.BAOYU_CHROME_PROFILE_DIR;
 
@@ -47,3 +52,17 @@ describe("ensureChromeProfileDir", () => {
     }
   });
 });
+
+describe("stale lock recovery helpers", () => {
+  test("detects Chrome singleton lock artifacts", () => {
+    expect(hasChromeLockArtifacts(["Cookies", "SingletonLock"])).toBe(true);
+    expect(hasChromeLockArtifacts(["chrome.pid"])).toBe(true);
+    expect(hasChromeLockArtifacts(["Preferences", "Cookies"])).toBe(false);
+  });
+
+  test("only retries stale-lock recovery when no live owner exists", () => {
+    expect(shouldRetryChromeLaunchRecovery({ hasLockArtifacts: true, hasLiveOwner: false })).toBe(true);
+    expect(shouldRetryChromeLaunchRecovery({ hasLockArtifacts: true, hasLiveOwner: true })).toBe(false);
+    expect(shouldRetryChromeLaunchRecovery({ hasLockArtifacts: false, hasLiveOwner: false })).toBe(false);
+  });
+});

packages/baoyu-fetch/src/__tests__/wait-mode.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { shouldAutoContinueForceWait } from "../commands/convert";
+import { shouldAutoContinueForceWait, shouldKeepBrowserOpenAfterInteraction } from "../commands/convert";
 
 describe("shouldAutoContinueForceWait", () => {
   test("continues when a challenge disappears", () => {
@@ -9,28 +9,49 @@ describe("shouldAutoContinueForceWait", () => {
           url: "https://example.com/challenge",
           hasGate: true,
           loginState: "unknown",
+          sessionReady: true,
         },
         {
           url: "https://example.com/article",
           hasGate: false,
           loginState: "unknown",
+          sessionReady: true,
         },
       ),
     ).toBe(true);
   });
 
-  test("continues when login state improves from logged out", () => {
+  test("waits for X session cookies before continuing after login", () => {
     expect(
       shouldAutoContinueForceWait(
         {
           url: "https://x.com/i/flow/login",
           hasGate: false,
           loginState: "logged_out",
+          sessionReady: false,
         },
         {
           url: "https://x.com/home",
           hasGate: false,
           loginState: "logged_in",
+          sessionReady: false,
+        },
+      ),
+    ).toBe(false);
+
+    expect(
+      shouldAutoContinueForceWait(
+        {
+          url: "https://x.com/i/flow/login",
+          hasGate: false,
+          loginState: "logged_out",
+          sessionReady: false,
+        },
+        {
+          url: "https://x.com/home",
+          hasGate: false,
+          loginState: "logged_in",
+          sessionReady: true,
         },
       ),
     ).toBe(true);
@@ -43,13 +64,42 @@ describe("shouldAutoContinueForceWait", () => {
           url: "https://x.com/lennysan/status/2036483059407810640",
           hasGate: false,
           loginState: "unknown",
+          sessionReady: false,
         },
         {
           url: "https://x.com/lennysan/status/2036483059407810640",
           hasGate: false,
           loginState: "unknown",
+          sessionReady: false,
         },
       ),
     ).toBe(false);
   });
 });
+
+describe("shouldKeepBrowserOpenAfterInteraction", () => {
+  test("keeps launched X login browsers open", () => {
+    expect(
+      shouldKeepBrowserOpenAfterInteraction({
+        launched: true,
+        interaction: { kind: "login", provider: "x" },
+      }),
+    ).toBe(true);
+  });
+
+  test("does not keep reused or non-login browsers open", () => {
+    expect(
+      shouldKeepBrowserOpenAfterInteraction({
+        launched: false,
+        interaction: { kind: "login", provider: "x" },
+      }),
+    ).toBe(false);
+
+    expect(
+      shouldKeepBrowserOpenAfterInteraction({
+        launched: true,
+        interaction: { kind: "cloudflare", provider: "cloudflare" },
+      }),
+    ).toBe(false);
+  });
+});

packages/baoyu-fetch/src/__tests__/x-session.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildXSessionCookieMap, hasRequiredXSessionCookies } from "../adapters/x/session";
+
+describe("X session helpers", () => {
+  test("keeps non-empty X session cookies", () => {
+    expect(
+      buildXSessionCookieMap([
+        { name: "auth_token", value: "auth" },
+        { name: "ct0", value: "csrf" },
+        { name: "twid", value: "u=123" },
+        { name: "ct0", value: "" },
+        { name: "", value: "ignored" },
+        { name: "gt", value: undefined },
+      ]),
+    ).toEqual({
+      auth_token: "auth",
+      ct0: "csrf",
+      twid: "u=123",
+    });
+  });
+
+  test("requires auth_token and ct0 for a ready X session", () => {
+    expect(hasRequiredXSessionCookies({ auth_token: "auth" })).toBe(false);
+    expect(hasRequiredXSessionCookies({ ct0: "csrf" })).toBe(false);
+    expect(hasRequiredXSessionCookies({ auth_token: "auth", ct0: "csrf" })).toBe(true);
+  });
+});