feat: split publish:bitbucket scaffolder action for Bitbucket Cloud/Server

Split the `publish:bitbucket` scaffolder action into `publish:bitbucketCloud`
and `publish:bitbucketServer`.

Both replacements use `integrations.bitbucketCloud` or `integrations.bitbucketServer`
respectively.

Relates-to: #9923
Signed-off-by: Patrick Jungermann <Patrick.Jungermann@gmail.com>

.changeset/shiny-students-approve.md

@@ -0,0 +1,21 @@
+---
+'@backstage/plugin-scaffolder-backend': minor
+---
+
+Split `publish:bitbucket` into `publish:bitbucketCloud` and `publish:bitbucketServer`.
+
+In order to migrate from the deprecated action, you need to replace the use of action
+`publish:bitbucket` in your templates with the use of either `publish:bitbucketCloud`
+or `publish:bitbucketServer` - depending on which destination SCM provider you use.
+
+Additionally, these actions will not utilize `integrations.bitbucket` anymore,
+but `integrations.bitbucketCloud` or `integrations.bitbucketServer` respectively.
+You may or may not have migrated to these already.
+
+As described in a previous changeset, using these two replacement integrations configs
+will not compromise use cases which still rely on `integrations.bitbucket` as this was
+set up in a backwards compatible way.
+
+Additionally, please mind that the option `enableLFS` is only available (and always was)
+for Bitbucket Server use cases and therefore, is not even part of the schema for
+`publish:bitbucketCloud` anymore.

plugins/scaffolder-backend/api-report.md

