claudforge 2.0.0__py3-none-any.whl

claudforge/__init__.py

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

claudforge/browser/launcher.py

@@ -0,0 +1,131 @@
+from playwright.sync_api import sync_playwright, Browser, Page
+from rich.console import Console
+
+console = Console()
+
+def launch_browser(p, headless: bool = False, connect_port: int = None, profile_path: str = None) -> tuple[any, Page]:
+    """Launch a fresh browser, a persistent session, or connect to an existing one."""
+    import random
+    
+    # Randomize viewport slightly to avoid "bot signatures"
+    width = random.randint(1280, 1920)
+    height = random.randint(720, 1080)
+
+    stealth_args = [
+        "--disable-blink-features=AutomationControlled",
+        "--no-sandbox",
+        "--disable-infobars",
+        f"--window-size={width},{height}",
+    ]
+    
+    if connect_port:
+        console.print(f"[bold cyan]🔗 Connecting to existing Chrome on port {connect_port}...[/bold cyan]")
+        try:
+            browser = p.chromium.connect_over_cdp(f"http://127.0.0.1:{connect_port}")
+            # Existing sessions are already "stealthy" because they are real processes
+            page = None
+            for context in browser.contexts:
+                for p_ in context.pages:
+                    if "claude.ai" in p_.url:
+                        page = p_
+                        console.print(f"[bold green]✅ Found existing Claude tab: '{page.title()}'[/bold green]")
+                        break
+                if page: break
+            
+            if not page:
+                page = browser.contexts[0].new_page()
+            return browser, page
+        except Exception as e:
+            if "Browser.setDownloadBehavior" in str(e) or "context management" in str(e):
+                raise RuntimeError(
+                    "Protocol Error: Your Chrome version is incompatible with direct CDP connection.\n"
+                    "FIX: Close Chrome and run with the --profile flag instead:\n"
+                    "claudforge upload --batch ... --profile \"/tmp/claudforge_debug\""
+                )
+            raise RuntimeError(f"Failed to connect to Chrome: {e}")
+    elif profile_path:
+        console.print(f"[bold cyan]🚀 Launching persistent Chrome session: {profile_path}[/bold cyan]")
+        context = p.chromium.launch_persistent_context(
+            profile_path,
+            headless=headless,
+            channel="chrome",
+            args=stealth_args,
+            no_viewport=True,
+            viewport={"width": width, "height": height}
+        )
+        page = context.pages[0] if context.pages else context.new_page()
+        return context, page
+    else:
+        console.print("[bold cyan]🚀 Launching fresh Chrome...[/bold cyan]")
+        browser = p.chromium.launch(headless=headless, channel="chrome", args=stealth_args)
+        context = browser.new_context(viewport={"width": width, "height": height})
+        page = context.new_page()
+        return browser, page
+
+def navigate_to_skills(page, console: Console):
+    """Navigate to the skills page and handle auth/Cloudflare."""
+    TARGET = "https://claude.ai/customize/skills"
+    
+    try:
+        page.goto(TARGET, wait_until="domcontentloaded", timeout=30000)
+    except Exception:
+        pass
+
+    # Handle Login
+    if "login" in page.url or "signin" in page.url:
+        console.print("\n[bold yellow]⚠️  Please log in manually in the browser window, then press Enter.[/bold yellow]")
+        input("   [Press Enter once logged in] ")
+        if TARGET not in page.url:
+            page.goto(TARGET, wait_until="networkidle")
+
+    # Handle Cloudflare
+    while "api/challenge_redirect" in page.url or "cloudflare" in page.content().lower() or "Just a moment" in page.title():
+        console.print("\n[bold red]🛡️  Cloudflare challenge detected![/bold red]")
+        console.print("   Please solve the challenge in the browser window.")
+        console.print("   The script will detect when you are through. (Or press Enter if page is ready)")
+        try:
+            # Wait for content or user to press enter
+            page.wait_for_selector("button:has-text('Add skill')", timeout=15000)
+            break
+        except Exception:
+            input("   [Press Enter once the Skills page has fully loaded] ")
+            if TARGET not in page.url:
+                page.goto(TARGET, wait_until="domcontentloaded")
+            break
+
+def get_existing_skills(page: Page) -> list[str]:
+    """Extract names of already uploaded skills from the settings page."""
+    try:
+        # Claude lists skills in a list-like structure. 
+        skills = []
+        # Wait a bit for the list to render
+        page.wait_for_timeout(2000)
+        
+        # 1. Primary: Look for elements in the flex list
+        elements = page.query_selector_all("div.flex.flex-col > div.flex.items-center.justify-between")
+        for el in elements:
+            text = el.inner_text().split('\n')[0]
+            if text and text not in ["Add skill", "Settings", "Skills"]:
+                skills.append(text.strip())
+        
+        # 2. Fallback: Search all H3s (often used for skill titles)
+        if not skills:
+            elements = page.query_selector_all("h3")
+            for el in elements:
+                t = el.inner_text().strip()
+                if t and t not in ["Add skill", "Settings", "Skills", "Customize Clause"]:
+                    skills.append(t)
+        
+        # 3. Last Resort: Any text near an 'Edit' button
+        if not skills:
+            elements = page.query_selector_all("button:has-text('Edit')")
+            for el in elements:
+                # Find the text in the same row/container
+                parent = el.evaluate_handle("node => node.closest('div.flex')")
+                if parent:
+                    t = parent.as_element().inner_text().split('\n')[0]
+                    if t: skills.append(t.strip())
+
+        return list(set([s for s in skills if s])) # Cleanup and deduplicate
+    except Exception:
+        return []

