bubble-agent 0.1.0__py3-none-any.whl

bubble_agent/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("bubble-agent")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

bubble_agent/__main__.py

@@ -0,0 +1,4 @@
+from bubble_agent.cli import main
+
+if __name__ == "__main__":
+    main()

bubble_agent/cli.py

@@ -0,0 +1,177 @@
+# PYTHON_ARGCOMPLETE_OK
+
+import argparse
+import logging
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Sequence
+
+import argcomplete
+
+from bubble_agent import __version__
+from bubble_agent.sandbox import (
+    build_bubble_args,
+    fmt_bubble_cmd,
+    make_data_fd,
+    patch_etc_profile,
+)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    stream=sys.stderr,
+)
+
+
+def create_parser(
+    default_config: Path | None = None,
+    default_bin: str = "opencode",
+) -> argparse.ArgumentParser:
+    """Build the argument parser.
+
+    *default_config* and *default_bin* can be overridden via environment
+    variables ``BUBBLE_AGENT_CONFIG_FILE`` and ``BUBBLE_AGENT_BIN``.
+    """
+    if default_config is None:
+        default_config = Path(
+            os.environ.get(
+                "BUBBLE_AGENT_CONFIG_FILE",
+                "~/.config/bubble-agent/bubble-agent.conf",
+            )
+        ).expanduser()
+
+    parser = argparse.ArgumentParser(
+        description="Run your coding agent in a bubble.",
+    )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        help="Directories or .code-workspace files to bind into the sandbox",
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=Path,
+        default=default_config,
+        help="Path to config file (default: %(default)s)",
+    )
+    parser.add_argument(
+        "-b",
+        "--bin",
+        default=default_bin,
+        help="Agent binary to run (default: %(default)s)",
+    )
+    parser.add_argument(
+        "-S",
+        "--no-symlink",
+        action="store_true",
+        help="Do not symlink workspace folders (preserve original tree structure)",
+    )
+    parser.add_argument(
+        "-D",
+        "--dry-run",
+        action="store_true",
+        help="Print bwrap command without executing",
+    )
+    return parser
+
+
+def parse_cli(argv: list[str]) -> tuple[argparse.Namespace, list[str]]:
+    """Split *argv* at ``--`` into bubble-agent options and agent args.
+
+    Everything before ``--`` is parsed by :func:`create_parser`; everything
+    after is forwarded to the agent binary unchanged.
+    """
+    try:
+        split_idx = argv.index("--")
+    except ValueError:
+        split_idx = len(argv)
+
+    cli_args = argv[:split_idx]
+    agent_args = argv[split_idx + 1 :] if split_idx < len(argv) else []
+
+    default_config = Path(
+        os.environ.get(
+            "BUBBLE_AGENT_CONFIG_FILE",
+            "~/.config/bubble-agent/bubble-agent.conf",
+        )
+    ).expanduser()
+    default_bin = os.environ.get("BUBBLE_AGENT_BIN", "opencode")
+
+    parser = create_parser(default_config, default_bin)
+    argcomplete.autocomplete(parser)
+    opts = parser.parse_args(cli_args)
+    return opts, agent_args
+
+
+def _launch(args: list[list[str]], bin_path: str, agent_args: list[str]) -> None:
+    """Feed bwrap options via ``--args <fd>`` and execute the sandbox.
+
+    Serializes *args* into a NUL-separated pipe for ``--args <fd>``,
+    patches ``/etc/profile`` to preserve the sandbox ``PATH``, and runs
+    bwrap via :func:`subprocess.run` with explicit ``pass_fds``.
+
+    Does not return — calls :func:`sys.exit` with bwrap's exit code.
+    """
+    bwrap_payload = [item for group in args for item in group]
+    args_data = b"\0".join(a.encode("utf-8") for a in bwrap_payload) + b"\0"
+    args_fd = make_data_fd(args_data)
+
+    path_value = next(
+        (g[2] for g in reversed(args) if g[0] == "--setenv" and g[1] == "PATH"),
+        os.environ.get("PATH", ""),
+    )
+    profile_fd = make_data_fd(patch_etc_profile(path_value))
+
+    bubble_cmd = [
+        "bwrap",
+        "--args",
+        str(args_fd),
+        "--ro-bind-data",
+        str(profile_fd),
+        "/etc/profile",
+        "--",
+        bin_path,
+    ] + agent_args
+
+    try:
+        result = subprocess.run(bubble_cmd, pass_fds=[args_fd, profile_fd])
+    except FileNotFoundError:
+        logging.error("bwrap not found in PATH")
+        sys.exit(1)
+    finally:
+        os.close(args_fd)
+        os.close(profile_fd)
+
+    sys.exit(result.returncode)
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    """Entry point: parse CLI, build sandbox, and launch the agent.
+
+    On ``--dry-run``, prints the equivalent ``bwrap`` command to stderr and
+    exits.  Otherwise, serializes sandbox configuration into anonymous pipes
+    and delegates execution to :func:`_launch`.
+    """
+    if argv is None:
+        argv = sys.argv[1:]
+
+    opts, agent_args = parse_cli(list(argv))
+    bin_path = shutil.which(opts.bin) or opts.bin
+
+    args = build_bubble_args(opts)
+
+    if opts.dry_run:
+        logging.info(fmt_bubble_cmd(args, bin_path, agent_args))
+        sys.exit(0)
+
+    _launch(args, bin_path, agent_args)