@@ -195,7 +195,7 @@ export function createPublishAzureAction(options: {
   token?: string | undefined;
 }>;
 
-// @public
+// @public @deprecated
 export function createPublishBitbucketAction(options: {
   integrations: ScmIntegrationRegistry;
   config: Config;
@@ -209,6 +209,33 @@ export function createPublishBitbucketAction(options: {
   token?: string | undefined;
 }>;
 
+// @public
+export function createPublishBitbucketCloudAction(options: {
+  integrations: ScmIntegrationRegistry;
+  config: Config;
+}): TemplateAction<{
+  repoUrl: string;
+  description?: string | undefined;
+  defaultBranch?: string | undefined;
+  repoVisibility?: 'private' | 'public' | undefined;
+  sourcePath?: string | undefined;
+  token?: string | undefined;
+}>;
+
+// @public
+export function createPublishBitbucketServerAction(options: {
+  integrations: ScmIntegrationRegistry;
+  config: Config;
+}): TemplateAction<{
+  repoUrl: string;
+  description?: string | undefined;
+  defaultBranch?: string | undefined;
+  repoVisibility?: 'private' | 'public' | undefined;
+  sourcePath?: string | undefined;
+  enableLFS?: boolean | undefined;
+  token?: string | undefined;
+}>;
+
 // @public
 export function createPublishFileAction(): TemplateAction<{
   path: string;

plugins/scaffolder-backend/src/scaffolder/actions/builtin/createBuiltinActions.ts

@@ -37,6 +37,8 @@ import {
 import {
   createPublishAzureAction,
   createPublishBitbucketAction,
+  createPublishBitbucketCloudAction,
+  createPublishBitbucketServerAction,
   createPublishGithubAction,
   createPublishGithubPullRequestAction,
   createPublishGitlabAction,
@@ -129,6 +131,14 @@ export const createBuiltinActions = (
       integrations,
       config,
     }),
+    createPublishBitbucketCloudAction({
+      integrations,
+      config,
+    }),
+    createPublishBitbucketServerAction({
+      integrations,
+      config,
+    }),
     createPublishAzureAction({
       integrations,
       config,

plugins/scaffolder-backend/src/scaffolder/actions/builtin/publish/bitbucket.ts

@@ -198,6 +198,7 @@ const performEnableLFS = async (opts: {
  * Creates a new action that initializes a git repository of the content in the workspace
  * and publishes it to Bitbucket.
  * @public
+ * @deprecated in favor of createPublishBitbucketCloudAction and createPublishBitbucketServerAction
  */
 export function createPublishBitbucketAction(options: {
   integrations: ScmIntegrationRegistry;
@@ -274,6 +275,9 @@ export function createPublishBitbucketAction(options: {
       },
     },
     async handler(ctx) {
+      ctx.logger.warn(
+        `[Deprecated] Please migrate the use of action "publish:bitbucket" to "publish:bitbucketCloud" or "publish:bitbucketServer".`,
+      );
       const {
         repoUrl,
         description,

plugins/scaffolder-backend/src/scaffolder/actions/builtin/publish/bitbucketCloud.test.ts

@@ -0,0 +1,480 @@
+/*
+ * Copyright 2021 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.
+ */
+
+jest.mock('../helpers');
+
+import { createPublishBitbucketCloudAction } from './bitbucketCloud';
+import { rest } from 'msw';
+import { setupServer } from 'msw/node';
+import { setupRequestMockHandlers } from '@backstage/backend-test-utils';
+import { ScmIntegrations } from '@backstage/integration';
+import { ConfigReader } from '@backstage/config';
+import { getVoidLogger } from '@backstage/backend-common';
+import { PassThrough } from 'stream';
+import { initRepoAndPush } from '../helpers';
+
+describe('publish:bitbucketCloud', () => {
+  const config = new ConfigReader({
+    integrations: {
+      bitbucketCloud: [
+        {
+          username: 'u',
+          appPassword: 'p',
+        },
+      ],
+    },
+  });
+
+  const integrations = ScmIntegrations.fromConfig(config);
+  const action = createPublishBitbucketCloudAction({ integrations, config });
+  const mockContext = {
+    input: {
+      repoUrl: 'bitbucket.org?workspace=workspace&project=project&repo=repo',
+      repoVisibility: 'private' as const,
+    },
+    workspacePath: 'wsp',
+    logger: getVoidLogger(),
+    logStream: new PassThrough(),
+    output: jest.fn(),
+    createTemporaryDirectory: jest.fn(),
+  };
+  const server = setupServer();
+  setupRequestMockHandlers(server);
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should throw an error when the repoUrl is not well formed', async () => {
+    await expect(
+      action.handler({
+        ...mockContext,
+        input: {
+          ...mockContext.input,
+          repoUrl: 'bitbucket.org?project=project&repo=repo',
+        },
+      }),
+    ).rejects.toThrow(/missing workspace/);
+
+    await expect(
+      action.handler({
+        ...mockContext,
+        input: {
+          ...mockContext.input,
+          repoUrl: 'bitbucket.org?workspace=workspace&repo=repo',
+        },
+      }),
+    ).rejects.toThrow(/missing project/);
+
+    await expect(
+      action.handler({
+        ...mockContext,
+        input: {
+          ...mockContext.input,
+          repoUrl: 'bitbucket.org?workspace=workspace&project=project',
+        },
+      }),
+    ).rejects.toThrow(/missing repo/);
+  });
+
+  it('should throw if there is no integration config provided', async () => {
+    await expect(
+      action.handler({
+        ...mockContext,
+        input: {
+          ...mockContext.input,
+          repoUrl: 'missing.com?workspace=workspace&project=project&repo=repo',
+        },
+      }),
+    ).rejects.toThrow(/No matching integration configuration/);
+  });
+
+  it('should throw if there is no token in the integration config that is returned', async () => {
+    const configNoCreds = new ConfigReader({
+      integrations: {
+        bitbucketCloud: [],
+      },
+    });
+
+    const integrationsNoCreds = ScmIntegrations.fromConfig(configNoCreds);
+    const actionNoCreds = createPublishBitbucketCloudAction({
+      integrations: integrationsNoCreds,
+      config: configNoCreds,
+    });
+
+    await expect(actionNoCreds.handler(mockContext)).rejects.toThrow(
+      /Authorization has not been provided for Bitbucket Cloud/,
+    );
+  });
+
+  it('should call the correct APIs', async () => {
+    expect.assertions(2);
+    server.use(
+      rest.post(
+        'https://api.bitbucket.org/2.0/repositories/workspace/repo',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Basic dTpw');
+          expect(req.body).toEqual({
+            is_private: true,
+            scm: 'git',
+            project: { key: 'project' },
+          });
+          return res(
+            ctx.status(200),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                html: {
+                  href: 'https://bitbucket.org/workspace/repo',
+                },
+                clone: [
+                  {
+                    name: 'https',
+                    href: 'https://bitbucket.org/workspace/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+
+    await action.handler(mockContext);
+  });
+
+  it('should work if the token is provided through ctx.input', async () => {
+    expect.assertions(2);
+    const token = 'user-token';
+    server.use(
+      rest.post(
+        'https://api.bitbucket.org/2.0/repositories/workspace/repo',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe(`Bearer ${token}`);
+          expect(req.body).toEqual({
+            is_private: true,
+            scm: 'git',
+            project: { key: 'project' },
+          });
+          return res(
+            ctx.status(200),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                html: {
+                  href: 'https://bitbucket.org/workspace/repo',
+                },
+                clone: [
+                  {
+                    name: 'https',
+                    href: 'https://bitbucket.org/workspace/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        token: token,
+      },
+    });
+  });
+
+  it('should call initAndPush with the correct values', async () => {
+    server.use(
+      rest.post(
+        'https://api.bitbucket.org/2.0/repositories/workspace/repo',
+        (_, res, ctx) =>
+          res(
+            ctx.status(200),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                html: {
+                  href: 'https://bitbucket.org/workspace/repo',
+                },
+                clone: [
+                  {
+                    name: 'https',
+                    href: 'https://bitbucket.org/workspace/cloneurl',
+                  },
+                ],
+              },
+            }),
+          ),
+      ),
+    );
+
+    await action.handler(mockContext);
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.org/workspace/cloneurl',
+      defaultBranch: 'master',
+      auth: { username: 'u', password: 'p' },
+      logger: mockContext.logger,
+      gitAuthorInfo: {},
+    });
+  });
+
+  it('should call initAndPush with the correct default branch', async () => {
+    server.use(
+      rest.post(
+        'https://api.bitbucket.org/2.0/repositories/workspace/repo',
+        (_, res, ctx) =>
+          res(
+            ctx.status(200),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                html: {
+                  href: 'https://bitbucket.org/workspace/repo',
+                },
+                clone: [
+                  {
+                    name: 'https',
+                    href: 'https://bitbucket.org/workspace/cloneurl',
+                  },
+                ],
+              },
+            }),
+          ),
+      ),
+    );
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        defaultBranch: 'main',
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.org/workspace/cloneurl',
+      defaultBranch: 'main',
+      auth: { username: 'u', password: 'p' },
+      logger: mockContext.logger,
+      gitAuthorInfo: {},
+    });
+  });
+
+  it('should call initAndPush with the configured defaultAuthor', async () => {
+    const customAuthorConfig = new ConfigReader({
+      integrations: {
+        bitbucketCloud: [
+          {
+            username: 'u',
+            appPassword: 'p',
+          },
+        ],
+      },
+      scaffolder: {
+        defaultAuthor: {
+          name: 'Test',
+          email: 'example@example.com',
+        },
+      },
+    });
+
+    const customAuthorIntegrations =
+      ScmIntegrations.fromConfig(customAuthorConfig);
+    const customAuthorAction = createPublishBitbucketCloudAction({
+      integrations: customAuthorIntegrations,
+      config: customAuthorConfig,
+    });
+
+    server.use(
+      rest.post(
+        'https://api.bitbucket.org/2.0/repositories/workspace/repo',
+        (_, res, ctx) =>
+          res(
+            ctx.status(200),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                html: {
+                  href: 'https://bitbucket.org/workspace/repo',
+                },
+                clone: [
+                  {
+                    name: 'https',
+                    href: 'https://bitbucket.org/workspace/cloneurl',
+                  },
+                ],
+              },
+            }),
+          ),
+      ),
+    );
+
+    await customAuthorAction.handler(mockContext);
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.org/workspace/cloneurl',
+      auth: { username: 'u', password: 'p' },
+      logger: mockContext.logger,
+      defaultBranch: 'master',
+      gitAuthorInfo: { name: 'Test', email: 'example@example.com' },
+    });
+  });
+
+  it('should call initAndPush with the configured defaultCommitMessage', async () => {
+    const customAuthorConfig = new ConfigReader({
+      integrations: {
+        bitbucketCloud: [
+          {
+            username: 'u',
+            appPassword: 'p',
+          },
+        ],
+      },
+      scaffolder: {
+        defaultCommitMessage: 'Test commit message',
+      },
+    });
+
+    const customAuthorIntegrations =
+      ScmIntegrations.fromConfig(customAuthorConfig);
+    const customAuthorAction = createPublishBitbucketCloudAction({
+      integrations: customAuthorIntegrations,
+      config: customAuthorConfig,
+    });
+
+    server.use(
+      rest.post(
+        'https://api.bitbucket.org/2.0/repositories/workspace/repo',
+        (_, res, ctx) =>
+          res(
+            ctx.status(200),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                html: {
+                  href: 'https://bitbucket.org/workspace/repo',
+                },
+                clone: [
+                  {
+                    name: 'https',
+                    href: 'https://bitbucket.org/workspace/cloneurl',
+                  },
+                ],
+              },
+            }),
+          ),
+      ),
+    );
+
+    await customAuthorAction.handler(mockContext);
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.org/workspace/cloneurl',
+      auth: { username: 'u', password: 'p' },
+      logger: mockContext.logger,
+      defaultBranch: 'master',
+      commitMessage: 'Test commit message',
+      gitAuthorInfo: { email: undefined, name: undefined },
+    });
+  });
+
+  it('should call outputs with the correct urls', async () => {
+    server.use(
+      rest.post(
+        'https://api.bitbucket.org/2.0/repositories/workspace/repo',
+        (_, res, ctx) =>
+          res(
+            ctx.status(200),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                html: {
+                  href: 'https://bitbucket.org/workspace/repo',
+                },
+                clone: [
+                  {
+                    name: 'https',
+                    href: 'https://bitbucket.org/workspace/cloneurl',
+                  },
+                ],
+              },
+            }),
+          ),
+      ),
+    );
+
+    await action.handler(mockContext);
+
+    expect(mockContext.output).toHaveBeenCalledWith(
+      'remoteUrl',
+      'https://bitbucket.org/workspace/cloneurl',
+    );
+    expect(mockContext.output).toHaveBeenCalledWith(
+      'repoContentsUrl',
+      'https://bitbucket.org/workspace/repo/src/master',
+    );
+  });
+
+  it('should call outputs with the correct urls with correct default branch', async () => {
+    server.use(
+      rest.post(
+        'https://api.bitbucket.org/2.0/repositories/workspace/repo',
+        (_, res, ctx) =>
+          res(
+            ctx.status(200),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                html: {
+                  href: 'https://bitbucket.org/workspace/repo',
+                },
+                clone: [
+                  {
+                    name: 'https',
+                    href: 'https://bitbucket.org/workspace/cloneurl',
+                  },
+                ],
+              },
+            }),
+          ),
+      ),
+    );
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        defaultBranch: 'main',
+      },
+    });
+
+    expect(mockContext.output).toHaveBeenCalledWith(
+      'remoteUrl',
+      'https://bitbucket.org/workspace/cloneurl',
+    );
+    expect(mockContext.output).toHaveBeenCalledWith(
+      'repoContentsUrl',
+      'https://bitbucket.org/workspace/repo/src/main',
+    );
+  });
+});

