fix: agent_run param mismatch (send agent_name) + add GitHub push-update (3 inputs: repo name, token, username; --force-with-lease)

Fixes agent_run + adds GitHub push-update:

FIX: handle_agent_run param mismatch
- Backend declared 8 params (prompt, target_language, target_framework,
history_json, skills_json, search_enabled, image_url, agent_name)
but frontend POST body only sent 7 — Gradio raised
'needed: 8, got: 7'. Frontend now sends state.activeAgent as the
8th value, restoring agent_run for ALL prompts (the bug broke agent
mode entirely after the Custom Agents feature shipped).

FEAT: Push Update to GitHub (3 inputs only)
- New backend: code/tools/github.py::push_to_github(repo_name,
github_token, username, branch?, commit_message?, timeout?)
- Workflow: snapshot workspace → fresh git repo in temp dir →
git add -A + git commit → git push --force-with-lease
https://<user>:<token>@github.com/<owner>/<repo>.git <branch>.
- Falls back to plain push if --force-with-lease fails on a brand-new
empty repo (no refs to lease against).
- Token is scrubbed from error messages before being returned.
- New API: push_github(repo_name, github_token, username, ...)
- New UI: 'Push Update to GitHub' section in the Deploy tab with 3
required inputs (repo name, GitHub token, username) + an Advanced
<details> for branch/commit_message.
- Updated README.md and CLAUDE.md with new feature docs.

CLAUDE.md

@@ -176,6 +176,7 @@ and any hard rules.
 | `set_active_agent(name)` | Set/clear the active agent for subsequent prompts |
 | `import_github(url, branch, subdir, target_subdir, depth, timeout)` | Clone a GitHub repo into the workspace (shallow, heavy dirs stripped) |
 | `github_url_examples()` | Return accepted GitHub URL formats |
+| `push_github(repo_name, github_token, username, branch?, commit_message?, timeout?)` | Snapshot workspace → commit → push to a GitHub repo |
 
 The `agent_run` endpoint also intercepts `/agent use|reset|delete|list` and
 dispatches them directly to the agents module, bypassing the model entirely
@@ -220,6 +221,50 @@ The slash command (defined in `code/commands/builtins/github.md`) instructs
 the agent to invoke `import_github_repo` via bash, then list the top-level
 files and suggest next steps based on what was imported.
 
+## GitHub Push
+
+Push the current workspace back to a GitHub repo as a commit. Only 3 inputs
+are required: repo name, GitHub token, username.
+
+### How it works (`code/tools/github.py::push_to_github`)
+
+1. Snapshot the workspace via `snapshot_workspace()` (returns a
+   `{relative_path: content}` dict).
+2. Create a temp dir, `git init -b <branch>` inside it, write the snapshot
+   files in, `git add -A` + `git commit -m <message>`.
+3. Build a push URL of the form
+   `https://<username>:<token>@github.com/<owner>/<repo>.git` and run
+   `git push --force-with-lease <url> <branch>`.
+4. If `--force-with-lease` fails because the remote has no refs yet
+   (brand-new empty repo), retry with a plain `git push`.
+5. Delete the temp dir. The token is never logged; error messages scrub it
+   before being returned.
+
+### Why `--force-with-lease`
+
+SoniCoder treats the workspace as the source of truth. `--force-with-lease`
+replaces the remote tip with the workspace snapshot, but fails loudly (rather
+than silently clobbering) if someone else pushed commits in the meantime —
+because the temp repo has no reflog of the remote tip, the lease fails and
+the user is told to pull first.
+
+### UI
+
+Located in the **Deploy** tab, in a "Push Update to GitHub" section below the
+HuggingFace section. Only 3 fields are required: repo name, token, username.
+An "Advanced" `<details>` exposes optional `branch` and `commit_message`
+fields.
+
+### Security
+
+- Token is sent over HTTPS to the SoniCoder backend, used once for the push,
+  then dropped (not stored, not logged).
+- Error messages are scrubbed to remove the token before being returned.
+- The temp repo is deleted at the end of the call (context manager).
+- The local SoniCoder workspace is never turned into a git repo; the
+  workspace's `.git` (if any, e.g. after an import — though imports strip
+  `.git`) is never read.
+
 ## Skills
 
 | Skill | Description |