bubble_agent/config.py

@@ -0,0 +1,123 @@
+import logging
+import os
+import re
+from pathlib import Path
+
+SHELL_VARS = {
+    "UID": str(os.getuid()),
+    "EUID": str(os.geteuid()),
+    "GID": str(os.getgid()),
+    "EGID": str(os.getegid()),
+}
+
+SHELL_VAR_RE = re.compile(
+    r"\$\{(UID|EUID|GID|EGID)\}|\$(UID|EUID|GID|EGID)(?![A-Za-z0-9_])"
+)
+
+UNEXPANDED_RE = re.compile(r"\$\{?[A-Za-z_][A-Za-z0-9_]*\}?")
+
+BIND_FLAG: dict[str, str] = {
+    "bind": "--bind",
+    "ro-bind": "--ro-bind",
+    "bind-try": "--bind-try",
+    "ro-bind-try": "--ro-bind-try",
+    "symlink": "--symlink",
+    "env": "--setenv",
+    "setenv": "--setenv",
+}
+
+
+def expand_path(s: str) -> str:
+    """Expand ``$UID``/``${EUID}``/..., ``$VAR``, ``~`` in *s*.
+
+    Shell built-in vars (``UID``, ``EUID``, ``GID``, ``EGID``) are
+    resolved from the process, then :func:`os.path.expandvars` and
+    :func:`os.path.expanduser` handle the rest.
+    """
+    s = SHELL_VAR_RE.sub(lambda m: SHELL_VARS[m.group(1) or m.group(2)], s)
+    return os.path.expandvars(os.path.expanduser(s))
+
+
+def has_unexpanded(s: str) -> bool:
+    """Return ``True`` if *s* appears to contain an unexpanded variable."""
+    return "$" in s and UNEXPANDED_RE.search(s) is not None
+
+
+def load_config(
+    conf: Path,
+) -> tuple[list[list[str]], list[str], list[str]]:
+    """Parse a config file and return ``(bind_args, path_prepend, path_append)``.
+
+    Lines are of the form ``type:source:destination`` (see docs for the
+    full list of bind types).  ``#`` starts a comment; blank lines are
+    ignored.  Returns empty lists when *conf* does not exist.
+    """
+    if not conf.is_file():
+        return [], [], []
+
+    logging.info("Loading binds from: %s", conf)
+    logging.info("----------------------------------------")
+
+    args: list[list[str]] = []
+    path_prepend: list[str] = []
+    path_append: list[str] = []
+    count = 0
+
+    for line in conf.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        parts = line.split(":", 2)
+        if len(parts) < 2:
+            continue
+
+        typ = parts[0].strip()
+        src = parts[1].strip()
+        dst = parts[2].strip() if len(parts) > 2 else ""
+
+        if typ in ("workspace", "workspace-path"):
+            logging.warning(
+                "[%s] config-based workspace is deprecated, use CLI args", typ
+            )
+            continue
+
+        if typ in ("path-prepend", "path-append"):
+            src = expand_path(src)
+            if has_unexpanded(src):
+                logging.warning("[%s] SKIP: unexpanded variable in %s", typ, src)
+                continue
+            logging.info("[%s] %s", typ, src)
+            if typ == "path-prepend":
+                path_prepend.append(src)
+            else:
+                path_append.append(src)
+            count += 1
+            continue
+
+        flag = BIND_FLAG.get(typ)
+        if not flag:
+            logging.warning("Unknown bind type: %s", typ)
+            continue
+
+        src = expand_path(src)
+        dst = expand_path(dst)
+
+        if has_unexpanded(src) or has_unexpanded(dst):
+            logging.warning("[%s] SKIP: unexpanded variable in %s:%s", typ, src, dst)
+            continue
+
+        if typ in ("bind", "ro-bind") and not os.path.exists(src):
+            logging.warning("[%s] SKIP: %s (not found)", typ, src)
+            continue
+
+        if typ in ("env", "setenv"):
+            logging.info("[env] %s=%s", src, dst)
+        else:
+            logging.info("[%s] %s -> %s", typ, src, dst)
+        args.append([flag, src, dst])
+        count += 1
+
+    logging.info("----------------------------------------")
+    logging.info("Total custom binds loaded: %d", count)
+    logging.info("")
+    return args, path_prepend, path_append

