@swell/cli 2.9.19 → 2.9.21

package/dist/commands/app/install.d.ts

@@ -3,6 +3,7 @@ export default class AppInstall extends RemoteAppCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        conflicts: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         env: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         store: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         version: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;

package/dist/commands/app/install.js

@@ -17,6 +17,10 @@ Without a store specified, install the app in the Live environment of the curren
         'swell app install -v 1.0.0 -s my-store-id',
     ];
     static flags = {
+        conflicts: Flags.string({
+            description: 'how to handle apps and integrations already using the same services',
+            options: ['ignore', 'disable'],
+        }),
         env: Flags.string({
             char: 'e',
             description: 'target environment to install the app, defaults to live',
@@ -42,7 +46,7 @@ Without a store specified, install the app in the Live environment of the curren
     static summary = 'Install an existing app in another store environment.';
     async run() {
         const { flags } = await this.parse(AppInstall);
-        const { env, store, version } = flags;
+        const { conflicts, env, store, version } = flags;
         this.app = await this.getAppWithConfig();
         const versions = await this.getVersions(version);
         if (versions.length === 0) {
@@ -102,6 +106,15 @@ Without a store specified, install the app in the Live environment of the curren
         if (!shouldContinue) {
             return;
         }
+        const noConflicts = await this.confirmIntegrationConflicts(this.app?.integrations || [], {
+            action: 'installing',
+            conflictsFlag: conflicts,
+            deferDisable: true,
+            excludeAppId: this.app.id,
+        });
+        if (!noConflicts) {
+            return;
+        }
         const spinner = ora();
         this.log();
         // install or update app depending on whether it's already installed
@@ -120,6 +133,11 @@ Without a store specified, install the app in the Live environment of the curren
         }
         else {
             spinner.succeed(`${existingInstalledApp?.id ? 'Update' : 'Install'} complete.\n`);
+            // Only once the install succeeded, so a failure leaves the store as is.
+            // After the install spinner stops, so the two don't garble each other
+            if (!(await this.disablePendingConflicts())) {
+                this.log(`${style.logStatus('!')} ${style.appConfigValue(this.app.name)} is now active alongside the conflicting apps and integrations. Disable them in your dashboard.\n`);
+            }
             this.log(`Manage app settings in your dashboard at ${style.link(this.dashboardUrl({ flags: { env: envToInstall } }, storeToInstall))}.`);
         }
     }

package/dist/commands/app/push.d.ts

@@ -14,5 +14,18 @@ export default class AppPush extends PushAppCommand {
         filePath: string;
         relativePath: string;
     };
+    /**
+     * Conflicts are only worth raising when this push is what puts the app's
+     * `integrations` on the store: the first push, or one that changes them.
+     * Re-asking on every unrelated push would train developers to skip it.
+     *
+     * Runs before the app is created or updated, so backing out leaves the
+     * store as it was. Choosing to disable is deferred until the app exists.
+     *
+     * @param conflictsFlag pre-answers the prompt for a scripted run
+     * @param file the file or directory a scoped push targets, if any
+     * @returns whether to go ahead with the push
+     */
+    confirmPushConflicts(conflictsFlag?: string, file?: string): Promise<boolean>;
     run(): Promise<void>;
 }

package/dist/commands/app/push.js

@@ -1,6 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import * as path from 'node:path';
-import { affectsFrontendDeployment, AllConfigPaths, filePathExistsAsync, isPathDirectory, } from '../../lib/apps/index.js';
+import { affectsFrontendDeployment, AllConfigPaths, filePathExistsAsync, isPathDirectory, sameIntegrations, } from '../../lib/apps/index.js';
+import { default as localConfig } from '../../lib/config.js';
 import style from '../../lib/style.js';
 import { PushAppCommand } from '../../push-app-command.js';
 export default class AppPush extends PushAppCommand {
@@ -37,6 +38,10 @@ ${Object.values(AllConfigPaths)
         'swell app push frontend --no-deploy',
     ];
     static flags = {
+        conflicts: Flags.string({
+            description: 'how to handle apps and integrations already using the same services',
+            options: ['ignore', 'disable'],
+        }),
         force: Flags.boolean({
             default: false,
             description: 'force push all configurations',
@@ -61,10 +66,56 @@ ${Object.values(AllConfigPaths)
         }
         return { filePath, relativePath };
     }
+    /**
+     * Conflicts are only worth raising when this push is what puts the app's
+     * `integrations` on the store: the first push, or one that changes them.
+     * Re-asking on every unrelated push would train developers to skip it.
+     *
+     * Runs before the app is created or updated, so backing out leaves the
+     * store as it was. Choosing to disable is deferred until the app exists.
+     *
+     * @param conflictsFlag pre-answers the prompt for a scripted run
+     * @param file the file or directory a scoped push targets, if any
+     * @returns whether to go ahead with the push
+     */
+    async confirmPushConflicts(conflictsFlag, file) {
+        const integrations = this.swellConfig.store?.integrations || [];
+        const klass = this.ctor;
+        // Nothing declared locally means nothing to contend over, including the
+        // case where a push removes the field
+        if (integrations.length === 0) {
+            return true;
+        }
+        // Look up the app and its conflicts in the environment being pushed to,
+        // not whatever the API client defaults to
+        const currentStore = localConfig.getDefaultStore();
+        await this.ensureLoggedIn();
+        await this.api.setStoreEnv(currentStore, klass.orientation.env);
+        const app = await this.getAppWithConfig('').catch(() => null);
+        // An app owned by another client isn't the one being pushed to:
+        // ensureAppExists() creates a new one on this store in its place
+        const isForeignApp = Boolean(app?.client_id && app.client_id !== currentStore);
+        // A scoped push leaves the app's integrations as they are, unless it has
+        // to create the app, so there is nothing new to contend over
+        if (file && !isForeignApp) {
+            return true;
+        }
+        if (app &&
+            !isForeignApp &&
+            sameIntegrations(app.integrations, integrations)) {
+            return true;
+        }
+        return this.confirmIntegrationConflicts(integrations, {
+            action: 'pushing',
+            conflictsFlag,
+            deferDisable: true,
+            excludeAppId: isForeignApp ? undefined : app?.id,
+        });
+    }
     async run() {
         const { args, flags } = await this.parse(AppPush);
         const { file } = args;
-        const { force } = flags;
+        const { conflicts, force } = flags;
         const noDeploy = flags['no-deploy'];
         if (this.swellConfig.store?.type === 'theme') {
             await this.config.runCommand('theme:push', [
@@ -75,9 +126,15 @@ ${Object.values(AllConfigPaths)
             return;
         }
         await this.logOrientation();
+        if (!(await this.confirmPushConflicts(conflicts, file))) {
+            return;
+        }
         if (!(await this.ensureAppExists(file))) {
             return;
         }
+        if (!(await this.disablePendingConflicts())) {
+            return;
+        }
         if (file) {
             const { filePath, relativePath } = this.resolvePushPaths(file, flags['app-path']);
             // Push individual files if not referring to the whole app path

package/dist/lib/apps/index.d.ts

@@ -50,6 +50,7 @@ export interface App {
         date_created: string;
         id: string;
     };
+    integrations?: string[];
     kind?: string;
     logo_icon?: unknown;
     name?: string;
@@ -90,10 +91,31 @@ export interface App {
     use_cases?: string[];
     version?: string;
 }
+/**
+ * Whether two `integrations` declarations name the same services. Order and
+ * duplicates do not matter — only which services are claimed.
+ *
+ * @param a one declaration
+ * @param b the other
+ * @returns whether they claim the same services
+ */
+export declare function sameIntegrations(a: string[] | undefined, b: string[] | undefined): boolean;
+/**
+ * Something on a store already using a service an app declares in its
+ * swell.json `integrations` — either a Swell integration or another installed
+ * app. Reported by the admin backend's conflict check.
+ */
+export interface AppConflict {
+    id: string;
+    integrations?: string[];
+    name?: string;
+    type: 'app' | 'integration';
+}
 export declare enum SwellJsonFields {
     DESCRIPTION = "description",
     EXTENSIONS = "extensions",
     ID = "id",
+    INTEGRATIONS = "integrations",
     KIND = "kind",
     NAME = "name",
     PERMISSIONS = "permissions",

package/dist/lib/apps/index.js

@@ -7,11 +7,25 @@ import { AppConfig } from './app-config.js';
 export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
 export { affectsFrontendDeployment, allBaseFilesInDir, allConfigDirsPaths, allConfigFilesInDir, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, globAllFilesByPath, isPathDirectory, toPosixPath, } from './paths.js';
 export const PUSH_CONCURRENCY = 3;
+/**
+ * Whether two `integrations` declarations name the same services. Order and
+ * duplicates do not matter — only which services are claimed.
+ *
+ * @param a one declaration
+ * @param b the other
+ * @returns whether they claim the same services
+ */
+export function sameIntegrations(a, b) {
+    const left = new Set(a || []);
+    const right = new Set(b || []);
+    return (left.size === right.size && [...left].every((value) => right.has(value)));
+}
 export var SwellJsonFields;
 (function (SwellJsonFields) {
     SwellJsonFields["DESCRIPTION"] = "description";
     SwellJsonFields["EXTENSIONS"] = "extensions";
     SwellJsonFields["ID"] = "id";
+    SwellJsonFields["INTEGRATIONS"] = "integrations";
     SwellJsonFields["KIND"] = "kind";
     SwellJsonFields["NAME"] = "name";
     SwellJsonFields["PERMISSIONS"] = "permissions";

package/dist/lib/create/tests/templates/mock-request.js

@@ -74,7 +74,7 @@ export function createMockRequest(options: MockRequestOptions = {}): SwellReques
   const req: Partial<SwellRequest> & { appId: string; storeId: string } = {
     originalRequest,
     context,
-    url,
+    url: new URL(url),
     method,
     headers: requestHeaders,
     referrer: originalRequest.referrer,

package/dist/lib/create/tests.js

@@ -3,7 +3,8 @@ import * as path from 'node:path';
 import { filePathExistsAsync, writeFile } from '../apps/index.js';
 import { envDtsTemplate, integrationTestTemplate, mockRequestTemplate, setupGlobalsTemplate, swellClientTemplate, tsconfigTemplate, unitTestTemplate, vitestConfigTemplate, } from './tests/templates/index.js';
 const TEST_DEV_DEPENDENCIES = {
-    '@cloudflare/vitest-pool-workers': 'latest',
+    // 0.13+ requires vitest 4 and drops the /config entry the vitest template imports
+    '@cloudflare/vitest-pool-workers': '0.12.x',
     vitest: '3.2.x',
     '@swell/app-types': 'latest',
 };

package/dist/remote-app-command.d.ts

@@ -1,7 +1,7 @@
 import { type Ora } from 'ora';
 import type { AppCommandOrientation } from './types/index.js';
 import { AppCommand } from './app-command.js';
-import { App, AppConfig, AppVersion } from './lib/apps/index.js';
+import { App, AppConfig, AppConflict, AppVersion } from './lib/apps/index.js';
 /**
  * Extends the AppCommand with methods that ease managing remote apps and
  * configurations.
@@ -12,6 +12,7 @@ export declare abstract class RemoteAppCommand extends AppCommand {
     app: App;
     appCreated: boolean;
     appType: string;
+    protected pendingConflicts?: AppConflict[];
     storefront?: any;
     storefrontLocalUrl?: string;
     themeSyncApp?: boolean;
@@ -26,6 +27,45 @@ export declare abstract class RemoteAppCommand extends AppCommand {
     getConfigData(configId: string): Promise<any>;
     protected getCreateUpdateApp(updateApp?: App | null, force?: boolean): Promise<App>;
     protected getInstalledApp(): Promise<any>;
+    /**
+     * Anything on the target store already using the services named by
+     * `integrations`. Answered by the admin backend so the CLI and the dashboard
+     * agree on what counts as a conflict.
+     *
+     * @param integrations services the app declares in swell.json
+     * @param excludeAppId app that must not be reported against itself
+     * @returns the conflicts, or none when the lookup fails
+     */
+    protected getAppConflicts(integrations: string[], excludeAppId?: string): Promise<AppConflict[]>;
+    /**
+     * Disable what confirmIntegrationConflicts() deferred, once the command is
+     * past the points where it could still back out.
+     *
+     * @returns whether they were all disabled
+     */
+    protected disablePendingConflicts(): Promise<boolean>;
+    /**
+     * Switch off every listed app and integration.
+     *
+     * @param conflicts what to disable
+     * @returns whether they were all disabled
+     */
+    protected disableAppConflicts(conflicts: AppConflict[]): Promise<boolean>;
+    /**
+     * List what already uses the services `integrations` names, and settle what
+     * to do about it. `conflictsFlag` pre-answers the prompt for a scripted run;
+     * cancelling is deliberately interactive-only.
+     *
+     * @param integrations services the app declares in swell.json
+     * @param options how to ask and what to leave out
+     * @returns whether to go ahead
+     */
+    protected confirmIntegrationConflicts(integrations: string[], { action, conflictsFlag, excludeAppId, deferDisable, }: {
+        action: string;
+        conflictsFlag?: string;
+        deferDisable?: boolean;
+        excludeAppId?: string;
+    }): Promise<boolean>;
     protected getLocalAppConfigs(): Promise<AppConfig[]>;
     protected getVersion(version?: null | string | undefined): Promise<AppVersion>;
     protected getVersions(version?: null | string | undefined): Promise<AppVersion[]>;

package/dist/remote-app-command.js

@@ -1,4 +1,4 @@
-import { confirm } from '@inquirer/prompts';
+import { confirm, select } from '@inquirer/prompts';
 import { inflect } from 'inflection';
 import sortBy from 'lodash/sortBy.js';
 import * as path from 'node:path';
@@ -24,6 +24,8 @@ export class RemoteAppCommand extends AppCommand {
     // Indicates the app was created during the command execution
     appCreated = false;
     appType = 'any';
+    // Conflicts the user chose to disable, held until the command commits
+    pendingConflicts;
     // API instance of the target storefront, if applicable
     storefront = null;
     // Indicates we are syncing with a local app frontend via proxy
@@ -258,6 +260,122 @@ export class RemoteAppCommand extends AppCommand {
         // check if app is already installed on store
         return this.api.get({ adminPath: `/client/apps/${this.app.id}` }, {});
     }
+    /**
+     * Anything on the target store already using the services named by
+     * `integrations`. Answered by the admin backend so the CLI and the dashboard
+     * agree on what counts as a conflict.
+     *
+     * @param integrations services the app declares in swell.json
+     * @param excludeAppId app that must not be reported against itself
+     * @returns the conflicts, or none when the lookup fails
+     */
+    async getAppConflicts(integrations, excludeAppId) {
+        if (integrations.length === 0) {
+            return [];
+        }
+        try {
+            const result = await this.api.post({ adminPath: '/client/conflicts' }, {
+                body: {
+                    exclude_app_id: excludeAppId,
+                    integrations,
+                },
+            });
+            return result?.conflicts || [];
+        }
+        catch {
+            // A conflict lookup that fails must not block the command
+            return [];
+        }
+    }
+    /**
+     * Disable what confirmIntegrationConflicts() deferred, once the command is
+     * past the points where it could still back out.
+     *
+     * @returns whether they were all disabled
+     */
+    async disablePendingConflicts() {
+        const conflicts = this.pendingConflicts;
+        this.pendingConflicts = undefined;
+        return conflicts ? this.disableAppConflicts(conflicts) : true;
+    }
+    /**
+     * Switch off every listed app and integration.
+     *
+     * @param conflicts what to disable
+     * @returns whether they were all disabled
+     */
+    async disableAppConflicts(conflicts) {
+        const spinner = ora();
+        spinner.start('Disabling conflicting apps and integrations...');
+        try {
+            await this.api.post({ adminPath: '/client/conflicts/resolve' }, {
+                body: {
+                    apps: conflicts
+                        .filter(({ type }) => type === 'app')
+                        .map(({ id }) => id),
+                    integrations: conflicts
+                        .filter(({ type }) => type === 'integration')
+                        .map(({ id }) => id),
+                },
+            });
+        }
+        catch (error) {
+            spinner.fail('Could not disable the conflicting apps and integrations.');
+            this.logError(error.message);
+            return false;
+        }
+        spinner.succeed('All conflicting apps and integrations were disabled.');
+        return true;
+    }
+    /**
+     * List what already uses the services `integrations` names, and settle what
+     * to do about it. `conflictsFlag` pre-answers the prompt for a scripted run;
+     * cancelling is deliberately interactive-only.
+     *
+     * @param integrations services the app declares in swell.json
+     * @param options how to ask and what to leave out
+     * @returns whether to go ahead
+     */
+    async confirmIntegrationConflicts(integrations, { action, conflictsFlag, excludeAppId, deferDisable, }) {
+        const conflicts = await this.getAppConflicts(integrations, excludeAppId);
+        if (conflicts.length === 0) {
+            return true;
+        }
+        this.log();
+        this.log(`${style.logStatus('!')} There are potential conflicts on this store:`);
+        for (const conflict of conflicts) {
+            const services = (conflict.integrations || []).join(', ');
+            this.log(`  ${style.appConfigValue(conflict.name || conflict.id)} (${conflict.type})${services ? ` — ${services}` : ''}`);
+        }
+        this.log();
+        const choice = conflictsFlag ||
+            (await select({
+                choices: [
+                    { name: 'Ignore all conflicts and continue', value: 'ignore' },
+                    {
+                        name: 'Disable all conflicting apps and integrations, then continue',
+                        value: 'disable',
+                    },
+                    { name: 'Cancel', value: 'cancel' },
+                ],
+                message: `How do you want to handle these before ${action}?`,
+            }));
+        if (choice === 'cancel') {
+            return false;
+        }
+        if (choice === 'disable') {
+            // Deferred so a command that can still back out doesn't leave the store's integrations switched off
+            if (deferDisable) {
+                this.pendingConflicts = conflicts;
+                return true;
+            }
+            return this.disableAppConflicts(conflicts);
+        }
+        // Ignoring is a decision worth showing, especially with --conflicts=ignore
+        // where nothing else marks that the conflicts were seen and waved through
+        this.log(`${style.logStatus('!')} Conflicts were ignored.`);
+        return true;
+    }
     async getLocalAppConfigs() {
         const promises = [];
         for (const { configFile, configType } of allConfigFilesPaths(this.appPath)) {

package/dist/types/index.d.ts

@@ -85,6 +85,7 @@ export interface App {
     type: string;
     private_id: string;
     public_id?: string;
+    integrations?: string[];
 }
 export interface Model {
     name: string;

package/oclif.manifest.json

@@ -1056,6 +1056,17 @@
           "multiple": false,
           "type": "option"
         },
+        "conflicts": {
+          "description": "how to handle apps and integrations already using the same services",
+          "name": "conflicts",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "ignore",
+            "disable"
+          ],
+          "type": "option"
+        },
         "env": {
           "char": "e",
           "description": "target environment to install the app, defaults to live",
@@ -1183,6 +1194,17 @@
           "multiple": false,
           "type": "option"
         },
+        "conflicts": {
+          "description": "how to handle apps and integrations already using the same services",
+          "name": "conflicts",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "ignore",
+            "disable"
+          ],
+          "type": "option"
+        },
         "force": {
           "description": "force push all configurations",
           "name": "force",
@@ -3572,5 +3594,5 @@
       ]
     }
   },
-  "version": "2.9.19"
+  "version": "2.9.21"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swell/cli",
-  "version": "2.9.19",
+  "version": "2.9.21",
   "type": "module",
   "description": "Swell's command line interface/utility",
   "keywords": [