@luciq/react-native 19.2.2 → 19.3.0

package/dist/models/CustomSpan.js

@@ -0,0 +1,82 @@
+/**
+ * Represents a custom span for performance tracking.
+ * A span measures the duration of an operation and reports it to the native SDK.
+ */
+export class CustomSpan {
+    name;
+    startTime; // Date.now() in milliseconds
+    startMonotonic; // performance.now() in milliseconds
+    endTime;
+    duration;
+    hasEnded = false;
+    endPromise;
+    unregisterCallback;
+    syncCallback;
+    /**
+     * Creates a new custom span. The span starts immediately upon creation.
+     * @internal - Use APM.startCustomSpan() instead
+     */
+    constructor(name, unregisterCallback, syncCallback) {
+        this.name = name;
+        this.startTime = Date.now();
+        this.startMonotonic = performance.now();
+        this.unregisterCallback = unregisterCallback;
+        this.syncCallback = syncCallback;
+    }
+    /**
+     * Ends this custom span and reports it to the native SDK.
+     * This method is idempotent - calling it multiple times is safe.
+     * Subsequent calls will wait for the first call to complete.
+     */
+    async end() {
+        // Thread-safe check using Promise-based locking
+        if (this.hasEnded) {
+            if (this.endPromise) {
+                await this.endPromise;
+            }
+            return;
+        }
+        // Create lock and mark as ended
+        let resolveEnd;
+        this.endPromise = new Promise((resolve) => {
+            resolveEnd = resolve;
+        });
+        this.hasEnded = true;
+        try {
+            // Unregister from active spans
+            this.unregisterCallback(this);
+            // Calculate duration using monotonic clock
+            const endMonotonic = performance.now();
+            this.duration = endMonotonic - this.startMonotonic;
+            // Calculate end time using wall clock
+            this.endTime = this.startTime + this.duration;
+            // Convert to microseconds for native SDK
+            const startMicros = this.startTime * 1000;
+            const endMicros = this.endTime * 1000;
+            // Send to native SDK
+            await this.syncCallback(this.name, startMicros, endMicros);
+        }
+        finally {
+            // Release lock
+            resolveEnd();
+        }
+    }
+    /**
+     * Get the span name
+     */
+    getName() {
+        return this.name;
+    }
+    /**
+     * Check if the span has ended
+     */
+    isEnded() {
+        return this.hasEnded;
+    }
+    /**
+     * Get the span duration in milliseconds (only available after end())
+     */
+    getDuration() {
+        return this.duration;
+    }
+}

package/dist/modules/APM.d.ts

@@ -1,3 +1,4 @@
+import type { CustomSpan } from '../models/CustomSpan';
 /**
  * Enables or disables APM
  * @param isEnabled
@@ -80,3 +81,60 @@ export declare const _lcqSleep: () => void;
  * @param isEnabled
  */
 export declare const setScreenRenderingEnabled: (isEnabled: boolean) => void;
+/**
+ * Starts a custom span for performance tracking.
+ *
+ * A custom span measures the duration of an arbitrary operation that is not
+ * automatically tracked by the SDK. The span must be manually ended by calling
+ * the `end()` method on the returned span object.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ *
+ * @returns Promise<CustomSpan | null> - The span object to end later, or null if:
+ *   - Name is empty after trimming
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *   - Maximum concurrent spans limit (100) reached
+ *
+ * @example
+ * ```typescript
+ * const span = await APM.startCustomSpan('Load User Profile');
+ * if (span) {
+ *   try {
+ *     // ... perform operation ...
+ *   } finally {
+ *     await span.end();
+ *   }
+ * }
+ * ```
+ */
+export declare const startCustomSpan: (name: string) => Promise<CustomSpan | null>;
+/**
+ * Records a completed custom span with pre-recorded timestamps.
+ *
+ * Use this method when you have already recorded the start and end times
+ * of an operation and want to report it retroactively.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ * @param startDate - The start time of the operation
+ * @param endDate - The end time of the operation (must be after startDate)
+ *
+ * @returns Promise<void> - Resolves when the span has been recorded, or logs error if:
+ *   - Name is empty after trimming
+ *   - End date is not after start date
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *
+ * @example
+ * ```typescript
+ * const start = new Date();
+ * // ... operation already completed ...
+ * const end = new Date();
+ * await APM.addCompletedCustomSpan('Cache Lookup', start, end);
+ * ```
+ */
+export declare const addCompletedCustomSpan: (name: string, startDate: Date, endDate: Date) => Promise<void>;

