feat: integration support for harness

Signed-off-by: Calvin Lee <cjlee@ualberta.ca>

.changeset/empty-beers-relax.md

@@ -0,0 +1,5 @@
+---
+'@backstage/backend-common': patch
+---
+
+This patch adds HarnessURLReader to the available classes. It currently only reads single files via Harness codes public repo api.

.changeset/tasty-rats-explain.md

@@ -0,0 +1,5 @@
+---
+'@backstage/integration': minor
+---
+
+This patch brings Harness Code as a valid integration via the ScmIntgration interface. It adds harness code to the relevant static properties ( get integration by name, get integration by type) for plugs to be able to reference the same harness code server

.github/vale/config/vocabularies/Backstage/accept.txt

@@ -152,6 +152,8 @@ graphviz
 Hackathons
 haproxy
 hardcoded
+Harness
+harness
 Helidon
 Henneke
 Heroku

docs/integrations/harness/locations.md

@@ -0,0 +1,33 @@
+---
+id: locations
+title: Harness Locations
+sidebar_label: Locations
+description: Integrating source code stored in Harness Code into the Backstage catalog
+---
+
+The Harness Code integration supports loading catalog entities from a hosted repository. Entities can be added to
+[static catalog configuration](../../features/software-catalog/configuration.md),
+registered with the
+[catalog-import](https://github.com/backstage/backstage/tree/master/plugins/catalog-import)
+plugin.
+
+## Configuration
+
+To use this integration, add configuration to your root `app-config.yaml`:
+
+```yaml
+integrations:
+  harness:
+    - host: app.harness.io
+      token: ${HARNESS_CODE_BEARER_TOKEN}
+```
+
+Directly under the `harnessCode` key is a list of provider configurations, where you
+can list the Gitea instances you want to be able to fetch
+data from. Each entry is a structure with up to four elements:
+
+- `host`: The host of the Harness Code instance that you want to match on.
+- `baseUrl` (optional): Needed if the Harness Code instance is not reachable at
+  the base of the `host` option (e.g. `https://app.harness.io`). This is the address that you would open in a browser.
+- `username` (optional): The gitea username to use in API requests.
+- `token` (optional): The password or api token to authenticate with.

microsite/sidebars.json

@@ -238,6 +238,11 @@
         "label": "Gitea",
         "items": ["integrations/gitea/locations"]
       },
