hyperagents 1.2.3rc5.post3__py3-none-any.whl

cli/onboarding.py

@@ -0,0 +1,469 @@
+"""
+HyperClaw Onboarding — Warm, conversational first-run experience.
+"""
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from rich import print as rprint
+
+from hyperclaw import live_state
+
+console = Console()
+
+def banner() -> str:
+    """Product banner (see hyperclaw.branding): "HyperAgents" before naming,
+    the agent's name with "HyperAgents · powered by HyperClaw" after."""
+    from hyperclaw.branding import banner_rich
+    return banner_rich()
+
+
+def slow_print(text: str, delay: float = 0.02):
+    """Print text character by character for a typewriter effect."""
+    import sys
+    for char in text:
+        sys.stdout.write(char)
+        sys.stdout.flush()
+        time.sleep(delay)
+    print()
+
+
+def _say(text: str, *, bold: bool = False, dim: bool = False, style: str = "") -> None:
+    """One plain line (never parsed as markup: live values are printed as-is)."""
+    st = " ".join(x for x in (style or ("dim" if dim else "white"), "bold" if bold else "") if x)
+    console.print(text, style=st, markup=False, highlight=False)
+
+
+def _live():
+    return live_state.snapshot()
+
+
+def name_assistant() -> str:
+    """Step one of onboarding: name the assistant (spec §14).
+
+    Naming comes before model setup, so on a fresh install no model is
+    reachable yet and a suggestion comes from the starter list; the customer
+    can ask for a model-made suggestion later with /name suggest. If a model
+    is already configured (e.g. `hyperclaw init --reset`), it is used."""
+    from hyperclaw import naming
+
+    console.print()
+
+    def ask(label: str) -> str:
+        return Prompt.ask(f"[cyan]{label}[/cyan]", default="", show_default=False)
+
+    def say(text: str) -> None:
+        console.print(text, markup=False, highlight=False)
+        console.print()
+
+    name = naming.run_interactive(ask, say, model_call=naming.default_model_call())
+    time.sleep(0.2)
+    return name
+
+
+def warm_greeting():
+    """First greeting - friendly and inviting."""
+    console.print(banner())
+    time.sleep(0.5)
+
+    # Welcome message
+    console.print()
+    # Generated from what is live on this install (truth rule): no fixed
+    # list of capabilities or integrations (hyperclaw.live_state).
+    state = _live()
+    for line in live_state.welcome_lines(state):
+        _say(line, bold=line.startswith("Welcome"))
+    console.print()
+    time.sleep(0.5)
+
+    _say("Setup:", dim=True)
+    for i, step in enumerate(live_state.steps(state), 1):
+        _say(f"  {i}. {step}")
+    console.print()
+    time.sleep(0.5)
+
+
+def get_name():
+    """Ask for user's name."""
+    name = Prompt.ask("[cyan]What should I call you?[/cyan]")
+    console.print()
+    rprint(f"[white]Nice to meet you, [bold]{name}[/bold].[/white]")
+    time.sleep(0.3)
+    return name
+
+
+def explain_system(user_name: str, ai_name: str):
+    """Explain what the AI does."""
+    console.print()
+    rprint(f"[white]Here's the deal, {user_name}.[/white]")
+    time.sleep(0.3)
+    console.print()
+
+    _say(f"I'm {ai_name}.")
+    for line in live_state.explain_lines(_live()):
+        _say(line)
+        time.sleep(0.2)
+    console.print()
+
+
+def ask_hyper_key() -> str:
+    """The only thing HyperSpeed V2 needs from the customer (masked)."""
+    from hyperclaw.hyperspeed import looks_like_third_party_key
+    rprint("[white]HyperSpeed V2 is preconfigured: the endpoint and model are built in.[/white]")
+    rprint("[white]All it needs is your [bold]Hyper access key[/bold] "
+           "(from your Hyper account or your Hyper contact).[/white]")
+    console.print()
+    from hyperclaw.model_policy import check_key
+    for _ in range(2):
+        key = Prompt.ask("[cyan]Hyper access key (hidden; press Enter to add it later)[/cyan]",
+                         password=True, default="", show_default=False).strip()
+        refused = check_key(key)
+        if refused:
+            _say(refused, style="yellow")
+            continue
+        vendor = looks_like_third_party_key(key)
+        if vendor:
+            _say(f"That looks like an {vendor} key, not a Hyper access key. "
+                 f"You can add it as your own provider in the next step.", style="yellow")
+            continue
+        if not key:
+            return key
+        result = check_connection(key)
+        _say(result.line, style="green" if result.ok else "yellow")
+        if result.ok or result.kind != "auth":
+            return key   # unavailable or timed out: the key is kept, try later
+    return ""
+
+
+def check_connection(key: str):
+    """Live test call to HyperSpeed V2 with the key just entered
+    (hyperclaw.connection_check). Tests replace this with a mock endpoint."""
+    from hyperclaw.connection_check import check_hyperspeed
+    return check_hyperspeed(key)
+
+
+def _own_provider_prompt(choice: str) -> dict:
+    """Ask for one of the customer's own providers. choice: 2-6."""
+    if choice == "5":
+        console.print()
+        rprint("[white]AWS Bedrock needs credentials and a region.[/white]")
+        rprint("[dim]Leave blank to use environment variables / IAM role.[/dim]")
+        console.print()
+        access_key = Prompt.ask("[cyan]AWS Access Key ID     (Enter to use env/IAM)[/cyan]", default="")
+        secret_key = Prompt.ask("[cyan]AWS Secret Access Key (Enter to use env/IAM)[/cyan]",
+                                password=True, default="")
+        if _refused(access_key) or _refused(secret_key):
+            return {}
+        region = Prompt.ask("[cyan]AWS Region[/cyan]", default="us-east-1")
+        return {"provider": "bedrock", "access_key": access_key or None,
+                "secret_key": secret_key or None, "region": region}
+
+    if choice == "4":
+        console.print()
+        base_url = Prompt.ask("[cyan]Base URL[/cyan]", default="https://api.openai.com/v1")
+        api_key = Prompt.ask("[cyan]API key[/cyan]", password=True)
+        if _refused(api_key):
+            return {}
+        model = Prompt.ask("[cyan]Model name[/cyan]", default="gpt-4o")
+        if not base_url or not api_key:
+            rprint("[yellow]Base URL and API key are both required.[/yellow]")
+            return {}
+        return {"provider": "openai_compat", "api_key": api_key, "base_url": base_url,
+                "model": model}
+
+    if choice == "6":
+        console.print()
+        base_url = Prompt.ask("[cyan]Base URL (Anthropic Messages API)[/cyan]",
+                              default="http://localhost:8000")
+        api_key = Prompt.ask("[cyan]API key (or any placeholder)[/cyan]", password=True)
+        if _refused(api_key):
+            return {}
+        if not base_url or not api_key:
+            rprint("[yellow]Base URL and API key are both required.[/yellow]")
+            return {}
+        return {"provider": "anthropic_compat", "api_key": api_key, "base_url": base_url}
+
+    if choice == "3":
+        console.print()
+        api_key = Prompt.ask("[cyan]Paste your OpenAI API key (hidden)[/cyan]", password=True)
+        if not api_key.strip() or _refused(api_key):
+            return {}
+        return {"provider": "openai", "api_key": api_key.strip()}
+
+    if choice == "7":
+        from hyperclaw import xai
+        console.print()
+        api_key = Prompt.ask("[cyan]Paste your xAI API key (hidden)[/cyan]", password=True)
+        if not api_key.strip() or _refused(api_key):
+            return {}
+        return {"provider": "xai", "api_key": api_key.strip(), "model": xai.DEFAULT_MODEL}
+
+    # Anthropic
+    console.print()
+    api_key = Prompt.ask("[cyan]Paste your Anthropic API key (hidden)[/cyan]", password=True)
+    if _refused(api_key):
+        return {}
+    if not api_key.startswith("sk-ant-"):
+        rprint("[yellow]That doesn't look right — Anthropic keys start with 'sk-ant-'.[/yellow]")
+        return {}
+    return {"provider": "anthropic", "api_key": api_key}
+
+
+OWN_NOTE = ("[dim]Your own providers are labelled as yours, and stay chat-only until "
+            "that model passes HyperAgents' tool qualification.[/dim]")
+
+
+def _refused(key: str) -> bool:
+    """A RunPod-looking key is never accepted for any provider."""
+    from hyperclaw.model_policy import check_key
+    reason = check_key(key or "")
+    if reason:
+        _say(reason, style="yellow")
+    return bool(reason)
+
+
+def ask_consent(provider: str, model: str) -> bool:
+    """Exactly one plain line, then the owner's yes. Recorded (time, provider,
+    model) in the owner-only consent file; no consent, no switch."""
+    from hyperclaw.model_policy import consent_line, has_consent, record_consent
+    _say(consent_line(provider))
+    if has_consent(provider):
+        return True
+    if not Confirm.ask("[cyan]Continue?[/cyan]", default=False):
+        return False
+    record_consent(provider, model)
+    return True
+
+
+def _default_model(cfg: dict) -> str:
+    kind = cfg.get("provider", "")
+    if cfg.get("model"):
+        return cfg["model"]
+    try:
+        from hyperclaw.providers import ProviderRegistry
+        prov = ProviderRegistry.load().providers.get(kind)
+        if prov is not None:
+            return prov.model_for()
+    except Exception:  # noqa: BLE001
+        pass
+    return ""
+
+
+def setup_model() -> dict:
+    """Choose the model. HyperSpeed V2 is preselected (option 1). A
+    Hyper-deployed install has no provider menu: it shows the models on its
+    allowed list (V2 first) and asks for the Hyper access key. Choosing a
+    third-party model needs the owner's consent. Returns the provider config."""
+    from hyperclaw.deployment import is_hyper
+    time.sleep(0.3)
+    console.print()
+    if is_hyper():
+        from hyperclaw import hyperspeed, managed_config
+        _say("This install is Hyper-deployed: Hyper sets the models it can use.")
+        _say("Models on this install:")
+        for name in live_state.snapshot().allowed:
+            _say(f"  • {name}")
+        console.print()
+        if not managed_config.provider_allowed(hyperspeed.PROVIDER_NAME):
+            return {}
+        return {"provider": "hyperspeed", "api_key": ask_hyper_key()}
+
+    rprint("[white]Next, the [bold]model[/bold] I run on.[/white]")
+    console.print()
+    rprint("[cyan]  1. HyperSpeed V2 (recommended) — Hyper's own model. Chat-only for now. "
+           "Needs your Hyper access key.[/cyan]")
+    rprint("[cyan]  2. Your own provider: Anthropic API key[/cyan]")
+    rprint("[cyan]  3. Your own provider: OpenAI API key[/cyan]")
+    rprint("[cyan]  4. Your own provider: OpenAI-compatible endpoint (Azure, LiteLLM, vLLM...)[/cyan]")
+    rprint("[cyan]  5. Your own provider: AWS Bedrock[/cyan]")
+    rprint("[cyan]  6. Your own provider: Anthropic-compatible endpoint[/cyan]")
+    rprint("[cyan]  7. Your own provider: xAI API key (Grok)[/cyan]")
+    rprint(OWN_NOTE)
+    console.print()
+    choice = Prompt.ask("[cyan]Choose[/cyan]", choices=["1", "2", "3", "4", "5", "6", "7"],
+                        default="1")
+    if choice == "1":
+        console.print()
+        return {"provider": "hyperspeed", "api_key": ask_hyper_key()}
+    cfg = _own_provider_prompt(choice)
+    if cfg.get("provider") and not ask_consent(cfg["provider"], _default_model(cfg)):
+        _say("Nothing was switched: HyperSpeed V2 stays the model.")
+        console.print()
+        return {"provider": "hyperspeed", "api_key": ask_hyper_key()}
+    return cfg
+
+
+def offer_own_provider() -> dict:
+    """Optional, after V2: add the customer's own Anthropic/OpenAI key too."""
+    from hyperclaw.deployment import is_hyper
+    if is_hyper():
+        return {}
+    console.print()
+    if not Confirm.ask("[cyan]Add your own provider as well? (optional — e.g. your "
+                       "Anthropic or OpenAI key)[/cyan]", default=False):
+        return {}
+    rprint("[cyan]  2. Anthropic API key[/cyan]")
+    rprint("[cyan]  3. OpenAI API key[/cyan]")
+    rprint("[cyan]  4. OpenAI-compatible endpoint[/cyan]")
+    rprint("[cyan]  7. xAI API key (Grok)[/cyan]")
+    rprint(OWN_NOTE)
+    choice = Prompt.ask("[cyan]Choose[/cyan]", choices=["2", "3", "4", "7"], default="2")
+    return _own_provider_prompt(choice)
+
+
+def setup_database():
+    """Guide through database setup."""
+    console.print()
+    rprint("[white]Next: [bold]memory[/bold].[/white]")
+    time.sleep(0.2)
+    _say("Your memory is kept in files on this computer. Optionally, you can keep it in a "
+         "PostgreSQL database of your own instead.")
+    console.print()
+
+    rprint("[white]One way: a [bold]Supabase[/bold] project[/white]")
+    rprint("[cyan]  1. Go to [link=https://supabase.com]supabase.com[/link][/cyan]")
+    rprint("[cyan]  2. Create a project[/cyan]")
+    rprint("[cyan]  3. Copy the connection string from Settings > Database[/cyan]")
+    console.print()
+
+    setup_db = Confirm.ask("[cyan]Want to set up a database now?[/cyan]", default=False)
+
+    if not setup_db:
+        rprint("\n[white]That's fine. You can add it later.[/white]")
+        _say("Memory stays on this computer.", dim=True)
+        return None
+
+    db_url = Prompt.ask("[cyan]Paste your database URL[/cyan]")
+    while "[YOUR-PASSWORD]" in db_url or "[YOUR-" in db_url:
+        rprint("[yellow]That URL still contains the [YOUR-PASSWORD] placeholder from "
+               "Supabase's template. Replace it with your actual database password "
+               "(Supabase: Settings > Database).[/yellow]")
+        db_url = Prompt.ask("[cyan]Paste your database URL (or press Enter to skip)[/cyan]", default="")
+        if not db_url:
+            rprint("[dim]Skipping database setup — you can add DATABASE_URL to ~/.hyperclaw/.env later.[/dim]")
+            return None
+    return db_url
+
+
+def setup_integrations():
+    """What is connected on this install, from live state only (truth rule)."""
+    console.print()
+    _say("Integrations", bold=True)
+    time.sleep(0.2)
+    for line in live_state.integrations_lines(_live()):
+        _say(line)
+
+
+def setup_telegram() -> bool:
+    """Optional chat-app step. Offered only where the install profile allows
+    it (managed config, docs/MODEL-POLICY.md); its text lives in
+    hyperclaw.telegram_pairing so this file names no integration itself."""
+    from hyperclaw import telegram_pairing
+    return telegram_pairing.onboarding_offer(
+        say=lambda text: rprint(text), confirm=Confirm.ask, prompt=Prompt.ask,
+        line=lambda text: console.print(text, markup=False))
+
+
+def write_config(user_name: str, ai_name: str, provider_cfg: dict, db_url: str | None,
+                 extra_provider: dict | None = None):
+    """Write the customer's config.json and .env (merged, never clobbered).
+
+    No persona file is written: there is no seeded persona (spec rule 1).
+    The persona grows only from preferences the customer sets or agrees to."""
+    from hyperclaw.provider_setup import HyperDeployedRefusal, save_provider
+    from hyperclaw.userconfig import env_update, root, update_config
+
+    hyperclaw_dir = root()
+    for _sub in ("", "memory", "memory/daily", "workspace", "workspace/context",
+                 "secrets", "logs", "config"):
+        (hyperclaw_dir / _sub).mkdir(parents=True, exist_ok=True)
+
+    update_config(user_name=user_name, ai_name=ai_name, version="1.0")
+
+    prov = provider_cfg.get("provider")
+    if prov:
+        try:
+            save_provider(provider_cfg, make_default=True)
+        except HyperDeployedRefusal as e:
+            rprint(f"[yellow]{e}[/yellow]")
+    if extra_provider and extra_provider.get("provider"):
+        try:
+            save_provider(extra_provider, make_default=False)
+        except HyperDeployedRefusal as e:
+            rprint(f"[yellow]{e}[/yellow]")
+
+    if db_url:
+        env_update({"DATABASE_URL": db_url})
+
+    rprint(f"\n[green]Created [bold]{ai_name}[/bold] at {hyperclaw_dir}[/green]")
+
+
+def final_message(user_name: str, ai_name: str, provider_cfg: dict):
+    """Wrap up the onboarding."""
+    console.print()
+    console.print(Panel.fit(
+        f"[bold white]You're all set, {user_name}.[/bold white]",
+        border_style="green"
+    ))
+    console.print()
+
+    if not provider_cfg.get("provider"):
+        rprint("[white]Once you have your API key:[/white]")
+        rprint("[cyan]  hyperclaw init[/cyan]       — Run setup again")
+        console.print()
+        return
+    if provider_cfg.get("provider") == "hyperspeed" and not provider_cfg.get("api_key"):
+        rprint("[white]Add your Hyper access key when you have it:[/white]")
+        rprint("[cyan]  hyperclaw provider hyper-key[/cyan]")
+        console.print()
+        return
+
+    rprint(f"[dim]{ai_name} is ready.[/dim]")
+    console.print()
+    time.sleep(1)
+
+    # Launch TUI directly
+    try:
+        from hyperclaw.tui import main as tui_main
+        tui_main()
+    except Exception as e:
+        rprint(f"[yellow]Couldn't start chat: {e}[/yellow]")
+        rprint("[white]Run [bold]hyperclaw start[/bold] to try again.[/white]")
+
+
+def run_onboarding():
+    """Main onboarding flow: name first, then the customer, then the model."""
+    from hyperclaw.deployment import is_hyper
+    console.clear()
+
+    warm_greeting()
+
+    ai_name = name_assistant()
+    user_name = get_name()
+    explain_system(user_name, ai_name)
+
+    provider_cfg = setup_model()
+    extra = {}
+    db_url = None
+
+    if provider_cfg.get("provider"):
+        if is_hyper():
+            # Hyper-deployed: no provider menu, no database step; local memory.
+            _say("Memory stays on this computer.", dim=True)
+        else:
+            if provider_cfg["provider"] == "hyperspeed":
+                extra = offer_own_provider()
+            db_url = setup_database()
+        setup_integrations()
+        setup_telegram()
+
+    write_config(user_name, ai_name, provider_cfg, db_url, extra)
+    final_message(user_name, ai_name, provider_cfg)
+
+
+if __name__ == "__main__":
+    run_onboarding()