package/dist/modules/APM.js

@@ -1,6 +1,7 @@
 import { Platform } from 'react-native';
 import { NativeAPM } from '../native/NativeAPM';
 import { NativeLuciq } from '../native/NativeLuciq';
+import { startCustomSpan as startCustomSpanInternal, addCompletedCustomSpan as addCompletedCustomSpanInternal, } from '../utils/CustomSpansManager';
 /**
  * Enables or disables APM
  * @param isEnabled
@@ -109,3 +110,64 @@ export const _lcqSleep = () => {
 export const setScreenRenderingEnabled = (isEnabled) => {
     NativeAPM.setScreenRenderingEnabled(isEnabled);
 };
+/**
+ * Starts a custom span for performance tracking.
+ *
+ * A custom span measures the duration of an arbitrary operation that is not
+ * automatically tracked by the SDK. The span must be manually ended by calling
+ * the `end()` method on the returned span object.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ *
+ * @returns Promise<CustomSpan | null> - The span object to end later, or null if:
+ *   - Name is empty after trimming
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *   - Maximum concurrent spans limit (100) reached
+ *
+ * @example
+ * ```typescript
+ * const span = await APM.startCustomSpan('Load User Profile');
+ * if (span) {
+ *   try {
+ *     // ... perform operation ...
+ *   } finally {
+ *     await span.end();
+ *   }
+ * }
+ * ```
+ */
+export const startCustomSpan = async (name) => {
+    return startCustomSpanInternal(name);
+};
+/**
+ * Records a completed custom span with pre-recorded timestamps.
+ *
+ * Use this method when you have already recorded the start and end times
+ * of an operation and want to report it retroactively.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ * @param startDate - The start time of the operation
+ * @param endDate - The end time of the operation (must be after startDate)
+ *
+ * @returns Promise<void> - Resolves when the span has been recorded, or logs error if:
+ *   - Name is empty after trimming
+ *   - End date is not after start date
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *
+ * @example
+ * ```typescript
+ * const start = new Date();
+ * // ... operation already completed ...
+ * const end = new Date();
+ * await APM.addCompletedCustomSpan('Cache Lookup', start, end);
+ * ```
+ */
+export const addCompletedCustomSpan = async (name, startDate, endDate) => {
+    return addCompletedCustomSpanInternal(name, startDate, endDate);
+};

package/dist/native/NativeAPM.d.ts

@@ -14,6 +14,9 @@ export interface ApmNativeModule extends NativeModule {
     endUITrace(): void;
     lcqSleep(): void;
     setScreenRenderingEnabled(isEnabled: boolean): void;
+    syncCustomSpan(name: string, startTimestamp: number, endTimestamp: number): Promise<void>;
+    isCustomSpanEnabled(): Promise<boolean>;
+    isAPMEnabled(): Promise<boolean>;
 }
 export declare const NativeAPM: ApmNativeModule;
 export declare const emitter: NativeEventEmitter;

package/dist/native/NativeLuciq.d.ts

