devin-cli 1.3.4__tar.gz → 1.3.6__tar.gz

{devin_cli-1.3.4 → devin_cli-1.3.6}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: devin-cli
-Version: 1.3.4
+Version: 1.3.6
 Summary: Unofficial CLI for Devin AI - The first AI Software Engineer
 Project-URL: Homepage, https://github.com/revanthpobala/devin-cli
 Project-URL: Repository, https://github.com/revanthpobala/devin-cli.git
 Project-URL: Issues, https://github.com/revanthpobala/devin-cli/issues
-Author-email: revanth <revanth@example.com>
+Author-email: Revanth Pobala <revanthpobala@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
 Keywords: agent,ai,automation,autonomous,cli,cognition,devin,software-engineer,terminal
@@ -42,6 +42,7 @@ Description-Content-Type: text/markdown
 
 <p align="center">
   <a href="https://pypi.org/project/devin-cli/"><img src="https://img.shields.io/pypi/v/devin-cli.svg?style=for-the-badge&color=0294DE" alt="PyPI version"></a>
+  <a href="https://pepy.tech/project/devin-cli"><img src="https://img.shields.io/pepy/dt/devin-cli?style=for-the-badge&color=4c1" alt="Downloads"></a>
   <a href="https://github.com/revanthpobala/homebrew-tap"><img src="https://img.shields.io/badge/Homebrew-Tap-orange?style=for-the-badge&logo=homebrew" alt="Homebrew Tap"></a>
   <a href="https://github.com/revanthpobala/devin-cli/actions/workflows/pypi-publish.yml"><img src="https://github.com/revanthpobala/devin-cli/actions/workflows/pypi-publish.yml/badge.svg" alt="Build Status"></a>
 </p>

{devin_cli-1.3.4 → devin_cli-1.3.6}/README.md

@@ -6,6 +6,7 @@
 
 <p align="center">
   <a href="https://pypi.org/project/devin-cli/"><img src="https://img.shields.io/pypi/v/devin-cli.svg?style=for-the-badge&color=0294DE" alt="PyPI version"></a>
+  <a href="https://pepy.tech/project/devin-cli"><img src="https://img.shields.io/pepy/dt/devin-cli?style=for-the-badge&color=4c1" alt="Downloads"></a>
   <a href="https://github.com/revanthpobala/homebrew-tap"><img src="https://img.shields.io/badge/Homebrew-Tap-orange?style=for-the-badge&logo=homebrew" alt="Homebrew Tap"></a>
   <a href="https://github.com/revanthpobala/devin-cli/actions/workflows/pypi-publish.yml"><img src="https://github.com/revanthpobala/devin-cli/actions/workflows/pypi-publish.yml/badge.svg" alt="Build Status"></a>
 </p>

{devin_cli-1.3.4 → devin_cli-1.3.6}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "devin-cli"
-version = "1.3.4"
+version = "1.3.6"
 description = "Unofficial CLI for Devin AI - The first AI Software Engineer"
 readme = "README.md"
 authors = [
-    { name = "revanth", email = "revanth@example.com" },
+    { name = "Revanth Pobala", email = "revanthpobala@gmail.com" },
 ]
 license = "MIT"
 keywords = ["devin", "ai", "agent", "software-engineer", "autonomous", "cli", "terminal", "cognition", "automation"]

devin_cli-1.3.6/src/devin_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.3.5"

{devin_cli-1.3.4 → devin_cli-1.3.6}/src/devin_cli/api/client.py

@@ -99,9 +99,24 @@ class BaseClient:
         if "files" in kwargs:
             headers.pop("Content-Type", None)
 
+        import os
+        verify_tls = True
+        if os.environ.get("DEVIN_INSECURE_TLS") == "1":
+            verify_tls = False
+        elif os.environ.get("DEVIN_CA_BUNDLE"):
+            verify_tls = os.environ.get("DEVIN_CA_BUNDLE")
+
         try:
-            with httpx.Client(follow_redirects=False, verify=False, timeout=httpx.Timeout(120.0)) as client:
-                response = client.request(method, url, headers=headers, **kwargs)
+            with httpx.Client(follow_redirects=True, verify=verify_tls, timeout=httpx.Timeout(120.0)) as client_httpx:
+                try:
+                    response = client_httpx.request(method, url, headers=headers, **kwargs)
+                except httpx.RequestError as req_err:
+                    if verify_tls is not False and ("SSL" in str(type(req_err).__name__) or "certificate" in str(req_err).lower() or isinstance(req_err, httpx.ConnectError)):
+                        console.print(f"[bold yellow]Warning:[/bold yellow] TLS verification or connection failed ({req_err}). Retrying with verify=False... Set DEVIN_INSECURE_TLS=1 to suppress this warning.")
+                        with httpx.Client(follow_redirects=True, verify=False, timeout=httpx.Timeout(120.0)) as insecure_client:
+                            response = insecure_client.request(method, url, headers=headers, **kwargs)
+                    else:
+                        raise req_err
                 return self._handle_response(response)
         except httpx.RequestError as e:
             raise APIError(f"Network error: {e}")

