orb-browser 0.1.0__tar.gz

orb_browser-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

orb_browser-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: orb-browser
+Version: 0.1.0
+Summary: Browser agents that sleep for $0 and wake in 500ms on Orb Cloud
+License: MIT
+Project-URL: Homepage, https://github.com/nextbysam/orb-browser
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# orb-browser
+
+Browser agents that sleep for $0 and wake in 500ms.
+
+Deploy headless Chrome on [Orb Cloud](https://orbcloud.dev). Connect [browser-use](https://github.com/browser-use/browser-use) or any CDP client. When idle, checkpoint the browser to NVMe — cookies, DOM, localStorage, everything preserved. Wake it up later in ~500ms, exactly where you left off.
+
+## Install
+
+```bash
+pip install orb-browser browser-use
+```
+
+Or from source:
+```bash
+pip install git+https://github.com/nextbysam/orb-browser.git
+```
+
+## Get an API Key
+
+```bash
+# Register
+curl -X POST https://api.orbcloud.dev/api/v1/auth/register \
+  -H 'Content-Type: application/json' \
+  -d '{"email":"you@example.com"}'
+
+# Create org key
+curl -X POST https://api.orbcloud.dev/v1/keys \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H 'Content-Type: application/json' \
+  -d '{"name":"my-key"}'
+```
+
+## Usage
+
+```python
+import asyncio
+from orb_browser import OrbBrowser
+from browser_use import Browser
+
+async def main():
+    # Deploy a browser on Orb Cloud (~1-3 min first time)
+    orb = OrbBrowser(api_key="orb_...")
+    cdp_url = orb.deploy()
+
+    # Connect browser-use
+    browser = Browser(cdp_url=cdp_url)
+    await browser.start()
+
+    # Full browser control
+    await browser.navigate_to("https://example.com")
+    title = await browser.get_current_page_title()
+    screenshot = await browser.take_screenshot()
+
+    # Disconnect before sleep
+    await browser.stop()
+
+    # Sleep — frozen to NVMe, $0/hr
+    orb.sleep()
+
+    # ... hours later ...
+
+    # Wake — ~500ms, everything restored
+    cdp_url = orb.wake()
+
+    # Reconnect — same page, same cookies
+    browser = Browser(cdp_url=cdp_url)
+    await browser.start()
+
+    # Clean up
+    await browser.stop()
+    orb.destroy()
+
+asyncio.run(main())
+```
+
+## API
+
+```python
+from orb_browser import OrbBrowser
+
+orb = OrbBrowser(api_key="orb_...")
+```
+
+| Method | Description |
+|--------|-------------|
+| `orb.deploy()` | Deploy browser VM, returns CDP WebSocket URL |
+| `orb.sleep()` | Checkpoint to NVMe ($0 while sleeping) |
+| `orb.wake()` | Restore from checkpoint (~500ms), returns new CDP URL |
+| `orb.destroy()` | Delete the VM |
+| `orb.connect(computer_id, agent_port)` | Connect to existing VM |
+| `orb.state` | Current state: init, deploying, running, sleeping, destroyed |
+| `orb.vm_url` | HTTPS URL of the VM |
+| `orb.cdp_url` | CDP WebSocket URL |
+
+## How It Works
+
+1. `deploy()` creates a VM on Orb Cloud, installs Chromium via Playwright, starts it with CDP debugging enabled
+2. Returns a `wss://` CDP URL that browser-use (or Puppeteer, Playwright, any CDP client) connects to
+3. `sleep()` calls CRIU to checkpoint the entire process tree (Node.js + Chromium + renderers) to NVMe
+4. `wake()` restores everything in ~500ms — the browser doesn't know it was frozen
+
+## Works With
+
+- [browser-use](https://github.com/browser-use/browser-use) (78K stars) — AI browser agents
+- [Playwright](https://playwright.dev) — `browser = await chromium.connect_over_cdp(cdp_url)`
+- [Puppeteer](https://pptr.dev) — `browser = await puppeteer.connect({ browserWSEndpoint: cdpUrl })`
+- Any CDP client
+
+## License
+
+MIT

orb_browser-0.1.0/README.md

@@ -0,0 +1,111 @@
+# orb-browser
+
+Browser agents that sleep for $0 and wake in 500ms.
+
+Deploy headless Chrome on [Orb Cloud](https://orbcloud.dev). Connect [browser-use](https://github.com/browser-use/browser-use) or any CDP client. When idle, checkpoint the browser to NVMe — cookies, DOM, localStorage, everything preserved. Wake it up later in ~500ms, exactly where you left off.
+
+## Install
+
+```bash
+pip install orb-browser browser-use
+```
+
+Or from source:
+```bash
+pip install git+https://github.com/nextbysam/orb-browser.git
+```
+
+## Get an API Key
+
+```bash
+# Register
+curl -X POST https://api.orbcloud.dev/api/v1/auth/register \
+  -H 'Content-Type: application/json' \
+  -d '{"email":"you@example.com"}'
+
+# Create org key
+curl -X POST https://api.orbcloud.dev/v1/keys \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H 'Content-Type: application/json' \
+  -d '{"name":"my-key"}'
+```
+
+## Usage
+
+```python
+import asyncio
+from orb_browser import OrbBrowser
+from browser_use import Browser
+
+async def main():
+    # Deploy a browser on Orb Cloud (~1-3 min first time)
+    orb = OrbBrowser(api_key="orb_...")
+    cdp_url = orb.deploy()
+
+    # Connect browser-use
+    browser = Browser(cdp_url=cdp_url)
+    await browser.start()
+
+    # Full browser control
+    await browser.navigate_to("https://example.com")
+    title = await browser.get_current_page_title()
+    screenshot = await browser.take_screenshot()
+
+    # Disconnect before sleep
+    await browser.stop()
+
+    # Sleep — frozen to NVMe, $0/hr
+    orb.sleep()
+
+    # ... hours later ...
+
+    # Wake — ~500ms, everything restored
+    cdp_url = orb.wake()
+
+    # Reconnect — same page, same cookies
+    browser = Browser(cdp_url=cdp_url)
+    await browser.start()
+
+    # Clean up
+    await browser.stop()
+    orb.destroy()
+
+asyncio.run(main())
+```
+
+## API
+
+```python
+from orb_browser import OrbBrowser
+
+orb = OrbBrowser(api_key="orb_...")
+```
+
+| Method | Description |
+|--------|-------------|
+| `orb.deploy()` | Deploy browser VM, returns CDP WebSocket URL |
+| `orb.sleep()` | Checkpoint to NVMe ($0 while sleeping) |
+| `orb.wake()` | Restore from checkpoint (~500ms), returns new CDP URL |
+| `orb.destroy()` | Delete the VM |
+| `orb.connect(computer_id, agent_port)` | Connect to existing VM |
+| `orb.state` | Current state: init, deploying, running, sleeping, destroyed |
+| `orb.vm_url` | HTTPS URL of the VM |
+| `orb.cdp_url` | CDP WebSocket URL |
+
+## How It Works
+
+1. `deploy()` creates a VM on Orb Cloud, installs Chromium via Playwright, starts it with CDP debugging enabled
+2. Returns a `wss://` CDP URL that browser-use (or Puppeteer, Playwright, any CDP client) connects to
+3. `sleep()` calls CRIU to checkpoint the entire process tree (Node.js + Chromium + renderers) to NVMe
+4. `wake()` restores everything in ~500ms — the browser doesn't know it was frozen
+
+## Works With
+
+- [browser-use](https://github.com/browser-use/browser-use) (78K stars) — AI browser agents
+- [Playwright](https://playwright.dev) — `browser = await chromium.connect_over_cdp(cdp_url)`
+- [Puppeteer](https://pptr.dev) — `browser = await puppeteer.connect({ browserWSEndpoint: cdpUrl })`
+- Any CDP client
+
+## License
+
+MIT

orb_browser-0.1.0/orb_browser/__init__.py

@@ -0,0 +1,4 @@
+from orb_browser.client import OrbBrowser
+
+__all__ = ["OrbBrowser"]
+__version__ = "0.1.0"

orb_browser-0.1.0/orb_browser/client.py

@@ -0,0 +1,281 @@
+"""
+OrbBrowser — deploy browser agents on Orb Cloud.
+
+Usage:
+    from orb_browser import OrbBrowser
+
+    orb = OrbBrowser(api_key="orb_...")
+    cdp_url = orb.deploy()
+
+    # Use with browser-use
+    from browser_use import Browser
+    browser = Browser(cdp_url=cdp_url)
+    await browser.start()
+
+    # Sleep ($0 while frozen)
+    orb.sleep()
+
+    # Wake (~500ms)
+    cdp_url = orb.wake()
+    browser = Browser(cdp_url=cdp_url)
+    await browser.start()
+"""
+
+import json
+import time
+import urllib.request
+import urllib.error
+
+# The orb.toml config that runs on Orb Cloud
+ORB_TOML = """[agent]
+name = "orb-browser"
+lang = "node"
+entry = "server.js"
+
+[source]
+git = "https://github.com/nextbysam/orb-browser.git"
+branch = "main"
+
+[build]
+steps = [
+  "apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y libnss3 libatk-bridge2.0-0t64 libcups2t64 libdrm2 libgbm1 libpango-1.0-0 libcairo2 libasound2t64 libxshmfence1 libxcomposite1 libxrandr2 libxdamage1 libxfixes3 libxext6 libx11-xcb1 libxcb1 libxkbcommon0 libdbus-1-3",
+  "cd /agent/code && npm install",
+  "PLAYWRIGHT_BROWSERS_PATH=/opt/browsers npx playwright install chromium"
+]
+working_dir = "/agent/code"
+
+[agent.env]
+PLAYWRIGHT_BROWSERS_PATH = "/opt/browsers"
+PORT = "8000"
+CDP_PORT = "9222"
+
+[backend]
+provider = "custom"
+
+[ports]
+expose = [8000, 9222]
+"""
+
+
+class OrbBrowser:
+    """Deploy and manage a browser on Orb Cloud with sleep/wake support."""
+
+    def __init__(self, api_key: str, api_url: str = "https://api.orbcloud.dev"):
+        self.api_key = api_key
+        self.api_url = api_url
+        self.computer_id: str | None = None
+        self.short_id: str | None = None
+        self.agent_port: int | None = None
+        self.cdp_url: str | None = None
+        self._state = "init"
+
+    def deploy(
+        self,
+        name: str | None = None,
+        runtime_mb: int = 2048,
+        disk_mb: int = 4096,
+        wait: bool = True,
+    ) -> str:
+        """
+        Deploy a browser on Orb Cloud. Returns the CDP WebSocket URL.
+
+        Takes 1-3 minutes on first deploy (installs Chrome).
+        """
+        if name is None:
+            name = f"orb-browser-{int(time.time())}"
+
+        self._state = "deploying"
+        print(f"[orb-browser] Creating VM...")
+
+        # 1. Create computer
+        res = self._orb("POST", "/v1/computers", {
+            "name": name, "runtime_mb": runtime_mb, "disk_mb": disk_mb,
+        })
+        self.computer_id = res["id"]
+        self.short_id = self.computer_id[:8]
+        print(f"[orb-browser] VM: {self.short_id}")
+
+        try:
+            # 2. Upload config
+            req = urllib.request.Request(
+                f"{self.api_url}/v1/computers/{self.computer_id}/config",
+                data=ORB_TOML.encode(),
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/toml",
+                },
+                method="POST",
+            )
+            urllib.request.urlopen(req)
+
+            # 3. Build
+            print(f"[orb-browser] Building (Chrome + Playwright)...")
+            req = urllib.request.Request(
+                f"{self.api_url}/v1/computers/{self.computer_id}/build",
+                headers={"Authorization": f"Bearer {self.api_key}"},
+                method="POST",
+            )
+            build_res = json.loads(urllib.request.urlopen(req, timeout=900).read())
+            if not build_res.get("success"):
+                failed = next(
+                    (s for s in build_res.get("steps", []) if s["exit_code"] != 0),
+                    None,
+                )
+                raise RuntimeError(f"Build failed: {failed}")
+            print(f"[orb-browser] Build OK")
+
+            # 4. Deploy agent
+            deploy_res = self._orb(
+                "POST", f"/v1/computers/{self.computer_id}/agents", {}
+            )
+            self.agent_port = deploy_res["agents"][0]["port"]
+
+            # 5. Wait for health
+            if wait:
+                self._wait_for_health(timeout=60)
+
+            # 6. Set hostname so CDP URLs are correct
+            vm_url = f"https://{self.short_id}.orbcloud.dev"
+            urllib.request.urlopen(
+                f"{vm_url}/set-host?host={self.short_id}.orbcloud.dev"
+            )
+
+            # 7. Get CDP URL
+            cdp_data = json.loads(
+                urllib.request.urlopen(f"{vm_url}/cdp").read()
+            )
+            self.cdp_url = cdp_data["cdpUrl"]
+            self._state = "running"
+
+            print(f"[orb-browser] Ready! CDP: {self.cdp_url}")
+            return self.cdp_url
+
+        except Exception:
+            self.destroy()
+            raise
+
+    def connect(self, computer_id: str, agent_port: int) -> str:
+        """Connect to an existing Orb Browser VM. Returns CDP URL."""
+        self.computer_id = computer_id
+        self.short_id = computer_id[:8]
+        self.agent_port = agent_port
+        self._state = "running"
+
+        vm_url = f"https://{self.short_id}.orbcloud.dev"
+        urllib.request.urlopen(
+            f"{vm_url}/set-host?host={self.short_id}.orbcloud.dev"
+        )
+        cdp_data = json.loads(urllib.request.urlopen(f"{vm_url}/cdp").read())
+        self.cdp_url = cdp_data["cdpUrl"]
+        return self.cdp_url
+
+    def sleep(self) -> dict:
+        """
+        Checkpoint the browser to NVMe. Costs $0 while sleeping.
+        WebSocket connections will drop — reconnect after wake().
+        """
+        if self._state != "running":
+            raise RuntimeError(f"Cannot sleep in state: {self._state}")
+
+        res = self._orb(
+            "POST",
+            f"/v1/computers/{self.computer_id}/agents/demote",
+            {"port": self.agent_port},
+        )
+        if res.get("status") != "demoted":
+            raise RuntimeError(f"Sleep failed: {res}")
+
+        self._state = "sleeping"
+        print(f"[orb-browser] Sleeping (frozen, $0)")
+        return res
+
+    def wake(self, wait: bool = True) -> str:
+        """
+        Restore the browser from NVMe. ~500ms.
+        Returns the CDP URL (same as before sleep).
+        Reconnect browser-use with the returned URL.
+        """
+        if self._state != "sleeping":
+            raise RuntimeError(f"Cannot wake in state: {self._state}")
+
+        res = self._orb(
+            "POST",
+            f"/v1/computers/{self.computer_id}/agents/promote",
+            {"port": self.agent_port},
+        )
+        if res.get("status") != "promoted":
+            raise RuntimeError(f"Wake failed: {res}")
+
+        if res.get("port"):
+            self.agent_port = res["port"]
+
+        if wait:
+            self._wait_for_health(timeout=30)
+
+        # Refresh CDP URL
+        vm_url = f"https://{self.short_id}.orbcloud.dev"
+        cdp_data = json.loads(urllib.request.urlopen(f"{vm_url}/cdp").read())
+        self.cdp_url = cdp_data["cdpUrl"]
+        self._state = "running"
+
+        print(f"[orb-browser] Awake! CDP: {self.cdp_url}")
+        return self.cdp_url
+
+    def destroy(self):
+        """Delete the VM."""
+        if not self.computer_id:
+            return
+        try:
+            req = urllib.request.Request(
+                f"{self.api_url}/v1/computers/{self.computer_id}",
+                headers={"Authorization": f"Bearer {self.api_key}"},
+                method="DELETE",
+            )
+            urllib.request.urlopen(req)
+        except urllib.error.HTTPError:
+            pass
+        self._state = "destroyed"
+        print(f"[orb-browser] Destroyed {self.short_id}")
+
+    @property
+    def vm_url(self) -> str | None:
+        return f"https://{self.short_id}.orbcloud.dev" if self.short_id else None
+
+    @property
+    def state(self) -> str:
+        return self._state
+
+    # -- Internal --
+
+    def _orb(self, method: str, path: str, body: dict | None = None) -> dict:
+        data = json.dumps(body).encode() if body is not None else None
+        req = urllib.request.Request(
+            f"{self.api_url}{path}",
+            data=data,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+            method=method,
+        )
+        try:
+            return json.loads(urllib.request.urlopen(req).read())
+        except urllib.error.HTTPError as e:
+            body_text = e.read().decode() if e.fp else ""
+            raise RuntimeError(
+                f"Orb API {method} {path} failed ({e.code}): {body_text}"
+            )
+
+    def _wait_for_health(self, timeout: int = 60):
+        vm_url = f"https://{self.short_id}.orbcloud.dev"
+        start = time.time()
+        while time.time() - start < timeout:
+            try:
+                res = urllib.request.urlopen(f"{vm_url}/health", timeout=5)
+                data = json.loads(res.read())
+                if data.get("status") == "ok" and data.get("browserReady"):
+                    return
+            except Exception:
+                pass
+            time.sleep(2)
+        raise TimeoutError(f"Browser not ready after {timeout}s")

orb_browser-0.1.0/orb_browser.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: orb-browser
+Version: 0.1.0
+Summary: Browser agents that sleep for $0 and wake in 500ms on Orb Cloud
+License: MIT
+Project-URL: Homepage, https://github.com/nextbysam/orb-browser
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# orb-browser
+
+Browser agents that sleep for $0 and wake in 500ms.
+
+Deploy headless Chrome on [Orb Cloud](https://orbcloud.dev). Connect [browser-use](https://github.com/browser-use/browser-use) or any CDP client. When idle, checkpoint the browser to NVMe — cookies, DOM, localStorage, everything preserved. Wake it up later in ~500ms, exactly where you left off.
+
+## Install
+
+```bash
+pip install orb-browser browser-use
+```
+
+Or from source:
+```bash
+pip install git+https://github.com/nextbysam/orb-browser.git
+```
+
+## Get an API Key
+
+```bash
+# Register
+curl -X POST https://api.orbcloud.dev/api/v1/auth/register \
+  -H 'Content-Type: application/json' \
+  -d '{"email":"you@example.com"}'
+
+# Create org key
+curl -X POST https://api.orbcloud.dev/v1/keys \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H 'Content-Type: application/json' \
+  -d '{"name":"my-key"}'
+```
+
+## Usage
+
+```python
+import asyncio
+from orb_browser import OrbBrowser
+from browser_use import Browser
+
+async def main():
+    # Deploy a browser on Orb Cloud (~1-3 min first time)
+    orb = OrbBrowser(api_key="orb_...")
+    cdp_url = orb.deploy()
+
+    # Connect browser-use
+    browser = Browser(cdp_url=cdp_url)
+    await browser.start()
+
+    # Full browser control
+    await browser.navigate_to("https://example.com")
+    title = await browser.get_current_page_title()
+    screenshot = await browser.take_screenshot()
+
+    # Disconnect before sleep
+    await browser.stop()
+
+    # Sleep — frozen to NVMe, $0/hr
+    orb.sleep()
+
+    # ... hours later ...
+
+    # Wake — ~500ms, everything restored
+    cdp_url = orb.wake()
+
+    # Reconnect — same page, same cookies
+    browser = Browser(cdp_url=cdp_url)
+    await browser.start()
+
+    # Clean up
+    await browser.stop()
+    orb.destroy()
+
+asyncio.run(main())
+```
+
+## API
+
+```python
+from orb_browser import OrbBrowser
+
+orb = OrbBrowser(api_key="orb_...")
+```
+
+| Method | Description |
+|--------|-------------|
+| `orb.deploy()` | Deploy browser VM, returns CDP WebSocket URL |
+| `orb.sleep()` | Checkpoint to NVMe ($0 while sleeping) |
+| `orb.wake()` | Restore from checkpoint (~500ms), returns new CDP URL |
+| `orb.destroy()` | Delete the VM |
+| `orb.connect(computer_id, agent_port)` | Connect to existing VM |
+| `orb.state` | Current state: init, deploying, running, sleeping, destroyed |
+| `orb.vm_url` | HTTPS URL of the VM |
+| `orb.cdp_url` | CDP WebSocket URL |
+
+## How It Works
+
+1. `deploy()` creates a VM on Orb Cloud, installs Chromium via Playwright, starts it with CDP debugging enabled
+2. Returns a `wss://` CDP URL that browser-use (or Puppeteer, Playwright, any CDP client) connects to
+3. `sleep()` calls CRIU to checkpoint the entire process tree (Node.js + Chromium + renderers) to NVMe
+4. `wake()` restores everything in ~500ms — the browser doesn't know it was frozen
+
+## Works With
+
+- [browser-use](https://github.com/browser-use/browser-use) (78K stars) — AI browser agents
+- [Playwright](https://playwright.dev) — `browser = await chromium.connect_over_cdp(cdp_url)`
+- [Puppeteer](https://pptr.dev) — `browser = await puppeteer.connect({ browserWSEndpoint: cdpUrl })`
+- Any CDP client
+
+## License
+
+MIT

orb_browser-0.1.0/orb_browser.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+orb_browser/__init__.py
+orb_browser/client.py
+orb_browser.egg-info/PKG-INFO
+orb_browser.egg-info/SOURCES.txt
+orb_browser.egg-info/dependency_links.txt
+orb_browser.egg-info/top_level.txt

orb_browser-0.1.0/orb_browser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

orb_browser-0.1.0/orb_browser.egg-info/top_level.txt

@@ -0,0 +1 @@
+orb_browser

orb_browser-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "orb-browser"
+version = "0.1.0"
+description = "Browser agents that sleep for $0 and wake in 500ms on Orb Cloud"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+
+[project.urls]
+Homepage = "https://github.com/nextbysam/orb-browser"
+
+[tool.setuptools.packages.find]
+include = ["orb_browser*"]

orb_browser-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+