cyclo-manager 0.2.0.dev2__tar.gz → 0.2.0.dev4__tar.gz

{cyclo_manager-0.2.0.dev2 → cyclo_manager-0.2.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cyclo-manager
-Version: 0.2.0.dev2
+Version: 0.2.0.dev4
 Summary: cyclo_manager CLI: pip-installable launcher for cyclo_manager server and UI containers. Run 'cyclo_manager up' to start Docker stack.
 License-Expression: Apache-2.0
 Requires-Python: >=3.10

{cyclo_manager-0.2.0.dev2 → cyclo_manager-0.2.0.dev4}/cyclo_host_agent/routers/repos.py

@@ -19,11 +19,8 @@
 """Repository management endpoints."""
 
 import asyncio
-import json
 import os
 import re
-import subprocess
-import urllib.request
 from pathlib import Path
 from typing import Optional
 
@@ -87,23 +84,20 @@ def _fmt_cmd(cmd: str, output: str) -> str:
 
 # ── git helpers ────────────────────────────────────────────────────────────────
 
-def _git_sync(args: list[str], cwd: Optional[Path] = None) -> tuple[int, str, str]:
-    try:
-        result = subprocess.run(
-            ['git', *args],
-            cwd=str(cwd) if cwd else None,
-            capture_output=True,
-            timeout=GIT_TIMEOUT,
-        )
-        return result.returncode, result.stdout.decode(), result.stderr.decode()
-    except subprocess.TimeoutExpired:
-        return 1, '', 'git timed out'
-    except Exception as e:
-        return 1, '', str(e)
-
-
 async def _git(args: list[str], cwd: Optional[Path] = None) -> tuple[int, str, str]:
-    return await asyncio.to_thread(_git_sync, args, cwd)
+    proc = await asyncio.create_subprocess_exec(
+        'git', *args,
+        cwd=str(cwd) if cwd else None,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=GIT_TIMEOUT)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        raise
+    return proc.returncode, stdout.decode(), stderr.decode()
 
 
 async def _repo_info(repo_path: Path) -> RepoInfo:
@@ -137,21 +131,14 @@ def _is_newer(latest: str, current: str) -> bool:
     return _parse_version(latest) > _parse_version(current)
 
 
-def _parse_github_slug(remote_url: str) -> Optional[str]:
-    https_match = re.match(r'https?://github\.com/([^/]+/[^/]+?)(?:\.git)?/?$', remote_url)
+def _is_managed_remote(remote_url: str) -> bool:
+    https_match = re.match(r'https?://github\.com/([^/]+)/', remote_url)
     if https_match:
-        return https_match.group(1)
-    ssh_match = re.match(r'git@github\.com:([^/]+/[^/]+?)(?:\.git)?$', remote_url)
+        return https_match.group(1).lower() == MANAGED_GITHUB_ORG.lower()
+    ssh_match = re.match(r'git@github\.com:([^/]+)/', remote_url)
     if ssh_match:
-        return ssh_match.group(1)
-    return None
-
-
-def _is_managed_remote(remote_url: str) -> bool:
-    slug = _parse_github_slug(remote_url)
-    if not slug:
-        return False
-    return slug.split('/')[0].lower() == MANAGED_GITHUB_ORG.lower()
+        return ssh_match.group(1).lower() == MANAGED_GITHUB_ORG.lower()
+    return False
 
 
 def _read_package_xml_version(repo_path: Path) -> Optional[str]:
@@ -168,15 +155,18 @@ def _read_package_xml_version(repo_path: Path) -> Optional[str]:
     return None
 
 
-def _fetch_github_latest(slug: str) -> Optional[str]:
-    url = f'https://api.github.com/repos/{slug}/releases/latest'
-    req = urllib.request.Request(url, headers={'User-Agent': 'cyclo-manager/1.0'})
-    try:
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            data = json.loads(resp.read().decode())
-            return (data.get('tag_name') or '').strip() or None
-    except Exception:
+async def _fetch_latest_tag(remote_url: str) -> Optional[str]:
+    rc, out, _ = await _git(['ls-remote', '--tags', remote_url])
+    if rc != 0:
+        return None
+    tags = []
+    for line in out.splitlines():
+        if 'refs/tags/' not in line or '^{}' in line:
+            continue
+        tags.append(line.split('refs/tags/')[-1].strip())
+    if not tags:
         return None
+    return max(tags, key=_parse_version)
 
 
 async def _repo_update_status(repo_path: Path) -> Optional[RepoUpdateStatus]:
@@ -186,12 +176,11 @@ async def _repo_update_status(repo_path: Path) -> Optional[RepoUpdateStatus]:
     if not remote_url or not _is_managed_remote(remote_url):
         return None
 
-    slug = _parse_github_slug(remote_url)
     current = _read_package_xml_version(repo_path)
     if not current:
         return RepoUpdateStatus(name=repo_path.name, has_update=False)
 
-    latest = await asyncio.to_thread(_fetch_github_latest, slug)
+    latest = await _fetch_latest_tag(remote_url)
     if not latest:
         return RepoUpdateStatus(name=repo_path.name, current_version=current, has_update=False)
 
@@ -283,25 +272,24 @@ async def _update_reset(repo_path: Path, preserve_files: list[str]) -> UpdateRes
 
 # ── container helper ───────────────────────────────────────────────────────────
 
-def _run_container_sh_sync(repo_path: Path, action: str) -> tuple[bool, str]:
+async def _run_container_sh(repo_path: Path, action: str) -> tuple[bool, str]:
     script = repo_path / 'docker' / 'container.sh'
     if not script.exists():
         return False, f'container.sh not found at {script}'
+    proc = await asyncio.create_subprocess_exec(
+        'bash', str(script), action,
+        cwd=str(repo_path / 'docker'),
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
     try:
-        result = subprocess.run(
-            ['bash', str(script), action],
-            cwd=str(repo_path / 'docker'),
-            input=b'y\n',
-            capture_output=True,
-            timeout=300.0,
-        )
-        return result.returncode == 0, (result.stdout.decode() + result.stderr.decode()).strip()
-    except subprocess.TimeoutExpired:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(input=b'y\n'), timeout=300.0)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
         return False, 'Timeout waiting for container.sh'
-
-
-async def _run_container_sh(repo_path: Path, action: str) -> tuple[bool, str]:
-    return await asyncio.to_thread(_run_container_sh_sync, repo_path, action)
+    return proc.returncode == 0, (stdout.decode() + stderr.decode()).strip()
 
 
 # ── endpoints ──────────────────────────────────────────────────────────────────

{cyclo_manager-0.2.0.dev2 → cyclo_manager-0.2.0.dev4}/cyclo_host_agent/routers/update.py

@@ -42,15 +42,16 @@ def _fmt(cmd: str, out: str) -> str:
     return f'$ {cmd}\n{out.strip()}' if out.strip() else f'$ {cmd}'
 
 
-
-def _run_cmd(args: list[str], timeout: float) -> tuple[int, str]:
+def _restart_self() -> None:
+    """Restart the host agent after a short delay so new binary takes effect."""
+    time.sleep(2)
     try:
-        result = subprocess.run(args, capture_output=True, timeout=timeout)
-        return result.returncode, (result.stdout.decode() + result.stderr.decode()).strip()
-    except subprocess.TimeoutExpired:
-        return 1, 'timed out'
+        subprocess.run(
+            ['sudo', 'systemctl', 'restart', f'{HOST_AGENT_SERVICE}.service'],
+            check=True,
+        )
     except Exception as e:
-        return 1, str(e)
+        logger.error('Failed to restart host agent: %s', e)
 
 
 async def _run_install_and_up(cyclo_exe: str, pip_exe: str) -> None:
@@ -59,24 +60,50 @@ async def _run_install_and_up(cyclo_exe: str, pip_exe: str) -> None:
 
     # pip install -U
     _update_status['phase'] = 'installing'
-    rc, out = await asyncio.to_thread(_run_cmd, [pip_exe, 'install', '-U', PYPI_PACKAGE], 120)
-    _update_status['install_output'] = _fmt(f'pip install -U {PYPI_PACKAGE}', out)
-    if rc != 0:
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            pip_exe, 'install', '-U', PYPI_PACKAGE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=120)
+        out = (stdout.decode() + stderr.decode()).strip()
+        _update_status['install_output'] = _fmt(f'pip install -U {PYPI_PACKAGE}', out)
+        if proc.returncode != 0:
+            _update_status['phase'] = 'error'
+            _update_status['error'] = f'pip install failed (exit {proc.returncode})'
+            return
+    except asyncio.TimeoutError:
         _update_status['phase'] = 'error'