{devin_cli-1.3.4 → devin_cli-1.3.6}/src/devin_cli/api/v1/sessions.py

@@ -55,9 +55,11 @@ def create_session(
 def get_session(session_id: str):
     return client.get(f"sessions/{session_id}")
 
-def get_session_messages(session_id: str):
+def get_session_messages(session_id: str, limit: int = 100, offset: int = 0):
     resp = get_session(session_id)
-    return {"messages": resp.get("messages", [])}
+    msgs = resp.get("messages", [])
+    # Slice the messages array for basic offset pagination since v1 doesn't support an endpoint
+    return {"messages": msgs[offset:offset+limit]}
 
 def get_session_insights(session_id: str):
     return {"error": "Insights are not available in the v1 API. Please upgrade to v3."}

{devin_cli-1.3.4 → devin_cli-1.3.6}/src/devin_cli/api/v3/sessions.py

@@ -75,8 +75,11 @@ def get_session(session_id: str):
             raise
         raise
 
-def get_session_messages(session_id: str):
-    return client.get(f"sessions/{session_id}/messages")
+def get_session_messages(session_id: str, limit: int = 100, after: Optional[str] = None):
+    params = {"limit": limit}
+    if after:
+        params["after"] = after
+    return client.get(f"sessions/{session_id}/messages", params=params)
 
 def send_message(session_id: str, message: str):
     return client.post(f"sessions/{session_id}/messages", json={"message": message})

{devin_cli-1.3.4 → devin_cli-1.3.6}/src/devin_cli/cli.py

@@ -195,6 +195,21 @@ def configure(
     console.print(f"[green]Configuration saved to {config.config_file}[/green]")
     return None
 
+def get_stable_terminal_state(status_enum: Optional[str]) -> str:
+    if not status_enum:
+        return "running"
+    status = status_enum.lower()
+    if status == "finished":
+        return "completed"
+    elif status in ("failed", "error"):
+        return "failed"
+    elif status in ("stopped", "cancelled", "terminated"):
+        return "terminated"
+    elif status == "blocked":
+        return "blocked"
+    else:
+        return "running"
+
 # --- Sessions ---
 @session_app.command("create")
 @handle_api_error
@@ -296,21 +311,23 @@ def create_session_cmd(
             console.print(f"[bold cyan]URL:[/bold cyan] {resp.get('url')}")
 
             if wait:
-                terminal_statuses = {"stopped", "finished", "error", "cancelled", "failed"}
                 console.print(f"[dim]Waiting for session to complete (polling every {interval}s)...[/dim]")
                 with console.status("[bold green]Running...[/bold green]") as s:
                     while True:
                         time.sleep(interval)
                         poll = sessions.get_session(sid)
-                        current_status = poll.get("status_enum", "").lower()
+                        current_status = poll.get("status_enum", "")
+                        stable_state = get_stable_terminal_state(current_status)
                         s.update(f"[bold green]Status: {current_status}[/bold green]")
-                        if current_status in terminal_statuses:
+                        if stable_state not in ("running", "blocked"):
                             console.print(f"[bold green]Session finished:[/bold green] {current_status}")
                             break
         else:
             console.print("[yellow]Session created, but no ID returned immediately (awaiting advanced mode setup).[/yellow]")
         
     return resp
+        
+    return resp
 
 
 @session_app.command("list")
@@ -319,38 +336,111 @@ def list_sessions_cmd(
     limit: int = 10,
     org: Optional[str] = typer.Option(None, "--org"),
     json_output: bool = typer.Option(False, "--json"),
+    after: Optional[str] = typer.Option(None, "--after", help="Cursor for pagination (v3 only)"),
+    all_pages: bool = typer.Option(False, "--all", help="Fetch all pages sequentially (v3 only)"),
 ):
     """List sessions."""
     if org: config.temporary_org_id = org
-    resp = sessions.list_sessions(limit=limit)
-    sess_list = resp.get("items", resp.get("sessions", []))
-    
-    if not sess_list and config.api_token and config.api_token.startswith("cog_"):
+
+    if (after or all_pages) and config.api_version == "v1":
+        console.print("[bold yellow]Warning:[/bold yellow] Pagination flags (--after, --all) are only supported in v3 API.")
+        raise typer.Exit(1)
+
+    items = []
+    current_after = after
+    current_offset = 0
+    has_next = False
+    next_cursor = None
+    total = None
+
+    while True:
+        kwargs = {"limit": limit}
+        if config.api_version == "v3" and current_after:
+            kwargs["after"] = current_after
+        elif config.api_version == "v1":
+            kwargs["offset"] = current_offset
+        
+        resp = sessions.list_sessions(**kwargs)
+        page_items = resp.get("items", resp.get("sessions", []))
+        items.extend(page_items)
+        
+        if total is None:
+            total = resp.get("total")
+
+        if config.api_version == "v3":
+            has_next = resp.get("has_next_page", False)
+            next_cursor = resp.get("end_cursor")
+        else:
+            has_next = len(page_items) == limit
+            current_offset += limit
+            
+        if not all_pages or not has_next or (config.api_version == "v3" and not next_cursor):
+            break
+            
+        current_after = next_cursor
+
+    for s in items:
+        if isinstance(s, dict):
+            s["terminal_state"] = get_stable_terminal_state(s.get("status_enum"))
+            
+    if not items and config.api_token and config.api_token.startswith("cog_"):
         console.print("[yellow]Warning: Service tokens (cog_) may only have visibility into sessions they explicitly created, not all organization sessions.[/yellow]")
         
-    if json_output:
-        console.print(json.dumps(sess_list, indent=2))
+    final_resp = {
+        "items": items,
+        "total": total if total is not None else len(items),
+    }
+    if not all_pages:
+        final_resp["end_cursor"] = next_cursor
+        final_resp["has_next_page"] = has_next
+
+    import os
+    if json_output or os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+        if os.environ.get("DEVIN_OUTPUT_FORMAT") != "json":
+            console.print(json.dumps(final_resp, indent=2))
+        return final_resp
     else:
-        table = Table(title="Devin Sessions")
+        table = Table(title="Devin Sessions" + (f" ({total} total)" if total is not None else ""))
         table.add_column("ID", style="cyan")
         table.add_column("Status", style="magenta")
+        table.add_column("Terminal State", style="blue")
         table.add_column("Title")
-        for s in sess_list:
-            table.add_row(s.get("session_id"), s.get("status_enum"), s.get("title") or s.get("prompt", "")[:50])
+        for s in items:
+            table.add_row(
+                s.get("session_id"),
+                s.get("status_enum"),
+                s.get("terminal_state"),
+                s.get("title") or s.get("prompt", "")[:50]
+            )
         console.print(table)
+        
+        if not all_pages and next_cursor:
+            console.print(f"[dim]More sessions available. Next cursor: {next_cursor}[/dim]")
+            console.print(f"[dim]Use --after {next_cursor} or --all to see them.[/dim]")
     
-    return resp
+    return final_resp
+
 
 @session_app.command("get")
 @handle_api_error
 def get_session_cmd(
     session_id: Optional[str] = typer.Argument(None),
     org: Optional[str] = typer.Option(None, "--org"),
+    json_output: bool = typer.Option(False, "--json"),
 ):
     """Get detailed session info."""
     if org: config.temporary_org_id = org
     sid = session_id or get_current_session_id()
     resp = sessions.get_session(sid)
+    if isinstance(resp, dict):
+        resp["terminal_state"] = get_stable_terminal_state(resp.get("status_enum"))
+    
+    import os
+    if json_output or os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+        if os.environ.get("DEVIN_OUTPUT_FORMAT") != "json":
+            console.print(json.dumps(resp, indent=2))
+        return resp
+        
     console.print(Panel(json.dumps(resp, indent=2), title=f"Session {sid}"))
     
     return resp
@@ -360,11 +450,19 @@ def get_session_cmd(
 def session_insights_cmd(
     session_id: Optional[str] = typer.Argument(None),
     org: Optional[str] = typer.Option(None, "--org"),
+    json_output: bool = typer.Option(False, "--json"),
 ):
     """Get technical insights for a session (ACUs, etc)."""
     if org: config.temporary_org_id = org
     sid = session_id or get_current_session_id()
     resp = sessions.get_session_insights(sid)
+    
+    import os
+    if json_output or os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+        if os.environ.get("DEVIN_OUTPUT_FORMAT") != "json":
+            console.print(json.dumps(resp, indent=2))
+        return resp
+        
     if isinstance(resp, dict) and "error" in resp:
         console.print(f"[bold yellow]Note:[/bold yellow] {resp['error']}")
         console.print("Tip: Switch to v3 with [bold cyan]devin configure[/bold cyan] or use [bold cyan]--profile [v3-profile][/bold cyan]")
@@ -378,22 +476,63 @@ def session_insights_cmd(
 def session_cost_cmd(
     session_id: Optional[str] = typer.Argument(None, help="Specific session ID to check cost for"),
     org: Optional[str] = typer.Option(None, "--org"),
+    json_output: bool = typer.Option(False, "--json"),
 ):
     """View ACU consumption."""
     if org: config.temporary_org_id = org
+    
+    import os
+    is_json = json_output or os.environ.get("DEVIN_OUTPUT_FORMAT") == "json"
+    
     if session_id:
-        resp = sessions.get_session(session_id)
+        if config.api_version == "v3":
+            import concurrent.futures
+            
+            def fetch_session():
+                return sessions.get_session(session_id)
+                
+            def fetch_consumption():
+                try:
+                    return consumption.get_session_consumption(session_id)
+                except Exception:
+                    return None
+                    
+            with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+                f_session = executor.submit(fetch_session)
+                f_cons = executor.submit(fetch_consumption)
+                
+                resp = f_session.result()
+                cons_resp = f_cons.result()
+        else:
+            resp = sessions.get_session(session_id)
+            cons_resp = None
+
         acus = resp.get("acus_consumed") or resp.get("acu_used")
         cost_data = {
             "session_id": resp.get("session_id"),
             "status": resp.get("status_enum"),
             "acus_consumed": acus,
         }
+        
+        if cons_resp:
+            cost_data["breakdown"] = cons_resp
+
+        if is_json:
+            if not os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+                console.print(json.dumps(cost_data, indent=2))
+            return cost_data
+
         console.print(Panel(json.dumps(cost_data, indent=2), title=f"Session Cost: {session_id}"))
         if acus is None:
             console.print("[yellow]ACU data unavailable — this may be a v1 API session or a service token without cost visibility.[/yellow]")
+        return cost_data
     else:
         resp = consumption.get_daily_consumption_breakdown()
+        if is_json:
+            if not os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+                console.print(json.dumps(resp, indent=2))
+            return resp
+            
         console.print(Panel(json.dumps(resp, indent=2), title="Daily Consumption"))
         
     return resp
@@ -428,19 +567,73 @@ def send_message_cmd(
 def list_messages_cmd(
     session_id: Optional[str] = typer.Argument(None),
     org: Optional[str] = typer.Option(None, "--org"),
+    json_output: bool = typer.Option(False, "--json"),
+    limit: int = 100,
+    after: Optional[str] = typer.Option(None, "--after", help="Cursor for pagination (v3 only)"),
+    all_pages: bool = typer.Option(False, "--all", help="Fetch all pages sequentially"),
 ):
     """List messages in a session."""
     if org: config.temporary_org_id = org
     sid = session_id or get_current_session_id()
-    resp = sessions.get_session_messages(sid)
-    msgs = resp.get("messages", [])
+    
+    if (after or all_pages) and config.api_version == "v1":
+        console.print("[bold yellow]Warning:[/bold yellow] Pagination flags (--after, --all) for messages are limited in v1 API since it fetches the full session payload locally.")
+
+    msgs = []
+    current_after = after
+    current_offset = 0
+    has_next = False
+    next_cursor = None
+    
+    while True:
+        kwargs = {"limit": limit}
+        if config.api_version == "v3" and current_after:
+            kwargs["after"] = current_after
+        elif config.api_version == "v1":
+            kwargs["offset"] = current_offset
+            
+        resp = sessions.get_session_messages(sid, **kwargs)
+        page_msgs = resp.get("messages", [])
+        msgs.extend(page_msgs)
+        
+        if config.api_version == "v3":
+            has_next = resp.get("has_next_page", False)
+            next_cursor = resp.get("end_cursor")
+        else:
+            has_next = len(page_msgs) == limit
+            current_offset += limit
+            
+        if not all_pages or not has_next or (config.api_version == "v3" and not next_cursor):
+            break
+            
+        current_after = next_cursor
+
+    import os
+    is_json = json_output or os.environ.get("DEVIN_OUTPUT_FORMAT") == "json"
+    
+    final_resp = {
+        "messages": msgs,
+    }
+    if not all_pages and config.api_version == "v3":
+        final_resp["end_cursor"] = next_cursor
+        final_resp["has_next_page"] = has_next
+        
+    if is_json:
+        if not os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+            console.print(json.dumps(final_resp if all_pages or next_cursor else msgs, indent=2))
+        return final_resp if all_pages or next_cursor else resp
+        
     for m in msgs:
         role = m.get("role", "unknown")
         content = m.get("message", "") or m.get("content", "")
         console.print(f"[bold cyan]{role}:[/bold cyan] {content}")
         console.print("---")
         
-    return resp
+    if not all_pages and next_cursor:
+        console.print(f"[dim]More messages available. Next cursor: {next_cursor}[/dim]")
+        console.print(f"[dim]Use --after {next_cursor} or --all to see them.[/dim]")
+        
+    return final_resp if all_pages or next_cursor else resp
 
 @session_app.command("terminate")
 @handle_api_error
@@ -456,6 +649,164 @@ def terminate_session_cmd(
         console.print(f"[green]Session {sid} terminated.[/green]")
     return None
 
+@session_app.command("archive")
+@handle_api_error
+def archive_session_cmd(
+    session_id: Optional[str] = typer.Argument(None),
+    org: Optional[str] = typer.Option(None, "--org"),
+):
+    """Archive a session (v3 only)."""
+    if org: config.temporary_org_id = org
+    sid = session_id or get_current_session_id()
+    if typer.confirm(f"Archive session {sid}?"):
+        if config.api_version == "v1":
+            console.print("[bold red]Error:[/bold red] Archive is only supported in v3 API.")
+            raise typer.Exit(1)
+        sessions.archive_session(sid)
+        console.print(f"[green]Session {sid} archived.[/green]")
+    return None
+
+@session_app.command("attachments")
+@handle_api_error
+def get_session_attachments_cmd(
+    session_id: Optional[str] = typer.Argument(None),
+    org: Optional[str] = typer.Option(None, "--org"),
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """Get session attachments (v3 only)."""
+    if org: config.temporary_org_id = org
+    sid = session_id or get_current_session_id()
+    if config.api_version == "v1":
+        console.print("[bold red]Error:[/bold red] Attachments are only supported in v3 API.")
+        raise typer.Exit(1)
+        
+    resp = sessions.get_session_attachments(sid)
+    
+    import os
+    if json_output or os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+        if os.environ.get("DEVIN_OUTPUT_FORMAT") != "json":
+            console.print(json.dumps(resp, indent=2))
+        return resp
+        
+    console.print(Panel(json.dumps(resp, indent=2), title=f"Attachments for {sid}"))
+    return resp
+
+@session_app.command("tags")
+@handle_api_error
+def get_session_tags_cmd(
+    session_id: Optional[str] = typer.Argument(None),
+    org: Optional[str] = typer.Option(None, "--org"),
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """Get session tags (v3 only)."""
+    if org: config.temporary_org_id = org
+    sid = session_id or get_current_session_id()
+    if config.api_version == "v1":
+        console.print("[bold red]Error:[/bold red] Tags fetching is only supported in v3 API.")
+        raise typer.Exit(1)
+        
+    resp = sessions.get_session_tags(sid)
+    
+    import os
+    if json_output or os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+        if os.environ.get("DEVIN_OUTPUT_FORMAT") != "json":
+            console.print(json.dumps(resp, indent=2))
+        return resp
+        
+    console.print(Panel(json.dumps(resp, indent=2), title=f"Tags for {sid}"))
+    return resp
+
+def parse_duration(duration_str: str) -> float:
+    if not duration_str:
+        return 0.0
+    duration_str = duration_str.strip().lower()
+    val = 0.0
+    if duration_str.endswith("s"):
+        val = float(duration_str[:-1])
+    elif duration_str.endswith("m"):
+        val = float(duration_str[:-1]) * 60
+    elif duration_str.endswith("h"):
+        val = float(duration_str[:-1]) * 3600
+    else:
+        try:
+            val = float(duration_str)
+        except ValueError:
+            raise ValueError(f"Invalid duration format: '{duration_str}'. Use format like 10s, 5m, 1h.")
+    if val < 0:
+        raise ValueError("Timeout duration cannot be negative.")
+    return val
+
+
+@session_app.command("wait")
+@handle_api_error
+def wait_session_cmd(
+    session_id: Optional[str] = typer.Argument(None, help="Session ID to wait for (defaults to active session)"),
+    until: str = typer.Option("completed", "--until", help="Terminal state to wait for (completed | terminal)"),
+    timeout: str = typer.Option("1h", "--timeout", help="Timeout duration (e.g. 10s, 5m, 1h)"),
+    interval: int = typer.Option(5, "--interval", help="Polling interval in seconds"),
+    org: Optional[str] = typer.Option(None, "--org"),
+):
+    """Block until the session reaches a terminal state or the desired state."""
+    if org: config.temporary_org_id = org
+    sid = session_id or get_current_session_id()
+    
+    until = until.lower()
+    if until not in ("completed", "terminal"):
+        console.print(f"[bold red]Error:[/bold red] --until must be 'completed' or 'terminal'.")
+        raise typer.Exit(1)
+        
+    try:
+        timeout_seconds = parse_duration(timeout)
+    except ValueError as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(1)
+        
+    start_time = time.time()
+    
+    console.print(f"[dim]Waiting for session {sid} to reach '{until}' (timeout {timeout}, polling every {interval}s)...[/dim]")
+    
+    try:
+        with console.status(f"[bold green]Waiting for session {sid}...[/bold green]") as status:
+            while True:
+                elapsed = time.time() - start_time
+                if timeout_seconds > 0 and elapsed >= timeout_seconds:
+                    console.print(f"\n[bold red]Timeout:[/bold red] Timed out waiting for session {sid} after {timeout}")
+                    raise typer.Exit(1)
+                    
+                try:
+                    resp = sessions.get_session(sid)
+                except Exception as e:
+                    console.print(f"\n[bold red]Error fetching session:[/bold red] {e}")
+                    raise typer.Exit(1)
+                    
+                status_enum = resp.get("status_enum")
+                term_state = get_stable_terminal_state(status_enum)
+                
+                status.update(f"[bold green]Current Status: {status_enum} (Terminal State: {term_state})[/bold green]")
+                
+                if term_state != "running" and term_state != "blocked":
+                    if until == "completed" and term_state == "completed":
+                        console.print(f"\n[bold green]Success:[/bold green] Session {sid} completed successfully.")
+                        raise typer.Exit(0)
+                    elif until == "completed" and term_state != "completed":
+                        console.print(f"\n[bold red]Failed:[/bold red] Session {sid} finished but reached non-completed terminal state '{term_state}'")
+                        raise typer.Exit(1)
+                    elif until == "terminal":
+                        console.print(f"\n[bold green]Terminal State Reached:[/bold green] Session {sid} reached state '{term_state}'.")
+                        if term_state == "completed":
+                            raise typer.Exit(0)
+                        else:
+                            raise typer.Exit(1)
+                
+                time_to_wait = min(interval, timeout_seconds - elapsed) if timeout_seconds > 0 else interval
+                if time_to_wait <= 0:
+                    continue
+                time.sleep(time_to_wait)
+    except KeyboardInterrupt:
+        console.print("\n[dim]Wait interrupted.[/dim]")
+        raise typer.Exit(130)
+
+
 # --- Knowledge ---
 @knowledge_app.command("list")
 @handle_api_error
@@ -694,19 +1045,51 @@ def create_schedule_cmd(
 def list_repos_cmd(
     org: Optional[str] = typer.Option(None, "--org"),
     json_output: bool = typer.Option(False, "--json"),
+    after: Optional[str] = typer.Option(None, "--after", help="Cursor for pagination"),
+    all_pages: bool = typer.Option(False, "--all", help="Fetch all pages sequentially"),
 ):
     """List repositories indexed for Devin."""
     if org: config.temporary_org_id = org
-    resp = repositories.list_repositories()
-    if isinstance(resp, list):
-        items = resp
-    elif isinstance(resp, dict):
-        items = resp.get("repositories") or resp.get("items") or resp.get("data") or []
-    else:
-        items = []
-    if json_output:
-        console.print(json.dumps(items, indent=2))
-        return
+    
+    items = []
+    current_after = after
+    has_next = False
+    next_cursor = None
+    
+    while True:
+        resp = repositories.list_repositories(after=current_after)
+        page_items = []
+        if isinstance(resp, list):
+            page_items = resp
+            has_next = False
+            next_cursor = None
+        elif isinstance(resp, dict):
+            page_items = resp.get("repositories") or resp.get("items") or resp.get("data") or []
+            has_next = resp.get("has_next_page", False)
+            next_cursor = resp.get("end_cursor") or resp.get("next_cursor")
+        else:
+            page_items = []
+            has_next = False
+            next_cursor = None
+            
+        items.extend(page_items)
+        
+        if not all_pages or not has_next or not next_cursor:
+            break
+            
+        current_after = next_cursor
+
+    final_resp = {
+        "repositories": items,
+        "end_cursor": next_cursor if not all_pages else None,
+        "has_next_page": has_next if not all_pages else False
+    }
+
+    if json_output or os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+        if os.environ.get("DEVIN_OUTPUT_FORMAT") != "json":
+            print(json.dumps(final_resp, indent=2))
+        return final_resp
+        
     table = Table(title="Repositories")
     table.add_column("Path", style="cyan")
     table.add_column("Indexed", style="green")
@@ -728,7 +1111,161 @@ def list_repos_cmd(
         )
         table.add_row(path, "Yes" if indexed else "No")
     console.print(table)
-    return resp
+    
+    if has_next and not all_pages:
+        console.print(f"[dim]More pages available. Use --after {next_cursor} to fetch next page, or --all to fetch all.[/dim]")
+        
+    return final_resp
+
+
+@repo_app.command("status")
+@handle_api_error
+def status_repo_cmd(
+    paths: List[str] = typer.Argument(..., help="Repository paths (owner/repo)"),
+    org: Optional[str] = typer.Option(None, "--org"),
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """Get indexing status for one or more repositories."""
+    if org: config.temporary_org_id = org
+    
+    results = []
+    exit_code = 0
+    
+    from concurrent.futures import ThreadPoolExecutor
+
+    def fetch_status(path):
+        try:
+            resp = repositories.get_indexing_status(path)
+            if isinstance(resp, dict):
+                if "repo_path" not in resp:
+                    resp["repo_path"] = path
+                indexing_enabled = resp.get("indexing_enabled", False)
+                item_exit = 0 if indexing_enabled else 1
+            else:
+                resp = {"repo_path": path, "indexing_enabled": False, "raw": resp}
+                item_exit = 1
+            return (path, resp, item_exit, None)
+        except Exception as e:
+            return (path, None, None, e)
+
+    results_map = {}
+    errors_map = {}
+    exit_codes_map = {}
+    
+    max_workers = min(10, len(paths))
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {executor.submit(fetch_status, path): path for path in paths}
+        for future in futures:
+            path = futures[future]
+            try:
+                p, resp, item_exit, err = future.result()
+                if err:
+                    errors_map[path] = err
+                else:
+                    results_map[path] = resp
+                    exit_codes_map[path] = item_exit
+            except Exception as ex:
+                errors_map[path] = ex
+
+    for path in paths:
+        if path in errors_map:
+            e = errors_map[path]
+            if isinstance(e, APIError):
+                if e.status_code == 404:
+                    resp = {
+                        "repo_path": path,
+                        "indexing_enabled": False,
+                        "error": "Not registered in Devin (404)"
+                    }
+                    results.append(resp)
+                    if len(paths) == 1:
+                        exit_code = 2
+                else:
+                    if len(paths) == 1:
+                        is_json = os.environ.get("DEVIN_OUTPUT_FORMAT") == "json" or json_output
+                        if is_json:
+                            try:
+                                err_json = e.response.json()
+                            except Exception:
+                                err_json = {"error": str(e)}
+                            print(json.dumps(err_json, indent=2))
+                        else:
+                            console.print(f"[bold red]API Error:[/bold red] {e}")
+                        raise typer.Exit(3)
+                    else:
+                        results.append({
+                            "repo_path": path,
+                            "indexing_enabled": False,
+                            "error": str(e)
+                        })
+                        exit_code = 3
+            else:
+                if len(paths) == 1:
+                    is_json = os.environ.get("DEVIN_OUTPUT_FORMAT") == "json" or json_output
+                    if is_json:
+                        print(json.dumps({"error": str(e)}, indent=2))
+                    else:
+                        console.print(f"[bold red]Error:[/bold red] {e}")
+                    raise typer.Exit(3)
+                else:
+                    results.append({
+                        "repo_path": path,
+                        "indexing_enabled": False,
+                        "error": str(e)
+                    })
+                    exit_code = 3
+        else:
+            resp = results_map[path]
+            item_exit = exit_codes_map[path]
+            results.append(resp)
+            if len(paths) == 1:
+                exit_code = item_exit
+                    
+    if len(paths) == 1:
+        final_result = results[0]
+    else:
+        final_result = {"results": results}
+
+    is_json = json_output or os.environ.get("DEVIN_OUTPUT_FORMAT") == "json"
+    if is_json:
+        if not os.environ.get("DEVIN_OUTPUT_FORMAT") == "json":
+            console.print(json.dumps(final_result, indent=2))
+        return final_result
+            
+    if len(paths) == 1:
+        res = results[0]
+        if "error" in res:
+            console.print(f"[bold red]Error:[/bold red] {res['error']}")
+        else:
+            console.print(Panel(json.dumps(res, indent=2), title=f"Status for {paths[0]}"))
+    else:
+        table = Table(title="Repository Indexing Status")
+        table.add_column("Path", style="cyan")
+        table.add_column("Indexing Enabled", style="magenta")
+        table.add_column("Status / Details")
+        
+        for res in results:
+            path = res.get("repo_path", "")
+            enabled = "Yes" if res.get("indexing_enabled") else "No"
+            
+            if "error" in res:
+                details = f"[red]{res['error']}[/red]"
+            else:
+                latest = res.get("latest_index") or {}
+                status = latest.get("status", "unknown") if latest else "N/A"
+                branch = latest.get("branch_name", "") if latest else ""
+                details = f"Status: {status}" + (f" ({branch})" if branch else "")
+                
+            table.add_row(path, enabled, details)
+        console.print(table)
+        
+    if len(paths) == 1:
+        raise typer.Exit(exit_code)
+    else:
+        if exit_code >= 3:
+            raise typer.Exit(exit_code)
+        return final_result
+
 
 @repo_app.command("index")
 @handle_api_error

devin_cli-1.3.6/tests/test_cli_extended.py

@@ -0,0 +1,191 @@
+import pytest
+from typer.testing import CliRunner
+from unittest.mock import patch, MagicMock
+from devin_cli.cli import app
+from devin_cli.api.client import APIError
+
+runner = CliRunner()
+
+@patch("devin_cli.api.repositories.list_repositories")
+def test_repos_list_pagination(mock_list):
+    # First call returns a page with has_next_page=True and end_cursor
+    # Second call returns a page with has_next_page=False
+    mock_list.side_effect = [
+        {
+            "repositories": [{"repo_path": "owner/repo1"}],
+            "has_next_page": True,
+            "end_cursor": "cursor123"
+        },
+        {
+            "repositories": [{"repo_path": "owner/repo2"}],
+            "has_next_page": False,
+            "end_cursor": None
+        }
+    ]
+    
+    result = runner.invoke(app, ["repos", "list", "--all"])
+    assert result.exit_code == 0
+    assert "owner/repo1" in result.stdout
+    assert "owner/repo2" in result.stdout
+    assert mock_list.call_count == 2
+
+
+@patch("devin_cli.api.repositories.get_indexing_status")
+def test_repos_status_enabled(mock_status):
+    mock_status.return_value = {
+        "repo_path": "owner/repo",
+        "indexing_enabled": True,
+        "latest_index": {"status": "completed"}
+    }
+    
+    result = runner.invoke(app, ["repos", "status", "owner/repo"])
+    assert result.exit_code == 0
+    assert "indexing_enabled" in result.stdout
+
+
+@patch("devin_cli.api.repositories.get_indexing_status")
+def test_repos_status_disabled(mock_status):
+    mock_status.return_value = {
+        "repo_path": "owner/repo",
+        "indexing_enabled": False
+    }
+    
+    result = runner.invoke(app, ["repos", "status", "owner/repo"])
+    assert result.exit_code == 1
+
+
+@patch("devin_cli.api.repositories.get_indexing_status")
+def test_repos_status_not_registered(mock_status):
+    # Raise a 404 APIError
+    mock_status.side_effect = APIError("Not found", 404)
+    
+    result = runner.invoke(app, ["repos", "status", "owner/repo"])
+    assert result.exit_code == 2
+    assert "Not registered in Devin" in result.stdout
+
+
+@patch("devin_cli.api.repositories.get_indexing_status")
+def test_repos_status_multi(mock_status):
+    mock_status.side_effect = [
+        {"repo_path": "owner/repo1", "indexing_enabled": True},
+        APIError("Not found", 404),
+    ]
+    
+    result = runner.invoke(app, ["repos", "status", "owner/repo1", "owner/repo2"])
+    assert result.exit_code == 0 # Multi-path doesn't fail exit code on 404
+    assert "Repository Indexing Status" in result.stdout
+    assert "owner/repo1" in result.stdout
+    assert "owner/repo2" in result.stdout
+
+
+@patch("devin_cli.api.sessions.get_session")
+def test_sessions_get_terminal_state(mock_get):
+    mock_get.return_value = {
+        "session_id": "sess_123",
+        "status_enum": "finished",
+        "title": "Test"
+    }
+    
+    result = runner.invoke(app, ["sessions", "get", "sess_123"])
+    assert result.exit_code == 0
+    assert '"terminal_state": "completed"' in result.stdout
+
+
+@patch("devin_cli.api.sessions.get_session")
+def test_sessions_wait(mock_get):
+    mock_get.side_effect = [
+        {"session_id": "sess_123", "status_enum": "running"},
+        {"session_id": "sess_123", "status_enum": "finished"}
+    ]
+    
+    result = runner.invoke(app, ["sessions", "wait", "sess_123", "--interval", "0"])
+    assert result.exit_code == 0
+    assert "completed successfully" in result.stdout
+    assert mock_get.call_count == 2
+
+
+@patch("devin_cli.api.repositories.get_indexing_status")
+def test_repos_status_other_error(mock_status):
+    # Raise a non-404 APIError (e.g., 403 Forbidden)
+    mock_status.side_effect = APIError("Forbidden", 403)
+    
+    result = runner.invoke(app, ["repos", "status", "owner/repo"])
+    print(result.stdout)
+    if result.exception:
+        print(result.exception)
+    assert result.exit_code == 3
+    assert "API Error" in result.stdout or "Forbidden" in result.stdout
+
+
+def test_sessions_wait_negative_timeout():
+    result = runner.invoke(app, ["sessions", "wait", "sess_123", "--timeout", "-10s"])
+    assert result.exit_code == 1
+    assert "cannot be negative" in result.stdout
+
+@patch("devin_cli.cli.sessions.list_sessions")
+def test_sessions_list_pagination(mock_list):
+    mock_list.side_effect = [
+        {
+            "items": [{"session_id": "sess_1"}],
+            "has_next_page": True,
+            "end_cursor": "cur_1"
+        },
+        {
+            "items": [{"session_id": "sess_2"}],
+            "has_next_page": False,
+            "end_cursor": None
+        }
+    ]
+    
+    with patch("devin_cli.cli.config") as mock_config:
+        mock_config.api_version = "v3"
+        result = runner.invoke(app, ["sessions", "list", "--all"])
+        
+    assert result.exit_code == 0
+    assert "sess_1" in result.stdout
+    assert "sess_2" in result.stdout
+    assert mock_list.call_count == 2
+
+@patch("devin_cli.cli.sessions.get_session_messages")
+def test_sessions_messages_pagination(mock_get_messages):
+    mock_get_messages.side_effect = [
+        {
+            "messages": [{"message": "hello", "role": "user"}],
+            "has_next_page": True,
+            "end_cursor": "cur_1"
+        },
+        {
+            "messages": [{"message": "world", "role": "assistant"}],
+            "has_next_page": False,
+            "end_cursor": None
+        }
+    ]
+    
+    with patch("devin_cli.cli.config") as mock_config:
+        mock_config.api_version = "v3"
+        result = runner.invoke(app, ["sessions", "messages", "sess_123", "--all"])
+        
+    assert result.exit_code == 0
+    assert "hello" in result.stdout
+    assert "world" in result.stdout
+    assert mock_get_messages.call_count == 2
+
+@patch("devin_cli.cli.consumption.get_session_consumption")
+@patch("devin_cli.cli.sessions.get_session")
+def test_sessions_cost_v3(mock_get_session, mock_consumption):
+    mock_get_session.return_value = {
+        "session_id": "sess_123",
+        "status_enum": "completed",
+        "acus_consumed": 15
+    }
+    mock_consumption.return_value = {"breakdown": "details"}
+    
+    with patch("devin_cli.cli.config") as mock_config:
+        mock_config.api_version = "v3"
+        result = runner.invoke(app, ["sessions", "cost", "sess_123"])
+        
+    assert result.exit_code == 0
+    assert "15" in result.stdout
+    assert mock_consumption.call_count == 1
+    assert "breakdown" in result.stdout
+

devin_cli-1.3.4/src/devin_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"