+      {
+        "type": "subcategory",
+        "label": "Harness",
+        "ids": ["integrations/harness/locations"]
+      },
       {
         "type": "category",
         "label": "Google GCS",

packages/backend-common/api-report.md

@@ -30,6 +30,7 @@ import { GiteaIntegration } from '@backstage/integration';
 import { GithubCredentialsProvider } from '@backstage/integration';
 import { GithubIntegration } from '@backstage/integration';
 import { GitLabIntegration } from '@backstage/integration';
+import { HarnessIntegration } from '@backstage/integration';
 import { HostDiscovery as HostDiscovery_2 } from '@backstage/backend-app-api';
 import { HttpAuthService } from '@backstage/backend-plugin-api';
 import { IdentityService } from '@backstage/backend-plugin-api';
@@ -530,6 +531,31 @@ export class GitlabUrlReader implements UrlReader {
   toString(): string;
 }
 
+// @public
+export class HarnessUrlReader implements UrlReader {
+  constructor(integration: HarnessIntegration);
+  // (undocumented)
+  static factory: ReaderFactory;
+  // (undocumented)
+  read(url: string): Promise<Buffer>;
+  // (undocumented)
+  readTree(): Promise<ReadTreeResponse>;
+  // (undocumented)
+  readUrl(url: string, options?: ReadUrlOptions): Promise<ReadUrlResponse>;
+  // (undocumented)
+  search(): Promise<SearchResponse>;
+  // (undocumented)
+  toString(): string;
+}
+
+// @public
+export type HarnessIntegrationConfig = {
+  host: string;
+  baseUrl?: string;
+  username?: string;
+  token?: string;
+};
+
 // @public
 export const HostDiscovery: typeof HostDiscovery_2;
 

packages/backend-common/src/reading/HarnessCodeUrlReader.test.ts

@@ -0,0 +1,204 @@
+/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { setupRequestMockHandlers } from '@backstage/backend-test-utils';
+import { ConfigReader } from '@backstage/config';
+import { HarnessIntegration, readHarnessConfig } from '@backstage/integration';
+import { JsonObject } from '@backstage/types';
+import { rest } from 'msw';
+import { setupServer } from 'msw/node';
+import { getVoidLogger } from '../logging';
+import { UrlReaderPredicateTuple } from './types';
+import { DefaultReadTreeResponseFactory } from './tree';
+import getRawBody from 'raw-body';
+import { HarnessUrlReader } from './HarnessUrlReader';
+import { NotFoundError } from '@backstage/errors';
+
+const treeResponseFactory = DefaultReadTreeResponseFactory.create({
+  config: new ConfigReader({}),
+});
+
+jest.mock('../scm', () => ({
+  Git: {
+    fromAuth: () => ({
+      clone: jest.fn(() => Promise.resolve({})),
+    }),
+  },
+}));
+
+const harnessProcessor = new HarnessUrlReader(
+  new HarnessIntegration(
+    readHarnessConfig(
+      new ConfigReader({
+        host: 'app.harness.io',
+      }),
+    ),
+  ),
+);
+
+const createReader = (config: JsonObject): UrlReaderPredicateTuple[] => {
+  return HarnessUrlReader.factory({
+    config: new ConfigReader(config),
+    logger: getVoidLogger(),
+    treeResponseFactory,
+  });
+};
+
+describe('HarnessUrlReader', () => {
+  const worker = setupServer();
+  setupRequestMockHandlers(worker);
+
+  afterAll(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('reader factory', () => {
+    it('creates a reader.', () => {
+      const readers = createReader({
+        integrations: {
+          harness: [{ host: 'app.harness.io' }],
+        },
+      });
+      expect(readers).toHaveLength(1);
+    });
+
+    it('should not create a default entry.', () => {
+      const readers = createReader({
+        integrations: {},
+      });
+      expect(readers).toHaveLength(0);
+    });
+  });
+
+  describe('predicates', () => {
+    it('returns true for the configured host', () => {
+      const readers = createReader({
+        integrations: {
+          harness: [{ host: 'app.harness.io' }],
+        },
+      });
+      const predicate = readers[0].predicate;
+
+      expect(predicate(new URL('https://app.harness.io/path'))).toBe(true);
+    });
+
+    it('returns false for a different host.', () => {
+      const readers = createReader({
+        integrations: {
+          harness: [{ host: 'app.harness.io' }],
+        },
+      });
+      const predicate = readers[0].predicate;
+
+      expect(predicate(new URL('https://github.com/path'))).toBe(false);
+    });
+  });
+
+  describe('readUrl', () => {
+    const responseBuffer = Buffer.from('Apache License');
+    const harnessApiResponse = (content: any) => {
+      return JSON.stringify({
+        encoding: 'base64',
+        content: Buffer.from(content).toString('base64'),
+      });
+    };
+
+    it.skip('should be able to read file contents as buffer', async () => {
+      worker.use(
+        rest.get(
+          'https://app.harness.io/api/v1/repos/owner/project/contents/LICENSE',
+          (req, res, ctx) => {
+            // Test utils prefers matching URL directly but it is part of Gitea's API
+            if (req.url.searchParams.get('ref') === 'branch2') {
+              return res(
+                ctx.status(200),
+                ctx.body(harnessApiResponse(responseBuffer.toString())),
+              );
+            }
+
+            return res(ctx.status(500));
+          },
+        ),
+      );
+
+      const result = await harnessProcessor.readUrl(
+        'https://app.harness.io/owner/project/src/branch/branch2/LICENSE',
+      );
+      const buffer = await result.buffer();
+      expect(buffer.toString()).toBe(responseBuffer.toString());
+    });
+
+    it.skip('should be able to read file contents as stream', async () => {
+      worker.use(
+        rest.get(
+          'https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/files/refMain/~/LICENSE.txt',
+          (req, res, ctx) => {
+            if (req.url.searchParams.get('ref') === 'refMain') {
+              return res(
+                ctx.status(200),
+                ctx.body(harnessApiResponse(responseBuffer.toString())),
+              );
+            }
+
+            return res(ctx.status(500));
+          },
+        ),
+      );
+
+      const result = await harnessProcessor.readUrl(
+        'https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/files/refMain/~/LICENSE.TXT',
+      );
+      const fromStream = await getRawBody(result.stream!());
+      expect(fromStream.toString()).toBe(responseBuffer.toString());
+    });
+
+    it.skip('should raise NotFoundError on 404.', async () => {
+      worker.use(
+        rest.get(
+          'https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/files/refMain/~/all-apis.yaml',
+          (_, res, ctx) => {
+            return res(ctx.status(404, 'File not found.'));
+          },
+        ),
+      );
+
+      await expect(
+        harnessProcessor.readUrl(
+          'https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/files/refMain/~/all-apis.yaml',
+        ),
+      ).rejects.toThrow(NotFoundError);
+    });
+
+    it.skip('should throw an error on non 404 errors.', async () => {
+      worker.use(
+        rest.get(
+          'https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/files/refMain/~/all-apis.yaml',
+          (_, res, ctx) => {
+            return res(ctx.status(500, 'Error!!!'));
+          },
+        ),
+      );
+
+      await expect(
+        harnessProcessor.readUrl(
+          'https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/files/refMain/~/all-apis.yaml',
+        ),
+      ).rejects.toThrow(
+        'https://app.harness.io/gateway/code/api/v1/repos/accountId/orgName/projName/repoName/+/content/all-apis.yaml?routingId=accountId&include_commit=false&ref=refMain, 500 Error!!!',
+      );
+    });
+  });
+});

packages/backend-common/src/reading/HarnessUrlReader.ts

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2025 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {
+  getHarnessRequestOptions,
+  getHarnessFileContentsUrl,
+  HarnessIntegration,
+  ScmIntegrations,
+} from '@backstage/integration';
+import { ReadUrlOptions, ReadUrlResponse } from './types';
+import {
+  ReaderFactory,
+  ReadTreeResponse,
+  SearchResponse,
+  UrlReader,
+} from './types';
+import fetch, { Response } from 'node-fetch';
+import { ReadUrlResponseFactory } from './ReadUrlResponseFactory';
+import {
+  AuthenticationError,
+  NotFoundError,
+  NotModifiedError,
+} from '@backstage/errors';
+import { Readable } from 'stream';
+
+/**
+ * Implements a {@link UrlReader} for the Harness code v1 api.
+ *
+ * @public
+ */
+export class HarnessUrlReader implements UrlReader {
+  static factory: ReaderFactory = ({ config }) => {
+    return ScmIntegrations.fromConfig(config)
+      .harness.list()
+      .map(integration => {
+        const reader = new HarnessUrlReader(integration);
+        const predicate = (url: URL) => {
+          return url.host === integration.config.host;
+        };
+        return { reader, predicate };
+      });
+  };
+
+  constructor(private readonly integration: HarnessIntegration) {}
+
+  async read(url: string): Promise<Buffer> {
+    const response = await this.readUrl(url);
+    return response.buffer();
+  }
+
+  async readUrl(
+    url: string,
+    options?: ReadUrlOptions,
+  ): Promise<ReadUrlResponse> {
+    let response: Response;
+    const blobUrl = getHarnessFileContentsUrl(this.integration.config, url);
+
+    try {
+      response = await fetch(blobUrl, {
+        method: 'GET',
+        ...getHarnessRequestOptions(this.integration.config),
+        signal: options?.signal as any,
+      });
+    } catch (e) {
+      throw new Error(`Unable to read ${blobUrl}, ${e}`);
+    }
+
+    if (response.ok) {
+      // Harness Code returns an object with the file contents encoded, not the file itself
+      const jsonResponse = await response.json();
+      if (jsonResponse?.content?.encoding === 'base64') {
+        return ReadUrlResponseFactory.fromReadable(
+          Readable.from(Buffer.from(jsonResponse?.content?.data, 'base64')),
+          {
+            etag: response.headers.get('ETag') ?? undefined,
+          },
+        );
+      }
+
+      throw new Error(`Unknown encoding: ${jsonResponse?.content?.encoding}`);
+    }
+
+    const message = `${url} x ${blobUrl}, ${response.status} ${response.statusText}`;
+    if (response.status === 404) {
+      throw new NotFoundError(message);
+    }
+
+    if (response.status === 304) {
+      throw new NotModifiedError();
+    }
+
+    if (response.status === 403) {
+      throw new AuthenticationError();
+    }
+
+    throw new Error(message);
+  }
+
+  readTree(): Promise<ReadTreeResponse> {
+    throw new Error('HarnessUrlReader readTree not implemented.');
+  }
+  search(): Promise<SearchResponse> {
+    throw new Error('HarnessUrlReader search not implemented.');
+  }
+
+  toString() {
+    const { host } = this.integration.config;
+    return `harness{host=${host},authed=${Boolean(
+      this.integration.config.token,
+    )}}`;
+  }
+}

packages/backend-common/src/reading/UrlReaders.ts

@@ -31,6 +31,7 @@ import { GoogleGcsUrlReader } from './GoogleGcsUrlReader';
 import { AwsS3UrlReader } from './AwsS3UrlReader';
 import { GiteaUrlReader } from './GiteaUrlReader';
 import { AwsCodeCommitUrlReader } from './AwsCodeCommitUrlReader';
+import { HarnessUrlReader } from './HarnessUrlReader';
 
 /**
  * Creation options for {@link @backstage/backend-plugin-api#UrlReaderService}.
@@ -61,7 +62,6 @@ export class UrlReaders {
     const treeResponseFactory = DefaultReadTreeResponseFactory.create({
       config,
     });
-
     for (const factory of factories ?? []) {
       const tuples = factory({ config, logger: logger, treeResponseFactory });
 
@@ -94,6 +94,7 @@ export class UrlReaders {
         GiteaUrlReader.factory,
         GitlabUrlReader.factory,
         GoogleGcsUrlReader.factory,
+        HarnessUrlReader.factory,
         AwsS3UrlReader.factory,
         AwsCodeCommitUrlReader.factory,
         FetchUrlReader.factory,

packages/backend-common/src/reading/index.ts

@@ -22,6 +22,7 @@ export { GerritUrlReader } from './GerritUrlReader';
 export { GithubUrlReader } from './GithubUrlReader';
 export { GitlabUrlReader } from './GitlabUrlReader';
 export { GiteaUrlReader } from './GiteaUrlReader';
+export { HarnessUrlReader } from './HarnessUrlReader';
 export { AwsS3UrlReader } from './AwsS3UrlReader';
 export { FetchUrlReader } from './FetchUrlReader';
 export { ReadUrlResponseFactory } from './ReadUrlResponseFactory';

packages/integration/api-report.md

@@ -513,6 +513,19 @@ export function getGitLabRequestOptions(config: GitLabIntegrationConfig): {
   headers: Record<string, string>;
 };
 
+// @public
+export function getHarnessFileContentsUrl(
+  config: HarnessIntegrationConfig,
+  url: string,
+): string;
+
+// @public
+export function getHarnessRequestOptions(
+  config: HarnessIntegrationConfig,
+): {
+  headers?: Record<string, string>;
+};
+
 // @public
 export class GiteaIntegration implements ScmIntegration {
   constructor(config: GiteaIntegrationConfig);
@@ -539,7 +552,7 @@ export type GiteaIntegrationConfig = {
   host: string;
   baseUrl?: string;
   username?: string;
-  password?: string;
+  token?: string;
 };
 
 // @public
@@ -674,6 +687,35 @@ export type GoogleGcsIntegrationConfig = {
   privateKey?: string;
 };
 
+// @public
+export class HarnessIntegration implements ScmIntegration {
+  constructor(config: HarnessIntegrationConfig);
+  // (undocumented)
+  readonly config: HarnessIntegrationConfig;
+  // (undocumented)
+  static factory: ScmIntegrationsFactory<HarnessIntegration>;
+  // (undocumented)
+  resolveEditUrl(url: string): string;
+  // (undocumented)
+  resolveUrl(options: {
+    url: string;
+    base: string;
+    lineNumber?: number | undefined;
+  }): string;
+  // (undocumented)
+  get title(): string;
+  // (undocumented)
+  get type(): string;
+}
+
+// @public
+export type HarnessIntegrationConfig = {
+  host: string;
+  baseUrl?: string;
+  username?: string;
+  token?: string;
+};
+
 // @public
 export interface IntegrationsByType {
   // (undocumented)
@@ -696,6 +738,8 @@ export interface IntegrationsByType {
   github: ScmIntegrationsGroup<GithubIntegration>;
   // (undocumented)
   gitlab: ScmIntegrationsGroup<GitLabIntegration>;
+  // (undocumented)
+  harness: ScmIntegrationsGroup<HarnessIntegration>;
 }
 
 // @public
@@ -839,6 +883,11 @@ export function readGoogleGcsIntegrationConfig(
   config: Config,
 ): GoogleGcsIntegrationConfig;
 
+// @public
+export function readHarnessConfig(
+  config: Config,
+): HarnessIntegrationConfig;
+
 // @public @deprecated (undocumented)
 export const replaceGitHubUrlType: typeof replaceGithubUrlType;
 
@@ -889,6 +938,8 @@ export interface ScmIntegrationRegistry
   github: ScmIntegrationsGroup<GithubIntegration>;
   // (undocumented)
   gitlab: ScmIntegrationsGroup<GitLabIntegration>;
+  // (undocumented)
+  harness: ScmIntegrationsGroup<HarnessIntegration>;
   resolveEditUrl(url: string): string;
   resolveUrl(options: {
     url: string;
@@ -927,6 +978,8 @@ export class ScmIntegrations implements ScmIntegrationRegistry {
   // (undocumented)
   get gitlab(): ScmIntegrationsGroup<GitLabIntegration>;
   // (undocumented)
+  get harness(): ScmIntegrationsGroup<HarnessIntegration>;
+  // (undocumented)
   list(): ScmIntegration[];
   // (undocumented)
   resolveEditUrl(url: string): string;

packages/integration/config.d.ts

@@ -345,5 +345,29 @@ export interface Config {
        */
       password?: string;
     }>;
+    /** Integration configuration for Harness Code */
+    harness?: Array<{
+      /**
+       * The hostname of the given Harness Code instance
+       * @visibility frontend
+       */
+      host: string;
+      /**
+       * The base url for the Gitea instance.
+       * @visibility frontend
+       */
+      baseUrl?: string;
+
+      /**
+       * The username to use for authenticated requests.
+       * @visibility secret
+       */
+      username?: string;
+      /**
+       * Harness Code token used to authenticate requests. This can be either a generated access token.
+       * @visibility secret
+       */
+      token?: string;
+    }>;
   };
 }

