import os
from typing import Dict, List, Optional
from cloudcode import SandboxSDK
# =====================
# CONFIGURATION SECTION
# =====================
# Fill in your values below
REPO_URL = "https://github.com/LMSystems-ai/cloud-coding" # GitHub repo to clone
BRANCH = None # Branch to checkout (None for default)
PROMPT = "what's this repo about?"
EDIT_FILES = [] # List of files to edit (relative to repo root) none means all are avalible
READONLY_FILES = [] # List of files to read but not edit
PUSH_BRANCH = "feature/ai-edits" # New branch to push changes to
COMMIT_MESSAGE = ""
INSTALL_CMD = None # e.g., 'pip install -r requirements.txt' or None
RUN_CMD = None # e.g., 'pytest' or None
CLOUD_CODE_API_KEY = os.environ.get("CLOUD_CODE_API_KEY") # Or hardcode your key
SANDBOX_TIMEOUT = 180 # 3 minutes
USER_ID = "user123" # Optional
GITHUB_USERNAME = "RVCA212" # Or hardcode your username
GITHUB_TOKEN = os.environ.get("GITHUB_TOKEN")
# =====================
class GitHubAgent:
def __init__(
self,
model: str = "gpt-4.1",
api_key: Optional[str] = None,
sandbox_timeout: int = 180,
user_id: Optional[str] = None
):
"""
Initialize the GitHubAgent:
- Set up the SandboxSDK with architect mode
- Store sandbox working directory
- Print sandbox ID and expiration
"""
# ensure API key is set
if not api_key:
api_key = os.environ.get("CLOUD_CODE_API_KEY")
self.sdk = SandboxSDK(
model="o4-mini", # Main (planner) model
editor_model="gpt-4.1-nano", # Editor model for implementing changes
architect_mode=True,
api_key=api_key,
sandbox_timeout=sandbox_timeout,
user_id=user_id,
)
self.repo_url = None
self.repo_name = None
self.working_dir = self.sdk.working_dir
sandbox_info = self.sdk.get_sandbox_info()
print(f"Sandbox created: {sandbox_info['sandbox_id']}")
print(f"Sandbox will expire at: {sandbox_info['end_at']}")
def clone_repository(self, repo_url: str, branch: Optional[str] = None) -> bool:
"""
Clone a GitHub repository into the sandbox:
- Inject credentials if provided
- Configure git user/email
- Optionally checkout a specific branch
Returns True on success, False otherwise.
"""
# record repo URL and compute local repo name
self.repo_url = repo_url
self.repo_name = repo_url.split("/")[-1]
if self.repo_name.endswith(".git"):
self.repo_name = self.repo_name[:-4]
# Inject credentials into clone URL if provided
username = GITHUB_USERNAME
token = GITHUB_TOKEN
clone_url = repo_url
if username and token:
# Prepend credentials for HTTPS clone
proto, rest = repo_url.split("://", 1)
clone_url = f"{proto}://{username}:{token}@{rest}"
# Clone the repository using URL with credentials if available
clone_cmd = f"cd {self.working_dir} && git clone \"{clone_url}\""
result = self.sdk.run_command(clone_cmd)
if result["exit_code"] != 0:
print(f"Error cloning repository: {result['stderr']}")
return False
self.sdk.run_command(f"cd {self.working_dir}/{self.repo_name} && git config user.email 'github-agent@example.com'")
self.sdk.run_command(f"cd {self.working_dir}/{self.repo_name} && git config user.name 'GitHub Agent'")
if branch:
checkout_cmd = f"cd {self.working_dir}/{self.repo_name} && git checkout {branch}"
checkout_result = self.sdk.run_command(checkout_cmd)
if checkout_result["exit_code"] != 0:
print(f"Error checking out branch '{branch}': {checkout_result['stderr']}")
return False
print(f"Successfully cloned repository: {self.repo_name}")
return True
def run_code_task(self, prompt: str, files: List[str], readonly_files: Optional[List[str]] = None) -> Dict:
"""
Submit a coding task to the sandbox editor:
- Provide a natural-language prompt
- Specify editable files and optional read-only files
Returns the sandbox result dict containing success flag, diff, etc.
"""
# ensure a repo has been cloned
if not self.repo_name:
print("No repository has been cloned yet.")
return {"success": False, "error": "No repository cloned"}
full_file_paths = [os.path.join(self.working_dir, self.repo_name, f) for f in files]
full_readonly_paths = [os.path.join(self.working_dir, self.repo_name, f) for f in readonly_files] if readonly_files else []
result = self.sdk.sandbox_code(
prompt=prompt,
editable_files=full_file_paths,
readonly_files=full_readonly_paths
)
if result["success"]:
print("Coding task completed successfully.")
print("Changes made:")
print(result["diff"])
else:
print("Coding task failed or made no meaningful changes.")
return result
def create_branch_and_push(self, branch_name: str, commit_message: str = "Changes made by GitHub Agent", github_username: Optional[str] = None, github_token: Optional[str] = None) -> bool:
"""
Create a new git branch, stage and commit all changes,
then push to origin using provided GitHub credentials.
Returns True on success, False on any step failure.
"""
# ensure a repo has been cloned
if not self.repo_name:
print("No repository has been cloned yet.")
return False
repo_dir = os.path.join(self.working_dir, self.repo_name)
create_branch_cmd = f"cd {repo_dir} && git checkout -b {branch_name}"
branch_result = self.sdk.run_command(create_branch_cmd)
if branch_result["exit_code"] != 0:
print(f"Error creating branch: {branch_result['stderr']}")
return False
add_cmd = f"cd {repo_dir} && git add ."
add_result = self.sdk.run_command(add_cmd)
if add_result["exit_code"] != 0:
print(f"Error adding changes: {add_result['stderr']}")
return False
commit_cmd = f"cd {repo_dir} && git commit -m \"{commit_message}\""
commit_result = self.sdk.run_command(commit_cmd)
if commit_result["exit_code"] != 0 and "nothing to commit" not in commit_result["stderr"]:
print(f"Error committing changes: {commit_result['stderr']}")
return False
if not github_username:
github_username = "RVCA212"
if not github_token:
github_token = os.environ.get("GITHUB_TOKEN")
if not github_username or not github_token:
print("GitHub username/token not provided. Set GITHUB_USERNAME and GITHUB_TOKEN env vars or hardcode in config.")
return False
self.sdk.run_command(f"cd {repo_dir} && git config credential.helper 'store --file=/tmp/git-credentials'")
credential_url = f"https://{github_username}:{github_token}@github.com"
self.sdk.run_command(f"echo '{credential_url}' > /tmp/git-credentials")
push_cmd = f"cd {repo_dir} && git push -u origin {branch_name}"
push_result = self.sdk.run_command(push_cmd)
self.sdk.run_command("rm -f /tmp/git-credentials")
if push_result["exit_code"] != 0:
print(f"Error pushing to GitHub: {push_result['stderr']}")
return False
print(f"Successfully pushed changes to branch '{branch_name}'")
return True
def install_dependencies(self, command: str) -> Dict:
"""
Install dependencies by running the specified shell command
inside the cloned repository directory.
Returns the SDK run_command result dict.
"""
# ensure a repo has been cloned
if not self.repo_name:
print("No repository has been cloned yet.")
return {"exit_code": 1, "stdout": "", "stderr": "No repository cloned"}
repo_dir = os.path.join(self.working_dir, self.repo_name)
full_cmd = f"cd {repo_dir} && {command}"
return self.sdk.run_command(full_cmd)
def run_command_in_repo(self, command: str) -> Dict:
"""
Run an arbitrary shell command in the cloned repository directory.
Returns the SDK run_command result dict.
"""
# ensure a repo has been cloned
if not self.repo_name:
print("No repository has been cloned yet.")
return {"exit_code": 1, "stdout": "", "stderr": "No repository cloned"}
repo_dir = os.path.join(self.working_dir, self.repo_name)
full_cmd = f"cd {repo_dir} && {command}"
return self.sdk.run_command(full_cmd)
def extend_timeout(self, seconds: int = 600) -> None:
"""
Extend the sandbox lifetime by the given number of seconds
and print the new expiration time.
"""
# call SDK to increase timeout
self.sdk.extend_sandbox_timeout(seconds)
updated_info = self.sdk.get_sandbox_info()
print(f"Sandbox timeout extended. New expiration: {updated_info['end_at']}")
def cleanup(self) -> Dict:
"""
Terminate the sandbox and clean up all resources.
Returns the SDK kill_sandbox result dict.
"""
# kill the sandbox
return self.sdk.kill_sandbox()
def main():
"""
Orchestrator:
1. Clone the repository
2. Install dependencies (if specified)
3. Run arbitrary commands (if specified)
4. Run the coding/editing task
5. Create a new branch and push changes
6. Clean up the sandbox
"""
agent = GitHubAgent(
model="gpt-4.1",
api_key=CLOUD_CODE_API_KEY,
sandbox_timeout=SANDBOX_TIMEOUT,
user_id=USER_ID
)
try:
# Clone repository
if REPO_URL:
success = agent.clone_repository(REPO_URL, BRANCH)
if not success:
print("Failed to clone repository. Exiting.")
agent.cleanup()
return
# Install dependencies
if INSTALL_CMD:
print(f"Installing dependencies: {INSTALL_CMD}")
result = agent.install_dependencies(INSTALL_CMD)
if result["exit_code"] != 0:
print(f"Error installing dependencies: {result['stderr']}")
# Run command
if RUN_CMD:
print(f"Running command: {RUN_CMD}")
result = agent.run_command_in_repo(RUN_CMD)
print(f"Exit code: {result['exit_code']}")
print(f"Output: {result['stdout']}")
if result["stderr"]:
print(f"Errors: {result['stderr']}")
# Run coding task
if PROMPT and EDIT_FILES:
print(f"Running coding task: {PROMPT}")
agent.run_code_task(PROMPT, EDIT_FILES, READONLY_FILES)
# Push changes
if PUSH_BRANCH:
print(f"Pushing changes to branch: {PUSH_BRANCH}")
agent.create_branch_and_push(PUSH_BRANCH, COMMIT_MESSAGE, GITHUB_USERNAME, GITHUB_TOKEN)
finally:
print("Cleaning up sandbox...")
kill_result = agent.cleanup()
print(f"Sandbox termination: {kill_result['message']}")
print(f"Termination success: {kill_result['success']}")
if __name__ == "__main__":
main()