README.md

@@ -26,6 +26,7 @@ Inspired by [Claude Code](https://github.com/anthropics/claude-code), SoniCoder
 - ⚡ **Slash Commands** — `/commit`, `/review`, `/feature`, `/design`, `/explain`, `/test`, `/refactor`, `/skill`, `/agent`, `/github`, `/help`
 - 🧠 **Custom Agents** — describe a specialized agent in natural language and the AI generates a full persona (system prompt + tool whitelist + auto-loaded skills + temperature + max iterations). Activate via `/agent use <name>` or the Agents panel. Built-ins: `code-reviewer`, `test-writer`.
 - 📥 **GitHub Import** — paste any GitHub URL (or use `/github <url>`) to shallow-clone a repo into the workspace. Heavy dirs (`.git`, `node_modules`, `__pycache__`, `.venv`, `dist`) are stripped automatically. Supports `branch`, `subdir`, and `target_subdir` options.
+- 📦 **GitHub Push** — push the current workspace to any GitHub repo with just 3 inputs: repo name, GitHub API token, and username. Uses `--force-with-lease` so the workspace is the source of truth. Available in the Deploy tab.
 - 🪝 **Hooks System** — pre/post tool execution rules (block dangerous commands, warn on debug code/secrets)
 - 📁 **Sandboxed Workspace** — agent manipulates files in `./workspace/` (path-escape protected)
 - ✅ **Todo Lists** — track multi-step tasks Claude Code-style
@@ -131,6 +132,44 @@ SoniCoder can clone any public GitHub repository into the sandboxed workspace so
 
 **Security:** Only `github.com` URLs are accepted (HTTPS or SSH form). The clone happens in a temp directory and is then *copied* into the workspace — the upstream repo is never modified. Path-escape protection on `target_subdir` prevents writing outside the workspace.
 
+### GitHub Push (Update a GitHub repo)
+
+Push the current SoniCoder workspace back to a GitHub repo as a commit. Designed to be minimal — only **3 required inputs**:
+
+1. **Repository name** — either `my-app` (combined with your username) or `username/my-app`.
+2. **GitHub API token** — a Personal Access Token (PAT) with `repo` scope. [Create one here](https://github.com/settings/tokens/new?scopes=repo&description=SoniCoder).
+3. **Username** — the GitHub user (or org) that owns the repo and matches the token.
+
+**How to use:**
+
+1. Open the **Deploy** tab.
+2. Scroll to the **"Push Update to GitHub"** section (below the HuggingFace section).
+3. Fill in the 3 required fields (optionally expand "Advanced" to set `branch` or `commit message`).
+4. Click **📦 Push to GitHub**. A confirmation dialog shows the target repo + branch.
+5. On success, the status box shows the commit SHA, commit URL, and repo URL.
+
+**How it works (under the hood):**
+
+1. The workspace is snapshotted (via `snapshot_workspace()` — same function used for HuggingFace deploy).
+2. A fresh git repo is created in a temp dir; the snapshot files are written in.
+3. `git init -b <branch>` → `git add -A` → `git commit -m <message>`.
+4. `git push --force-with-lease https://<username>:<token>@github.com/<owner>/<repo>.git <branch>`.
+5. If `--force-with-lease` fails because the remote has no refs yet (brand-new empty repo), it retries with a plain `git push`.
+6. The temp dir is deleted. The token is never logged; error messages scrub it before being returned to the UI.
+
+**API endpoint:**
+
+| Endpoint | Description |
+|----------|-------------|
+| `push_github(repo_name, github_token, username, branch?, commit_message?, timeout?)` | Snapshot workspace → commit → push to GitHub |
+
+**Security notes:**
+
+- The token is sent over HTTPS to the SoniCoder backend, used once for the push, then dropped (not stored, not logged).
+- Error messages are scrubbed to remove the token before being returned to the frontend.
+- `--force-with-lease` is used instead of `--force` so the push fails loudly if the remote moved (rather than silently overwriting someone else's commits). For a brand-new empty repo, it falls back to a plain push.
+- The push happens from a temp dir — your local SoniCoder workspace is never turned into a git repo, and the workspace's `.git` (if any) is never read.
+
 ### Custom Agents
 
 Custom agents are AI-generated personas that layer on top of the base SoniCoder system prompt. Each agent defines:

code/server/routes.py

@@ -23,6 +23,7 @@ Defines all HTTP and API endpoints:
 - API todo_write   → update todo list
 - API import_github → clone a GitHub repo into the workspace
 - API github_url_examples → return accepted GitHub URL formats
+- API push_github → push the current workspace to a GitHub repo
 """
 
 from __future__ import annotations
@@ -1185,3 +1186,48 @@ def handle_github_url_examples() -> str:
     from code.tools.github import list_github_url_examples
     result = list_github_url_examples()
     yield json.dumps(result, default=str)
+
+
+@app.api(name="push_github", concurrency_limit=1)
+def handle_push_github(
+    repo_name: str,
+    github_token: str,
+    username: str,
+    branch: str = "main",
+    commit_message: str = "",
+    timeout: str = "120",
+) -> str:
+    """Push the current workspace to a GitHub repo.
+
+    Requires only 3 user inputs (repo_name, github_token, username) plus
+    optional branch / commit_message / timeout. The workspace is snapshotted
+    (via `snapshot_workspace`), written into a fresh git repo in a temp dir,
+    committed, and pushed to `https://github.com/<username>/<repo_name>.git`
+    using HTTPS basic auth with the token.
+
+    The push uses `--force-with-lease` so it replaces the remote tip with the
+    SoniCoder workspace contents. If the remote doesn't exist yet (no refs
+    to lease against), it retries with a plain push.
+
+    Yields
+    ------
+    JSON dict with keys: success, message, repo_full_name, branch,
+    commit_sha, commit_url, repo_url, files_pushed, error (on failure).
+    """
+    from code.tools.github import push_to_github
+
+    try:
+        timeout_int = int(timeout) if str(timeout).strip() else 120
+        timeout_int = max(10, min(600, timeout_int))
+    except (ValueError, TypeError):
+        timeout_int = 120
+
+    result = push_to_github(
+        repo_name=repo_name,
+        github_token=github_token,
+        username=username,
+        branch=branch or "main",
+        commit_message=commit_message or "",
+        timeout=timeout_int,
+    )
+    yield json.dumps(result, default=str)

code/tools/__init__.py

@@ -26,6 +26,7 @@ from code.tools.todos import (
 from code.tools.github import (
     import_github_repo,
     list_github_url_examples,
+    push_to_github,
 )
 
 __all__ = [
@@ -42,4 +43,5 @@ __all__ = [
     "todo_update",
     "import_github_repo",
     "list_github_url_examples",
+    "push_to_github",
 ]

code/tools/github.py

@@ -394,3 +394,227 @@ def list_github_url_examples() -> dict[str, Any]:
             "If a /tree/<branch>/<subdir> path is included, only that subdir is imported.",
         ],
     }
+
+
+# ─── Push workspace to GitHub ────────────────────────────────────────────
+
+
+def push_to_github(
+    repo_name: str,
+    github_token: str,
+    username: str,
+    branch: str = "main",
+    commit_message: str = "",
+    timeout: int = 120,
+) -> dict[str, Any]:
+    """Push the current SoniCoder workspace to a GitHub repo.
+
+    Workflow:
+    1. Snapshot the workspace (call `snapshot_workspace()`).
+    2. Create a fresh git repo in a temp dir, copy the files in.
+    3. `git commit -m <message>`.
+    4. `git push https://<token>@github.com/<username>/<repo>.git <branch>`.
+
+    If the remote repo already exists with history, the push uses
+    `--force-with-lease` so the new commit replaces the remote tip. This
+    matches the SoniCoder mental model: "the workspace IS the source of
+    truth; overwrite whatever's on GitHub with my latest".
+
+    Parameters
+    ----------
+    repo_name : str
+        Repo name. Either "repo" (combined with `username` as
+        `username/repo`) or "username/repo" (username arg then ignored).
+    github_token : str
+        GitHub Personal Access Token (PAT) with `repo` scope.
+    username : str
+        GitHub username (or org) to push as. Required.
+    branch : str
+        Target branch (default "main"). Will be created on push if missing.
+    commit_message : str
+        Commit message. Defaults to a timestamped message.
+    timeout : int
+        Per-git-command timeout in seconds (default 120).
+
+    Returns
+    -------
+    dict with keys:
+        success, message, repo_full_name, branch, commit_sha,
+        commit_url, repo_url, files_pushed, error (on failure)
+    """
+    import datetime
+    import subprocess
+
+    # ── Validate inputs ──────────────────────────────────────────────
+    repo_name = (repo_name or "").strip()
+    github_token = (github_token or "").strip()
+    username = (username or "").strip()
+    branch = (branch or "main").strip() or "main"
+    if not commit_message:
+        commit_message = (
+            f"Update from SoniCoder at "
+            f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+        )
+
+    if not repo_name:
+        return _gh_err("Repo name is required.")
+    if not github_token:
+        return _gh_err("GitHub token is required.")
+    if not username:
+        return _gh_err("Username (or org) is required.")
+
+    # Normalize repo_name into owner/repo
+    if "/" in repo_name:
+        owner, name = repo_name.split("/", 1)
+        owner = owner.strip() or username
+        name = name.strip()
+    else:
+        owner = username
+        name = repo_name
+
+    if not name:
+        return _gh_err(f"Invalid repo_name: {repo_name!r}")
+
+    repo_full_name = f"{owner}/{name}"
+
+    if not _git_available():
+        return _gh_err("`git` is not installed in this environment. Cannot push.")
+
+    # ── Snapshot workspace ───────────────────────────────────────────
+    from code.tools.fs import snapshot_workspace
+
+    files = snapshot_workspace()
+    if not files:
+        return _gh_err(
+            "Workspace is empty. Generate or import some code first."
+        )
+
+    # ── Set up a fresh git repo in temp dir ──────────────────────────
+    with tempfile.TemporaryDirectory(prefix="sonicoder_gh_push_") as tmp:
+        repo_dir = os.path.join(tmp, name)
+        os.makedirs(repo_dir, exist_ok=True)
+
+        def _run_git(args: list[str], cwd: str = repo_dir) -> tuple[int, str, str]:
+            try:
+                proc = subprocess.run(
+                    ["git", *args],
+                    cwd=cwd,
+                    capture_output=True,
+                    text=True,
+                    timeout=timeout,
+                )
+                return proc.returncode, proc.stdout, proc.stderr
+            except subprocess.TimeoutExpired:
+                return 124, "", f"git {' '.join(args)} timed out after {timeout}s"
+
+        # Init repo
+        rc, _, err = _run_git(["init", "-b", branch])
+        if rc != 0:
+            # Older git doesn't support -b; fall back
+            rc, _, err = _run_git(["init"])
+            if rc != 0:
+                return _gh_err(f"git init failed: {err}")
+            # Then checkout/create the branch
+            _run_git(["checkout", "-b", branch])
+
+        # Set committer identity (required for commit)
+        _run_git(["config", "user.email", f"{username}@users.noreply.github.com"])
+        _run_git(["config", "user.name", username])
+
+        # Write all snapshot files into the repo dir
+        for rel_path, content in files.items():
+            # Safety: skip absolute paths and parent-escape attempts
+            if os.path.isabs(rel_path) or rel_path.startswith(".."):
+                continue
+            target = os.path.join(repo_dir, rel_path)
+            os.makedirs(os.path.dirname(target) or repo_dir, exist_ok=True)
+            try:
+                with open(target, "w", encoding="utf-8") as f:
+                    f.write(content)
+            except (OSError, UnicodeEncodeError):
+                continue
+
+        # Stage everything
+        rc, _, err = _run_git(["add", "-A"])
+        if rc != 0:
+            return _gh_err(f"git add failed: {err}")
+
+        # Check if there's anything to commit
+        rc, out, _ = _run_git(["status", "--porcelain"])
+        has_changes = bool(out.strip())
+        if not has_changes:
+            return {
+                "success": True,
+                "message": "No changes to commit (workspace matches last commit).",
+                "repo_full_name": repo_full_name,
+                "branch": branch,
+                "commit_sha": None,
+                "commit_url": None,
+                "repo_url": f"https://github.com/{repo_full_name}",
+                "files_pushed": 0,
+            }
+
+        # Commit
+        rc, out, err = _run_git(["commit", "-m", commit_message])
+        if rc != 0:
+            return _gh_err(f"git commit failed: {err}")
+
+        # Get commit SHA
+        rc, sha, _ = _run_git(["rev-parse", "HEAD"])
+        commit_sha = sha.strip()
+
+        # Build the push URL with token embedded (HTTPS basic auth).
+        # Token is URL-safe enough for typical PATs (alphanumeric).
+        push_url = (
+            f"https://{username}:{github_token}@github.com/{repo_full_name}.git"
+        )
+
+        # Push with --force-with-lease so we don't silently overwrite
+        # someone else's commits if the remote moved.
+        rc, out, err = _run_git(
+            ["push", "--force-with-lease", push_url, branch]
+        )
+        if rc != 0:
+            # If --force-with-lease fails because the remote doesn't exist
+            # yet (no refs to lease against), retry with a plain push.
+            if "no matching references" in err.lower() or "delete" in err.lower():
+                rc, out, err = _run_git(["push", push_url, branch])
+            if rc != 0:
+                # Don't leak the token in the error
+                safe_err = err.replace(github_token, "***").replace(push_url, "https://github.com/{repo_full_name}.git")
+                return _gh_err(
+                    f"git push failed: {safe_err[:400]}. "
+                    "Check that the token has `repo` scope and the repo exists.",
+                    repo_full_name=repo_full_name,
+                    branch=branch,
+                    commit_sha=commit_sha,
+                )
+
+        # Count files pushed
+        rc, count_out, _ = _run_git(["ls-files"])
+        files_pushed = len([l for l in count_out.splitlines() if l.strip()])
+
+        return {
+            "success": True,
+            "message": (
+                f"Pushed {files_pushed} file(s) to {repo_full_name} "
+                f"on branch `{branch}` (commit {commit_sha[:8]})."
+            ),
+            "repo_full_name": repo_full_name,
+            "branch": branch,
+            "commit_sha": commit_sha,
+            "commit_url": f"https://github.com/{repo_full_name}/commit/{commit_sha}",
+            "repo_url": f"https://github.com/{repo_full_name}",
+            "files_pushed": files_pushed,
+        }
+
+
+def _gh_err(message: str, **extras: Any) -> dict[str, Any]:
+    """Build a standard error response for push_to_github."""
+    result: dict[str, Any] = {
+        "success": False,
+        "message": message,
+        "error": message,
+    }
+    result.update(extras)
+    return result

index.html

@@ -1418,6 +1418,55 @@ body.hide-thinking .think-block { display: none; }
             <div class="deploy-status" id="deploy-status"></div>
             <div class="project-files" id="project-files"></div>
           </div>
+
+          <!-- ─── GitHub Push Section ────────────────────────────────── -->
+          <div class="deploy-section" style="margin-top:14px;">
+            <div class="deploy-title" style="color:var(--cyan, #00d4ff);text-shadow:0 0 6px rgba(0,212,255,0.4);">&#128230; Push Update to GitHub</div>
+            <div class="deploy-hint" style="margin-bottom:10px;">
+              Snapshots the current workspace and pushes it as a commit to a
+              GitHub repo. Uses <code>--force-with-lease</code> so the latest
+              workspace contents overwrite the remote tip.
+            </div>
+
+            <!-- Only 3 required inputs -->
+            <div class="deploy-field">
+              <label for="gh-repo-name">1. Repository Name</label>
+              <input type="text" id="gh-repo-name" placeholder="my-app  (or username/my-app)" autocomplete="off">
+              <div class="deploy-hint">If you omit the owner prefix, your username is used.</div>
+            </div>
+
+            <div class="deploy-field">
+              <label for="gh-token">2. GitHub API Token</label>
+              <input type="password" id="gh-token" placeholder="ghp_xxxxxxxxxxxxxxxxxxxxx" autocomplete="off">
+              <div class="deploy-hint">
+                Needs <code>repo</code> scope.
+                <a href="https://github.com/settings/tokens/new?scopes=repo&description=SoniCoder" target="_blank" rel="noopener">Create a token &nearr;</a>
+              </div>
+            </div>
+
+            <div class="deploy-field">
+              <label for="gh-username">3. Username (for push)</label>
+              <input type="text" id="gh-username" placeholder="your-github-username" autocomplete="off">
+              <div class="deploy-hint">The GitHub user (or org) that owns the repo and matches the token.</div>
+            </div>
+
+            <!-- Optional advanced settings (collapsed) -->
+            <details style="margin-top:8px;">
+              <summary style="font-size:10px;color:var(--gray-dim);cursor:pointer;letter-spacing:1px;text-transform:uppercase;">Advanced (optional)</summary>
+              <div class="deploy-field" style="margin-top:8px;">
+                <label for="gh-branch">Branch</label>
+                <input type="text" id="gh-branch" placeholder="main" value="main" autocomplete="off">
+              </div>
+              <div class="deploy-field">
+                <label for="gh-commit-msg">Commit message</label>
+                <input type="text" id="gh-commit-msg" placeholder="Update from SoniCoder" autocomplete="off">
+                <div class="deploy-hint">If empty, a timestamped message is used.</div>
+              </div>
+            </details>
+
+            <button id="btn-push-github" onclick="pushToGithub()" style="margin-top:10px;">&#128230; Push to GitHub</button>
+            <div class="deploy-status" id="github-deploy-status"></div>
+          </div>
         </div>
       </div>
     </div>
@@ -2894,7 +2943,16 @@ async function sendMessageAgent(prompt) {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        data: [prompt, state.targetLanguage, framework, historyJSON, skillsJSON, state.searchEnabled ? 'true' : 'false', state.uploadedImageFileUrl || '']
+        data: [
+          prompt,
+          state.targetLanguage,
+          framework,
+          historyJSON,
+          skillsJSON,
+          state.searchEnabled ? 'true' : 'false',
+          state.uploadedImageFileUrl || '',
+          state.activeAgent || ''
+        ]
       })
     });
 
@@ -3630,6 +3688,135 @@ async function pushToHuggingFace() {
     btn.disabled = false;
   }
 }
+
+// ═══════════════════════════════════════════════════════
+// PUSH TO GITHUB (3 inputs: repo name, token, username)
+// ═══════════════════════════════════════════════════════
+
+async function pushToGithub() {
+  const repoNameEl = document.getElementById('gh-repo-name');
+  const tokenEl    = document.getElementById('gh-token');
+  const usernameEl = document.getElementById('gh-username');
+  const branchEl   = document.getElementById('gh-branch');
+  const msgEl      = document.getElementById('gh-commit-msg');
+  const statusEl   = document.getElementById('github-deploy-status');
+  const btn        = document.getElementById('btn-push-github');
+
+  if (!repoNameEl || !tokenEl || !usernameEl || !statusEl || !btn) return;
+
+  const repoName = repoNameEl.value.trim();
+  const token    = tokenEl.value.trim();
+  const username = usernameEl.value.trim();
+  const branch   = (branchEl && branchEl.value.trim()) || 'main';
+  const commitMsg = (msgEl && msgEl.value.trim()) || '';
+
+  // ── Validate the 3 required inputs ───────────────────────────────
+  if (!repoName) {
+    statusEl.className = 'deploy-status error';
+    statusEl.textContent = 'Please enter the repository name.';
+    statusEl.style.display = 'block';
+    repoNameEl.focus();
+    return;
+  }
+  if (!token) {
+    statusEl.className = 'deploy-status error';
+    statusEl.textContent = 'Please enter your GitHub API token.';
+    statusEl.style.display = 'block';
+    tokenEl.focus();
+    return;
+  }
+  if (!username) {
+    statusEl.className = 'deploy-status error';
+    statusEl.textContent = 'Please enter your GitHub username.';
+    statusEl.style.display = 'block';
+    usernameEl.focus();
+    return;
+  }
+
+  // Quick client-side token sanity check (server validates too)
+  if (token.length < 20) {
+    statusEl.className = 'deploy-status error';
+    statusEl.textContent = 'Token looks too short — expected a GitHub PAT (starts with ghp_, github_pat_, etc.).';
+    statusEl.style.display = 'block';
+    return;
+  }
+
+  // Confirm push — it overwrites the remote tip
+  const fullRepo = repoName.includes('/') ? repoName : `${username}/${repoName}`;
+  if (!confirm(
+    `Push workspace to github.com/${fullRepo} on branch "${branch}"?\n\n` +
+    `This will overwrite the remote tip (--force-with-lease).\n` +
+    `Token will be sent to the SoniCoder backend only (not stored).`
+  )) {
+    return;
+  }
+
+  // ── Disable + show working state ─────────────────────────────────
+  btn.disabled = true;
+  btn.textContent = '⏳ Pushing...';
+  statusEl.className = 'deploy-status working';
+  statusEl.textContent = `Pushing to github.com/${fullRepo} on "${branch}"... (this may take 10-60 seconds)`;
+  statusEl.style.display = 'block';
+
+  try {
+    const resp = await fetch('/gradio_api/call/push_github', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        data: [repoName, token, username, branch, commitMsg, '180']
+      })
+    });
+
+    if (!resp.ok) throw new Error(`API error: ${resp.status} ${resp.statusText}`);
+
+    const { event_id } = await resp.json();
+    const eventSource = new EventSource(`/gradio_api/call/push_github/${event_id}`);
+
+    eventSource.addEventListener('complete', (e) => {
+      try {
+        const dataArray = JSON.parse(e.data);
+        const result = JSON.parse(dataArray[0]);
+
+        if (result.success) {
+          statusEl.className = 'deploy-status success';
+          const sha = result.commit_sha ? ` (commit ${result.commit_sha.slice(0,8)})` : '';
+          const commitLink = result.commit_url
+            ? `<br><a href="${result.commit_url}" target="_blank" rel="noopener">view commit ${result.commit_sha ? result.commit_sha.slice(0,8) : ''} &nearr;</a>`
+            : '';
+          const repoLink = result.repo_url
+            ? `<br><a href="${result.repo_url}" target="_blank" rel="noopener">${result.repo_url} &nearr;</a>`
+            : '';
+          statusEl.innerHTML =
+            `✓ ${result.message}${sha}${commitLink}${repoLink}`;
+          addSystemMessage(`📦 Pushed ${result.files_pushed} file(s) to ${result.repo_full_name}.`);
+        } else {
+          statusEl.className = 'deploy-status error';
+          statusEl.textContent = `✗ ${result.message || result.error || 'Push failed.'}`;
+        }
+      } catch (err) {
+        statusEl.className = 'deploy-status error';
+        statusEl.textContent = `Parse error: ${err.message}`;
+      }
+      eventSource.close();
+      btn.disabled = false;
+      btn.textContent = '📦 Push to GitHub';
+    });
+
+    eventSource.addEventListener('error', (e) => {
+      statusEl.className = 'deploy-status error';
+      statusEl.textContent = `Push failed: ${e.data || 'Network error. Check console.'}`;
+      eventSource.close();
+      btn.disabled = false;
+      btn.textContent = '📦 Push to GitHub';
+    });
+
+  } catch (err) {
+    statusEl.className = 'deploy-status error';
+    statusEl.textContent = `Push failed: ${err.message}`;
+    btn.disabled = false;
+    btn.textContent = '📦 Push to GitHub';
+  }
+}
 </script>
 </body>
 </html>