core/__init__.py

@@ -0,0 +1 @@
+# HyperClaw Core — HyperCore Foundation

core/connectors/__init__.py

@@ -0,0 +1,119 @@
+"""
+HyperClaw Connectors.
+Integration connectors for social media, smart home, messaging, productivity, and infrastructure.
+"""
+
+from .social import (
+    SocialConnector,
+    TwitterConnector,
+    LinkedInConnector,
+    InstagramConnector,
+    FacebookConnector,
+    YouTubeConnector,
+    BlueskyConnector,
+    MastodonConnector,
+    RedditConnector,
+    TikTokConnector,
+)
+
+from .smarthome import (
+    SmartHomeConnector,
+    PhilipsHueConnector,
+    HomeAssistantConnector,
+    SonosConnector,
+    SpotifyConnector,
+    MQTTConnector,
+    SmartThingsConnector,
+)
+
+from .messaging import (
+    MessagingConnector,
+    GoogleChatConnector,
+    SignalConnector,
+    MatrixConnector,
+    iMessageConnector,
+    LINEConnector,
+    IRCConnector,
+    WeChatConnector,
+    MattermostConnector,
+)
+
+from .productivity import (
+    ProductivityConnector,
+    ObsidianConnector,
+    AppleNotesConnector,
+    AppleCalendarConnector,
+    GoogleSheetsConnector,
+    GoogleDocsConnector,
+    EvernoteConnector,
+    OneNoteConnector,
+    ClickUpConnector,
+    MondayConnector,
+)
+
+from .infrastructure import (
+    InfrastructureConnector,
+    DockerConnector,
+    AWSConnector,
+    GCPConnector,
+    AzureConnector,
+    TailscaleConnector,
+    SnowflakeConnector,
+    BigQueryConnector,
+    DatadogConnector,
+    PagerDutyConnector,
+)
+
+__all__ = [
+    # Social
+    "SocialConnector",
+    "TwitterConnector",
+    "LinkedInConnector",
+    "InstagramConnector",
+    "FacebookConnector",
+    "YouTubeConnector",
+    "BlueskyConnector",
+    "MastodonConnector",
+    "RedditConnector",
+    "TikTokConnector",
+    # Smart Home
+    "SmartHomeConnector",
+    "PhilipsHueConnector",
+    "HomeAssistantConnector",
+    "SonosConnector",
+    "SpotifyConnector",
+    "MQTTConnector",
+    "SmartThingsConnector",
+    # Messaging
+    "MessagingConnector",
+    "GoogleChatConnector",
+    "SignalConnector",
+    "MatrixConnector",
+    "iMessageConnector",
+    "LINEConnector",
+    "IRCConnector",
+    "WeChatConnector",
+    "MattermostConnector",
+    # Productivity
+    "ProductivityConnector",
+    "ObsidianConnector",
+    "AppleNotesConnector",
+    "AppleCalendarConnector",
+    "GoogleSheetsConnector",
+    "GoogleDocsConnector",
+    "EvernoteConnector",
+    "OneNoteConnector",
+    "ClickUpConnector",
+    "MondayConnector",
+    # Infrastructure
+    "InfrastructureConnector",
+    "DockerConnector",
+    "AWSConnector",
+    "GCPConnector",
+    "AzureConnector",
+    "TailscaleConnector",
+    "SnowflakeConnector",
+    "BigQueryConnector",
+    "DatadogConnector",
+    "PagerDutyConnector",
+]