@unito/integration-cli 0.64.3 → 0.64.5

package/dist/src/commands/publish.js

@@ -271,10 +271,11 @@ class Publish extends baseCommand_1.BaseCommand {
     }
     archiveIntegration() {
         const archivePath = tmp_1.default.tmpNameSync({ postfix: `.zip` });
-        child_process_1.default.execSync(`git ls-files ':!:docs/' --cached --others --exclude-standard | zip -@ ${archivePath}`, {
+        child_process_1.default.execSync(`git ls-files ':!:docs/' ':!:test/' --cached --others --exclude-standard | zip -@ ${archivePath}`, {
             cwd: process.cwd(),
             env: { ...process.env },
         });
+        core_1.ux.log(chalk_1.default.yellowBright("Note: the 'docs' and 'test' folders are excluded from the published package."));
         return archivePath;
     }
     hashEmail(email) {

package/dist/src/hooks/init/displayLogo.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const gradient = tslib_1.__importStar(require("gradient-string"));
+const updateNotifier_1 = require("./updateNotifier");
 const displayLogo = async function () {
     const gradients = [
         gradient.atlas,
@@ -33,5 +34,6 @@ const displayLogo = async function () {
         '+------------------------------------+',
     ].join('\n'));
     core_1.ux.log(UNITOCLI_LOGO);
+    (0, updateNotifier_1.checkForUpdate)(this.config.version);
 };
 exports.default = displayLogo;

package/dist/src/hooks/init/updateNotifier.d.ts

@@ -0,0 +1,19 @@
+import child_process from 'child_process';
+interface UpdateCache {
+    latest: string;
+    checkedAt: number;
+}
+export interface UpdateNotifierDeps {
+    cacheFile: string;
+    spawn: typeof child_process.spawn;
+    log: typeof console.log;
+    upgrade: () => void;
+}
+export declare function isNewerVersion(latest: string, current: string): boolean;
+export declare function readCache(cacheFile: string): UpdateCache | null;
+export declare function isCacheStale(cache: UpdateCache | null, intervalMs?: number): boolean;
+export declare function stripAnsi(str: string): string;
+export declare function formatNotification(current: string, latest: string): string;
+export declare function spawnBackgroundCheck(deps: UpdateNotifierDeps): void;
+export declare function checkForUpdate(currentVersion: string, overrides?: Partial<UpdateNotifierDeps>): void;
+export {};

package/dist/src/hooks/init/updateNotifier.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNewerVersion = isNewerVersion;
+exports.readCache = readCache;
+exports.isCacheStale = isCacheStale;
+exports.stripAnsi = stripAnsi;
+exports.formatNotification = formatNotification;
+exports.spawnBackgroundCheck = spawnBackgroundCheck;
+exports.checkForUpdate = checkForUpdate;
+const tslib_1 = require("tslib");
+const child_process_1 = tslib_1.__importDefault(require("child_process"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const PACKAGE_NAME = '@unito/integration-cli';
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+function getDefaultCacheFile() {
+    return path_1.default.join(os_1.default.homedir(), '.cache', 'integrationcli', 'update-check.json');
+}
+function defaultUpgrade() {
+    child_process_1.default.execSync(`npm install --force --global ${PACKAGE_NAME}`, {
+        stdio: ['ignore', 'ignore', 'pipe'],
+    });
+}
+function getDefaultDeps() {
+    return {
+        cacheFile: getDefaultCacheFile(),
+        spawn: child_process_1.default.spawn,
+        log: core_1.ux.log,
+        upgrade: defaultUpgrade,
+    };
+}
+function isNewerVersion(latest, current) {
+    const latestParts = latest.split('.').map(Number);
+    const currentParts = current.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((latestParts[i] || 0) > (currentParts[i] || 0))
+            return true;
+        if ((latestParts[i] || 0) < (currentParts[i] || 0))
+            return false;
+    }
+    return false;
+}
+function readCache(cacheFile) {
+    try {
+        const data = fs_1.default.readFileSync(cacheFile, 'utf8');
+        const parsed = JSON.parse(data);
+        if (typeof parsed?.latest !== 'string' || typeof parsed?.checkedAt !== 'number')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function isCacheStale(cache, intervalMs = CHECK_INTERVAL_MS) {
+    if (!cache)
+        return true;
+    return Date.now() - cache.checkedAt > intervalMs;
+}
+// eslint-disable-next-line no-control-regex
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+function stripAnsi(str) {
+    return str.replace(ANSI_PATTERN, '');
+}
+function formatNotification(current, latest) {
+    const npmUrl = `https://www.npmjs.com/package/${PACKAGE_NAME}`;
+    const lines = [
+        '',
+        `  Update available ${chalk_1.default.gray(current)} ${chalk_1.default.gray('→')} ${chalk_1.default.greenBright(latest)}`,
+        `  ${chalk_1.default.cyan(npmUrl)}`,
+        '',
+        `  Run ${chalk_1.default.bold('integration-cli upgrade')} to update`,
+        '',
+    ];
+    const maxLen = Math.max(...lines.map(line => stripAnsi(line).length));
+    const border = chalk_1.default.yellowBright;
+    const boxLines = [
+        border('  ┌' + '─'.repeat(maxLen) + '┐'),
+        ...lines.map(line => {
+            const padding = maxLen - stripAnsi(line).length;
+            return border('  │') + line + ' '.repeat(padding) + border('│');
+        }),
+        border('  └' + '─'.repeat(maxLen) + '┘'),
+    ];
+    return '\n' + boxLines.join('\n') + '\n';
+}
+function spawnBackgroundCheck(deps) {
+    const cacheDir = path_1.default.dirname(deps.cacheFile);
+    const script = `
+    const https = require('https');
+    const fs = require('fs');
+
+    const cacheDir = ${JSON.stringify(cacheDir)};
+    const cacheFile = ${JSON.stringify(deps.cacheFile)};
+
+    const url = 'https://registry.npmjs.org/${PACKAGE_NAME.replace('/', '%2f')}';
+
+    const req = https.get(url, { headers: { Accept: 'application/vnd.npm.install-v1+json' } }, (res) => {
+      if (res.statusCode !== 200) return;
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const pkg = JSON.parse(data);
+          const latest = pkg['dist-tags']?.latest;
+          if (!latest) return;
+          fs.mkdirSync(cacheDir, { recursive: true });
+          fs.writeFileSync(cacheFile, JSON.stringify({ latest, checkedAt: Date.now() }));
+        } catch {}
+      });
+    });
+    req.on('error', () => {});
+    req.setTimeout(10000, () => { req.destroy(); });
+  `;
+    const child = deps.spawn(process.execPath, ['-e', script], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.unref();
+}
+function checkForUpdate(currentVersion, overrides) {
+    try {
+        // Skip during upgrade command — it handles its own version messaging
+        if (process.argv[2] === 'upgrade')
+            return;
+        // Skip in non-interactive environments (CI, tests)
+        if (process.env.CI)
+            return;
+        const deps = { ...getDefaultDeps(), ...overrides };
+        const cache = readCache(deps.cacheFile);
+        // Auto-upgrade if we have a cached newer version
+        if (cache && isNewerVersion(cache.latest, currentVersion)) {
+            try {
+                deps.log(`Upgrading integration-cli ${currentVersion} → ${cache.latest}...`);
+                deps.upgrade();
+                deps.log(`Upgraded! The new version will be used on your next command.`);
+            }
+            catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
+                deps.log(chalk_1.default.yellow(`  Auto-upgrade failed: ${reason}`));
+                deps.log(formatNotification(currentVersion, cache.latest));
+            }
+        }
+        // Spawn background check if cache is stale
+        if (isCacheStale(cache)) {
+            spawnBackgroundCheck(deps);
+        }
+    }
+    catch {
+        // Never let update checking break the CLI
+    }
+}

package/dist/src/services/integrationsPlatformClient.d.ts

@@ -328,10 +328,14 @@ export declare function getCredentials({ pagination, filters, }?: {
         unitoUserId?: string;
         /** The id of the credential account for which this credential belongs to. */
         credentialAccountId?: string;
+        /** The credential was created after the provided date. */
+        createdAfter?: string;
         /** The last access to the credential account occured before the provided date. */
         lastCredentialAccountAccessAtBefore?: string;
         /** The first failure to access the credential account occured after the provided date. */
         firstFailedCredentialAccountAccessAtAfter?: string;
+        /** Whether to filter archived credentials. */
+        isArchived?: boolean;
     };
 }, opts?: Oazapfts.RequestOpts): Promise<Pagination & {
     /** The credentials. */

package/dist/src/services/oauth2.d.ts

@@ -40,6 +40,7 @@ declare class OAuth2Service {
     private tokenRequestParameters;
     private refreshRequestParameters;
     private credentialPayload;
+    private legacyRedirectUrl;
     /**
      * Constructs an instance of OAuthHelper.
      * @param clientId The client ID for your OAuth application.
@@ -49,6 +50,12 @@ declare class OAuth2Service {
      * @param providerTokenUrl The URL for the token endpoint of the provider.
      */
     constructor(authorizationInfo: Oauth2Payload, environment?: Environment, credentialPayload?: Record<string, unknown>);
+    /**
+     * Returns the redirect URI for the OAuth2 flow.
+     * When legacyRedirectUrl is configured, uses that URL (routed through maestro).
+     * Otherwise, uses the standard platformServer callback URL.
+     */
+    private get redirectUri();
     /**
      * Initiate the authorization flow and redirects the user to the provider's authorization page.
      */

package/dist/src/services/oauth2.js

@@ -32,6 +32,7 @@ class OAuth2Service {
     tokenRequestParameters;
     refreshRequestParameters;
     credentialPayload;
+    legacyRedirectUrl;
     /**
      * Constructs an instance of OAuthHelper.
      * @param clientId The client ID for your OAuth application.
@@ -41,7 +42,7 @@ class OAuth2Service {
      * @param providerTokenUrl The URL for the token endpoint of the provider.
      */
     constructor(authorizationInfo, environment = globalConfiguration_1.Environment.Production, credentialPayload) {
-        const { clientId, clientSecret, authorizationUrl, scopes, tokenUrl, grantType, requestContentType, refreshRequestParameters, tokenRequestParameters, } = authorizationInfo;
+        const { clientId, clientSecret, authorizationUrl, scopes, tokenUrl, grantType, requestContentType, refreshRequestParameters, tokenRequestParameters, legacyRedirectUrl, } = authorizationInfo;
         this.clientId = clientId;
         this.clientSecret = clientSecret;
         this.providerAuthorizationUrl = authorizationUrl;
@@ -51,12 +52,22 @@ class OAuth2Service {
         this.requestContentType = requestContentType ?? configurationTypes_1.RequestContentType.URL_ENCODED;
         this.tokenRequestParameters = tokenRequestParameters;
         this.refreshRequestParameters = refreshRequestParameters;
+        this.legacyRedirectUrl = legacyRedirectUrl;
         this.environment = environment;
         this.credentialPayload = credentialPayload;
         if (!Object.values(configurationTypes_1.RequestContentType).includes(this.requestContentType)) {
             throw new errors_1.UnsupportedContentTypeError(`Request content type not supported: ${this.requestContentType}`);
         }
     }
+    /**
+     * Returns the redirect URI for the OAuth2 flow.
+     * When legacyRedirectUrl is configured, uses that URL (routed through maestro).
+     * Otherwise, uses the standard platformServer callback URL.
+     */
+    get redirectUri() {
+        return (this.legacyRedirectUrl ??
+            `${IntegrationsPlatformClient.Servers[this.environment]}/credentials/new/oauth2/callback`);
+    }
     /**
      * Initiate the authorization flow and redirects the user to the provider's authorization page.
      */
@@ -71,12 +82,18 @@ class OAuth2Service {
         if (this.scopes) {
             authorizationParams.set('scope', this.scopes.join(' '));
         }
-        const state = Buffer.from(JSON.stringify({
+        const statePayload = {
             cliCallbackUrl: `${this.serverUrl}/oauth2/callback`,
-        })).toString('base64');
+            // When using legacyRedirectUrl, the callback is routed through maestro first.
+            // maestro checks for redirectToIPS in state and forwards to platformServer's oauth2Callback,
+            // which then detects cliCallbackUrl and forwards to the CLI via ngrok.
+            // TLDR: redirectToIPS makes maestro act as a pass-through relay instead of handling the callback itself.
+            ...(this.legacyRedirectUrl ? { redirectToIPS: 'true' } : {}),
+        };
+        const state = Buffer.from(JSON.stringify(statePayload)).toString('base64');
         authorizationParams.set('state', state);
         authorizationParams.set('response_type', 'code');
-        authorizationParams.set('redirect_uri', `${IntegrationsPlatformClient.Servers[this.environment]}/credentials/new/oauth2/callback-cli`);
+        authorizationParams.set('redirect_uri', this.redirectUri);
         const delimiter = this.providerAuthorizationUrl.includes('?') ? '&' : '?';
         const authorizationUrlTemplate = `${this.providerAuthorizationUrl}${delimiter}${authorizationParams.toString()}`;
         const authorizationUrl = (0, template_1.expandTemplate)(authorizationUrlTemplate, {
@@ -119,7 +136,7 @@ class OAuth2Service {
             ])),
             grant_type: this.grantType,
             code: req.query.code,
-            redirect_uri: `${IntegrationsPlatformClient.Servers[this.environment]}/credentials/new/oauth2/callback-cli`,
+            redirect_uri: this.redirectUri,
             ...(this.clientId && { client_id: this.clientId }),
             ...(this.clientSecret && { client_secret: this.clientSecret }),
         };
@@ -235,7 +252,7 @@ class OAuth2Service {
             bodyData.client_assertion = this.clientSecret;
             bodyData.assertion = refreshToken;
             bodyData.client_assertion_type = 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer';
-            bodyData.redirect_uri = `${IntegrationsPlatformClient.Servers[this.environment]}/credentials/new/oauth2/callback-cli`;
+            bodyData.redirect_uri = `${IntegrationsPlatformClient.Servers[this.environment]}/credentials/new/oauth2/callback`;
         }
         const templateVariables = structuredClone(this.credentialPayload ?? {});
         templateVariables.clientId ??= this.clientId;

package/dist/test/helpers/init.js

@@ -2,5 +2,6 @@
 const path = require('path');
 process.env.TS_NODE_PROJECT = path.resolve('test/tsconfig.json');
 process.env.NODE_ENV = 'development';
+process.env.CI = '1';
 global.oclif = global.oclif || {};
 global.oclif.columns = 80;

package/dist/test/hooks/updateNotifier.test.d.ts

@@ -0,0 +1 @@
+export {};