Update src/index.ts

src/index.ts

@@ -1,5 +1,5 @@
 import * as http from 'node:http';
-import { exec, spawn, ChildProcess } from 'node:child_process';
+import { exec, spawn } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -104,57 +104,113 @@ async function cloneOrPull(repoUrl: string, targetDir: string): Promise<void> {
 }
 
 // ============================================================
-// 🧠 READ EXPOSE PORT FROM RES1's Dockerfile
+// 🐳 DOCKER UTILITIES FOR RES1
 // ============================================================
-async function getExposedPort(versionDir: string): Promise<number> {
-  const dockerfilePath = path.join(versionDir, 'Dockerfile');
-  if (!fs.existsSync(dockerfilePath)) {
-    console.warn('⚠️ No Dockerfile found in Res1. Using default port 7000.');
-    return 7000;
-  }
-  const content = fs.readFileSync(dockerfilePath, 'utf-8');
-  const match = content.match(/EXPOSE\s+(\d+)/);
-  if (match && match[1]) {
-    const port = parseInt(match[1], 10);
-    console.log(`✅ Found EXPOSE port ${port} in Res1 Dockerfile`);
-    return port;
+function execDocker(cmd: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    exec(cmd, (error, stdout, stderr) => {
+      if (error) reject(stderr || error.message);
+      else resolve(stdout.trim());
+    });
+  });
+}
+
+async function buildAndRunRes1(
+  versionDir: string,
+  containerName: string,
+  portMapping: string // e.g., "7000:7000" or "2000:2000"
+): Promise<number> {
+  const imageTag = `oracus-${Date.now()}`;
+  console.log(`🐳 Building Docker image ${imageTag} from ${versionDir}...`);
+  await execDocker(`docker build -t ${imageTag} ${versionDir}`);
+
+  console.log(`🐳 Running container ${containerName} with port ${portMapping}...`);
+  await execDocker(
+    `docker run -d --name ${containerName} -p ${portMapping} ${imageTag}`
+  );
+
+  // Find the actual host port mapped
+  const inspect = await execDocker(
+    `docker inspect ${containerName} --format='{{range $p, $conf := .NetworkSettings.Ports}}{{(index $conf 0).HostPort}} {{end}}'`
+  );
+  const ports = inspect.trim().split(/\s+/);
+  if (ports.length === 0) throw new Error('No ports exposed');
+  const hostPort = parseInt(ports[0], 10);
+  console.log(`✅ Container running on host port ${hostPort}`);
+  return hostPort;
+}
+
+async function stopAndRemoveContainer(containerName: string): Promise<void> {
+  try {
+    await execDocker(`docker stop ${containerName}`);
+    await execDocker(`docker rm ${containerName}`);
+    console.log(`🧹 Removed container ${containerName}`);
+  } catch (e) {
+    console.warn(`⚠️ Could not remove container ${containerName}:`, e);
   }
-  console.warn('⚠️ No EXPOSE directive found. Using default port 7000.');
-  return 7000;
 }
 
 // ============================================================
-// 🤖 DEPLOY AGENT (subprocess, not Docker)
+// 🤖 DEPLOY AGENT (USING DOCKER)
 // ============================================================
