@arkeytyp/valu-api 1.0.0

package/.github/labeler.yml

@@ -0,0 +1,5 @@
+bug:
+    title: "^fix:.*"
+
+enhancement:
+    title: "^feat:.*"

package/.github/pull_request_template.md

@@ -0,0 +1,16 @@
+## Purpose of this PR
+<!-- Why do you submit this PR? -->
+
+## Testing status
+<!-- Remove the options that do not apply -->
+* No tests have been added.
+* Includes unit tests.
+* Includes performance tests.
+* Includes integration tests.
+
+### Manual testing status
+<!-- Describe how you tested your implementation/fix. Try to mention all the cases and flows.  -->
+<!-- It will help the reviewer to understand if you missed any cases or test steps as well as will tell more about your feature or fix.   -->
+
+## Comments to reviewers
+<!-- Notes for the reviewers you have assigned.  Remove if not applicable-->

package/.github/release-drafter-config.yml

@@ -0,0 +1,12 @@
+name-template: '$NEXT_PATCH_VERSION'
+tag-template: '$NEXT_PATCH_VERSION'
+categories:
+  - title: 'New'
+    labels:
+      - 'enhancement'
+  - title: 'Fixes'
+    labels:
+      - 'bug'
+template: |
+  ## Changes
+  $CHANGES

package/.github/workflows/auto-pr-labels.yml

@@ -0,0 +1,14 @@
+name: Label PRs
+
+on:
+  - pull_request
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: srvaroa/labeler@master
+        env:
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"

package/.github/workflows/draft-release.yml

@@ -0,0 +1,18 @@
+name: Release Drafter
+
+on:
+  push:
+    # branches to consider in the event; optional, defaults to all
+    branches:
+      - master
+
+jobs:
+  update_release_draft:
+    runs-on: ubuntu-latest
+    steps:
+      # Drafts your next Release notes as Pull Requests are merged into "master"
+      - uses: release-drafter/release-drafter@v5
+        with:
+          config-name: release-drafter-config.yml
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/npm.yml

@@ -0,0 +1,28 @@
+name: Publish to npm
+
+# Controls when the action will run.  
+# In this case I'm saying on each release event when it's specifically a new release publish, the types: [published] is required here, 
+# since releases could also be updated or deleted, we only want to publish to npm when a new release is created (published).
+on:
+  release:
+    types: [published, edited]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+    - uses: actions/checkout@v2
+    #Install Node.js, with the version 12 and using the registry URL of npm, this could be changed to a custom registry or the GitHub registry.
+    - uses: actions/setup-node@v1
+      with:
+        node-version: 12
+        registry-url: https://registry.npmjs.org/
+
+    # Command to install the package dependencies
+    # - run: yarn install
+      
+    # Publish to npm
+    - run: npm publish --access public
+      env:
+        NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/.github/workflows/pr-assign-creator.yml

@@ -0,0 +1,13 @@
+name: Assign PR to creator
+
+on: [pull_request]
+
+jobs:
+  automation:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Assign PR to creator
+      uses: thomaseizinger/assign-pr-creator-action@v1.0.0
+      if: github.event_name == 'pull_request' && github.event.action == 'opened'
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/pr-title-convention-validation.yml

@@ -0,0 +1,15 @@
+name: "PR Title Convention Validation"
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v1.1.1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/release-mods-workflow.yml

