feature: octopus deploy integration

2025-03-25 14:05:03 +00:00 · 2024-11-22 11:22:47 -08:00
parent d7b494c6f8
commit cf275979ba
38 changed files with 1229 additions and 25 deletions
--- a/backend/package-lock.json
+++ b/backend/package-lock.json
@ -32,6 +32,8 @@
        "@octokit/plugin-retry": "^5.0.5",
        "@octokit/rest": "^20.0.2",
        "@octokit/webhooks-types": "^7.3.1",
+        "@octopusdeploy/api-client": "^3.4.1",
+        "@octopusdeploy/message-contracts": "^1.3.2",
        "@opentelemetry/api": "^1.9.0",
        "@opentelemetry/auto-instrumentations-node": "^0.53.0",
        "@opentelemetry/exporter-metrics-otlp-proto": "^0.55.0",
@ -6944,6 +6946,50 @@
      "resolved": "https://registry.npmjs.org/@octokit/webhooks-types/-/webhooks-types-7.1.0.tgz",
      "integrity": "sha512-y92CpG4kFFtBBjni8LHoV12IegJ+KFxLgKRengrVjKmGE5XMeCuGvlfRe75lTRrgXaG6XIWJlFpIDTlkoJsU8w=="
    },
+    "node_modules/@octopusdeploy/api-client": {
+      "version": "3.4.1",
+      "resolved": "https://registry.npmjs.org/@octopusdeploy/api-client/-/api-client-3.4.1.tgz",
+      "integrity": "sha512-j6FRgDNzc6AQoT3CAguYLWxoMR4W5TKCT1BCPpqjEN9mknmdMSKfYORs3djn/Yj/BhqtITTydDpBoREbzKY5+g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "adm-zip": "^0.5.9",
+        "axios": "^1.2.1",
+        "form-data": "^4.0.0",
+        "glob": "^8.0.3",
+        "lodash": "^4.17.21",
+        "semver": "^7.3.8",
+        "urijs": "^1.19.11"
+      }
+    },
+    "node_modules/@octopusdeploy/message-contracts": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@octopusdeploy/message-contracts/-/message-contracts-1.3.2.tgz",
+      "integrity": "sha512-UcpfKgnDVgejse07AvcvmBZCmoKkmXxdegneysS3+d/ariTySXzkLNaO/pGku50TBUPq8HnOZJgr7q9JP+rgsA==",
+      "license": "https://github.com/OctopusDeploy/message-contracts.ts/blob/main/LICENSE",
+      "dependencies": {
+        "@octopusdeploy/runtime-inputs": "^0.16.0",
+        "lodash": "^4.17.21",
+        "moment": "^2.29.4"
+      }
+    },
+    "node_modules/@octopusdeploy/runtime-inputs": {
+      "version": "0.16.0",
+      "resolved": "https://registry.npmjs.org/@octopusdeploy/runtime-inputs/-/runtime-inputs-0.16.0.tgz",
+      "integrity": "sha512-U0S7OmvyLxFgjzi1ePAf715b62o1NGBfxmDU+p3mljsC8xg4vnJGg7vJVQyleIPQQM7wKlY0sE+XPYgRhPzesg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@octopusdeploy/step-inputs": "^0.6.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@octopusdeploy/step-inputs": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@octopusdeploy/step-inputs/-/step-inputs-0.6.0.tgz",
+      "integrity": "sha512-paj0VXsu3kAVLqQU2+UwDH0b1wdoW8/1TnCtnkXFu9LH9t4tyKCLoDblTQw2LvKR/u6NGSfUR2V5DdpLFyRpow==",
+      "license": "Apache-2.0"
+    },
    "node_modules/@opentelemetry/api": {
      "version": "1.9.0",
      "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
@ -22365,6 +22411,12 @@
        "punycode": "^2.1.0"
      }
    },
+    "node_modules/urijs": {
+      "version": "1.19.11",
+      "resolved": "https://registry.npmjs.org/urijs/-/urijs-1.19.11.tgz",
+      "integrity": "sha512-HXgFDgDommxn5/bIv0cnQZsPhHDA90NPHD6+c/v21U5+Sx5hoP8+dP9IZXBU1gIfvdRfhG8cel9QNPeionfcCQ==",
+      "license": "MIT"
+    },
    "node_modules/url": {
      "version": "0.10.3",
      "resolved": "https://registry.npmjs.org/url/-/url-0.10.3.tgz",
--- a/backend/package.json
+++ b/backend/package.json
@ -140,6 +140,8 @@
    "@octokit/plugin-retry": "^5.0.5",
    "@octokit/rest": "^20.0.2",
    "@octokit/webhooks-types": "^7.3.1",
+    "@octopusdeploy/api-client": "^3.4.1",
+    "@octopusdeploy/message-contracts": "^1.3.2",
    "@opentelemetry/api": "^1.9.0",
    "@opentelemetry/auto-instrumentations-node": "^0.53.0",
    "@opentelemetry/exporter-metrics-otlp-proto": "^0.55.0",
--- a/backend/src/lib/api-docs/constants.ts
+++ b/backend/src/lib/api-docs/constants.ts
@ -1080,7 +1080,8 @@ export const INTEGRATION = {
      shouldDisableDelete: "The flag to disable deletion of secrets in AWS Parameter Store.",
      shouldMaskSecrets: "Specifies if the secrets synced from Infisical to Gitlab should be marked as 'Masked'.",
      shouldProtectSecrets: "Specifies if the secrets synced from Infisical to Gitlab should be marked as 'Protected'.",
-      shouldEnableDelete: "The flag to enable deletion of secrets."
+      shouldEnableDelete: "The flag to enable deletion of secrets.",
+      octopusDeployScopeValues: "Specifies the scope values to set on synced secrets to Octopus Deploy."
    }
  },
  UPDATE: {
--- a/backend/src/server/routes/v1/integration-auth-router.ts
+++ b/backend/src/server/routes/v1/integration-auth-router.ts
@ -5,6 +5,7 @@ import { INTEGRATION_AUTH } from "@app/lib/api-docs";
 import { readLimit, writeLimit } from "@app/server/config/rateLimiter";
 import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
 import { AuthMode } from "@app/services/auth/auth-type";
+import { OctopusDeployScope } from "@app/services/integration-auth/integration-auth-types";

 import { integrationAuthPubSchema } from "../sanitizedSchemas";

@ -1008,4 +1009,118 @@ export const registerIntegrationAuthRouter = async (server: FastifyZodProvider)
      return { buildConfigs };
    }
  });
