mcp-mokogitea-api/src/client.ts

/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
 *
 * This file is part of a Moko Consulting project.
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * FILE INFORMATION
 * DEFGROUP: gitea-api-mcp.Client
 * INGROUP: gitea-api-mcp
 * REPO: https://git.mokoconsulting.tech/MokoConsulting/gitea-api-mcp
 * PATH: /src/client.ts
 * VERSION: 01.00.00
 * BRIEF: HTTP client for Gitea REST API v1
 */

import * as https from 'node:https';
import * as http from 'node:http';
import type { GiteaConnection, ApiResponse } from './types.js';

const API_PREFIX = '/api/v1';
const TIMEOUT_MS = 30_000;

export class GiteaClient {
	private readonly base_url: string;
	private readonly headers: Record<string, string>;
	private readonly insecure: boolean;

	constructor(conn: GiteaConnection) {
		this.base_url = conn.baseUrl.replace(/\/+$/, '') + API_PREFIX;
		this.headers = {
			'Authorization': `token ${conn.token}`,
			'Content-Type': 'application/json',
			'Accept': 'application/json',
		};
		this.insecure = conn.insecure ?? false;
	}

	async get(endpoint: string, params?: Record<string, string>): Promise<ApiResponse> {
		return this.request(this.buildUrl(endpoint, params), 'GET');
	}

	async post(endpoint: string, body?: unknown): Promise<ApiResponse> {
		return this.request(this.buildUrl(endpoint), 'POST', body);
	}

	async patch(endpoint: string, body: unknown): Promise<ApiResponse> {
		return this.request(this.buildUrl(endpoint), 'PATCH', body);
	}

	async put(endpoint: string, body: unknown): Promise<ApiResponse> {
		return this.request(this.buildUrl(endpoint), 'PUT', body);
	}

	async delete(endpoint: string): Promise<ApiResponse> {
		return this.request(this.buildUrl(endpoint), 'DELETE');
	}

	private buildUrl(endpoint: string, params?: Record<string, string>): string {
		const path = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
		const url = new URL(`${this.base_url}${path}`);
		if (params) {
			for (const [key, value] of Object.entries(params)) {
				url.searchParams.set(key, value);
			}
		}
		return url.toString();
	}

	private request(url: string, method: string, body?: unknown): Promise<ApiResponse> {
		return new Promise((resolve, reject) => {
			const parsed = new URL(url);
			const is_https = parsed.protocol === 'https:';
			const transport = is_https ? https : http;

			const options: https.RequestOptions = {
				hostname: parsed.hostname,
				port: parsed.port || (is_https ? 443 : 80),
				path: parsed.pathname + parsed.search,
				method,
				headers: { ...this.headers },
				timeout: TIMEOUT_MS,
			};

			if (this.insecure && is_https) {
				options.rejectUnauthorized = false;
			}

			const payload = body !== undefined ? JSON.stringify(body) : undefined;
			if (payload) {
				(options.headers as Record<string, string>)['Content-Length'] = Buffer.byteLength(payload).toString();
			}

			const req = transport.request(options, (res) => {
				const chunks: Buffer[] = [];
				res.on('data', (chunk: Buffer) => chunks.push(chunk));
				res.on('end', () => {
					const raw = Buffer.concat(chunks).toString('utf-8');
					let data: unknown;
					try {
						data = JSON.parse(raw);
					} catch {
						data = raw;
					}
					resolve({ status: res.statusCode ?? 0, data });
				});
			});

			req.on('error', (err) => reject(err));
			req.on('timeout', () => {
				req.destroy();
				reject(new Error('Request timed out'));
			});

			if (payload) {
				req.write(payload);
			}
			req.end();
		});
	}
}