sbxloop 0.6.0__tar.gz → 0.6.2__tar.gz

{sbxloop-0.6.0 → sbxloop-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sbxloop
-Version: 0.6.0
+Version: 0.6.2
 Summary: Agentic loop orchestration on Docker Sandboxes (sbx) with isolated credential domains
 Project-URL: Homepage, https://github.com/brettbergin/sbxloop
 Project-URL: Repository, https://github.com/brettbergin/sbxloop
@@ -23,6 +23,8 @@ Requires-Dist: sbxloop-worker
 Requires-Dist: typer>=0.12
 Provides-Extra: copilot
 Requires-Dist: github-copilot-sdk>=1.0.8; extra == 'copilot'
+Provides-Extra: discord
+Requires-Dist: discord-py>=2.3; extra == 'discord'
 Description-Content-Type: text/markdown
 
 # sbxloop

{sbxloop-0.6.0 → sbxloop-0.6.2}/pyproject.toml

@@ -31,6 +31,9 @@ dependencies = [
 # Host-side SDK access for `sbxloop list-models` (agent sessions get the SDK
 # inside the sandbox via sbxloop-worker[copilot]; runs never need this extra).
 copilot = ["github-copilot-sdk>=1.0.8"]
+# `sbxloop daemon`'s Discord bridge (chronology + steering); the daemon runs
+# without it when [discord] is unset.
+discord = ["discord.py>=2.3"]
 
 [project.scripts]
 sbxloop = "sbxloop.cli.app:main"

{sbxloop-0.6.0 → sbxloop-0.6.2}/src/sbxloop/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.6.0'
-__version_tuple__ = version_tuple = (0, 6, 0)
+__version__ = version = '0.6.2'
+__version_tuple__ = version_tuple = (0, 6, 2)
 
 __commit_id__ = commit_id = None

{sbxloop-0.6.0 → sbxloop-0.6.2}/src/sbxloop/cli/app.py

@@ -25,6 +25,8 @@ from sbxloop.cli.doctor import run_doctor
 from sbxloop.cli.tui import ChatInput, Dashboard, format_event, plain_printer, render_event
 from sbxloop.config import (
     Config,
+    DaemonConfig,
+    DiscordConfig,
     GithubConfig,
     load_config,
     load_config_with_sources,
@@ -34,7 +36,7 @@ from sbxloop.engine.engine import LoopEngine
 from sbxloop.engine.model import TERMINAL_RUN_STATES, RunResult, artifacts_dir, scan_artifacts
 from sbxloop.engine.store import StateStore
 from sbxloop.errors import SbxloopError
-from sbxloop.events import Event, HostEventTypes
+from sbxloop.events import Event, EventBus, HostEventTypes
 from sbxloop.sbx.bake import DEFAULT_TEMPLATE_REF, bake_template
 from sbxloop.sbx.cli import SbxCLI
 from sbxloop.sbx.models import SandboxRole
@@ -1204,6 +1206,155 @@ def init(
     console.print(f"wrote {path}")
 
 
+@app.command()
+def daemon(
+    repo: Annotated[
+        str | None,
+        typer.Option("--repo", help='GitHub repository ("owner/name") to poll for labeled issues.'),
+    ] = None,
+    inbox: Annotated[
+        str | None,
+        typer.Option("--inbox", help='Inbox directory of .md work files ("" disables).'),
+    ] = None,
+    backlog: Annotated[
+        str | None,
+        typer.Option("--backlog", help="Where agent-filed follow-up work goes: github|inbox|off."),
+    ] = None,
+    max_runs_per_day: Annotated[
+        int | None, typer.Option("--max-runs-per-day", help="Rolling 24h run cap.")
+    ] = None,
+    poll_interval: Annotated[
+        float | None, typer.Option("--poll-interval", help="Seconds between polls.")
+    ] = None,
+    discord_channel: Annotated[
+        int | None,
+        typer.Option("--discord-channel", help="Discord control channel id (enables the bridge)."),
+    ] = None,
+    once: Annotated[
+        bool, typer.Option("--once", help="Recover, run one tick, exit (cron / smoke tests).")
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Poll and print candidates; claim and run nothing.")
+    ] = False,
+) -> None:
+    """Run the always-on outer loop: discover work (labeled GitHub issues,
+    inbox files), run each item through the inner loop, report back, and
+    mirror the chronology to Discord."""
+    import logging
+
+    from sbxloop.daemon.discord import DiscordBridge
+    from sbxloop.daemon.github import DaemonGithub
+    from sbxloop.daemon.loop import DaemonLoop
+    from sbxloop.daemon.sources import GitHubIssueSource, GitHubLabels, InboxSource, WorkSource
+    from sbxloop.daemon.store import DaemonStore
+
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s"
+    )
+    config = load_config()
+    daemon_overrides = {
+        k: v
+        for k, v in (
+            ("inbox_dir", inbox),
+            ("backlog", backlog),
+            ("max_runs_per_day", max_runs_per_day),
+            ("poll_interval_s", poll_interval),
+        )
+        if v is not None
+    }
+    try:
+        if daemon_overrides:
+            daemon_cfg = DaemonConfig.model_validate(
+                {**config.daemon.model_dump(), **daemon_overrides}
+            )
+            config = config.model_copy(update={"daemon": daemon_cfg})
+        if repo is not None:
+            github_cfg = GithubConfig.model_validate({**config.github.model_dump(), "repo": repo})
+            config = config.model_copy(update={"github": github_cfg})
+        if discord_channel is not None:
+            discord_cfg = DiscordConfig.model_validate(
+                {**config.discord.model_dump(), "channel_id": discord_channel}
+            )
+            config = config.model_copy(update={"discord": discord_cfg})
+    except ValidationError as exc:
+        console.print(f"[bold red]invalid daemon option:[/] {exc.errors()[0]['msg']}")
+        raise typer.Exit(2) from exc
+
+    github_active = config.github.enabled
+    inbox_active = bool(config.daemon.inbox_dir)
+    if not github_active and not inbox_active:
+        console.print(
+            "[bold red]no work sources:[/] set [cyan]--repo owner/name[/] (or "
+            "[cyan]\\[github] repo[/]) to poll issues, and/or an inbox directory "
+            "([cyan]--inbox DIR[/] / [cyan]\\[daemon] inbox_dir[/])."
+        )
+        raise typer.Exit(2)
+    if config.daemon.backlog == "github" and not github_active:
+        console.print("[bold red]--backlog github needs a GitHub repository[/] (--repo).")
+        raise typer.Exit(2)
+
+    store = _store(config)
+    dstore = DaemonStore(config.state_dir / "state.db")
+    sbx = SbxCLI(app_name=config.app_name or None)
+    bus = EventBus()
+    bus.subscribe(plain_printer(console))
+    sources: list[WorkSource] = []
+    github: DaemonGithub | None = None
+    if inbox_active:
+        sources.append(InboxSource(Path(config.daemon.inbox_dir)))
+    if github_active:
+        assert config.github.repo is not None
+        github = DaemonGithub(config, sbx, bus, worker_python=config.worker_python)
+        github.remove_stale()
+        labels = GitHubLabels(
+            config.daemon.trigger_label,
+            config.daemon.in_progress_label,
+            config.daemon.failed_label,
+            config.daemon.backlog_label,
+        )
+        sources.append(GitHubIssueSource(github.ops, config.github.repo, labels))
+
+    if dry_run:
+        for source in sources:
+            for item in source.poll():
+                console.print(
+                    f"[cyan]{item.item_id}[/]  {item.title}" + (f"  {item.url}" if item.url else "")
+                )
+        if github is not None:
+            github.close()
+        raise typer.Exit(0)
+
+    loop = DaemonLoop(config, store=store, dstore=dstore, sources=sources, sbx=sbx)
+    bridge: DiscordBridge | None = None
+    if config.discord.enabled:
+        try:
+            bridge = DiscordBridge(config, dstore, loop_ref=loop)
+            bridge.start()
+        except SbxloopError as exc:
+            console.print(f"[bold red]discord bridge:[/] {exc}")
+            raise typer.Exit(2) from exc
+        loop.frontend = bridge
+
+    cleanup_registry.install_handlers()
+    cleanup_registry.set_quiesce(loop.quiesce)
+    try:
+        loop.recover()
+        if once:
+            result = loop.tick()
+            console.print(f"tick: {result}")
+        else:
+            loop.run_forever()
+    except KeyboardInterrupt:
+        console.print("\n[bold yellow]daemon interrupted[/]")
+    finally:
+        cleanup_registry.set_quiesce(None)
+        if bridge is not None:
+            bridge.close()
+        if github is not None:
+            github.close()
+        dstore.close()
+
+
 @app.command()
 def bake(
     ref: Annotated[
@@ -1448,6 +1599,44 @@ per_job_timeout_s = 1800.0
 disk_warn = 85.0
 disk_abort = 95.0
 mem_warn = 90.0
+
+[daemon]
+# `sbxloop daemon` — the always-on outer loop. Discovers work and runs each
+# item as a full inner-loop run, fully autonomously: a labeled issue in the
+# [github] repo or a .md file in the inbox starts a run on its own, so the
+# guardrails below are what stand between a mislabeled issue and your budget.
+# inbox_dir = ".sbxloop/inbox"     # "" disables the inbox source
+# poll_interval_s = 60.0
+# trigger_label = "sbxloop:run"    # issue label that queues work
+# in_progress_label = "sbxloop:in-progress"
+# failed_label = "sbxloop:failed"
+# backlog_label = "sbxloop:backlog"
+# max_runs_per_day = 12            # rolling 24h window, persisted across restarts
+# max_attempts_per_item = 2
+# retry_backoff_s = 900.0          # times the attempt number
+# max_consecutive_failures = 3     # circuit breaker ...
+# breaker_cooldown_s = 3600.0      # ... and how long it stays open
+# shutdown_grace_s = 60.0          # keep below systemd TimeoutStopSec
+# Agent-filed follow-up work (.sbxloop/backlog/*.md in the run workspace):
+# "github" files issues with backlog_label, "inbox" writes to inbox/triage/,
+# "off" ignores it. Filed items wait for a human unless auto-trigger is on.
+# backlog = "off"
+# backlog_max_per_run = 5
+# backlog_auto_trigger = false
+# deliver_draft = true             # autonomous PRs arrive as drafts
+
+[discord]
+# The daemon's human channel: a gateway bot posts each run's chronology
+# (agent messages, tool lines, issue/PR links) into a thread under a control
+# channel and relays replies typed in the thread to the running agent as
+# steering. Needs `pip install 'sbxloop[discord]'` and DISCORD_BOT_TOKEN in
+# the environment / .env (never here). Anyone who can post in the channel can
+# steer — restrict the channel. Unset channel_id = Discord off.
+# channel_id = 123456789012345678
+# command_prefix = "!sbx"          # !sbx status|pause|resume|cancel|queue
+# thread_per_run = true
+# chronology_level = "normal"      # quiet | normal | verbose
+# max_message_chars = 1900
 """
 
 

{sbxloop-0.6.0 → sbxloop-0.6.2}/src/sbxloop/cli/doctor.py

@@ -295,6 +295,25 @@ def collect_checks(
             )
         )
 
+    # daemon's Discord bridge (only when configured)
+    if config.discord.enabled:
+        problems: list[str] = []
+        try:
+            import discord as _discordpy  # noqa: F401
+        except ImportError:
+            problems.append("discord.py missing (pip install 'sbxloop[discord]')")
+        if not env.get("DISCORD_BOT_TOKEN"):
+            problems.append("DISCORD_BOT_TOKEN not set")
+        checks.append(
+            Check(
+                "discord bridge",
+                not problems,
+                f"channel {config.discord.channel_id}: "
+                + ("; ".join(problems) if problems else "extra installed, token present"),
+                hard=False,
+            )
+        )
+
     # worker wheel
     wheel = resolve_worker_wheel()
     checks.append(

{sbxloop-0.6.0 → sbxloop-0.6.2}/src/sbxloop/config.py

@@ -278,6 +278,99 @@ class Budgets(_ConfigModel):
     per_job_timeout_s: float = 1800.0
 
 
+BacklogMode = Literal["off", "github", "inbox"]
+
+
+class DaemonConfig(_ConfigModel):
+    """``sbxloop daemon`` — the always-on outer loop.
+
+    The daemon discovers work (GitHub issues carrying ``trigger_label`` in
+    the configured repo, and ``.md`` files in ``inbox_dir``), runs each item
+    as a full inner-loop run, and reports back to the source. It is fully
+    autonomous — a label or a file alone starts a run — so the spend
+    guardrails here are the only thing standing between a mislabeled issue
+    and an empty Copilot budget: a rolling daily run cap, a per-item retry
+    cap, and a consecutive-failure circuit breaker.
+
+    ``backlog`` lets the inner agent file follow-up work it discovers
+    (written to ``.sbxloop/backlog/*.md`` in the run workspace) into either
+    source. Agent-filed items land in triage (the ``backlog_label`` / the
+    inbox ``triage/`` dir) and never run until a human promotes them, unless
+    ``backlog_auto_trigger`` is set — a self-feeding queue is the failure
+    mode that flag guards.
+    """
+
+    inbox_dir: str = ".sbxloop/inbox"  # "" disables the inbox source
+    # Must be positive: Event.wait(<= 0) returns immediately and the loop spins.
+    poll_interval_s: float = Field(default=60.0, gt=0)
+    trigger_label: str = "sbxloop:run"
+    in_progress_label: str = "sbxloop:in-progress"
+    failed_label: str = "sbxloop:failed"
+    backlog_label: str = "sbxloop:backlog"
+    max_runs_per_day: int = 12
+    max_attempts_per_item: int = 2
+    retry_backoff_s: float = 900.0
+    max_consecutive_failures: int = 3
+    breaker_cooldown_s: float = 3600.0
+    # Keep below the service manager's stop timeout. Cancellation is honored
+    # only at task-phase boundaries and interrupted runs are resumable, so
+    # this is a courtesy wait, not a correctness requirement.
+    shutdown_grace_s: float = 60.0
+    backlog: BacklogMode = "off"
+    backlog_max_per_run: int = 5
+    backlog_auto_trigger: bool = False
+    # Autonomous PRs arrive as drafts unless the operator says otherwise.
+    deliver_draft: bool = True
+
+    @model_validator(mode="after")
+    def _check(self) -> DaemonConfig:
+        labels = [
+            self.trigger_label,
+            self.in_progress_label,
+            self.failed_label,
+            self.backlog_label,
+        ]
+        if any(not label.strip() for label in labels):
+            raise ValueError("daemon labels must be non-empty")
+        # GitHub label names are case-insensitive: "sbxloop:run" and
+        # "SBXLOOP:RUN" are the same label, so they cannot mark two states.
+        if len({label.strip().casefold() for label in labels}) != len(labels):
+            raise ValueError("daemon labels must be distinct (case-insensitively)")
+        for name in (
+            "max_runs_per_day",
+            "max_attempts_per_item",
+            "max_consecutive_failures",
+            "backlog_max_per_run",
+        ):
+            if getattr(self, name) < 1:
+                raise ValueError(f"daemon.{name} must be >= 1")
+        return self
+
+
+ChronologyLevel = Literal["quiet", "normal", "verbose"]
+
+
+class DiscordConfig(_ConfigModel):
+    """The daemon's human channel: a gateway bot posting each run's
+    chronology (agent messages, tool lines, issue/PR links) into a thread
+    under a control channel, and relaying replies typed in that thread to
+    the running agent as steering. Unset ``channel_id`` disables it. The bot
+    token comes from ``DISCORD_BOT_TOKEN`` in the environment / .env, never
+    from this file. Anyone who can post in the channel can steer — restrict
+    the channel accordingly."""
+
+    channel_id: int | None = None
+    command_prefix: str = "!sbx"
+    thread_per_run: bool = True
+    chronology_level: ChronologyLevel = "normal"
+    # Discord's hard cap is 2000; leave headroom for wrappers.
+    max_message_chars: int = Field(default=1900, ge=200, le=2000)
+
+    @property
+    def enabled(self) -> bool:
+        return self.channel_id is not None
+
+
 class Config(_ConfigModel):
     model: str = "auto"
     # sbx --app-name. Empty (the default) shares the user's normal sbx
@@ -305,6 +398,8 @@ class Config(_ConfigModel):
     artifacts: ArtifactsConfig = Field(default_factory=ArtifactsConfig)
     budgets: Budgets = Field(default_factory=Budgets)
     limits: Limits = Field(default_factory=Limits)
+    daemon: DaemonConfig = Field(default_factory=DaemonConfig)
+    discord: DiscordConfig = Field(default_factory=DiscordConfig)
 
 
 def _read_toml(path: Path) -> dict[str, Any]:

sbxloop-0.6.2/src/sbxloop/daemon/__init__.py

@@ -0,0 +1,10 @@
+"""``sbxloop daemon`` — the always-on outer loop around the run engine.
+
+Discovers work (GitHub issues by label, inbox ``.md`` files), runs each item
+through a fresh :class:`~sbxloop.engine.engine.LoopEngine`, reports back to
+the source, mirrors the chronology to Discord, and keeps going.
+"""
+
+from sbxloop.daemon.model import RunReport, TickResult, WorkItem
+
+__all__ = ["RunReport", "TickResult", "WorkItem"]

sbxloop-0.6.2/src/sbxloop/daemon/backlog.py

@@ -0,0 +1,95 @@
+"""Agent-filed backlog: follow-up work the inner agent discovered.
+
+The agent sandbox holds no GH_TOKEN, so an agent cannot file issues; it
+writes ``.sbxloop/backlog/*.md`` files in the run workspace instead, and
+the daemon files them after the run through whichever source ``--backlog``
+names. ``.sbxloop`` sits in the default artifact excludes, which is exactly
+what keeps these files out of harvest and out of the delivery PR — and also
+why collection reads the mounted workspace directly (unmounted runs are
+skipped with a loud warning).
+
+Filed items land in triage by default (backlog label / inbox ``triage/``);
+``backlog_auto_trigger`` puts them straight into the queue. Fingerprints
+dedup re-collection on resume, and ``max_items`` caps how much queue one
+run may generate — an agent enumerating infinite future work must not
+flood the daemon.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+from pathlib import Path
+
+from sbxloop.daemon.sources import WorkSource, parse_markdown_item
+from sbxloop.daemon.store import DaemonStore
+from sbxloop.engine.model import RunRecord
+
+logger = logging.getLogger(__name__)
+
+BACKLOG_SUBDIR = Path(".sbxloop") / "backlog"
+
+BACKLOG_INSTRUCTIONS = (
+    "If you identify follow-up work that is OUT OF SCOPE for this outcome, do "
+    "not expand scope. Write each such item as its own markdown file under "
+    "`.sbxloop/backlog/` in the workspace — first line `# <short title>`, then a "
+    "paragraph describing the work and why it matters. These are triaged and "
+    "filed automatically after the run."
+)
+
+
+def fingerprint(title: str, body: str) -> str:
+    return hashlib.sha256(f"{title}\n{body}".encode()).hexdigest()
+
+
+def collect_backlog(
+    run: RunRecord,
+    *,
+    dstore: DaemonStore,
+    source: WorkSource,
+    max_items: int,
+    trigger: bool,
+    now: float,
+) -> list[str]:
+    """File the run's backlog items via ``source``; returns the refs filed."""
+    if not run.mounted or run.workspace is None:
+        logger.warning(
+            "backlog skipped for run %s: workspace not mounted (agent-filed backlog "
+            "requires the mounted-workspace mode)",
+            run.run_id,
+        )
+        return []
+    folder = run.workspace / BACKLOG_SUBDIR
+    if not folder.is_dir():
+        return []
+    filed: list[str] = []
+    skipped = 0
+    for path in sorted(folder.glob("*.md")):
+        try:
+            title, body = parse_markdown_item(path.read_text(), path.stem)
+        except OSError:
+            continue
+        fp = fingerprint(title, body)
+        if dstore.backlog_seen(fp):
+            continue
+        if len(filed) >= max_items:
+            skipped += 1
+            continue
+        try:
+            ref = source.file_backlog(title, body, run.run_id, trigger=trigger)
+        except Exception:
+            logger.warning(
+                "backlog: filing %r from run %s failed", title, run.run_id, exc_info=True
+            )
+            continue
+        dstore.backlog_record(fp, run.run_id, ref, now)
+        filed.append(ref)
+    if skipped:
+        logger.warning(
+            "backlog: run %s produced %d item(s) beyond the per-run cap of %d; deferred "
+            "(not fingerprint-recorded, so the next collection pass files them)",
+            run.run_id,
+            skipped,
+            max_items,
+        )
+    return filed