claudforge/cli.py

@@ -0,0 +1,257 @@
+import typer
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+from playwright.sync_api import sync_playwright
+
+from claudforge.browser.launcher import launch_browser, navigate_to_skills
+from claudforge.utils.zipper import zip_folder, cleanup_zips
+from claudforge.utils.yaml_parser import validate_skill_metadata, get_skill_md_path
+from claudforge.utils.history import load_history
+from claudforge.uploader.single import upload_skill
+from claudforge.uploader.batch import run_batch_upload, export_web_data
+
+app = typer.Typer(
+    help="ClaudForge ⚒️ - The missing CLI for Claude.ai Skills.",
+    add_completion=False,
+)
+console = Console()
+
+@app.command()
+def upload(
+    path: Path = typer.Argument(..., help="Path to a skill folder or batch directory", metavar="PATH"),
+    limit: Optional[int] = typer.Option(None, "--limit", help="Max skills to upload in batch mode"),
+    headless: bool = typer.Option(False, "--headless", help="Run browser in headless mode"),
+    connect: Optional[int] = typer.Option(None, "--connect", help="Connect to existing Chrome on port", show_default=False),
+    profile: Optional[str] = typer.Option(None, "--profile", help="Path to a persistent Chrome profile/data directory"),
+    keep_zips: bool = typer.Option(False, "--keep-zips", help="Keep generated zip files"),
+    force: bool = typer.Option(False, "--force", "-f", help="Ignore local history and force re-check/re-upload"),
+):
+    """Deploy a skill or a batch of skills to Claude.ai."""
+    target = path.expanduser().resolve()
+    if not target.exists():
+        console.print(f"[red]Error: Path '{target}' does not exist.[/red]")
+        raise typer.Exit(1)
+
+    # AUTO-DETECT MODE
+    is_single = (target / "SKILL.md").exists() or (target / "skill.md").exists()
+    
+    with sync_playwright() as p:
+        try:
+            browser, page = launch_browser(p, headless=headless, connect_port=connect, profile_path=profile)
+            navigate_to_skills(page, console)
+
+            if is_single:
+                ok, err = validate_skill_metadata(target)
+                if not ok:
+                    console.print(f"[red]Validation Error: {err}[/red]")
+                    raise typer.Exit(1)
+
+                zip_dir = target.parent / "_zips"
+                zip_dir.mkdir(exist_ok=True)
+                zp = zip_folder(target, zip_dir)
+
+                console.print(f"⬆️  Uploading [cyan]{target.name}[/cyan] ...", end="")
+                if upload_skill(page, zp, console, auto_replace=force):
+                    console.print(" [bold green]✅ Success[/bold green]")
+                else:
+                    console.print(" [bold red]❌ Failed[/bold red]")
+
+                if not keep_zips:
+                    cleanup_zips(zip_dir)
+            else:
+                # BATCH MODE
+                zip_dir = target / "_zips"
+                zip_dir.mkdir(exist_ok=True)
+                run_batch_upload(page, target, zip_dir, limit, keep_zips, console, force=force)
+                if not keep_zips:
+                    cleanup_zips(zip_dir)
+
+            browser.close()
+        except Exception as e:
+            console.print(f"[bold red]Fatal Error:[/bold red] {e}")
+            raise typer.Exit(1)
+
+@app.command()
+def status(
+    path: Path = typer.Argument(..., help="Path to the directory of skill folders", metavar="PATH")
+):
+    """Check the upload progress/status of a batch without launching a browser."""
+    batch_dir = path.expanduser().resolve()
+    if not batch_dir.is_dir():
+        console.print(f"[red]Error: '{batch_dir}' is not a directory.[/red]")
+        return
+
+    history = load_history(batch_dir)
+    # Only count folders that actually contain a SKILL.md
+    skill_folders = [d for d in batch_dir.iterdir() if d.is_dir() and (d / "SKILL.md").exists()]
+    
+    total = len(skill_folders)
+    done = len([f for f in skill_folders if f.name in history])
+    pending = total - done
+
+    console.print(f"\n⚒️  [bold cyan]Batch Project:[/bold cyan] {batch_dir.name}")
+    console.print(f"📁 Total SkillFolders: [bold]{total}[/bold]")
+    console.print(f"✅ Local History:     [bold green]{done}[/bold green]")
+    console.print(f"⏳ Pending Upload:    [bold yellow]{pending}[/bold yellow]")
+    
+    if total > 0:
+        percent = (done / total) * 100
+        console.print(f"📊 Completion:        [bold]{percent:.1f}%[/bold]\n")
+        
+    # Export data for the True UI website
+    export_web_data(batch_dir, history)
+
+@app.command()
+def validate(
+    path: Path = typer.Argument(..., help="Path to the skill folder", metavar="PATH")
+):
+    """Validate SKILL.md structure without deploying."""
+    folder = path.expanduser().resolve()
+    ok, err = validate_skill_metadata(folder)
+    if ok:
+        console.print(f"[bold green]✅ '{folder.name}' is valid and ready for upload.[/bold green]")
+    else:
+        console.print(f"[bold red]❌ Validation failed for '{folder.name}': {err}[/bold red]")
+
+@app.command()
+def init(name: str = typer.Option(..., "--name", help="Name of the new skill")):
+    """Scaffold a new Claude skill folder."""
+    folder = Path.cwd() / name
+    if folder.exists():
+        console.print(f"[red]Error: Folder '{name}' already exists.[/red]")
+        return
+    
+    folder.mkdir()
+    skill_md = folder / "SKILL.md"
+    skill_md.write_text(f"""---
+name: {name}
+description: A short description of what {name} does.
+---
+
+# {name}
+
+Describe your skill here.
+""")
+    console.print(f"[bold green]✅ Created skill scaffold in ./{name}/[/bold green]")
+    console.print(f"🚀 Edit {name}/SKILL.md, then run: [cyan]claudforge upload ./{name}[/cyan]")
+
+@app.command()
+def doctor():
+    """Check environment health (Chrome, Playwright, Python)."""
+    import sys
+    console.print(f"Python Version: [cyan]{sys.version.split()[0]}[/cyan]")
+    
+    try:
+        from playwright.sync_api import sync_playwright
+        console.print("Playwright: [green]Installed[/green]")
+    except ImportError:
+        console.print("Playwright: [red]Not Found[/red]")
+        
+    console.print("\n[dim]To fix environment issues, run:[/dim]")
+    console.print("[cyan]pip install -r requirements.txt && playwright install chrome[/cyan]")
+
+@app.command(name="list")
+def list_skills(
+    path: Path = typer.Argument(..., help="Path to the batch directory", metavar="PATH")
+):
+    """List all skills recorded in the local history."""
+    batch_dir = path.expanduser().resolve()
+    if not (batch_dir / ".claudforge_history").exists():
+        console.print(f"[yellow]No history found for '{batch_dir.name}'.[/yellow]")
+        return
+        
+    history = load_history(batch_dir)
+    
+    table = Table(title=f"Synced Skills: {batch_dir.name}", box=None)
+    table.add_column("#", justify="right", style="dim")
+    table.add_column("Skill Name", style="cyan")
+    
+    for i, name in enumerate(sorted(list(history)), 1):
+        table.add_row(str(i), name)
+    
+    console.print("\n", table)
+    console.print(f"\n[dim]Total: {len(history)} skills recorded.[/dim]")
+
+@app.command()
+def dashboard(path: Path = typer.Argument(..., help="Path to the batch directory", metavar="PATH")):
+    """Launch the real-time web dashboard to monitor progress."""
+    import subprocess
+    import sys
+    
+    batch_dir = path.expanduser().resolve()
+    if not batch_dir.is_dir():
+        console.print(f"[red]Error: '{batch_dir}' is not a directory.[/red]")
+        raise typer.Exit(1)
+        
+    dashboard_path = Path(__file__).parent / "dashboard" / "app.py"
+    
+    if not dashboard_path.exists():
+        console.print("[red]Error: Dashboard component not found.[/red]")
+        raise typer.Exit(1)
+    
+    console.print(f"\n[bold cyan]🚀 Launching ClaudForge Live Monitor...[/bold cyan]")
+    console.print(f"[dim]Tracking directory: {batch_dir}[/dim]")
+    console.print("[dim]Opening browser at http://localhost:8501[/dim]\n")
+    
+    try:
+        # Run streamlit as a module
+        subprocess.run([sys.executable, "-m", "streamlit", "run", str(dashboard_path), "--", str(batch_dir)])
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Dashboard stopped.[/yellow]")
+
+@app.command()
+def rollback(
+    path: Path = typer.Argument(..., help="Path to the batch directory", metavar="PATH"),
+    skill: str = typer.Argument(..., help="Name of the skill folder to rollback"),
+    profile: Optional[str] = typer.Option(None, "--profile", help="Chrome profile to use"),
+):
+    """Revert a skill to a previous version from the archive."""
+    from rich.prompt import IntPrompt
+    from claudforge.utils.archive import list_snapshots, get_snapshot_zip
+    
+    batch_dir = path.expanduser().resolve()
+    snapshots = list_snapshots(batch_dir, skill)
+    
+    if not snapshots:
+        console.print(f"[yellow]No archives found for '{skill}' in {batch_dir.name}.[/yellow]")
+        return
+        
+    table = Table(title=f"📜 Archive History: {skill}", box=None)
+    table.add_column("#", justify="right", style="dim")
+    table.add_column("Uploaded At", style="cyan")
+    table.add_column("Filename", style="dim")
+    
+    for i, (ts, filename) in enumerate(snapshots, 1):
+        table.add_row(str(i), ts, filename)
+        
+    console.print("\n", table)
+    
+    choice = IntPrompt.ask("\n[bold green]Select version to restore[/bold green]", choices=[str(i) for i in range(1, len(snapshots)+1)])
+    selected_ts, selected_file = snapshots[choice - 1]
+    
+    zip_path = get_snapshot_zip(batch_dir, skill, selected_file)
+    
+    console.print(f"\n[bold yellow]🕒 Preparing rollback to version {selected_ts}...[/bold yellow]")
+    
+    with sync_playwright() as p:
+        try:
+            # We use headless=False by default for rollback to ensure safety
+            browser, page = launch_browser(p, profile_path=profile)
+            navigate_to_skills(page, console)
+            
+            if upload_skill(page, zip_path, console, auto_replace=True):
+                console.print(f"\n[bold green]✅ Successfully rolled back '{skill}' to {selected_ts}![/bold green]")
+            else:
+                console.print(f"\n[bold red]❌ Rollback upload failed.[/bold red]")
+            
+            browser.close()
+        except Exception as e:
+            console.print(f"[bold red]Fatal Error during rollback:[/bold red] {e}")
+
+def main():
+    app()
+
+if __name__ == "__main__":
+    main()