-        _update_status['error'] = f'pip install failed (exit {rc})'
+        _update_status['error'] = 'pip install timed out'
         return
 
     # cyclo up
     _update_status['phase'] = 'starting'
-    rc, out = await asyncio.to_thread(_run_cmd, [cyclo_exe, 'up'], 300)
-    _update_status['up_output'] = _fmt('cyclo_manager up', out)
-    if rc != 0:
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            cyclo_exe, 'up',
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=300)
+        out = (stdout.decode() + stderr.decode()).strip()
+        _update_status['up_output'] = _fmt('cyclo_manager up', out)
+        if proc.returncode != 0:
+            _update_status['phase'] = 'error'
+            _update_status['error'] = f'cyclo_manager up failed (exit {proc.returncode})'
+            return
+    except asyncio.TimeoutError:
         _update_status['phase'] = 'error'
-        _update_status['error'] = f'cyclo_manager up failed (exit {rc})'
+        _update_status['error'] = 'cyclo_manager up timed out'
         return
 
     _update_status['phase'] = 'done'
 
+    # Restart self so new binary takes effect
+    loop = asyncio.get_event_loop()
+    await loop.run_in_executor(None, _restart_self)
+
 
 @router.post('/update')
 async def start_update() -> dict:
@@ -100,9 +127,20 @@ async def start_update() -> dict:
 
     _update_status = {'phase': 'stopping', 'install_output': '', 'up_output': '', 'error': ''}
 
