appium-mcp 0.0.1 → 1.1.5

package/src/resources/submodules/appium/packages/images-plugin/docs/find-by-image.md

@@ -0,0 +1,65 @@
+## Finding and Interacting with Image Elements
+
+Using the `-image` locator strategy supported by this plugin, it is possible to send an Appium an image file representing an element you want to tap. If Appium can find a screen region matching your template, it will wrap up information about this region as a standard `WebElement` and send it back to your Appium client.
+
+The strategy will be made available differently for each Appium client, for example: `driver.findElementByImage()`.
+
+### Image Selectors
+
+In conjunction with any locator strategy, you need to use a "selector" which details the specific nature of your find request. In the case of the `-image` strategy, the selector must be a string which is a base64-encoded image file representing the template you want to use for matching.
+
+### Image Elements
+
+If the image match is successful, Appium will cache information about the match and create a standard response for your client to consume, resulting in the instantiation of a standard element object in your test script. Using this element object, you are able to call a small number of methods on the "Image Element", as if it were a bona-fide `WebElement`:
+
+* `click`
+* `isDisplayed`
+* `getSize`
+* `getLocation`
+* `getLocationInView`
+* `getElementRect`
+* `getAttribute`
+    * `visual` returns matched image as base64 data if `getMatchedImageResult` is `true`
+    * `score` returns the similarity score as a float number in range `[0.0, 1.0]` sine Appium 1.18.0
+
+These actions are supported on "Image Elements" because they are the actions which involve only use of screen position for their functioning. Other actions (like `sendKeys`, for example) are not supported, because all Appium can know based on your template image is whether or not there is a screen region which visually matches it--Appium has no way of turning that information into a driver-specific UI element object, which would be necessary for the use of other actions.
+
+It's important to keep this important point in mind: there is nothing "magic" about Image Elements---they merely reference screen coordinates, and thus "tapping" an Image Element is internally nothing more than Appium constructing a tap at a point in the center of the Image Element's screen bounds (and in fact you can tell Appium which API to use to perform that tap---see below).
+
+### Related Settings
+
+Because finding elements by image relies on image analysis software in conjunction with Appium's screenshot functionality and the reference images you yourself provide, we provide a number of settings that help you modulate this feature, in some cases potentially speeding up the match or making it more accurate.
+
+To access these settings, you should use the Appium [Settings API](http://appium.io/docs/en/latest/guides/settings/), or pre-set any settings as capabilities using the [special `settings[]` capability](http://appium.io/docs/en/latest/guides/settings/#initializing-settings-via-capabilities). These are the settings that are available:
+
+|Setting Name|Description|Possible Values|Default Value|
+|------------|-----------|---------------|-------------|
+|imageMatchThreshold|The OpenCV match threshold below which to consider the find a failure. Basically the range of possibilities is between 0 (which means no threshold should be used) and 1 (which means that the reference image must be an exact pixel-for-pixel match). The exact values in between have no absolute meaning. For example a match that requires drastic resizing of a reference image will come out as a lower match strength than otherwise. It's recommended you try the default setting, and then incrementally lower the threshold if you're not finding matching elements. If you're matching the wrong element, try increasing the threshold value.|Numbers from 0 to 1|0.4|
+|fixImageFindScreenshotDims|Appium knows the screen dimensions, and ultimately these are the dimensions which are relevant for deciding where to tap on the screen. If the screenshot retrieved (via Appium's native methods, or an external source) does not match the screen dimensions, this setting dictates that Appium will adjust the size of the screenshot to match, ensuring that matched elements are found at the correct coordinates. Turn this setting off if you know it's not necessary, and Appium will forego the check, potentially speeding things up a bit.|`true` or `false`|`true`|
+|fixImageTemplateSize|OpenCV will not allow the matching of a reference image / template if that image is larger than the base image to match against. It can happen that the reference image you send in has dimensions which are larger than the screenshot Appium retrieves. In this case the match will automatically fail. If you set this setting to `true`, Appium will resize the template to ensure it is at least smaller than the size of the screenshot.|`true` or `false`|`false`|
+|fixImageTemplateScale| Appium resizes a base image to fit its window size before matching them with OpenCV. If you set this setting to `true`, Appium scales a reference image you send in as the same scale Appium scales the base image to fit the window size. e.g. iOS screenshot is `750 × 1334` pixels base image. The window size is `375 x 667`. Appium rescale the base image to window size scaling it with `0.5`. A reference image is based on the screenshot size, never the image matches with the window size scale. This settings allow Appium to scale the reference image with `0.5`. [appium-base-driver#306](https://github.com/appium/appium-base-driver/pull/306)| `true` or `false` | `false` |
+|defaultImageTemplateScale| Appium does not resize template images by default (the value of 1.0). Although, storing scaled template images might help to save size of the storage. E.g. One could represent 1080 × 126 pixels area by 270 × 32 pixels template image (the value of defaultImageTemplateScale is expected to be set to 4.0). Check [appium-base-driver#307](https://github.com/appium/appium-base-driver/pull/307) for more details. |e.g., `0.5`, `10.0`, `100`| `1.0` |
+|checkForImageElementStaleness|It can happen that, in between the time you have matched an image element and the time you choose to tap on it, the element is no longer present. The only way for Appium to determine this is to attempt to re-match the template immediately before tapping. If that re-match fails, you will get a `StaleElementException`, as you would expect. Turn this to `false` to skip the check, potentially speeding things up, but potentially running into stale element issues without the benefit of an exception to let you know you did.|`true` or `false`|`true`|
+|autoUpdateImageElementPosition|It can happen that a matched image changes position in between the time it is found and the time you tap on it. As with the previous setting, Appium can automatically adjust its position if it determines in a re-match that the position changed.|`true` or `false`|`false`|
+|imageElementTapStrategy|In order to tap on a found image element, Appium has to use one of its touch action strategies. The available strategies are the W3C Actions API, or the older MJSONWP TouchActions API. Stick to the default unless the driver you are using does not support the W3C Actions API for some reason.|`"w3cActions"` or `"touchActions"`|`"w3cActions"`|
+|getMatchedImageResult| Appium does not store the matched image result. Although, storing the result in memory might help for debugging whether which area is matched by find by image. Appium returns the image against `attribute` API as `visual`. | `true` or `false` | `false` |
+
+Note that each language-specific Appium client may make these settings available via special constants which could differ slightly from the exact setting names mentioned above.
+
+### Debug
+
+The `getMatchedImageResult` setting might help for debugging if Appium found the provided image expectedly. The returned element will have a `visual` attribute which will make comparison image available as base64 data if `getMatchedImageResult` is `true`.
+
+```ruby
+# Ruby core
+@driver.update_settings({ getMatchedImageResult: true })
+el = @driver.find_element_by_image 'path/to/img.ong'
+img_el.visual # returns base64 encoded string
+```
+
+```python
+# Python
+self.driver.update_settings({"getMatchedImageResult": True})
+el = self.driver.find_element_by_image('path/to/img.ong')
+el.get_attribute('visual') # returns base64 encoded string
+```

package/src/resources/submodules/appium/packages/images-plugin/docs/image-comparison.md

@@ -0,0 +1,203 @@
+# Image Comparison Features
+
+This article describes the set of image comparison features available within the plugin. These features are available in all drivers and require OpenCV 3 native libs. Also, each feature is able to visualize the comparison result, so you can always track what is going on under the hood to select optimal matching parameters to achieve the best comparison results.
+
+## Purpose
+
+Image comparison might be handy for many automation tasks. For example:
+* It is necessary to figure out whether the given picture example is present on the screen
+* It is necessary to calculate coordinates of some predefined on-screen object
+* It is necessary to verify whether the current on-screen object state is similar to the expected state
+
+## Feature-based Comparison
+
+Performs image matching by template to find possible occurrence of the partial image in the full image. Read [the OpenCV docs](https://docs.opencv.org/3.0-beta/doc/py_tutorials/py_feature2d/py_matcher/py_matcher.html) for more details on this topic. Such comparison is useful in the case where resulting image is rotated/scaled in relation to the original one.
+
+### Examples
+
+```java
+// java
+
+byte[] screenshot = Base64.encodeBase64(driver.getScreenshotAs(OutputType.BYTES));
+FeaturesMatchingResult result = driver
+        .matchImagesFeatures(screenshot, originalImg, new FeaturesMatchingOptions()
+                .withDetectorName(FeatureDetector.ORB)
+                .withGoodMatchesFactor(40)
+                .withMatchFunc(MatchingFunction.BRUTE_FORCE_HAMMING)
+                .withEnabledVisualization());
+assertThat(result.getVisualization().length, is(greaterThan(0)));
+assertThat(result.getCount(), is(greaterThan(0)));
+assertThat(result.getTotalCount(), is(greaterThan(0)));
+assertFalse(result.getPoints1().isEmpty());
+assertNotNull(result.getRect1());
+assertFalse(result.getPoints2().isEmpty());
+assertNotNull(result.getRect2());
+```
+
+All the `FeaturesMatchingOptions` builder methods above contain detailed descriptions in their docstrings.
+
+```ruby
+# Ruby
+image1 = File.read 'first/image/path.png'
+image2 = File.read 'second/image/path.png'
+
+match_result = @driver.match_images_features first_image: image1, second_image: image2
+assert_equal %w(points1 rect1 points2 rect2 totalCount count), match_result.keys
+
+match_result_visual = @driver.match_images_features first_image: image1, second_image: image2, visualize: true
+assert_equal %w(points1 rect1 points2 rect2 totalCount count visualization), match_result_visual.keys
+File.open('match_result_visual.png', 'wb') { |f| f<< Base64.decode64(match_result_visual['visualization']) }
+assert File.size? 'match_result_visual.png'
+```
+
+### Visualization Example
+
+![Feature-Based Comparison Example](https://user-images.githubusercontent.com/7767781/38800997-f7408fb8-4168-11e8-93b9-cfe3d51ecf1c.png)
+
+
+## Occurrences Lookup
+
+Performs images matching by template to find possible occurrence of the partial image in the full image. Read [the OpenCV template matching docs](https://docs.opencv.org/2.4/doc/tutorials/imgproc/histograms/template_matching/template_matching.html) for more details on this topic. Such comparison is useful in case the full image is a superset of the partial image.
+
+There is a subtle difference between occurrence comparison and feature comparison. The former is to be used when the image to be found is a subset of the target/screenshot. The latter is to be used when the image to be found is basically the same as the target but rotated and/or scaled.
+
+### Examples
+
+```java
+// java
+
+byte[] screenshot = Base64.encodeBase64(driver.getScreenshotAs(OutputType.BYTES));
+OccurrenceMatchingResult result = driver
+        .findImageOccurrence(screenshot, partialImage, new OccurrenceMatchingOptions()
+                .withEnabledVisualization());
+assertThat(result.getVisualization().length, is(greaterThan(0)));
+assertNotNull(result.getRect());
+```
+
+All the `OccurrenceMatchingOptions` builder methods above contain detailed descriptions in their docstrings.
+
+```ruby
+# Ruby
+image1 = File.read 'first/image/path.png'
+image2 = File.read 'partial/image/path.png'
+
+find_result = @driver.find_image_occurrence full_image: image1, partial_image: image2
+assert_equal({ 'rect' => { 'x' => 0, 'y' => 0, 'width' => 750, 'height' => 1334 } }, find_result)
+
+find_result_visual = @driver.find_image_occurrence full_image: image1, partial_image: image2, visualize: true
+assert_equal %w(rect visualization), find_result_visual.keys
+File.open('find_result_visual.png', 'wb') { |f| f<< Base64.decode64(find_result_visual['visualization']) }
+assert File.size? 'find_result_visual.png'
+```
+
+```javascript
+// Typescript / Javascript
+/*
+   Typescsript code for occurrence comparison using the template matching algorithm.
+   It detects if an image is contained in another image (called the template).
+   The image must have the same scale and look the same. However, you can add a scaling transformation beforehand.
+
+   official doc:
+   https://github.com/appium/appium/blob/master/packages/images-plugin/docs/image-comparison.md
+   OpenCV algorithm doc:
+   https://docs.opencv.org/2.4/doc/tutorials/imgproc/histograms/template_matching/template_matching.html
+   official sample code:
+   https://github.com/justadudewhohacks/opencv4nodejs/blob/master/examples/templateMatching.js
+
+   You must install opencv4nodejs using the -g option.
+
+   The Javascript client driver webdriverio does not support (in January 2020) the "-image" strategy implemented in the Appium server. You will have more power and understanding while using openCV directly. Since the appium server is in Javascript, you can do all it does with opencv in your test suite.
+
+   The testing framework mocha can be run with typescript to have async/await.
+   You need to run mocha with those options in the right order and with the associated packages installed:
+   NODE_PATH=/path/to/nodejs/lig/node_modules TS_NODE_PROJECT=config/tsconfig_test.json --require ts-node/register --require tsconfig-paths/register
+   You will also need to make a basic config/tsconfig_test.json
+   Note that paths in tsconfig.json does not support absolute paths. Hence, you cannot move the NODE_PATH there.
+*/
+import * as path from 'path';
+const cv = require(path.join(process.env.NODE_PATH, 'opencv4nodejs'));
+const isImagePresent = async () => {
+  /// Take screenshot and read the image
+  const screenImagePath = './appium_screenshot1.png';
+  await driver.saveScreenshot(screenImagePath)
+  const likedImagePath = './occurrence1.png';
+
+  // Load images
+  const originalMatPromise = cv.imreadAsync(screenImagePath);
+  const waldoMatPromise = cv.imreadAsync(likedImagePath);
+  const [originalMat, waldoMat] = await Promise.all([originalMatPromise, waldoMatPromise]);
+
+  // Match template (the brightest locations indicate the highest match)
+  // In the OpenCV doc, the option 5 refers to the algorithm called CV_TM_CCOEFF_NORMED
+  const matched = originalMat.matchTemplate(waldoMat, 5);
+
+  // Use minMaxLoc to locate the highest value (or lower, depending of the type of matching method)
+  const minMax = matched.minMaxLoc();
+  const { maxLoc: { x, y } } = minMax;
+
+  // Draw bounding rectangle
+  originalMat.drawRectangle(
+    new cv.Rect(x, y, waldoMat.cols, waldoMat.rows),
+    new cv.Vec(0, 255, 0),
+    2,
+    cv.LINE_8
+  );
+
+  // Open result in new window
+  // If the image is too big for your screen, you need to write to a file instead.
+  // Check the source of opencv4nodejs for writing an image to a file.
+  cv.imshow('We\'ve found Waldo!', originalMat);
+  await cv.waitKey();
+
+  // then you know if the image was found by comparing the rectangle with a reference rectangle.
+  // the structure minMax contains the property maxVal that gives the quality of the match
+  // 1 is prefect match, but you may get .999. If you extract an image from the screenshot manually,
+  // you will get an image that matches.
+};
+```
+
+### Visualization Example
+
+![Occurrences Lookup](https://user-images.githubusercontent.com/7767781/40233298-b7decfe4-5aa2-11e8-8c9b-f85f384d2092.png)
+
+The highlighted picture at the left bottom corner is the resulting match of ![Waldo](https://github.com/appium/appium-support/blob/master/test/images/waldo.jpg?raw=true) lookup.
+
+## Similarity Calculation
+
+Performs images matching to calculate the similarity score between them. The flow there is similar to the one used in `findImageOccurrence`, but it is mandatory that both images are of equal size. Such comparison is useful in case the original image is a copy of the original one, but with changed content.
+
+### Examples
+
+```java
+// java
+
+byte[] screenshot1 = Base64.encodeBase64(driver.getScreenshotAs(OutputType.BYTES));
+byte[] screenshot2 = Base64.encodeBase64(driver.getScreenshotAs(OutputType.BYTES));
+SimilarityMatchingResult result = driver
+        .getImagesSimilarity(screenshot1, screenshot2, new SimilarityMatchingOptions()
+                .withEnabledVisualization());
+assertThat(result.getVisualization().length, is(greaterThan(0)));
+assertThat(result.getScore(), is(greaterThan(0.0)));
+```
+
+All the `SimilarityMatchingOptions` builder methods above contain detailed descriptions in their docstrings.
+
+```ruby
+# Ruby
+image1 = File.read 'first/image/path.png'
+image2 = File.read 'second/image/path.png'
+
+get_images_result = @driver.get_images_similarity first_image: image1, second_image: image2
+assert_equal({ 'score' => 0.891606867313385 }, get_images_result)
+
+get_images_result_visual = @driver.get_images_similarity first_image: image1, second_image: image2, visualize: true
+assert_equal %w(score visualization), get_images_result_visual.keys
+File.open('get_images_result_visual.png', 'wb') { |f| f<< Base64.decode64(get_images_result_visual['visualization']) }
+assert File.size? 'get_images_result_visual.png'
+```
+
+### Visualization Example
+
+![Similarity Matching Example](https://user-images.githubusercontent.com/7767781/38780635-27198346-40da-11e8-803d-1ec4afd3c3aa.png)
+
+The similarity score for two pictures above is ~0.98.

package/src/resources/submodules/appium/packages/logger/CHANGELOG.md

@@ -0,0 +1,162 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## [2.0.2](https://github.com/appium/appium/compare/@appium/logger@2.0.1...@appium/logger@2.0.2) (2025-10-08)
+
+**Note:** Version bump only for package @appium/logger
+
+
+
+
+
+## [2.0.1](https://github.com/appium/appium/compare/@appium/logger@2.0.0...@appium/logger@2.0.1) (2025-09-09)
+
+**Note:** Version bump only for package @appium/logger
+
+
+
+
+
+## [2.0.0](https://github.com/appium/appium/compare/@appium/logger@2.0.0-rc.1...@appium/logger@2.0.0) (2025-08-18)
+
+**Note:** Version bump only for package @appium/logger
+
+
+
+
+
+## [2.0.0-rc.1](https://github.com/appium/appium/compare/@appium/logger@1.6.1...@appium/logger@2.0.0-rc.1) (2025-08-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* set minimum Node.js version to v20.19.0 (#21394)
+
+### Bug Fixes
+
+* **appium:** Return hostname as web socket url for BiDi if a broadcast address is assigned to the server ([#20603](https://github.com/appium/appium/issues/20603)) ([f0de55d](https://github.com/appium/appium/commit/f0de55da0da2fc0305876a948704c1f0a2a5990f))
+
+
+### Miscellaneous Chores
+
+* set minimum Node.js version to v20.19.0 ([#21394](https://github.com/appium/appium/issues/21394)) ([37e22c4](https://github.com/appium/appium/commit/37e22c4f9c9920cea3f340841ab1b7c60e3147e9))
+
+
+
+## [1.7.1](https://github.com/appium/appium/compare/@appium/logger@1.7.0...@appium/logger@1.7.1) (2025-06-01)
+
+**Note:** Version bump only for package @appium/logger
+
+
+
+
+
+## [1.7.0](https://github.com/appium/appium/compare/@appium/logger@1.6.1...@appium/logger@1.7.0) (2025-04-25)
+
+
+### Features
+
+* Add a possibility to mask sensitive log values depending on request headers ([#21123](https://github.com/appium/appium/issues/21123)) ([c24d2ac](https://github.com/appium/appium/commit/c24d2ac46123f41ee9b54e0adefacfabd149089c))
+
+
+### Bug Fixes
+
+* **appium:** Return hostname as web socket url for BiDi if a broadcast address is assigned to the server ([#20603](https://github.com/appium/appium/issues/20603)) ([f0de55d](https://github.com/appium/appium/commit/f0de55da0da2fc0305876a948704c1f0a2a5990f))
+* **logger:** Error stack logging ([#21176](https://github.com/appium/appium/issues/21176)) ([1de5d0a](https://github.com/appium/appium/commit/1de5d0a0e8994b170a44eebe2d0575d5c74c3ff2))
+
+
+
+## [1.6.1](https://github.com/appium/appium/compare/@appium/logger@1.6.0...@appium/logger@1.6.1) (2024-08-07)
+
+
+### Bug Fixes
+
+* **logger:** update dependency lru-cache to v10.4.3 ([#20364](https://github.com/appium/appium/issues/20364)) ([8d79467](https://github.com/appium/appium/commit/8d79467da8a0733ac3e49b9152bd6905989a57ca))
+* **support:** Print an empty string if no arguments are provided to a logging function ([#20424](https://github.com/appium/appium/issues/20424)) ([885570e](https://github.com/appium/appium/commit/885570e7caec486765c1baa67131f0b3adf1daf7))
+
+
+
+## [1.6.0](https://github.com/appium/appium/compare/@appium/logger@1.5.0...@appium/logger@1.6.0) (2024-07-10)
+
+
+### Features
+
+* **logger:** Use LRUCache to manage log history ([#20325](https://github.com/appium/appium/issues/20325)) ([e7665d1](https://github.com/appium/appium/commit/e7665d1cd93e1edb6c981aae09ff9df37fe43d0a))
+
+
+
+## [1.5.0](https://github.com/appium/appium/compare/@appium/logger@1.4.2...@appium/logger@1.5.0) (2024-06-27)
+
+
+### Features
+
+* **appium:** Improve context logging ([#20250](https://github.com/appium/appium/issues/20250)) ([f675abc](https://github.com/appium/appium/commit/f675abc27b3e6beac2431cc71afb5fc2c2f70534))
+
+
+### Bug Fixes
+
+* **logger:** Print an empty message if no arguments are provided ([#20284](https://github.com/appium/appium/issues/20284)) ([87fc50c](https://github.com/appium/appium/commit/87fc50c2aff523492a353f20fa9dc7e759be06b3))
+
+
+
+## [1.4.2](https://github.com/appium/appium/compare/@appium/logger@1.4.1...@appium/logger@1.4.2) (2024-06-11)
+
+
+### Bug Fixes
+
+* **logger:** use `index.d.ts` for types instead of `index.ts` ([#20247](https://github.com/appium/appium/issues/20247)) ([9469aae](https://github.com/appium/appium/commit/9469aaef0e31d27b4814bc14763b0abeb6e11bf7))
+
+
+
+## [1.4.1](https://github.com/appium/appium/compare/@appium/logger@1.4.0...@appium/logger@1.4.1) (2024-06-11)
+
+
+### Bug Fixes
+
+* **logger:** Type declaration for DEFAULT_LOG_LEVELS ([#20244](https://github.com/appium/appium/issues/20244)) ([c670010](https://github.com/appium/appium/commit/c670010ec7ea1c2730839e86b308837a83fc026e))
+
+
+
+## [1.4.0](https://github.com/appium/appium/compare/@appium/logger@1.3.0...@appium/logger@1.4.0) (2024-06-10)
+
+
+### Features
+
+* **appium:** Add session signature to all logs ([#20202](https://github.com/appium/appium/issues/20202)) ([#20214](https://github.com/appium/appium/issues/20214)) ([0363aab](https://github.com/appium/appium/commit/0363aab8ba4fe0ec49845db2f493001aa873578b)), closes [#20222](https://github.com/appium/appium/issues/20222)
+* **logger:** Add the debug level to the default logger ([#20219](https://github.com/appium/appium/issues/20219)) ([8ee7d07](https://github.com/appium/appium/commit/8ee7d07af4e2375d2eb7c23badaaac34685bc59c))
+* **support:** Move SecureValuesPreprocessor to @appum/logger ([#20228](https://github.com/appium/appium/issues/20228)) ([dbc3b66](https://github.com/appium/appium/commit/dbc3b668a0a7a815d23f1cae4207d435fc09034d))
+
+
+
+## [1.3.0](https://github.com/appium/appium/compare/@appium/logger@1.2.0...@appium/logger@1.3.0) (2024-06-06)
+
+
+### Features
+
+* **appium:** Add session signature to all logs ([#20202](https://github.com/appium/appium/issues/20202)) ([b3f8a47](https://github.com/appium/appium/commit/b3f8a47c2d3fa029bdb5592d7130c6d1664e53b5))
+
+
+### Bug Fixes
+
+* **appium:** Revert changes in 20203 and 20202 ([#20209](https://github.com/appium/appium/issues/20209)) ([40def9d](https://github.com/appium/appium/commit/40def9dbdbde64706111900967d66735257b7404)), closes [#20202](https://github.com/appium/appium/issues/20202) [#20203](https://github.com/appium/appium/issues/20203)
+
+
+
+## [1.2.0](https://github.com/appium/appium/compare/@appium/logger@1.1.0...@appium/logger@1.2.0) (2024-06-06)
+
+
+### Features
+
+* **logger:** Add the 'debug' level to the default logger ([#20203](https://github.com/appium/appium/issues/20203)) ([7fd9d5f](https://github.com/appium/appium/commit/7fd9d5f6261b385c234580c2bfee4d576905458b))
+
+
+
+## 1.1.0 (2024-06-06)
+
+
+### Features
+
+* **appium:** Replace npmlog with the local fork ([#20190](https://github.com/appium/appium/issues/20190)) ([8915934](https://github.com/appium/appium/commit/8915934270243bfb46c4d104a098ce1cc481b0ff))
+* **logger:** add packages/logger package from npmlog ([#20161](https://github.com/appium/appium/issues/20161)) ([70449cd](https://github.com/appium/appium/commit/70449cd077d7efc3dbc8aa498ee2072cc2dc0f22))

package/src/resources/submodules/appium/packages/logger/README.md

@@ -0,0 +1,31 @@
+# @appium/logger
+
+> Appium's logging functionality
+
+## Installation
+
+```console
+npm install @appium/logger --save
+```
+
+## Basic Usage
+
+```js
+import log from '@appium/logger';
+
+// additional stuff ---------------------------+
+// message ----------+                         |
+// prefix ----+      |                         |
+// level -+   |      |                         |
+//        v   v      v                         v
+    log.info('fyi', 'I have a kitty cat: %j', myKittyCat);
+```
+
+## History
+
+This module is forked from [npmlog](https://github.com/npm/npmlog) under ISC License because the original project has been archived.
+Please check [the npmlog changelog](https://github.com/npm/npmlog/blob/main/CHANGELOG.md) to see the list of former module updates before it was forked.
+
+## License
+
+ISC License