packages/integration/src/ScmIntegrations.test.ts

@@ -38,6 +38,7 @@ import { ScmIntegrations } from './ScmIntegrations';
 import { GiteaIntegration, GiteaIntegrationConfig } from './gitea';
 import { AwsCodeCommitIntegration } from './awsCodeCommit/AwsCodeCommitIntegration';
 import { AwsCodeCommitIntegrationConfig } from './awsCodeCommit';
+import { HarnessIntegration, HarnessIntegrationConfig } from './harness';
 
 describe('ScmIntegrations', () => {
   const awsS3 = new AwsS3Integration({
@@ -80,6 +81,10 @@ describe('ScmIntegrations', () => {
     host: 'gitea.local',
   } as GiteaIntegrationConfig);
 
+  const harness = new HarnessIntegration({
+    host: 'harness.local',
+  } as HarnessIntegrationConfig);
+
   const i = new ScmIntegrations({
     awsS3: basicIntegrations([awsS3], item => item.config.host),
     awsCodeCommit: basicIntegrations([awsCodeCommit], item => item.config.host),
@@ -94,6 +99,7 @@ describe('ScmIntegrations', () => {
     github: basicIntegrations([github], item => item.config.host),
     gitlab: basicIntegrations([gitlab], item => item.config.host),
     gitea: basicIntegrations([gitea], item => item.config.host),
+    harness: basicIntegrations([harness], item => item.config.host),
   });
 
   it('can get the specifics', () => {
@@ -113,6 +119,7 @@ describe('ScmIntegrations', () => {
     expect(i.github.byUrl('https://github.local')).toBe(github);
     expect(i.gitlab.byUrl('https://gitlab.local')).toBe(gitlab);
     expect(i.gitea.byUrl('https://gitea.local')).toBe(gitea);
+    expect(i.harness.byUrl('https://harness.local')).toBe(harness);
   });
 
   it('can list', () => {
@@ -128,6 +135,7 @@ describe('ScmIntegrations', () => {
         github,
         gitlab,
         gitea,
+        harness,
       ]),
     );
   });
@@ -143,6 +151,7 @@ describe('ScmIntegrations', () => {
     expect(i.byUrl('https://github.local')).toBe(github);
     expect(i.byUrl('https://gitlab.local')).toBe(gitlab);
     expect(i.byUrl('https://gitea.local')).toBe(gitea);
+    expect(i.byUrl('https://harness.local')).toBe(harness);
 
     expect(i.byHost('awss3.local')).toBe(awsS3);
     expect(i.byHost('awscodecommit.local')).toBe(awsCodeCommit);

packages/integration/src/ScmIntegrations.ts

@@ -28,6 +28,7 @@ import { defaultScmResolveUrl } from './helpers';
 import { ScmIntegration, ScmIntegrationsGroup } from './types';
 import { ScmIntegrationRegistry } from './registry';
 import { GiteaIntegration } from './gitea';
+import { HarnessIntegration } from './harness/HarnessIntegration';
 
 /**
  * The set of supported integrations.
@@ -48,6 +49,7 @@ export interface IntegrationsByType {
   github: ScmIntegrationsGroup<GithubIntegration>;
   gitlab: ScmIntegrationsGroup<GitLabIntegration>;
   gitea: ScmIntegrationsGroup<GiteaIntegration>;
+  harness: ScmIntegrationsGroup<HarnessIntegration>;
 }
 
 /**
@@ -70,6 +72,7 @@ export class ScmIntegrations implements ScmIntegrationRegistry {
       github: GithubIntegration.factory({ config }),
       gitlab: GitLabIntegration.factory({ config }),
       gitea: GiteaIntegration.factory({ config }),
+      harness: HarnessIntegration.factory({ config }),
     });
   }
 
@@ -120,6 +123,10 @@ export class ScmIntegrations implements ScmIntegrationRegistry {
     return this.byType.gitea;
   }
 
+  get harness(): ScmIntegrationsGroup<HarnessIntegration> {
+    return this.byType.harness;
+  }
+
   list(): ScmIntegration[] {
     return Object.values(this.byType).flatMap(
       i => i.list() as ScmIntegration[],

packages/integration/src/harness/HarnessIntegration.test.ts

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ConfigReader } from '@backstage/config';
+import { HarnessIntegration } from './HarnessIntegration';
+
+describe('HarnessIntegration', () => {
+  it('has a working factory', () => {
+    const integrations = HarnessIntegration.factory({
+      config: new ConfigReader({
+        integrations: {
+          harness: [
+            {
+              host: 'app.harness.io',
+              username: 'git',
+              baseUrl: 'https://app.harness.io/route',
+              token: '1234',
+            },
+          ],
+        },
+      }),
+    });
+    expect(integrations.list().length).toBe(1);
+    expect(integrations.list()[0].config.host).toBe('app.harness.io');
+    expect(integrations.list()[0].config.baseUrl).toBe(
+      'https://app.harness.io/route',
+    );
+  });
+
+  it('returns the basics', () => {
+    const integration = new HarnessIntegration({
+      host: 'app.harness.io',
+    });
+    expect(integration.type).toBe('harness');
+    expect(integration.title).toBe('app.harness.io');
+  });
+
+  describe('resolveUrl', () => {
+    it('works for valid urls, ignoring line number', () => {
+      const integration = new HarnessIntegration({
+        host: 'app.harness.io',
+      });
+
+      expect(
+        integration.resolveUrl({
+          url: 'https://app.harness.io/catalog-info.yaml',
+          base: 'https://app.harness.io/catalog-info.yaml',
+          lineNumber: 9,
+        }),
+      ).toBe('https://app.harness.io/catalog-info.yaml');
+    });
+
+    it('handles line numbers', () => {
+      const integration = new HarnessIntegration({
+        host: 'app.harness.io',
+      });
+
+      expect(
+        integration.resolveUrl({
+          url: '',
+          base: 'https://app.harness.io/catalog-info.yaml#4',
+          lineNumber: 9,
+        }),
+      ).toBe('https://app.harness.io/catalog-info.yaml#L9');
+    });
+  });
+
+  describe('resolves with a relative url', () => {
+    it('works for valid urls', () => {
+      const integration = new HarnessIntegration({
+        host: 'app.harness.io',
+      });
+
+      expect(
+        integration.resolveUrl({
+          url: './skeleton',
+          base: 'https://app.harness.io/git/plugins/repo/+/refs/heads/master/template.yaml',
+        }),
+      ).toBe(
+        'https://app.harness.io/git/plugins/repo/+/refs/heads/master/skeleton',
+      );
+    });
+  });
+
+  describe('resolves with an absolute url', () => {
+    it('works for valid urls', () => {
+      const integration = new HarnessIntegration({
+        host: 'app.harness.io',
+      });
+
+      expect(
+        integration.resolveUrl({
+          url: '/catalog-info.yaml',
+          base: 'https://app.harness.io/git/repo/+/refs/heads/master/',
+        }),
+      ).toBe(
+        'https://app.harness.io/git/repo/+/refs/heads/master/catalog-info.yaml',
+      );
+    });
+  });
+
+  it('resolve edit URL', () => {
+    const integration = new HarnessIntegration({
+      host: 'app.harness.io',
+    });
+
+    expect(
+      integration.resolveEditUrl(
+        'https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/edit/refMain/~/all-apis.yaml',
+      ),
+    ).toBe(
+      'https://app.harness.io/gateway/code/api/v1/repos/accountId/orgName/projName/repoName/+/edit/all-apis.yaml',
+    );
+  });
+});

packages/integration/src/harness/HarnessIntegration.ts

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { basicIntegrations, defaultScmResolveUrl } from '../helpers';
+import { ScmIntegration, ScmIntegrationsFactory } from '../types';
+import { HarnessIntegrationConfig, readHarnessConfig } from './config';
+import { getHarnessEditContentsUrl } from './core';
+
+/**
+ * A Harness Code based integration.
+ *
+ * @public
+ */
+export class HarnessIntegration implements ScmIntegration {
+  static factory: ScmIntegrationsFactory<HarnessIntegration> = ({ config }) => {
+    const configs = config.getOptionalConfigArray('integrations.harness') ?? [];
+    const harnessConfigs = configs.map(c => readHarnessConfig(c));
+
+    return basicIntegrations(
+      harnessConfigs.map(c => new HarnessIntegration(c)),
+      (harness: HarnessIntegration) => harness.config.host,
+    );
+  };
+
+  constructor(readonly config: HarnessIntegrationConfig) {}
+
+  get type(): string {
+    return 'harness';
+  }
+
+  get title(): string {
+    return this.config.host;
+  }
+
+  resolveUrl(options: {
+    url: string;
+    base: string;
+    lineNumber?: number | undefined;
+  }): string {
+    return defaultScmResolveUrl(options);
+  }
+
+  resolveEditUrl(url: string): string {
+    return getHarnessEditContentsUrl(this.config, url);
+  }
+}

packages/integration/src/harness/config.test.ts

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Config, ConfigReader } from '@backstage/config';
+import { loadConfigSchema } from '@backstage/config-loader';
+import { HarnessIntegrationConfig, readHarnessConfig } from './config';
+
+describe('readHarnessConfig', () => {
+  function buildConfig(data: Partial<HarnessIntegrationConfig>): Config {
+    return new ConfigReader(data);
+  }
+
+  async function buildFrontendConfig(
+    data: Partial<HarnessIntegrationConfig>,
+  ): Promise<Config> {
+    const fullSchema = await loadConfigSchema({
+      dependencies: ['@backstage/integration'],
+    });
+    const serializedSchema = fullSchema.serialize() as {
+      schemas: { value: { properties?: { integrations?: object } } }[];
+    };
+    const schema = await loadConfigSchema({
+      serialized: {
+        ...serializedSchema, // only include schemas that apply to integrations
+        schemas: serializedSchema.schemas.filter(
+          s => s.value?.properties?.integrations,
+        ),
+      },
+    });
+    const processed = schema.process(
+      [{ data: { integrations: { harness: [data] } }, context: 'app' }],
+      { visibility: ['frontend'] },
+    );
+    return new ConfigReader((processed[0].data as any).integrations.harness[0]);
+  }
+
+  it('reads all values', () => {
+    const output = readHarnessConfig(
+      buildConfig({
+        host: 'a.com',
+        baseUrl: 'https://a.com/route/api',
+        username: 'u',
+        token: 'p',
+      }),
+    );
+    expect(output).toEqual({
+      host: 'a.com',
+      baseUrl: 'https://a.com/route/api',
+      username: 'u',
+      token: 'p',
+    });
+  });
+
+  it('can create a default value if the API base URL is missing', () => {
+    const output = readHarnessConfig(
+      buildConfig({
+        host: 'a.com',
+      }),
+    );
+    expect(output).toEqual({
+      host: 'a.com',
+      baseUrl: 'https://a.com',
+      username: undefined,
+      token: undefined,
+    });
+  });
+
+  it('rejects funky configs', () => {
+    const valid: any = {
+      host: 'a.com',
+    };
+    expect(() => readHarnessConfig(buildConfig({ ...valid, host: 2 }))).toThrow(
+      /host/,
+    );
+    expect(() =>
+      readHarnessConfig(buildConfig({ ...valid, baseUrl: 2 })),
+    ).toThrow(/baseUrl/);
+  });
+
+  it('works on the frontend', async () => {
+    expect(
+      readHarnessConfig(
+        await buildFrontendConfig({
+          host: 'a.com',
+          baseUrl: 'https://a.com/route',
+          username: 'u',
+          token: 'p',
+        }),
+      ),
+    ).toEqual({
+      host: 'a.com',
+      baseUrl: 'https://a.com/route',
+    });
+  });
+});

packages/integration/src/harness/config.ts

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Config } from '@backstage/config';
+import { trimEnd } from 'lodash';
+import { isValidHost } from '../helpers';
+
+/**
+ * The configuration for a single Gitea integration.
+ *
+ * @public
+ */
+export type HarnessIntegrationConfig = {
+  /**
+   * The host of the target that this matches on, e.g. "app.harness.io"
+   */
+  host: string;
+  /**
+   * The optional base URL of the Harness code instance. It is assumed that https
+   * is used and that the base path is "/" on the host. If that is not the
+   * case set the complete base url to the Harness code instance, e.g.
+   * "https://harnesscode.website.com/". This is the url that you would open
+   * in a browser.
+   */
+  baseUrl?: string;
+  /**
+   * The username to use for requests to harness code.
+   */
+  username?: string;
+
+  /**
+   * The password or http token to use for authentication.
+   */
+  token?: string;
+};
+
+/**
+ * Parses a location config block for use in HarnessIntegration
+ *
+ * @public
+ */
+export function readHarnessConfig(config: Config): HarnessIntegrationConfig {
+  const host = config.getString('host');
+  let baseUrl = config.getOptionalString('baseUrl');
+  const username = config.getOptionalString('username');
+  const token = config.getOptionalString('token');
+  if (!isValidHost(host)) {
+    throw new Error(
+      `Invalid Harness Code integration config, '${host}' is not a valid host`,
+    );
+  }
+
+  if (baseUrl) {
+    baseUrl = trimEnd(baseUrl, '/');
+  } else {
+    baseUrl = `https://${host}`;
+  }
+
+  return {
+    host,
+    baseUrl,
+    username,
+    token,
+  };
+}

packages/integration/src/harness/core.test.ts

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2020 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { setupServer } from 'msw/node';
+import { setupRequestMockHandlers } from '@backstage/test-utils';
+import { HarnessIntegrationConfig } from './config';
+import {
+  getHarnessEditContentsUrl,
+  getHarnessFileContentsUrl,
+  getHarnessRequestOptions,
+} from './core';
+
+describe('Harness code core', () => {
+  const worker = setupServer();
+  setupRequestMockHandlers(worker);
+
+  describe('getHarnessFileContentsUrl', () => {
+    it('can create an url from arguments', () => {
+      const config: HarnessIntegrationConfig = {
+        host: 'app.harness.io',
+      };
+      expect(
+        getHarnessFileContentsUrl(
+          config,
+          'https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/files/refMain/~/all-apis.yaml',
+        ),
+      ).toEqual(
+        'https://app.harness.io/gateway/code/api/v1/repos/accountId/orgName/projName/repoName/+/content/all-apis.yaml?routingId=accountId&include_commit=false&ref=refMain',
+      );
+    });
+  });
+
+  describe('getHarnessEditContentsUrl', () => {
+    it('can create an url from arguments', () => {
+      const config: HarnessIntegrationConfig = {
+        host: 'app.harness.io',
+      };
+      expect(
+        getHarnessEditContentsUrl(
+          config,
+          'https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/edit/refMain/~/all-apis.yaml',
+        ),
+      ).toEqual(
+        'https://app.harness.io/gateway/code/api/v1/repos/accountId/orgName/projName/repoName/+/edit/all-apis.yaml',
+      );
+    });
+  });
+
+  describe('getGerritRequestOptions', () => {
+    it('adds token header when only a token is specified', () => {
+      const authRequest: HarnessIntegrationConfig = {
+        host: 'gerrit.com',
+        token: 'P',
+      };
+      const anonymousRequest: HarnessIntegrationConfig = {
+        host: 'gerrit.com',
+      };
+      expect(
+        (getHarnessRequestOptions(authRequest).headers as any).Authorization,
+      ).toEqual('Bearer P');
+      expect(
+        getHarnessRequestOptions(anonymousRequest).headers,
+      ).toBeUndefined();
+    });
+
+    it('adds basic auth when username and token are specified', () => {
+      const authRequest: HarnessIntegrationConfig = {
+        host: 'gerrit.com',
+        username: 'username',
+        token: 'P',
+      };
+
+      const basicAuthentication = `basic ${Buffer.from(
+        `${authRequest.username}:${authRequest.token}`,
+      ).toString('base64')}`;
+
+      expect(
+        (getHarnessRequestOptions(authRequest).headers as any).Authorization,
+      ).toEqual(basicAuthentication);
+    });
+  });
+});

packages/integration/src/harness/core.ts

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { HarnessIntegrationConfig } from './config';
+
+/**
+ * Given a URL pointing to a file, returns a URL
+ * for editing the contents of the data.
+ *
+ * @remarks
+ *
+ * Converts
+ * from: https://app.harness.io/a/b/src/branchname/path/to/c.yaml
+ * or:   https://app.harness.io/a/b/_edit/branchname/path/to/c.yaml
+ *
+ * @param url - A URL pointing to a file
+ * @param config - The relevant provider config
+ * @public
+ */
+export function getHarnessEditContentsUrl(
+  config: HarnessIntegrationConfig,
+  url: string,
+) {
+  try {
+    const baseUrl = config.baseUrl ?? `https://${config.host}`;
+    const [
+      _blank,
+      _ng,
+      _account,
+      accountId,
+      _module,
+      _moduleName,
+      _org,
+      orgName,
+      _projects,
+      projectName,
+      _repos,
+      repoName,
+      _files,
+      _ref,
+      _branch,
+      ...path
+    ] = url.replace(baseUrl, '').split('/');
+    const pathWithoutSlash = path.join('/').replace(/^\//, '');
+    return `${baseUrl}/gateway/code/api/v1/repos/${accountId}/${orgName}/${projectName}/${repoName}/+/edit/${pathWithoutSlash}`;
+  } catch (e) {
+    throw new Error(`Incorrect URL: ${url}, ${e}`);
+  }
+}
+
+/**
+ * Given a URL pointing to a file, returns an api URL
+ * for fetching the contents of the data.
+ *
+ * @remarks
+ *
+ * Converts
+ * from: https://app.harness.io/ng/account/accountId/module/code/orgs/orgName/projects/projName/repos/repoName/files/refMain/~/all-apis.yaml
+ * to:   https://app.harness.io/gateway/code/api/v1/repos/accountId/orgName/projName/repoName/+/content/all-apis.yaml?routingId=accountId&include_commit=false&ref=refMain
+ *
+ * @param url - A URL pointing to a file
+ * @param config - The relevant provider config
+ * @public
+ */
+export function getHarnessFileContentsUrl(
+  config: HarnessIntegrationConfig,
+  url: string,
+) {
+  try {
+    const baseUrl = config.baseUrl ?? `https://${config.host}`;
+    const [
+      _blank,
+      _ng,
+      _account,
+      accountId,
+      _module,
+      _moduleName,
+      _org,
+      orgName,
+      _projects,
+      projectName,
+      _repos,
+      repoName,
+      _files,
+      ref,
+      _branch,
+      ...path
+    ] = url.replace(baseUrl, '').split('/');
+    const pathWithoutSlash = path.join('/').replace(/^\//, '');
+    return `${baseUrl}/gateway/code/api/v1/repos/${accountId}/${orgName}/${projectName}/${repoName}/+/content/${pathWithoutSlash}?routingId=${accountId}&include_commit=false&ref=${ref}`;
+  } catch (e) {
+    throw new Error(`Incorrect URL: ${url}, ${e}`);
+  }
+}
+
+/**
+ * Return request headers for a Harness Code provider.
+ *
+ * @param config - A Harness Code provider config
+ * @public
+ */
+export function getHarnessRequestOptions(config: HarnessIntegrationConfig): {
+  headers?: Record<string, string>;
+} {
+  const headers: Record<string, string> = {};
+  const { username, token } = config;
+
+  if (!token) {
+    return headers;
+  }
+
+  if (username) {
+    headers.Authorization = `basic ${Buffer.from(
+      `${username}:${token}`,
+    ).toString('base64')}`;
+  } else {
+    headers.Authorization = `Bearer ${token}`;
+  }
+
+  return {
+    headers,
+  };
+}

packages/integration/src/harness/index.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { HarnessIntegration } from './HarnessIntegration';
+export { getHarnessRequestOptions, getHarnessFileContentsUrl } from './core';
+export { readHarnessConfig } from './config';
+export type { HarnessIntegrationConfig } from './config';

packages/integration/src/index.ts

@@ -31,6 +31,7 @@ export * from './gitea';
 export * from './github';
 export * from './gitlab';
 export * from './googleGcs';
+export * from './harness';
 export { defaultScmResolveUrl } from './helpers';
 export { ScmIntegrations } from './ScmIntegrations';
 export type { IntegrationsByType } from './ScmIntegrations';

packages/integration/src/registry.ts

@@ -25,6 +25,7 @@ import { GerritIntegration } from './gerrit/GerritIntegration';
 import { GithubIntegration } from './github/GithubIntegration';
 import { GitLabIntegration } from './gitlab/GitLabIntegration';
 import { GiteaIntegration } from './gitea/GiteaIntegration';
+import { HarnessIntegration } from './harness/HarnessIntegration';
 
 /**
  * Holds all registered SCM integrations, of all types.
@@ -46,6 +47,7 @@ export interface ScmIntegrationRegistry
   github: ScmIntegrationsGroup<GithubIntegration>;
   gitlab: ScmIntegrationsGroup<GitLabIntegration>;
   gitea: ScmIntegrationsGroup<GiteaIntegration>;
+  harness: ScmIntegrationsGroup<HarnessIntegration>;
   /**
    * Resolves an absolute or relative URL in relation to a base URL.
    *