hypercli-cli 2026.5.21__tar.gz → 2026.6.21__tar.gz

{hypercli_cli-2026.5.21 → hypercli_cli-2026.6.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 2026.5.21
+Version: 2026.6.21
 Summary: CLI for HyperCLI - GPU orchestration and LLM API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com
@@ -9,9 +9,10 @@ Author-email: HyperCLI <support@hypercli.com>
 License: MIT
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: hypercli-sdk>=2026.5.21
+Requires-Dist: hypercli-sdk>=2026.6.21
 Requires-Dist: mutagen>=1.47.0
 Requires-Dist: openai>=2.8.1
+Requires-Dist: pysubs2>=1.8.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=14.2.0
 Requires-Dist: typer>=0.20.0
@@ -19,11 +20,11 @@ Provides-Extra: all
 Requires-Dist: argon2-cffi>=25.0.0; extra == 'all'
 Requires-Dist: eth-account>=0.13.0; extra == 'all'
 Requires-Dist: faster-whisper>=1.1.0; extra == 'all'
-Requires-Dist: hypercli-sdk[comfyui]>=2026.5.21; extra == 'all'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.6.21; extra == 'all'
 Requires-Dist: web3>=7.0.0; extra == 'all'
 Requires-Dist: x402[evm,httpx]>=2.0.0; extra == 'all'
 Provides-Extra: comfyui
-Requires-Dist: hypercli-sdk[comfyui]>=2026.5.21; extra == 'comfyui'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.6.21; extra == 'comfyui'
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'

hypercli_cli-2026.6.21/hypercli_cli/__init__.py

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

{hypercli_cli-2026.5.21 → hypercli_cli-2026.6.21}/hypercli_cli/agent.py

@@ -502,11 +502,15 @@ def subscription_summary(
 def activate_code(
     code: str = typer.Argument(..., help="Activation or promo code to redeem"),
     dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+    extend_existing: bool = typer.Option(False, "--extend-existing", help="Extend the matching entitlement instead of creating a new one"),
     json_output: bool = typer.Option(False, "--json", help="Print raw JSON response"),
 ):
     """Redeem a HyperClaw activation code for the current account."""
     client = _get_agent_query_client(dev)
-    result = client.agent.redeem_grant_code(code)
+    result = client.agent.redeem_grant_code(
+        code,
+        extend_existing=True if extend_existing else None,
+    )
 
     if json_output:
         console.print_json(json.dumps(result, indent=2, default=str))

{hypercli_cli-2026.5.21 → hypercli_cli-2026.6.21}/hypercli_cli/agents.py

@@ -12,7 +12,7 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from hypercli.agents import Agent, Deployments, OpenClawAgent, DEFAULT_OPENCLAW_IMAGE
+from hypercli.agents import AGENT_FILE_MAX_BYTES, Agent, Deployments, OpenClawAgent, DEFAULT_OPENCLAW_IMAGE
 from hypercli.config import get_agent_api_key as get_config_agent_api_key
 
 app = typer.Typer(help="Manage OpenClaw agent pods")
@@ -284,6 +284,8 @@ def create(
     registry_url: str = typer.Option(None, "--registry-url", help="Container registry URL for private image pulls"),
     registry_username: str = typer.Option(None, "--registry-username", help="Registry username"),
     registry_password: str = typer.Option(None, "--registry-password", help="Registry password"),
+    sync_uid: int = typer.Option(None, "--sync-uid", help="UID for restored synced files; defaults to Lagoon's configured value"),
+    sync_gid: int = typer.Option(None, "--sync-gid", help="GID for restored synced files; defaults to Lagoon's configured value"),
     gateway_token: str = typer.Option(None, "--gateway-token", help="OpenClaw gateway token override"),
     dry_run: bool = typer.Option(False, "--dry-run", help="Validate launch configuration without creating the agent or pod"),
     no_start: bool = typer.Option(False, "--no-start", help="Create without starting"),
@@ -310,6 +312,8 @@ def create(
             image=_default_openclaw_image(image),
             registry_url=registry_url,
             registry_auth=registry_auth,
+            sync_uid=sync_uid,
+            sync_gid=sync_gid,
             gateway_token=gateway_token,
             dry_run=dry_run,
             start=not no_start,
@@ -436,6 +440,36 @@ def list_agents(
 
     console.print()
     console.print(table)
+
+
+@app.command("web-search")
+def web_search_cmd(
+    query: str = typer.Argument(..., help="Search query"),
+    count: int = typer.Option(5, "--count", "-n", min=1, max=20, help="Number of Brave results to request"),
+    json_output: bool = typer.Option(False, "--json", help="Print raw JSON response"),
+):
+    """Search the web through the HyperClaw Brave proxy."""
+    agents = _get_deployments_client()
+    try:
+        payload = agents.web_search(query, count=count)
+    except Exception as e:
+        console.print(f"[red]❌ Web search failed: {e}[/red]")
+        raise typer.Exit(1)
+
+    if json_output:
+        console.print(json.dumps(payload, indent=2))
+        return
+
+    web = payload.get("web") if isinstance(payload, dict) else None
+    results = web.get("results") if isinstance(web, dict) else []
+    table = Table(title="Web Search")
+    table.add_column("Title")
+    table.add_column("URL")
+    for item in results or []:
+        if not isinstance(item, dict):
+            continue
+        table.add_row(str(item.get("title") or ""), str(item.get("url") or ""))
+    console.print(table)
     console.print()
 
 
@@ -493,6 +527,8 @@ def start(
     registry_url: str = typer.Option(None, "--registry-url", help="Container registry URL for private image pulls"),
     registry_username: str = typer.Option(None, "--registry-username", help="Registry username"),
     registry_password: str = typer.Option(None, "--registry-password", help="Registry password"),
+    sync_uid: int = typer.Option(None, "--sync-uid", help="UID for restored synced files; defaults to Lagoon's configured value"),
+    sync_gid: int = typer.Option(None, "--sync-gid", help="GID for restored synced files; defaults to Lagoon's configured value"),
     gateway_token: str = typer.Option(None, "--gateway-token", help="OpenClaw gateway token override"),
     dry_run: bool = typer.Option(False, "--dry-run", help="Validate launch configuration without starting the agent"),
 ):
@@ -521,6 +557,8 @@ def start(
             image=effective_image,
             registry_url=registry_url,
             registry_auth=registry_auth,
+            sync_uid=sync_uid,
+            sync_gid=sync_gid,
             gateway_token=effective_gateway_token,
             dry_run=dry_run,
         )
@@ -639,6 +677,9 @@ def cp(
 
     try:
         if dst_agent_id:
+            local_size = Path(src_path).stat().st_size
+            if local_size > AGENT_FILE_MAX_BYTES:
+                raise ValueError(f"Agent file writes are limited to {AGENT_FILE_MAX_BYTES // 1024 // 1024} MiB")
             pod = _get_pod_with_token(dst_agent_id)
             agents.cp_to(pod, src_path, dst_path)
             console.print(f"[green]✓[/green] Copied [bold]{src_path}[/bold] to [bold]{dst_agent_id[:12]}:{dst_path}[/bold]")

{hypercli_cli-2026.5.21 → hypercli_cli-2026.6.21}/hypercli_cli/cli.py

@@ -10,7 +10,7 @@ from rich.table import Table
 from hypercli import HyperCLI, APIError, configure
 from hypercli.config import CONFIG_FILE
 
-from . import agent, agents, billing, comfyui, files, flow, instances, jobs, keys, llm, user, voice, wallet
+from . import agent, agents, billing, comfyui, files, flow, instances, jobs, keys, llm, memory, user, voice, wallet
 from .output import output, spinner
 
 console = Console()
@@ -94,6 +94,7 @@ app.add_typer(instances.app, name="instances")
 app.add_typer(keys.app, name="keys")
 app.add_typer(jobs.app, name="jobs")
 app.add_typer(llm.app, name="llm")
+app.add_typer(memory.app, name="memory")
 app.add_typer(user.app, name="user")
 app.add_typer(voice.app, name="voice")
 app.add_typer(wallet.app, name="wallet")
@@ -192,6 +193,32 @@ def me_cmd(
     console.print(table)
 
 
+@app.command("status")
+def status_cmd(
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Show compact platform status."""
+    client = HyperCLI()
+    with spinner("Checking platform status..."):
+        payload = client.status()
+    if fmt == "json":
+        output(payload, fmt)
+        return
+
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("Type")
+    table.add_column("Name")
+    table.add_column("Healthy")
+
+    for name, healthy in (payload.get("models") or {}).items():
+        table.add_row("model", str(name), "true" if healthy else "false")
+    for name, healthy in (payload.get("clusters") or {}).items():
+        table.add_row("cluster", str(name), "true" if healthy else "false")
+
+    console.print(f"ok: {'true' if payload.get('ok') else 'false'}")
+    console.print(table)
+
+
 @app.command("configure")
 def configure_cmd():
     """Configure HyperCLI with your API key and API URL"""

hypercli_cli-2026.6.21/hypercli_cli/memory.py

@@ -0,0 +1,334 @@
+"""OpenClaw memory artifact helpers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import subprocess
+from typing import Any
+
+import typer
+from rich.console import Console
+
+from . import llm
+from .memory_captions import (
+    DEFAULT_WORKSPACE,
+    SUPPORTED_CAPTION_EXTENSIONS,
+    discover_caption_files,
+    import_caption_file,
+    parse_caption_file,
+    transcript_lines,
+)
+from .memory_documents import (
+    SUPPORTED_DOCUMENT_EXTENSIONS,
+    discover_document_files,
+    extract_document_text,
+    import_document_file,
+)
+
+app = typer.Typer(help="Prepare OpenClaw memory artifacts")
+console = Console()
+
+
+def _split_csv(value: str | None) -> list[str] | None:
+    if not value:
+        return None
+    return [part.strip() for part in value.split(",") if part.strip()] or None
+
+
+def _sample_transcript_text(caption_file: Path, max_chars: int = 12_000) -> str:
+    segments = parse_caption_file(caption_file)
+    lines = transcript_lines(segments)
+    parts: list[str] = []
+    for line in lines:
+        parts.append(line.text)
+        if sum(len(part) + 1 for part in parts) >= max_chars:
+            break
+    return "\n".join(parts)[:max_chars]
+
+
+def _sample_document_text(document_file: Path, max_chars: int = 12_000) -> str:
+    return extract_document_text(document_file).text[:max_chars]
+
+
+def _extract_json_object(text: str) -> dict[str, Any]:
+    stripped = text.strip()
+    if stripped.startswith("```"):
+        stripped = stripped.strip("`")
+        if stripped.lower().startswith("json"):
+            stripped = stripped[4:].strip()
+    try:
+        parsed = json.loads(stripped)
+    except json.JSONDecodeError:
+        start = stripped.find("{")
+        end = stripped.rfind("}")
+        if start < 0 or end <= start:
+            raise
+        parsed = json.loads(stripped[start : end + 1])
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def enrich_text_metadata(
+    *,
+    title: str,
+    source_kind: str,
+    text_sample: str,
+    source_url: str | None,
+    source_name: str | None,
+    model: str | None,
+    base_url: str | None,
+    key: str | None,
+) -> dict[str, Any]:
+    """Generate optional memory metadata through Hyper's OpenAI-compatible API."""
+    api_key = llm._resolve_api_key(key)
+    api_base = llm._resolve_api_base(base_url)
+    resolved_model = model or llm._resolve_default_model(api_key, api_base)
+    client = llm._get_openai_client(api_key, api_base)
+    response = client.chat.completions.create(
+        model=resolved_model,
+        stream=False,
+        temperature=0.2,
+        messages=[
+            {
+                "role": "system",
+                "content": (
+                    "Return strict JSON only. Summarize extracted source text for an "
+                    "OpenClaw memory file. Keep claims grounded in the supplied text."
+                ),
+            },
+            {
+                "role": "user",
+                "content": (
+                    f"Title: {title}\n"
+                    f"Source kind: {source_kind}\n"
+                    f"Source name: {source_name or ''}\n"
+                    f"Source URL: {source_url or ''}\n\n"
+                    "Text excerpt:\n"
+                    f"{text_sample}\n\n"
+                    "Return JSON with keys: short_summary, long_description, keywords. "
+                    "keywords must be a list of concise lowercase phrases."
+                ),
+            },
+        ],
+    )
+    content = response.choices[0].message.content or "{}"
+    parsed = _extract_json_object(content)
+    keywords = parsed.get("keywords")
+    if not isinstance(keywords, list):
+        parsed["keywords"] = []
+    return parsed
+
+
+def enrich_caption_metadata(
+    *,
+    caption_file: Path,
+    title: str,
+    source_url: str | None,
+    channel: str | None,
+    model: str | None,
+    base_url: str | None,
+    key: str | None,
+) -> dict[str, Any]:
+    """Generate optional caption metadata through Hyper's OpenAI-compatible API."""
+    return enrich_text_metadata(
+        title=title,
+        source_kind="captions",
+        text_sample=_sample_transcript_text(caption_file),
+        source_url=source_url,
+        source_name=channel,
+        model=model,
+        base_url=base_url,
+        key=key,
+    )
+
+
+def enrich_document_metadata(
+    *,
+    document_file: Path,
+    title: str,
+    source_url: str | None,
+    author: str | None,
+    model: str | None,
+    base_url: str | None,
+    key: str | None,
+) -> dict[str, Any]:
+    """Generate optional document metadata through Hyper's OpenAI-compatible API."""
+    return enrich_text_metadata(
+        title=title,
+        source_kind=document_file.suffix.lower().lstrip(".") or "document",
+        text_sample=_sample_document_text(document_file),
+        source_url=source_url,
+        source_name=author,
+        model=model,
+        base_url=base_url,
+        key=key,
+    )
+
+
+def _discover_memory_files(input_path: Path) -> tuple[list[Path], list[Path]]:
+    if input_path.is_file():
+        suffix = input_path.suffix.lower()
+        if suffix in SUPPORTED_CAPTION_EXTENSIONS:
+            return [input_path], []
+        if suffix in SUPPORTED_DOCUMENT_EXTENSIONS:
+            return [], [input_path]
+        return [], []
+    return discover_caption_files(input_path), discover_document_files(input_path)
+
+
+def _run_index(*, index: bool, agent: str | None) -> None:
+    if not index:
+        return
+    cmd = ["openclaw", "memory", "index"]
+    if agent:
+        cmd.extend(["--agent", agent])
+    subprocess.run(cmd, check=True)
+
+
+@app.command("import")
+def import_memory(
+    input_path: Path = typer.Argument(
+        ...,
+        help=(
+            "Source file or directory. Supported: .srt, .vtt, .ttml, "
+            ".pdf, .doc, .docx, .epub, .txt, .md"
+        ),
+    ),
+    workspace: Path = typer.Option(
+        DEFAULT_WORKSPACE,
+        "--workspace",
+        "-w",
+        help="OpenClaw workspace root used when --memory-dir/HYPER_MEMORY_DIR is not set",
+    ),
+    memory_dir: Path = typer.Option(
+        None,
+        "--memory-dir",
+        envvar="HYPER_MEMORY_DIR",
+        help="OpenClaw memory root; defaults to <workspace>/memory",
+    ),
+    collection: str = typer.Option(
+        ...,
+        "--collection",
+        "-c",
+        help="Collection under memory root, e.g. youtube/examplecreator",
+    ),
+    source_id: str = typer.Option(
+        None,
+        "--source-id",
+        help="Stable source/video id for single-file imports",
+    ),
+    title: str = typer.Option(None, "--title", help="Readable title for single-file imports"),
+    source_url: str = typer.Option(None, "--source-url", help="Original source URL"),
+    channel: str = typer.Option(None, "--channel", help="Channel/show/source name"),
+    channel_url: str = typer.Option(None, "--channel-url", help="Channel/show/source URL"),
+    author: str = typer.Option(None, "--author", help="Document author/source name"),
+    source_type: str = typer.Option(
+        None, "--source-type", help="Override document source type in frontmatter"
+    ),
+    participants: str = typer.Option(
+        None,
+        "--participants",
+        help="Comma-separated participant names, if known",
+    ),
+    caption_language: str = typer.Option(None, "--language", "-l", help="Caption language"),
+    caption_kind: str = typer.Option(None, "--caption-kind", help="manual, auto, translated, asr"),
+    raw_json3: Path = typer.Option(
+        None, "--raw-json3", help="Optional json3 file to copy/link in metadata"
+    ),
+    no_copy_raw: bool = typer.Option(
+        False, "--no-copy-raw", help="Do not copy raw caption/json3 files"
+    ),
+    enrich: bool = typer.Option(
+        False, "--enrich", help="Generate summaries/keywords through Hyper /v1"
+    ),
+    model: str = typer.Option(None, "--model", "-m", help="Model for --enrich"),
+    base_url: str = typer.Option(
+        None, "--base-url", "-b", help="Product API base URL for --enrich"
+    ),
+    key: str = typer.Option(None, "--key", "-k", help="API key for --enrich"),
+    index: bool = typer.Option(False, "--index", help="Run openclaw memory index after import"),
+    agent: str = typer.Option(None, "--agent", help="Agent id for --index"),
+):
+    """Import supported sources into OpenClaw-indexable Markdown memory files."""
+    caption_files, document_files = _discover_memory_files(input_path)
+    if not caption_files and not document_files:
+        console.print(f"[red]No supported memory source files found under {input_path}[/red]")
+        raise typer.Exit(1)
+    total_files = len(caption_files) + len(document_files)
+    if total_files > 1 and (source_id or title or source_url or raw_json3):
+        console.print(
+            "[red]--source-id, --title, --source-url, and --raw-json3 only apply to "
+            "single-file imports[/red]"
+        )
+        raise typer.Exit(1)
+    if raw_json3 and not caption_files:
+        console.print("[red]--raw-json3 only applies to caption imports[/red]")
+        raise typer.Exit(1)
+
+    for caption_file in caption_files:
+        resolved_title = title or caption_file.stem
+        enrichment = None
+        if enrich:
+            enrichment = enrich_caption_metadata(
+                caption_file=caption_file,
+                title=resolved_title,
+                source_url=source_url,
+                channel=channel,
+                model=model,
+                base_url=base_url,
+                key=key,
+            )
+        result = import_caption_file(
+            caption_file=caption_file,
+            workspace=workspace,
+            memory_dir=memory_dir,
+            collection=collection,
+            video_id=source_id,
+            title=resolved_title,
+            source_url=source_url,
+            channel=channel,
+            channel_url=channel_url,
+            participants=_split_csv(participants),
+            caption_language=caption_language,
+            caption_kind=caption_kind,
+            raw_json3=raw_json3,
+            copy_raw=not no_copy_raw,
+            enrichment=enrichment,
+        )
+        console.print(
+            f"[green]✓[/green] {result.markdown_path} "
+            f"({result.transcript_line_count} transcript lines)"
+        )
+
+    for document_file in document_files:
+        resolved_title = title or document_file.stem
+        enrichment = None
+        if enrich:
+            enrichment = enrich_document_metadata(
+                document_file=document_file,
+                title=resolved_title,
+                source_url=source_url,
+                author=author,
+                model=model,
+                base_url=base_url,
+                key=key,
+            )
+        result = import_document_file(
+            document_file=document_file,
+            workspace=workspace,
+            memory_dir=memory_dir,
+            collection=collection,
+            source_id=source_id,
+            title=resolved_title,
+            source_url=source_url,
+            source_type=source_type,
+            author=author,
+            copy_raw=not no_copy_raw,
+            enrichment=enrichment,
+        )
+        console.print(
+            f"[green]✓[/green] {result.markdown_path} "
+            f"({result.word_count} words, {result.character_count} chars)"
+        )
+
+    _run_index(index=index, agent=agent)