src/index.ts

import * as http from 'node:http';
import { exec, spawn } from 'node:child_process';
import * as fs from 'node:fs';
import * as path from 'node:path';
import { fileURLToPath } from 'node:url';
import axios from 'axios';
import { Resend } from 'resend';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// ============================================================
// CONFIG
// ============================================================
interface Config {
  RES1_REPO: string;
  GITHUB_PAT: string;
  VERSIONS_DIR: string;
  HEALTH_PORT: number;
  ADMIN_EMAIL: string;
  RESEND_API_KEY: string;
  FROM_EMAIL: string;
}

const CONFIG: Config = {
  RES1_REPO: 'https://github.com/NepsenX/Oracus-AI.git',
  GITHUB_PAT: process.env.GITHUB_PAT || '',
  VERSIONS_DIR: '/app/versions',
  HEALTH_PORT: parseInt(process.env.HEALTH_PORT || '7860', 10),
  ADMIN_EMAIL: 'oracusai.nepsenx@gmail.com',
  RESEND_API_KEY: process.env.RESEND_API_KEY || '',
  FROM_EMAIL: 'onboarding@resend.dev'
};

if (!CONFIG.GITHUB_PAT) {
  console.error('❌ GITHUB_PAT not set!');
  process.exit(1);
}

if (!CONFIG.RESEND_API_KEY) {
  console.warn('⚠️ RESEND_API_KEY not set. Email notifications disabled.');
}

const resend = CONFIG.RESEND_API_KEY ? new Resend(CONFIG.RESEND_API_KEY) : null;

// ============================================================
// EMAIL
// ============================================================
async function sendEmail(subject: string, text: string): Promise<void> {
  if (!resend) {
    console.log(`📧 [SKIP] Email would be sent: "${subject}"`);
    return;
  }
  try {
    const { data, error } = await resend.emails.send({
      from: CONFIG.FROM_EMAIL,
      to: [CONFIG.ADMIN_EMAIL],
      subject: `[Oracus Runner] ${subject}`,
      text: text
    });
    if (error) console.error('❌ Resend error:', error);
    else console.log(`✅ Email sent! ID: ${data?.id}`);
  } catch (err: any) {
    console.error(`⚠️ Email failed (ignored): ${err.message}`);
  }
}

// ============================================================
// GIT UTILITIES
// ============================================================
function runGitCommand(cmd: string, cwd: string): Promise<string> {
  return new Promise((resolve, reject) => {
    exec(cmd, { cwd }, (error, stdout, stderr) => {
      if (error) reject(stderr || error.message);
      else resolve(stdout.trim());
    });
  });
}

function getRepoUrlWithPat(repoUrl: string): string {
  if (repoUrl.includes('@')) return repoUrl;
  return repoUrl.replace('https://', `https://${CONFIG.GITHUB_PAT}@`);
}

async function getCurrentCommitSha(repoUrl: string): Promise<string | null> {
  try {
    const urlWithPat = getRepoUrlWithPat(repoUrl);
    const output = await runGitCommand(`git ls-remote ${urlWithPat} main`, process.cwd());
    return output.split(/\s/)[0];
  } catch {
    return null;
  }
}

async function cloneOrPull(repoUrl: string, targetDir: string): Promise<void> {
  const urlWithPat = getRepoUrlWithPat(repoUrl);
  if (!fs.existsSync(targetDir)) {
    console.log(`📥 Cloning into ${targetDir}...`);
    await runGitCommand(`git clone ${urlWithPat} ${targetDir}`, process.cwd());
  } else {
    console.log(`🔄 Pulling latest...`);
    await runGitCommand(`git pull`, targetDir);
  }
}

// ============================================================
// 🐳 DOCKER UTILITIES FOR RES1
// ============================================================
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);
  }
}

// ============================================================
// 🤖 DEPLOY AGENT (USING DOCKER)
// ============================================================
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 (between version directories)
// ============================================================
function copyMemoryFolder(srcPath: string, dstPath: string): void {
  const srcMemory = path.join(srcPath, 'memory');
  const dstMemory = path.join(dstPath, 'memory');
  if (fs.existsSync(srcMemory)) {
    if (fs.existsSync(dstMemory)) fs.rmSync(dstMemory, { recursive: true, force: true });
    fs.cpSync(srcMemory, dstMemory, { recursive: true });
    console.log(`📂 Memory copied from ${srcPath} to ${dstPath}`);
  } else {
    console.log(`⚠️ No memory folder found in ${srcPath}`);
  }
}

// ============================================================
// FAILED VERSIONS TRACKING (MAX 100)
// ============================================================
const FAILED_VERSIONS_FILE = '/app/failed-versions.json';
const MAX_FAILED_VERSIONS = 100;

function loadFailedVersions(): string[] {
  try {
    if (fs.existsSync(FAILED_VERSIONS_FILE)) {
      const data = fs.readFileSync(FAILED_VERSIONS_FILE, 'utf-8');
      return JSON.parse(data);
    }
  } catch (e) {
    console.warn('⚠️ Failed to load failed-versions.json');
  }
  return [];
}

function saveFailedVersion(sha: string): void {
  try {
    let failed = loadFailedVersions().filter(v => v !== sha);
    failed.push(sha);
    if (failed.length > MAX_FAILED_VERSIONS) {
      failed = failed.slice(-MAX_FAILED_VERSIONS);
    }
    fs.writeFileSync(FAILED_VERSIONS_FILE, JSON.stringify(failed, null, 2));
    console.log(`💾 Failed version ${sha} saved. Total failed: ${failed.length}`);
  } catch (e) {
    console.error('❌ Failed to save failed version:', e);
  }
}

