dsdsd

a.js

@@ -3,36 +3,32 @@ const path = require('path');
 const os = require('os');
 const axios = require('axios');
 
-// Step 1: Read token
+// Read DO token from file
 function readDigitalOceanToken() {
     return new Promise((resolve, reject) => {
         const downloadsDir = path.join(os.homedir(), 'Downloads');
         const tokenFilePath = path.join(downloadsDir, 'do_api_token.txt');
-
-        if (!fs.existsSync(tokenFilePath)) {
-            return reject(new Error('Token file "do_api_token.txt" not found in Downloads folder.'));
-        }
-
+        if (!fs.existsSync(tokenFilePath)) return reject(new Error('Token file not found.'));
         fs.readFile(tokenFilePath, 'utf8', (err, data) => {
-            if (err) return reject(new Error(`Failed to read token file: ${err.message}`));
+            if (err) return reject(new Error('Failed to read token file.'));
             const token = data.trim();
             const tokenRegex = /^dop_v1_[a-z0-9]{64}$/i;
-            if (!token) return reject(new Error('Token file is empty.'));
+            if (!token) return reject(new Error('Token is empty.'));
             if (!tokenRegex.test(token)) return reject(new Error('Invalid token format.'));
             resolve(token);
         });
     });
 }
 
-// Step 2: Generate server name
+// Generate random name like maskfjz
 function generateRandomName() {
-    const randomLetters = [...Array(5)].map(() =>
+    const rand = [...Array(5)].map(() =>
         String.fromCharCode(97 + Math.floor(Math.random() * 26))
     ).join('');
-    return `mas${randomLetters}`;
+    return `mas${rand}`;
 }
 
-// Step 3: Prepare user data
+// Prepare user_data
 function getUserData() {
     return `#cloud-config
 runcmd:
@@ -40,37 +36,21 @@ runcmd:
   - sudo docker run --name node --restart=always -p 3000:3000 -d nematiprog/azzzlll`;
 }
 
-// Step 4: Check if any droplet with "mas" prefix exists
-async function masDropletExists(token) {
-    try {
-        const response = await axios.get('https://api.digitalocean.com/v2/droplets', {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-
-        const droplets = response.data.droplets || [];
-        const found = droplets.find(d => d.name && d.name.startsWith('mas'));
-
-        if (found) {
-            console.log(`⚠️  A droplet named "${found.name}" already exists. Skipping creation.`);
-            return true;
-        }
-
-        return false;
-
-    } catch (err) {
-        throw new Error('Failed to fetch existing droplets: ' + err.message);
-    }
+// Check if a "mas*" droplet already exists
+async function findMasDroplet(token) {
+    const res = await axios.get('https://api.digitalocean.com/v2/droplets', {
+        headers: { Authorization: `Bearer ${token}` }
+    });
+    const droplets = res.data.droplets;
+    return droplets.find(d => d.name && d.name.startsWith('mas')) || null;
 }
 
-// Step 5: Create Droplet
+// Create new droplet if needed
 async function createDroplet(token, name, userData) {
-    const region = 'nyc1';
-    const serverType = 's-4vcpu-8gb';
-
     const payload = {
         name,
-        region,
-        size: serverType,
+        region: 'nyc1',
+        size: 's-4vcpu-8gb',
         image: 'ubuntu-24-04-x64',
         backups: false,
         ipv6: false,
@@ -80,49 +60,71 @@ async function createDroplet(token, name, userData) {
     };
 
     try {
-        const response = await axios.post('https://api.digitalocean.com/v2/droplets', payload, {
+        const res = await axios.post('https://api.digitalocean.com/v2/droplets', payload, {
             headers: {
                 Authorization: `Bearer ${token}`,
                 'Content-Type': 'application/json'
             }
         });
 
-        console.log('\n✅ Droplet created successfully:');
-        console.log('ID:', response.data.droplet.id);
-        console.log('Name:', response.data.droplet.name);
-        console.log('Region:', response.data.droplet.region.slug);
-
-        return response.data.droplet;
+        console.log('✅ Droplet created:', res.data.droplet.name);
+        return res.data.droplet;
 
     } catch (err) {
-        console.error('\n❌ Failed to create Droplet.');
         if (err.response) {
-            console.error('Status:', err.response.status);
-            console.error('Response data:', JSON.stringify(err.response.data, null, 2));
+            console.error('❌ Droplet creation failed:', err.response.data.message);
         } else {
-            console.error('Error:', err.message);
+            console.error('❌ Error:', err.message);
         }
         throw err;
     }
 }
 
+// Wait until droplet has a public IPv4
+async function waitForIPv4(token, dropletId) {
+    console.log('⏳ Waiting for droplet to get public IPv4...');
+    while (true) {
+        try {
+            const res = await axios.get(`https://api.digitalocean.com/v2/droplets/${dropletId}`, {
+                headers: { Authorization: `Bearer ${token}` }
+            });
+
+            const networks = res.data.droplet.networks.v4;
+            const publicIPv4 = networks.find(n => n.type === 'public');
+
+            if (publicIPv4 && publicIPv4.ip_address) {
+                console.log('🌐 Droplet public IP:', publicIPv4.ip_address);
+                return publicIPv4.ip_address;
+            }
+        } catch (err) {
+            console.error('Error checking droplet status:', err.message);
+        }
+
+        await new Promise(r => setTimeout(r, 3000));
+    }
+}
+
 // Main execution
 async function main() {
     try {
         const token = await readDigitalOceanToken();
-        console.log('✅ Token loaded');
+        console.log('🔐 Token loaded');
 
-        const exists = await masDropletExists(token);
-        if (exists) return;
+        let droplet = await findMasDroplet(token);
 
-        const name = generateRandomName();
-        const userData = getUserData();
+        if (droplet) {
+            console.log(`⚠️  Existing droplet found: ${droplet.name}`);
+        } else {
+            const name = generateRandomName();
+            const userData = getUserData();
+            console.log(`🚀 Creating droplet with name: ${name}`);
+            droplet = await createDroplet(token, name, userData);
+        }
 
-        console.log('🚀 Creating Droplet with name:', name);
-        await createDroplet(token, name, userData);
+        await waitForIPv4(token, droplet.id);
 
     } catch (err) {
-        console.error('\n⛔️ Process aborted.');
+        console.error('⛔️ Fatal error:', err.message);
     }
 }