@@ -8,6 +8,7 @@ import type { ThemeConfig } from '../models/ThemeConfig';
 export interface LuciqNativeModule extends NativeModule {
     getConstants(): NativeConstants;
     setEnabled(isEnabled: boolean): void;
+    isBuilt(): Promise<boolean>;
     init(token: string, invocationEvents: InvocationEvent[], debugLogsLevel: LogLevel, useNativeNetworkInterception: boolean, codePushVersion?: string, appVariant?: string, options?: {
         ignoreAndroidSecureFlag?: boolean;
     }, overAirVersion?: OverAirUpdate): void;

package/dist/utils/CustomSpansManager.d.ts

@@ -0,0 +1,38 @@
+import { CustomSpan } from '../models/CustomSpan';
+/**
+ * Starts a custom span for performance tracking.
+ *
+ * A custom span measures the duration of an arbitrary operation that is not
+ * automatically tracked by the SDK. The span must be manually ended by calling
+ * the `end()` method on the returned span object.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ *
+ * @returns Promise<CustomSpan | null> - The span object to end later, or null if:
+ *   - Name is empty after trimming
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *   - Maximum concurrent spans limit (100) reached
+ */
+export declare const startCustomSpan: (name: string) => Promise<CustomSpan | null>;
+/**
+ * Records a completed custom span with pre-recorded timestamps.
+ *
+ * Use this method when you have already recorded the start and end times
+ * of an operation and want to report it retroactively.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ * @param startDate - The start time of the operation
+ * @param endDate - The end time of the operation (must be after startDate)
+ *
+ * @returns Promise<void>
+ */
+export declare const addCompletedCustomSpan: (name: string, startDate: Date, endDate: Date) => Promise<void>;
+/**
+ * Test-only helper to clear active spans between tests.
+ * @internal
+ */
+export declare const __resetCustomSpansForTests: () => void;

package/dist/utils/CustomSpansManager.js

@@ -0,0 +1,173 @@
+import { NativeAPM } from '../native/NativeAPM';
+import { NativeLuciq } from '../native/NativeLuciq';
+import { CustomSpan } from '../models/CustomSpan';
+import { LuciqStrings } from '../constants/Strings';
+/**
+ * Tracks currently active custom spans
+ * @internal
+ */
+const activeSpans = new Set();
+/**
+ * Maximum concurrent custom spans allowed at any time
+ * @internal
+ */
+const MAX_CONCURRENT_SPANS = 100;
+/**
+ * Internal: unregister a span from active tracking
+ * @internal
+ */
+const unregisterSpan = (span) => {
+    activeSpans.delete(span);
+};
+/**
+ * Internal: sync custom span data to native SDK
+ * @internal
+ */
+const syncCustomSpan = async (name, startTimestamp, endTimestamp) => {
+    // Validate inputs (safety net)
+    if (!name || name.trim().length === 0) {
+        console.error(LuciqStrings.customSpanNameEmpty);
+        return;
+    }
+    if (endTimestamp <= startTimestamp) {
+        console.error(LuciqStrings.customSpanEndTimeBeforeStartTime);
+        return;
+    }
+    // Truncate name if needed (safety net)
+    let spanName = name.trim();
+    if (spanName.length > 150) {
+        spanName = spanName.substring(0, 150);
+    }
+    await NativeAPM.syncCustomSpan(spanName, startTimestamp, endTimestamp);
+};
+/**
+ * Starts a custom span for performance tracking.
+ *
+ * A custom span measures the duration of an arbitrary operation that is not
+ * automatically tracked by the SDK. The span must be manually ended by calling
+ * the `end()` method on the returned span object.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ *
+ * @returns Promise<CustomSpan | null> - The span object to end later, or null if:
+ *   - Name is empty after trimming
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *   - Maximum concurrent spans limit (100) reached
+ */
+export const startCustomSpan = async (name) => {
+    try {
+        // Validate name
+        const trimmedName = name.trim();
+        if (trimmedName.length === 0) {
+            console.error(LuciqStrings.customSpanNameEmpty);
+            return null;
+        }
+        // Check SDK initialization
+        const isInitialized = await NativeLuciq.isBuilt();
+        if (!isInitialized) {
+            console.error(LuciqStrings.customSpanSDKNotInitializedMessage);
+            return null;
+        }
+        // Check APM enabled
+        const isAPMEnabled = await NativeAPM.isAPMEnabled();
+        if (!isAPMEnabled) {
+            console.log(LuciqStrings.customSpanAPMDisabledMessage);
+            return null;
+        }
+        // Check custom spans enabled
+        const isCustomSpanEnabled = await NativeAPM.isCustomSpanEnabled();
+        if (!isCustomSpanEnabled) {
+            console.log(LuciqStrings.customSpanDisabled);
+            return null;
+        }
+        // Check concurrent span limit
+        if (activeSpans.size >= MAX_CONCURRENT_SPANS) {
+            console.error(LuciqStrings.customSpanLimitReached);
+            return null;
+        }
+        // Truncate name if needed
+        let spanName = trimmedName;
+        if (spanName.length > 150) {
+            spanName = spanName.substring(0, 150);
+            console.log(LuciqStrings.customSpanNameTruncated);
+        }
+        // Create and register span with callbacks
+        const span = new CustomSpan(spanName, unregisterSpan, syncCustomSpan);
+        activeSpans.add(span);
+        return span;
+    }
+    catch (error) {
+        console.error('[CustomSpan] Error starting span:', error);
+        return null;
+    }
+};
+/**
+ * Records a completed custom span with pre-recorded timestamps.
+ *
+ * Use this method when you have already recorded the start and end times
+ * of an operation and want to report it retroactively.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ * @param startDate - The start time of the operation
+ * @param endDate - The end time of the operation (must be after startDate)
+ *
+ * @returns Promise<void>
+ */
+export const addCompletedCustomSpan = async (name, startDate, endDate) => {
+    try {
+        // Validate name
+        const trimmedName = name.trim();
+        if (trimmedName.length === 0) {
+            console.error(LuciqStrings.customSpanNameEmpty);
+            return;
+        }
+        // Validate timestamps
+        if (endDate <= startDate) {
+            console.error(LuciqStrings.customSpanEndTimeBeforeStartTime);
+            return;
+        }
+        // Check SDK initialization
+        const isInitialized = await NativeLuciq.isBuilt();
+        if (!isInitialized) {
+            console.error(LuciqStrings.customSpanSDKNotInitializedMessage);
+            return;
+        }
+        // Check APM enabled
+        const isAPMEnabled = await NativeAPM.isAPMEnabled();
+        if (!isAPMEnabled) {
+            console.log(LuciqStrings.customSpanAPMDisabledMessage);
+            return;
+        }
+        // Check custom spans enabled
+        const isCustomSpanEnabled = await NativeAPM.isCustomSpanEnabled();
+        if (!isCustomSpanEnabled) {
+            console.log(LuciqStrings.customSpanDisabled);
+            return;
+        }
+        // Truncate name if needed
+        let spanName = trimmedName;
+        if (spanName.length > 150) {
+            spanName = spanName.substring(0, 150);
+            console.log(LuciqStrings.customSpanNameTruncated);
+        }
+        // Convert to microseconds
+        const startMicros = startDate.getTime() * 1000;
+        const endMicros = endDate.getTime() * 1000;
+        // Send to native SDK
+        await syncCustomSpan(spanName, startMicros, endMicros);
+    }
+    catch (error) {
+        console.error('[CustomSpan] Error adding completed span:', error);
+    }
+};
+/**
+ * Test-only helper to clear active spans between tests.
+ * @internal
+ */
+export const __resetCustomSpansForTests = () => {
+    activeSpans.clear();
+};

package/ios/RNLuciq/LuciqAPMBridge.h

@@ -23,4 +23,17 @@
 
 - (void)setScreenRenderingEnabled:(BOOL)isEnabled;
 
+// Custom Span methods
+- (void)syncCustomSpan:(NSString *)name
+        startTimestamp:(double)startTimestamp
+          endTimestamp:(double)endTimestamp
+              resolver:(RCTPromiseResolveBlock)resolve
+              rejecter:(RCTPromiseRejectBlock)reject;
+
+- (void)isCustomSpanEnabled:(RCTPromiseResolveBlock)resolve
+                   rejecter:(RCTPromiseRejectBlock)reject;
+
+- (void)isAPMEnabled:(RCTPromiseResolveBlock)resolve
+            rejecter:(RCTPromiseRejectBlock)reject;
+
 @end

package/ios/RNLuciq/LuciqAPMBridge.m

@@ -90,6 +90,61 @@ RCT_EXPORT_METHOD(setScreenRenderingEnabled:(BOOL)isEnabled) {
     LCQAPM.screenRenderingEnabled = isEnabled;
 }
 
+// Syncs a custom span to the native SDK (currently logs only)
+RCT_EXPORT_METHOD(syncCustomSpan:(NSString *)name
+                  startTimestamp:(double)startTimestamp
+                  endTimestamp:(double)endTimestamp
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    @try {
+        // Convert microseconds → seconds (NSDate uses seconds)
+        NSTimeInterval startSeconds = startTimestamp / 1e6;
+        NSTimeInterval endSeconds   = endTimestamp / 1e6;
+
+        NSDate *startDate = [NSDate dateWithTimeIntervalSince1970:startSeconds];
+        NSDate *endDate   = [NSDate dateWithTimeIntervalSince1970:endSeconds];
+
+        // Add completed span to APM
+        [LCQAPM addCompletedCustomSpanWithName:name
+                                     startDate:startDate
+                                       endDate:endDate];
+
+        resolve(@YES);
+    }
+    @catch (NSException *exception) {
+        reject(
+            @"SYNC_CUSTOM_SPAN_ERROR",
+            exception.reason ?: @"Failed to sync custom span",
+            nil
+        );
+    }
+}
+
+// Checks if custom spans feature is enabled
+RCT_EXPORT_METHOD(isCustomSpanEnabled:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        BOOL enabled = LCQAPM.customSpansEnabled;
+        resolve(@(enabled));
+    } @catch (NSException *exception) {
+        NSLog(@"[CustomSpan] Error checking feature flag: %@", exception);
+        resolve(@NO);
+    }
+}
+
+// Checks if APM is enabled
+RCT_EXPORT_METHOD(isAPMEnabled:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        BOOL enabled = LCQAPM.enabled;
+        resolve(@(enabled));
+    } @catch (NSException *exception) {
+        NSLog(@"[CustomSpan] Error checking APM enabled: %@", exception);
+        resolve(@NO);
+    }
+}
+
 
 
 @synthesize description;

