initial

ts/providers/classes.baseprovider.ts

@@ -0,0 +1,89 @@
+import type * as interfaces from '../../ts_interfaces/index.ts';
+
+export interface ITestConnectionResult {
+  ok: boolean;
+  error?: string;
+}
+
+export interface IListOptions {
+  search?: string;
+  page?: number;
+  perPage?: number;
+}
+
+/**
+ * Abstract base class for Git provider implementations.
+ * Subclasses implement Gitea API v1 or GitLab API v4.
+ */
+export abstract class BaseProvider {
+  constructor(
+    public readonly connectionId: string,
+    public readonly baseUrl: string,
+    protected readonly token: string,
+  ) {}
+
+  // Connection
+  abstract testConnection(): Promise<ITestConnectionResult>;
+
+  // Projects
+  abstract getProjects(opts?: IListOptions): Promise<interfaces.data.IProject[]>;
+
+  // Groups / Orgs
+  abstract getGroups(opts?: IListOptions): Promise<interfaces.data.IGroup[]>;
+
+  // Secrets — project scope
+  abstract getProjectSecrets(projectId: string): Promise<interfaces.data.ISecret[]>;
+  abstract createProjectSecret(
+    projectId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret>;
+  abstract updateProjectSecret(
+    projectId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret>;
+  abstract deleteProjectSecret(projectId: string, key: string): Promise<void>;
+
+  // Secrets — group scope
+  abstract getGroupSecrets(groupId: string): Promise<interfaces.data.ISecret[]>;
+  abstract createGroupSecret(
+    groupId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret>;
+  abstract updateGroupSecret(
+    groupId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret>;
+  abstract deleteGroupSecret(groupId: string, key: string): Promise<void>;
+
+  // Pipelines / CI
+  abstract getPipelines(
+    projectId: string,
+    opts?: IListOptions,
+  ): Promise<interfaces.data.IPipeline[]>;
+  abstract getPipelineJobs(
+    projectId: string,
+    pipelineId: string,
+  ): Promise<interfaces.data.IPipelineJob[]>;
+  abstract getJobLog(projectId: string, jobId: string): Promise<string>;
+  abstract retryPipeline(projectId: string, pipelineId: string): Promise<void>;
+  abstract cancelPipeline(projectId: string, pipelineId: string): Promise<void>;
+
+  /**
+   * Helper for making authenticated fetch requests
+   */
+  protected async apiFetch(
+    path: string,
+    options: RequestInit = {},
+  ): Promise<Response> {
+    const url = `${this.baseUrl.replace(/\/+$/, '')}${path}`;
+    const headers = new Headers(options.headers);
+    this.setAuthHeader(headers);
+    return fetch(url, { ...options, headers });
+  }
+
+  protected abstract setAuthHeader(headers: Headers): void;
+}

ts/providers/classes.giteaprovider.ts

@@ -0,0 +1,263 @@
+import type * as interfaces from '../../ts_interfaces/index.ts';
+import { BaseProvider, type ITestConnectionResult, type IListOptions } from './classes.baseprovider.ts';
+
+/**
+ * Gitea API v1 provider implementation
+ */
+export class GiteaProvider extends BaseProvider {
+  protected setAuthHeader(headers: Headers): void {
+    headers.set('Authorization', `token ${this.token}`);
+    if (!headers.has('Content-Type')) {
+      headers.set('Content-Type', 'application/json');
+    }
+  }
+
+  async testConnection(): Promise<ITestConnectionResult> {
+    try {
+      const resp = await this.apiFetch('/api/v1/user');
+      if (!resp.ok) {
+        return { ok: false, error: `HTTP ${resp.status}: ${resp.statusText}` };
+      }
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async getProjects(opts?: IListOptions): Promise<interfaces.data.IProject[]> {
+    const page = opts?.page || 1;
+    const limit = opts?.perPage || 50;
+    let url = `/api/v1/repos/search?page=${page}&limit=${limit}&sort=updated`;
+    if (opts?.search) {
+      url += `&q=${encodeURIComponent(opts.search)}`;
+    }
+    const resp = await this.apiFetch(url);
+    if (!resp.ok) throw new Error(`Gitea getProjects failed: ${resp.status}`);
+    const body = await resp.json();
+    const repos = body.data || body;
+    return (repos as any[]).map((r) => this.mapProject(r));
+  }
+
+  async getGroups(opts?: IListOptions): Promise<interfaces.data.IGroup[]> {
+    const page = opts?.page || 1;
+    const limit = opts?.perPage || 50;
+    const resp = await this.apiFetch(`/api/v1/orgs?page=${page}&limit=${limit}`);
+    if (!resp.ok) throw new Error(`Gitea getGroups failed: ${resp.status}`);
+    const orgs = await resp.json() as any[];
+    return orgs.map((o) => this.mapGroup(o));
+  }
+
+  // --- Project Secrets ---
+
+  async getProjectSecrets(projectId: string): Promise<interfaces.data.ISecret[]> {
+    const resp = await this.apiFetch(`/api/v1/repos/${projectId}/actions/secrets`);
+    if (!resp.ok) throw new Error(`Gitea getProjectSecrets failed: ${resp.status}`);
+    const secrets = await resp.json() as any[];
+    return secrets.map((s) => this.mapSecret(s, 'project', projectId));
+  }
+
+  async createProjectSecret(
+    projectId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const resp = await this.apiFetch(`/api/v1/repos/${projectId}/actions/secrets/${key}`, {
+      method: 'PUT',
+      body: JSON.stringify({ data: value }),
+    });
+    if (!resp.ok) throw new Error(`Gitea createProjectSecret failed: ${resp.status}`);
+    return { key, value: '***', protected: false, masked: true, scope: 'project', scopeId: projectId, connectionId: this.connectionId, environment: '*' };
+  }
+
+  async updateProjectSecret(
+    projectId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    return this.createProjectSecret(projectId, key, value);
+  }
+
+  async deleteProjectSecret(projectId: string, key: string): Promise<void> {
+    const resp = await this.apiFetch(`/api/v1/repos/${projectId}/actions/secrets/${key}`, {
+      method: 'DELETE',
+    });
+    if (!resp.ok) throw new Error(`Gitea deleteProjectSecret failed: ${resp.status}`);
+  }
+
+  // --- Group Secrets ---
+
+  async getGroupSecrets(groupId: string): Promise<interfaces.data.ISecret[]> {
+    const resp = await this.apiFetch(`/api/v1/orgs/${groupId}/actions/secrets`);
+    if (!resp.ok) throw new Error(`Gitea getGroupSecrets failed: ${resp.status}`);
+    const secrets = await resp.json() as any[];
+    return secrets.map((s) => this.mapSecret(s, 'group', groupId));
+  }
+
+  async createGroupSecret(
+    groupId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const resp = await this.apiFetch(`/api/v1/orgs/${groupId}/actions/secrets/${key}`, {
+      method: 'PUT',
+      body: JSON.stringify({ data: value }),
+    });
+    if (!resp.ok) throw new Error(`Gitea createGroupSecret failed: ${resp.status}`);
+    return { key, value: '***', protected: false, masked: true, scope: 'group', scopeId: groupId, connectionId: this.connectionId, environment: '*' };
+  }
+
+  async updateGroupSecret(
+    groupId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    return this.createGroupSecret(groupId, key, value);
+  }
+
+  async deleteGroupSecret(groupId: string, key: string): Promise<void> {
+    const resp = await this.apiFetch(`/api/v1/orgs/${groupId}/actions/secrets/${key}`, {
+      method: 'DELETE',
+    });
+    if (!resp.ok) throw new Error(`Gitea deleteGroupSecret failed: ${resp.status}`);
+  }
+
+  // --- Pipelines (Action Runs) ---
+
+  async getPipelines(
+    projectId: string,
+    opts?: IListOptions,
+  ): Promise<interfaces.data.IPipeline[]> {
+    const page = opts?.page || 1;
+    const limit = opts?.perPage || 30;
+    const resp = await this.apiFetch(
+      `/api/v1/repos/${projectId}/actions/runs?page=${page}&limit=${limit}`,
+    );
+    if (!resp.ok) throw new Error(`Gitea getPipelines failed: ${resp.status}`);
+    const body = await resp.json();
+    const runs = body.workflow_runs || body;
+    return (runs as any[]).map((r) => this.mapPipeline(r, projectId));
+  }
+
+  async getPipelineJobs(
+    projectId: string,
+    pipelineId: string,
+  ): Promise<interfaces.data.IPipelineJob[]> {
+    const resp = await this.apiFetch(
+      `/api/v1/repos/${projectId}/actions/runs/${pipelineId}/jobs`,
+    );
+    if (!resp.ok) throw new Error(`Gitea getPipelineJobs failed: ${resp.status}`);
+    const body = await resp.json();
+    const jobs = body.jobs || body;
+    return (jobs as any[]).map((j) => this.mapJob(j, pipelineId));
+  }
+
+  async getJobLog(projectId: string, jobId: string): Promise<string> {
+    const resp = await this.apiFetch(
+      `/api/v1/repos/${projectId}/actions/jobs/${jobId}/logs`,
+    );
+    if (!resp.ok) throw new Error(`Gitea getJobLog failed: ${resp.status}`);
+    return resp.text();
+  }
+
+  async retryPipeline(projectId: string, pipelineId: string): Promise<void> {
+    // Gitea doesn't have a native retry — we re-run the workflow
+    const resp = await this.apiFetch(
+      `/api/v1/repos/${projectId}/actions/runs/${pipelineId}/rerun`,
+      { method: 'POST' },
+    );
+    if (!resp.ok) throw new Error(`Gitea retryPipeline failed: ${resp.status}`);
+  }
+
+  async cancelPipeline(projectId: string, pipelineId: string): Promise<void> {
+    const resp = await this.apiFetch(
+      `/api/v1/repos/${projectId}/actions/runs/${pipelineId}/cancel`,
+      { method: 'POST' },
+    );
+    if (!resp.ok) throw new Error(`Gitea cancelPipeline failed: ${resp.status}`);
+  }
+
+  // --- Mappers ---
+
+  private mapProject(r: any): interfaces.data.IProject {
+    return {
+      id: String(r.id),
+      name: r.name || '',
+      fullPath: r.full_name || '',
+      description: r.description || '',
+      defaultBranch: r.default_branch || 'main',
+      webUrl: r.html_url || '',
+      connectionId: this.connectionId,
+      visibility: r.private ? 'private' : (r.internal ? 'internal' : 'public'),
+      topics: r.topics || [],
+      lastActivity: r.updated_at || '',
+    };
+  }
+
+  private mapGroup(o: any): interfaces.data.IGroup {
+    return {
+      id: String(o.id || o.name),
+      name: o.name || o.username || '',
+      fullPath: o.name || o.username || '',
+      description: o.description || '',
+      webUrl: `${this.baseUrl}/${o.name || o.username}`,
+      connectionId: this.connectionId,
+      visibility: o.visibility || 'public',
+      projectCount: o.repo_count || 0,
+    };
+  }
+
+  private mapSecret(s: any, scope: 'project' | 'group', scopeId: string): interfaces.data.ISecret {
+    return {
+      key: s.name || s.key || '',
+      value: '***',
+      protected: false,
+      masked: true,
+      scope,
+      scopeId,
+      connectionId: this.connectionId,
+      environment: '*',
+    };
+  }
+
+  private mapPipeline(r: any, projectId: string): interfaces.data.IPipeline {
+    return {
+      id: String(r.id),
+      projectId,
+      projectName: projectId,
+      connectionId: this.connectionId,
+      status: this.mapStatus(r.status || r.conclusion),
+      ref: r.head_branch || '',
+      sha: r.head_sha || '',
+      webUrl: r.html_url || '',
+      duration: r.run_duration || 0,
+      createdAt: r.created_at || '',
+      source: r.event || 'push',
+    };
+  }
+
+  private mapJob(j: any, pipelineId: string): interfaces.data.IPipelineJob {
+    return {
+      id: String(j.id),
+      pipelineId,
+      name: j.name || '',
+      stage: j.name || 'default',
+      status: this.mapStatus(j.status || j.conclusion),
+      duration: j.run_duration || 0,
+    };
+  }
+
+  private mapStatus(status: string): interfaces.data.TPipelineStatus {
+    const map: Record<string, interfaces.data.TPipelineStatus> = {
+      success: 'success',
+      completed: 'success',
+      failure: 'failed',
+      cancelled: 'canceled',
+      waiting: 'waiting',
+      running: 'running',
+      queued: 'pending',
+      in_progress: 'running',
+      skipped: 'skipped',
+    };
+    return map[status?.toLowerCase()] || 'pending';
+  }
+}

ts/providers/classes.gitlabprovider.ts

@@ -0,0 +1,275 @@
+import type * as interfaces from '../../ts_interfaces/index.ts';
+import { BaseProvider, type ITestConnectionResult, type IListOptions } from './classes.baseprovider.ts';
+
+/**
+ * GitLab API v4 provider implementation
+ */
+export class GitLabProvider extends BaseProvider {
+  protected setAuthHeader(headers: Headers): void {
+    headers.set('PRIVATE-TOKEN', this.token);
+    if (!headers.has('Content-Type')) {
+      headers.set('Content-Type', 'application/json');
+    }
+  }
+
+  async testConnection(): Promise<ITestConnectionResult> {
+    try {
+      const resp = await this.apiFetch('/api/v4/user');
+      if (!resp.ok) {
+        return { ok: false, error: `HTTP ${resp.status}: ${resp.statusText}` };
+      }
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async getProjects(opts?: IListOptions): Promise<interfaces.data.IProject[]> {
+    const page = opts?.page || 1;
+    const perPage = opts?.perPage || 50;
+    let url = `/api/v4/projects?page=${page}&per_page=${perPage}&order_by=updated_at&sort=desc&membership=true`;
+    if (opts?.search) {
+      url += `&search=${encodeURIComponent(opts.search)}`;
+    }
+    const resp = await this.apiFetch(url);
+    if (!resp.ok) throw new Error(`GitLab getProjects failed: ${resp.status}`);
+    const projects = await resp.json() as any[];
+    return projects.map((p) => this.mapProject(p));
+  }
+
+  async getGroups(opts?: IListOptions): Promise<interfaces.data.IGroup[]> {
+    const page = opts?.page || 1;
+    const perPage = opts?.perPage || 50;
+    let url = `/api/v4/groups?page=${page}&per_page=${perPage}&order_by=name&sort=asc`;
+    if (opts?.search) {
+      url += `&search=${encodeURIComponent(opts.search)}`;
+    }
+    const resp = await this.apiFetch(url);
+    if (!resp.ok) throw new Error(`GitLab getGroups failed: ${resp.status}`);
+    const groups = await resp.json() as any[];
+    return groups.map((g) => this.mapGroup(g));
+  }
+
+  // --- Project Secrets (CI/CD Variables) ---
+
+  async getProjectSecrets(projectId: string): Promise<interfaces.data.ISecret[]> {
+    const resp = await this.apiFetch(`/api/v4/projects/${encodeURIComponent(projectId)}/variables`);
+    if (!resp.ok) throw new Error(`GitLab getProjectSecrets failed: ${resp.status}`);
+    const vars = await resp.json() as any[];
+    return vars.map((v) => this.mapVariable(v, 'project', projectId));
+  }
+
+  async createProjectSecret(
+    projectId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const resp = await this.apiFetch(`/api/v4/projects/${encodeURIComponent(projectId)}/variables`, {
+      method: 'POST',
+      body: JSON.stringify({ key, value, protected: false, masked: false }),
+    });
+    if (!resp.ok) throw new Error(`GitLab createProjectSecret failed: ${resp.status}`);
+    const v = await resp.json();
+    return this.mapVariable(v, 'project', projectId);
+  }
+
+  async updateProjectSecret(
+    projectId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const resp = await this.apiFetch(
+      `/api/v4/projects/${encodeURIComponent(projectId)}/variables/${encodeURIComponent(key)}`,
+      {
+        method: 'PUT',
+        body: JSON.stringify({ value }),
+      },
+    );
+    if (!resp.ok) throw new Error(`GitLab updateProjectSecret failed: ${resp.status}`);
+    const v = await resp.json();
+    return this.mapVariable(v, 'project', projectId);
+  }
+
+  async deleteProjectSecret(projectId: string, key: string): Promise<void> {
+    const resp = await this.apiFetch(
+      `/api/v4/projects/${encodeURIComponent(projectId)}/variables/${encodeURIComponent(key)}`,
+      { method: 'DELETE' },
+    );
+    if (!resp.ok) throw new Error(`GitLab deleteProjectSecret failed: ${resp.status}`);
+  }
+
+  // --- Group Secrets (CI/CD Variables) ---
+
+  async getGroupSecrets(groupId: string): Promise<interfaces.data.ISecret[]> {
+    const resp = await this.apiFetch(`/api/v4/groups/${encodeURIComponent(groupId)}/variables`);
+    if (!resp.ok) throw new Error(`GitLab getGroupSecrets failed: ${resp.status}`);
+    const vars = await resp.json() as any[];
+    return vars.map((v) => this.mapVariable(v, 'group', groupId));
+  }
+
+  async createGroupSecret(
+    groupId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const resp = await this.apiFetch(`/api/v4/groups/${encodeURIComponent(groupId)}/variables`, {
+      method: 'POST',
+      body: JSON.stringify({ key, value, protected: false, masked: false }),
+    });
+    if (!resp.ok) throw new Error(`GitLab createGroupSecret failed: ${resp.status}`);
+    const v = await resp.json();
+    return this.mapVariable(v, 'group', groupId);
+  }
+
+  async updateGroupSecret(
+    groupId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const resp = await this.apiFetch(
+      `/api/v4/groups/${encodeURIComponent(groupId)}/variables/${encodeURIComponent(key)}`,
+      {
+        method: 'PUT',
+        body: JSON.stringify({ value }),
+      },
+    );
+    if (!resp.ok) throw new Error(`GitLab updateGroupSecret failed: ${resp.status}`);
+    const v = await resp.json();
+    return this.mapVariable(v, 'group', groupId);
+  }
+
+  async deleteGroupSecret(groupId: string, key: string): Promise<void> {
+    const resp = await this.apiFetch(
+      `/api/v4/groups/${encodeURIComponent(groupId)}/variables/${encodeURIComponent(key)}`,
+      { method: 'DELETE' },
+    );
+    if (!resp.ok) throw new Error(`GitLab deleteGroupSecret failed: ${resp.status}`);
+  }
+
+  // --- Pipelines ---
+
+  async getPipelines(
+    projectId: string,
+    opts?: IListOptions,
+  ): Promise<interfaces.data.IPipeline[]> {
+    const page = opts?.page || 1;
+    const perPage = opts?.perPage || 30;
+    const resp = await this.apiFetch(
+      `/api/v4/projects/${encodeURIComponent(projectId)}/pipelines?page=${page}&per_page=${perPage}&order_by=updated_at&sort=desc`,
+    );
+    if (!resp.ok) throw new Error(`GitLab getPipelines failed: ${resp.status}`);
+    const pipelines = await resp.json() as any[];
+    return pipelines.map((p) => this.mapPipeline(p, projectId));
+  }
+
+  async getPipelineJobs(
+    projectId: string,
+    pipelineId: string,
+  ): Promise<interfaces.data.IPipelineJob[]> {
+    const resp = await this.apiFetch(
+      `/api/v4/projects/${encodeURIComponent(projectId)}/pipelines/${pipelineId}/jobs`,
+    );
+    if (!resp.ok) throw new Error(`GitLab getPipelineJobs failed: ${resp.status}`);
+    const jobs = await resp.json() as any[];
+    return jobs.map((j) => this.mapJob(j, pipelineId));
+  }
+
+  async getJobLog(projectId: string, jobId: string): Promise<string> {
+    const resp = await this.apiFetch(
+      `/api/v4/projects/${encodeURIComponent(projectId)}/jobs/${jobId}/trace`,
+      { headers: { Accept: 'text/plain' } },
+    );
+    if (!resp.ok) throw new Error(`GitLab getJobLog failed: ${resp.status}`);
+    return resp.text();
+  }
+
+  async retryPipeline(projectId: string, pipelineId: string): Promise<void> {
+    const resp = await this.apiFetch(
+      `/api/v4/projects/${encodeURIComponent(projectId)}/pipelines/${pipelineId}/retry`,
+      { method: 'POST' },
+    );
+    if (!resp.ok) throw new Error(`GitLab retryPipeline failed: ${resp.status}`);
+  }
+
+  async cancelPipeline(projectId: string, pipelineId: string): Promise<void> {
+    const resp = await this.apiFetch(
+      `/api/v4/projects/${encodeURIComponent(projectId)}/pipelines/${pipelineId}/cancel`,
+      { method: 'POST' },
+    );
+    if (!resp.ok) throw new Error(`GitLab cancelPipeline failed: ${resp.status}`);
+  }
+
+  // --- Mappers ---
+
+  private mapProject(p: any): interfaces.data.IProject {
+    return {
+      id: String(p.id),
+      name: p.name || '',
+      fullPath: p.path_with_namespace || '',
+      description: p.description || '',
+      defaultBranch: p.default_branch || 'main',
+      webUrl: p.web_url || '',
+      connectionId: this.connectionId,
+      visibility: p.visibility || 'private',
+      topics: p.topics || p.tag_list || [],
+      lastActivity: p.last_activity_at || '',
+    };
+  }
+
+  private mapGroup(g: any): interfaces.data.IGroup {
+    return {
+      id: String(g.id),
+      name: g.name || '',
+      fullPath: g.full_path || '',
+      description: g.description || '',
+      webUrl: g.web_url || '',
+      connectionId: this.connectionId,
+      visibility: g.visibility || 'private',
+      projectCount: g.projects?.length || 0,
+    };
+  }
+
+  private mapVariable(
+    v: any,
+    scope: 'project' | 'group',
+    scopeId: string,
+  ): interfaces.data.ISecret {
+    return {
+      key: v.key || '',
+      value: v.value || '***',
+      protected: v.protected || false,
+      masked: v.masked || false,
+      scope,
+      scopeId,
+      connectionId: this.connectionId,
+      environment: v.environment_scope || '*',
+    };
+  }
+
+  private mapPipeline(p: any, projectId: string): interfaces.data.IPipeline {
+    return {
+      id: String(p.id),
+      projectId,
+      projectName: projectId,
+      connectionId: this.connectionId,
+      status: (p.status || 'pending') as interfaces.data.TPipelineStatus,
+      ref: p.ref || '',
+      sha: p.sha || '',
+      webUrl: p.web_url || '',
+      duration: p.duration || 0,
+      createdAt: p.created_at || '',
+      source: p.source || 'push',
+    };
+  }
+
+  private mapJob(j: any, pipelineId: string): interfaces.data.IPipelineJob {
+    return {
+      id: String(j.id),
+      pipelineId: String(pipelineId),
+      name: j.name || '',
+      stage: j.stage || '',
+      status: (j.status || 'pending') as interfaces.data.TPipelineStatus,
+      duration: j.duration || 0,
+    };
+  }
+}

ts/providers/index.ts

@@ -0,0 +1,3 @@
+export { BaseProvider } from './classes.baseprovider.ts';
+export { GiteaProvider } from './classes.giteaprovider.ts';
+export { GitLabProvider } from './classes.gitlabprovider.ts';