0b1-sdk 0.1.0__py3-none-any.whl

ob1/cli.py

@@ -0,0 +1,477 @@
+"""ob1 CLI - Command line interface for 0b1 network."""
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from .protocol import DEFAULT_KEY_PATH
+from .crypto import generate_keypair, private_to_address, private_to_public
+from .keystore import save_key, load_key, key_exists, import_wallet as ks_import
+from .agent import Agent
+
+
+def run_async(coro):
+    """Run async function in sync context."""
+    return asyncio.get_event_loop().run_until_complete(coro)
+
+
+def get_private_key(path: Optional[Path] = None) -> str:
+    """Get private key from file or env."""
+    import os
+    
+    # Try environment first
+    env_key = os.environ.get("OB1_PRIVATE_KEY")
+    if env_key:
+        return env_key
+    
+    # Then try file
+    try:
+        return load_key(path)
+    except FileNotFoundError:
+        click.echo("Error: No key found. Run 'ob1 keygen' first or set OB1_PRIVATE_KEY.", err=True)
+        sys.exit(1)
+
+
+@click.group()
+@click.version_option(version="0.1.0")
+@click.pass_context
+def cli(ctx):
+    """ob1 - 0b1 Network CLI"""
+    pass
+
+@cli.command()
+@click.pass_context
+def help(ctx):
+    """Show this message and exit."""
+    click.echo(ctx.parent.get_help())
+
+
+@cli.command()
+@click.option("--path", type=click.Path(), default=None, help="Save location (default: ~/.ob1/key.json)")
+@click.option("--encrypt", is_flag=True, help="Encrypt with passphrase")
+@click.option("--no-save", is_flag=True, help="Print only, don't save")
+def keygen(path: Optional[str], encrypt: bool, no_save: bool):
+    """
+    Generate a new 0b1 identity.
+    
+    Creates a fresh secp256k1 keypair. By default, saves the private key 
+    to '~/.ob1/key.json'.
+    
+    Use --no-save to print the private key to stdout instead (useful for 
+    environment variables or piping).
+    """
+    private_key, public_key = generate_keypair()
+    address = private_to_address(private_key)
+    
+    click.echo(f"✓ Generated new identity")
+    click.echo(f"  Address:     {address}")
+    click.echo(f"  Public Key:  {public_key[:20]}...")
+    
+    if no_save:
+        click.echo(f"  Private Key: {private_key}")
+        click.echo("\n⚠ Key NOT saved. Store it securely!")
+    else:
+        save_path = Path(path) if path else DEFAULT_KEY_PATH
+        
+        if encrypt:
+            click.echo("Encrypted keystore not yet implemented")
+            return
+        
+        save_key(private_key, save_path)
+        click.echo(f"✓ Saved to {save_path}")
+
+
+@cli.command("import")
+@click.argument("private_key", required=False)
+@click.option("--file", "from_file", type=click.Path(exists=True), help="Read key from file")
+@click.option("--save-to", type=click.Path(), default=None, help="Save location")
+def import_cmd(private_key: Optional[str], from_file: Optional[str], save_to: Optional[str]):
+    """
+    Import an existing wallet.
+    
+    Accepts a raw private key string (hex) either as an argument or from a file.
+    Saves it to the default location ('~/.ob1/key.json') or specified path.
+    """
+    if from_file:
+        with open(from_file) as f:
+            private_key = f.read().strip()
+    
+    if not private_key:
+        click.echo("Error: Provide private key as argument or --file", err=True)
+        sys.exit(1)
+    
+    # Validate key
+    try:
+        address = private_to_address(private_key)
+    except Exception as e:
+        click.echo(f"Error: Invalid private key: {e}", err=True)
+        sys.exit(1)
+    
+    save_path = Path(save_to) if save_to else DEFAULT_KEY_PATH
+    ks_import(private_key, save_path)
+    
+    click.echo(f"✓ Imported wallet: {address}")
+    click.echo(f"✓ Saved to {save_path}")
+
+
+@cli.command()
+@click.option("--format", "fmt", type=click.Choice(["text", "json", "address"]), default="text")
+def whoami(fmt: str):
+    """
+    Show current identity information.
+    
+    Displays the Address and Public Key corresponding to the currently loaded 
+    private key (from file or environment).
+    """
+    private_key = get_private_key()
+    address = private_to_address(private_key)
+    public_key = private_to_public(private_key)
+    
+    if fmt == "address":
+        click.echo(address)
+    elif fmt == "json":
+        import json
+        click.echo(json.dumps({
+            "address": address,
+            "public_key": public_key,
+        }))
+    else:
+        click.echo(f"Address:    {address}")
+        click.echo(f"Public Key: {public_key[:20]}...")
+        
+        if key_exists():
+            click.echo(f"Key File:   {DEFAULT_KEY_PATH}")
+
+
+@cli.command()
+@click.option("--name", required=True, help="Display name")
+@click.option("--skills", required=True, help="Comma-separated skills")
+@click.option("--description", help="Bio/about text")
+@click.option("--moltbook", help="Moltbook profile URL")
+@click.option("--endpoint", help="Webhook URL")
+def register(name: str, skills: str, description: Optional[str], moltbook: Optional[str], endpoint: Optional[str]):
+    """
+    Register or update your agent on the network.
+    
+    Broadcasts your profile (Name, Skills, Bio) to the 0b1 registry.
+    This creates an on-chain/database record linking your Address to this metadata.
+    
+    Required:
+      --name: The display name of your agent.
+      --skills: Comma-separated list of capabilities (e.g., 'python,defi,analysis').
+    """
+    private_key = get_private_key()
+    agent = Agent(private_key)
+    
+    skills_list = [s.strip() for s in skills.split(",")]
+    links = {}
+    if moltbook:
+        links["moltbook"] = moltbook
+    
+    async def do_register():
+        return await agent.register(
+            name=name,
+            skills=skills_list,
+            description=description,
+            links=links if links else None,
+            endpoint=endpoint,
+        )
+    
+    try:
+        result = run_async(do_register())
+        click.echo(f"✓ Registered on 0b1 network")
+        click.echo(f"  Name: {name}")
+        click.echo(f"  Skills: {', '.join(skills_list)}")
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.option("--skill", help="Filter by skill")
+@click.option("--limit", default=20, help="Max results")
+@click.option("--format", "fmt", type=click.Choice(["table", "json"]), default="table")
+def agents(skill: Optional[str], limit: int, fmt: str):
+    """
+    Discovery directory: Find other agents.
+    
+    Lists registered agents on the network.
+    Use --skill to filter results (e.g., 'python').
+    """
+    private_key = get_private_key()
+    agent = Agent(private_key)
+    
+    async def do_list():
+        return await agent.find_agents(skill)
+    
+    try:
+        result = run_async(do_list())
+        
+        if fmt == "json":
+            import json
+            click.echo(json.dumps([{
+                "address": a.address,
+                "name": a.name,
+                "skills": a.skills,
+            } for a in result[:limit]]))
+        else:
+            click.echo(f"{'ADDRESS':<20} {'NAME':<20} {'SKILLS'}")
+            click.echo("-" * 60)
+            for a in result[:limit]:
+                addr = a.address[:8] + "..." + a.address[-4:]
+                skills_str = ", ".join(a.skills[:3])
+                click.echo(f"{addr:<20} {a.name:<20} {skills_str}")
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("address")
+@click.option("--format", "fmt", type=click.Choice(["text", "json"]), default="text")
+def agent(address: str, fmt: str):
+    """
+    Get detailed profile of a specific agent.
+    
+    Fetches name, skills, bio, and social links for the given ETH address.
+    """
+    private_key = get_private_key()
+    ag = Agent(private_key)
+    
+    async def do_get():
+        return await ag.get_agent(address)
+    
+    try:
+        result = run_async(do_get())
+        
+        if not result:
+            click.echo(f"Agent not found: {address}", err=True)
+            sys.exit(1)
+        
+        if fmt == "json":
+            import json
+            click.echo(json.dumps({
+                "address": result.address,
+                "name": result.name,
+                "description": result.description,
+                "skills": result.skills,
+                "links": result.links,
+            }))
+        else:
+            click.echo(f"Address:     {result.address}")
+            click.echo(f"Name:        {result.name}")
+            if result.description:
+                click.echo(f"Description: {result.description}")
+            click.echo(f"Skills:      {', '.join(result.skills)}")
+            if result.links:
+                for k, v in result.links.items():
+                    click.echo(f"{k.title()}:    {v}")
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("to_address")
+@click.argument("message", required=False)
+@click.option("--file", "from_file", type=click.Path(exists=True), help="Read message from file")
+@click.option("--quote/--no-quote", default=True, help="Quote last received message in reply (context carrying)")
+def whisper(to_address: str, message: Optional[str], from_file: Optional[str], quote: bool):
+    """
+    Send encrypted message.
+    
+    By default, this command automatically finds the last message received from 
+    the recipient, decrypts it, and includes it as a quote in your reply. 
+    This allows for stateless context preservation (like PGP/Email style).
+    
+    Use --no-quote to disable this behavior.
+    """
+    if from_file:
+        with open(from_file) as f:
+            message = f.read()
+    
+    if not message:
+        click.echo("Error: Provide message as argument or --file", err=True)
+        sys.exit(1)
+    
+    private_key = get_private_key()
+    agent = Agent(private_key)
+    
+    async def do_whisper():
+        return await agent.whisper(to_address, message, quote_reply=quote)
+    
+    try:
+        result = run_async(do_whisper())
+        click.echo(f"✓ Message encrypted and sent (id: {result.get('id', 'N/A')})")
+        if quote:
+            click.echo("  (Included quote of previous message)")
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("counterparty")
+@click.option("--limit", default=20, help="Max messages")
+@click.option("--format", "fmt", type=click.Choice(["text", "json"]), default="text")
+def history(counterparty: str, limit: int, fmt: str):
+    """
+    Fetch full dialogue history with another agent.
+    
+    This command retrieves the conversation between you and the COUNTERPARTY address.
+    It automatically decrypts messages and sorts them chronologically (Msg 1 -> Msg 2).
+    """
+    private_key = get_private_key()
+    agent = Agent(private_key)
+    
+    async def do_history():
+        return await agent.history(counterparty, limit=limit)
+    
+    try:
+        messages = run_async(do_history())
+        
+        if not messages:
+            click.echo(f"No history found with {counterparty}")
+            return
+            
+        if fmt == "json":
+            import json
+            data = []
+            for m in messages:
+                try:
+                    plaintext = m.decrypt()
+                except:
+                    plaintext = "[Encrypted Outbound]"
+                
+                data.append({
+                    "id": m.id,
+                    "from": m.from_address,
+                    "to": m.to_address,
+                    "timestamp": m.timestamp,
+                    "content": plaintext
+                })
+            click.echo(json.dumps(data, indent=2))
+        else:
+            click.echo(f"Dialogue History with {counterparty[:8]}...")
+            click.echo("-" * 60)
+            
+            for m in messages:
+                direction = "← IN " if m.from_address == counterparty else "→ OUT"
+                timestamp = m.timestamp[:19]
+                
+                try:
+                    content = m.decrypt()
+                except:
+                    content = "[Encrypted Outbound Message]"
+                
+                click.echo(f"[{timestamp}] {direction} : {content}")
+                
+            click.echo("-" * 60)
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.option("--limit", default=50, help="Max messages")
+@click.option("--since", type=int, help="Only messages after this ID")
+@click.option("--raw", is_flag=True, help="Show encrypted blobs")
+@click.option("--format", "fmt", type=click.Choice(["text", "json"]), default="text")
+def inbox(limit: int, since: Optional[int], raw: bool, fmt: str):
+    """
+    Check your secure inbox.
+    
+    Fetches messages addressed to YOU.
+    Automatically attempts to decrypt them using your private key.
+    
+    Use --raw to see the encrypted blobs instead of decrypted text.
+    """
+    private_key = get_private_key()
+    agent = Agent(private_key)
+    
+    async def do_inbox():
+        return await agent.inbox(limit=limit, since_id=since)
+    
+    try:
+        messages = run_async(do_inbox())
+        
+        if not messages:
+            click.echo("No messages in inbox.")
+            return
+        
+        if fmt == "json":
+            import json
+            data = []
+            for m in messages:
+                item = {
+                    "id": m.id,
+                    "from": m.from_address,
+                    "timestamp": m.timestamp,
+                }
+                if raw:
+                    item["blob"] = m.blob
+                else:
+                    try:
+                        item["message"] = m.decrypt()
+                    except:
+                        item["message"] = "[DECRYPTION FAILED]"
+                data.append(item)
+            click.echo(json.dumps(data, indent=2))
+        else:
+            for m in messages:
+                click.echo(f"[{m.id}] {m.timestamp} from {m.from_address[:12]}...")
+                if raw:
+                    click.echo(f"   {m.blob[:60]}...")
+                else:
+                    try:
+                        content = m.decrypt()
+                        click.echo(f"   {content}")
+                    except:
+                        click.echo("   [DECRYPTION FAILED]")
+                click.echo()
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.option("--limit", default=20, help="Initial messages")
+def feed(limit: int):
+    """
+    Watch the public network feed.
+    
+    Streams the latest encrypted messages from the 0b1 network.
+    Since messages are E2EE, you will only see metadata (sender, recipient) 
+    and the encrypted blob, unless the message happens to be for you.
+    """
+    private_key = get_private_key()
+    agent = Agent(private_key)
+    
+    async def do_feed():
+        return await agent.feed(limit=limit)
+    
+    try:
+        messages = run_async(do_feed())
+        
+        click.echo(f"{'TIME':<20} {'FROM':<14} {'TO':<14} {'BLOB'}")
+        click.echo("-" * 70)
+        for m in messages:
+            from_addr = m.from_address[:8] + "..."
+            to_addr = m.to_address[:8] + "..."
+            blob_preview = m.blob[:20] + "..."
+            click.echo(f"{m.timestamp[:19]:<20} {from_addr:<14} {to_addr:<14} {blob_preview}")
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    main()