-    # cyclo down
-    rc, out = await asyncio.to_thread(_run_cmd, [cyclo_exe, 'down'], 30)
-    down_output = _fmt('cyclo_manager down', out)
+    # cyclo down (synchronous — server goes down here)
+    down_output = ''
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            cyclo_exe, 'down',
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=30)
+        down_output = _fmt('cyclo_manager down', (stdout.decode() + stderr.decode()))
+    except asyncio.TimeoutError:
+        down_output = '$ cyclo_manager down\n(timed out)'
+    except Exception as e:
+        down_output = f'$ cyclo_manager down\n(error: {e})'
 
     # Continue install + up in background
     asyncio.create_task(_run_install_and_up(cyclo_exe, pip_exe))

{cyclo_manager-0.2.0.dev2 → cyclo_manager-0.2.0.dev4}/cyclo_manager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cyclo-manager
-Version: 0.2.0.dev2
+Version: 0.2.0.dev4
 Summary: cyclo_manager CLI: pip-installable launcher for cyclo_manager server and UI containers. Run 'cyclo_manager up' to start Docker stack.
 License-Expression: Apache-2.0
 Requires-Python: >=3.10

{cyclo_manager-0.2.0.dev2 → cyclo_manager-0.2.0.dev4}/cyclo_manager_cli/cli.py

@@ -33,6 +33,7 @@ import sys
 PYPI_PACKAGE = 'cyclo-manager'
 HOST_AGENT_SERVICE = 'cyclo_host_agent'
 HOST_AGENT_SOCKET = '/var/run/robotis/agent_sockets/host/host_agent.sock'
+HOST_AGENT_SOCKET_DIR = '/var/run/robotis/agent_sockets/host'
 
 # `cyclo_manager up` starts these immediately.
 COMPOSE_SERVICES_UP = ('cyclo_manager', 'ui')
@@ -53,24 +54,67 @@ def _packaged_config_path() -> Path:
     return _config_dir() / 'config.yml'
 
 
