@serve.zone/gitops 2.13.1

package/ts/providers/classes.baseprovider.ts

@@ -0,0 +1,99 @@
+import type * as interfaces from '../../ts_interfaces/index.js';
+
+export interface ITestConnectionResult {
+  ok: boolean;
+  error?: string;
+}
+
+export interface IListOptions {
+  search?: string;
+  page?: number;
+  perPage?: number;
+}
+
+export interface IPipelineListOptions extends IListOptions {
+  status?: string;
+  ref?: string;
+  source?: string;
+}
+
+/**
+ * Abstract base class for Git provider implementations.
+ * Subclasses implement Gitea API v1 or GitLab API v4.
+ */
+export abstract class BaseProvider {
+  public readonly groupFilterId?: string;
+
+  constructor(
+    public readonly connectionId: string,
+    public readonly baseUrl: string,
+    protected readonly token: string,
+    groupFilterId?: string,
+  ) {
+    this.groupFilterId = groupFilterId;
+  }
+
+  // Connection
+  abstract testConnection(): Promise<ITestConnectionResult>;
+
+  // Projects
+  abstract getProjects(opts?: IListOptions): Promise<interfaces.data.IProject[]>;
+
+  // Groups / Orgs
+  abstract getGroups(opts?: IListOptions): Promise<interfaces.data.IGroup[]>;
+
+  // Group Projects
+  abstract getGroupProjects(groupId: string, opts?: IListOptions): Promise<interfaces.data.IProject[]>;
+
+  // 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>;
+
+  // Branches / Tags
+  abstract getBranches(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.IBranch[]>;
+  abstract getTags(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.ITag[]>;
+
+  // Pipelines / CI
+  abstract getPipelines(
+    projectId: string,
+    opts?: IPipelineListOptions,
+  ): 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>;
+
+  // File content
+  abstract getFileContent(projectFullPath: string, filePath: string, ref?: string): Promise<string | null>;
+
+  // Directory listing
+  abstract getDirectoryContents(projectFullPath: string, dirPath: string, ref?: string): Promise<{ name: string; path: string; type: string }[] | null>;
+
+}

package/ts/providers/classes.giteaprovider.ts

@@ -0,0 +1,279 @@
+import * as plugins from '../plugins.js';
+import type * as interfaces from '../../ts_interfaces/index.js';
+import { BaseProvider, type ITestConnectionResult, type IListOptions, type IPipelineListOptions } from './classes.baseprovider.js';
+
+/**
+ * Gitea API v1 provider implementation
+ */
+export class GiteaProvider extends BaseProvider {
+  private client: plugins.giteaClient.GiteaClient;
+
+  constructor(connectionId: string, baseUrl: string, token: string, groupFilterId?: string) {
+    super(connectionId, baseUrl, token, groupFilterId);
+    this.client = new plugins.giteaClient.GiteaClient(baseUrl, token);
+  }
+
+  async testConnection(): Promise<ITestConnectionResult> {
+    return this.client.testConnection();
+  }
+
+  async getProjects(opts?: IListOptions): Promise<interfaces.data.IProject[]> {
+    const repos = this.groupFilterId
+      ? await (await this.client.getOrg(this.groupFilterId)).getRepos(opts)
+      : await this.client.getRepos(opts);
+    return repos.map((r) => this.mapProject(r));
+  }
+
+  async getGroups(opts?: IListOptions): Promise<interfaces.data.IGroup[]> {
+    if (this.groupFilterId) {
+      const org = await this.client.getOrg(this.groupFilterId);
+      return [this.mapGroup(org)];
+    }
+    const orgs = await this.client.getOrgs(opts);
+    return orgs.map((o) => this.mapGroup(o));
+  }
+
+  async getGroupProjects(groupId: string, opts?: IListOptions): Promise<interfaces.data.IProject[]> {
+    const org = await this.client.getOrg(groupId);
+    const repos = await org.getRepos(opts);
+    return repos.map((r) => this.mapProject(r));
+  }
+
+  // --- Branches / Tags ---
+
+  async getBranches(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.IBranch[]> {
+    const repo = await this.client.getRepo(projectFullPath);
+    const branches = await repo.getBranches(opts);
+    return branches.map((b) => ({ name: b.name, commitSha: b.commitSha }));
+  }
+
+  async getTags(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.ITag[]> {
+    const repo = await this.client.getRepo(projectFullPath);
+    const tags = await repo.getTags(opts);
+    return tags.map((t) => ({ name: t.name, commitSha: t.commitSha }));
+  }
+
+  // --- Project Secrets ---
+
+  async getProjectSecrets(projectId: string): Promise<interfaces.data.ISecret[]> {
+    const repo = await this.client.getRepo(projectId);
+    const secrets = await repo.getSecrets();
+    return secrets.map((s) => this.mapSecret(s, 'project', projectId));
+  }
+
+  async createProjectSecret(
+    projectId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const repo = await this.client.getRepo(projectId);
+    await repo.setSecret(key, value);
+    return { key, value: '***', protected: false, masked: true, scope: 'project', scopeId: projectId, scopeName: 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 repo = await this.client.getRepo(projectId);
+    await repo.deleteSecret(key);
+  }
+
+  // --- Group Secrets ---
+
+  async getGroupSecrets(groupId: string): Promise<interfaces.data.ISecret[]> {
+    const org = await this.client.getOrg(groupId);
+    const secrets = await org.getSecrets();
+    return secrets.map((s) => this.mapSecret(s, 'group', groupId));
+  }
+
+  async createGroupSecret(
+    groupId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const org = await this.client.getOrg(groupId);
+    await org.setSecret(key, value);
+    return { key, value: '***', protected: false, masked: true, scope: 'group', scopeId: groupId, scopeName: 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 org = await this.client.getOrg(groupId);
+    await org.deleteSecret(key);
+  }
+
+  // --- Pipelines (Action Runs) ---
+
+  async getPipelines(
+    projectId: string,
+    opts?: IPipelineListOptions,
+  ): Promise<interfaces.data.IPipeline[]> {
+    const repo = await this.client.getRepo(projectId);
+    const runs = await repo.getActionRuns({
+      page: opts?.page,
+      perPage: opts?.perPage,
+      status: opts?.status,
+      branch: opts?.ref,
+      event: opts?.source,
+    });
+    return runs.map((r) => this.mapPipeline(r, projectId));
+  }
+
+  async getPipelineJobs(
+    projectId: string,
+    pipelineId: string,
+  ): Promise<interfaces.data.IPipelineJob[]> {
+    // Use the client's internal method directly to avoid an extra getRepo call
+    const jobs = await this.client.requestGetActionRunJobs(projectId, Number(pipelineId));
+    return jobs.map((j) => {
+      const resolvedStatus = plugins.giteaClient.resolveGiteaStatus(j.status, j.conclusion);
+      return this.mapJob(resolvedStatus, j, pipelineId);
+    });
+  }
+
+  async getJobLog(projectId: string, jobId: string): Promise<string> {
+    return this.client.requestGetJobLog(projectId, Number(jobId));
+  }
+
+  async retryPipeline(projectId: string, pipelineId: string): Promise<void> {
+    // Fetch the run to get its workflow path, then dispatch
+    const run = await this.client.requestGetActionRun(projectId, Number(pipelineId));
+    const wfId = plugins.giteaClient.extractWorkflowIdFromPath(run.path);
+    const ref = run.head_branch || 'main';
+    if (!wfId) {
+      throw new Error(`Cannot retry: no workflow ID found in path "${run.path}"`);
+    }
+    await this.client.requestDispatchWorkflow(projectId, wfId, ref);
+  }
+
+  async cancelPipeline(_projectId: string, _pipelineId: string): Promise<void> {
+    throw new Error('Cancel is not supported by Gitea 1.25');
+  }
+
+  // --- File Content ---
+
+  async getFileContent(projectFullPath: string, filePath: string, ref?: string): Promise<string | null> {
+    try {
+      const query = ref ? `?ref=${encodeURIComponent(ref)}` : '';
+      return await this.client.requestText('GET', `/api/v1/repos/${projectFullPath}/raw/${encodeURIComponent(filePath)}${query}`);
+    } catch {
+      return null;
+    }
+  }
+
+  // --- Directory Listing ---
+
+  async getDirectoryContents(projectFullPath: string, dirPath: string, ref?: string): Promise<{ name: string; path: string; type: string }[] | null> {
+    try {
+      const query = ref ? `?ref=${encodeURIComponent(ref)}` : '';
+      const result = await this.client.request<any[]>('GET', `/api/v1/repos/${projectFullPath}/contents/${encodeURIComponent(dirPath)}${query}`);
+      if (!Array.isArray(result)) return null;
+      return result.map((entry: any) => ({
+        name: entry.name,
+        path: entry.path,
+        type: entry.type, // "file" or "dir"
+      }));
+    } catch {
+      return null;
+    }
+  }
+
+  // --- Mappers ---
+
+  private mapProject(r: plugins.giteaClient.GiteaRepository): interfaces.data.IProject {
+    return {
+      id: r.fullName || String(r.id),
+      name: r.name,
+      fullPath: r.fullName,
+      description: r.description,
+      defaultBranch: r.defaultBranch,
+      webUrl: r.htmlUrl,
+      connectionId: this.connectionId,
+      visibility: r.isPrivate ? 'private' : 'public',
+      topics: r.topics,
+      lastActivity: r.updatedAt,
+    };
+  }
+
+  private mapGroup(o: plugins.giteaClient.GiteaOrganization): interfaces.data.IGroup {
+    return {
+      id: o.name || String(o.id),
+      name: o.name,
+      fullPath: o.name,
+      description: o.description,
+      webUrl: `${this.baseUrl}/${o.name}`,
+      connectionId: this.connectionId,
+      visibility: o.visibility || 'public',
+      projectCount: o.repoCount,
+    };
+  }
+
+  private mapSecret(s: plugins.giteaClient.GiteaSecret, scope: 'project' | 'group', scopeId: string): interfaces.data.ISecret {
+    return {
+      key: s.name,
+      value: '***',
+      protected: false,
+      masked: true,
+      scope,
+      scopeId,
+      scopeName: scopeId,
+      connectionId: this.connectionId,
+      environment: '*',
+    };
+  }
+
+  private mapPipeline(r: plugins.giteaClient.GiteaActionRun, projectId: string): interfaces.data.IPipeline {
+    return {
+      id: String(r.id),
+      projectId,
+      projectName: projectId,
+      connectionId: this.connectionId,
+      status: this.mapStatus(r.resolvedStatus),
+      ref: r.ref,
+      sha: r.headSha,
+      webUrl: r.htmlUrl,
+      duration: r.duration,
+      createdAt: r.startedAt,
+      source: r.event || 'push',
+    };
+  }
+
+  private mapJob(resolvedStatus: string, j: plugins.giteaClient.IGiteaActionRunJob, pipelineId: string): interfaces.data.IPipelineJob {
+    return {
+      id: String(j.id),
+      pipelineId,
+      name: j.name || '',
+      stage: j.name || 'default',
+      status: this.mapStatus(resolvedStatus),
+      duration: plugins.giteaClient.computeDuration(j.started_at, j.completed_at),
+    };
+  }
+
+  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';
+  }
+}

package/ts/providers/classes.gitlabprovider.ts

@@ -0,0 +1,265 @@
+import * as plugins from '../plugins.js';
+import type * as interfaces from '../../ts_interfaces/index.js';
+import { BaseProvider, type ITestConnectionResult, type IListOptions, type IPipelineListOptions } from './classes.baseprovider.js';
+
+/**
+ * GitLab API v4 provider implementation
+ */
+export class GitLabProvider extends BaseProvider {
+  private client: plugins.gitlabClient.GitLabClient;
+
+  constructor(connectionId: string, baseUrl: string, token: string, groupFilterId?: string) {
+    super(connectionId, baseUrl, token, groupFilterId);
+    this.client = new plugins.gitlabClient.GitLabClient(baseUrl, token);
+  }
+
+  async testConnection(): Promise<ITestConnectionResult> {
+    return this.client.testConnection();
+  }
+
+  async getProjects(opts?: IListOptions): Promise<interfaces.data.IProject[]> {
+    const projects = this.groupFilterId
+      ? await (await this.client.getGroup(this.groupFilterId)).getProjects(opts)
+      : await this.client.getProjects(opts);
+    return projects.map((p) => this.mapProject(p));
+  }
+
+  async getGroups(opts?: IListOptions): Promise<interfaces.data.IGroup[]> {
+    if (this.groupFilterId) {
+      const group = await this.client.getGroup(this.groupFilterId);
+      const descendants = await group.getDescendantGroups(opts);
+      return descendants.map((g) => this.mapGroup(g));
+    }
+    const groups = await this.client.getGroups(opts);
+    return groups.map((g) => this.mapGroup(g));
+  }
+
+  async getGroupProjects(groupId: string, opts?: IListOptions): Promise<interfaces.data.IProject[]> {
+    const group = await this.client.getGroup(groupId);
+    const projects = await group.getProjects(opts);
+    return projects.map((p) => this.mapProject(p));
+  }
+
+  // --- Branches / Tags ---
+
+  async getBranches(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.IBranch[]> {
+    const project = await this.client.getProject(projectFullPath);
+    const branches = await project.getBranches(opts);
+    return branches.map((b) => ({ name: b.name, commitSha: b.commitSha }));
+  }
+
+  async getTags(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.ITag[]> {
+    const project = await this.client.getProject(projectFullPath);
+    const tags = await project.getTags(opts);
+    return tags.map((t) => ({ name: t.name, commitSha: t.commitSha }));
+  }
+
+  // --- Project Secrets (CI/CD Variables) ---
+
+  async getProjectSecrets(projectId: string): Promise<interfaces.data.ISecret[]> {
+    const project = await this.client.getProject(projectId);
+    const vars = await project.getVariables();
+    return vars.map((v) => this.mapVariable(v, 'project', projectId));
+  }
+
+  async createProjectSecret(
+    projectId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const project = await this.client.getProject(projectId);
+    const v = await project.createVariable(key, value);
+    return this.mapVariable(v, 'project', projectId);
+  }
+
+  async updateProjectSecret(
+    projectId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const project = await this.client.getProject(projectId);
+    const v = await project.updateVariable(key, value);
+    return this.mapVariable(v, 'project', projectId);
+  }
+
+  async deleteProjectSecret(projectId: string, key: string): Promise<void> {
+    const project = await this.client.getProject(projectId);
+    await project.deleteVariable(key);
+  }
+
+  // --- Group Secrets (CI/CD Variables) ---
+
+  async getGroupSecrets(groupId: string): Promise<interfaces.data.ISecret[]> {
+    const group = await this.client.getGroup(groupId);
+    const vars = await group.getVariables();
+    return vars.map((v) => this.mapVariable(v, 'group', groupId));
+  }
+
+  async createGroupSecret(
+    groupId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const group = await this.client.getGroup(groupId);
+    const v = await group.createVariable(key, value);
+    return this.mapVariable(v, 'group', groupId);
+  }
+
+  async updateGroupSecret(
+    groupId: string,
+    key: string,
+    value: string,
+  ): Promise<interfaces.data.ISecret> {
+    const group = await this.client.getGroup(groupId);
+    const v = await group.updateVariable(key, value);
+    return this.mapVariable(v, 'group', groupId);
+  }
+
+  async deleteGroupSecret(groupId: string, key: string): Promise<void> {
+    const group = await this.client.getGroup(groupId);
+    await group.deleteVariable(key);
+  }
+
+  // --- Pipelines ---
+
+  async getPipelines(
+    projectId: string,
+    opts?: IPipelineListOptions,
+  ): Promise<interfaces.data.IPipeline[]> {
+    const project = await this.client.getProject(projectId);
+    const pipelines = await project.getPipelines({
+      page: opts?.page,
+      perPage: opts?.perPage,
+      status: opts?.status,
+      ref: opts?.ref,
+      source: opts?.source,
+    });
+    return pipelines.map((p) => this.mapPipeline(p, projectId));
+  }
+
+  async getPipelineJobs(
+    projectId: string,
+    pipelineId: string,
+  ): Promise<interfaces.data.IPipelineJob[]> {
+    const jobs = await this.client.requestGetPipelineJobs(projectId, Number(pipelineId));
+    return jobs.map((j) => this.mapJob(j, pipelineId));
+  }
+
+  async getJobLog(projectId: string, jobId: string): Promise<string> {
+    return this.client.requestGetJobLog(projectId, Number(jobId));
+  }
+
+  async retryPipeline(projectId: string, pipelineId: string): Promise<void> {
+    await this.client.requestRetryPipeline(projectId, Number(pipelineId));
+  }
+
+  async cancelPipeline(projectId: string, pipelineId: string): Promise<void> {
+    await this.client.requestCancelPipeline(projectId, Number(pipelineId));
+  }
+
+  // --- File Content ---
+
+  async getFileContent(projectFullPath: string, filePath: string, ref?: string): Promise<string | null> {
+    try {
+      const encodedPath = encodeURIComponent(projectFullPath);
+      const encodedFile = encodeURIComponent(filePath);
+      const refParam = ref ? `?ref=${encodeURIComponent(ref)}` : '?ref=HEAD';
+      return await this.client.requestText('GET', `/api/v4/projects/${encodedPath}/repository/files/${encodedFile}/raw${refParam}`);
+    } catch {
+      return null;
+    }
+  }
+
+  // --- Directory Listing ---
+
+  async getDirectoryContents(projectFullPath: string, dirPath: string, ref?: string): Promise<{ name: string; path: string; type: string }[] | null> {
+    try {
+      const encodedPath = encodeURIComponent(projectFullPath);
+      const refParam = ref ? `&ref=${encodeURIComponent(ref)}` : '&ref=HEAD';
+      const result = await this.client.request<any[]>('GET', `/api/v4/projects/${encodedPath}/repository/tree?path=${encodeURIComponent(dirPath)}${refParam}`);
+      if (!Array.isArray(result)) return null;
+      return result.map((entry: any) => ({
+        name: entry.name,
+        path: entry.path,
+        type: entry.type === 'blob' ? 'file' : 'dir',
+      }));
+    } catch {
+      return null;
+    }
+  }
+
+  // --- Mappers ---
+
+  private mapProject(p: plugins.gitlabClient.GitLabProject): interfaces.data.IProject {
+    return {
+      id: String(p.id),
+      name: p.name,
+      fullPath: p.fullPath,
+      description: p.description,
+      defaultBranch: p.defaultBranch,
+      webUrl: p.webUrl,
+      connectionId: this.connectionId,
+      visibility: p.visibility,
+      topics: p.topics,
+      lastActivity: p.lastActivityAt,
+    };
+  }
+
+  private mapGroup(g: plugins.gitlabClient.GitLabGroup): interfaces.data.IGroup {
+    return {
+      id: String(g.id),
+      name: g.name,
+      fullPath: g.fullPath,
+      description: g.description,
+      webUrl: g.webUrl,
+      connectionId: this.connectionId,
+      visibility: g.visibility,
+      projectCount: 0,
+    };
+  }
+
+  private mapVariable(
+    v: plugins.gitlabClient.GitLabVariable,
+    scope: 'project' | 'group',
+    scopeId: string,
+  ): interfaces.data.ISecret {
+    return {
+      key: v.key,
+      value: v.value || '***',
+      protected: v.protected,
+      masked: v.masked,
+      scope,
+      scopeId,
+      scopeName: scopeId,
+      connectionId: this.connectionId,
+      environment: v.environmentScope,
+    };
+  }
+
+  private mapPipeline(p: plugins.gitlabClient.GitLabPipeline, 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.webUrl,
+      duration: p.duration,
+      createdAt: p.createdAt,
+      source: p.source || 'push',
+    };
+  }
+
+  private mapJob(j: plugins.gitlabClient.IGitLabJob, 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,
+    };
+  }
+}

package/ts/providers/index.ts

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