┌─────────────────────────────────────────────────────────────┐
│                    Cloudflare Workers (Tier 1)              │
│                                                              │
│  ┌────────────────────────────────────────────────────┐    │
│  │  Telegram Agent / GitHub Agent                    │    │
│  │  • Handle webhooks                                 │    │
│  │  • Quick responses (chat, reviews)                 │    │
│  │  • Detect long-running tasks                       │    │
│  └────────────────────────────────────────────────────┘    │
│                          │                                   │
│                          │ Trigger                           │
│                          ▼                                   │
│  ┌────────────────────────────────────────────────────┐    │
│  │  Workflow Orchestrator                             │    │
│  │  • Detects heavy compute needs                     │    │
│  │  • Creates workflow task                           │    │
│  │  • Notifies agent server                           │    │
│  └────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────┘
                          │
                          │ HTTP/WebSocket
                          ▼
┌─────────────────────────────────────────────────────────────┐
│                 Agent Server (Tier 2)                       │
│                  Container / VPS / Fly.io                    │
│                                                              │
│  ┌────────────────────────────────────────────────────┐    │
│  │  Claude Agent SDK Application                      │    │
│  │  • Full Node.js runtime                            │    │
│  │  • Filesystem access                               │    │
│  │  • Shell command execution                         │    │
│  │  • Long-running processes                          │    │
│  │  • Persistent storage                              │    │
│  └────────────────────────────────────────────────────┘    │
│                                                              │
│  Tools Available:                                            │
│  ├─ bash: Full shell execution (no timeout limits)         │
│  ├─ git: Clone, commit, push operations                   │
│  ├─ gh: GitHub CLI for complex operations                  │
│  ├─ fs: File read/write/list operations                    │
│  ├─ code: Analysis and editing tools                       │
│  ├─ docker: Container operations (optional)                │
│  └─ custom: Domain-specific tools                          │
└─────────────────────────────────────────────────────────────┘

1. User sends message to Telegram bot
   → "Refactor this repo: https://github.com/user/repo"

2. Telegram Agent receives webhook
   → Analyzes request
   → Detects: needs full clone + analysis + code editing

3. Agent creates workflow task
   POST /api/workflows
   {
     "type": "refactor",
     "repoUrl": "https://github.com/user/repo",
     "instructions": "refactor for performance",
     "priority": "high"
   }

4. Agent Server receives task
   → Clones repository
   → Runs analysis tools
   → Makes code changes
   → Runs tests
   → Creates PR

5. Agent Server updates workflow status
   → Telegram Agent notified
   → User receives result

apps/agent-server/
├── src/
│   ├── agent/
│   │   ├── agent.ts          # Claude Agent SDK setup
│   │   ├── tools.ts          # Tool definitions
│   │   └── session.ts        # Session management
│   ├── tools/
│   │   ├── bash.ts           # Shell execution
│   │   ├── git.ts            # Git operations
│   │   ├── fs.ts             # Filesystem operations
│   │   └── gh.ts             # GitHub CLI wrapper
│   ├── api/
│   │   ├── routes.ts         # API endpoints
│   │   ├── workflows.ts      # Workflow handling
│   │   └── health.ts         # Health checks
│   ├── storage/
│   │   ├── sessions.ts       # Session persistence
│   │   └── workspaces.ts     # Workspace management
│   └── index.ts              # Server entry point
├── package.json
├── tsconfig.json
└── wrangler.toml             # Optional: Workers compatibility

{
  name: "bash",
  description: "Execute shell commands with full system access",
  inputSchema: {
    type: "object",
    properties: {
      command: { type: "string" },
      cwd: { type: "string" },
      timeout: { type: "number", default: 300000 } // 5 min default
    },
    required: ["command"]
  }
}

{
  name: "git",
  description: "Perform Git operations on repositories",
  inputSchema: {
    type: "object",
    properties: {
      operation: {
        type: "string",
        enum: ["clone", "status", "commit", "push", "pull", "log", "diff"]
      },
      repoUrl: { type: "string" },
      message: { type: "string" }
    },
    required: ["operation"]
  }
}

{
  name: "fs",
  description: "Read, write, and manipulate files",
  inputSchema: {
    type: "object",
    properties: {
      operation: {
        type: "string",
        enum: ["read", "write", "list", "delete", "move", "copy"]
      },
      path: { type: "string" },
      content: { type: "string" }
    },
    required: ["operation", "path"]
  }
}

// apps/telegram-bot/src/workflows.ts
 
interface WorkflowTask {
  id: string;
  type: 'refactor' | 'analysis' | 'test' | 'deploy' | 'custom';
  priority: 'low' | 'medium' | 'high';
  status: 'pending' | 'running' | 'completed' | 'failed';
  payload: Record<string, unknown>;
  createdAt: number;
  startedAt?: number;
  completedAt?: number;
  result?: unknown;
  error?: string;
}
 
async function createWorkflow(task: Omit<WorkflowTask, 'id' | 'createdAt' | 'status'>): Promise<string> {
  // Store in KV
  // Notify agent server via webhook
  // Return workflow ID
}
 
async function getWorkflowStatus(id: string): Promise<WorkflowTask | null> {
  // Fetch from KV or agent server
}

# fly.toml
app = "duyetbot-agent-server"
primary_region = "sjc"
 
[build]
  build_target = "start"
 
[env]
  NODE_ENV = "production"
  ANTHROPIC_API_KEY = ""
 
[[vm]]
  cpu_kind = "shared"
  cpus = 2
  memory_mb = 4096
 
[[mounts]]
  source = "agent_workspace"
  destination = "/workspace"

User: "Refactor this repo for better performance"

Telegram Agent:
1. Detects: needs full repo clone + analysis
2. Creates workflow task
3. Returns: "Started refactoring task (ID: abc123)"

Agent Server:
1. Receives workflow task
2. Clones repository to /workspace/abc123/
3. Runs code analysis tools
4. Identifies optimization opportunities
5. Makes code changes
6. Runs tests
7. Creates PR with changes
8. Updates workflow status

Telegram Agent:
1. Receives completion notification
2. Sends: "Refactoring complete! PR created: https://github.com/..."

User: "Run full test suite and fix failures"

Telegram Agent:
1. Creates workflow task
2. Returns: "Running tests (ID: def456)"

Agent Server:
1. Clones repository
2. Installs dependencies
3. Runs test suite (may take 10+ minutes)
4. Analyzes failures
5. Attempts fixes
6. Re-runs tests
7. Reports results

Telegram Agent:
1. Sends detailed test report
2. Includes fixes applied