@serve.zone/gitops 3.0.0 → 3.1.0

package/ts/classes/syncpath.ts

@@ -0,0 +1,71 @@
+export interface ISyncPathMappingOptions {
+  sourceFullPath: string;
+  sourceGroupFilter?: string;
+  targetGroupOffset?: string;
+}
+
+export interface IContainerImagePathOptions extends ISyncPathMappingOptions {
+  sourceImagePath: string;
+}
+
+export function normalizeSyncPath(pathArg: string): string {
+  return pathArg
+    .split('/')
+    .map((segment) => segment.trim())
+    .filter(Boolean)
+    .join('/');
+}
+
+export function computeRelativePath(sourceFullPath: string, sourceGroupFilter?: string): string {
+  const sourcePath = normalizeSyncPath(sourceFullPath);
+  const filterPath = sourceGroupFilter ? normalizeSyncPath(sourceGroupFilter) : '';
+  if (!filterPath) return sourcePath;
+  if (sourcePath === filterPath) return '';
+  if (sourcePath.startsWith(`${filterPath}/`)) {
+    return sourcePath.substring(filterPath.length + 1);
+  }
+  return sourcePath;
+}
+
+export function computeTargetFullPath(options: ISyncPathMappingOptions): string {
+  const relativePath = computeRelativePath(options.sourceFullPath, options.sourceGroupFilter);
+  const targetOffset = options.targetGroupOffset ? normalizeSyncPath(options.targetGroupOffset) : '';
+  return targetOffset ? `${targetOffset}/${relativePath}` : relativePath;
+}
+
+export function computeTargetContainerImagePath(options: IContainerImagePathOptions): string {
+  const sourceProjectPath = normalizeSyncPath(options.sourceFullPath);
+  const sourceImagePath = normalizeSyncPath(options.sourceImagePath);
+  const targetProjectPath = computeTargetFullPath(options);
+
+  if (sourceImagePath === sourceProjectPath) {
+    return targetProjectPath;
+  }
+
+  if (sourceImagePath.startsWith(`${sourceProjectPath}/`)) {
+    return `${targetProjectPath}/${sourceImagePath.substring(sourceProjectPath.length + 1)}`;
+  }
+
+  const relativeImagePath = computeRelativePath(sourceImagePath, options.sourceGroupFilter);
+  const targetOffset = options.targetGroupOffset ? normalizeSyncPath(options.targetGroupOffset) : '';
+  return targetOffset ? `${targetOffset}/${relativeImagePath}` : relativeImagePath;
+}
+
+export function reverseTargetGroupPath(
+  targetGroupPath: string,
+  sourceGroupFilter?: string,
+  targetGroupOffset?: string,
+): string | null {
+  const targetPath = normalizeSyncPath(targetGroupPath);
+  const offsetPath = targetGroupOffset ? normalizeSyncPath(targetGroupOffset) : '';
+  let relativePath = targetPath;
+
+  if (offsetPath) {
+    if (targetPath === offsetPath) return null;
+    if (!targetPath.startsWith(`${offsetPath}/`)) return null;
+    relativePath = targetPath.substring(offsetPath.length + 1);
+  }
+
+  const sourceFilter = sourceGroupFilter ? normalizeSyncPath(sourceGroupFilter) : '';
+  return sourceFilter ? `${sourceFilter}/${relativePath}` : relativePath;
+}

package/ts/opsserver/handlers/connections.handler.ts

