ai-browser-bridge 0.5.1 → 0.5.2

package/README.md

@@ -163,17 +163,21 @@ Then validate it and start the autonomous queue:
 
 ```bash
 bridge chat organize --plan @organization-plan.json --dry-run
-bridge chat organize --plan @organization-plan.json --interval 10-20 --cooldown 300
+bridge chat organize --plan @organization-plan.json \
+  --interval 60-90 --cooldown 600 --max-attempts 4
 ```
 
 The queue verifies every move from ChatGPT's loaded Project label, with the destination Project page
-as a fallback. It spaces UI operations by a fixed `--interval 30` or randomized range such as
-`--interval 10-20`, and acknowledges ChatGPT's “Too many requests” modal before waiting for
-`--cooldown`; rate-limit cooldowns do not consume retry attempts. Progress is persisted under
-`.bridge/chat-organization-queues/`; rerunning the same plan resumes pending work without repeating
-completed moves. Use `--restart` only when you intentionally want to replay the full plan, and
-`--max-attempts` to change the default of three attempts per Conversation. `--json` keeps the final
-summary on stdout and writes progress to stderr.
+as a fallback. It spaces UI operations by a fixed interval or randomized range; the defaults are a
+60-second interval, a 600-second rate-limit cooldown, and four attempts per Conversation. For large
+history cleanups, the randomized `--interval 60-90` profile above is recommended. The queue
+acknowledges ChatGPT's “Too many requests” modal before cooling down, and automatically relaunches a
+closed browser session. Neither infrastructure condition consumes a move attempt. Progress is
+persisted under `.bridge/chat-organization-queues/`; rerunning the same plan resumes pending work
+without repeating completed moves. Once the queue has started and processed or deferred one item,
+it can continue unattended without an agent watching it. Use `--restart` only when you intentionally
+want to replay the full plan. `--json` keeps the final summary on stdout and writes progress to
+stderr.
 
 ## Agents & fan-out
 

package/dist/bridge.js

@@ -11195,6 +11195,11 @@ var ChatOrganizationQueueSchema = Schema8.Struct({
   items: Schema8.Array(ChatOrganizationQueueItemSchema).pipe(Schema8.minItems(1))
 });
 var ORGANIZATION_INTERVAL = /^(?<minimum>\d+)(?:-(?<maximum>\d+))?$/u;
