@53able/pi-agent-browser 0.4.2 → 0.6.0

package/README.ja-JP.md

@@ -177,7 +177,9 @@ https://example.com をブラウザ経由で読み、outputs/browser/example.md
 agent-browser doctor
 ```
 
-または Pi に `agent_browser_doctor` を実行させてください。
+または Pi に `agent_browser_doctor` を実行させてください。インストール、Chrome、daemon、security、provider、network、launch test を確認します。`agent_browser_login_handoff` で作ったセッションでまだ開いているログインブラウザも報告し、期限切れ追跡データを自動削除します。
+
+`agent_browser_login_handoff` で作ったセッションの中で、まだ生存しているログインブラウザがあれば、`agent_browser_doctor` がそれらを報告します（セッション名、プロセス ID、デバッグポート、最後に開いていた URL を表示）。終わったら各セッションに対して `agent_browser_close` を呼んでください — これらのセッションはブラウザを閉じるまでリモートデバッグポートが開いたままです。期限切れエントリ（実行中でなくなったプロセスの追跡データ）は、何も通知することなく自動削除されます。`agent_browser_login_handoff` 自身も、成功メッセージの中でほかに生存中のログインブラウザ（セッション名とプロセス ID）を教えてくれるので、`agent_browser_doctor` を別途呼ばなくても気づけます。
 
 よくある修正:
 

package/README.md

@@ -179,7 +179,9 @@ Run:
 agent-browser doctor
 ```
 
-Or ask Pi to run `agent_browser_doctor`.
+Or ask Pi to run `agent_browser_doctor`. This verifies installation, Chrome, daemon, security, providers, network, and launch tests. It also reports any live login-handoff browsers left open and cleans up stale tracking entries.
+
+If you have sessions created with `agent_browser_login_handoff`, `agent_browser_doctor` will report any that still have live login browsers running, showing the session name, process ID, debugging port, and last known URL. Call `agent_browser_close` for each session when done — these hold an open remote-debugging port until closed. Stale entries (tracking data for processes no longer running) are cleaned up automatically with no notification. `agent_browser_login_handoff` itself also names any *other* sessions still running a live login browser in its success message, so you notice without a separate `agent_browser_doctor` call.
 
 Common fixes:
 

package/index.ts

