steerdev 1.0.56__tar.gz → 1.0.58__tar.gz

{steerdev-1.0.56 → steerdev-1.0.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.0.56
+Version: 1.0.58
 Summary: Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting
 Project-URL: Homepage, https://github.com/pentoai/steerdev-agent
 Project-URL: Repository, https://github.com/pentoai/steerdev-agent

{steerdev-1.0.56 → steerdev-1.0.58}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerdev"
-version = "1.0.56"
+version = "1.0.58"
 description = "Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting"
 readme = "README.md"
 authors = [

steerdev-1.0.58/snapshots/steerdev-agent-v1/Dockerfile

@@ -0,0 +1,56 @@
+FROM ubuntu:22.04
+
+# Prevent interactive prompts during package install
+ENV DEBIAN_FRONTEND=noninteractive
+
+# ── System packages ──────────────────────────────────────────────────────────
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    ca-certificates \
+    curl \
+    git \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── Python 3.12 via deadsnakes PPA ───────────────────────────────────────────
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    software-properties-common \
+    && add-apt-repository ppa:deadsnakes/ppa \
+    && apt-get update && apt-get install -y --no-install-recommends \
+    python3.12 \
+    python3.12-venv \
+    python3-pip \
+    && rm -rf /var/lib/apt/lists/*
+
+# Make python3.12 the default python3
+RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.12 1 \
+    && update-alternatives --install /usr/bin/python python /usr/bin/python3.12 1
+
+# ── uv (fast Python package installer) ───────────────────────────────────────
+RUN curl -Ls https://astral.sh/uv/install.sh | sh
+ENV PATH="/root/.local/bin:${PATH}"
+
+# ── Node.js 20 LTS ───────────────────────────────────────────────────────────
+RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y --no-install-recommends nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── daytona user (uid 1000, matching Daytona convention) ─────────────────────
+RUN useradd -m -u 1000 -s /bin/bash daytona
+
+# ── steerdev agent (PyPI) — installed as root so it's on PATH for all users ──
+RUN pip install --no-cache-dir steerdev
+
+# ── Claude Code CLI (npm global) ─────────────────────────────────────────────
+RUN npm install -g @anthropic-ai/claude-code
+
+# ── Startup script ───────────────────────────────────────────────────────────
+COPY start-agent.sh /home/daytona/start-agent.sh
+RUN chmod 755 /home/daytona/start-agent.sh \
+    && chown daytona:daytona /home/daytona/start-agent.sh
+
+# ── Runtime defaults ─────────────────────────────────────────────────────────
+USER daytona
+WORKDIR /home/daytona
+
+CMD ["/home/daytona/start-agent.sh"]

steerdev-1.0.58/snapshots/steerdev-agent-v1/start-agent.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# Startup script for steerdev-agent-v1 Daytona sandbox.
+#
+# Environment variables consumed:
+#   STEERDEV_PROJECT_ID  (required) — project ID passed to the agent
+#   STEERDEV_AGENT_NAME  (required) — name used to register the agent
+#   STEERDEV_API_KEY     (required) — API key read natively by the steerdev CLI
+#   GIT_REPO_URL         (optional) — if set, clone this repo before starting
+#   GIT_BRANCH           (optional) — branch to checkout (default: main)
+#   GIT_WORKSPACE_DIR    (optional) — clone destination (default: /home/daytona/workspace)
+
+# Disable trace mode so shell expansion never prints secret values to stdout.
+set +x
+set -euo pipefail
+
+: "${STEERDEV_PROJECT_ID:?STEERDEV_PROJECT_ID is required}"
+: "${STEERDEV_AGENT_NAME:?STEERDEV_AGENT_NAME is required}"
+: "${STEERDEV_API_KEY:?STEERDEV_API_KEY is required}"
+
+GIT_BRANCH="${GIT_BRANCH:-main}"
+GIT_WORKSPACE_DIR="${GIT_WORKSPACE_DIR:-/home/daytona/workspace}"
+
+# ── Optional repository clone ─────────────────────────────────────────────────
+if [ -n "${GIT_REPO_URL:-}" ]; then
+    # Configure git to authenticate via GITHUB_TOKEN for private repos.
+    # URL rewriting keeps the token out of process arguments and clone logs.
+    if [ -n "${GITHUB_TOKEN:-}" ]; then
+        git config --global url."https://x-access-token:${GITHUB_TOKEN}@github.com/".insteadOf "https://github.com/"
+    fi
+
+    mkdir -p "${GIT_WORKSPACE_DIR}"
+    git clone --branch "${GIT_BRANCH}" -- "${GIT_REPO_URL}" "${GIT_WORKSPACE_DIR}"
+fi
+
+cd "${GIT_WORKSPACE_DIR}"
+
+# Replace this shell process with the agent so signals (SIGTERM/SIGINT) are
+# delivered directly to the agent. Credentials are passed only via environment
+# variables — never as CLI flags (which would appear in `ps aux`).
+exec steerdev agent \
+    --project-id "${STEERDEV_PROJECT_ID}" \
+    --agent-name "${STEERDEV_AGENT_NAME}"

{steerdev-1.0.56 → steerdev-1.0.58}/src/steerdev_agent/api/reports.py

@@ -29,6 +29,7 @@ class ReportsClient(SteerDevClient):
         project_id: str,
         summary: str,
         blocks: list[dict[str, Any]],
+        artifacts: list[dict[str, Any]] | None = None,
         task_id: str | None = None,
         wave_id: str | None = None,
         agent_id: str | None = None,
@@ -40,6 +41,7 @@ class ReportsClient(SteerDevClient):
                 project_id: SteerDev project ID.
                 summary: Report title/summary (required for reviewability).
                 blocks: List of report blocks (type, content, order).
+                artifacts: Optional list of file artifacts (filename, mime_type, size, content_base64/url).
                 task_id: Associated task ID.
                 wave_id: Associated wave ID.
                 agent_id: Associated agent ID.
@@ -53,6 +55,8 @@ class ReportsClient(SteerDevClient):
             "summary": summary,
             "blocks": blocks,
         }
+        if artifacts:
+            payload["artifacts"] = artifacts
         if task_id:
             payload["task_id"] = task_id
         if wave_id:

{steerdev-1.0.56 → steerdev-1.0.58}/src/steerdev_agent/cli.py

@@ -1667,7 +1667,7 @@ def run(
         bool | None,
         typer.Option(
             "--evidence/--no-evidence",
-            help="Submit evidence reports after task completion (default: from config or disabled)",
+            help="Submit evidence reports after task completion (default: from config or enabled)",
         ),
     ] = None,
     dry_run: Annotated[
@@ -1983,11 +1983,19 @@ def agent(
             help="Enable canal merge flow selection (default: disabled)",
         ),
     ] = False,
+    worktrees: Annotated[
+        bool | None,
+        typer.Option(
+            "--worktrees/--no-worktrees",
+            "-W",
+            help="Enable git worktree isolation (default: from config or disabled)",
+        ),
+    ] = None,
     evidence: Annotated[
         bool | None,
         typer.Option(
             "--evidence/--no-evidence",
-            help="Submit evidence reports after task completion (default: from config or disabled)",
+            help="Submit evidence reports after task completion (default: from config or enabled)",
         ),
     ] = None,
 ) -> None:
@@ -2008,12 +2016,14 @@ def agent(
     Use --workflow-id to force a specific workflow for all tasks.
 
     Use --waves/--no-waves to control wave-aware scheduling. Use --canals to
-    expose the canal merge flow to workflow phases.
+    expose the canal merge flow to workflow phases. Use --worktrees to enable
+    git worktree isolation.
 
     Example:
         steerdev agent --project-id abc123 --agent-name my-agent
         steerdev agent --workspace ~/workspace --agent-name my-agent
         steerdev agent --project-id abc123 --agent-name my-agent --no-waves
+        steerdev agent --project-id abc123 --agent-name my-agent --worktrees
         steerdev agent --project-id abc123 --agent-name my-agent --workflow-id wf-abc123 --canals
         steerdev agent --project-id abc123 --agent-name my-agent --workflow-id wf-abc123
         steerdev agent --project-id abc123 --agent-name my-agent --poll-interval 10
@@ -2050,6 +2060,8 @@ def agent(
         agent_loop_config.gap_seconds = gap_seconds
 
     resolved_worktree_config = config.worktrees.model_copy()
+    if worktrees is not None:
+        resolved_worktree_config.enabled = worktrees
     resolved_evidence_config = config.evidence.model_copy()
     if evidence is not None:
         resolved_evidence_config.enabled = evidence

{steerdev-1.0.56 → steerdev-1.0.58}/src/steerdev_agent/config/models.py

@@ -255,7 +255,14 @@ class EvidenceConfig(BaseModel):
 
     enabled: Annotated[
         bool,
-        Field(default=False, description="Submit evidence reports after task completion"),
+        Field(default=True, description="Submit evidence reports after task completion"),
+    ]
+    assets_dir: Annotated[
+        str,
+        Field(
+            default=".steerdev/evidence",
+            description="Directory for evidence assets (screenshots, logs) relative to working directory",
+        ),
     ]
 
 

{steerdev-1.0.56 → steerdev-1.0.58}/src/steerdev_agent/evidence.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+from pathlib import Path
 from typing import Any
 
 from loguru import logger
@@ -27,6 +28,7 @@ EVIDENCE_MAX_TURNS = 25
 def build_evidence_prompt(
     task: dict[str, Any],
     success: bool,
+    assets_dir: str | None = None,
     phase_summaries: list[dict[str, Any]] | None = None,
     evidence_messages: list[str] | None = None,
 ) -> str:
@@ -35,6 +37,7 @@ def build_evidence_prompt(
     Args:
         task: The completed task dict.
         success: Whether the task succeeded.
+        assets_dir: Absolute path where the agent should save evidence files.
         phase_summaries: Per-phase summaries (workflow tasks only).
         evidence_messages: Assistant messages collected during execution
             (non-workflow tasks only).
@@ -66,21 +69,43 @@ def build_evidence_prompt(
         last = evidence_messages[-1][:3000]
         sections.append(f"## Agent Output (last message)\n{last}\n")
 
+    # Build asset directory instructions
+    assets_instruction = ""
+    if assets_dir:
+        assets_instruction = (
+            f"\n**IMPORTANT — Evidence Assets Directory:** `{assets_dir}/`\n"
+            "Save ALL screenshots, logs, and evidence files to this directory.\n"
+        )
+
+    screenshot_cmd = "agent-browser screenshot"
+    if assets_dir:
+        screenshot_cmd = f"agent-browser screenshot {assets_dir}/screenshot-01.png"
+
     sections.append(
         "## Your Instructions\n\n"
         "Collect evidence that the work is correct. Follow these steps:\n\n"
+        f"{assets_instruction}\n"
         "### 1. File Changes\n"
         "Run `git diff --stat` and `git log --oneline -5` to see what changed.\n"
         "Summarize the key modifications.\n\n"
         "### 2. Visual Verification\n"
         "If the task involved **UI or frontend changes**:\n"
-        "- Use `agent-browser open <url>` to navigate to the relevant page\n"
-        "- Use `agent-browser screenshot` to capture it\n"
+        f"- Use `agent-browser open <url>` to navigate to the relevant page\n"
+        f"- Use `{screenshot_cmd}` to capture it\n"
+        "- Take multiple screenshots if needed (screenshot-01.png, screenshot-02.png, etc.)\n"
         "- Describe what you see and whether it matches the acceptance criteria\n\n"
         "If the task was backend-only, verify via tests or logs instead.\n\n"
         "### 3. Tests\n"
-        "If there are relevant tests, run them and report the results.\n\n"
-        "### 4. Review Summary\n"
+        "If there are relevant tests, run them and report the results.\n"
+    )
+
+    if assets_dir:
+        sections.append(
+            f"If tests produce log output, save it to `{assets_dir}/test-output.log`.\n"
+        )
+
+    sections.append(
+        "\n### 4. Review Summary\n"
         "Write a structured review covering:\n"
         "- What was implemented or changed\n"
         "- Key files modified and why\n"
@@ -101,6 +126,7 @@ async def collect_evidence(
     model: str | None,
     api_key: str | None,
     dry_run: bool = False,
+    assets_dir: str | None = None,
     phase_summaries: list[dict[str, Any]] | None = None,
     evidence_messages: list[str] | None = None,
 ) -> list[str]:
@@ -109,9 +135,14 @@ async def collect_evidence(
     Returns a list of assistant messages produced during the evidence session.
     Best-effort: returns an empty list on any failure.
     """
+    # Ensure assets directory exists so the evidence agent can write to it.
+    if assets_dir:
+        Path(assets_dir).mkdir(parents=True, exist_ok=True)
+
     prompt = build_evidence_prompt(
         task,
         success=success,
+        assets_dir=assets_dir,
         phase_summaries=phase_summaries,
         evidence_messages=evidence_messages,
     )

steerdev-1.0.58/src/steerdev_agent/evidence_assets.py

@@ -0,0 +1,177 @@
+"""Evidence asset scanning and upload.
+
+Scans a directory for evidence files (screenshots, logs) produced during
+evidence collection, then uploads them to the platform via multipart upload
+and returns metadata with CDN URLs.
+"""
+
+from __future__ import annotations
+
+import mimetypes
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+from loguru import logger
+
+from steerdev_agent.api.client import get_api_endpoint
+
+# File extensions we recognise as evidence assets.
+ASSET_EXTENSIONS: set[str] = {
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".webp",
+    ".gif",  # images
+    ".pdf",  # documents
+    ".webm",
+    ".mp4",  # video
+    ".log",
+    ".txt",  # logs / text
+}
+
+# Hard limits to avoid uploading too much data.
+MAX_ASSETS = 10
+DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024  # 10 MB
+
+
+@dataclass(frozen=True)
+class EvidenceAsset:
+    """A file found in the evidence assets directory, optionally uploaded."""
+
+    filepath: Path
+    filename: str
+    mime_type: str
+    size: int
+    # Populated after upload — proxy URL that serves the file through app auth
+    url: str | None = None
+
+
+def scan_evidence_assets(
+    assets_dir: str | Path,
+    *,
+    max_file_size: int = DEFAULT_MAX_FILE_SIZE,
+    max_assets: int = MAX_ASSETS,
+) -> list[EvidenceAsset]:
+    """Scan *assets_dir* and return evidence assets found on disk.
+
+    Best-effort: logs warnings for unreadable files, never raises.
+    """
+    dir_path = Path(assets_dir)
+    if not dir_path.is_dir():
+        return []
+
+    assets: list[EvidenceAsset] = []
+
+    try:
+        # Sort by name for deterministic ordering.
+        for entry in sorted(dir_path.iterdir(), key=lambda p: p.name):
+            if len(assets) >= max_assets:
+                logger.debug(f"Evidence assets capped at {max_assets}")
+                break
+
+            if not entry.is_file():
+                continue
+
+            suffix = entry.suffix.lower()
+            if suffix not in ASSET_EXTENSIONS:
+                continue
+
+            try:
+                size = entry.stat().st_size
+                if size == 0:
+                    continue
+                if size > max_file_size:
+                    logger.warning(
+                        f"Evidence asset too large, skipping: {entry.name} ({size} bytes)"
+                    )
+                    continue
+
+                mime_type = mimetypes.guess_type(entry.name)[0] or "application/octet-stream"
+
+                assets.append(
+                    EvidenceAsset(
+                        filepath=entry,
+                        filename=entry.name,
+                        mime_type=mime_type,
+                        size=size,
+                    )
+                )
+            except Exception:
+                logger.warning(f"Failed to read evidence asset: {entry.name}", exc_info=True)
+
+    except Exception:
+        logger.warning("Failed to scan evidence assets directory", exc_info=True)
+
+    return assets
+
+
+def upload_evidence_assets(
+    assets: list[EvidenceAsset],
+    *,
+    api_key: str | None,
+    folder: str = "evidence",
+    timeout: float = 60.0,
+) -> list[EvidenceAsset]:
+    """Upload evidence assets to the platform via multipart upload.
+
+    Returns a new list of ``EvidenceAsset`` with ``url`` and ``download_url``
+    populated for successfully uploaded files.  Assets that fail to upload are
+    returned unchanged (url=None).
+
+    Best-effort: individual upload failures are logged, never raised.
+    """
+    if not assets or not api_key:
+        return assets
+
+    api_base = get_api_endpoint()
+    upload_url = f"{api_base}/upload"
+    headers = {"Authorization": f"Bearer {api_key}"}
+
+    uploaded: list[EvidenceAsset] = []
+
+    with httpx.Client(timeout=timeout, follow_redirects=True) as client:
+        for asset in assets:
+            try:
+                with asset.filepath.open("rb") as f:
+                    files = {
+                        "file": (asset.filename, f, asset.mime_type),
+                    }
+                    data = {
+                        "filename": asset.filename,
+                        "folder": folder,
+                    }
+                    response = client.post(
+                        upload_url,
+                        headers=headers,
+                        files=files,
+                        data=data,
+                    )
+
+                if response.status_code in (200, 201):
+                    result = response.json()
+                    uploaded.append(
+                        EvidenceAsset(
+                            filepath=asset.filepath,
+                            filename=asset.filename,
+                            mime_type=asset.mime_type,
+                            size=asset.size,
+                            url=result.get("url"),
+                        )
+                    )
+                    logger.debug(f"Uploaded evidence asset: {asset.filename}")
+                else:
+                    logger.warning(
+                        f"Evidence asset upload failed ({response.status_code}): "
+                        f"{asset.filename} - {response.text[:200]}"
+                    )
+                    uploaded.append(asset)
+
+            except Exception:
+                logger.warning(
+                    f"Failed to upload evidence asset: {asset.filename}",
+                    exc_info=True,
+                )
+                uploaded.append(asset)
+
+    return uploaded

{steerdev-1.0.56 → steerdev-1.0.58}/src/steerdev_agent/runner.py

@@ -496,9 +496,13 @@ class Runner:
         Spawns a short agent session that reviews git changes, optionally
         uses agent-browser for visual verification, and writes a structured
         review. The review output becomes the evidence report content.
+        Screenshots and other assets are gathered from the evidence directory
+        and uploaded alongside the text report.
 
         Best-effort: errors are logged but never propagate.
         """
+        from pathlib import Path
+
         from steerdev_agent.api.reports import ReportsClient
         from steerdev_agent.evidence import collect_evidence
 
@@ -506,6 +510,11 @@ class Runner:
         task_title = task.get("title", "Unknown Task")
         status_label = "Completed" if success else "Failed"
 
+        # ── Compute evidence assets directory ──
+        assets_dir = str(
+            Path(self.working_directory) / self._evidence_config.assets_dir / (task_id or "unknown")
+        )
+
         # ── Run evidence-collection session ──
         collected = await collect_evidence(
             task=task,
@@ -515,10 +524,47 @@ class Runner:
             model=self.model,
             api_key=self._api_key,
             dry_run=self.dry_run,
+            assets_dir=assets_dir,
             phase_summaries=phase_summaries,
             evidence_messages=evidence_messages,
         )
 
+        # ── Scan and upload evidence assets (screenshots, logs) ──
+        api_artifacts: list[dict[str, Any]] = []
+        uploaded_assets: list[Any] = []
+        try:
+            from steerdev_agent.evidence_assets import (
+                scan_evidence_assets,
+                upload_evidence_assets,
+            )
+
+            assets = scan_evidence_assets(assets_dir)
+            if assets:
+                console.print(f"[dim]Evidence assets found: {len(assets)} files[/dim]")
+                upload_folder = f"evidence/{self.project_id}/{task_id or 'unknown'}"
+                uploaded_assets = upload_evidence_assets(
+                    assets,
+                    api_key=self._api_key,
+                    folder=upload_folder,
+                )
+                uploaded_count = sum(1 for a in uploaded_assets if a.url)
+                console.print(
+                    f"[dim]Evidence assets uploaded: {uploaded_count}/{len(assets)}[/dim]"
+                )
+
+                for asset in uploaded_assets:
+                    if asset.url:
+                        api_artifacts.append(
+                            {
+                                "filename": asset.filename,
+                                "mime_type": asset.mime_type,
+                                "size": asset.size,
+                                "url": asset.url,
+                            }
+                        )
+        except Exception:
+            logger.debug("Evidence asset scanning/upload failed", exc_info=True)
+
         # ── Build report blocks from collected evidence ──
         summary = f"{task_title} - {status_label}"
         blocks: list[dict[str, Any]] = []
@@ -556,6 +602,19 @@ class Runner:
                 )
                 order += 1
 
+        # Add image blocks for uploaded screenshot assets (with CDN URLs)
+        for asset in uploaded_assets:
+            if asset.url and asset.mime_type.startswith("image/"):
+                blocks.append(
+                    {
+                        "type": "image",
+                        "content": asset.url,
+                        "order": order,
+                        "alt_text": asset.filename,
+                    }
+                )
+                order += 1
+
         if not blocks:
             blocks.append(
                 {
@@ -584,6 +643,7 @@ class Runner:
                     project_id=self.project_id,
                     summary=summary,
                     blocks=blocks,
+                    artifacts=api_artifacts or None,
                     task_id=task_id,
                     wave_id=wave_id,
                     evaluation_steps=evaluation_steps,

{steerdev-1.0.56 → steerdev-1.0.58}/src/steerdev_agent/setup/templates/steerdev.yaml

@@ -74,7 +74,9 @@ worktrees:
 
 # Evidence reports: submit a review-ready report after each task/workflow
 evidence:
-  enabled: false
+  enabled: true
+  # Directory for evidence assets (screenshots, logs) relative to working dir
+  assets_dir: ".steerdev/evidence"
 
 # Retry failed tasks automatically
 retry:

{steerdev-1.0.56 → steerdev-1.0.58}/tests/test_reports_client.py

@@ -108,8 +108,13 @@ class TestReportsClient:
 class TestEvidenceConfig:
     def test_defaults(self):
         cfg = EvidenceConfig()
-        assert cfg.enabled is False
+        assert cfg.enabled is True
+        assert cfg.assets_dir == ".steerdev/evidence"
 
     def test_enabled(self):
         cfg = EvidenceConfig(enabled=True)
         assert cfg.enabled is True
+
+    def test_custom_assets_dir(self):
+        cfg = EvidenceConfig(assets_dir=".evidence")
+        assert cfg.assets_dir == ".evidence"

{steerdev-1.0.56 → steerdev-1.0.58}/tests/test_runner_worktrees.py

@@ -82,11 +82,17 @@ class TestRunnerWorktreeConfig:
 
 
 class TestRunnerEvidenceConfig:
-    def test_disabled_by_default(self):
+    def test_enabled_by_default(self):
         r = Runner(project_id="p", api_key="k")
-        assert r._evidence_config.enabled is False
+        assert r._evidence_config.enabled is True
+        assert r._evidence_config.assets_dir == ".steerdev/evidence"
 
     def test_enabled_via_config(self):
         cfg = EvidenceConfig(enabled=True)
         r = Runner(project_id="p", api_key="k", evidence_config=cfg)
         assert r._evidence_config.enabled is True
+
+    def test_disabled_via_config(self):
+        cfg = EvidenceConfig(enabled=False)
+        r = Runner(project_id="p", api_key="k", evidence_config=cfg)
+        assert r._evidence_config.enabled is False