-function deployAgent(versionDir: string, port: number): Promise<ChildProcess> {
-  return new Promise((resolve, reject) => {
-    console.log(`🚀 Starting agent on port ${port} from ${versionDir}...`);
-    exec(`npm install && npm run build`, { cwd: versionDir }, (err) => {
-      if (err) return reject(`Build failed: ${err.message}`);
-      const proc = spawn('npm', ['start'], {
-        cwd: versionDir,
-        env: { ...process.env, PORT: String(port) },
-        stdio: 'pipe'
-      });
-      proc.stdout.on('data', (data) => console.log(`[AGENT:${port}] ${data}`));
-      proc.stderr.on('data', (data) => console.error(`[AGENT ERR:${port}] ${data}`));
-      setTimeout(async () => {
-        try {
-          const res = await axios.get(`http://localhost:${port}/health`, { timeout: 3000 });
-          if (res.status === 200) {
-            console.log(`✅ Health check passed on port ${port}!`);
-            resolve(proc);
-          } else reject(`Health check failed on port ${port}`);
-        } catch (err: any) {
-          reject(`Health check error on port ${port}: ${err.message}`);
-        }
-      }, 8000);
-    });
-  });
+async function deployAgentWithDocker(
+  versionDir: string,
+  containerName: string,
+  port: number
+): Promise<number> {
+  // Res1's Dockerfile exposes ports; we map the same port internally
+  // but let Docker assign a random host port (-P) or we can map explicitly.
+  // Here we use explicit mapping: hostPort:containerPort
+  // Since Res1 listens on the port we give (via PORT env), we map that.
+  // But Res1's Dockerfile may have multiple EXPOSE; we'll use the first one.
+  // Simpler: just use -P (random host port) and inspect.
+  // But we need health check on that port.
+  // We'll build with PORT env set in the container.
+  // Actually, we can pass -e PORT=7000 during docker run.
+  // But Res1's code reads PORT env. So we set it.
+  const imageTag = `oracus-${Date.now()}`;
+  console.log(`🐳 Building Docker image ${imageTag} from ${versionDir}...`);
+  await execDocker(`docker build -t ${imageTag} ${versionDir}`);
+
+  console.log(`🐳 Running container ${containerName} with PORT=${port}...`);
+  // Run with -P to let Docker assign random host ports, but we also set PORT env.
+  await execDocker(
+    `docker run -d --name ${containerName} -P -e PORT=${port} ${imageTag}`
+  );
+
+  // Inspect to get mapped host port for the container's exposed port
+  const inspect = await execDocker(
+    `docker inspect ${containerName} --format='{{range $p, $conf := .NetworkSettings.Ports}}{{(index $conf 0).HostPort}} {{end}}'`
+  );
+  const ports = inspect.trim().split(/\s+/);
+  if (ports.length === 0) throw new Error('No ports exposed by container');
+  const hostPort = parseInt(ports[0], 10);
+  console.log(`✅ Container running on host port ${hostPort}`);
+
+  // Health check on hostPort
+  console.log(`⏳ Waiting for health check on port ${hostPort}...`);
+  let healthy = false;
+  for (let attempt = 0; attempt < 20; attempt++) {
+    try {
+      const res = await axios.get(`http://localhost:${hostPort}/health`, { timeout: 2000 });
+      if (res.status === 200) {
+        healthy = true;
+        break;
+      }
+    } catch (e) {
+      // ignore
+    }
+    await new Promise(r => setTimeout(r, 1000));
+  }
+  if (!healthy) {
+    throw new Error(`Health check failed on port ${hostPort}`);
+  }
+  console.log(`✅ Health check passed on port ${hostPort}`);
+  return hostPort;
 }
 
 // ============================================================
-// MEMORY COPY
+// MEMORY COPY (between version directories)
 // ============================================================
 function copyMemoryFolder(srcPath: string, dstPath: string): void {
   const srcMemory = path.join(srcPath, 'memory');
@@ -178,8 +234,7 @@ function loadFailedVersions(): string[] {
   try {
     if (fs.existsSync(FAILED_VERSIONS_FILE)) {
       const data = fs.readFileSync(FAILED_VERSIONS_FILE, 'utf-8');
-      const parsed = JSON.parse(data);
-      if (Array.isArray(parsed)) return parsed;
+      return JSON.parse(data);
     }
   } catch (e) {
     console.warn('⚠️ Failed to load failed-versions.json');
@@ -189,8 +244,7 @@ function loadFailedVersions(): string[] {
 
 function saveFailedVersion(sha: string): void {
   try {
-    let failed = loadFailedVersions();
-    failed = failed.filter(v => v !== sha);
+    let failed = loadFailedVersions().filter(v => v !== sha);
     failed.push(sha);
     if (failed.length > MAX_FAILED_VERSIONS) {
       failed = failed.slice(-MAX_FAILED_VERSIONS);
@@ -203,15 +257,13 @@ function saveFailedVersion(sha: string): void {
 }
 
 function isVersionFailed(sha: string): boolean {
-  const failed = loadFailedVersions();
-  return failed.includes(sha);
+  return loadFailedVersions().includes(sha);
 }
 
 function clearFailedVersion(sha: string): void {
   try {
-    const failed = loadFailedVersions();
-    const updated = failed.filter(v => v !== sha);
-    fs.writeFileSync(FAILED_VERSIONS_FILE, JSON.stringify(updated, null, 2));
+    const failed = loadFailedVersions().filter(v => v !== sha);
+    fs.writeFileSync(FAILED_VERSIONS_FILE, JSON.stringify(failed, null, 2));
     console.log(`🗑️ Failed version ${sha} removed from tracking list.`);
   } catch (e) {
     console.error('❌ Failed to clear failed version:', e);
@@ -221,14 +273,14 @@ function clearFailedVersion(sha: string): void {
 // ============================================================
 // STATE
 // ============================================================
-let prodProcess: ChildProcess | null = null;
+let prodContainerName: string | null = null;
 let prodVersionPath: string | null = null;
 let prodCommitSha: string | null = null;
-let prodPort: number | null = null;
+let prodHostPort: number | null = null;
 let isUpdating: boolean = false;
 
 // ============================================================
-// 🧠 MAIN UPDATE LOGIC
+// 🧠 MAIN UPDATE LOGIC (Docker-based)
 // ============================================================
 async function checkAndUpdate(): Promise<void> {
   if (isUpdating) {
@@ -237,10 +289,10 @@ async function checkAndUpdate(): Promise<void> {
   }
 
   isUpdating = true;
-  let testProcess: ChildProcess | null = null;
+  let testContainerName: string | null = null;
   let testVersionPath: string | null = null;
   let testCommitSha: string | null = null;
-  let testPort: number | null = null;
+  let testHostPort: number | null = null;
 
   try {
     console.log('🔍 Checking for updates...');
@@ -251,7 +303,6 @@ async function checkAndUpdate(): Promise<void> {
     console.log(`📌 Latest SHA: ${latestSha.substring(0, 7)}`);
     console.log(`📌 Current Prod SHA: ${prodCommitSha ? prodCommitSha.substring(0, 7) : 'none'}`);
 
-    // 1. New code?
     if (latestSha === prodCommitSha) {
       console.log('✅ No new code. Current version is already running.');
       if (prodCommitSha && isVersionFailed(prodCommitSha)) {
@@ -261,23 +312,18 @@ async function checkAndUpdate(): Promise<void> {
       return;
     }
 
-    // 2. Previously failed?
     if (isVersionFailed(latestSha)) {
       console.log(`⏳ Version ${latestSha.substring(0, 7)} is marked as FAILED. Waiting for a newer version.`);
       isUpdating = false;
       return;
     }
 
-    // 3. New version detected – clone and test
-    console.log(`🆕 New version: ${latestSha.substring(0, 7)}. Deploying test on dynamic port...`);
+    console.log(`🆕 New version: ${latestSha.substring(0, 7)}. Deploying test container on port 2000...`);
+
     testCommitSha = latestSha;
     testVersionPath = path.join(CONFIG.VERSIONS_DIR, `v2_${Date.now()}`);
     await cloneOrPull(CONFIG.RES1_REPO, testVersionPath);
 
-    // Read EXPOSE port from Res1 Dockerfile
-    testPort = await getExposedPort(testVersionPath);
-    console.log(`🔄 Test agent will run on port ${testPort}`);
-
     // Copy memory from production if exists
     if (prodVersionPath) {
       copyMemoryFolder(prodVersionPath, testVersionPath);
@@ -285,79 +331,71 @@ async function checkAndUpdate(): Promise<void> {
       console.log('⚠️ No previous version. Starting fresh without memory copy.');
     }
 
-    // Deploy test agent
-    testProcess = await deployAgent(testVersionPath, testPort);
-    console.log(`✅ Test agent passed health check on port ${testPort}!`);
-
-    // Stop test process (we'll promote it)
-    if (testProcess) {
-      console.log('🛑 Stopping test agent...');
-      testProcess.kill('SIGTERM');
-      await new Promise(resolve => setTimeout(resolve, 2000));
-      if (!testProcess.killed) testProcess.kill('SIGKILL');
-      testProcess = null;
+    // Deploy test container using Res1's Dockerfile, mapping internal 2000 to host
+    // But we use -P, so we don't need to specify host port; Docker assigns random.
+    // However, Res1's Dockerfile must have EXPOSE 2000. It does.
+    // We'll run with PORT=2000 env.
+    testContainerName = `oracus-test-${Date.now()}`;
+    testHostPort = await deployAgentWithDocker(testVersionPath, testContainerName, 2000);
+    console.log(`✅ Test container running on host port ${testHostPort} (internal 2000)`);
+
+    // Promote to production (port 7000)
+    console.log(`🚀 Promoting to production (internal port 7000)...`);
+
+    // Stop and remove test container
+    if (testContainerName) {
+      await stopAndRemoveContainer(testContainerName);
+      testContainerName = null;
     }
 
-    // 4. Promote to production
-    console.log(`🚀 Promoting to production on port ${testPort}...`);
-    const newProdProc = await deployAgent(testVersionPath, testPort);
-
-    // Stop old production
-    if (prodProcess) {
-      console.log('🛑 Stopping old production...');
-      prodProcess.kill('SIGTERM');
-      setTimeout(() => {
-        if (!prodProcess?.killed) prodProcess?.kill('SIGKILL');
-      }, 3000);
+    // Build and run production container with internal port 7000
+    const prodContainerNameNew = `oracus-prod-${Date.now()}`;
+    const prodHostPortNew = await deployAgentWithDocker(testVersionPath, prodContainerNameNew, 7000);
+    console.log(`✅ Production container running on host port ${prodHostPortNew} (internal 7000)`);
+
+    // Stop old production container
+    if (prodContainerName) {
+      await stopAndRemoveContainer(prodContainerName);
     }
 
     // Update state
-    prodProcess = newProdProc;
+    prodContainerName = prodContainerNameNew;
     prodVersionPath = testVersionPath;
     prodCommitSha = testCommitSha;
-    prodPort = testPort;
+    prodHostPort = prodHostPortNew;
     testVersionPath = null;
     testCommitSha = null;
-    testPort = null;
+    testHostPort = null;
 
     if (prodCommitSha && isVersionFailed(prodCommitSha)) {
       clearFailedVersion(prodCommitSha);
     }
 
-    console.log(`✅ Successfully deployed V2 (${latestSha.substring(0, 7)}) on port ${prodPort}`);
+    console.log(`✅ Successfully deployed V2 (${latestSha.substring(0, 7)}) on host port ${prodHostPort}`);
 
   } catch (error: any) {
     console.error('❌ Deployment failed:', error);
 
-    // Stop test process if running
-    if (testProcess) {
-      console.log('🛑 Stopping failed test agent...');
-      testProcess.kill('SIGTERM');
-      setTimeout(() => {
-        if (!testProcess?.killed) testProcess?.kill('SIGKILL');
-      }, 2000);
-      testProcess = null;
+    if (testContainerName) {
+      await stopAndRemoveContainer(testContainerName);
+      testContainerName = null;
     }
 
-    // Save failed version
     if (testCommitSha) {
       saveFailedVersion(testCommitSha);
     }
 
-    // Send email
     await sendEmail(
       'Deployment FAILED',
-      `Version: ${testCommitSha ? testCommitSha.substring(0, 7) : 'unknown'}\nError: ${error.message}\nPort ${prodPort || '?'} is unchanged.`
+      `Version: ${testCommitSha ? testCommitSha.substring(0, 7) : 'unknown'}\nError: ${error.message}\nPort ${prodHostPort || '?'} is unchanged.`
     );
 
-    // Keep old production
-    if (prodProcess) {
-      console.log(`🔄 Keeping old version running on port ${prodPort}`);
+    if (prodContainerName) {
+      console.log(`🔄 Keeping old version running on host port ${prodHostPort}`);
     } else {
       console.log('⚠️ No previous version available.');
     }
 
-    // Clean up test directory
     if (testVersionPath && fs.existsSync(testVersionPath)) {
       try {
         fs.rmSync(testVersionPath, { recursive: true, force: true });
@@ -389,8 +427,8 @@ const server = http.createServer(async (req, res) => {
     const failed = loadFailedVersions();
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({
-      prodRunning: prodProcess !== null,
-      prodPort: prodPort,
+      prodRunning: prodContainerName !== null,
+      prodHostPort: prodHostPort,
       prodVersion: prodCommitSha ? prodCommitSha.substring(0, 7) : 'none',
       isUpdating,
       failedVersions: failed.map(s => s.substring(0, 7))