@shipfox/api-integration-gitea 2.0.0

package/src/api/client.ts

@@ -0,0 +1,364 @@
+import {Buffer} from 'node:buffer';
+import {MAX_REPOSITORY_FILE_BYTES} from '@shipfox/api-integration-core-dto';
+import {config} from '#config.js';
+import {GiteaIntegrationProviderError} from '#core/errors.js';
+
+const TRAILING_SLASHES_RE = /\/+$/;
+const NEXT_PAGE_RE = /[?&]page=(\d+)/;
+
+// Recursive tree listing is a single call; a tree larger than this is reported as
+// truncated by Gitea and surfaced to the adapter as `too-many-files`.
+const TREE_PAGE_SIZE = 1000;
+
+export interface GiteaRepository {
+  ownerLogin: string;
+  name: string;
+  fullName: string;
+  defaultBranch: string;
+  private: boolean;
+  cloneUrl: string;
+  htmlUrl: string;
+}
+
+export interface GiteaRepositoryPage {
+  repositories: GiteaRepository[];
+  nextCursor: string | null;
+}
+
+export interface GiteaTreeBlob {
+  path: string;
+  size: number | null;
+}
+
+export interface GiteaTree {
+  blobs: GiteaTreeBlob[];
+  truncated: boolean;
+}
+
+export interface GiteaFileContent {
+  path: string;
+  content: string;
+  size: number;
+}
+
+export interface GiteaApiClient {
+  listOrgRepositories(input: {
+    org: string;
+    limit: number;
+    cursor?: string | undefined;
+  }): Promise<GiteaRepositoryPage>;
+  getRepository(input: {owner: string; repo: string}): Promise<GiteaRepository>;
+  resolveRef(input: {owner: string; repo: string; ref: string}): Promise<string>;
+  listTree(input: {owner: string; repo: string; sha: string}): Promise<GiteaTree>;
+  fetchFileContent(input: {
+    owner: string;
+    repo: string;
+    path: string;
+    ref: string;
+  }): Promise<GiteaFileContent>;
+  organizationExists(input: {org: string}): Promise<boolean>;
+}
+
+export function createGiteaApiClient(): GiteaApiClient {
+  return new HttpGiteaApiClient();
+}
+
+class HttpGiteaApiClient implements GiteaApiClient {
+  private cachedBaseApiUrl: string | undefined;
+  private cachedAuthHeader: string | undefined;
+
+  async listOrgRepositories(input: {
+    org: string;
+    limit: number;
+    cursor?: string | undefined;
+  }): Promise<GiteaRepositoryPage> {
+    const response = await this.request(`orgs/${encodeURIComponent(input.org)}/repos`, {
+      page: String(cursorToPage(input.cursor)),
+      limit: String(input.limit),
+    });
+    const data = await response.json();
+    if (!Array.isArray(data)) {
+      throw new GiteaIntegrationProviderError(
+        'malformed-provider-response',
+        'Gitea repository list response was not an array',
+      );
+    }
+
+    return {
+      repositories: data.map(toGiteaRepository),
+      nextCursor: nextCursorFromLink(response.headers.get('link')),
+    };
+  }
+
+  async getRepository(input: {owner: string; repo: string}): Promise<GiteaRepository> {
+    const response = await this.request(
+      `repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}`,
+    );
+    return toGiteaRepository(await response.json());
+  }
+
+  async resolveRef(input: {owner: string; repo: string; ref: string}): Promise<string> {
+    const response = await this.request(
+      `repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}/commits`,
+      {sha: input.ref, limit: '1', stat: 'false', verification: 'false', files: 'false'},
+    );
+    const data = await response.json();
+    const head = Array.isArray(data) ? data[0] : undefined;
+    if (!isRecord(head) || typeof head.sha !== 'string') {
+      throw new GiteaIntegrationProviderError(
+        'repository-not-found',
+        `Gitea ref ${input.ref} did not resolve to a commit`,
+      );
+    }
+    return head.sha;
+  }
+
+  async listTree(input: {owner: string; repo: string; sha: string}): Promise<GiteaTree> {
+    const response = await this.request(
+      `repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}/git/trees/${encodeURIComponent(input.sha)}`,
+      {recursive: 'true', per_page: String(TREE_PAGE_SIZE)},
+    );
+    const data = await response.json();
+    if (!isRecord(data)) {
+      throw new GiteaIntegrationProviderError(
+        'malformed-provider-response',
+        'Gitea tree response was not an object',
+      );
+    }
+
+    const entries = Array.isArray(data.tree) ? data.tree : [];
+    const blobs: GiteaTreeBlob[] = [];
+    for (const entry of entries) {
+      if (isRecord(entry) && entry.type === 'blob' && typeof entry.path === 'string') {
+        blobs.push({path: entry.path, size: typeof entry.size === 'number' ? entry.size : null});
+      }
+    }
+
+    return {blobs, truncated: data.truncated === true};
+  }
+
+  async fetchFileContent(input: {
+    owner: string;
+    repo: string;
+    path: string;
+    ref: string;
+  }): Promise<GiteaFileContent> {
+    const response = await this.request(
+      `repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}/contents/${encodePath(input.path)}`,
+      {ref: input.ref},
+      {notFoundReason: 'file-not-found'},
+    );
+    const data = await response.json();
+
+    // Gitea returns an array for a directory path and an object for a single file;
+    // a non-file response means the requested path is not a readable file.
+    if (!isRecord(data) || Array.isArray(data) || data.type !== 'file') {
+      throw new GiteaIntegrationProviderError(
+        'file-not-found',
+        `Gitea path ${input.path} is not a file`,
+      );
+    }
+
+    // A well-formed Gitea file response always carries a numeric size; coercing a
+    // missing size to 0 would skip the limit guard below and decode unbounded content.
+    if (typeof data.size !== 'number') {
+      throw new GiteaIntegrationProviderError(
+        'malformed-provider-response',
+        'Gitea file response did not include a numeric size',
+      );
+    }
+    const size = data.size;
+    if (size > MAX_REPOSITORY_FILE_BYTES) {
+      throw new GiteaIntegrationProviderError(
+        'content-too-large',
+        'Gitea file content is larger than the supported limit',
+      );
+    }
+    if (typeof data.content !== 'string' || data.encoding !== 'base64') {
+      throw new GiteaIntegrationProviderError(
+        'malformed-provider-response',
+        'Gitea file response did not include base64 content',
+      );
+    }
+
+    return {
+      path: typeof data.path === 'string' ? data.path : input.path,
+      size,
+      content: Buffer.from(data.content, 'base64').toString('utf8'),
+    };
+  }
+
+  async organizationExists(input: {org: string}): Promise<boolean> {
+    const response = await this.requestRaw(`orgs/${encodeURIComponent(input.org)}`);
+    if (response.ok) return true;
+    if (response.status === 404) return false;
+    throw giteaHttpError(response);
+  }
+
+  private async request(
+    path: string,
+    searchParams: Record<string, string> = {},
+    options: {notFoundReason?: NotFoundReason} = {},
+  ): Promise<Response> {
+    const response = await this.requestRaw(path, {searchParams});
+    if (!response.ok)
+      throw giteaHttpError(response, options.notFoundReason ?? 'repository-not-found');
+    return response;
+  }
+
+  private async requestRaw(
+    path: string,
+    options: {method?: string; searchParams?: Record<string, string>; body?: unknown} = {},
+  ): Promise<Response> {
+    const url = new URL(`${this.baseApiUrl()}/${path}`);
+    for (const [key, value] of Object.entries(options.searchParams ?? {})) {
+      url.searchParams.set(key, value);
+    }
+
+    const headers: Record<string, string> = {
+      authorization: this.authHeader(),
+      accept: 'application/json',
+    };
+    const init: RequestInit = {
+      method: options.method ?? 'GET',
+      headers,
+      signal: AbortSignal.timeout(config.GITEA_REQUEST_TIMEOUT_MS),
+    };
+    if (options.body !== undefined) {
+      headers['content-type'] = 'application/json';
+      init.body = JSON.stringify(options.body);
+    }
+
+    try {
+      return await fetch(url, init);
+    } catch (error) {
+      // A bare `fetch` has no request timeout, so an unresponsive Gitea would
+      // otherwise hold the worker open indefinitely; the AbortSignal.timeout
+      // above surfaces as a fast `timeout` (503) instead of stalling.
+      if (
+        error instanceof Error &&
+        (error.name === 'TimeoutError' || error.name === 'AbortError')
+      ) {
+        throw new GiteaIntegrationProviderError('timeout', 'Gitea request timed out');
+      }
+      throw new GiteaIntegrationProviderError(
+        'provider-unavailable',
+        `Gitea request failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  private baseApiUrl(): string {
+    if (!this.cachedBaseApiUrl) {
+      this.cachedBaseApiUrl = `${config.GITEA_BASE_URL.replace(TRAILING_SLASHES_RE, '')}/api/v1`;
+    }
+    return this.cachedBaseApiUrl;
+  }
+
+  private authHeader(): string {
+    if (!this.cachedAuthHeader) {
+      const credentials = `${config.GITEA_SERVICE_USERNAME}:${config.GITEA_SERVICE_TOKEN}`;
+      this.cachedAuthHeader = `Basic ${Buffer.from(credentials).toString('base64')}`;
+    }
+    return this.cachedAuthHeader;
+  }
+}
+
+type NotFoundReason = 'repository-not-found' | 'file-not-found';
+
+function giteaHttpError(
+  response: Response,
+  notFoundReason: NotFoundReason = 'repository-not-found',
+): GiteaIntegrationProviderError {
+  const status = response.status;
+  if (status === 404) {
+    return new GiteaIntegrationProviderError(notFoundReason, `Gitea responded ${status}`);
+  }
+  if (isRateLimited(response)) {
+    return new GiteaIntegrationProviderError(
+      'rate-limited',
+      `Gitea responded ${status}`,
+      retryAfterSeconds(response),
+    );
+  }
+  if (status === 401 || status === 403) {
+    return new GiteaIntegrationProviderError('access-denied', `Gitea responded ${status}`);
+  }
+  // Server errors and any other unexpected status mean the provider could not
+  // serve the request; surface it as unavailable rather than leaking a raw error.
+  return new GiteaIntegrationProviderError('provider-unavailable', `Gitea responded ${status}`);
+}
+
+function isRateLimited(response: Response): boolean {
+  if (response.status === 429) return true;
+  return response.status === 403 && response.headers.get('x-ratelimit-remaining') === '0';
+}
+
+function retryAfterSeconds(response: Response): number | undefined {
+  const retryAfter = response.headers.get('retry-after');
+  if (!retryAfter) return undefined;
+  const parsed = Number.parseInt(retryAfter, 10);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+
+function cursorToPage(cursor: string | undefined): number {
+  if (!cursor) return 1;
+  const page = Number.parseInt(cursor, 10);
+  return Number.isNaN(page) || page < 1 ? 1 : page;
+}
+
+function nextCursorFromLink(link: string | null): string | null {
+  if (!link) return null;
+  const next = link.split(',').find((part) => part.includes('rel="next"'));
+  if (!next) return null;
+  const match = next.match(NEXT_PAGE_RE);
+  return match?.[1] ?? null;
+}
+
+function encodePath(path: string): string {
+  const segments = path.split('/');
+  // `..`/`.`/empty segments survive encodeURIComponent and would let `new URL`
+  // normalize the request path out of `/contents/` and hit other authenticated
+  // Gitea endpoints, so reject them before building the URL.
+  for (const segment of segments) {
+    if (segment === '' || segment === '.' || segment === '..') {
+      throw new GiteaIntegrationProviderError(
+        'file-not-found',
+        `Gitea path contains an invalid segment: ${path}`,
+      );
+    }
+  }
+  return segments.map(encodeURIComponent).join('/');
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function toGiteaRepository(raw: unknown): GiteaRepository {
+  if (
+    !isRecord(raw) ||
+    !isRecord(raw.owner) ||
+    typeof raw.owner.login !== 'string' ||
+    typeof raw.name !== 'string' ||
+    typeof raw.full_name !== 'string' ||
+    typeof raw.default_branch !== 'string' ||
+    typeof raw.clone_url !== 'string' ||
+    typeof raw.html_url !== 'string'
+  ) {
+    throw new GiteaIntegrationProviderError(
+      'malformed-provider-response',
+      'Gitea repository response is missing required fields',
+    );
+  }
+
+  return {
+    ownerLogin: raw.owner.login,
+    name: raw.name,
+    fullName: raw.full_name,
+    defaultBranch: raw.default_branch,
+    private: raw.private === true,
+    cloneUrl: raw.clone_url,
+    htmlUrl: raw.html_url,
+  };
+}

package/src/config.ts

@@ -0,0 +1,42 @@
+import {createConfig, num, str, url} from '@shipfox/config';
+
+export const config = createConfig({
+  GITEA_BASE_URL: url({
+    desc: 'Base URL of the Gitea instance the provider connects to, including the scheme (for example https://gitea.example.com). Required.',
+  }),
+  GITEA_CLONE_BASE_URL: str({
+    desc: 'Base URL runners use when cloning Gitea repositories. Leave it unset to use clone URLs reported by Gitea, or set it when runners reach Gitea through a different scheme, host, or port.',
+    default: undefined,
+  }),
+  GITEA_SERVICE_USERNAME: str({
+    desc: 'Username of the Gitea service account the provider authenticates as. Required.',
+  }),
+  GITEA_SERVICE_TOKEN: str({
+    desc: 'Access token or bot password of the Gitea service account, used for REST API and git-http basic auth. Required.',
+  }),
+  GITEA_WEBHOOK_SECRET: str({
+    desc: 'Secret used to verify incoming Gitea webhooks. Must match the org webhook secret set by the instance admin. Required.',
+  }),
+  GITEA_CHECKOUT_TTL_SECONDS: num({
+    desc: 'Lifetime in seconds of the checkout credentials handed to the runner. Defaults to 300 (five minutes).',
+    default: 300,
+  }),
+  GITEA_REQUEST_TIMEOUT_MS: num({
+    desc: 'How long in milliseconds the provider waits for a Gitea REST API response before giving up. A request that exceeds this fails as a timeout instead of holding an API worker open. Defaults to 10000 (ten seconds).',
+    default: 10_000,
+  }),
+});
+
+export const giteaCloneBaseOrigin = parseGiteaCloneBaseOrigin(config.GITEA_CLONE_BASE_URL);
+
+function parseGiteaCloneBaseOrigin(value: string | undefined): URL | undefined {
+  if (!value) return undefined;
+
+  try {
+    return new URL(value);
+  } catch {
+    throw new Error(
+      'GITEA_CLONE_BASE_URL must be an absolute URL with a scheme, host, and optional port.',
+    );
+  }
+}

package/src/connection-external-url.test.ts

@@ -0,0 +1,36 @@
+import type {GiteaApiClient} from '#api/client.js';
+import {createGiteaIntegrationProvider} from '#index.js';
+
+function giteaClient(): GiteaApiClient {
+  return {
+    listOrgRepositories: vi.fn(() => Promise.reject(new Error('not used'))),
+    getRepository: vi.fn(() => Promise.reject(new Error('not used'))),
+    resolveRef: vi.fn(() => Promise.reject(new Error('not used'))),
+    listTree: vi.fn(() => Promise.reject(new Error('not used'))),
+    fetchFileContent: vi.fn(() => Promise.reject(new Error('not used'))),
+    organizationExists: vi.fn(() => Promise.reject(new Error('not used'))),
+  };
+}
+
+function createProvider() {
+  return createGiteaIntegrationProvider({
+    gitea: giteaClient(),
+    getExistingGiteaConnection: vi.fn(() => Promise.resolve(undefined)),
+    connectGiteaConnection: vi.fn() as never,
+    // Provider-level mounting includes webhook routes; this test exercises only URLs.
+    coreDb: vi.fn() as never,
+    publishSourcePush: vi.fn() as never,
+    recordDeliveryOnly: vi.fn() as never,
+    getIntegrationConnectionById: vi.fn() as never,
+  });
+}
+
+describe('gitea connectionExternalUrl', () => {
+  it('points at the org page on the configured Gitea instance', async () => {
+    const provider = createProvider();
+
+    const url = await provider.connectionExternalUrl({externalAccountId: 'shipfox'});
+
+    expect(url).toBe('https://gitea.example.com/shipfox');
+  });
+});

package/src/core/connect.test.ts

@@ -0,0 +1,149 @@
+import type {IntegrationConnection} from '@shipfox/api-integration-core-dto';
+import type {GiteaApiClient} from '#api/client.js';
+import {handleGiteaConnect} from '#core/connect.js';
+import {GiteaOrgAlreadyLinkedError, GiteaOrganizationNotFoundError} from '#core/errors.js';
+
+function giteaClient(overrides: Partial<GiteaApiClient> = {}): GiteaApiClient {
+  return {
+    listOrgRepositories: vi.fn(() => Promise.reject(new Error('not used'))),
+    getRepository: vi.fn(() => Promise.reject(new Error('not used'))),
+    resolveRef: vi.fn(() => Promise.reject(new Error('not used'))),
+    listTree: vi.fn(() => Promise.reject(new Error('not used'))),
+    fetchFileContent: vi.fn(() => Promise.reject(new Error('not used'))),
+    organizationExists: vi.fn(() => Promise.resolve(true)),
+    ...overrides,
+  };
+}
+
+function connection(
+  overrides: Partial<IntegrationConnection<'gitea'>> = {},
+): IntegrationConnection<'gitea'> {
+  return {
+    id: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    provider: 'gitea',
+    externalAccountId: 'shipfox',
+    slug: 'gitea_shipfox',
+    displayName: 'Gitea shipfox',
+    lifecycleStatus: 'active',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...overrides,
+  };
+}
+
+describe('handleGiteaConnect', () => {
+  it('rejects an org that does not exist on the Gitea instance', async () => {
+    const gitea = giteaClient({organizationExists: vi.fn(() => Promise.resolve(false))});
+    const connectGiteaConnection = vi.fn();
+
+    const result = handleGiteaConnect({
+      gitea,
+      workspaceId: crypto.randomUUID(),
+      org: 'ghost',
+      getExistingGiteaConnection: vi.fn(() => Promise.resolve(undefined)),
+      connectGiteaConnection,
+    });
+
+    await expect(result).rejects.toBeInstanceOf(GiteaOrganizationNotFoundError);
+    expect(connectGiteaConnection).not.toHaveBeenCalled();
+  });
+
+  it('rejects an org already linked to another workspace', async () => {
+    const gitea = giteaClient();
+    const existing = connection({workspaceId: 'workspace-a'});
+    const connectGiteaConnection = vi.fn();
+
+    const result = handleGiteaConnect({
+      gitea,
+      workspaceId: 'workspace-b',
+      org: 'shipfox',
+      getExistingGiteaConnection: vi.fn(() => Promise.resolve(existing)),
+      connectGiteaConnection,
+    });
+
+    await expect(result).rejects.toBeInstanceOf(GiteaOrgAlreadyLinkedError);
+    expect(connectGiteaConnection).not.toHaveBeenCalled();
+  });
+
+  it('returns the existing active connection unchanged', async () => {
+    const gitea = giteaClient();
+    const workspaceId = crypto.randomUUID();
+    const existing = connection({workspaceId, lifecycleStatus: 'active'});
+    const connectGiteaConnection = vi.fn();
+
+    const result = await handleGiteaConnect({
+      gitea,
+      workspaceId,
+      org: 'shipfox',
+      getExistingGiteaConnection: vi.fn(() => Promise.resolve(existing)),
+      connectGiteaConnection,
+    });
+
+    expect(result).toBe(existing);
+    expect(connectGiteaConnection).not.toHaveBeenCalled();
+  });
+
+  it('persists the connection for a new org', async () => {
+    const gitea = giteaClient();
+    const workspaceId = crypto.randomUUID();
+    const connected = connection({workspaceId, externalAccountId: 'shipfox'});
+    const connectGiteaConnection = vi.fn(() => Promise.resolve(connected));
+
+    const result = await handleGiteaConnect({
+      gitea,
+      workspaceId,
+      org: 'shipfox',
+      getExistingGiteaConnection: vi.fn(() => Promise.resolve(undefined)),
+      connectGiteaConnection,
+    });
+
+    expect(connectGiteaConnection).toHaveBeenCalledWith({
+      workspaceId,
+      org: 'shipfox',
+      displayName: 'Gitea shipfox',
+    });
+    expect(result).toBe(connected);
+  });
+
+  it('canonicalizes org case so a case variant cannot bypass the cross-tenant guard', async () => {
+    const gitea = giteaClient();
+    const existing = connection({workspaceId: 'workspace-a', externalAccountId: 'acme'});
+    const getExistingGiteaConnection = vi.fn(() => Promise.resolve(existing));
+    const connectGiteaConnection = vi.fn();
+
+    const result = handleGiteaConnect({
+      gitea,
+      workspaceId: 'workspace-b',
+      org: 'Acme',
+      getExistingGiteaConnection,
+      connectGiteaConnection,
+    });
+
+    await expect(result).rejects.toBeInstanceOf(GiteaOrgAlreadyLinkedError);
+    expect(gitea.organizationExists).toHaveBeenCalledWith({org: 'acme'});
+    expect(getExistingGiteaConnection).toHaveBeenCalledWith({org: 'acme'});
+    expect(connectGiteaConnection).not.toHaveBeenCalled();
+  });
+
+  it('persists the canonical lowercase org for a new connection', async () => {
+    const gitea = giteaClient();
+    const workspaceId = crypto.randomUUID();
+    const connected = connection({workspaceId, externalAccountId: 'shipfox'});
+    const connectGiteaConnection = vi.fn(() => Promise.resolve(connected));
+
+    await handleGiteaConnect({
+      gitea,
+      workspaceId,
+      org: 'ShipFox',
+      getExistingGiteaConnection: vi.fn(() => Promise.resolve(undefined)),
+      connectGiteaConnection,
+    });
+
+    expect(connectGiteaConnection).toHaveBeenCalledWith({
+      workspaceId,
+      org: 'shipfox',
+      displayName: 'Gitea shipfox',
+    });
+  });
+});

package/src/core/connect.ts

@@ -0,0 +1,52 @@
+import type {IntegrationConnection} from '@shipfox/api-integration-core-dto';
+import type {GiteaApiClient} from '#api/client.js';
+import {GiteaOrgAlreadyLinkedError, GiteaOrganizationNotFoundError} from './errors.js';
+
+export interface ConnectGiteaConnectionInput {
+  workspaceId: string;
+  org: string;
+  displayName: string;
+}
+
+export interface HandleGiteaConnectParams {
+  gitea: GiteaApiClient;
+  workspaceId: string;
+  org: string;
+  getExistingGiteaConnection: (input: {
+    org: string;
+  }) => Promise<IntegrationConnection<'gitea'> | undefined>;
+  connectGiteaConnection: (
+    input: ConnectGiteaConnectionInput,
+  ) => Promise<IntegrationConnection<'gitea'>>;
+}
+
+export async function handleGiteaConnect(
+  params: HandleGiteaConnectParams,
+): Promise<IntegrationConnection<'gitea'>> {
+  // Gitea resolves org names case-insensitively, but the ownership lookup and the
+  // unique indexes that back the cross-tenant guard compare the stored `org`
+  // case-sensitively. Canonicalize once here so a case variant ("Acme" vs "acme")
+  // cannot slip past getExistingGiteaConnection and link an org another workspace
+  // already owns. The source-control scope guard already lowercases both sides.
+  const org = params.org.toLowerCase();
+
+  if (!(await params.gitea.organizationExists({org}))) {
+    throw new GiteaOrganizationNotFoundError(org);
+  }
+
+  const existing = await params.getExistingGiteaConnection({org});
+  if (existing && existing.workspaceId !== params.workspaceId) {
+    throw new GiteaOrgAlreadyLinkedError(org);
+  }
+  if (existing && existing.lifecycleStatus === 'active') {
+    return existing;
+  }
+
+  // The read-only service account cannot manage org hooks; the instance admin
+  // provisions push delivery out of band.
+  return await params.connectGiteaConnection({
+    workspaceId: params.workspaceId,
+    org,
+    displayName: `Gitea ${org}`,
+  });
+}

package/src/core/connection-url.ts

@@ -0,0 +1,8 @@
+import {config} from '#config.js';
+
+const TRAILING_SLASHES_RE = /\/+$/;
+
+export function giteaConnectionExternalUrl(externalAccountId: string): string {
+  const base = config.GITEA_BASE_URL.replace(TRAILING_SLASHES_RE, '');
+  return `${base}/${encodeURIComponent(externalAccountId)}`;
+}

package/src/core/errors.ts

@@ -0,0 +1,17 @@
+import {IntegrationProviderError} from '@shipfox/api-integration-core-dto';
+
+export class GiteaIntegrationProviderError extends IntegrationProviderError {}
+
+export class GiteaOrganizationNotFoundError extends Error {
+  constructor(org: string) {
+    super(`Gitea organization not found: ${org}`);
+    this.name = 'GiteaOrganizationNotFoundError';
+  }
+}
+
+export class GiteaOrgAlreadyLinkedError extends Error {
+  constructor(org: string) {
+    super(`Gitea organization is already linked to another Shipfox workspace: ${org}`);
+    this.name = 'GiteaOrgAlreadyLinkedError';
+  }
+}