+
+  server.route({
+    method: "GET",
+    url: "/:integrationAuthId/octopus-deploy/scope-values",
+    config: {
+      rateLimit: readLimit
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    schema: {
+      params: z.object({
+        integrationAuthId: z.string().trim()
+      }),
+      querystring: z.object({
+        scope: z.nativeEnum(OctopusDeployScope),
+        spaceId: z.string().trim(),
+        resourceId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          Environments: z
+            .object({
+              Name: z.string(),
+              Id: z.string()
+            })
+            .array(),
+          Machines: z
+            .object({
+              Name: z.string(),
+              Id: z.string()
+            })
+            .array(),
+          Actions: z
+            .object({
+              Name: z.string(),
+              Id: z.string()
+            })
+            .array(),
+          Roles: z
+            .object({
+              Name: z.string(),
+              Id: z.string()
+            })
+            .array(),
+          Channels: z
+            .object({
+              Name: z.string(),
+              Id: z.string()
+            })
+            .array(),
+          TenantTags: z
+            .object({
+              Name: z.string(),
+              Id: z.string()
+            })
+            .array(),
+          Processes: z
+            .object({
+              ProcessType: z.string(),
+              Name: z.string(),
+              Id: z.string()
+            })
+            .array()
+        })
+      }
+    },
+    handler: async (req) => {
+      const scopeValues = await server.services.integrationAuth.getOctopusDeployScopeValues({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        actorAuthMethod: req.permission.authMethod,
+        actorOrgId: req.permission.orgId,
+        id: req.params.integrationAuthId,
+        scope: req.query.scope,
+        spaceId: req.query.spaceId,
+        resourceId: req.query.resourceId
+      });
+      return scopeValues;
+    }
+  });
+
+  server.route({
+    method: "GET",
+    url: "/:integrationAuthId/octopus-deploy/spaces",
+    config: {
+      rateLimit: readLimit
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    schema: {
+      params: z.object({
+        integrationAuthId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          spaces: z
+            .object({
+              Name: z.string(),
+              Id: z.string(),
+              IsDefault: z.boolean()
+            })
+            .array()
+        })
+      }
+    },
+    handler: async (req) => {
+      const spaces = await server.services.integrationAuth.getOctopusDeploySpaces({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        actorAuthMethod: req.permission.authMethod,
+        actorOrgId: req.permission.orgId,
+        id: req.params.integrationAuthId
+      });
+      return { spaces };
+    }
+  });
 };
--- a/backend/src/services/integration-auth/integration-app-list.ts
+++ b/backend/src/services/integration-auth/integration-app-list.ts
@ -1,6 +1,7 @@
 /* eslint-disable no-await-in-loop */
 import { createAppAuth } from "@octokit/auth-app";
 import { Octokit } from "@octokit/rest";
+import { Client as OctopusDeployClient, ProjectRepository as OctopusDeployRepository } from "@octopusdeploy/api-client";

 import { TIntegrationAuths } from "@app/db/schemas";
 import { getConfig } from "@app/lib/config/env";