-def _check_host_agent() -> bool:
-    """Return True if the cyclo_host_agent service is already active."""
-    result = subprocess.run(
-        ['systemctl', 'is-active', f'{HOST_AGENT_SERVICE}.service'],
-        capture_output=True,
-        text=True,
-    )
-    return result.returncode == 0
+def _resolve_service_user() -> tuple[str, Path] | None:
+    """
+    Return (username, home) for the host agent systemd service.
 
+    Uses SUDO_USER when cyclo_manager up is invoked via sudo so the agent runs
+    as the login user (required for git repo scans under ~/...).
+    """
+    sudo_user = os.environ.get('SUDO_USER')
+    if sudo_user:
+        return sudo_user, Path(f'/home/{sudo_user}')
+    user = os.environ.get('USER') or os.getlogin()
+    if user == 'root':
+        print(
+            'Error: cyclo_manager up must run as a normal user (e.g. robotis), not root.',
+            file=sys.stderr,
+        )
+        return None
+    return user, Path.home()
+
+
+def _setup_socket_dir(user: str) -> bool:
+    """
+    Ensure the host agent UDS directory exists and is owned by the service user.
+
+    Only host/ is chowned so other agent sockets under agent_sockets/ are untouched.
+    Removes a stale socket file (e.g. left by a previous root-owned service).
+    """
+    try:
+        subprocess.run(
+            ['sudo', 'mkdir', '-p', HOST_AGENT_SOCKET_DIR],
+            check=True,
+            capture_output=True,
+        )
+        subprocess.run(
+            ['sudo', 'chown', f'{user}:{user}', HOST_AGENT_SOCKET_DIR],
+            check=True,
+            capture_output=True,
+        )
+        subprocess.run(
+            ['sudo', 'rm', '-f', HOST_AGENT_SOCKET],
+            check=True,
+            capture_output=True,
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f'Failed to set up host agent socket directory: {e}', file=sys.stderr)
+        return False
 
 
-def _create_host_agent() -> int:
+def _ensure_host_agent() -> int:
     """
-    Write cyclo_host_agent systemd service unit file and enable it.
+    Install or refresh cyclo_host_agent: systemd unit, socket dir, and service start.
 
-    Runs as a persistent service (Restart=always); systemd starts it at boot
-    and restarts it automatically if it exits unexpectedly.
+    Idempotent — safe to run on every `cyclo_manager up` (fixes upgraded units and
+    socket ownership after switching away from a root-owned service).
     """
+    account = _resolve_service_user()
+    if account is None:
+        return 1
+
+    user, user_home = account
     agent_exe = shutil.which('cyclo_host_agent')
     if not agent_exe:
         print(
@@ -80,8 +124,9 @@ def _create_host_agent() -> int:
         )
         return 1
 
-    current_user = os.environ.get('SUDO_USER') or os.environ.get('USER') or os.getlogin()
-    user_home = Path(f'/home/{current_user}') if current_user else Path.home()
+    if not _setup_socket_dir(user):
+        return 1
+
     service_content = f"""\
 [Unit]
 Description=Cyclo Host Agent
@@ -89,7 +134,8 @@ After=network.target
 
 [Service]
 Type=simple
-User={current_user}
+User={user}
+Group={user}
 ExecStart={agent_exe}
 Environment=HOME={user_home}
 Restart=always
@@ -110,7 +156,8 @@ WantedBy=multi-user.target
             check=True,
         )
         subprocess.run(['sudo', 'systemctl', 'daemon-reload'], check=True)
-        subprocess.run(['sudo', 'systemctl', 'enable', '--now', f'{HOST_AGENT_SERVICE}.service'], check=True)
+        subprocess.run(['sudo', 'systemctl', 'enable', f'{HOST_AGENT_SERVICE}.service'], check=True)
+        subprocess.run(['sudo', 'systemctl', 'restart', f'{HOST_AGENT_SERVICE}.service'], check=True)
         print('Host agent service installed and started.')
         return 0
     except subprocess.CalledProcessError as e:
@@ -123,14 +170,8 @@ WantedBy=multi-user.target
 
 def cmd_up(args: argparse.Namespace) -> int:
     """Start API + UI; create zenoh and noVNC containers without starting them."""
-    if _check_host_agent():
-        try:
-            subprocess.run(['sudo', 'systemctl', 'restart', f'{HOST_AGENT_SERVICE}.service'], check=True)
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            print('Warning: Failed to restart host agent service.', file=sys.stderr)
-    else:
-        if _create_host_agent() != 0:
-            print('Warning: Failed to install host agent service.')
+    if _ensure_host_agent() != 0:
+        print('Warning: Failed to install host agent service.', file=sys.stderr)
 
     config_path = _packaged_config_path()
     if not config_path.is_file():
@@ -237,15 +278,6 @@ def cmd_update(args: argparse.Namespace) -> int:
     except subprocess.CalledProcessError as e:
         return e.returncode
 
-    print('Restarting host agent...')
-    try:
-        subprocess.run(
-            ['sudo', 'systemctl', 'restart', f'{HOST_AGENT_SERVICE}.service'],
-            check=True,
-        )
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        print('Warning: Failed to restart host agent service.', file=sys.stderr)
-
     print('cyclo_manager update completed.')
     return 0
 

{cyclo_manager-0.2.0.dev2 → cyclo_manager-0.2.0.dev4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cyclo-manager"
-version = "0.2.0.dev2"
+version = "0.2.0.dev4"
 description = "cyclo_manager CLI: pip-installable launcher for cyclo_manager server and UI containers. Run 'cyclo_manager up' to start Docker stack."
 readme = "README.md"
 license = "Apache-2.0"