@@ -0,0 +1,117 @@
+name: Draft Release Modifications
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+    types: [closed]
+
+env:
+  GITHUB_USER_EMAIL: noreply@stansassets.com
+  GITHUB_USER_NAME: Stan's Assets Automation
+  GITHUB_API_TOKEN: ${{ secrets.GH_API_TOKEN }}
+  GITHUB_API_CALLER: StansAssets
+  LATEST_RELEASE_TAG: 0.0.0
+  LATEST_RELEASE_DRAFT_STATUS: false
+
+  GET_LATEST_RELEASE_INFO: |
+    URL="https://api.github.com/repos/${{ github.repository }}/releases"
+    LATEST_RELEASE_TAG=$(curl -u $GITHUB_API_CALLER:$GITHUB_API_TOKEN -s GET $URL | jq '.[0]' | jq -r '.tag_name')
+    LATEST_RELEASE_DRAFT_STATUS=$(curl -u $GITHUB_API_CALLER:$GITHUB_API_TOKEN -s GET $URL | jq '.[0]' | jq -r '.draft')
+
+  CHANGE_RELEASE_TAG_BY_ONE: |
+    IFS='.' read -ra TAG_ARRAY <<< "$LATEST_RELEASE_TAG"
+    for ((idx=0; idx<${#TAG_ARRAY[@]}; ++idx)); do
+      if [[ $(($idx+1)) == ${#TAG_ARRAY[@]} ]]
+      then
+        RELEASE_VERSION+="$((${TAG_ARRAY[idx]}+1))"
+      else
+        RELEASE_VERSION+=${TAG_ARRAY[idx]}.
+      fi
+    done
+    LATEST_RELEASE_TAG=$RELEASE_VERSION
+
+  CREATE_NEW_DRAFT_RELEASE: |
+    URL="https://api.github.com/repos/${{ github.repository }}/releases"
+    API_JSON=$(echo "{\"tag_name\": \"$LATEST_RELEASE_TAG\",
+      \"target_commitish\": \"master\",
+      \"name\": \"$LATEST_RELEASE_TAG\",
+      \"body\": \"\",
+      \"draft\": true,
+      \"prerelease\": false}")
+    curl -u $GITHUB_API_CALLER:$GITHUB_API_TOKEN -s -d "$API_JSON" -X POST $URL
+  
+  MODIFY_PACKAGE_JSON: |
+    git config --global user.email "${GITHUB_USER_EMAIL}"
+    git config --global user.name "${GITHUB_USER_NAME}"
+    jq ".version=\"$LATEST_RELEASE_TAG\"" package.json > "tmp" && mv "tmp" package.json
+    git add -A
+    git status
+    git commit -m "Version Changed"
+    git push origin HEAD:master
+
+  ADD_PULL_REQUEST_TITLE_CONTENTS: |
+    URL="https://api.github.com/repos/${{ github.repository }}/releases"
+    LATEST_RELEASE_BODY=$(curl -u $GITHUB_API_CALLER:$GITHUB_API_TOKEN -s GET $URL | jq '.[0]' | jq -r '.body' | sed -E ':a;N;$!ba;s/\r{0,1}\n/\\n/g')
+    LATEST_RELEASE_ID=$(curl -u $GITHUB_API_CALLER:$GITHUB_API_TOKEN -s GET $URL | jq '.[0]' | jq -r '.id')
+    ADDED_DELIMITER="### Added"
+    FIXED_DELIMITER="### Fixed"
+    if [[ "${{ github.event.pull_request.title }}" == *"feat:"* ]]; then
+      if [[ $LATEST_RELEASE_BODY == *$ADDED_DELIMITER* ]]; then
+        if [[ $LATEST_RELEASE_BODY == *$FIXED_DELIMITER* ]]; then
+          FIRST_PART="${LATEST_RELEASE_BODY%"$FIXED_DELIMITER"*}"
+          LAST_PART="${LATEST_RELEASE_BODY#*"$FIXED_DELIMITER"}"
+          BODY_CONTENTS="${FIRST_PART}* ${{ github.event.pull_request.title }}\n${FIXED_DELIMITER}${LAST_PART}"
+        else
+          BODY_CONTENTS="${LATEST_RELEASE_BODY}\n* ${{ github.event.pull_request.title }}"
+        fi
+      else
+        BODY_CONTENTS="${ADDED_DELIMITER}\n* ${{ github.event.pull_request.title }}\n${LATEST_RELEASE_BODY}"
+      fi
+    elif [[ "${{ github.event.pull_request.title }}" == *"fix:"* ]]; then
+      if [[ $LATEST_RELEASE_BODY == *$FIXED_DELIMITER* ]]; then
+        BODY_CONTENTS="${LATEST_RELEASE_BODY}\n* ${{ github.event.pull_request.title }}"
+      else
+        BODY_CONTENTS="${LATEST_RELEASE_BODY}\n${FIXED_DELIMITER}\n* ${{ github.event.pull_request.title }}"
+      fi
+    fi
+    URL="https://api.github.com/repos/${{ github.repository }}/releases/${LATEST_RELEASE_ID}"
+    API_JSON=$(echo "{\"tag_name\": \"$LATEST_RELEASE_TAG\",
+      \"target_commitish\": \"master\",
+      \"name\": \"$LATEST_RELEASE_TAG\",
+      \"body\": \"$BODY_CONTENTS\",
+      \"draft\": true,
+      \"prerelease\": false}")
+    curl -u $GITHUB_API_CALLER:$GITHUB_API_TOKEN -s -d "$API_JSON" -X POST $URL
+
+jobs:
+  PushModifications:
+    name: Modifications on Push
+    if: ( github.event_name == 'push' )
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Get latest release info. Create and modify if needed
+      run: |
+        eval "$GET_LATEST_RELEASE_INFO"
+        if [[ $LATEST_RELEASE_DRAFT_STATUS == false ]]; then
+          eval "$CHANGE_RELEASE_TAG_BY_ONE"
+          eval "$CREATE_NEW_DRAFT_RELEASE"
+          eval "$MODIFY_PACKAGE_JSON"
+        fi
+  PullRequestModifications:
+    name: Modifications on Pull Request
+    if: ( github.event_name == 'pull_request' )
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Add Pull Request title contents to release
+      run: |
+        eval "$GET_LATEST_RELEASE_INFO"
+        if [[ $LATEST_RELEASE_DRAFT_STATUS == false ]]; then
+          eval "$CHANGE_RELEASE_TAG_BY_ONE"
+          eval "$CREATE_NEW_DRAFT_RELEASE"
+          eval "$MODIFY_PACKAGE_JSON"
+        fi
+        eval "$ADD_PULL_REQUEST_TITLE_CONTENTS"

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Arkeytyp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+The `valu-api` package enables developers to create custom iframe applications for Valu Social. It provides tools to invoke functions of registered Valu applications and subscribe to their events. With features like API versioning, event handling, and console command testing, developers can seamlessly integrate and extend functionality within the Valu Social ecosystem.
+
+# Usage
+
+## 1. Initialize ValuApi
+On your application startup, create an instance of ValuApi and subscribe to the API_READY event. This event will be triggered only when your application is launched as an iframe within the Valu Verse application.
+
+```javascript
+import { ValuApi } from 'valu-api';
+
+const valuApi = new ValuApi();
+valuApi.current.addEventListener(ValuApi.API_READY, async (e) => {
+  console.log("API IS READY!!!");
+});
+```
+
+## 2. Get an API Pointer
+Once the API is ready, you can create an APIPointer instance by specifying the name and version of the API you want to use. The version parameter is optional, and if omitted, the latest version will be used.
+
+To get a pointer to the app API version 1:
+
+```javascript
+const appApi = valuApi.getApi('app', 1);
+```
+
+To use the latest version of the API:
+
+```javascript
+const appApi = valuApi.current.getApi('app');
+```
+
+## 3. Invoke API Commands
+After obtaining the API pointer, you can invoke commands on the API. Here's an example of opening the text_chat on the app API:
+
+```javascript
+await appApi.run('open', 'text_chat');
+```
+
+For interacting with other APIs, like the chat API:
+
+```javascript
+const chatApi = valuApi.current.getApi('chat');
+await chatApi.run('open-channel', { roomId: 'room123', propId: 'prop456' });
+```
+
+## 4. Subscribe to Events
+You can subscribe to events emitted by the API. For example, if you want to listen for the app-open event:
+
+```javascript
+appApi.addEventListener('app-open', (event) => {
+  console.log(event);
+});
+```
+
+## 5. Run Console Commands (For Testing)
+You can use the runConsoleCommand method to execute commands directly in the console environment. This method processes the output and returns a resolved promise on success or an error message if the command fails.
+
+To run a console command, use:
+
+```javascript
+let command = 'app open text_chat';
+let reply = await valuApi.current.runConsoleCommand(command);
+console.log(reply);
+
+command = 'chat open-channel roomId xz21wd31tx83kk propId 812t26xbq5424b';
+reply = await valuApi.current.runConsoleCommand(command);
+console.log(reply);
+```
+
+## Example Workflow
+Here's an example of a simple workflow using valu-api:
+
+```javascript
+import { ValuApi } from 'valu-api';
+
+const valuApi = new ValuApi();
+
+// Wait for the API to be ready
+valuApi.current.addEventListener(ValuApi.API_READY, async () => {
+  console.log("API IS READY!!!");
+
+  // Get API pointer
+  const appApi = valuApi.current.getApi('app');
+
+  // Run a command on the app API
+  await appApi.run('open', 'text_chat');
+
+  // Subscribe to events
+  appApi.addEventListener('app-open', (event) => {
+    console.log('App opened:', event);
+  });
+
+  // Run console command for testing
+  let command = 'app open text_chat';
+  let reply = await valuApi.current.runConsoleCommand(command);
+  console.log(reply);
+});
+```
+

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@arkeytyp/valu-api",
+  "version": "1.0.0",
+  "description": "A package for developing iframe applications for Valu Social. Allows invoking functions of registered Valu applications and subscribing to events, as well as other features that enable developers creating own ifram apps for the value social",
+  "main": "ValuApi.js",
+  "scripts": {
+    "test": "echo \"No test specified\" && exit 1"
+  },
+  "keywords": ["valu", "api", "iframe", "valu social", "multiverse"],
+  "author": "Stanislav Osipov",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arkeytyp/valu-api.git"
+  }
+}

package/src/APIPointer.js

@@ -0,0 +1,110 @@
+import {EventEmitter} from "./EventEmitter.js";
+import {guid4, nextId} from "./Utils.js";
+
+/**
+ * An access point to a specified API based on the provided API name and version.
+ * It simplifies interaction with APIs by dynamically resolving the appropriate versioned endpoints or features.
+ */
+export class APIPointer {
+
+  #apiName;
+  #version;
+  #guid;
+  #eventEmitter;
+  #runRequest
+
+  #apiCalls = new Map();
+
+
+  /**
+   * @private
+   * @description Unique identifier (GUID) for the API Pointer object.
+   * Used for communication between your and valu app.
+   * @type {string}
+   */
+  get guid ()  {
+    return this.#guid;
+  }
+
+  /**
+   * @private
+   * @description Stores the API name.
+   * @type {string}
+   */
+  get apiName ()  {
+    return this.#apiName;
+  }
+
+  /**
+   * @private
+   * @description Stores the version of the API.
+   * @type {string}
+   */
+  get version ()  {
+    return this.#version;
+  }
+
+  constructor(apiName, version, runRequest) {
+    this.#apiName = apiName
+    this.#version = version;
+    this.#eventEmitter = new EventEmitter();
+    this.#guid = guid4();
+    this.#runRequest = runRequest;
+  }
+
+  /**
+   * Use to subscribe to the API events.
+   */
+  addEventListener = (...parameters) => this.#eventEmitter.addEventListener(...parameters);
+
+  /**
+   * Removes API event subscription.
+   */
+  removeEventListener = (...parameters) => this.#eventEmitter.removeEventListener(...parameters);
+
+  /**
+   * Executes and api request.
+   *
+   * @param {string} functionName - The name of the function to execute.
+   * @param {Object} params - The parameters required for the function execution.
+   * @private
+   */
+  run(functionName, params) {
+    let deferredPromise = this.#createDeferred();
+    this.#apiCalls[deferredPromise.id] = deferredPromise;
+    this.#runRequest(functionName, params, deferredPromise.id, this);
+
+    return deferredPromise.promise;
+  }
+
+
+  postRunResult(requestId, result) {
+    let deferred = this.#apiCalls[requestId];
+    if(!deferred) {
+      console.error(`Failed to postRunResult for ${requestId}`);
+      return;
+    }
+
+    if(result?.error) {
+      deferred.reject(result.error);
+    } else {
+      deferred.resolve(result);
+    }
+
+    delete this.#apiCalls[requestId];
+  }
+
+  /**
+   * Creates a deferred object with a promise and its resolve/reject functions.
+   * @returns {object} A deferred object.
+   */
+  #createDeferred() {
+    let resolve, reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+
+    return { id: nextId(), promise, resolve, reject };
+  }
+}

package/src/EventEmitter.js

@@ -0,0 +1,86 @@
+/** @module EventEmitter */
+
+/**
+ * @class EventEmitter
+ *
+ * @property {function(eventName: string, listener: Function, once?: boolean=false): EventEmitter} addEventListener
+ * @property {function(eventName: string, listener: Function): EventEmitter} removeEventListener
+ * @property {function(eventName: string): EventEmitter} emit
+ */
+export class EventEmitter {
+  #events = [];
+
+  get events() {
+    return this.#events;
+  }
+
+  get addEventListener() {
+    return (eventName, callback, once = false) => {
+      const listeners = this.#events[eventName] || [];
+
+      listeners.push({
+        callback,
+        once
+      });
+      this.#events[eventName] = listeners;
+
+      return this;
+    };
+  }
+
+  get removeEventListener() {
+    return (eventName = false, callback = false) => {
+      if (!eventName) {
+        this.#events = {};
+      } else if (!callback) {
+        this.#events[eventName] = [];
+      } else {
+        const listeners = this.#events[eventName] || [];
+
+        for (let i = listeners.length - 1; i >= 0; i--) {
+          if (listeners[i].callback === callback) listeners.splice(i, 1);
+        }
+      }
+
+      return this;
+    };
+  }
+
+  get emit() {
+    return (eventName, ...parameters) => {
+      const listeners = this.#events[eventName] || [];
+      const onceListeners = [];
+      const specialEvent = ['__before__', '__after__'].indexOf(eventName) !== -1;
+
+      let returnValue, lastValue;
+
+      specialEvent || this.emit.apply(this, ['__before__', eventName].concat(parameters));
+
+      for (let i = 0, length = listeners.length; i < length; i++) {
+        const listener = listeners[i];
+
+        if (listener === undefined) {
+          console.error('Error: incorrect event behaviour!');
+          return;
+        }
+
+        if (listener.callback) {
+          lastValue = listener.callback.apply(this, parameters);
+        } else {
+          listener.once = true;
+        }
+
+        if (listener.once) onceListeners.push(i);
+        if (lastValue !== undefined) returnValue = lastValue;
+      }
+
+      for (let i = onceListeners.length - 1; i >= 0; i--) {
+        listeners.splice(onceListeners[i], 1);
+      }
+
+      specialEvent || this.emit.apply(this, ['__after__', eventName].concat(parameters));
+
+      return returnValue;
+    };
+  }
+}

package/src/Utils.js

@@ -0,0 +1,13 @@
+export const guid4 = () => crypto && crypto.randomUUID
+  ? ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c =>
+    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16))
+  : "10000000-1000-4000-8000-100000000000".replace(/[018]/g, c =>
+    (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
+  );
+
+
+let lastId = 0;
+export const nextId =() => {
+  lastId++;
+  return lastId;
+}

package/src/ValuApi.js

@@ -0,0 +1,163 @@
+import {EventEmitter} from "./EventEmitter.js";
+import {APIPointer} from "./APIPointer.js";
+import {guid4, nextId} from "@/valu-api/Utils.js";
+
+
+/**
+ * Allows to invoke functions of a registered Valu application and subscribe to its events.
+ *
+ * More info:
+ * https://github.com/Roomful/valu-api
+ */
+export class ValuApi {
+
+  static API_READY = 'api:ready'
+
+  #eventEmitter;
+  #valuApplication = {};
+  #apiRequests = {};
+  #consoleCommands = new Map();
+
+
+  constructor() {
+    globalThis.addEventListener('message', (event) => {
+      this.#handleParentMessage(event);
+    });
+    this.#eventEmitter = new EventEmitter();
+  }
+
+  addEventListener = (...parameters) => this.#eventEmitter.addEventListener(...parameters);
+  removeEventListener = (...parameters) => this.#eventEmitter.removeEventListener(...parameters);
+
+  /**
+   * Retrieves an APIPointer object for a specific API module.
+   * @param {string} apiName The name of the API module to retrieve.
+   * @param {string} [version] The optional version of the API module. If not provided, the APIPointer will be bound to the latest available version.
+   * @returns {APIPointer} An APIPointer object bound to the specified API version (or the latest version if no version is specified).
+   *
+   * The APIPointer object provides the ability to:
+   * - Run functions within the specified API module.
+   * - Subscribe to events associated with the module.
+   *
+   * This method enables interaction with a specific version of an API module, allowing users to access its functionality and listen to events.
+   */
+  getApi(apiName, version) {
+    const apiPointer = new APIPointer(apiName, version, (functionName, params, requestId, apiPointer) => {
+      this.#onApiRunRequest(functionName, params, requestId, apiPointer);
+    });
+    this.#registerApiPointer(apiPointer);
+    return apiPointer;
+  }
+
+  #registerApiPointer(apiPointer) {
+    this.#postToValuApp('api:create-pointer', {
+      guid: apiPointer.guid,
+      api: apiPointer.apiName,
+      version: apiPointer.version,
+    });
+  }
+
+  #postToValuApp(name, message) {
+     const data = { name: name, message: message};
+
+     console.log('Posting to Valu: ', name, ' ', message, ' source: ', this.#valuApplication.source);
+     this.#valuApplication.source.postMessage(data, this.#valuApplication.origin);
+  }
+
+  async #onApiRunRequest(functionName, params, requestId, apiPointer) {
+    console.log('onApiRunRequest', this);
+
+    this.#apiRequests[requestId] = apiPointer;
+
+    this.#postToValuApp('api:run', {
+      apiPointerId: apiPointer.guid,
+      requestId: requestId,
+      functionName: functionName,
+      params: params,
+    });
+  }
+
+  /**
+   * Executes a given console command and returns the result of an API function.
+   *
+   * This method accepts a string command, executes it in the console environment,
+   * and processes the output. If the execution is successful, it returns the result
+   * of the associated API function as a resolved promise. If the promise fails
+   * or an exception occurs during execution, it will return an error message string.
+   *
+   * @param {string} command - The console command to execute.
+   *                          Example: `/chat -h`.
+   * @returns {Promise<any|string>} A promise resolving to the API function result. If the promise
+   *                                fails or throws an exception, it resolves to an error message string.
+   */
+  async runConsoleCommand(command) {
+    let deferredPromise = this.#createDeferred();
+    this.#consoleCommands[deferredPromise.id] = deferredPromise;
+
+    this.#postToValuApp('api:run-console', {
+      requestId: deferredPromise.id,
+      command: command,
+    });
+
+    return deferredPromise.promise;
+  }
+
+  #createDeferred() {
+    let resolve, reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+
+    return { id: nextId(), promise, resolve, reject };
+  }
+
+  #handleParentMessage(event) {
+    if(event.data?.target !== 'valuApi') {
+      //console.log('Skipped non valu event: ');
+       return;
+    }
+
+    const message = event.data.message;
+    console.log('Message From Valu: ', event.data.name, ' ', message);
+
+    switch (event.data.name) {
+      case 'api:ready': {
+        this.#valuApplication = {
+          id : message,
+          source: event.source,
+          origin: event.origin,
+        }
+
+        this.#eventEmitter.emit(ValuApi.API_READY);
+        break;
+      }
+
+      case 'api:run-console-completed': {
+        const requestId = event.data.requestId;
+        const deferred = this.#consoleCommands[requestId];
+        if(deferred) {
+          deferred.resolve(message);
+        } else {
+          console.log('Failed to locate console request with Id: ', requestId);
+        }
+
+        delete this.#consoleCommands[requestId];
+        break;
+      }
+
+      case 'api:run-completed': {
+        const requestId = event.data.requestId;
+        const apiPointer = this.#apiRequests[requestId];
+        if(!apiPointer)  {
+          console.error(`Failed to find Api Pointer for requestId: ${requestId}`);
+          break
+        }
+
+        apiPointer.postRunResult(requestId, message);
+        delete this.#apiRequests[requestId];
+        break;
+      }
+    }
+  }
+}