@contrail/cli 3.5.0 → 3.5.1-alpha.9da7ac5

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/3.5.0 linux-x64 node-v24.14.1
+@contrail/cli/3.5.1-alpha.9da7ac5 linux-x64 node-v24.14.1
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND

package/node_modules/@contrail/sdk/.github/workflows/publish-to-npm.yml

@@ -0,0 +1,120 @@
+name: Publish to NPM
+
+on:
+  push:
+    branches: [master]
+    paths-ignore:
+      - '.github/**'
+  pull_request:
+    paths-ignore:
+      - '.github/**'
+
+jobs:
+  check-version:
+    name: Verify version is available on npm
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check version not already published
+        run: |
+          PACKAGE_NAME=$(node -p "require('./package.json').name")
+          VERSION=$(node -p "require('./package.json').version")
+          echo "Checking if ${PACKAGE_NAME}@${VERSION} exists on npm..."
+          if npm view "${PACKAGE_NAME}@${VERSION}" version 2>/dev/null; then
+            echo "::error::Version ${VERSION} is already published on npm. Bump the version in package.json before merging."
+            exit 1
+          else
+            echo "Version ${VERSION} is available."
+          fi
+
+  check-dependencies:
+    name: Verify no private dependencies
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Verify no private dependencies
+        run: |
+          node -e "
+            const deps = require('./package.json').dependencies || {};
+            const { execSync } = require('child_process');
+            let failed = false;
+            for (const pkg of Object.keys(deps)) {
+              try {
+                execSync('npm view ' + pkg, { stdio: 'pipe' });
+              } catch {
+                console.error('::error::Dependency ' + pkg + ' is not publicly accessible on npm');
+                failed = true;
+              }
+            }
+            if (failed) process.exit(1);
+            console.log('All ' + Object.keys(deps).length + ' dependencies are public.');
+          "
+
+  publish-alpha:
+    name: Publish alpha
+    needs: check-dependencies
+    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    outputs:
+      version: ${{ steps.publish.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install and build
+        run: npm ci && npm run build
+
+      - name: Publish alpha
+        id: publish
+        run: |
+          SHORT_SHA=$(echo ${{ github.event.pull_request.head.sha }} | cut -c1-7)
+          VERSION=$(node -p "require('./package.json').version")-alpha.${SHORT_SHA}
+          npm version $VERSION --no-git-tag-version
+          OUTPUT=$(npm publish --tag alpha 2>&1) && {
+            echo "version=$VERSION" >> $GITHUB_OUTPUT
+          } || {
+            if echo "$OUTPUT" | grep -q "You cannot publish over the previously published versions"; then
+              echo "::warning::Alpha ${VERSION} already published, skipping."
+            else
+              echo "::error::Failed to publish alpha ${VERSION}"
+              echo "$OUTPUT"
+              exit 1
+            fi
+          }
+
+  publish-release:
+    name: Publish release
+    needs: check-dependencies
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    outputs:
+      version: ${{ steps.publish.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install and build
+        run: npm ci && npm run build
+
+      - name: Publish release
+        id: publish
+        run: |
+          npm publish
+          echo "version=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT

package/node_modules/@contrail/sdk/lib/auth/login.js

@@ -93,8 +93,16 @@ function usernameAuthentication(email, password, orgSlug) {
             cognitoUser.authenticateUser(authDetails, {
                 onSuccess: (result) => __awaiter(this, void 0, void 0, function* () {
                     const user = result;
-                    const config = yield setAuthContext(user.idToken.jwtToken, orgSlug);
-                    resolve(config);
+                    const cognitoAccessToken = user.idToken.jwtToken;
+                    try {
+                        const apiTokens = yield exchangeCognitoTokensForApiTokens(cognitoAccessToken);
+                        const config = yield setAuthContext(apiTokens.accessToken, orgSlug, apiTokens.refreshToken);
+                        resolve(config);
+                    }
+                    catch (error) {
+                        console.error('Failed to process Cognito token:', error);
+                        reject(error);
+                    }
                 }),
                 onFailure: (err) => {
                     reject(err);
@@ -103,11 +111,42 @@ function usernameAuthentication(email, password, orgSlug) {
         });
     });
 }
-function setAuthContext(bearerToken, orgSlug) {
+function exchangeCognitoTokensForApiTokens(cognitoAccessToken) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const apiGateway = CONFIGURATION.apiGateway;
+        const url = apiGateway + '/auth/cognito/';
+        const response = yield fetch(url, {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                accessToken: cognitoAccessToken,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to authenticate with Cognito token: ${response.status}`);
+        }
+        const data = yield response.json();
+        if (!data.accessToken) {
+            throw new Error('Response from /auth/cognito/ missing required field: accessToken');
+        }
+        if (!data.refreshToken) {
+            throw new Error('Response from /auth/cognito/ missing required field: refreshToken');
+        }
+        return {
+            accessToken: data.accessToken,
+            refreshToken: data.refreshToken,
+        };
+    });
+}
+function setAuthContext(bearerToken, orgSlug, apiRefreshToken) {
     return __awaiter(this, void 0, void 0, function* () {
         let apiGateway = CONFIGURATION.apiGateway;
         auth_1.Auth.config = {
             apiUserToken: bearerToken,
+            apiRefreshToken: apiRefreshToken,
             apiGateway,
             orgSlug,
         };

package/node_modules/@contrail/sdk/lib/core/request.d.ts

@@ -1,9 +1,12 @@
 import { InvocationContext } from '../config/config';
 export declare const AUTH_TOKEN_REQUIRED = "Authentication token must be set to make a contrail call.";
+export declare function _resetTokenRefreshPromise(): void;
 export declare class Request {
     private static MAX_RETRIES;
     private static RETRY_DELAY;
     static request(resource: any, params?: any, ctx?: InvocationContext): Promise<any>;
+    private static requestWithRetries;
+    private static isTokenExpiredError;
     private static delay;
     static logError(error: {}, resource: any, params?: {}): void;
     static sanitizeParametersString(params: any): string;

package/node_modules/@contrail/sdk/lib/core/request.js

@@ -12,19 +12,108 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Request = exports.AUTH_TOKEN_REQUIRED = void 0;
+exports.Request = exports._resetTokenRefreshPromise = exports.AUTH_TOKEN_REQUIRED = void 0;
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const config_1 = require("../config/config");
+const auth_1 = require("../auth/auth");
 exports.AUTH_TOKEN_REQUIRED = 'Authentication token must be set to make a contrail call.';
 class ApiError extends Error {
-    constructor(message, details) {
+    constructor(message, details, errorCode) {
         super(message);
         this.details = details;
+        this.errorCode = errorCode;
         this.details = details;
+        this.errorCode = errorCode;
     }
 }
+let tokenRefreshPromise = null;
+function performTokenRefresh() {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const apiRefreshToken = (_a = auth_1.Auth.config) === null || _a === void 0 ? void 0 : _a.apiRefreshToken;
+        const apiGateway = (_b = auth_1.Auth.config) === null || _b === void 0 ? void 0 : _b.apiGateway;
+        if (!apiRefreshToken) {
+            throw new Error('No API refresh token available. Please login again.');
+        }
+        if (!apiGateway) {
+            throw new Error('API Gateway not configured. Ensure the application environment is properly configured.');
+        }
+        const url = apiGateway + '/auth/jwt_refresh/';
+        try {
+            const response = yield (0, node_fetch_1.default)(url, {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    refreshToken: apiRefreshToken,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = yield response.text();
+                throw new Error(`Token refresh failed with status ${response.status}: ${errorText}`);
+            }
+            const data = yield response.json();
+            if (!data.accessToken) {
+                throw new Error(`Token refresh response did not contain a new access token.`);
+            }
+            auth_1.Auth.config.apiUserToken = data.accessToken;
+            (0, config_1.setConfig)(auth_1.Auth.config);
+            console.log('Access token refreshed successfully');
+            return data.accessToken;
+        }
+        catch (error) {
+            throw new Error(`Token refresh failed: ${(_c = error === null || error === void 0 ? void 0 : error.message) !== null && _c !== void 0 ? _c : String(error)}. Please login again with your credentials.`);
+        }
+    });
+}
+function refreshAccessToken() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (tokenRefreshPromise) {
+            console.log('Token refresh already in progress, waiting for completion...');
+            return tokenRefreshPromise;
+        }
+        tokenRefreshPromise = performTokenRefresh();
+        try {
+            const newToken = yield tokenRefreshPromise;
+            return newToken;
+        }
+        finally {
+            tokenRefreshPromise = null;
+        }
+    });
+}
+function _resetTokenRefreshPromise() {
+    tokenRefreshPromise = null;
+}
+exports._resetTokenRefreshPromise = _resetTokenRefreshPromise;
 class Request {
     static request(resource, params = { method: 'get' }, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            params.headers = Object.assign(Object.assign({}, (params.headers || {})), (yield Request.getHeaders()));
+            try {
+                return yield this.requestWithRetries(resource, params, ctx);
+            }
+            catch (error) {
+                if (this.isTokenExpiredError(error)) {
+                    console.log(`[SDK Request: Token Expired] Attempting to refresh access token...`);
+                    try {
+                        yield refreshAccessToken();
+                        params.headers = Object.assign(Object.assign({}, (params.headers || {})), (yield Request.getHeaders()));
+                        console.log(`[SDK Request: Token Refreshed] Retrying request...`);
+                        return yield this.requestWithRetries(resource, params, ctx);
+                    }
+                    catch (refreshError) {
+                        console.error(`[SDK Request: Token Refresh Failed] ${refreshError === null || refreshError === void 0 ? void 0 : refreshError.message}`, refreshError);
+                        throw new ApiError('Access token refresh failed after TOKEN_EXPIRED error. Unable to proceed with request', refreshError);
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    static requestWithRetries(resource, params, ctx) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const userCtx = ctx || (0, config_1.getGlobalContext)();
@@ -33,7 +122,6 @@ class Request {
             const url = API_GATEWAY + resource;
             const method = (params === null || params === void 0 ? void 0 : params.method) ? params.method.toUpperCase() : 'GET';
             const fullResource = `${method} ${url.split('/')[3]}${resource}`;
-            params.headers = Object.assign(Object.assign({}, (params.headers || {})), (yield Request.getHeaders()));
             let res;
             let attempt = 0;
             while (attempt <= this.MAX_RETRIES) {
@@ -72,11 +160,16 @@ class Request {
                 else {
                     const error = yield res.text();
                     const errorJson = this.tryParseStringIntoObject(error);
+                    const isTokenExpired = errorJson && typeof errorJson === 'object' && errorJson.errorCode === 'TOKEN_EXPIRED';
+                    if (isTokenExpired) {
+                        throw new ApiError('Token expired', errorJson, 'TOKEN_EXPIRED');
+                    }
                     if (errorHandler) {
                         const retryCallback = () => __awaiter(this, void 0, void 0, function* () {
+                            params.headers = Object.assign(Object.assign({}, (params.headers || {})), (yield Request.getHeaders()));
                             return yield (0, node_fetch_1.default)(url, params);
                         });
-                        console.log(`[###### SDK Request: ERROR] code ${error.statusCode} resource: ${fullResource}`);
+                        console.log(`[###### SDK Request: ERROR] code ${res.status} resource: ${fullResource}`);
                         console.log(`[###### SDK Request: ERROR] params ${Request.sanitizeParametersString(params)}`);
                         const request = Object.assign(Object.assign({}, params), { url, method });
                         return yield errorHandler.handle(res, errorJson, retryCallback, request);
@@ -97,6 +190,9 @@ class Request {
             }
         });
     }
+    static isTokenExpiredError(error) {
+        return error instanceof ApiError && error.errorCode === 'TOKEN_EXPIRED';
+    }
     static delay(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }

package/node_modules/@contrail/sdk/lib/entities/entities.client.js

@@ -131,7 +131,7 @@ class Entities {
                 resource += `skipHydrateRelationships=${options.skipHydrateRelationships}&`;
             }
             if (options.federatedIds) {
-                resource += `ids=${options.federatedIds.map((id) => id.replace(/,/g, '_COMMA_')).join(',')}&`;
+                resource += `ids=${options.federatedIds.map((id) => encodeURIComponent(id.replace(/,/g, '_COMMA_'))).join(',')}&`;
             }
             if (options.criteria) {
                 resource += 'criteria=' + JSURL.stringify(options.criteria);

package/node_modules/@contrail/sdk/lib/entities/entity.resource.registry.js

@@ -55,3 +55,4 @@ EntityResourceRegistry.registerEntityResourceName('open-search', 'open-search');
 EntityResourceRegistry.registerEntityResourceName('project-configurator', 'project-configurator');
 EntityResourceRegistry.registerEntityResourceName('identity', 'identities');
 EntityResourceRegistry.registerEntityResourceName('entity-policy', 'entity-policies');
+EntityResourceRegistry.registerEntityResourceName('measurement-spec-entry', 'measurement-spec-entries');

package/node_modules/@contrail/sdk/lib/files/files.d.ts

@@ -1,9 +1,19 @@
+/// <reference types="node" />
 export declare class Files {
     private ctx;
     constructor(ctx?: any);
     createAndUploadFile(file: File, ownedByReference?: string, ttl?: number): Promise<any>;
-    createAndUploadFileFromBuffer(buffer: any, contentType: string, fileName: string, ownedByReference?: string, ttl?: number): Promise<any>;
-    uploadFile(uploadPost: any, file: File): Promise<void>;
-    uploadFileAsStream(uploadPost: any, buffer: File, options?: any): Promise<unknown>;
+    createAndUploadFileFromBuffer(buffer: Buffer, contentType: string, fileName: string, ownedByReference?: string, ttl?: number): Promise<any>;
+    uploadFile(uploadPost: {
+        url: string;
+        fields: Record<string, string>;
+    }, file: File): Promise<void>;
+    uploadFileAsStream(uploadPost: {
+        url: string;
+        fields: Record<string, string>;
+    }, buffer: Buffer | File, options?: {
+        contentType?: string;
+    }): Promise<void>;
+    private withRetry;
     private appendUploadHeaders;
 }

package/node_modules/@contrail/sdk/lib/files/files.js

@@ -17,6 +17,13 @@ const node_fetch_1 = __importDefault(require("node-fetch"));
 const entities_1 = require("../entities");
 const FormData = require('form-data');
 const file_type_helper_1 = require("./file-type-helper");
+const RETRYABLE_HTTP_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+class NonRetryableError extends Error {
+    constructor(cause) {
+        super(cause.message);
+        this.cause = cause;
+    }
+}
 class Files {
     constructor(ctx) {
         this.ctx = ctx;
@@ -69,36 +76,70 @@ class Files {
     }
     uploadFile(uploadPost, file) {
         return __awaiter(this, void 0, void 0, function* () {
-            const formData = new FormData();
-            formData.append('Content-Type', file.type || file_type_helper_1.FileTypeHelper.getContentType(file));
-            this.appendUploadHeaders(uploadPost, formData);
-            formData.append('file', file);
-            yield (0, node_fetch_1.default)(uploadPost.url, { method: 'POST', body: formData });
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                const formData = new FormData();
+                formData.append('Content-Type', file.type || file_type_helper_1.FileTypeHelper.getContentType(file));
+                this.appendUploadHeaders(uploadPost, formData);
+                formData.append('file', file);
+                const response = yield (0, node_fetch_1.default)(uploadPost.url, { method: 'POST', body: formData });
+                if (!response.ok) {
+                    const errorText = yield response.text();
+                    const error = new Error(`File upload failed with status ${response.status}: ${errorText}`);
+                    if (!RETRYABLE_HTTP_STATUSES.has(response.status))
+                        throw new NonRetryableError(error);
+                    throw error;
+                }
+                yield response.text();
+            }), 'Files.uploadFile', () => console.error(`[Files.uploadFile: Max attempts reached] file: ${file.name}, size: ${file.size}`));
         });
     }
     uploadFileAsStream(uploadPost, buffer, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const formData = new FormData();
-            formData.append('Content-Type', options.contentType);
-            this.appendUploadHeaders(uploadPost, formData);
-            formData.append('file', buffer);
-            return new Promise((res, rej) => {
-                formData.getLength((err, len) => __awaiter(this, void 0, void 0, function* () {
-                    if (err) {
-                        rej(err);
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                const formData = new FormData();
+                if (options === null || options === void 0 ? void 0 : options.contentType) {
+                    formData.append('Content-Type', options.contentType);
+                }
+                this.appendUploadHeaders(uploadPost, formData);
+                formData.append('file', buffer);
+                const contentLength = yield new Promise((resolve, reject) => {
+                    formData.getLength((err, length) => (err ? reject(new NonRetryableError(err)) : resolve(length)));
+                });
+                const response = yield (0, node_fetch_1.default)(uploadPost.url, {
+                    method: 'POST',
+                    body: formData,
+                    headers: { 'Content-Length': contentLength },
+                });
+                if (!response.ok) {
+                    const errorText = yield response.text();
+                    const error = new Error(`File upload failed with status ${response.status}: ${errorText}`);
+                    if (!RETRYABLE_HTTP_STATUSES.has(response.status))
+                        throw new NonRetryableError(error);
+                    throw error;
+                }
+                yield response.text();
+            }), 'Files.uploadFileAsStream', () => console.error(`[Files.uploadFileAsStream: Max attempts reached] size: ${'size' in buffer ? buffer.size : buffer.length}`));
+        });
+    }
+    withRetry(operation, context, onExhausted) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const MAX_ATTEMPTS = 3;
+            const RETRY_DELAY_MS = 1000;
+            for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+                try {
+                    return yield operation();
+                }
+                catch (error) {
+                    if (error instanceof NonRetryableError)
+                        throw error.cause;
+                    console.error(`[Attempt ${attempt}][${context}: Error]`, error);
+                    if (attempt >= MAX_ATTEMPTS) {
+                        onExhausted();
+                        throw error;
                     }
-                    const response = yield (0, node_fetch_1.default)(uploadPost.url, {
-                        method: 'POST',
-                        body: formData,
-                        headers: {
-                            'Content-Length': len,
-                        },
-                    });
-                    const text = yield response.text();
-                    console.log('text: ', text);
-                    res('ok');
-                }));
-            });
+                    yield new Promise((resolve) => setTimeout(resolve, attempt * RETRY_DELAY_MS));
+                }
+            }
         });
     }
     appendUploadHeaders(uploadPost, formData) {

package/node_modules/@contrail/sdk/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@contrail/sdk",
-  "version": "1.5.5",
+  "version": "1.5.13",
   "description": "Client library for interfacing with contrail services.",
   "homepage": "https://archergreysorg.github.io/contrail-lib/",
+  "publishConfig": {
+    "access": "public"
+  },
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.0",
+  "version": "3.5.1-alpha.9da7ac5",
   "commands": {
     "app:create": {
       "id": "app:create",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "3.5.0",
+  "version": "3.5.1-alpha.9da7ac5",
   "description": "VibeIQ's Contrail Platform CLI.",
   "bin": {
     "contrail-cli": "./bin/run",
@@ -33,7 +33,7 @@
     "@contrail/entity-types": "^1.6.1",
     "@contrail/loader": "^2.0.6",
     "@contrail/org-config-migration": "^1.1.13",
-    "@contrail/sdk": "^1.5.5",
+    "@contrail/sdk": "^1.5.13",
     "@contrail/types": "^3.1.5",
     "@contrail/util": "^1.2.0",
     "@oclif/core": "^2",