plugins/scaffolder-backend/src/scaffolder/actions/builtin/publish/bitbucketCloud.ts

@@ -0,0 +1,281 @@
+/*
+ * Copyright 2021 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 { InputError } from '@backstage/errors';
+import { ScmIntegrationRegistry } from '@backstage/integration';
+import fetch, { Response, RequestInit } from 'node-fetch';
+import { initRepoAndPush } from '../helpers';
+import { createTemplateAction } from '../../createTemplateAction';
+import { getRepoSourceDirectory, parseRepoUrl } from './util';
+import { Config } from '@backstage/config';
+
+const createRepository = async (opts: {
+  workspace: string;
+  project: string;
+  repo: string;
+  description?: string;
+  repoVisibility: 'private' | 'public';
+  mainBranch: string;
+  authorization: string;
+  apiBaseUrl: string;
+}) => {
+  const {
+    workspace,
+    project,
+    repo,
+    description,
+    repoVisibility,
+    mainBranch,
+    authorization,
+    apiBaseUrl,
+  } = opts;
+
+  const options: RequestInit = {
+    method: 'POST',
+    body: JSON.stringify({
+      scm: 'git',
+      description: description,
+      is_private: repoVisibility === 'private',
+      project: { key: project },
+    }),
+    headers: {
+      Authorization: authorization,
+      'Content-Type': 'application/json',
+    },
+  };
+
+  let response: Response;
+  try {
+    response = await fetch(
+      `${apiBaseUrl}/repositories/${workspace}/${repo}`,
+      options,
+    );
+  } catch (e) {
+    throw new Error(`Unable to create repository, ${e}`);
+  }
+
+  if (response.status !== 200) {
+    throw new Error(
+      `Unable to create repository, ${response.status} ${
+        response.statusText
+      }, ${await response.text()}`,
+    );
+  }
+
+  const r = await response.json();
+  let remoteUrl = '';
+  for (const link of r.links.clone) {
+    if (link.name === 'https') {
+      remoteUrl = link.href;
+    }
+  }
+
+  // "mainbranch.name" cannot be set neither at create nor update of the repo
+  // the first pushed branch will be set as "main branch" then
+  const repoContentsUrl = `${r.links.html.href}/src/${mainBranch}`;
+  return { remoteUrl, repoContentsUrl };
+};
+
+const getAuthorizationHeader = (config: {
+  username?: string;
+  appPassword?: string;
+  token?: string;
+}) => {
+  if (config.username && config.appPassword) {
+    const buffer = Buffer.from(
+      `${config.username}:${config.appPassword}`,
+      'utf8',
+    );
+
+    return `Basic ${buffer.toString('base64')}`;
+  }
+
+  if (config.token) {
+    return `Bearer ${config.token}`;
+  }
+
+  throw new Error(
+    `Authorization has not been provided for Bitbucket Cloud. Please add either username + appPassword to the Integrations config or a user login auth token`,
+  );
+};
+
+/**
+ * Creates a new action that initializes a git repository of the content in the workspace
+ * and publishes it to Bitbucket Cloud.
+ * @public
+ */
+export function createPublishBitbucketCloudAction(options: {
+  integrations: ScmIntegrationRegistry;
+  config: Config;
+}) {
+  const { integrations, config } = options;
+
+  return createTemplateAction<{
+    repoUrl: string;
+    description?: string;
+    defaultBranch?: string;
+    repoVisibility?: 'private' | 'public';
+    sourcePath?: string;
+    token?: string;
+  }>({
+    id: 'publish:bitbucketCloud',
+    description:
+      'Initializes a git repository of the content in the workspace, and publishes it to Bitbucket Cloud.',
+    schema: {
+      input: {
+        type: 'object',
+        required: ['repoUrl'],
+        properties: {
+          repoUrl: {
+            title: 'Repository Location',
+            type: 'string',
+          },
+          description: {
+            title: 'Repository Description',
+            type: 'string',
+          },
+          repoVisibility: {
+            title: 'Repository Visibility',
+            type: 'string',
+            enum: ['private', 'public'],
+          },
+          defaultBranch: {
+            title: 'Default Branch',
+            type: 'string',
+            description: `Sets the default branch on the repository. The default value is 'master'`,
+          },
+          sourcePath: {
+            title: 'Source Path',
+            description:
+              'Path within the workspace that will be used as the repository root. If omitted, the entire workspace will be published as the repository.',
+            type: 'string',
+          },
+          token: {
+            title: 'Authentication Token',
+            type: 'string',
+            description:
+              'The token to use for authorization to BitBucket Cloud',
+          },
+        },
+      },
+      output: {
+        type: 'object',
+        properties: {
+          remoteUrl: {
+            title: 'A URL to the repository with the provider',
+            type: 'string',
+          },
+          repoContentsUrl: {
+            title: 'A URL to the root of the repository',
+            type: 'string',
+          },
+        },
+      },
+    },
+    async handler(ctx) {
+      const {
+        repoUrl,
+        description,
+        defaultBranch = 'master',
+        repoVisibility = 'private',
+      } = ctx.input;
+
+      const { workspace, project, repo, host } = parseRepoUrl(
+        repoUrl,
+        integrations,
+      );
+
+      if (!workspace) {
+        throw new InputError(
+          `Invalid URL provider was included in the repo URL to create ${ctx.input.repoUrl}, missing workspace`,
+        );
+      }
+
+      if (!project) {
+        throw new InputError(
+          `Invalid URL provider was included in the repo URL to create ${ctx.input.repoUrl}, missing project`,
+        );
+      }
+
+      const integrationConfig = integrations.bitbucketCloud.byHost(host);
+      if (!integrationConfig) {
+        throw new InputError(
+          `No matching integration configuration for host ${host}, please check your integrations config`,
+        );
+      }
+
+      const authorization = getAuthorizationHeader(
+        ctx.input.token ? { token: ctx.input.token } : integrationConfig.config,
+      );
+
+      const apiBaseUrl = integrationConfig.config.apiBaseUrl;
+
+      const { remoteUrl, repoContentsUrl } = await createRepository({
+        authorization,
+        workspace: workspace || '',
+        project,
+        repo,
+        repoVisibility,
+        mainBranch: defaultBranch,
+        description,
+        apiBaseUrl,
+      });
+
+      const gitAuthorInfo = {
+        name: config.getOptionalString('scaffolder.defaultAuthor.name'),
+        email: config.getOptionalString('scaffolder.defaultAuthor.email'),
+      };
+
+      let auth;
+
+      if (ctx.input.token) {
+        auth = {
+          username: 'x-token-auth',
+          password: ctx.input.token,
+        };
+      } else {
+        if (
+          !integrationConfig.config.username ||
+          !integrationConfig.config.appPassword
+        ) {
+          throw new Error(
+            'Credentials for Bitbucket Cloud integration required for this action.',
+          );
+        }
+
+        auth = {
+          username: integrationConfig.config.username,
+          password: integrationConfig.config.appPassword,
+        };
+      }
+
+      await initRepoAndPush({
+        dir: getRepoSourceDirectory(ctx.workspacePath, ctx.input.sourcePath),
+        remoteUrl,
+        auth,
+        defaultBranch,
+        logger: ctx.logger,
+        commitMessage: config.getOptionalString(
+          'scaffolder.defaultCommitMessage',
+        ),
+        gitAuthorInfo,
+      });
+
+      ctx.output('remoteUrl', remoteUrl);
+      ctx.output('repoContentsUrl', repoContentsUrl);
+    },
+  });
+}