bubble_agent/sandbox.py

@@ -0,0 +1,243 @@
+import argparse
+import getpass
+import logging
+import os
+import re
+from pathlib import Path
+
+from bubble_agent.config import expand_path, load_config
+from bubble_agent.workspace import parse_workspace, ws_folder_paths
+
+
+def fmt_bubble_cmd(
+    groups: list[list[str]], bin_path: str, agent_args: list[str]
+) -> str:
+    """Format a ``bwrap`` command-line string for ``--dry-run`` output.
+
+    Each group in *groups* is joined with spaces; groups are separated by
+    `` \\\n  `` for readability.
+    """
+    items: list[str] = ["bwrap"]
+    for g in groups:
+        items.append(" ".join(g))
+    items.append("--")
+    items.append(bin_path)
+    items.extend(agent_args)
+    return " \\\n  ".join(items)
+
+
+def make_data_fd(data: bytes) -> int:
+    """Write *data* into a pipe and return the read-end file descriptor.
+
+    The caller is responsible for closing the returned fd.
+    Intended for passing arbitrary payloads to subprocesses via ``pass_fds``
+    (e.g. bwrap ``--args <fd>``).
+    """
+    r_fd, w_fd = os.pipe()
+    try:
+        while data:
+            try:
+                n = os.write(w_fd, data)
+            except InterruptedError:
+                continue
+            data = data[n:]
+    finally:
+        os.close(w_fd)
+    return r_fd
+
+
+_PATH_BLOCK_RE = re.compile(
+    r'if\s+\[\s*"\$\(id\s+-u\)"[^;]*;\s*then\b'
+    r".*?"
+    r"\bfi\b\s*\n\s*export\s+PATH\s*\n?",
+    re.DOTALL,
+)
+
+
+def patch_etc_profile(custom_path: str) -> bytes:
+    """Return a patched ``/etc/profile`` that keeps *custom_path* in effect.
+
+    The standard ``id -u`` PATH-initialization block is removed and
+    *custom_path* is appended at the end so it always wins.  All other
+    content (``/etc/bash.bashrc``, ``/etc/profile.d/*``, …) is preserved.
+    """
+    try:
+        original = Path("/etc/profile").read_text()
+    except OSError:
+        original = ""
+
+    patched = _PATH_BLOCK_RE.sub("", original)
+    patched = patched.rstrip("\n") + f'\nPATH="{custom_path}"\nexport PATH\n'
+    return patched.encode()
+
+
+def resolv_conf_args() -> list[list[str]]:
+    """Bind-resolve ``/etc/resolv.conf`` when it is a symlink.
+
+    Returns the ``--ro-bind`` entry for the parent directory of the
+    symlink target, or an empty list when nothing needs to be done.
+    """
+    resolv = Path("/etc/resolv.conf")
+    if not resolv.is_symlink():
+        return []
+    try:
+        real = resolv.resolve(strict=True)
+    except OSError:
+        return []
+    if real.parent.is_dir():
+        logging.info("resolv.conf symlink: /etc/resolv.conf -> %s", real)
+        return [["--ro-bind", str(real.parent), str(real.parent)]]
+    return []
+
+
+def build_bubble_args(opts: argparse.Namespace) -> list[list[str]]:
+    """Build the full list of bwrap argument groups from CLI *opts*.
+
+    Combines fixed sandbox setup (namespaces, mounts, env vars) with
+    entries from the config file and positional path arguments.
+    """
+    home = os.environ.get("HOME", str(Path.home()))
+    user = os.environ.get("USER") or os.environ.get("LOGNAME") or getpass.getuser()
+    logname = os.environ.get("LOGNAME") or user
+    shell = os.environ.get("SHELL", "/bin/sh")
+    uid = os.getuid()
+
+    args: list[list[str]] = []
+
+    args.append(["--unshare-pid"])
+    args.append(["--die-with-parent"])
+    args.append(["--new-session"])
+
+    args.append(["--clearenv"])
+    args.extend(
+        [
+            ["--setenv", "HOME", home],
+            ["--setenv", "USER", user],
+            ["--setenv", "LOGNAME", logname],
+            ["--setenv", "TERM", os.environ.get("TERM", "xterm-256color")],
+            ["--setenv", "LANG", os.environ.get("LANG", "en_US.UTF-8")],
+            ["--setenv", "SHELL", shell],
+        ]
+    )
+
+    args.append(["--share-net"])
+    args.append(["--dev", "/dev"])
+
+    args.extend(
+        [
+            ["--ro-bind", "/usr", "/usr"],
+            ["--ro-bind", "/etc", "/etc"],
+            ["--ro-bind-try", "/lib", "/lib"],
+            ["--ro-bind-try", "/lib64", "/lib64"],
+            ["--ro-bind-try", "/lib32", "/lib32"],
+            ["--ro-bind-try", "/sys", "/sys"],
+        ]
+    )
+
+    args.append(["--symlink", "usr/bin", "/bin"])
+    args.append(["--symlink", "usr/sbin", "/sbin"])
+
+    args.append(["--proc", "/proc"])
+    args.append(["--tmpfs", "/tmp"])
+
+    args.append(["--tmpfs", "/run"])
+    args.append(["--dir", f"/run/user/{uid}"])
+    args.append(["--setenv", "XDG_RUNTIME_DIR", f"/run/user/{uid}"])
+
+    args.append(["--dir", "/var"])
+    args.append(["--symlink", "../tmp", "var/tmp"])
+
+    args.extend(resolv_conf_args())
+
+    config_groups, path_prepend, path_append = load_config(opts.config)
+
+    explicit_path = next(
+        (
+            g[2]
+            for g in reversed(config_groups)
+            if g[0] == "--setenv" and g[1] == "PATH"
+        ),
+        None,
+    )
+
+    if explicit_path is not None:
+        config_groups = [
+            g for g in config_groups if not (g[0] == "--setenv" and g[1] == "PATH")
+        ]
+        base_parts = explicit_path.split(":") if explicit_path else []
+        all_paths = list(path_prepend) + base_parts + list(path_append)
+    else:
+        base_path = os.environ.get("PATH", "")
+        all_paths = (
+            list(path_prepend)
+            + (base_path.split(":") if base_path else [])
+            + list(path_append)
+        )
+
+    seen: set[str] = set()
+    merged: list[str] = []
+    for p in all_paths:
+        if p and p not in seen:
+            seen.add(p)
+            merged.append(p)
+    path_value = ":".join(merged)
+    args.append(["--setenv", "PATH", path_value])
+
+    args.extend(config_groups)
+
+    dir_paths: list[str] = []
+    ws_files: list[str] = []
+
+    for p in opts.paths or []:
+        expanded = expand_path(p)
+        if expanded.endswith(".code-workspace"):
+            if os.path.isfile(expanded):
+                ws_files.append(expanded)
+            else:
+                logging.warning(
+                    "[path] %s looks like a workspace file but "
+                    "is not a regular file, treating as directory",
+                    expanded,
+                )
+                dir_paths.append(expanded)
+        else:
+            dir_paths.append(expanded)
+
+    for dp in dir_paths:
+        args.append(["--bind-try", dp, dp])
+
+    if ws_files:
+        if opts.no_symlink:
+            for ws in ws_files:
+                args.extend(parse_workspace(ws, "", no_symlink=True))
+            args.append(["--dir", home])
+
+            all_folders: list[Path] = []
+            for ws in ws_files:
+                all_folders.extend(ws_folder_paths(ws))
+            chdir = (
+                os.path.commonpath([str(f) for f in all_folders])
+                if all_folders
+                else str(Path(ws_files[0]).parent)
+            )
+            args.append(["--chdir", chdir])
+        else:
+            ws_dest = expand_path("~/workspace")
+            args.append(["--tmpfs", ws_dest])
+            args.append(["--dir", home])
+            for ws in ws_files:
+                args.extend(parse_workspace(ws, ws_dest))
+            args.append(["--chdir", ws_dest])
+    elif dir_paths:
+        args.append(["--dir", home])
+        args.append(["--chdir", dir_paths[0]])
+        if opts.no_symlink:
+            logging.warning("--no-symlink has no effect without a .code-workspace file")
+    else:
+        pwd = str(Path.cwd())
+        args.append(["--dir", home])
+        args.append(["--bind", pwd, pwd])
+        args.append(["--chdir", pwd])
+        logging.info("[pwd] auto-binding cwd: %s", pwd)
+
+    return args