claudforge/dashboard/app.py

@@ -0,0 +1,135 @@
+import streamlit as st
+import json
+import time
+from pathlib import Path
+import pandas as pd
+from datetime import datetime
+
+# --- CONFIG ---
+st.set_page_config(
+    page_title="ClaudForge Live ⚒️",
+    page_icon="⚒️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# --- THEME (Glassmorphism) ---
+st.markdown("""
+    <style>
+    .main {
+        background-color: #0E1117;
+    }
+    .stMetric {
+        background: rgba(255, 255, 255, 0.05);
+        padding: 20px;
+        border-radius: 15px;
+        border: 1px solid rgba(255, 255, 255, 0.1);
+        backdrop-filter: blur(10px);
+    }
+    .status-card {
+        background: linear-gradient(135deg, #1e1e2f 0%, #11111d 100%);
+        padding: 30px;
+        border-radius: 20px;
+        border-left: 5px solid #ff4b4b;
+        margin-bottom: 25px;
+    }
+    .highlight {
+        color: #ff4b4b;
+        font-weight: bold;
+    }
+    header {visibility: hidden;}
+    footer {visibility: hidden;}
+    .stDeployButton {display:none;}
+    /* Hide the running spinner */
+    [data-testid="stStatusWidget"] {
+        display: none;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# --- DATA LOADING ---
+def load_session(path: Path):
+    if not path.exists():
+        return None
+    try:
+        with open(path, 'r') as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+# --- UI LOGIC ---
+def run_app():
+    # Get path from CLI args passed to streamlit
+    import sys
+    # Extract path if passed after --
+    try:
+        idx = sys.argv.index("--")
+        batch_path_str = sys.argv[idx + 1]
+    except (ValueError, IndexError):
+        batch_path_str = "."
+
+    batch_path = Path(batch_path_str).resolve()
+    session_file = batch_path / ".claudforge_session.json"
+
+    st.title("ClaudForge Live Monitor ⚒️")
+    
+    placeholder = st.empty()
+
+    while True:
+        data = load_session(session_file)
+        
+        with placeholder.container():
+            if not data:
+                st.warning(f"Waiting for session data at {batch_path.name}...")
+                st.info("Start an upload in the terminal to see live progress.")
+            else:
+                # 1. METRICS ROW
+                col1, col2, col3, col4 = st.columns(4)
+                
+                total = data["total_folders"]
+                history = data["history_count"]
+                current_session_done = len(data["results"])
+                limit = data["limit"] or total
+                
+                global_progress = ((history + current_session_done) / total) * 100 if total > 0 else 0
+                session_progress = (current_session_done / limit) * 100 if limit > 0 else 0
+                
+                col1.metric("Global Progress", f"{global_progress:.1f}%", f"{history + current_session_done}/{total}")
+                col2.metric("Current Session", f"{session_progress:.1f}%", f"{current_session_done}/{limit}")
+                
+                # ETR Calculation
+                elapsed = time.time() - data["session_start"]
+                if current_session_done > 0:
+                    avg_time = elapsed / current_session_done
+                    remaining = (limit - current_session_done) * avg_time
+                    etr_min = int(remaining // 60)
+                    etr_sec = int(remaining % 60)
+                    col3.metric("ETR", f"{etr_min}m {etr_sec}s", f"Avg: {avg_time:.1f}s/skill")
+                else:
+                    col3.metric("ETR", "Calculating...")
+                
+                col4.metric("Status", data["status"])
+
+                # 2. ACTIVE UPLOAD
+                if data["status"] == "RUNNING" and data["current_skill"]:
+                    st.markdown(f"""
+                        <div class="status-card">
+                            <h3 style='margin:0'>🚀 Now Uploading</h3>
+                            <p style='font-size: 24px; color: #00d4ff; margin-top:10px;'>{data["current_skill"]}</p>
+                            <p style='font-size: 14px; opacity: 0.7;'>Processing skill {data["current_index"]} of session limit {limit}</p>
+                        </div>
+                    """, unsafe_allow_html=True)
+                elif data["status"] == "FINISHED":
+                    st.success("🎉 Batch Complete! All skills successfully processed.")
+
+                # 3. RESULTS TABLE
+                if data["results"]:
+                    st.subheader("Recent Activity")
+                    df = pd.DataFrame(data["results"], columns=["Skill", "Status", "Details"])
+                    # Reverse to show newest at top
+                    st.dataframe(df.iloc[::-1], width="stretch", hide_index=True)
+
+        time.sleep(1)
+
+if __name__ == "__main__":
+    run_app()