plugins/scaffolder-backend/src/scaffolder/actions/builtin/publish/bitbucketServer.test.ts

@@ -0,0 +1,593 @@
+/*
+ * Copyright 2021 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.
+ */
+
+jest.mock('../helpers');
+
+import { createPublishBitbucketServerAction } from './bitbucketServer';
+import { rest } from 'msw';
+import { setupServer } from 'msw/node';
+import { setupRequestMockHandlers } from '@backstage/backend-test-utils';
+import { ScmIntegrations } from '@backstage/integration';
+import { ConfigReader } from '@backstage/config';
+import { getVoidLogger } from '@backstage/backend-common';
+import { PassThrough } from 'stream';
+import { initRepoAndPush } from '../helpers';
+
+describe('publish:bitbucketServer', () => {
+  const config = new ConfigReader({
+    integrations: {
+      bitbucketServer: [
+        {
+          host: 'hosted.bitbucket.com',
+          token: 'thing',
+          apiBaseUrl: 'https://hosted.bitbucket.com/rest/api/1.0',
+        },
+        {
+          host: 'notoken.bitbucket.com',
+        },
+      ],
+    },
+  });
+
+  const integrations = ScmIntegrations.fromConfig(config);
+  const action = createPublishBitbucketServerAction({ integrations, config });
+  const mockContext = {
+    input: {
+      repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+      repoVisibility: 'private' as const,
+    },
+    workspacePath: 'wsp',
+    logger: getVoidLogger(),
+    logStream: new PassThrough(),
+    output: jest.fn(),
+    createTemporaryDirectory: jest.fn(),
+  };
+  const server = setupServer();
+  setupRequestMockHandlers(server);
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should throw an error when the repoUrl is not well formed', async () => {
+    await expect(
+      action.handler({
+        ...mockContext,
+        input: {
+          ...mockContext.input,
+          repoUrl: 'hosted.bitbucket.com?repo=repo',
+        },
+      }),
+    ).rejects.toThrow(/missing project/);
+
+    await expect(
+      action.handler({
+        ...mockContext,
+        input: {
+          ...mockContext.input,
+          repoUrl: 'hosted.bitbucket.com?project=project',
+        },
+      }),
+    ).rejects.toThrow(/missing repo/);
+  });
+
+  it('should throw if there is no integration config provided', async () => {
+    await expect(
+      action.handler({
+        ...mockContext,
+        input: {
+          ...mockContext.input,
+          repoUrl: 'missing.com?project=project&repo=repo',
+        },
+      }),
+    ).rejects.toThrow(/No matching integration configuration/);
+  });
+
+  it('should throw if there is no token in the integration config that is returned', async () => {
+    await expect(
+      action.handler({
+        ...mockContext,
+        input: {
+          ...mockContext.input,
+          repoUrl: 'notoken.bitbucket.com?project=project&repo=repo',
+        },
+      }),
+    ).rejects.toThrow(
+      /Authorization has not been provided for notoken.bitbucket.com/,
+    );
+  });
+
+  it('should call the correct APIs', async () => {
+    expect.assertions(2);
+    server.use(
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({ public: false, name: 'repo' });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+      },
+    });
+  });
+
+  it('should work if the token is provided through ctx.input', async () => {
+    expect.assertions(2);
+    const token = 'user-token';
+    server.use(
+      rest.post(
+        'https://notoken.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe(`Bearer ${token}`);
+          expect(req.body).toEqual({ public: false, name: 'repo' });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        repoUrl: 'notoken.bitbucket.com?project=project&repo=repo',
+        token: token,
+      },
+    });
+  });
+
+  describe('LFS for hosted bitbucket', () => {
+    const repoCreationResponse = {
+      links: {
+        self: [
+          {
+            href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+          },
+        ],
+        clone: [
+          {
+            name: 'http',
+            href: 'https://bitbucket.mycompany.com/scm/project/repo',
+          },
+        ],
+      },
+    };
+
+    it('should call the correct APIs to enable LFS if requested and the host is hosted bitbucket', async () => {
+      expect.assertions(1);
+      server.use(
+        rest.post(
+          'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+          (_, res, ctx) => {
+            return res(
+              ctx.status(201),
+              ctx.set('Content-Type', 'application/json'),
+              ctx.json(repoCreationResponse),
+            );
+          },
+        ),
+        rest.put(
+          'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+          (req, res, ctx) => {
+            expect(req.headers.get('Authorization')).toBe('Bearer thing');
+            return res(ctx.status(204));
+          },
+        ),
+      );
+
+      await action.handler({
+        ...mockContext,
+        input: {
+          ...mockContext.input,
+          repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+          enableLFS: true,
+        },
+      });
+    });
+
+    it('should report an error if enabling LFS fails', async () => {
+      server.use(
+        rest.post(
+          'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+          (_, res, ctx) => {
+            return res(
+              ctx.status(201),
+              ctx.set('Content-Type', 'application/json'),
+              ctx.json(repoCreationResponse),
+            );
+          },
+        ),
+        rest.put(
+          'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+          (_, res, ctx) => {
+            return res(ctx.status(500));
+          },
+        ),
+      );
+
+      await expect(
+        action.handler({
+          ...mockContext,
+          input: {
+            ...mockContext.input,
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            enableLFS: true,
+          },
+        }),
+      ).rejects.toThrow(/Failed to enable LFS/);
+    });
+  });
+
+  it('should call initAndPush with the correct values', async () => {
+    server.use(
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({ public: false, name: 'repo' });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+
+    await action.handler(mockContext);
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      defaultBranch: 'master',
+      auth: { username: 'x-token-auth', password: 'thing' },
+      logger: mockContext.logger,
+      gitAuthorInfo: {},
+    });
+  });
+
+  it('should call initAndPush with the correct default branch', async () => {
+    server.use(
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({ public: false, name: 'repo' });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        defaultBranch: 'main',
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      defaultBranch: 'main',
+      auth: { username: 'x-token-auth', password: 'thing' },
+      logger: mockContext.logger,
+      gitAuthorInfo: {},
+    });
+  });
+
+  it('should call initAndPush with the configured defaultAuthor', async () => {
+    const customAuthorConfig = new ConfigReader({
+      integrations: {
+        bitbucketServer: [
+          {
+            host: 'hosted.bitbucket.com',
+            token: 'thing',
+            apiBaseUrl: 'https://hosted.bitbucket.com/rest/api/1.0',
+          },
+          {
+            host: 'notoken.bitbucket.com',
+          },
+        ],
+      },
+      scaffolder: {
+        defaultAuthor: {
+          name: 'Test',
+          email: 'example@example.com',
+        },
+      },
+    });
+
+    const customAuthorIntegrations =
+      ScmIntegrations.fromConfig(customAuthorConfig);
+    const customAuthorAction = createPublishBitbucketServerAction({
+      integrations: customAuthorIntegrations,
+      config: customAuthorConfig,
+    });
+
+    server.use(
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({ public: false, name: 'repo' });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+
+    await customAuthorAction.handler(mockContext);
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { username: 'x-token-auth', password: 'thing' },
+      logger: mockContext.logger,
+      defaultBranch: 'master',
+      gitAuthorInfo: { name: 'Test', email: 'example@example.com' },
+    });
+  });
+
+  it('should call initAndPush with the configured defaultCommitMessage', async () => {
+    const customAuthorConfig = new ConfigReader({
+      integrations: {
+        bitbucketServer: [
+          {
+            host: 'hosted.bitbucket.com',
+            token: 'thing',
+            apiBaseUrl: 'https://hosted.bitbucket.com/rest/api/1.0',
+          },
+          {
+            host: 'notoken.bitbucket.com',
+          },
+        ],
+      },
+      scaffolder: {
+        defaultCommitMessage: 'Test commit message',
+      },
+    });
+
+    const customAuthorIntegrations =
+      ScmIntegrations.fromConfig(customAuthorConfig);
+    const customAuthorAction = createPublishBitbucketServerAction({
+      integrations: customAuthorIntegrations,
+      config: customAuthorConfig,
+    });
+
+    server.use(
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({ public: false, name: 'repo' });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+
+    await customAuthorAction.handler(mockContext);
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { username: 'x-token-auth', password: 'thing' },
+      logger: mockContext.logger,
+      defaultBranch: 'master',
+      commitMessage: 'Test commit message',
+      gitAuthorInfo: { email: undefined, name: undefined },
+    });
+  });
+
+  it('should call outputs with the correct urls', async () => {
+    server.use(
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({ public: false, name: 'repo' });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+
+    await action.handler(mockContext);
+
+    expect(mockContext.output).toHaveBeenCalledWith(
+      'remoteUrl',
+      'https://bitbucket.mycompany.com/scm/project/repo',
+    );
+    expect(mockContext.output).toHaveBeenCalledWith(
+      'repoContentsUrl',
+      'https://bitbucket.mycompany.com/projects/project/repos/repo',
+    );
+  });
+
+  it('should call outputs with the correct urls with correct default branch', async () => {
+    server.use(
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({ public: false, name: 'repo' });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    );
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        defaultBranch: 'main',
+      },
+    });
+
+    expect(mockContext.output).toHaveBeenCalledWith(
+      'remoteUrl',
+      'https://bitbucket.mycompany.com/scm/project/repo',
+    );
+    expect(mockContext.output).toHaveBeenCalledWith(
+      'repoContentsUrl',
+      'https://bitbucket.mycompany.com/projects/project/repos/repo',
+    );
+  });
+});