+var CLOSED_BROWSER_SESSION = /(?:target page, context or browser has been closed|browser has been closed|context has been closed|page has been closed)/iu;
+var chatOrganizationSessionWasClosed = (reason) => {
+  if (reason === void 0) return false;
+  return CLOSED_BROWSER_SESSION.test(reason);
+};
 var chatOrganizationIntervalFrom = (value, defaultSeconds) => {
   if (value === void 0) {
     return { minimumSeconds: defaultSeconds, maximumSeconds: defaultSeconds };
@@ -15076,11 +15081,12 @@ var runChatMove = async (chat, options) => {
   writeMoveOutcomes(outcomes, options);
   process.exit(outcomes.every((outcome) => outcome.moved || outcome.alreadyFiled) ? 0 : 1);
 };
-var DEFAULT_ORGANIZATION_INTERVAL_SECONDS = 30;
-var DEFAULT_ORGANIZATION_COOLDOWN_SECONDS = 300;
-var DEFAULT_ORGANIZATION_MAX_ATTEMPTS = 3;
+var DEFAULT_ORGANIZATION_INTERVAL_SECONDS = 60;
+var DEFAULT_ORGANIZATION_COOLDOWN_SECONDS = 600;
+var DEFAULT_ORGANIZATION_MAX_ATTEMPTS = 4;
 var MAX_CONSECUTIVE_ORGANIZATION_COOLDOWNS = 12;
 var RATE_LIMIT_REASON = "ChatGPT temporarily limited access to Conversation history.";
+var CLOSED_SESSION_REASON = "ChatGPT browser session closed; reopening before retry.";
 var positiveIntegerOption = (value, optionName, defaultValue) => {
   if (value === void 0) return defaultValue;
   if (!/^[1-9]\d*$/u.test(value.trim())) {
@@ -15159,7 +15165,14 @@ var writeChatOrganizationDryRun = (input) => {
 var recordChatOrganizationAttempt = async (input) => {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   let queue;
-  if (input.rateLimited) {
+  if (input.sessionClosed) {
+    queue = deferChatOrganizationQueueItem({
+      queue: input.queue,
+      index: input.index,
+      reason: CLOSED_SESSION_REASON,
+      timestamp
+    });
+  } else if (input.rateLimited) {
     queue = deferChatOrganizationQueueItem({
       queue: input.queue,
       index: input.index,
@@ -15269,7 +15282,7 @@ var runChatOrganize = async (options) => {
     await releaseQueueLock();
     throw error;
   }
-  const { engine, page } = workspace;
+  let workspaceWasShutdown = false;
   try {
     let index = nextChatOrganizationQueueIndex(queue);
     let consecutiveRateLimitCooldowns = 0;
@@ -15279,7 +15292,7 @@ var runChatOrganize = async (options) => {
         index = nextChatOrganizationQueueIndex(queue);
         continue;
       }
-      if (await acknowledgeChatGptHistoryRateLimit(page)) {
+      if (await acknowledgeChatGptHistoryRateLimit(workspace.page)) {
         consecutiveRateLimitCooldowns += 1;
         if (consecutiveRateLimitCooldowns >= MAX_CONSECUTIVE_ORGANIZATION_COOLDOWNS) {
           writeChatOrganizationProgress(
@@ -15303,23 +15316,45 @@ var runChatOrganize = async (options) => {
       let moveOutcome;
       let thrownReason;
       try {
-        moveOutcome = await moveChatToProject(page, {
+        moveOutcome = await moveChatToProject(workspace.page, {
           chat: item.conversation,
           project: item.project
         });
       } catch (error) {
         thrownReason = error instanceof Error ? error.message : String(error);
       }
-      const rateLimited = await acknowledgeChatGptHistoryRateLimit(page);
+      const sessionClosed = chatOrganizationSessionWasClosed(thrownReason);
+      const rateLimited = await acknowledgeChatGptHistoryRateLimit(workspace.page);
       queue = await recordChatOrganizationAttempt({
         queue,
         queuePath,
         index,
         maxAttempts,
+        sessionClosed,
         rateLimited,
         moveOutcome,
         thrownReason
       });
+      if (sessionClosed) {
+        writeChatOrganizationProgress(
+          "ChatGPT browser session closed; reopening it without consuming a retry attempt.",
+          options
+        );
+        await workspace.engine.shutdown({ closeBrowser: false });
+        workspaceWasShutdown = true;
+        try {
+          workspace = await startWorkspaceSession(options);
+          workspaceWasShutdown = false;
+        } catch (error) {
+          writeChatOrganizationProgress(
+            `Could not reopen the ChatGPT browser session; leaving the queue pending: ${error instanceof Error ? error.message : String(error)}`,
+            options
+          );
+          break;
+        }
+        index = nextChatOrganizationQueueIndex(queue);
+        continue;
+      }
       const recorded = queue.items[index];
       if (recorded?.status === "moved") {
         writeChatOrganizationProgress(`Moved "${recorded.conversation}".`, options);
@@ -15351,7 +15386,7 @@ var runChatOrganize = async (options) => {
     }
   } finally {
     try {
-      await engine.shutdown({ closeBrowser: false });
+      if (!workspaceWasShutdown) await workspace.engine.shutdown({ closeBrowser: false });
     } finally {
       await releaseQueueLock();
     }
@@ -15820,7 +15855,7 @@ var subcommandOpts = (command) => {
 // src/features/terminal/registerCli.ts
 var PROVIDER_OPTION = `Browser provider: ${PROVIDER_IDS.join(", ")} (default: ${DEFAULT_PROVIDER})`;
 var registerCliCommands = (program) => {
-  program.name("bridge").description("Terminal CLI that bridges ChatGPT or Gemini with local tools via MCP").version("0.5.1").option("-r, --repo <path>", "Path to the target repository (default: cwd)").option("-p, --port <number>", "MCP server port (default: 8765)").option("--provider <name>", PROVIDER_OPTION).option("--no-browser", "Skip Chrome browser connection").action(async (_options, command) => {
+  program.name("bridge").description("Terminal CLI that bridges ChatGPT or Gemini with local tools via MCP").version("0.5.2").option("-r, --repo <path>", "Path to the target repository (default: cwd)").option("-p, --port <number>", "MCP server port (default: 8765)").option("--provider <name>", PROVIDER_OPTION).option("--no-browser", "Skip Chrome browser connection").action(async (_options, command) => {
     if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
       command.outputHelp({ error: true });
       process.exitCode = 1;
@@ -15954,8 +15989,8 @@ var registerWorkspaceCommands = (program) => {
     "JSON array of {conversation, project} tasks (inline, @file, or a path)"
   ).option(
     "--interval <secondsOrRange>",
-    "Seconds between UI operations, fixed or random range such as 10-20 (default: 30)"
-  ).option("--cooldown <seconds>", "Seconds to wait after rate limiting (default: 300)").option("--max-attempts <count>", "Attempts per Conversation before failing (default: 3)").option("--restart", "Restart this plan instead of resuming its persisted queue").option("--dry-run", "Validate and show the queue without opening Chrome or writing state").action(
+    "Seconds between UI operations, fixed or random range such as 60-90 (default: 60)"
+  ).option("--cooldown <seconds>", "Seconds to wait after rate limiting (default: 600)").option("--max-attempts <count>", "Attempts per Conversation before failing (default: 4)").option("--restart", "Restart this plan instead of resuming its persisted queue").option("--dry-run", "Validate and show the queue without opening Chrome or writing state").action(
     (_options, command) => runChatOrganize(command.optsWithGlobals())
   );
   const task = program.command("task").description("List or schedule ChatGPT Tasks (ChatGPT only)");