Daytona Workspace Agents

import asyncio
from praisonaiagents import Agent
from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig

managed = ManagedAgent(
    provider="local",
    config=ManagedConfig(model="gpt-4o-mini"),
    compute="daytona"
)

# Provision workspace with development tools
info = asyncio.run(managed.provision_compute(
    template="full-stack",  # Pre-configured development environment
    resources={"cpu": 2, "memory": 4096}  # 4GB memory
))

print(f"Workspace ID: {info.instance_id}")
print(f"Template: {info.template}")
print(f"Status: {info.status}")

# Create project structure that persists
create_project = asyncio.run(managed.execute_in_compute("""
mkdir -p myproject/src myproject/tests myproject/docs
cd myproject

# Create package.json
cat > package.json << 'EOF'
{
  "name": "myproject",
  "version": "1.0.0",
  "description": "A sample project",
  "main": "src/index.js",
  "scripts": {
    "test": "jest",
    "start": "node src/index.js"
  }
}
EOF

# Create main application file
cat > src/index.js << 'EOF'
console.log("Hello from Daytona workspace!");

function fibonacci(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

console.log("Fibonacci(10):", fibonacci(10));
EOF

# List project structure
find . -type f
"""))

print(create_project["stdout"])

# Development workflow with persistent state
workflow = asyncio.run(managed.execute_in_compute("""
cd myproject

# Install dependencies
npm install express jest

# Update package.json to include express
cat > src/index.js << 'EOF'
const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
    res.json({ message: 'Hello from Daytona workspace!', timestamp: new Date() });
});

app.get('/fibonacci/:n', (req, res) => {
    const n = parseInt(req.params.n);
    function fib(x) {
        if (x <= 1) return x;
        return fib(x - 1) + fib(x - 2);
    }
    res.json({ n: n, result: fib(n) });
});

if (require.main === module) {
    app.listen(port, () => {
        console.log(\`Server running at http://localhost:\${port}\`);
    });
}

module.exports = app;
EOF

# Create tests
cat > tests/index.test.js << 'EOF'
const request = require('supertest');
const app = require('../src/index');

describe('API Tests', () => {
    test('GET / should return message', async () => {
        const res = await request(app).get('/');
        expect(res.statusCode).toBe(200);
        expect(res.body.message).toContain('Hello');
    });

    test('GET /fibonacci/5 should return 5', async () => {
        const res = await request(app).get('/fibonacci/5');
        expect(res.statusCode).toBe(200);
        expect(res.body.result).toBe(5);
    });
});
EOF

# Install test dependencies
npm install supertest --save-dev

# Run tests
npm test
"""))

print(workflow["stdout"])

import asyncio
from praisonaiagents import Agent
from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig

managed = ManagedAgent(
    provider="local",
    config=ManagedConfig(
        model="gpt-4o-mini",
        system="You are a full-stack developer with access to a persistent Daytona workspace."
    ),
    compute="daytona"
)
agent = Agent(name="developer", backend=managed)

# Provision development workspace
info = asyncio.run(managed.provision_compute(template="full-stack"))

# LLM-driven development workflow
result = agent.start("""
Create a complete REST API for a todo application:
1. Set up a Node.js/Express project
2. Implement CRUD endpoints (GET, POST, PUT, DELETE)
3. Add in-memory storage
4. Include error handling
5. Write unit tests
6. Create documentation

The workspace should persist all files for future development.
""", stream=True)

import asyncio
from praisonaiagents import Agent
from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig

managed = ManagedAgent(
    provider="local",
    config=ManagedConfig(
        model="gpt-4o-mini",
        system="You are a full-stack developer using a Daytona workspace for development."
    ),
    compute="daytona"
)
agent = Agent(name="fullstack-dev", backend=managed)

# Full-stack workspace
info = asyncio.run(managed.provision_compute(
    template="full-stack",
    resources={"cpu": 4, "memory": 8192}  # 8GB for full development
))

# Build full application
result = agent.start("""
Create a full-stack web application:
1. Backend: Node.js/Express API with user authentication
2. Frontend: React application with login/dashboard
3. Database: JSON file-based storage
4. Testing: Unit and integration tests
5. Documentation: README with setup instructions

Structure the project professionally with separate folders.
""")

import asyncio
from praisonaiagents import Agent
from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig

managed = ManagedAgent(
    provider="local",
    config=ManagedConfig(model="gpt-4o-mini"),
    compute="daytona"
)
agent = Agent(name="devops-engineer", backend=managed)

# DevOps workspace with tools
info = asyncio.run(managed.provision_compute(template="devops"))

# Set up CI/CD pipeline
result = agent.start("""
Create a DevOps pipeline setup:
1. Dockerfile for containerization
2. GitHub Actions workflow
3. Docker Compose for local development
4. Makefile for common operations
5. Environment configuration files
6. Deployment scripts

Focus on best practices and maintainability.
""")

import asyncio
from praisonaiagents import Agent
from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig

managed = ManagedAgent(
    provider="local",
    config=ManagedConfig(
        model="gpt-4o-mini",
        system="You are working on a long-term project in a persistent workspace."
    ),
    compute="daytona"
)
agent = Agent(name="project-lead", backend=managed)

# Resume existing workspace (if available)
existing_workspace_id = "workspace-123"  # From previous session
if existing_workspace_id:
    managed.resume_session(existing_workspace_id)

# Continue development
result = agent.start("""
Continue working on the project:
1. Check current project status
2. Review recent changes
3. Plan next development phase
4. Implement new features
5. Update documentation

Use git to track all changes.
""")

import asyncio
from praisonaiagents import Agent
from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig

managed = ManagedAgent(
    provider="local",
    config=ManagedConfig(model="gpt-4o-mini"),
    compute="daytona"
)

# Large persistent workspace
info = asyncio.run(managed.provision_compute(
    template="full-stack",
    resources={"cpu": 4, "memory": 8192},
    storage=51200,  # 50GB storage
    timeout=0       # Persistent (no auto-shutdown)
))