steerdev 1.1.3__tar.gz → 1.1.6__tar.gz

{steerdev-1.1.3 → steerdev-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.1.3
+Version: 1.1.6
 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.1.3 → steerdev-1.1.6}/pyproject.toml

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

{steerdev-1.1.3 → steerdev-1.1.6}/src/steerdev_agent/cli.py

@@ -1617,6 +1617,17 @@ def run(
             envvar="STEERDEV_AGENT_NAME",
         ),
     ] = None,
+    agent_id: Annotated[
+        str | None,
+        typer.Option(
+            "--agent-id",
+            help=(
+                "Pre-existing agent ID to attach this run to (skips agent registration)."
+                " Reads from STEERDEV_AGENT_ID env var."
+            ),
+            envvar="STEERDEV_AGENT_ID",
+        ),
+    ] = None,
     model: Annotated[
         str | None,
         typer.Option(
@@ -1726,6 +1737,14 @@ def run(
             help="Default branch for sync/rebase/PR targets (default: from config or 'main')",
         ),
     ] = None,
+    task_id: Annotated[
+        str | None,
+        typer.Option(
+            "--task-id",
+            "-t",
+            help="Run a specific task by ID (bypasses queue/wave scheduling)",
+        ),
+    ] = None,
 ) -> None:
     """Run the agent for a project!
 
@@ -1851,6 +1870,8 @@ def run(
                 dry_run=dry_run,
                 retry_config=retry_config,
                 branch_config=resolved_branch_config,
+                task_id=task_id,
+                agent_id=agent_id,
             )
         )
 
@@ -2341,8 +2362,15 @@ def _display_dependency_check(deps: list) -> None:
 
     for dep in deps:
         if dep.found:
-            status = "[green]Found[/green]"
-            details = dep.version or dep.path or ""
+            if dep.authenticated is False:
+                status = "[red]Not authenticated[/red]"
+                details = dep.auth_hint or "Run the tool's login command"
+            elif dep.authenticated is True:
+                status = "[green]Found & authenticated[/green]"
+                details = dep.auth_details or dep.version or dep.path or ""
+            else:
+                status = "[green]Found[/green]"
+                details = dep.version or dep.path or ""
         elif dep.required:
             status = "[red]Missing (required)[/red]"
             details = f"Install: {dep.install_hint}"
@@ -2488,6 +2516,21 @@ def setup(
         )
         raise typer.Exit(1)
 
+    unauthenticated_required = [
+        d for d in deps if d.required and d.found and d.authenticated is False
+    ]
+    if unauthenticated_required:
+        names = ", ".join(d.name for d in unauthenticated_required)
+        hints = "\n".join(
+            f"  - {d.name}: {d.auth_hint}" for d in unauthenticated_required if d.auth_hint
+        )
+        console.print(
+            f"\n[red]Required tool(s) not authenticated: {names}.[/red]\n"
+            f"Log in before running setup so steerdev can create PRs and "
+            f"manage branches on your behalf.\n{hints}"
+        )
+        raise typer.Exit(1)
+
     # Prompt for install target if not provided
     if install_target is None:
         install_target = _prompt_install_target()

{steerdev-1.1.3 → steerdev-1.1.6}/src/steerdev_agent/runner.py

@@ -287,6 +287,7 @@ class Runner:
         branch_config: BranchConfig | None = None,
         shutdown_event: asyncio.Event | None = None,
         agent_id: str | None = None,
+        task_id: str | None = None,
     ) -> None:
         """Initialize the runner.
 
@@ -334,6 +335,7 @@ class Runner:
         self._enable_waves = enable_waves
         self._enable_canals = enable_canals
         self._agent_id = agent_id
+        self._target_task_id = task_id
 
         # State
         self._state = RunState.STOPPED
@@ -424,6 +426,7 @@ class Runner:
         request = SessionCreateRequest(
             project_id=self.project_id,
             task_id=task_id,
+            agent_id=self._agent_id,
             agent_name=self.agent_name,
             agent_type=self.agent_type,
             prompt=prompt,
@@ -1021,6 +1024,7 @@ class Runner:
             project_id=self.project_id,
             agent_type=self.agent_type,
             agent_name=self.agent_name,
+            agent_id=self._agent_id,
             shutdown_event=self._shutdown_event,
         )
 
@@ -1124,25 +1128,36 @@ class Runner:
                 suggested_workflow_id: str | None = None
 
                 with TasksClient(api_key=self._api_key) as client:
-                    if self._enable_waves:
-                        try:
-                            task, wave_ctx, suggested_workflow_id = extract_task_and_wave_context(
-                                client.get_next_wave(
-                                    project_id=self.project_id,
-                                    agent_id=self._agent_id,
+                    if self._target_task_id:
+                        if self._tasks_executed > 0:
+                            # Targeted single-task mode: only run the requested task once.
+                            break
+                        task = client.get_task(self._target_task_id)
+                        if not task:
+                            console.print(f"[red]Task {self._target_task_id} not found[/red]")
+                            break
+                    else:
+                        if self._enable_waves:
+                            try:
+                                task, wave_ctx, suggested_workflow_id = (
+                                    extract_task_and_wave_context(
+                                        client.get_next_wave(
+                                            project_id=self.project_id,
+                                            agent_id=self._agent_id,
+                                        )
+                                    )
+                                )
+                            except Exception:
+                                logger.debug(
+                                    "Wave fetch failed, falling back to single-task",
+                                    exc_info=True,
                                 )
-                            )
-                        except Exception:
-                            logger.debug(
-                                "Wave fetch failed, falling back to single-task",
-                                exc_info=True,
-                            )
 
-                    if not task:
-                        task = client.get_next_task(
-                            project_id=self.project_id,
-                            agent_id=self._agent_id,
-                        )
+                        if not task:
+                            task = client.get_next_task(
+                                project_id=self.project_id,
+                                agent_id=self._agent_id,
+                            )
 
                 if not task:
                     if self._tasks_executed == 0:
@@ -1395,6 +1410,8 @@ async def run_agent(
     dry_run: bool = False,
     retry_config: RetryConfig | None = None,
     branch_config: BranchConfig | None = None,
+    task_id: str | None = None,
+    agent_id: str | None = None,
 ) -> dict[str, Any]:
     """Run the steerdev agent.
 
@@ -1442,6 +1459,8 @@ async def run_agent(
         dry_run=dry_run,
         retry_config=retry_config,
         branch_config=branch_config,
+        task_id=task_id,
+        agent_id=agent_id,
     )
 
     # Install signal handler that kills the subprocess immediately on Ctrl+C

{steerdev-1.1.3 → steerdev-1.1.6}/src/steerdev_agent/setup/claude_setup.py

@@ -30,6 +30,11 @@ class DependencyStatus:
     version: str | None = None
     required: bool = True
     install_hint: str = ""
+    # Auth status: True if authenticated, False if not, None if not applicable
+    # (or the binary was not found, or the check could not be performed).
+    authenticated: bool | None = None
+    auth_hint: str = ""
+    auth_details: str | None = None
 
 
 def check_cli_dependencies() -> list[DependencyStatus]:
@@ -75,6 +80,15 @@ def check_cli_dependencies() -> list[DependencyStatus]:
             install_hint="https://nodejs.org/",
         ),
     ]
+
+    for dep in deps:
+        if dep.command == "gh" and dep.found and dep.path is not None:
+            authenticated, details = _check_gh_auth(dep.path)
+            dep.authenticated = authenticated
+            dep.auth_details = details
+            if authenticated is False:
+                dep.auth_hint = "Run: gh auth login"
+
     return deps
 
 
@@ -125,6 +139,37 @@ def _check_dep(
     )
 
 
+def _check_gh_auth(gh_path: str) -> tuple[bool | None, str | None]:
+    """Check whether the GitHub CLI is logged in.
+
+    Returns a tuple of (authenticated, details). `authenticated` is True when
+    `gh auth status` exits 0, False when it exits non-zero (meaning gh is
+    installed but the user isn't logged in), and None when the check could
+    not be executed (timeout / OS error).
+    """
+    try:
+        result = subprocess.run(
+            [gh_path, "auth", "status"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        logger.debug("Failed to run `gh auth status`")
+        return None, None
+
+    # `gh auth status` writes its human-readable output to stderr.
+    combined = (result.stderr or "") + (result.stdout or "")
+    details: str | None = None
+    for line in combined.splitlines():
+        stripped = line.strip()
+        if "Logged in to" in stripped or "not logged in" in stripped.lower():
+            details = stripped
+            break
+
+    return result.returncode == 0, details
+
+
 # Word lists for generating agent names
 ADJECTIVES = [
     "bright",

{steerdev-1.1.3 → steerdev-1.1.6}/src/steerdev_agent/workflow/executor.py

@@ -50,6 +50,7 @@ class WorkflowExecutor:
         project_id: str | None = None,
         agent_type: str = "claude",
         agent_name: str | None = None,
+        agent_id: str | None = None,
         shutdown_event: asyncio.Event | None = None,
     ) -> None:
         """Initialize the workflow executor.
@@ -75,6 +76,7 @@ class WorkflowExecutor:
         self.project_id = project_id
         self.agent_type = agent_type
         self.agent_name = agent_name
+        self.agent_id = agent_id
         self._shutdown_event = shutdown_event
 
         self._memory_manager = WorkflowMemoryManager(working_directory)
@@ -251,6 +253,7 @@ Complete this phase according to its type: {phase.phase_type}
             request = SessionCreateRequest(
                 project_id=self.project_id,
                 task_id=task_id,
+                agent_id=self.agent_id,
                 agent_name=self.agent_name,
                 agent_type=self.agent_type,
                 prompt=prompt,

{steerdev-1.1.3 → steerdev-1.1.6}/tests/test_claude_setup.py

@@ -1,6 +1,7 @@
 """Tests for Claude setup templates and installed skills."""
 
-from unittest.mock import patch
+import subprocess
+from unittest.mock import MagicMock, patch
 
 from steerdev_agent.setup.claude_setup import ClaudeSetup, check_cli_dependencies
 
@@ -86,3 +87,83 @@ class TestCheckCliDependencies:
         if git_dep.found:
             assert git_dep.path is not None
             assert git_dep.version is not None
+
+
+class TestGhAuthStatus:
+    """Tests for gh auth status checking within check_cli_dependencies()."""
+
+    @staticmethod
+    def _fake_run(*, auth_returncode: int, auth_stderr: str = ""):
+        """Build a fake subprocess.run that returns a version then an auth result."""
+
+        def run(cmd, *args, **kwargs):
+            # First subprocess call is `--version`; second is `auth status`.
+            if "auth" in cmd:
+                return MagicMock(returncode=auth_returncode, stdout="", stderr=auth_stderr)
+            return MagicMock(returncode=0, stdout="gh version 2.0.0\n", stderr="")
+
+        return run
+
+    def test_gh_authenticated_sets_flag_true(self):
+        with (
+            patch("shutil.which", return_value="/usr/bin/gh"),
+            patch(
+                "subprocess.run",
+                side_effect=self._fake_run(
+                    auth_returncode=0,
+                    auth_stderr="✓ Logged in to github.com as octocat",
+                ),
+            ),
+        ):
+            deps = check_cli_dependencies()
+
+        gh_dep = next(d for d in deps if d.command == "gh")
+        assert gh_dep.found is True
+        assert gh_dep.authenticated is True
+        assert gh_dep.auth_hint == ""
+        assert gh_dep.auth_details is not None
+        assert "Logged in" in gh_dep.auth_details
+
+    def test_gh_not_authenticated_sets_flag_false_with_hint(self):
+        with (
+            patch("shutil.which", return_value="/usr/bin/gh"),
+            patch(
+                "subprocess.run",
+                side_effect=self._fake_run(
+                    auth_returncode=1,
+                    auth_stderr="You are not logged into any GitHub hosts.",
+                ),
+            ),
+        ):
+            deps = check_cli_dependencies()
+
+        gh_dep = next(d for d in deps if d.command == "gh")
+        assert gh_dep.found is True
+        assert gh_dep.authenticated is False
+        assert "gh auth login" in gh_dep.auth_hint
+
+    def test_gh_auth_check_timeout_leaves_status_none(self):
+        def run(cmd, *args, **kwargs):
+            if "auth" in cmd:
+                raise subprocess.TimeoutExpired(cmd=cmd, timeout=5)
+            return MagicMock(returncode=0, stdout="gh version 2.0.0\n", stderr="")
+
+        with (
+            patch("shutil.which", return_value="/usr/bin/gh"),
+            patch("subprocess.run", side_effect=run),
+        ):
+            deps = check_cli_dependencies()
+
+        gh_dep = next(d for d in deps if d.command == "gh")
+        assert gh_dep.found is True
+        assert gh_dep.authenticated is None
+        assert gh_dep.auth_hint == ""
+
+    def test_missing_gh_does_not_run_auth_check(self):
+        # When gh isn't installed, authenticated should stay None (not False).
+        with patch("shutil.which", return_value=None):
+            deps = check_cli_dependencies()
+
+        gh_dep = next(d for d in deps if d.command == "gh")
+        assert gh_dep.found is False
+        assert gh_dep.authenticated is None