package/ios/RNLuciq/LuciqReactBridge.m

@@ -545,4 +545,16 @@ RCT_EXPORT_METHOD(setNetworkLogBodyEnabled:(BOOL)isEnabled) {
     LCQNetworkLogger.logBodyEnabled = isEnabled;
 }
 
+// Checks if Luciq SDK is initialized
+RCT_EXPORT_METHOD(isBuilt:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        BOOL isBuilt = YES;
+        resolve(@(isBuilt));
+    } @catch (NSException *exception) {
+        NSLog(@"[Luciq] Error checking if SDK is built: %@", exception);
+        resolve(@NO);
+    }
+}
+
 @end

package/ios/RNLuciq/Util/LCQAPM+PrivateAPIs.h

@@ -11,5 +11,6 @@
 
 @property (class, atomic, assign) BOOL networkEnabled;
 
++ (BOOL)customSpansEnabled;
 
 @end

package/ios/native.rb

@@ -1,4 +1,4 @@
-$luciq= { :version => '19.4.1' }
+$luciq= { :version => '19.5.0' }
 
 def use_luciq! (spec = nil)
   version = $luciq[:version]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@luciq/react-native",
   "description": "Luciq is the Agentic Observability Platform built for Mobile.",
-  "version": "19.2.2",
+  "version": "19.3.0",
   "author": "Luciq (https://luciq.ai)",
   "repository": "github:luciqai/luciq-reactnative-sdk",
   "homepage": "https://www.luciq.ai/platforms/react-native",