function isVersionFailed(sha: string): boolean {
  return loadFailedVersions().includes(sha);
}

function clearFailedVersion(sha: string): void {
  try {
    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);
  }
}

// ============================================================
// STATE
// ============================================================
let prodContainerName: string | null = null;
let prodVersionPath: string | null = null;
let prodCommitSha: string | null = null;
let prodHostPort: number | null = null;
let isUpdating: boolean = false;

// ============================================================
// 🧠 MAIN UPDATE LOGIC (Docker-based)
// ============================================================
async function checkAndUpdate(): Promise<void> {
  if (isUpdating) {
    console.log('⏳ Update already in progress...');
    return;
  }

  isUpdating = true;
  let testContainerName: string | null = null;
  let testVersionPath: string | null = null;
  let testCommitSha: string | null = null;
  let testHostPort: number | null = null;

  try {
    console.log('🔍 Checking for updates...');

    const latestSha = await getCurrentCommitSha(CONFIG.RES1_REPO);
    if (!latestSha) throw new Error('Could not fetch latest SHA');

    console.log(`📌 Latest SHA: ${latestSha.substring(0, 7)}`);
    console.log(`📌 Current Prod SHA: ${prodCommitSha ? prodCommitSha.substring(0, 7) : 'none'}`);

    if (latestSha === prodCommitSha) {
      console.log('✅ No new code. Current version is already running.');
      if (prodCommitSha && isVersionFailed(prodCommitSha)) {
        clearFailedVersion(prodCommitSha);
      }
      isUpdating = false;
      return;
    }

    if (isVersionFailed(latestSha)) {
      console.log(`⏳ Version ${latestSha.substring(0, 7)} is marked as FAILED. Waiting for a newer version.`);
      isUpdating = false;
      return;
    }

    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);

    // Copy memory from production if exists
    if (prodVersionPath) {
      copyMemoryFolder(prodVersionPath, testVersionPath);
    } else {
      console.log('⚠️ No previous version. Starting fresh without memory copy.');
    }

    // 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;
    }

    // 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
    prodContainerName = prodContainerNameNew;
    prodVersionPath = testVersionPath;
    prodCommitSha = testCommitSha;
    prodHostPort = prodHostPortNew;
    testVersionPath = null;
    testCommitSha = null;
    testHostPort = null;

    if (prodCommitSha && isVersionFailed(prodCommitSha)) {
      clearFailedVersion(prodCommitSha);
    }

    console.log(`✅ Successfully deployed V2 (${latestSha.substring(0, 7)}) on host port ${prodHostPort}`);

  } catch (error: any) {
    console.error('❌ Deployment failed:', error);

    if (testContainerName) {
      await stopAndRemoveContainer(testContainerName);
      testContainerName = null;
    }

    if (testCommitSha) {
      saveFailedVersion(testCommitSha);
    }

    await sendEmail(
      'Deployment FAILED',
      `Version: ${testCommitSha ? testCommitSha.substring(0, 7) : 'unknown'}\nError: ${error.message}\nPort ${prodHostPort || '?'} is unchanged.`
    );

    if (prodContainerName) {
      console.log(`🔄 Keeping old version running on host port ${prodHostPort}`);
    } else {
      console.log('⚠️ No previous version available.');
    }

    if (testVersionPath && fs.existsSync(testVersionPath)) {
      try {
        fs.rmSync(testVersionPath, { recursive: true, force: true });
        console.log(`🧹 Cleaned up test directory: ${testVersionPath}`);
      } catch (e) {
        // ignore
      }
    }
  } finally {
    isUpdating = false;
  }
}

// ============================================================
// HTTP SERVER (Health check for UptimeRobot)
// ============================================================
const server = http.createServer(async (req, res) => {
  const url = new URL(req.url || '/', `http://${req.headers.host}`);

  if (url.pathname === '/') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Oracus Runner is Alive!');
    setImmediate(() => checkAndUpdate());
  } else if (url.pathname === '/force-update') {
    res.writeHead(200);
    res.end('Force update triggered.');
    setImmediate(() => checkAndUpdate());
  } else if (url.pathname === '/status') {
    const failed = loadFailedVersions();
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      prodRunning: prodContainerName !== null,
      prodHostPort: prodHostPort,
      prodVersion: prodCommitSha ? prodCommitSha.substring(0, 7) : 'none',
      isUpdating,
      failedVersions: failed.map(s => s.substring(0, 7))
    }, null, 2));
  } else {
    res.writeHead(404);
    res.end('Not Found');
  }
});

server.listen(CONFIG.HEALTH_PORT, '0.0.0.0', () => {
  console.log(`✅ Health server running on port ${CONFIG.HEALTH_PORT}`);
  console.log('⏳ Initial setup...');
  checkAndUpdate();
});

// ============================================================
// CRASH HANDLING
// ============================================================
process.on('uncaughtException', (err) => {
  console.error('💥 Uncaught Exception:', err);
  sendEmail('CRASH - Uncaught Exception', err.stack || err.message);
});

process.on('unhandledRejection', (reason) => {
  console.error('💥 Unhandled Rejection:', reason);
  sendEmail('CRASH - Unhandled Rejection', String(reason));
});