@ -1087,6 +1088,33 @@ const getAppsAzureDevOps = async ({ accessToken, orgName }: { accessToken: strin
  return apps;
 };

+const getAppsOctopusDeploy = async ({
+  apiKey,
+  instanceURL,
+  spaceName = "Default"
+}: {
+  apiKey: string;
+  instanceURL: string;
+  spaceName?: string;
+}) => {
+  const client = await OctopusDeployClient.create({
+    instanceURL,
+    apiKey,
+    userAgentApp: "Infisical Integration"
+  });
+
+  const repository = new OctopusDeployRepository(client, spaceName);
+
+  const projects = await repository.list({
+    take: 1000
+  });
+
+  return projects.Items.map((project) => ({
+    name: project.Name,
+    appId: project.Id
+  }));
+};
+
 export const getApps = async ({
  integration,
  integrationAuth,
@ -1260,6 +1288,13 @@ export const getApps = async ({
        orgName: azureDevOpsOrgName as string
      });

+    case Integrations.OCTOPUS_DEPLOY:
+      return getAppsOctopusDeploy({
+        apiKey: accessToken,
+        instanceURL: url!,
+        spaceName: workspaceSlug
+      });
+
    default:
      throw new NotFoundError({ message: `Integration '${integration}' not found` });
  }
--- a/backend/src/services/integration-auth/integration-auth-service.ts
+++ b/backend/src/services/integration-auth/integration-auth-service.ts
@ -1,6 +1,7 @@
 import { ForbiddenError } from "@casl/ability";
 import { createAppAuth } from "@octokit/auth-app";
 import { Octokit } from "@octokit/rest";
+import { Client as OctopusClient, SpaceRepository as OctopusSpaceRepository } from "@octopusdeploy/api-client";
 import AWS from "aws-sdk";

 import { SecretEncryptionAlgo, SecretKeyEncoding, TIntegrationAuths, TIntegrationAuthsInsert } from "@app/db/schemas";
@ -9,7 +10,7 @@ import { ProjectPermissionActions, ProjectPermissionSub } from "@app/ee/services
 import { getConfig } from "@app/lib/config/env";
 import { request } from "@app/lib/config/request";
 import { decryptSymmetric128BitHexKeyUTF8, encryptSymmetric128BitHexKeyUTF8 } from "@app/lib/crypto";
-import { BadRequestError, NotFoundError } from "@app/lib/errors";
+import { BadRequestError, InternalServerError, NotFoundError } from "@app/lib/errors";
 import { TGenericPermission, TProjectPermission } from "@app/lib/types";

 import { TIntegrationDALFactory } from "../integration/integration-dal";
@ -20,6 +21,7 @@ import { getApps } from "./integration-app-list";
 import { TIntegrationAuthDALFactory } from "./integration-auth-dal";
 import { IntegrationAuthMetadataSchema, TIntegrationAuthMetadata } from "./integration-auth-schema";
 import {
+  OctopusDeployScope,
  TBitbucketEnvironment,
  TBitbucketWorkspace,
  TChecklyGroups,
@ -38,6 +40,8 @@ import {
  TIntegrationAuthGithubOrgsDTO,
  TIntegrationAuthHerokuPipelinesDTO,
  TIntegrationAuthNorthflankSecretGroupDTO,
+  TIntegrationAuthOctopusDeployProjectScopeValuesDTO,
+  TIntegrationAuthOctopusDeploySpacesDTO,
  TIntegrationAuthQoveryEnvironmentsDTO,
  TIntegrationAuthQoveryOrgsDTO,
  TIntegrationAuthQoveryProjectDTO,
@ -48,6 +52,7 @@ import {
  TIntegrationAuthVercelBranchesDTO,
  TNorthflankSecretGroup,
  TOauthExchangeDTO,
+  TOctopusDeployVariableSet,
  TSaveIntegrationAccessTokenDTO,
  TTeamCityBuildConfig,
  TVercelBranches
@ -1521,6 +1526,88 @@ export const integrationAuthServiceFactory = ({
    return integrationAuthDAL.create(newIntegrationAuth);
  };

+  const getOctopusDeploySpaces = async ({
+    actorId,
+    actor,
+    actorOrgId,
+    actorAuthMethod,
+    id
+  }: TIntegrationAuthOctopusDeploySpacesDTO) => {
+    const integrationAuth = await integrationAuthDAL.findById(id);
+    if (!integrationAuth) throw new NotFoundError({ message: `Integration auth with ID '${id}' not found` });
+
+    const { permission } = await permissionService.getProjectPermission(
+      actor,
+      actorId,
+      integrationAuth.projectId,
+      actorAuthMethod,
+      actorOrgId
+    );
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Read, ProjectPermissionSub.Integrations);
+    const { shouldUseSecretV2Bridge, botKey } = await projectBotService.getBotKey(integrationAuth.projectId);
+    const { accessToken } = await getIntegrationAccessToken(integrationAuth, shouldUseSecretV2Bridge, botKey);
+
+    const client = await OctopusClient.create({
+      apiKey: accessToken,
+      instanceURL: integrationAuth.url!,
+      userAgentApp: "Infisical Integration"
+    });
+
+    const spaceRepository = new OctopusSpaceRepository(client);
+
+    const spaces = await spaceRepository.list({
+      partialName: "", // throws error if no string is present...
+      take: 1000
+    });
+
+    return spaces.Items;
+  };
+
+  const getOctopusDeployScopeValues = async ({
+    actorId,
+    actor,
+    actorOrgId,
+    actorAuthMethod,
+    id,
+    scope,
+    spaceId,
+    resourceId
+  }: TIntegrationAuthOctopusDeployProjectScopeValuesDTO) => {
+    const integrationAuth = await integrationAuthDAL.findById(id);
+    if (!integrationAuth) throw new NotFoundError({ message: `Integration auth with ID '${id}' not found` });
+
+    const { permission } = await permissionService.getProjectPermission(
+      actor,
+      actorId,
+      integrationAuth.projectId,
+      actorAuthMethod,
+      actorOrgId
+    );
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Read, ProjectPermissionSub.Integrations);
+    const { shouldUseSecretV2Bridge, botKey } = await projectBotService.getBotKey(integrationAuth.projectId);
+    const { accessToken } = await getIntegrationAccessToken(integrationAuth, shouldUseSecretV2Bridge, botKey);
+
+    let url: string;
+    switch (scope) {
+      case OctopusDeployScope.Project:
+        url = `${integrationAuth.url}/api/${spaceId}/projects/${resourceId}/variables`;
+        break;
+      // future support tenant, variable set etc.
+      default:
+        throw new InternalServerError({ message: `Unhandled Octopus Deploy scope` });
+    }
+
+    // SDK doesn't support variable set...
+    const { data: variableSet } = await request.get<TOctopusDeployVariableSet>(url, {
+      headers: {
+        "X-NuGet-ApiKey": accessToken,
+        Accept: "application/json"
+      }
+    });
+
+    return variableSet.ScopeValues;
+  };
+
  return {
    listIntegrationAuthByProjectId,
    listOrgIntegrationAuth,
@ -1552,6 +1639,8 @@ export const integrationAuthServiceFactory = ({
    getBitbucketWorkspaces,
    getBitbucketEnvironments,
    getIntegrationAccessToken,
-    duplicateIntegrationAuth
+    duplicateIntegrationAuth,
+    getOctopusDeploySpaces,
+    getOctopusDeployScopeValues
  };
 };
--- a/backend/src/services/integration-auth/integration-auth-types.ts
+++ b/backend/src/services/integration-auth/integration-auth-types.ts
@ -193,3 +193,72 @@ export type TIntegrationsWithEnvironment = TIntegrations & {
    | null
    | undefined;
 };
+
+export type TIntegrationAuthOctopusDeploySpacesDTO = {
+  id: string;
+} & Omit<TProjectPermission, "projectId">;
+
+export type TIntegrationAuthOctopusDeployProjectScopeValuesDTO = {
+  id: string;
+  spaceId: string;
+  resourceId: string;
+  scope: OctopusDeployScope;
+} & Omit<TProjectPermission, "projectId">;
+
+export enum OctopusDeployScope {
+  Project = "project"
+  // add tenant, variable set, etc.
+}
+
+export type TOctopusDeployVariableSet = {
+  Id: string;
+  OwnerId: string;
+  Version: number;
+  Variables: {
+    Id: string;
+    Name: string;
+    Value: string;
+    Description: string;
+    Scope: {
+      Environment?: string[];
+      Machine?: string[];
+      Role?: string[];
+      TargetRole?: string[];
+      Action?: string[];
+      User?: string[];
+      Trigger?: string[];
+      ParentDeployment?: string[];
+      Private?: string[];
+      Channel?: string[];
+      TenantTag?: string[];
+      Tenant?: string[];
+      ProcessOwner?: string[];
+    };
+    IsEditable: boolean;
+    Prompt: {
+      Description: string;
+      DisplaySettings: Record<string, string>;
+      Label: string;
+      Required: boolean;
+    } | null;
+    Type: "String";
+    IsSensitive: boolean;
+  }[];
+  ScopeValues: {
+    Environments: { Id: string; Name: string }[];
+    Machines: { Id: string; Name: string }[];
+    Actions: { Id: string; Name: string }[];
+    Roles: { Id: string; Name: string }[];
+    Channels: { Id: string; Name: string }[];
+    TenantTags: { Id: string; Name: string }[];
+    Processes: {
+      ProcessType: string;
+      Id: string;
+      Name: string;
+    }[];
+  };
+  SpaceId: string;
+  Links: {
+    Self: string;
+  };
+};
--- a/backend/src/services/integration-auth/integration-list.ts
+++ b/backend/src/services/integration-auth/integration-list.ts
@ -34,7 +34,8 @@ export enum Integrations {
  HASURA_CLOUD = "hasura-cloud",
  RUNDECK = "rundeck",
  AZURE_DEVOPS = "azure-devops",
-  AZURE_APP_CONFIGURATION = "azure-app-configuration"
+  AZURE_APP_CONFIGURATION = "azure-app-configuration",
+  OCTOPUS_DEPLOY = "octopus-deploy"
 }

 export enum IntegrationType {
@ -413,6 +414,15 @@ export const getIntegrationOptions = async () => {
      type: "pat",
      clientId: "",
      docsLink: ""
+    },
+    {
+      name: "Octopus Deploy",
+      slug: "octopus-deploy",
+      image: "Octopus Deploy.png",
+      isAvailable: true,
+      type: "sat",
+      clientId: "",
+      docsLink: ""
    }
  ];

--- a/backend/src/services/integration-auth/integration-sync-secret.ts
+++ b/backend/src/services/integration-auth/integration-sync-secret.ts
@ -32,14 +32,14 @@ import { z } from "zod";
 import { SecretType, TIntegrationAuths, TIntegrations } from "@app/db/schemas";
 import { getConfig } from "@app/lib/config/env";
 import { request } from "@app/lib/config/request";
-import { BadRequestError } from "@app/lib/errors";
+import { BadRequestError, InternalServerError } from "@app/lib/errors";
 import { logger } from "@app/lib/logger";
 import { TCreateManySecretsRawFn, TUpdateManySecretsRawFn } from "@app/services/secret/secret-types";

 import { TIntegrationDALFactory } from "../integration/integration-dal";
 import { IntegrationMetadataSchema } from "../integration/integration-schema";
 import { IntegrationAuthMetadataSchema } from "./integration-auth-schema";
-import { TIntegrationsWithEnvironment } from "./integration-auth-types";
+import { OctopusDeployScope, TIntegrationsWithEnvironment, TOctopusDeployVariableSet } from "./integration-auth-types";
 import {
  IntegrationInitialSyncBehavior,
  IntegrationMappingBehavior,
@ -4201,6 +4201,61 @@ const syncSecretsRundeck = async ({
  }
 };

+const syncSecretsOctopusDeploy = async ({
+  integration,
+  integrationAuth,
+  secrets,
+  accessToken
+}: {
+  integration: TIntegrations;
+  integrationAuth: TIntegrationAuths;
+  secrets: Record<string, { value: string; comment?: string }>;
+  accessToken: string;
+}) => {
+  let url: string;
+  switch (integration.scope) {
+    case OctopusDeployScope.Project:
+      url = `${integrationAuth.url}/api/${integration.targetEnvironmentId}/projects/${integration.appId}/variables`;
+      break;
+    // future support tenant, variable set, etc.
+    default:
+      throw new InternalServerError({ message: `Unhandled Octopus Deploy scope: ${integration.scope}` });
+  }
+
+  // SDK doesn't support variable set...
+  const { data: variableSet } = await request.get<TOctopusDeployVariableSet>(url, {
+    headers: {
+      "X-NuGet-ApiKey": accessToken,
+      Accept: "application/json"
+    }
+  });
+
+  await request.put(
+    url,
+    {
+      ...variableSet,
+      Variables: Object.entries(secrets).map(([key, value]) => ({
+        Name: key,
+        Value: value.value,
+        Description: value.comment ?? "",
+        Scope:
+          (integration.metadata as { octopusDeployScopeValues: TOctopusDeployVariableSet["ScopeValues"] })
+            ?.octopusDeployScopeValues ?? {},
+        IsEditable: false,
+        Prompt: null,
+        Type: "String",
+        IsSensitive: true
+      }))
+    } as unknown as TOctopusDeployVariableSet,
+    {
+      headers: {
+        "X-NuGet-ApiKey": accessToken,
+        Accept: "application/json"
+      }
+    }
+  );
+};
+
 /**
 * Sync/push [secrets] to [app] in integration named [integration]
 *
@ -4513,6 +4568,14 @@ export const syncIntegrationSecrets = async ({
        accessToken
      });
      break;
+    case Integrations.OCTOPUS_DEPLOY:
+      await syncSecretsOctopusDeploy({
+        integration,
+        integrationAuth,
+        secrets,
+        accessToken
+      });
+      break;
    default:
      throw new BadRequestError({ message: "Invalid integration" });
  }
--- a/backend/src/services/integration/integration-schema.ts
+++ b/backend/src/services/integration/integration-schema.ts
@ -46,5 +46,18 @@ export const IntegrationMetadataSchema = z.object({
  shouldDisableDelete: z.boolean().optional().describe(INTEGRATION.CREATE.metadata.shouldDisableDelete),
  shouldEnableDelete: z.boolean().optional().describe(INTEGRATION.CREATE.metadata.shouldEnableDelete),
  shouldMaskSecrets: z.boolean().optional().describe(INTEGRATION.CREATE.metadata.shouldMaskSecrets),
-  shouldProtectSecrets: z.boolean().optional().describe(INTEGRATION.CREATE.metadata.shouldProtectSecrets)
+  shouldProtectSecrets: z.boolean().optional().describe(INTEGRATION.CREATE.metadata.shouldProtectSecrets),
+
+  octopusDeployScopeValues: z
+    .object({
+      // in Octopus Deploy Scope Value Format
+      Environment: z.string().array().optional(),
+      Action: z.string().array().optional(),
+      Channel: z.string().array().optional(),
+      Machine: z.string().array().optional(),
+      ProcessOwner: z.string().array().optional(),
+      Role: z.string().array().optional()
+    })
+    .optional()
+    .describe(INTEGRATION.CREATE.metadata.octopusDeployScopeValues)
 });
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-add-role.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-add-role.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-add-to-team.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-add-to-team.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-authorize.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-authorize.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-copy-api-key.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-copy-api-key.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-create-api-key.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-create-api-key.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-create-service-account.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-create-service-account.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-create-team.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-create-team.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-create.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-create.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-generate-api-key.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-generate-api-key.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-integrations.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-integrations.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-save-team.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-save-team.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-sync.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-sync.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-team-settings.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-team-settings.png
--- a/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-user-settings.png
+++ b/docs/images/integrations/octopus-deploy/integrations-octopus-deploy-user-settings.png
--- a/docs/integrations/cicd/octopus-deploy.mdx
+++ b/docs/integrations/cicd/octopus-deploy.mdx
@ -0,0 +1,69 @@
+---
+title: "Octopus Deploy"
+description: "Learn how to sync secrets from Infisical to Octopus Deploy"
+---
+
+Prerequisites:
+
+- Set up and add secrets to [Infisical Cloud](https://app.infisical.com)
+
+<Steps>
+    <Step title="Create a Service Account for Infisical in Octopus Deploy">
+        Navigate to **Configuration** > **Users** and click on the **Create Service Account** button.
+
+        ![integrations octopus deploy
+        users](/images/integrations/octopus-deploy/integrations-octopus-deploy-user-settings.png)
+
+        Fill out the required fields and click on the **Save** button.
+        ![integrations octopus deploy service
+        account](/images/integrations/octopus-deploy/integrations-octopus-deploy-create-service-account.png)
+    </Step>
+    <Step title="Generate an API Key for your Service Account">
+        On the **Service Account** user page, expand the **API Keys** section and click on the **New API Key** button.
+
+        ![integrations octopus deploy
+        new api key](/images/integrations/octopus-deploy/integrations-octopus-deploy-create-api-key.png)
+
+        Fill out the required fields and click on the **Generate New** button.
+
+        ![integrations octopus deploy
+        generate api key](/images/integrations/octopus-deploy/integrations-octopus-deploy-generate-api-key.png)
+
+        Copy the generated **API Key** and click on the **Close** button.
+
+        ![integrations octopus deploy
+        copy api key](/images/integrations/octopus-deploy/integrations-octopus-deploy-copy-api-key.png)
+    </Step>
+    <Step title="Create a Service Accounts Team and assign your Service Account">
+        Navigate to **Configuration** > **Teams** and click on the **Add Team** button.
+
+        ![integrations octopus deploy
+        teams](/images/integrations/octopus-deploy/integrations-octopus-deploy-team-settings.png)
+
+        Create a new team for **Service Accounts** and click on the **Save** button.
+        ![integrations octopus deploy add
+        team](/images/integrations/octopus-deploy/integrations-octopus-deploy-create-team.png)
+
+        On the **Members** tab, click on the **Add Member** button, add your **Infisical Service Account** and click on the **Add** button.
+        ![integrations octopus deploy add service account to team](/images/integrations/octopus-deploy/integrations-octopus-deploy-add-to-team.png)
+
+        On the **User Roles** tab, click on the **Include User Role** button, add the **Project Contributor** role and click on the **Apply** button.
+        ![integrations octopus deploy add user roles to team](/images/integrations/octopus-deploy/integrations-octopus-deploy-add-role.png)
+
+        Save your team changes by clicking on the **Save** button.
+        ![integrations octopus deploy save team changes](/images/integrations/octopus-deploy/integrations-octopus-deploy-save-team.png)
+    </Step>
+    <Step title="Setup Integration">
+        In Infisical, navigate to your **Project** > **Integrations** page and select the **Octopus Deploy** integration.
+        ![integration octopus deploy](/images/integrations/octopus-deploy/integrations-octopus-deploy-integrations.png)
+
+        Enter your **Instance URL** and **API Key** from **Octopus Deploy** to authorize Infisical.
+        ![integration octopus deploy](/images/integrations/octopus-deploy/integrations-octopus-deploy-authorize.png)
+
+        Select a **Space** and **Project** from **Octopus Deploy** to sync secrets to; configuring additional **Scope Values** as needed. Click on the **Create Integration** button once configured.
+        ![integration octopus deploy](/images/integrations/octopus-deploy/integrations-octopus-deploy-create.png)
+
+        Your Infisical secrets will begin to sync to **Octopus Deploy**.
+        ![integration octopus deploy](/images/integrations/octopus-deploy/integrations-octopus-deploy-sync.png)
+    </Step>
+</Steps>
--- a/docs/integrations/overview.mdx
+++ b/docs/integrations/overview.mdx
@ -42,6 +42,7 @@ Missing an integration? [Throw in a request](https://github.com/Infisical/infisi
 | [CircleCI](/integrations/cicd/circleci)                        | CI/CD                  | Available   |
 | [Travis CI](/integrations/cicd/travisci)                       | CI/CD                  | Available   |
 | [Rundeck](/integrations/cicd/rundeck)                          | CI/CD                  | Available   |
+| [Octopus Deploy](/integrations/cicd/octopus-deploy)            | CI/CD                  | Available   |
 | [React](/integrations/frameworks/react)                        | Framework              | Available   |
 | [Vue](/integrations/frameworks/vue)                            | Framework              | Available   |
 | [Express](/integrations/frameworks/express)                    | Framework              | Available   |
--- a/docs/mint.json
+++ b/docs/mint.json
@ -422,7 +422,8 @@
            "integrations/cicd/travisci",
            "integrations/cicd/rundeck",
            "integrations/cicd/codefresh",
-            "integrations/cloud/checkly"
+            "integrations/cloud/checkly",
+            "integrations/cicd/octopus-deploy"
          ]
        }
      ]
--- a/frontend/public/data/frequentConstants.ts
+++ b/frontend/public/data/frequentConstants.ts
@ -36,7 +36,8 @@ const integrationSlugNameMapping: Mapping = {
  "hasura-cloud": "Hasura Cloud",
  rundeck: "Rundeck",
  "azure-devops": "Azure DevOps",
-  "azure-app-configuration": "Azure App Configuration"
+  "azure-app-configuration": "Azure App Configuration",
+  "octopus-deploy": "Octopus Deploy"
 };

 const envMapping: Mapping = {
--- a/frontend/public/images/integrations/Octopus
+++ b/frontend/public/images/integrations/Octopus
--- a/frontend/src/components/v2/FilterableSelect/FilterableSelect.tsx
+++ b/frontend/src/components/v2/FilterableSelect/FilterableSelect.tsx
@ -79,7 +79,8 @@ export const FilterableSelect = <T,>({ isMulti, closeMenuOnSelect, ...props }: P
        ),
      placeholder: () => "text-mineshaft-400 text-sm pl-1 py-0.5",
      input: () => "pl-1 py-0.5",
-      valueContainer: () => `p-1 max-h-[14rem] ${isMulti ? "!overflow-y-scroll" : ""} gap-1`,
+      valueContainer: () =>
+        `p-1 max-h-[14rem] ${isMulti ? "!overflow-y-auto thin-scrollbar" : ""} gap-1`,
      singleValue: () => "leading-7 ml-1",
      multiValue: () => "bg-mineshaft-600 rounded items-center py-0.5 px-2 gap-1.5",
      multiValueLabel: () => "leading-6 text-sm",
--- a/frontend/src/hooks/api/integrationAuth/queries.tsx
+++ b/frontend/src/hooks/api/integrationAuth/queries.tsx
@ -17,7 +17,9 @@ import {
  Project,
  Service,
  Team,
-  TeamCityBuildConfig
+  TeamCityBuildConfig,
+  TGetIntegrationAuthOctopusDeployScopeValuesDTO,
+  TOctopusDeployScopeValues
 } from "./types";

 const integrationAuthKeys = {
@ -119,7 +121,14 @@ const integrationAuthKeys = {
  }: {
    integrationAuthId: string;
    appId: string;
-  }) => [{ integrationAuthId, appId }, "integrationAuthTeamCityBranchConfigs"] as const
+  }) => [{ integrationAuthId, appId }, "integrationAuthTeamCityBranchConfigs"] as const,
+  getIntegrationAuthOctopusDeploySpaces: (integrationAuthId: string) =>
+    [{ integrationAuthId }, "getIntegrationAuthOctopusDeploySpaces"] as const,
+  getIntegrationAuthOctopusDeployScopeValues: ({
+    integrationAuthId,
+    ...params
+  }: TGetIntegrationAuthOctopusDeployScopeValuesDTO) =>
+    [{ integrationAuthId }, "getIntegrationAuthOctopusDeployScopeValues", params] as const
 };

 const fetchIntegrationAuthById = async (integrationAuthId: string) => {
@ -479,6 +488,28 @@ const fetchIntegrationAuthTeamCityBuildConfigs = async ({
  return buildConfigs;
 };

+const fetchIntegrationAuthOctopusDeploySpaces = async (integrationAuthId: string) => {
+  const {
+    data: { spaces }
+  } = await apiRequest.get<{
+    spaces: { Name: string; Slug: string; Id: string; IsDefault: boolean }[];
+  }>(`/api/v1/integration-auth/${integrationAuthId}/octopus-deploy/spaces`);
+  return spaces;
+};
+
+const fetchIntegrationAuthOctopusDeployScopeValues = async ({
+  integrationAuthId,
+  scope,
+  spaceId,
+  resourceId
+}: TGetIntegrationAuthOctopusDeployScopeValuesDTO) => {
+  const { data } = await apiRequest.get<TOctopusDeployScopeValues>(
+    `/api/v1/integration-auth/${integrationAuthId}/octopus-deploy/scope-values`,
+    { params: { scope, spaceId, resourceId } }
+  );
+  return data;
+};
+
 export const useGetIntegrationAuthById = (integrationAuthId: string) => {
  return useQuery({
    queryKey: integrationAuthKeys.getIntegrationAuthById(integrationAuthId),
@ -487,17 +518,24 @@ export const useGetIntegrationAuthById = (integrationAuthId: string) => {
  });
 };

-export const useGetIntegrationAuthApps = ({
-  integrationAuthId,
-  teamId,
-  azureDevOpsOrgName,
-  workspaceSlug
-}: {
-  integrationAuthId: string;
-  teamId?: string;
-  azureDevOpsOrgName?: string;
-  workspaceSlug?: string;
-}) => {
+export const useGetIntegrationAuthApps = (
+  {
+    integrationAuthId,
+    teamId,
+    azureDevOpsOrgName,
+    workspaceSlug
+  }: {
+    integrationAuthId: string;
+    teamId?: string;
+    azureDevOpsOrgName?: string;
+    workspaceSlug?: string;
+  },
+  options?: UseQueryOptions<
+    Awaited<ReturnType<typeof fetchIntegrationAuthApps>>,
+    unknown,
+    Awaited<ReturnType<typeof fetchIntegrationAuthApps>>
+  >
+) => {
  return useQuery({
    queryKey: integrationAuthKeys.getIntegrationAuthApps(integrationAuthId, teamId, workspaceSlug),
    queryFn: () =>
@ -507,7 +545,7 @@ export const useGetIntegrationAuthApps = ({
        azureDevOpsOrgName,
        workspaceSlug
      }),
-    enabled: true
+    ...options
  });
 };

@ -759,6 +797,23 @@ export const useGetIntegrationAuthBitBucketWorkspaces = (integrationAuthId: stri
  });
 };

+export const useGetIntegrationAuthOctopusDeploySpaces = (integrationAuthId: string) => {
+  return useQuery({
+    queryKey: integrationAuthKeys.getIntegrationAuthBitBucketWorkspaces(integrationAuthId),
+    queryFn: () => fetchIntegrationAuthOctopusDeploySpaces(integrationAuthId)
+  });
+};
+
+export const useGetIntegrationAuthOctopusDeployScopeValues = (
+  params: TGetIntegrationAuthOctopusDeployScopeValuesDTO,
+  options?: UseQueryOptions<TOctopusDeployScopeValues, unknown, TOctopusDeployScopeValues>
+) =>
+  useQuery({
+    queryKey: integrationAuthKeys.getIntegrationAuthOctopusDeployScopeValues(params),
+    queryFn: () => fetchIntegrationAuthOctopusDeployScopeValues(params),
+    ...options
+  });
+
 export const useGetIntegrationAuthBitBucketEnvironments = (
  {
    integrationAuthId,
--- a/frontend/src/hooks/api/integrationAuth/types.ts
+++ b/frontend/src/hooks/api/integrationAuth/types.ts
@ -99,3 +99,29 @@ export type TDuplicateIntegrationAuthDTO = {
  integrationAuthId: string;
  projectId: string;
 };
+
+export enum OctopusDeployScope {
+  Project = "project"
+  // tenant, variable set
+}
+
+export type TGetIntegrationAuthOctopusDeployScopeValuesDTO = {
+  integrationAuthId: string;
+  spaceId: string;
+  resourceId: string;
+  scope: OctopusDeployScope;
+};
+
+export type TOctopusDeployScopeValues = {
+  Environments: { Id: string; Name: string }[];
+  Machines: { Id: string; Name: string }[];
+  Actions: { Id: string; Name: string }[];
+  Roles: { Id: string; Name: string }[];
+  Channels: { Id: string; Name: string }[];
+  TenantTags: { Id: string; Name: string }[];
+  Processes: {
+    ProcessType: string;
+    Id: string;
+    Name: string;
+  }[];
+};
--- a/frontend/src/hooks/api/integrations/queries.tsx
+++ b/frontend/src/hooks/api/integrations/queries.tsx
@ -87,6 +87,14 @@ export const useCreateIntegration = () => {
        shouldMaskSecrets?: boolean;
        shouldProtectSecrets?: boolean;
        shouldEnableDelete?: boolean;
+        octopusDeployScopeValues?: {
+          Environment?: string[];
+          Action?: string[];
+          Channel?: string[];
+          Machine?: string[];
+          ProcessOwner?: string[];
+          Role?: string[];
+        };
      };
    }) => {
      const {
--- a/frontend/src/pages/integrations/bitbucket/create.tsx
+++ b/frontend/src/pages/integrations/bitbucket/create.tsx
@ -181,7 +181,7 @@ export default function BitBucketCreateIntegrationPage() {
                onChange={onChange}
                options={currentWorkspace?.environments}
                placeholder="Select a project environment"
-                isDisabled={!bitbucketWorkspaces?.length}
+                isDisabled={!currentWorkspace?.environments.length}
              />
            </FormControl>
          )}
--- a/frontend/src/pages/integrations/octopus-deploy/authorize.tsx
+++ b/frontend/src/pages/integrations/octopus-deploy/authorize.tsx
@ -0,0 +1,138 @@
+import { Controller, useForm } from "react-hook-form";
+import Head from "next/head";
+import Image from "next/image";
+import Link from "next/link";
+import { useRouter } from "next/router";
+import { faArrowUpRightFromSquare, faBookOpen } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { z } from "zod";
+
+import { createNotification } from "@app/components/notifications";
+import { Button, Card, CardTitle, FormControl, Input } from "@app/components/v2";
+import { useWorkspace } from "@app/context";
+import { removeTrailingSlash } from "@app/helpers/string";
+import { useSaveIntegrationAccessToken } from "@app/hooks/api";
+
+const formSchema = z.object({
+  instanceUrl: z.string().min(1, { message: "Instance URL required" }),
+  apiKey: z.string().min(1, { message: "API Key required" })
+});
+
+type TForm = z.infer<typeof formSchema>;
+
+export default function OctopusDeployIntegrationPage() {
+  const router = useRouter();
+  const { mutateAsync, isLoading } = useSaveIntegrationAccessToken();
+  const { currentWorkspace } = useWorkspace();
+
+  const { control, handleSubmit } = useForm<TForm>({
+    resolver: zodResolver(formSchema)
+  });
+
+  const onSubmit = async ({ instanceUrl, apiKey }: TForm) => {
+    try {
+      const integrationAuth = await mutateAsync({
+        workspaceId: currentWorkspace!.id,
+        integration: "octopus-deploy",
+        url: removeTrailingSlash(instanceUrl),
+        accessToken: apiKey
+      });
+
+      router.push(`/integrations/octopus-deploy/create?integrationAuthId=${integrationAuth.id}`);
+    } catch (err: any) {
+      createNotification({
+        type: "error",
+        text: err.message ?? "Error authorizing integration"
+      });
+      console.error(err);
+    }
+  };
+
+  return (
+    <form
+      onSubmit={handleSubmit(onSubmit)}
+      className="flex h-full w-full items-center justify-center"
+    >
+      <Head>
+        <title>Authorize Octopus Deploy Integration</title>
+        <link rel="icon" href="/infisical.ico" />
+      </Head>
+      <Card className="mb-12 max-w-lg rounded-md border border-mineshaft-600">
+        <CardTitle
+          className="px-6 text-left text-xl"
+          subTitle="After adding your credentials, you will be prompted to set up an integration for a particular environment and secret path."
+        >
+          <div className="flex flex-row items-center">
+            <div className="inline-flex items-center pb-0.5">
+              <Image
+                src="/images/integrations/Octopus Deploy.png"
+                height={30}
+                width={30}
+                alt="Databricks logo"
+              />
+            </div>
+            <span className="ml-1.5">Octopus Deploy Integration</span>
+            <Link href="https://infisical.com/docs/integrations/cloud/octopus-deploy" passHref>
+              <a target="_blank" rel="noopener noreferrer">
+                <div className="ml-2 mb-1 inline-block cursor-default rounded-md bg-yellow/20 px-1.5 pb-[0.03rem] pt-[0.04rem] text-sm text-yellow opacity-80 hover:opacity-100">
+                  <FontAwesomeIcon icon={faBookOpen} className="mr-1.5" />
+                  Docs
+                  <FontAwesomeIcon
+                    icon={faArrowUpRightFromSquare}
+                    className="ml-1.5 mb-[0.07rem] text-xxs"
+                  />
+                </div>
+              </a>
+            </Link>
+          </div>
+        </CardTitle>
+        <Controller
+          render={({ field: { value, onChange }, fieldState: { error } }) => (
+            <FormControl
+              label="Octopus Deploy Instance URL"
+              errorText={error?.message}
+              isError={Boolean(error)}
+              className="px-6"
+            >
+              <Input value={value} onChange={onChange} placeholder="https://xxxx.octopus.app" />
+            </FormControl>
+          )}
+          name="instanceUrl"
+          control={control}
+        />
+        <Controller
+          render={({ field: { value, onChange }, fieldState: { error } }) => (
+            <FormControl
+              label="Octopus Deploy API Key"
+              errorText={error?.message}
+              isError={Boolean(error)}
+              className="px-6"
+            >
+              <Input
+                value={value}
+                onChange={onChange}
+                placeholder="API-XXXXXXXXXXXXXXXXXXXXXXXX"
+                type="password"
+              />
+            </FormControl>
+          )}
+          name="apiKey"
+          control={control}
+        />
+        <Button
+          type="submit"
+          colorSchema="primary"
+          variant="outline_bg"
+          className="mb-6 mt-2 ml-auto mr-6 w-min"
+          isLoading={isLoading}
+          isDisabled={isLoading}
+        >
+          Connect to Octopus Deploy
+        </Button>
+      </Card>
+    </form>
+  );
+}
+
+OctopusDeployIntegrationPage.requireAuth = true;
--- a/frontend/src/pages/integrations/octopus-deploy/create.tsx
+++ b/frontend/src/pages/integrations/octopus-deploy/create.tsx
@ -0,0 +1,443 @@
+import { useEffect } from "react";
+import { Controller, useForm } from "react-hook-form";
+import { SiOctopusdeploy } from "react-icons/si";
+import { useRouter } from "next/router";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { z } from "zod";
+
+import { createNotification } from "@app/components/notifications";
+import {
+  Button,
+  Card,
+  CardTitle,
+  FilterableSelect,
+  FormControl,
+  Input,
+  Spinner
+} from "@app/components/v2";
+import { useWorkspace } from "@app/context";
+import { useCreateIntegration, useGetIntegrationAuthApps } from "@app/hooks/api";
+import {
+  useGetIntegrationAuthOctopusDeployScopeValues,
+  useGetIntegrationAuthOctopusDeploySpaces
+} from "@app/hooks/api/integrationAuth/queries";
+import { OctopusDeployScope } from "@app/hooks/api/integrationAuth/types";
+
+const formSchema = z.object({
+  scope: z.nativeEnum(OctopusDeployScope),
+  secretPath: z.string().default("/"),
+  sourceEnvironment: z.object({ name: z.string(), slug: z.string() }),
+  targetSpace: z.object({ Name: z.string(), Id: z.string() }),
+  targetResource: z.object({ appId: z.string().optional(), name: z.string() }),
+  targetEnvironments: z.object({ Name: z.string(), Id: z.string() }).array().optional(),
+  targetRoles: z.object({ Name: z.string(), Id: z.string() }).array().optional(),
+  targetMachines: z.object({ Name: z.string(), Id: z.string() }).array().optional(),
+  targetProcesses: z
+    .object({ Name: z.string(), Id: z.string(), ProcessType: z.string() })
+    .array()
+    .optional(),
+  targetActions: z.object({ Name: z.string(), Id: z.string() }).array().optional(),
+  targetChannels: z.object({ Name: z.string(), Id: z.string() }).array().optional()
+});
+
+type TFormData = z.infer<typeof formSchema>;
+
+export default function OctopusDeployCreateIntegrationPage() {
+  const router = useRouter();
+  const createIntegration = useCreateIntegration();
+
+  const { watch, control, reset, handleSubmit } = useForm<TFormData>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+      secretPath: "/",
+      scope: OctopusDeployScope.Project
+    }
+  });
+
+  const integrationAuthId = router.query.integrationAuthId as string;
+
+  const { currentWorkspace, isLoading: isProjectLoading } = useWorkspace();
+
+  const { data: octopusDeploySpaces, isLoading: isLoadingOctopusDeploySpaces } =
+    useGetIntegrationAuthOctopusDeploySpaces((integrationAuthId as string) ?? "");
+
+  const currentSpace = watch("targetSpace", octopusDeploySpaces?.[0]);
+  const currentScope = watch("scope");
+
+  const { data: octopusDeployResources, isLoading: isOctopusDeployResourcesLoading } =
+    useGetIntegrationAuthApps(
+      {
+        integrationAuthId,
+        workspaceSlug: currentSpace?.Name
+        // scope once we support other resources than project
+      },
+      {
+        enabled: Boolean(currentSpace ?? octopusDeploySpaces?.find((space) => space.IsDefault))
+      }
+    );
+
+  const currentResource = watch("targetResource", octopusDeployResources?.[0]);
+
+  const { data: octopusDeployScopeValues, isLoading: isOctopusDeployScopeValuesLoading } =
+    useGetIntegrationAuthOctopusDeployScopeValues(
+      {
+        integrationAuthId,
+        spaceId: currentSpace?.Id,
+        resourceId: currentResource?.appId!,
+        scope: currentScope
+      },
+      { enabled: Boolean(currentSpace && currentResource) }
+    );
+
+  const onSubmit = async ({
+    sourceEnvironment,
+    secretPath,
+    targetEnvironments,
+    targetResource,
+    targetSpace,
+    targetChannels,
+    targetActions,
+    targetMachines,
+    targetProcesses,
+    targetRoles,
+    scope
+  }: TFormData) => {
+    try {
+      await createIntegration.mutateAsync({
+        integrationAuthId,
+        isActive: true,
+        scope,
+        app: targetResource.name,
+        appId: targetResource.appId,
+        targetEnvironment: targetSpace.Name,
+        targetEnvironmentId: targetSpace.Id,
+        metadata: {
+          octopusDeployScopeValues: {
+            Environment: targetEnvironments?.map(({ Id }) => Id),
+            Action: targetActions?.map(({ Id }) => Id),
+            Channel: targetChannels?.map(({ Id }) => Id),
+            ProcessOwner: targetProcesses?.map(({ Id }) => Id),
+            Role: targetRoles?.map(({ Id }) => Id),
+            Machine: targetMachines?.map(({ Id }) => Id)
+          }
+        },
+        sourceEnvironment: sourceEnvironment.slug,
+        secretPath
+      });
+
+      createNotification({
+        type: "success",
+        text: "Successfully created integration"
+      });
+      router.push(`/integrations/${currentWorkspace?.id}`);
+    } catch (err) {
+      createNotification({
+        type: "error",
+        text: "Failed to create integration"
+      });
+      console.error(err);
+    }
+  };
+
+  useEffect(() => {
+    if (!octopusDeployResources || !octopusDeploySpaces || !currentWorkspace) return;
+
+    reset({
+      targetResource: octopusDeployResources[0],
+      targetSpace: octopusDeploySpaces.find((space) => space.IsDefault),
+      sourceEnvironment: currentWorkspace.environments[0],
+      secretPath: "/",
+      scope: OctopusDeployScope.Project
+    });
+  }, [octopusDeploySpaces, octopusDeployResources, currentWorkspace]);
+
+  if (isProjectLoading || isLoadingOctopusDeploySpaces || isOctopusDeployResourcesLoading)
+    return (
+      <div className="flex h-full w-full items-center justify-center p-24">
+        <Spinner />
+      </div>
+    );
+
+  return (
+    <form
+      onSubmit={handleSubmit(onSubmit)}
+      className="flex h-full w-full items-center justify-center"
+    >
+      <Card className="max-w-4xl rounded-md p-8 pt-4">
+        <CardTitle className=" text-center">
+          <SiOctopusdeploy size="1.2rem" className="mr-2 mb-1 inline-block" />
+          Octopus Deploy Integration
+        </CardTitle>
+        <div className="grid grid-cols-2 gap-4">
+          <Controller
+            control={control}
+            name="sourceEnvironment"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl
+                errorText={error?.message}
+                isError={Boolean(error)}
+                label="Project Environment"
+              >
+                <FilterableSelect
+                  getOptionValue={(option) => option.slug}
+                  value={value}
+                  getOptionLabel={(option) => option.name}
+                  onChange={onChange}
+                  options={currentWorkspace?.environments}
+                  placeholder="Select a project environment"
+                  isDisabled={!currentWorkspace?.environments.length}
+                />
+              </FormControl>
+            )}
+          />
+          <Controller
+            control={control}
+            name="secretPath"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl isError={Boolean(error)} label="Secrets Path">
+                <Input
+                  className="mt-[1px] h-[2.46rem]"
+                  value={value}
+                  onChange={onChange}
+                  placeholder={'Provide a path (defaults to "/")'}
+                />
+              </FormControl>
+            )}
+          />
+          <div className="col-span-2 flex w-full flex-row items-center pb-2">
+            <div className="w-full border-t border-mineshaft-500" />
+            <span className="mx-2 whitespace-nowrap text-xs text-mineshaft-400">Sync To</span>
+            <div className="w-full border-t border-mineshaft-500" />
+          </div>
+          <Controller
+            control={control}
+            name="targetSpace"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl
+                errorText={error?.message}
+                isError={Boolean(error)}
+                label="Octopus Deploy Space"
+              >
+                <FilterableSelect
+                  getOptionValue={(option) => option.Id}
+                  value={value}
+                  getOptionLabel={(option) => option.Name}
+                  onChange={onChange}
+                  options={octopusDeploySpaces}
+                  placeholder={
+                    octopusDeploySpaces?.length ? "Select a space..." : "No spaces found..."
+                  }
+                  isDisabled={!octopusDeploySpaces?.length}
+                />
+              </FormControl>
+            )}
+          />
+          <Controller
+            control={control}
+            name="targetResource"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl
+                errorText={error?.message}
+                isError={Boolean(error)}
+                className="capitalize"
+                label={`Octopus Deploy ${currentScope}`}
+              >
+                <FilterableSelect
+                  getOptionValue={(option) => option.appId!}
+                  value={value}
+                  getOptionLabel={(option) => option.name}
+                  onChange={onChange}
+                  options={octopusDeployResources}
+                  placeholder={
+                    octopusDeployResources?.length ? "Select a project..." : "No projects found..."
+                  }
+                  isDisabled={!octopusDeployResources?.length}
+                />
+              </FormControl>
+            )}
+          />
+
+          <Controller
+            control={control}
+            name="targetEnvironments"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl
+                errorText={error?.message}
+                isError={Boolean(error)}
+                label="Octopus Deploy Environments"
+                isOptional
+              >
+                <FilterableSelect
+                  isMulti
+                  getOptionValue={(option) => option.Name}
+                  value={value}
+                  getOptionLabel={(option) => option.Name}
+                  onChange={onChange}
+                  isLoading={isOctopusDeployScopeValuesLoading}
+                  options={octopusDeployScopeValues?.Environments}
+                  placeholder={
+                    octopusDeployScopeValues?.Environments?.length
+                      ? "Select environments..."
+                      : "No environments found..."
+                  }
+                  isDisabled={!octopusDeployScopeValues?.Environments?.length}
+                />
+              </FormControl>
+            )}
+          />
+          <Controller
+            control={control}
+            name="targetRoles"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl
+                errorText={error?.message}
+                isError={Boolean(error)}
+                label="Octopus Deploy Target Tags"
+                isOptional
+              >
+                <FilterableSelect
+                  isMulti
+                  getOptionValue={(option) => option.Name}
+                  value={value}
+                  getOptionLabel={(option) => option.Name}
+                  onChange={onChange}
+                  isLoading={isOctopusDeployScopeValuesLoading}
+                  options={octopusDeployScopeValues?.Roles}
+                  placeholder={
+                    octopusDeployScopeValues?.Roles?.length
+                      ? "Select target tags..."
+                      : "No target tags found..."
+                  }
+                  isDisabled={!octopusDeployScopeValues?.Roles?.length}
+                />
+              </FormControl>
+            )}
+          />
+          <Controller
+            control={control}
+            name="targetMachines"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl
+                errorText={error?.message}
+                isError={Boolean(error)}
+                label="Octopus Deploy Targets"
+                isOptional
+              >
+                <FilterableSelect
+                  isMulti
+                  getOptionValue={(option) => option.Name}
+                  value={value}
+                  getOptionLabel={(option) => option.Name}
+                  onChange={onChange}
+                  isLoading={isOctopusDeployScopeValuesLoading}
+                  options={octopusDeployScopeValues?.Machines}
+                  placeholder={
+                    octopusDeployScopeValues?.Machines?.length
+                      ? "Select targets..."
+                      : "No targets found..."
+                  }
+                  isDisabled={!octopusDeployScopeValues?.Machines?.length}
+                />
+              </FormControl>
+            )}
+          />
+          <Controller
+            control={control}
+            name="targetProcesses"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl
+                errorText={error?.message}
+                isError={Boolean(error)}
+                label="Octopus Deploy Processes"
+                isOptional
+              >
+                <FilterableSelect
+                  isMulti
+                  getOptionValue={(option) => option.Name}
+                  value={value}
+                  getOptionLabel={(option) => option.Name}
+                  onChange={onChange}
+                  isLoading={isOctopusDeployScopeValuesLoading}
+                  options={octopusDeployScopeValues?.Processes}
+                  placeholder={
+                    octopusDeployScopeValues?.Processes?.length
+                      ? "Select processes..."
+                      : "No processes found..."
+                  }
+                  isDisabled={!octopusDeployScopeValues?.Processes?.length}
+                />
+              </FormControl>
+            )}
+          />
+          <Controller
+            control={control}
+            name="targetActions"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl
+                errorText={error?.message}
+                isError={Boolean(error)}
+                label="Octopus Deploy Deployment Steps"
+                isOptional
+              >
+                <FilterableSelect
+                  isMulti
+                  getOptionValue={(option) => option.Name}
+                  value={value}
+                  getOptionLabel={(option) => option.Name}
+                  onChange={onChange}
+                  isLoading={isOctopusDeployScopeValuesLoading}
+                  options={octopusDeployScopeValues?.Actions}
+                  placeholder={
+                    octopusDeployScopeValues?.Actions?.length
+                      ? "Select deployment steps..."
+                      : "No deployment steps found..."
+                  }
+                  isDisabled={!octopusDeployScopeValues?.Actions?.length}
+                />
+              </FormControl>
+            )}
+          />
+          <Controller
+            control={control}
+            name="targetChannels"
+            render={({ field: { value, onChange }, fieldState: { error } }) => (
+              <FormControl
+                errorText={error?.message}
+                isError={Boolean(error)}
+                label="Octopus Deploy Channels"
+                isOptional
+              >
+                <FilterableSelect
+                  isMulti
+                  getOptionValue={(option) => option.Name}
+                  value={value}
+                  getOptionLabel={(option) => option.Name}
+                  onChange={onChange}
+                  isLoading={isOctopusDeployScopeValuesLoading}
+                  options={octopusDeployScopeValues?.Channels}
+                  placeholder={
+                    octopusDeployScopeValues?.Channels?.length
+                      ? "Select channels..."
+                      : "No channels found..."
+                  }
+                  isDisabled={!octopusDeployScopeValues?.Channels?.length}
+                />
+              </FormControl>
+            )}
+          />
+        </div>
+        <Button
+          type="submit"
+          colorSchema="primary"
+          className="mt-4"
+          isLoading={createIntegration.isLoading}
+          isDisabled={createIntegration.isLoading || !octopusDeployResources?.length}
+        >
+          Create Integration
+        </Button>
+      </Card>
+    </form>
+  );
+}
+
+OctopusDeployCreateIntegrationPage.requireAuth = true;
--- a/frontend/src/views/IntegrationsPage/IntegrationPage.utils.tsx
+++ b/frontend/src/views/IntegrationsPage/IntegrationPage.utils.tsx
@ -140,6 +140,9 @@ export const redirectForProviderAuth = (integrationOption: TCloudIntegration) =>
      case "azure-devops":
        link = `${window.location.origin}/integrations/azure-devops/authorize`;
        break;
+      case "octopus-deploy":
+        link = `${window.location.origin}/integrations/octopus-deploy/authorize`;
+        break;
      default:
        break;
    }
--- a/frontend/src/views/IntegrationsPage/components/IntegrationsSection/ConfiguredIntegrationItem.tsx
+++ b/frontend/src/views/IntegrationsPage/components/IntegrationsSection/ConfiguredIntegrationItem.tsx
@ -76,6 +76,14 @@ export const ConfiguredIntegrationItem = ({
            {integrationSlugNameMapping[integration.integration]}
          </div>
        </div>
+        {integration.integration === "octopus-deploy" && (
+          <div className="ml-2 flex flex-col">
+            <FormLabel label="Space" />
+            <div className="overflow-clip text-ellipsis whitespace-nowrap rounded-md border border-mineshaft-700 bg-mineshaft-900 px-3 py-2 font-inter text-sm text-bunker-200">
+              {integration.targetEnvironment || integration.targetEnvironmentId}
+            </div>
+          </div>
+        )}
        {integration.integration === "qovery" && (
          <div className="flex flex-row">
            <div className="ml-2 flex flex-col">
@ -108,6 +116,7 @@ export const ConfiguredIntegrationItem = ({
                (integration.integration === "qovery" && integration?.scope) ||
                (integration.integration === "circleci" && "Project") ||
                (integration.integration === "bitbucket" && "Repository") ||
+                (integration.integration === "octopus-deploy" && "Project") ||
                (integration.integration === "aws-secret-manager" && "Secret") ||
                (["aws-parameter-store", "rundeck"].includes(integration.integration) && "Path") ||
                (integration?.integration === "terraform-cloud" && "Project") ||