package/scripts/releases/changelog_to_slack_formatter.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+input=$(cat)
+
+input=$(sed -E \
+          -e 's/\[([^]]+)\]\(([^)]+)\)/<\2|\1>/g' \
+          -e 's/^#{1,6}[[:space:]]*([^[:space:]].*)$/\*\1\*/' \
+          -e 's/^- /• /' <<< "$input")
+
+echo "$input"

package/scripts/releases/get_job_approver.sh

@@ -0,0 +1,60 @@
+if [ -z "$CIRCLE_TOKEN" ]; then
+  echo "Error: CIRCLE_TOKEN is not set" >&2
+  exit 1
+fi
+
+if [ -z "$CIRCLE_WORKFLOW_ID" ]; then
+  if [ -z "$CIRCLE_PIPELINE_ID" ]; then
+    echo "Error: Neither CIRCLE_WORKFLOW_ID nor CIRCLE_PIPELINE_ID is set" >&2
+    exit 1
+  fi
+  pipelineJson=$(curl -s -X GET "https://circleci.com/api/v2/pipeline/$CIRCLE_PIPELINE_ID/workflow" --header "Circle-Token: $CIRCLE_TOKEN")
+  CIRCLE_WORKFLOW_ID=$(echo "$pipelineJson" | jq -r '.items[0].id // empty')
+  if [ -z "$CIRCLE_WORKFLOW_ID" ]; then
+    echo "Error: Failed to get workflow ID from pipeline" >&2
+    exit 1
+  fi
+fi
+
+response=$(curl -s -w "\n%{http_code}" -X GET "https://circleci.com/api/v2/workflow/$CIRCLE_WORKFLOW_ID/job" --header "Circle-Token: $CIRCLE_TOKEN")
+http_code=$(echo "$response" | tail -n1)
+jobsJson=$(echo "$response" | sed '$d')
+
+if [ "$http_code" != "200" ]; then
+  echo "Error: CircleCI API returned HTTP $http_code" >&2
+  echo "Workflow ID: $CIRCLE_WORKFLOW_ID" >&2
+  echo "Response: $jobsJson" >&2
+  exit 1
+fi
+
+if [ -z "$jobsJson" ]; then
+  echo "Error: Failed to fetch jobs from CircleCI API (empty response)" >&2
+  exit 1
+fi
+
+if ! echo "$jobsJson" | jq -e '.items' > /dev/null 2>&1; then
+  echo "Error: Invalid JSON response from CircleCI API" >&2
+  echo "Response: $jobsJson" >&2
+  exit 1
+fi
+
+job=$(jq '.items[] | select(.name == "hold_publish" or .name == "hold_slack_notification") | select(.approved_by != null)' <<< "$jobsJson")
+
+if [ -z "$job" ] || [ "$job" == "null" ]; then
+  echo "Error: Could not find approved job in workflow" >&2
+  exit 1
+fi
+
+approver_id=$(jq '.approved_by' <<< "$job")
+
+approver_id=$(tr -d '"' <<< "$approver_id")
+
+user=$(curl -s -X GET "https://circleci.com/api/v2/user/$approver_id" --header "Circle-Token: $CIRCLE_TOKEN")
+
+username=$(jq '.login' <<< "$user")
+
+username=$(tr -d '"' <<< "$username")
+
+slack_id=$(./scripts/releases/get_slack_id_from_username.sh "$username")
+
+echo "$slack_id"

package/scripts/releases/get_release_notes.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+latest_release=""
+capturing=false
+
+while IFS= read -r line; do
+  if [[ "$line" == "## ["* ]]; then
+      if $capturing; then
+        break
+      fi
+  fi
+
+  if [[ "$line" == "### "* ]]; then
+    capturing=true
+  fi
+
+  if $capturing; then
+    line=$(./scripts/releases/changelog_to_slack_formatter.sh <<< "$line")
+    latest_release+="$line\n"
+  fi
+done < CHANGELOG.md
+
+echo "$latest_release"

package/scripts/releases/get_sdk_version.sh

@@ -0,0 +1,5 @@
+sdk_version=$(grep -i 'version' package.json) #"version": "xx.x.x+x",
+sdk_version=$(cut -f2 -d' ' <<< $sdk_version | tr -d '" ,') #xx.x.x+x,
+sdk_version=$(cut -f1 -d'+' <<< $sdk_version) #xx.x.x
+
+echo "$sdk_version"