@@ -275,6 +275,15 @@ function killPidBestEffort(pid?: number): void {
   try { process.kill(pid); } catch { /* already gone / not ours */ }
 }
 
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0); // signal 0 = no-op existence/permission check, does not actually kill
+    return true;
+  } catch (err) {
+    return (err as NodeJS.ErrnoException).code !== "ESRCH"; // ESRCH = no such process (dead); any other error (e.g. EPERM) means it exists
+  }
+}
+
 function abortableDelay(ms: number, signal?: AbortSignal): Promise<void> {
   return new Promise((resolveDelay) => {
     if (signal?.aborted) {
@@ -956,6 +965,18 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
         loginDebugPort: port,
       });
 
+      // Surface other still-live login browsers so they don't go unnoticed between
+      // agent_browser_doctor runs (same isPidAlive/cleanup semantics as doctor).
+      const otherLiveBrowsers: { session: string; pid: number }[] = [];
+      for (const [otherSession, otherState] of Object.entries(await readSessionStates(ctx.cwd))) {
+        if (otherSession === session || !otherState.loginBrowserPid) continue;
+        if (!isPidAlive(otherState.loginBrowserPid)) {
+          await writeSessionState(ctx.cwd, otherSession, { clearLoginBrowserPid: true });
+          continue;
+        }
+        otherLiveBrowsers.push({ session: otherSession === DEFAULT_SESSION_KEY ? "(default)" : otherSession, pid: otherState.loginBrowserPid });
+      }
+
       const multiTab = /\bt2\b/.test(tabResult.stdout) || (tabResult.stdout.match(/\[t\d+\]/g)?.length ?? 0) > 1;
       return {
         content: [{
@@ -966,6 +987,9 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
             multiTab ? `Note: multiple tabs are open — verify the active tab before acting:\n${tabResult.stdout.trim()}` : undefined,
             "The session drives this real browser window directly. Take a fresh agent_browser_snapshot before continuing.",
             "This login browser has an open remote-debugging port and will stay open until agent_browser_close is called for this session (or the window is closed manually).",
+            otherLiveBrowsers.length > 0
+              ? `Also still open: ${otherLiveBrowsers.map((b) => `${b.session} (pid ${b.pid})`).join(", ")}. Call agent_browser_close for each when done, or run agent_browser_doctor for full details.`
+              : undefined,
           ].filter(Boolean).join("\n"),
         }],
         details: { ...result, artifactPaths: [] },
@@ -1052,15 +1076,43 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "agent_browser_doctor",
     label: "Agent Browser Doctor",
-    description: "Run agent-browser doctor to verify installation, Chrome, daemon, security, providers, network, and launch tests.",
-    promptSnippet: "Use agent_browser_doctor when browser automation fails or before relying on agent-browser in a workflow.",
+    description: "Run agent-browser doctor to verify installation, Chrome, daemon, security, providers, network, and launch tests. Also reports and cleans up tracked login-handoff browsers (see agent_browser_login_handoff).",
+    promptSnippet: "Use agent_browser_doctor when browser automation fails or before relying on agent-browser in a workflow. It also flags any live login-handoff browsers left open and cleans up stale tracking entries.",
     parameters: DoctorSchema,
     async execute(_id, rawParams, signal, onUpdate, ctx) {
       const params = rawParams as JsonObject;
       const args = ["doctor"];
       if (params.fix === true) args.push("--fix");
       const result = await runAgentBrowser(args, { signal, timeoutMs: params.timeoutMs as number | undefined, cwd: ctx.cwd, onUpdate });
-      return buildTextResult(result);
+      const textResult = buildTextResult(result);
+
+      const states = await readSessionStates(ctx.cwd);
+      const liveBrowsers: { session: string; pid: number; port: number | undefined; lastUrl?: string }[] = [];
+      for (const [session, state] of Object.entries(states)) {
+        if (!state.loginBrowserPid) continue;
+        if (!isPidAlive(state.loginBrowserPid)) {
+          await writeSessionState(ctx.cwd, session, { clearLoginBrowserPid: true });
+          continue;
+        }
+        liveBrowsers.push({
+          session: session === DEFAULT_SESSION_KEY ? "(default)" : session,
+          pid: state.loginBrowserPid,
+          port: state.loginDebugPort,
+          lastUrl: state.lastUrl,
+        });
+      }
+
+      if (liveBrowsers.length > 0) {
+        const lines = [
+          "",
+          "Live login browsers (from agent_browser_login_handoff) still open:",
+          ...liveBrowsers.map((b) => `- ${b.session}: pid ${b.pid}, debug port ${b.port ?? "?"}${b.lastUrl ? `, last url ${b.lastUrl}` : ""}`),
+          "Call agent_browser_close for each session when done — these hold an open remote-debugging port until closed.",
+        ];
+        textResult.content[0].text += lines.join("\n");
+      }
+
+      return textResult;
     },
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@53able/pi-agent-browser",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "description": "Typed Pi tools for browser automation, rendered-page context extraction, screenshots, and saved session state via agent-browser.",
   "type": "module",
   "license": "MIT",

package/skills/agent-browser/SKILL.md

@@ -64,6 +64,10 @@ After the human confirms login is complete, subsequent `agent_browser_open`, `ag
 
 **Security note:** The login browser's `--remote-debugging-port` remains open on localhost for as long as the session is alive. This gives any local process full browser control — the same caveat agent-browser's own docs give about `--remote-debugging-port`. Call `agent_browser_close` when done with a session that went through login handoff, rather than leaving it open indefinitely. `agent_browser_close` will terminate the tracked login Chrome process and clean up its debugging port.
 
+Run `agent_browser_doctor` to see which sessions still have live login browsers open. It reports any that are still running (session name, process ID, debugging port, and last known URL) with a reminder to call `agent_browser_close`. Stale tracking entries for processes no longer running are cleaned up silently with no user notification.
+
+`agent_browser_login_handoff` also surfaces this automatically: its success message names any *other* sessions that still have a live login browser open (session name and process ID), so you don't have to run `agent_browser_doctor` separately just to notice one was left open.
+
 Re-running `agent_browser_login_handoff` for the same session name will terminate any previous live login browser for that session before spawning a new one.
 
 ## Common examples