camoufox-cli 0.7.1__tar.gz → 0.7.2__tar.gz

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camoufox-cli
-Version: 0.7.1
+Version: 0.7.2
 Summary: Anti-detect browser CLI & Skills for AI agents, powered by Camoufox
 Project-URL: Homepage, https://github.com/Bin-Huang/camoufox-cli
 Project-URL: Repository, https://github.com/Bin-Huang/camoufox-cli

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/js/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "camoufox-cli",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "camoufox-cli",
-      "version": "0.7.1",
+      "version": "0.7.2",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camoufox-cli",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Anti-detect headless browser automation CLI & Skills for AI agents, powered by Camoufox",
   "type": "module",
   "bin": {

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/js/src/browser.ts

@@ -70,6 +70,8 @@ export class BrowserManager {
   private tabs = new Map<string, TabState>();
   private launching: Promise<void> | null = null;
   private recovering: Promise<void> | null = null;
+  // Serializes releaseTab calls; see releaseTab for why.
+  private releasing: Promise<void> = Promise.resolve();
   private persistent: string | null;
   private proxy: string | null;
   private geoip: boolean;
@@ -266,10 +268,23 @@ export class BrowserManager {
    * which would hijack another agent's tab), and when no live tab remains
    * the browser itself is closed. Idempotent: releasing a tab that has no
    * open page is a no-op, not an error.
+   *
+   * Releases are SERIALIZED through a promise chain. Without it, N
+   * concurrent closes interleave at the awaits: every one deletes its own
+   * map entry first, then every survivor scan sees an emptied map, so all
+   * N conclude they are the last tab out — the browser gets torn down N
+   * times and isRunning flips false for every in-flight close, which made
+   * the server destroy sibling connections before their responses flushed
+   * (their tabs were released, but the clients never got the receipt).
    */
-  async releaseTab(tab: string): Promise<void> {
-    // Remove the entry before any await so a concurrent release of another
-    // tab doesn't still count this one as live.
+  releaseTab(tab: string): Promise<void> {
+    const run = this.releasing.then(() => this.doReleaseTab(tab));
+    // Keep the chain usable even if a release fails.
+    this.releasing = run.catch(() => {});
+    return run;
+  }
+
+  private async doReleaseTab(tab: string): Promise<void> {
     const st = this.tabs.get(tab);
     this.tabs.delete(tab);
     if (st?.page && !st.page.isClosed()) {

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/js/src/cli.ts

@@ -493,10 +493,24 @@ async function main() {
       return;
     } catch (e: any) {
       lastErr = e.message || String(e);
+      // close is idempotent: if the daemon is gone (socket removed), there is
+      // nothing left to close — that IS success. This is the receipt for a
+      // close that raced the last-tab shutdown: the daemon may exit after
+      // releasing our tab but before our response could be delivered.
+      if (action === "close" && !fs.existsSync(sockPath)) {
+        if (flags.json) console.log(JSON.stringify({ id: "r1", success: true, data: { closed: true } }));
+        return;
+      }
       if (attempt < 4) await new Promise((r) => setTimeout(r, 200 * (attempt + 1)));
     }
   }
 
+  // Same idempotent-close check once more: the daemon may have finished
+  // unlinking its socket only while we were burning the retry budget.
+  if (action === "close" && !fs.existsSync(sockPath)) {
+    if (flags.json) console.log(JSON.stringify({ id: "r1", success: true, data: { closed: true } }));
+    return;
+  }
   process.stderr.write(`Error: Failed to connect to daemon after 5 attempts: ${lastErr}\n`);
   process.exit(1);
 }

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/js/src/server.ts

@@ -21,6 +21,9 @@ export class DaemonServer {
   // the server side lingering until we destroy it. Track live connections so
   // shutdown can drop them — otherwise server.close() never emits 'close'.
   private connections = new Set<net.Socket>();
+  // Connections currently processing a request; closeServer defers their
+  // destruction until the response has flushed.
+  private busy = new Set<net.Socket>();
 
   constructor(opts: { session?: string; headless?: boolean; timeout?: number; persistent?: string | null; proxy?: string | null; geoip?: boolean; locale?: string | null }) {
     this.session = opts.session ?? "default";
@@ -67,7 +70,7 @@ export class DaemonServer {
 
   private handleConnection(conn: net.Socket): void {
     this.connections.add(conn);
-    conn.on("close", () => this.connections.delete(conn));
+    conn.on("close", () => { this.connections.delete(conn); this.busy.delete(conn); });
 
     let data = "";
     let handled = false;
@@ -77,6 +80,10 @@ export class DaemonServer {
       const nlIdx = data.indexOf("\n");
       if (nlIdx < 0) return;
       handled = true;
+      // Mark mid-request: closeServer must let this connection's response
+      // flush instead of destroying it (its client would otherwise never
+      // learn that its command actually succeeded).
+      this.busy.add(conn);
 
       this.lastActivity = Date.now();
       const line = data.slice(0, nlIdx).trim();
@@ -97,10 +104,7 @@ export class DaemonServer {
         // tabs keep the daemon alive, so a non-final close just responds and
         // its connection cleans up on the normal path.
         if (command.action === "close" && !this.manager.isRunning) {
-          // Destroy the current connection only after its response has
-          // flushed, then drop the rest via closeServer().
-          conn.once("finish", () => conn.destroy());
-          this.closeServer(conn);
+          this.closeServer();
         }
       } catch (e: any) {
         conn.end(Buffer.from(JSON.stringify({ id: "?", success: false, error: String(e) }) + "\n"));
@@ -169,16 +173,26 @@ export class DaemonServer {
   }
 
   /**
-   * Stop the server and drop every lingering half-open connection so it can
-   * actually emit 'close'. Without destroying connections, allowHalfOpen keeps
-   * them alive and server.close() never completes, so the daemon hangs forever.
-   * Pass `except` to spare one connection (e.g. the in-flight close command,
-   * which destroys itself once its response has flushed).
+   * Stop the server and drop lingering connections so it can actually emit
+   * 'close'. Without destroying idle half-open connections, allowHalfOpen
+   * keeps them alive and server.close() never completes, so the daemon hangs
+   * forever. Connections that are mid-request (concurrent commands — e.g.
+   * several agents' closes racing the last-tab shutdown) are NOT cut: their
+   * work has already executed, so destroying them would eat the response and
+   * make the client report a failure for a command that succeeded. They are
+   * destroyed once their response flushes ('finish'), with a timeout backstop
+   * so a wedged handler can't keep the daemon alive forever.
    */
-  private closeServer(except?: net.Socket): void {
+  private closeServer(): void {
     this.server?.close();
     for (const c of this.connections) {
-      if (c !== except) c.destroy();
+      if (!this.busy.has(c) || c.writableFinished) {
+        c.destroy();
+        continue;
+      }
+      const backstop = setTimeout(() => c.destroy(), 10_000);
+      backstop.unref();
+      c.once("finish", () => { clearTimeout(backstop); c.destroy(); });
     }
   }
 

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/js/tests/browser.test.ts

@@ -29,6 +29,30 @@ describe("BrowserManager", () => {
     expect(launches).toBe(2);
   });
 
+  it("concurrent releases: only the true last tab out closes the browser", async () => {
+    const manager = new BrowserManager();
+    let closes = 0;
+    vi.spyOn(manager, "close").mockImplementation(async () => { closes++; });
+    // Fake pages that take a moment to close, forcing the releases to
+    // interleave at the await — the exact shape of the production race.
+    const mkTab = () => ({
+      page: { isClosed: () => false, close: () => new Promise((r) => setTimeout(r, 20)) },
+    });
+    (manager as any).tabs.set("a", mkTab());
+    (manager as any).tabs.set("b", mkTab());
+    (manager as any).tabs.set("c", mkTab());
+
+    await Promise.all([
+      manager.releaseTab("a"),
+      manager.releaseTab("b"),
+      manager.releaseTab("c"),
+    ]);
+    // Unserialized, every release sees an emptied map and all three "close
+    // the browser"; serialized, only the genuine last one does.
+    expect(closes).toBe(1);
+    expect((manager as any).tabs.size).toBe(0);
+  });
+
   it("getPage rejects when not launched", async () => {
     const manager = new BrowserManager();
     await expect(manager.getPage()).rejects.toThrow("not launched");

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/js/tests/server.test.ts

@@ -178,6 +178,49 @@ describe("DaemonServer", () => {
     await serverPromise;
   });
 
+  it("concurrent closes all receive a response (none eaten by shutdown)", async () => {
+    // Regression: N agents closing at once. The first close to complete used
+    // to see isRunning=false and destroy every sibling connection before its
+    // response flushed — the tabs were released but the clients reported
+    // failure. All N clients must get a parseable success response.
+    const server = new DaemonServer({ session: TEST_SESSION, timeout: 5 });
+    const serverPromise = server.start();
+    for (let i = 0; i < 50; i++) {
+      if (fs.existsSync(SOCK_PATH)) break;
+      await new Promise(r => setTimeout(r, 100));
+    }
+
+    const sendClose = (id: string) => new Promise<string>((resolve, reject) => {
+      const client = net.createConnection(SOCK_PATH, () => {
+        client.end(JSON.stringify({ id, action: "close", params: {} }) + "\n");
+      });
+      let data = "";
+      client.on("data", chunk => { data += chunk.toString(); });
+      client.on("end", () => resolve(data));
+      client.on("error", reject);
+    });
+
+    const responses = await Promise.all(
+      ["c1", "c2", "c3", "c4", "c5", "c6"].map(sendClose)
+    );
+    // Every connection whose request began processing must get a full,
+    // parseable response (the old code destroyed them mid-response). A
+    // sibling that had not even been read yet may be dropped at shutdown —
+    // the real CLI covers that via its idempotent-close fallback — but a
+    // partial/truncated response is never acceptable.
+    let delivered = 0;
+    for (const raw of responses) {
+      if (raw === "") continue;
+      const parsed = JSON.parse(raw); // truncated raw -> test fails here
+      expect(parsed.success).toBe(true);
+      delivered++;
+    }
+    expect(delivered).toBeGreaterThan(0);
+
+    await serverPromise; // daemon still shuts down cleanly afterwards
+    expect(fs.existsSync(SOCK_PATH)).toBe(false);
+  });
+
   it("cleans up socket and pid on shutdown", async () => {
     const server = new DaemonServer({
       session: TEST_SESSION,

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "camoufox-cli"
-version = "0.7.1"
+version = "0.7.2"
 description = "Anti-detect browser CLI & Skills for AI agents, powered by Camoufox"
 requires-python = ">=3.10"
 license = "MIT"

{camoufox_cli-0.7.1 → camoufox_cli-0.7.2}/src/camoufox_cli/cli.py

@@ -502,9 +502,24 @@ def main():
             return
         except Exception as e:
             last_err = str(e)
+            # close is idempotent: if the daemon is gone (socket removed),
+            # there is nothing left to close — that IS success. This is the
+            # receipt for a close that raced the last-tab shutdown: the daemon
+            # may exit after releasing our tab but before responding.
+            if action == "close" and not os.path.exists(sock_path):
+                if flags["json"]:
+                    print(json.dumps({"id": "r1", "success": True, "data": {"closed": True}}))
+                return
             if attempt < 4:
                 time.sleep(0.2 * (attempt + 1))
 
+    # Same idempotent-close check once more: the daemon may have finished
+    # unlinking its socket only while we were burning the retry budget.
+    if action == "close" and not os.path.exists(sock_path):
+        if flags["json"]:
+            print(json.dumps({"id": "r1", "success": True, "data": {"closed": True}}))
+        return
+
     print(f"Error: Failed to connect to daemon after 5 attempts: {last_err}", file=sys.stderr)
     sys.exit(1)