bubble_agent/workspace.py

@@ -0,0 +1,88 @@
+import json
+import logging
+from pathlib import Path
+
+from bubble_agent.config import expand_path
+
+
+def parse_workspace(
+    ws_file: str, dest: str, *, no_symlink: bool = False
+) -> list[list[str]]:
+    """Parse a ``.code-workspace`` file into bwrap bind/symlink groups.
+
+    Binds each folder at its real path and, unless *no_symlink* is set,
+    creates a symlink under *dest* with the folder name.  Duplicate folder
+    names are disambiguated with a parent-directory prefix.
+    """
+    f = Path(ws_file)
+    if not f.is_file():
+        logging.warning("Workspace file not found: %s", f)
+        return []
+    try:
+        data = json.loads(f.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as exc:
+        logging.warning("Failed to parse workspace file %s: %s", f, exc)
+        return []
+    folders = data.get("folders")
+    if not folders:
+        logging.warning("Workspace file %s has no 'folders'", f)
+        return []
+
+    ws_root = Path(expand_path(dest)) if dest else Path()
+    result: list[list[str]] = []
+
+    seen: set[str] = set()
+    for folder in folders:
+        raw = folder.get("path", "")
+        if not raw:
+            continue
+        path = Path(raw)
+        if not path.is_absolute():
+            path = f.parent / path
+        real = path.expanduser().resolve()
+        if no_symlink:
+            logging.info("[workspace] %s (no-symlink)", real)
+            result.append(["--bind-try", str(real), str(real)])
+            continue
+        name = folder.get("name") or real.name
+        if name in seen:
+            parent_name = real.parent.name or "root"
+            name = f"{parent_name}_{name}"
+            if name in seen:
+                suffix = 2
+                while f"{name}_{suffix}" in seen:
+                    suffix += 1
+                name = f"{name}_{suffix}"
+        seen.add(name)
+        logging.info("[workspace] %s -> %s/%s", real, ws_root, name)
+        result.append(["--bind-try", str(real), str(real)])
+        result.append(["--symlink", str(real), f"{ws_root}/{name}"])
+    return result
+
+
+def ws_folder_paths(ws_file: str) -> list[Path]:
+    """Return the resolved folder paths from a ``.code-workspace`` file.
+
+    Relative paths are resolved against the workspace file's parent
+    directory.  Each path goes through ``.expanduser().resolve()``.
+    """
+    f = Path(ws_file)
+    if not f.is_file():
+        return []
+    try:
+        data = json.loads(f.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return []
+    folders = data.get("folders")
+    if not folders:
+        return []
+    result: list[Path] = []
+    for folder in folders:
+        raw = folder.get("path", "")
+        if not raw:
+            continue
+        path = Path(raw)
+        if not path.is_absolute():
+            path = f.parent / path
+        result.append(path.expanduser().resolve())
+    return result

bubble_agent-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: bubble-agent
+Version: 0.1.0
+Summary: Run your coding agent in a bubble.
+Project-URL: Homepage, https://github.com/ak1ra-lab/bubble-agent
+Project-URL: Repository, https://github.com/ak1ra-lab/bubble-agent
+Project-URL: Documentation, https://ak1ra-lab.github.io/bubble-agent/
+Author-email: ak1ra <git@ak1ra.xyz>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: argcomplete>=3.6.3
+Description-Content-Type: text/markdown
+
+# bubble-agent
+
+[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/ak1ra-lab/bubble-agent/.github%2Fworkflows%2Fpublish-to-pypi.yaml)](https://github.com/ak1ra-lab/bubble-agent/actions/workflows/publish-to-pypi.yaml)
+[![PyPI - Version](https://img.shields.io/pypi/v/bubble-agent)](https://pypi.org/project/bubble-agent/)
+[![Docs](https://img.shields.io/badge/docs-online-0a7ea4)](https://ak1ra-lab.github.io/bubble-agent/)
+
+> This project is inspired by [cyunrei/opencode-bwrap](https://github.com/cyunrei/opencode-bwrap).
+
+Run your coding agent in a bubble.
+
+Uses [bubblewrap](https://github.com/containers/bubblewrap) to sandbox coding agents with configurable bind mounts and virtual workspace (`.code-workspace`) support.  Sandbox arguments are passed via ``--args <fd>`` for clean process listings, and ``/etc/profile`` is automatically patched to prevent login shells from resetting the custom ``PATH``.
+
+By default, the sandbox wraps [opencode](https://github.com/anomalyco/opencode). Use `--bin` to run a different coding agent.
+
+## Quick Start
+
+```shell
+git clone https://github.com/ak1ra-lab/bubble-agent.git
+cd bubble-agent
+just install
+
+bubble-agent                              # runs opencode by default
+bubble-agent ~/my-project                 # work in a specific directory
+bubble-agent --dry-run                    # preview the bwrap command
+```
+
+See [Documentation](https://ak1ra-lab.github.io/bubble-agent/) for full usage, configuration, and workspace features.

bubble_agent-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+bubble_agent/__init__.py,sha256=FxxSOAmqVmwoL-VcKQGr3dJowovmHbR2GOKASUCYZzg,164
+bubble_agent/__main__.py,sha256=QAjLEVNspn3OzkvhoESNzPDt5hZlHAbLsBQjzhWJz0w,73
+bubble_agent/cli.py,sha256=nHUBEIDTfhbgTAdMiUdsVonSoXKDObKzeKa-N8_OKPI,4908
+bubble_agent/config.py,sha256=NAq596qBIVsnJNIUbTDIp4hs1AT9yKIAaMA_OIv6D_k,3766
+bubble_agent/sandbox.py,sha256=fiPdIh_iMmNTVagqKBr9MANsWZ9WTsCTRPjJwOxP5EM,7530
+bubble_agent/workspace.py,sha256=h31dn0ptkacPKa--NmLBozfXhwNEl3aUP57qqSXAoXs,2905
+bubble_agent-0.1.0.dist-info/METADATA,sha256=naXO6owU6CkJ1wXlIsHuPJ2wuXPqV1dtKrDXIyMRGIE,2305
+bubble_agent-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+bubble_agent-0.1.0.dist-info/entry_points.txt,sha256=YJ09ueGbKGj9pM5gX-IdCCYAbpR40x0mKAYlwpNoO_g,55
+bubble_agent-0.1.0.dist-info/licenses/LICENSE,sha256=YHzY01v-48KH_ZZhuZXvAtJ7xrfmVk5RiNU-r44LVeU,1066
+bubble_agent-0.1.0.dist-info/RECORD,,

bubble_agent-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

bubble_agent-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bubble-agent = bubble_agent.cli:main

bubble_agent-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ak1ra-lab
+
+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.