manus-dashboard/src/backend/src/gitea.js

const axios = require('axios');
const https = require('https');
const config = require('./config');

// Créer un client axios pour Gitea (ignorer les certificats auto-signés si nécessaire)
// Utiliser le token API si disponible, sinon auth basique
const giteaClientHeaders = config.gitea.token
  ? { 'Authorization': `token ${config.gitea.token}` }
  : {};

const giteaClient = axios.create({
  baseURL: `${config.gitea.url}/api/v1`,
  ...(config.gitea.token
    ? { headers: giteaClientHeaders }
    : { auth: { username: config.gitea.username, password: config.gitea.password } }
  ),
  httpsAgent: new https.Agent({ rejectUnauthorized: false }),
  timeout: 10000,
});

/**
 * Récupérer les informations d'un dépôt
 */
async function getRepo(owner, repo) {
  try {
    const response = await giteaClient.get(`/repos/${owner}/${repo}`);
    return response.data;
  } catch (err) {
    console.error(`Erreur Gitea getRepo ${owner}/${repo}:`, err.message);
    return null;
  }
}

/**
 * Récupérer les derniers commits d'un dépôt
 */
async function getCommits(owner, repo, limit = 10) {
  try {
    const response = await giteaClient.get(`/repos/${owner}/${repo}/commits`, {
      params: { limit, page: 1 },
    });
    return response.data.map((c) => ({
      sha: c.sha,
      shortSha: c.sha.substring(0, 7),
      message: c.commit.message,
      author: c.commit.author.name,
      date: c.commit.author.date,
      url: c.html_url,
    }));
  } catch (err) {
    console.error(`Erreur Gitea getCommits ${owner}/${repo}:`, err.message);
    return [];
  }
}

/**
 * Récupérer les branches d'un dépôt
 */
async function getBranches(owner, repo) {
  try {
    const response = await giteaClient.get(`/repos/${owner}/${repo}/branches`);
    return response.data.map((b) => ({
      name: b.name,
      commit: b.commit.id.substring(0, 7),
      commitMessage: b.commit.message,
    }));
  } catch (err) {
    console.error(`Erreur Gitea getBranches ${owner}/${repo}:`, err.message);
    return [];
  }
}

function toDurationSeconds(startedAt, completedAt) {
  if (!startedAt || !completedAt) return null;
  const milliseconds = new Date(completedAt).getTime() - new Date(startedAt).getTime();
  return Number.isFinite(milliseconds) && milliseconds >= 0 ? Math.round(milliseconds / 1000) : null;
}

function normalizeWorkflowRun(run) {
  const startedAt = run.run_started_at || run.started_at || null;
  const completedAt = run.updated_at || (run.status === 'completed' ? run.created_at : null);
  return {
    id: run.id,
    name: run.name || run.workflow_id || 'Validation CI',
    status: run.status || 'unknown',
    conclusion: run.conclusion || null,
    event: run.event || null,
    commit: run.head_sha || null,
    createdAt: run.created_at || null,
    startedAt,
    completedAt,
    durationSeconds: toDurationSeconds(startedAt, completedAt),
    url: run.html_url || null,
  };
}

async function getWorkflowRuns(owner, repo, limit = 10) {
  try {
    const response = await giteaClient.get(`/repos/${owner}/${repo}/actions/runs`, { params: { limit, page: 1 } });
    return (response.data.workflow_runs || []).map(normalizeWorkflowRun);
  } catch (err) {
    console.error(`Erreur Gitea getWorkflowRuns ${owner}/${repo}:`, err.message);
    return [];
  }
}

async function getWorkflowRunForCommit(owner, repo, commitHash) {
  const runs = await getWorkflowRuns(owner, repo, 30);
  return runs.find((run) => run.commit && run.commit.startsWith(commitHash)) || null;
}

/**
 * Récupérer tous les dépôts (avec retry en cas d'erreur DNS)
 */
async function listRepos(retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await giteaClient.get('/repos/search', {
        params: { limit: 50 },
      });
      return response.data.data || [];
    } catch (err) {
      console.error(`Erreur Gitea listRepos (tentative ${i + 1}/${retries}):`, err.message);
      if (i < retries - 1) {
        await new Promise((r) => setTimeout(r, 2000));
      }
    }
  }
  return [];
}

/**
 * Créer un nouveau dépôt
 */
async function createRepo(name, description, isPrivate = true) {
  try {
    const response = await giteaClient.post('/user/repos', {
      name,
      description,
      private: isPrivate,
      auto_init: true,
      default_branch: 'main',
    });
    return response.data;
  } catch (err) {
    console.error(`Erreur Gitea createRepo ${name}:`, err.message);
    throw err;
  }
}

module.exports = {
  getRepo,
  getCommits,
  getBranches,
  getWorkflowRuns,
  getWorkflowRunForCommit,
  normalizeWorkflowRun,
  listRepos,
  createRepo,
  giteaClient,
};