@@ -40,6 +40,9 @@ export class ConnectionsHandler {
             dataArg.baseUrl,
             dataArg.token,
             dataArg.groupFilter,
+            dataArg.registryUrl,
+            dataArg.registryUsername,
+            dataArg.registryToken,
           );
           this.actionLog.append({
             actionType: 'create',
@@ -67,6 +70,9 @@ export class ConnectionsHandler {
               baseUrl: dataArg.baseUrl,
               token: dataArg.token,
               groupFilter: dataArg.groupFilter,
+              registryUrl: dataArg.registryUrl,
+              registryUsername: dataArg.registryUsername,
+              registryToken: dataArg.registryToken,
             },
           );
           const fields = [
@@ -74,6 +80,9 @@ export class ConnectionsHandler {
             dataArg.baseUrl && 'baseUrl',
             dataArg.token && 'token',
             dataArg.groupFilter !== undefined && 'groupFilter',
+            dataArg.registryUrl !== undefined && 'registryUrl',
+            dataArg.registryUsername !== undefined && 'registryUsername',
+            dataArg.registryToken && 'registryToken',
           ].filter(Boolean).join(', ');
           this.actionLog.append({
             actionType: 'update',

package/ts/opsserver/handlers/sync.handler.ts

@@ -70,6 +70,8 @@ export class SyncHandler {
             intervalMinutes: dataArg.intervalMinutes,
             enforceDelete: dataArg.enforceDelete,
             enforceGroupDelete: dataArg.enforceGroupDelete,
+            syncReleases: dataArg.syncReleases,
+            syncContainerImages: dataArg.syncContainerImages,
             addMirrorHint: dataArg.addMirrorHint,
             useGroupAvatarsForProjects: dataArg.useGroupAvatarsForProjects,
           });
@@ -98,6 +100,8 @@ export class SyncHandler {
             intervalMinutes: dataArg.intervalMinutes,
             enforceDelete: dataArg.enforceDelete,
             enforceGroupDelete: dataArg.enforceGroupDelete,
+            syncReleases: dataArg.syncReleases,
+            syncContainerImages: dataArg.syncContainerImages,
             addMirrorHint: dataArg.addMirrorHint,
             useGroupAvatarsForProjects: dataArg.useGroupAvatarsForProjects,
           });

package/ts/providers/classes.baseprovider.ts

@@ -17,6 +17,18 @@ export interface IPipelineListOptions extends IListOptions {
   source?: string;
 }
 
+export interface IReleaseAssetPayload {
+  data: Uint8Array;
+  contentType?: string;
+}
+
+export interface IReleaseAssetTransferOptions {
+  signal?: AbortSignal;
+  maxBytes?: number;
+}
+
+const PROVIDER_REQUEST_TIMEOUT_MS = 2 * 60 * 1000;
+
 /**
  * Abstract base class for Git provider implementations.
  * Subclasses implement Gitea API v1 or GitLab API v4.
@@ -96,4 +108,129 @@ export abstract class BaseProvider {
   // Directory listing
   abstract getDirectoryContents(projectFullPath: string, dirPath: string, ref?: string): Promise<{ name: string; path: string; type: string }[] | null>;
 
+  // Releases / release assets
+  abstract getReleases(projectFullPath: string): Promise<interfaces.data.IRelease[]>;
+  abstract upsertRelease(projectFullPath: string, release: interfaces.data.IRelease): Promise<interfaces.data.IRelease>;
+  abstract deleteRelease(projectFullPath: string, tagName: string): Promise<void>;
+  abstract deleteReleaseAsset(projectFullPath: string, release: interfaces.data.IRelease, asset: interfaces.data.IReleaseAsset): Promise<void>;
+  abstract downloadReleaseAsset(projectFullPath: string, release: interfaces.data.IRelease, asset: interfaces.data.IReleaseAsset, options?: IReleaseAssetTransferOptions): Promise<IReleaseAssetPayload | null>;
+  abstract uploadReleaseAsset(projectFullPath: string, release: interfaces.data.IRelease, asset: interfaces.data.IReleaseAsset, payload: IReleaseAssetPayload, options?: IReleaseAssetTransferOptions): Promise<interfaces.data.IReleaseAsset>;
+  abstract createReleaseAssetLink(projectFullPath: string, release: interfaces.data.IRelease, asset: interfaces.data.IReleaseAsset): Promise<interfaces.data.IReleaseAsset>;
+
+  // Container images
+  abstract getContainerImageRepositories(projectFullPath: string): Promise<interfaces.data.IContainerImageRepository[]>;
+  abstract deleteContainerImageTag(projectFullPath: string, repositoryId: string, tagName: string): Promise<void>;
+
+  protected async readReleaseAssetPayload(
+    response: Response,
+    assetName: string,
+    fallbackContentType: string | undefined,
+    options: IReleaseAssetTransferOptions | undefined,
+  ): Promise<IReleaseAssetPayload> {
+    const maxBytes = options?.maxBytes;
+    const contentLengthHeader = response.headers.get('content-length');
+    const contentLength = contentLengthHeader ? Number(contentLengthHeader) : undefined;
+    if (maxBytes && contentLength && contentLength > maxBytes) {
+      if (response.body) {
+        try {
+          await response.body.cancel();
+        } catch {
+          // Best-effort cleanup before rejecting the oversized transfer.
+        }
+      }
+      throw new Error(`Release asset ${assetName} is ${contentLength} bytes, exceeding the ${maxBytes} byte limit`);
+    }
+
+    if (!response.body) {
+      const buffer = await response.arrayBuffer();
+      if (maxBytes && buffer.byteLength > maxBytes) {
+        throw new Error(`Release asset ${assetName} is ${buffer.byteLength} bytes, exceeding the ${maxBytes} byte limit`);
+      }
+      return {
+        data: new Uint8Array(buffer),
+        contentType: response.headers.get('content-type') || fallbackContentType,
+      };
+    }
+
+    const reader = response.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let totalBytes = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        totalBytes += value.byteLength;
+        if (maxBytes && totalBytes > maxBytes) {
+          await reader.cancel();
+          throw new Error(`Release asset ${assetName} exceeds the ${maxBytes} byte limit`);
+        }
+        chunks.push(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    const data = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+      data.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return {
+      data,
+      contentType: response.headers.get('content-type') || fallbackContentType,
+    };
+  }
+
+  protected getPayloadArrayBuffer(payload: IReleaseAssetPayload): ArrayBuffer {
+    const copy = new Uint8Array(payload.data.byteLength);
+    copy.set(payload.data);
+    return copy.buffer;
+  }
+
+  protected async fetchJsonWithTimeout<T>(
+    url: string,
+    init: RequestInit,
+    label: string,
+  ): Promise<T> {
+    return await this.fetchWithTimeout(url, init, label, async (response) => await response.json() as T);
+  }
+
+  protected async fetchVoidWithTimeout(
+    url: string,
+    init: RequestInit,
+    label: string,
+  ): Promise<void> {
+    await this.fetchWithTimeout(url, init, label, async (response) => {
+      await response.text().catch(() => undefined);
+    });
+  }
+
+  private async fetchWithTimeout<T>(
+    url: string,
+    init: RequestInit,
+    label: string,
+    parser: (response: Response) => Promise<T>,
+  ): Promise<T> {
+    const controller = new AbortController();
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    try {
+      timeout = setTimeout(() => {
+        controller.abort(new Error(`${label} timed out after ${PROVIDER_REQUEST_TIMEOUT_MS}ms`));
+      }, PROVIDER_REQUEST_TIMEOUT_MS);
+      (timeout as any).unref?.();
+      const response = await fetch(url, {
+        ...init,
+        signal: controller.signal,
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`${label}: ${response.status} - ${text}`);
+      }
+      return await parser(response);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+
 }

package/ts/providers/classes.giteaprovider.ts

@@ -1,6 +1,6 @@
 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';
+import { BaseProvider, type IReleaseAssetPayload, type IReleaseAssetTransferOptions, type ITestConnectionResult, type IListOptions, type IPipelineListOptions } from './classes.baseprovider.js';
 
 /**
  * Gitea API v1 provider implementation
@@ -191,8 +191,300 @@ export class GiteaProvider extends BaseProvider {
     }
   }
 
+  // --- Releases / Release Assets ---
+
+  async getReleases(projectFullPath: string): Promise<interfaces.data.IRelease[]> {
+    const { owner, repo } = this.splitOwnerRepo(projectFullPath);
+    try {
+      const releases = await this.requestPaginated<any>(
+        `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases`,
+      );
+      return releases.map((release) => this.mapRelease(release));
+    } catch (err) {
+      if (this.isNotFoundError(err)) return [];
+      throw err;
+    }
+  }
+
+  async upsertRelease(projectFullPath: string, release: interfaces.data.IRelease): Promise<interfaces.data.IRelease> {
+    const { owner, repo } = this.splitOwnerRepo(projectFullPath);
+    const basePath = `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`;
+    const body: Record<string, unknown> = {
+      tag_name: release.tagName,
+      name: release.name || release.tagName,
+      body: release.description || '',
+      draft: !!release.draft,
+      prerelease: !!release.preRelease,
+    };
+    if (release.targetCommitish) body.target_commitish = release.targetCommitish;
+
+    try {
+      const existing = await this.requestJson<any>(
+        'GET',
+        `${basePath}/releases/tags/${encodeURIComponent(release.tagName)}`,
+      );
+      const updated = await this.requestJson<any>(
+        'PATCH',
+        `${basePath}/releases/${existing.id}`,
+        body,
+      );
+      return this.mapRelease(updated);
+    } catch (err) {
+      if (!this.isNotFoundError(err)) throw err;
+      const created = await this.requestJson<any>('POST', `${basePath}/releases`, body);
+      return this.mapRelease(created);
+    }
+  }
+
+  async deleteRelease(projectFullPath: string, tagName: string): Promise<void> {
+    const { owner, repo } = this.splitOwnerRepo(projectFullPath);
+    try {
+      const release = await this.getReleaseByTag(projectFullPath, tagName);
+      if (!release?.id) return;
+      await this.requestVoid(
+        'DELETE',
+        `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${encodeURIComponent(release.id)}`,
+      );
+    } catch (err) {
+      if (!this.isNotFoundError(err)) throw err;
+    }
+  }
+
+  async deleteReleaseAsset(
+    projectFullPath: string,
+    release: interfaces.data.IRelease,
+    asset: interfaces.data.IReleaseAsset,
+  ): Promise<void> {
+    if (asset.kind !== 'attachment' || !asset.id || !release.id) return;
+    const { owner, repo } = this.splitOwnerRepo(projectFullPath);
+    await this.requestVoid(
+      'DELETE',
+      `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${encodeURIComponent(release.id)}/assets/${encodeURIComponent(asset.id)}`,
+    );
+  }
+
+  async downloadReleaseAsset(
+    _projectFullPath: string,
+    _release: interfaces.data.IRelease,
+    asset: interfaces.data.IReleaseAsset,
+    options?: IReleaseAssetTransferOptions,
+  ): Promise<IReleaseAssetPayload | null> {
+    const url = asset.downloadUrl || asset.url;
+    if (!url) return null;
+    const resolvedUrl = url.startsWith('http') ? url : `${this.baseUrl}${url}`;
+    const response = await fetch(resolvedUrl, {
+      headers: { Authorization: `token ${this.token}` },
+      signal: options?.signal,
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`GET release asset ${asset.name}: ${response.status} - ${text}`);
+    }
+    return await this.readReleaseAssetPayload(response, asset.name, asset.contentType, options);
+  }
+
+  async uploadReleaseAsset(
+    projectFullPath: string,
+    release: interfaces.data.IRelease,
+    asset: interfaces.data.IReleaseAsset,
+    payload: IReleaseAssetPayload,
+    options?: IReleaseAssetTransferOptions,
+  ): Promise<interfaces.data.IReleaseAsset> {
+    const releaseId = release.id || (await this.getReleaseByTag(projectFullPath, release.tagName))?.id;
+    if (!releaseId) {
+      throw new Error(`Cannot upload release asset ${asset.name}: target release has no ID`);
+    }
+    const { owner, repo } = this.splitOwnerRepo(projectFullPath);
+    const formData = new FormData();
+    const blob = new Blob([this.getPayloadArrayBuffer(payload)], {
+      type: payload.contentType || asset.contentType || 'application/octet-stream',
+    });
+    formData.append('attachment', blob, asset.name);
+    const response = await fetch(
+      `${this.baseUrl}/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${encodeURIComponent(releaseId)}/assets?name=${encodeURIComponent(asset.name)}`,
+      {
+        method: 'POST',
+        headers: { Authorization: `token ${this.token}` },
+        body: formData,
+        signal: options?.signal,
+      },
+    );
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`POST release asset ${asset.name}: ${response.status} - ${text}`);
+    }
+    return this.mapReleaseAsset(await response.json());
+  }
+
+  async createReleaseAssetLink(
+    _projectFullPath: string,
+    _release: interfaces.data.IRelease,
+    asset: interfaces.data.IReleaseAsset,
+  ): Promise<interfaces.data.IReleaseAsset> {
+    throw new Error(`Gitea releases do not support link-only asset "${asset.name}"`);
+  }
+
+  // --- Container Images ---
+
+  async getContainerImageRepositories(projectFullPath: string): Promise<interfaces.data.IContainerImageRepository[]> {
+    const { owner, repo } = this.splitOwnerRepo(projectFullPath);
+    try {
+      const packages = await this.requestPaginated<any>(
+        `/api/v1/packages/${encodeURIComponent(owner)}?type=container&q=${encodeURIComponent(repo)}`,
+      );
+      const byName = new Map<string, any[]>();
+      for (const packageItem of packages) {
+        if (packageItem.type !== 'container') continue;
+        const repositoryFullName = packageItem.repository?.full_name;
+        if (!repositoryFullName || repositoryFullName !== projectFullPath) continue;
+        const name = packageItem.name || repo;
+        const list = byName.get(name) || [];
+        list.push(packageItem);
+        byName.set(name, list);
+      }
+
+      const registryHost = new URL(this.baseUrl).host;
+      return [...byName.entries()].map(([packageName, versions]) => {
+        const imagePath = packageName.startsWith(`${owner}/`) ? packageName : `${owner}/${packageName}`;
+        return {
+          id: imagePath,
+          name: packageName,
+          path: imagePath,
+          location: `${registryHost}/${imagePath}`,
+          projectFullPath,
+          tags: versions.map((version) => ({
+            name: version.version,
+            location: `${registryHost}/${imagePath}:${version.version}`,
+            createdAt: version.created_at,
+          })),
+        };
+      });
+    } catch (err) {
+      if (this.isNotFoundError(err)) return [];
+      throw err;
+    }
+  }
+
+  async deleteContainerImageTag(
+    _projectFullPath: string,
+    repositoryId: string,
+    tagName: string,
+  ): Promise<void> {
+    const [owner, ...packageNameParts] = repositoryId.split('/');
+    const packageName = packageNameParts.join('/');
+    if (!owner || !packageName) {
+      throw new Error(`Invalid Gitea container repository ID: ${repositoryId}`);
+    }
+    try {
+      await this.requestVoid(
+        'DELETE',
+        `/api/v1/packages/${encodeURIComponent(owner)}/container/${encodeURIComponent(packageName)}/${encodeURIComponent(tagName)}`,
+      );
+    } catch (err) {
+      if (!this.isNotFoundError(err)) throw err;
+    }
+  }
+
   // --- Mappers ---
 
+  private splitOwnerRepo(projectFullPath: string): { owner: string; repo: string } {
+    const [owner, ...repoParts] = projectFullPath.split('/');
+    const repo = repoParts.join('/');
+    if (!owner || !repo) {
+      throw new Error(`Invalid Gitea repository path: ${projectFullPath}`);
+    }
+    return { owner, repo };
+  }
+
+  private async requestPaginated<T>(path: string): Promise<T[]> {
+    const items: T[] = [];
+    const limit = 100;
+    const maxPages = 1000;
+    for (let page = 1; page <= maxPages; page++) {
+      const separator = path.includes('?') ? '&' : '?';
+      const requestPath = `${path}${separator}page=${page}&limit=${limit}`;
+      const pageItems = await this.requestJson<T[]>('GET', requestPath);
+      if (!Array.isArray(pageItems) || pageItems.length === 0) break;
+      items.push(...pageItems);
+      if (pageItems.length < limit) break;
+    }
+    if (items.length >= limit * maxPages) {
+      throw new Error(`Pagination exceeded ${maxPages} pages for ${path}`);
+    }
+    return items;
+  }
+
+  private async requestJson<T>(method: string, path: string, body?: Record<string, unknown>): Promise<T> {
+    const headers: Record<string, string> = { Authorization: `token ${this.token}` };
+    if (body) headers['Content-Type'] = 'application/json';
+    return await this.fetchJsonWithTimeout<T>(
+      `${this.baseUrl.replace(/\/+$/, '')}${path}`,
+      {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+      },
+      `Gitea ${method} ${path}`,
+    );
+  }
+
+  private async requestVoid(method: string, path: string): Promise<void> {
+    await this.fetchVoidWithTimeout(
+      `${this.baseUrl.replace(/\/+$/, '')}${path}`,
+      {
+        method,
+        headers: { Authorization: `token ${this.token}` },
+      },
+      `Gitea ${method} ${path}`,
+    );
+  }
+
+  private isNotFoundError(err: unknown): boolean {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    return errMsg.includes(': 404 ') || errMsg.includes(': 404 -') || errMsg.includes(' 404 Not Found');
+  }
+
+  private async getReleaseByTag(projectFullPath: string, tagName: string): Promise<interfaces.data.IRelease | null> {
+    const { owner, repo } = this.splitOwnerRepo(projectFullPath);
+    try {
+      const release = await this.requestJson<any>(
+        'GET',
+        `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/tags/${encodeURIComponent(tagName)}`,
+      );
+      return this.mapRelease(release);
+    } catch (err) {
+      if (this.isNotFoundError(err)) return null;
+      throw err;
+    }
+  }
+
+  private mapRelease(raw: any): interfaces.data.IRelease {
+    const assets = Array.isArray(raw.assets) ? raw.assets : [];
+    return {
+      id: raw.id ? String(raw.id) : undefined,
+      tagName: raw.tag_name,
+      name: raw.name || raw.tag_name,
+      description: raw.body || '',
+      releasedAt: raw.published_at,
+      createdAt: raw.created_at,
+      draft: !!raw.draft,
+      preRelease: !!raw.prerelease,
+      targetCommitish: raw.target_commitish,
+      assets: assets.map((asset: any) => this.mapReleaseAsset(asset)),
+    };
+  }
+
+  private mapReleaseAsset(raw: any): interfaces.data.IReleaseAsset {
+    return {
+      id: raw.id ? String(raw.id) : undefined,
+      name: raw.name || '',
+      kind: 'attachment',
+      url: raw.browser_download_url,
+      downloadUrl: raw.browser_download_url,
+      size: raw.size,
+    };
+  }
+
   private mapProject(r: plugins.giteaClient.GiteaRepository): interfaces.data.IProject {
     return {
       id: r.fullName || String(r.id),