plugins/scaffolder-backend/src/scaffolder/actions/builtin/publish/bitbucketServer.ts

@@ -0,0 +1,265 @@
+/*
+ * Copyright 2021 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 { InputError } from '@backstage/errors';
+import { ScmIntegrationRegistry } from '@backstage/integration';
+import fetch, { Response, RequestInit } from 'node-fetch';
+import { initRepoAndPush } from '../helpers';
+import { createTemplateAction } from '../../createTemplateAction';
+import { getRepoSourceDirectory, parseRepoUrl } from './util';
+import { Config } from '@backstage/config';
+
+const createRepository = async (opts: {
+  project: string;
+  repo: string;
+  description?: string;
+  repoVisibility: 'private' | 'public';
+  authorization: string;
+  apiBaseUrl: string;
+}) => {
+  const {
+    project,
+    repo,
+    description,
+    authorization,
+    repoVisibility,
+    apiBaseUrl,
+  } = opts;
+
+  let response: Response;
+  const options: RequestInit = {
+    method: 'POST',
+    body: JSON.stringify({
+      name: repo,
+      description: description,
+      public: repoVisibility === 'public',
+    }),
+    headers: {
+      Authorization: authorization,
+      'Content-Type': 'application/json',
+    },
+  };
+
+  try {
+    response = await fetch(`${apiBaseUrl}/projects/${project}/repos`, options);
+  } catch (e) {
+    throw new Error(`Unable to create repository, ${e}`);
+  }
+
+  if (response.status !== 201) {
+    throw new Error(
+      `Unable to create repository, ${response.status} ${
+        response.statusText
+      }, ${await response.text()}`,
+    );
+  }
+
+  const r = await response.json();
+  let remoteUrl = '';
+  for (const link of r.links.clone) {
+    if (link.name === 'http') {
+      remoteUrl = link.href;
+    }
+  }
+
+  const repoContentsUrl = `${r.links.self[0].href}`;
+  return { remoteUrl, repoContentsUrl };
+};
+
+const getAuthorizationHeader = (config: { token: string }) => {
+  return `Bearer ${config.token}`;
+};
+
+const performEnableLFS = async (opts: {
+  authorization: string;
+  host: string;
+  project: string;
+  repo: string;
+}) => {
+  const { authorization, host, project, repo } = opts;
+
+  const options: RequestInit = {
+    method: 'PUT',
+    headers: {
+      Authorization: authorization,
+    },
+  };
+
+  const { ok, status, statusText } = await fetch(
+    `https://${host}/rest/git-lfs/admin/projects/${project}/repos/${repo}/enabled`,
+    options,
+  );
+
+  if (!ok)
+    throw new Error(
+      `Failed to enable LFS in the repository, ${status}: ${statusText}`,
+    );
+};
+
+/**
+ * Creates a new action that initializes a git repository of the content in the workspace
+ * and publishes it to Bitbucket Server.
+ * @public
+ */
+export function createPublishBitbucketServerAction(options: {
+  integrations: ScmIntegrationRegistry;
+  config: Config;
+}) {
+  const { integrations, config } = options;
+
+  return createTemplateAction<{
+    repoUrl: string;
+    description?: string;
+    defaultBranch?: string;
+    repoVisibility?: 'private' | 'public';
+    sourcePath?: string;
+    enableLFS?: boolean;
+    token?: string;
+  }>({
+    id: 'publish:bitbucketServer',
+    description:
+      'Initializes a git repository of the content in the workspace, and publishes it to Bitbucket Server.',
+    schema: {
+      input: {
+        type: 'object',
+        required: ['repoUrl'],
+        properties: {
+          repoUrl: {
+            title: 'Repository Location',
+            type: 'string',
+          },
+          description: {
+            title: 'Repository Description',
+            type: 'string',
+          },
+          repoVisibility: {
+            title: 'Repository Visibility',
+            type: 'string',
+            enum: ['private', 'public'],
+          },
+          defaultBranch: {
+            title: 'Default Branch',
+            type: 'string',
+            description: `Sets the default branch on the repository. The default value is 'master'`,
+          },
+          sourcePath: {
+            title: 'Source Path',
+            description:
+              'Path within the workspace that will be used as the repository root. If omitted, the entire workspace will be published as the repository.',
+            type: 'string',
+          },
+          enableLFS: {
+            title: 'Enable LFS?',
+            description: 'Enable LFS for the repository.',
+            type: 'boolean',
+          },
+          token: {
+            title: 'Authentication Token',
+            type: 'string',
+            description:
+              'The token to use for authorization to BitBucket Server',
+          },
+        },
+      },
+      output: {
+        type: 'object',
+        properties: {
+          remoteUrl: {
+            title: 'A URL to the repository with the provider',
+            type: 'string',
+          },
+          repoContentsUrl: {
+            title: 'A URL to the root of the repository',
+            type: 'string',
+          },
+        },
+      },
+    },
+    async handler(ctx) {
+      const {
+        repoUrl,
+        description,
+        defaultBranch = 'master',
+        repoVisibility = 'private',
+        enableLFS = false,
+      } = ctx.input;
+
+      const { project, repo, host } = parseRepoUrl(repoUrl, integrations);
+
+      if (!project) {
+        throw new InputError(
+          `Invalid URL provider was included in the repo URL to create ${ctx.input.repoUrl}, missing project`,
+        );
+      }
+
+      const integrationConfig = integrations.bitbucketServer.byHost(host);
+      if (!integrationConfig) {
+        throw new InputError(
+          `No matching integration configuration for host ${host}, please check your integrations config`,
+        );
+      }
+
+      const token = ctx.input.token ?? integrationConfig.config.token;
+      if (!token) {
+        throw new Error(
+          `Authorization has not been provided for ${integrationConfig.config.host}. Please add either token to the Integrations config or a user login auth token`,
+        );
+      }
+
+      const authorization = getAuthorizationHeader({ token });
+
+      const apiBaseUrl = integrationConfig.config.apiBaseUrl;
+
+      const { remoteUrl, repoContentsUrl } = await createRepository({
+        authorization,
+        project,
+        repo,
+        repoVisibility,
+        description,
+        apiBaseUrl,
+      });
+
+      const gitAuthorInfo = {
+        name: config.getOptionalString('scaffolder.defaultAuthor.name'),
+        email: config.getOptionalString('scaffolder.defaultAuthor.email'),
+      };
+
+      const auth = {
+        username: 'x-token-auth',
+        password: token,
+      };
+
+      await initRepoAndPush({
+        dir: getRepoSourceDirectory(ctx.workspacePath, ctx.input.sourcePath),
+        remoteUrl,
+        auth,
+        defaultBranch,
+        logger: ctx.logger,
+        commitMessage: config.getOptionalString(
+          'scaffolder.defaultCommitMessage',
+        ),
+        gitAuthorInfo,
+      });
+
+      if (enableLFS) {
+        await performEnableLFS({ authorization, host, project, repo });
+      }
+
+      ctx.output('remoteUrl', remoteUrl);
+      ctx.output('repoContentsUrl', repoContentsUrl);
+    },
+  });
+}

plugins/scaffolder-backend/src/scaffolder/actions/builtin/publish/index.ts

@@ -16,6 +16,8 @@
 
 export { createPublishAzureAction } from './azure';
 export { createPublishBitbucketAction } from './bitbucket';
+export { createPublishBitbucketCloudAction } from './bitbucketCloud';
+export { createPublishBitbucketServerAction } from './bitbucketServer';
 export { createPublishFileAction } from './file';
 export { createPublishGithubAction } from './github';
 export { createPublishGithubPullRequestAction } from './githubPullRequest';