@swell/cli 2.9.20 → 2.9.22

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,19 @@ 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>;
+    private exitIfFilesFailed;
 }

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
@@ -96,6 +153,7 @@ ${Object.values(AllConfigPaths)
                 }
                 this.log();
                 this.logDashboardUrl(flags);
+                this.exitIfFilesFailed();
                 return;
             }
         }
@@ -105,5 +163,12 @@ ${Object.values(AllConfigPaths)
             this.log();
         }
         this.logDashboardUrl(flags);
+        this.exitIfFilesFailed();
+    }
+    // A skipped file is a failed push, for scripts and CI too
+    exitIfFilesFailed() {
+        if (this.failedFiles.length > 0) {
+            this.error(`${this.failedFiles.length} file(s) failed to push: ${this.failedFiles.join(', ')}`);
+        }
     }
 }

package/dist/lib/apps/app-config.d.ts

@@ -45,6 +45,16 @@ export declare abstract class AppConfig {
     version?: string;
     constructor(attrs?: Partial<AppConfig>);
     load(): Promise<void>;
+    /**
+     * The hash push compares with the pushed config to skip unchanged files
+     * @returns {Promise<string | undefined>} the hash
+     */
+    protected contentHash(): Promise<string | undefined>;
+    /**
+     * Full path of the app directory this config belongs to
+     * @returns {string} the path
+     */
+    protected appRoot(): string;
     static create(attrs?: Partial<AppConfig>): Promise<AppConfig>;
     isRootConfig(configDir: string): boolean;
     postData(): Promise<any>;
@@ -88,6 +98,7 @@ export declare class AppConfigFunction extends AppConfig {
     hasValues: boolean;
     type: ConfigType;
     isRootFunction(): boolean;
+    protected contentHash(): Promise<string | undefined>;
     preparePostData(postData: any): Promise<any>;
 }
 export declare class AppConfigComponent extends AppConfig {

package/dist/lib/apps/app-config.js

@@ -3,9 +3,9 @@ import isEmpty from 'lodash/isEmpty.js';
 import { detectFilenameMime } from 'mime-detect';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { bundleFunction, bundleComponent, bundleWorkflow } from '../bundle.js';
+import { bundleFunction, bundleComponent, bundleWorkflow, getLocalInputs, } from '../bundle.js';
 import { analyzeFunctionSource, hasKindDiagnostic, workflowStaticConfigError, } from '../function-source-analysis.js';
-import { AllConfigPaths, ConfigType, filePathExistsAsync, hashFile, } from './index.js';
+import { AllConfigPaths, ConfigType, filePathExistsAsync, hashFile, hashString, } from './index.js';
 export class IgnoringFileError extends Error {
     constructor(message) {
         super(message);
@@ -83,11 +83,25 @@ export class AppConfig {
         if (await filePathExistsAsync(this.appPath)) {
             this.fileData = await fs.readFile(this.appPath);
             this.fileHash = hashFile(this.appPath, this.fileData, this.filePath);
-            this.hash = this.hash || this.fileHash;
+            this.hash = this.hash || (await this.contentHash());
             this.byteSize = this.fileData.length;
             this.mbSize = this.byteSize / 1024 / 1024;
         }
     }
+    /**
+     * The hash push compares with the pushed config to skip unchanged files
+     * @returns {Promise<string | undefined>} the hash
+     */
+    async contentHash() {
+        return this.fileHash;
+    }
+    /**
+     * Full path of the app directory this config belongs to
+     * @returns {string} the path
+     */
+    appRoot() {
+        return path.resolve(this.appPath, ...this.filePath.split('/').map(() => '..'));
+    }
     static async create(attrs = {}) {
         let instance;
         switch (attrs.type) {
@@ -263,6 +277,27 @@ export class AppConfigFunction extends AppConfig {
         return (this.isRootConfig('functions') &&
             (this.filePath.endsWith('.js') || this.filePath.endsWith('.ts')));
     }
+    // A function deploys as a bundle, so the hash includes the local files it
+    // imports: a change in shared code under functions/lib redeploys it
+    async contentHash() {
+        if (!this.isRootFunction() || !this.fileHash) {
+            return this.fileHash;
+        }
+        const appRoot = this.appRoot();
+        let inputs;
+        try {
+            inputs = await getLocalInputs(this.appPath, appRoot);
+        }
+        catch {
+            // Unknown until it compiles: push tries it and reports the error
+            return undefined;
+        }
+        const imports = inputs
+            .filter((input) => input !== this.filePath)
+            .sort()
+            .map((input) => hashFile(path.join(appRoot, input), undefined, input));
+        return hashString(this.fileHash, ...imports);
+    }
     async preparePostData(postData) {
         if (this.isRootFunction()) {
             try {

package/dist/lib/apps/frontend-package.js

@@ -3,7 +3,7 @@ import { execa } from 'execa';
 import { isIgnoredByIgnoreFiles } from 'globby';
 import { createHash } from 'node:crypto';
 import * as fs from 'node:fs/promises';
-import { createRequire } from 'node:module';
+import { createRequire, isBuiltin } from 'node:module';
 import * as os from 'node:os';
 import * as path from 'node:path';
 const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
@@ -155,13 +155,25 @@ export async function checkModuleGraph(pkg) {
                 name: 'retained-frontend-modules',
                 setup(builder) {
                     builder.onResolve({ filter: /.*/ }, (args) => {
-                        if (/^(?:node|cloudflare):/.test(args.path))
+                        // The provider validates runtime module names at upload, so a
+                        // scheme is never checked against the Node version running here.
+                        if (args.kind !== 'entry-point' &&
+                            (/^(?:node|cloudflare):/.test(args.path) || isBuiltin(args.path)))
                             return { path: args.path, external: true };
+                        // Like the runtime, resolve any other name, bare or relative,
+                        // against the importer's directory.
                         const name = args.kind === 'entry-point'
                             ? args.path
                             : path.posix.join(path.posix.dirname(args.importer), args.path);
-                        if (!modules.has(name))
-                            throw new Error(`Missing frontend Worker module: ${name}`);
+                        if (!modules.has(name)) {
+                            const from = args.importer
+                                ? ` (imported as "${args.path}" from "${args.importer}")`
+                                : '';
+                            const hint = args.importer && /^[\w@]/.test(args.path)
+                                ? '. npm dependencies must be bundled.'
+                                : '';
+                            throw new Error(`Missing frontend Worker module: ${name}${from}${hint}`);
+                        }
                         return { path: name, namespace: 'frontend' };
                     });
                     builder.onLoad({ filter: /.*/, namespace: 'frontend' }, (args) => {

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/bundle.d.ts

@@ -1,4 +1,12 @@
 import type { FunctionSourceAnalysis } from './function-source-analysis.js';
+/**
+ * Local source files an entry point imports, itself included, relative to
+ * rootDir. Packages are not followed: only the app's own files are listed.
+ * @param {string} entryPoint path of the entry point, relative to rootDir
+ * @param {string} rootDir directory the paths are relative to
+ * @returns {Promise<string[]>} paths of the imported files
+ */
+export declare function getLocalInputs(entryPoint: string, rootDir: string): Promise<string[]>;
 export declare function bundleFunction(filePath: string): Promise<any>;
 export declare function bundleWorkflow(filePath: string, analysis: FunctionSourceAnalysis): Promise<any>;
 export declare function bundleComponent(filePath: string): Promise<any>;

package/dist/lib/bundle.js

@@ -2,6 +2,27 @@ import * as esbuild from 'esbuild';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
+/**
+ * Local source files an entry point imports, itself included, relative to
+ * rootDir. Packages are not followed: only the app's own files are listed.
+ * @param {string} entryPoint path of the entry point, relative to rootDir
+ * @param {string} rootDir directory the paths are relative to
+ * @returns {Promise<string[]>} paths of the imported files
+ */
+export async function getLocalInputs(entryPoint, rootDir) {
+    const { metafile } = await esbuild.build({
+        absWorkingDir: rootDir,
+        bundle: true,
+        entryPoints: [entryPoint],
+        external: ['cloudflare:*'],
+        logLevel: 'silent',
+        metafile: true,
+        packages: 'external',
+        platform: 'node',
+        write: false,
+    });
+    return Object.keys(metafile.inputs);
+}
 export async function bundleFunction(filePath) {
     try {
         const buildResult = await esbuild.build({

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

@@ -46,6 +46,7 @@ export function createMockRequest(options: MockRequestOptions = {}): SwellReques
   } = options;
 
   const requestHeaders = new Headers(headers);
+  const requestQuery = { ...Object.fromEntries(new URL(url).searchParams), ...query };
   const originalRequest = new Request(url, {
     method,
     headers: requestHeaders,
@@ -88,40 +89,20 @@ export function createMockRequest(options: MockRequestOptions = {}): SwellReques
     apiHost: env.SWELL_API_BASE_URL || "",
     logParams: undefined,
     swell: swellClient as SwellAPI,
-    body: data,
-    data,
-    query,
+    rawBody: method === "GET" ? "" : JSON.stringify(data),
+    body: method === "GET" ? "" : { ...data },
+    data: { ...(method === "GET" ? {} : data), ...requestQuery },
+    query: requestQuery,
     initialize: async () => {},
-    parseJson: (input: string) => JSON.parse(input),
+    parseJson: (input: string) => {
+      try { return JSON.parse(input); } catch { return {}; }
+    },
     reject: (
       code: string,
       message: string,
       options: { status?: number } = {}
     ) => {
-      const status =
-        typeof options.status === "number" &&
-        options.status >= 400 &&
-        options.status < 500
-          ? options.status
-          : 422;
-      const error = new Error(
-        message || "Request rejected by function"
-      ) as Error & {
-        body: { $reject: { code: string; message: string; status: number } };
-        code: string;
-        status: number;
-      };
-      error.name = "SwellRejection";
-      error.code = code;
-      error.status = status;
-      error.body = {
-        $reject: {
-          code,
-          message: error.message,
-          status,
-        },
-      };
-      return error;
+      return new SwellRejection(code, message, options);
     },
     appValues: (idOrValues: string | SwellData, values?: SwellData) => {
       const targetAppId =

package/dist/lib/create/tests/templates/setup-globals.js

@@ -1,21 +1,6 @@
 export function setupGlobalsTemplate() {
     return `\
-class SwellErrorImpl extends Error {
-  status: number;
-  body?: unknown;
-
-  constructor(message: string | object, options: { status?: number } = {}) {
-    const text =
-      typeof message === "string"
-        ? message
-        : JSON.stringify(message, null, 2);
-
-    super(text);
-    this.name = "SwellError";
-    this.status = options.status ?? 500;
-    this.body = typeof message === "string" ? undefined : message;
-  }
-}
+import { SwellError } from "@swell/apps-sdk";
 
 class SwellRejectionImpl extends Error {
   status: number;
@@ -51,7 +36,7 @@ class SwellRejectionImpl extends Error {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-(globalThis as any).SwellError = SwellErrorImpl;
+(globalThis as any).SwellError = SwellError;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 (globalThis as any).SwellRejection = SwellRejectionImpl;
 

package/dist/lib/create/tests/templates/unit-test.js

@@ -14,7 +14,7 @@ describe("Unit test examples", () => {
     });
 
     expect(req.data.product_id).toBe("prod_123");
-    expect(req.session.account_id).toBe("acc_456");
+    expect(req.session?.account_id).toBe("acc_456");
   });
 
   it("mocks swell.get", async () => {

package/dist/lib/create/tests.js

@@ -7,6 +7,7 @@ const TEST_DEV_DEPENDENCIES = {
     '@cloudflare/vitest-pool-workers': '0.12.x',
     vitest: '3.2.x',
     '@swell/app-types': 'latest',
+    '@swell/apps-sdk': '2.0.0-alpha.0',
 };
 async function writeTextFile(filePath, contents, overwrite) {
     if (!overwrite && (await filePathExistsAsync(filePath))) {
@@ -52,6 +53,9 @@ async function updatePackageJson(appPath) {
     if (!devDeps['@swell/app-types'] && !deps['@swell/app-types']) {
         devDeps['@swell/app-types'] = TEST_DEV_DEPENDENCIES['@swell/app-types'];
     }
+    if (!devDeps['@swell/apps-sdk'] && !deps['@swell/apps-sdk']) {
+        devDeps['@swell/apps-sdk'] = TEST_DEV_DEPENDENCIES['@swell/apps-sdk'];
+    }
     pkg.devDependencies = devDeps;
     const scripts = (pkg.scripts || {});
     scripts.test = scripts.test || 'vitest run';

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

@@ -48,6 +48,13 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
     }, shouldChoose?: boolean): Promise<App | undefined>;
     getExistingApp(appId: string): Promise<App>;
     getFrontendDeploymentHash(): Promise<string | undefined>;
+    /**
+     * Files outside frontend/ that the worker's entry point imports, relative to
+     * the app path. Only a local entry point set by `main` in the wrangler
+     * config is followed; frameworks that build their own entry are not.
+     * @returns {Promise<string[]>} paths of the imported files
+     */
+    getFrontendSharedInputs(): Promise<string[]>;
     getFrontendProjectType(required?: boolean): Promise<FrontendProjectType | null>;
     getStorefrontToPull(args?: {
         appId?: string;

package/dist/push-app-command.js

@@ -8,9 +8,10 @@ import ora from 'ora';
 import { default as swellConfig } from './lib/app-config.js';
 import { buildFrontendPackage, getManagedFrontendFramework, } from './lib/apps/frontend-package.js';
 import { warnFrontendRouteCollisions } from './lib/apps/frontend-routes.js';
-import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, CUSTOM_FRAMEWORK_SLUG, appConfigFromFile, filePathExistsAsync, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, getProjectCommands, globAllFilesByPath, hashString, isPathDirectory, toPosixPath, } from './lib/apps/index.js';
+import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, CUSTOM_FRAMEWORK_SLUG, appConfigFromFile, filePathExistsAsync, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, getProjectCommands, globAllFilesByPath, hashFile, hashString, isPathDirectory, toPosixPath, } from './lib/apps/index.js';
 import { getGlobIgnorePathsChecker } from './lib/apps/paths.js';
 import { slugFromApp } from './lib/apps/slug.js';
+import { getLocalInputs } from './lib/bundle.js';
 import { default as localConfig } from './lib/config.js';
 import { toAppId } from './lib/create/index.js';
 import { detectPackageManager, transformCommand, } from './lib/package-manager.js';
@@ -21,6 +22,27 @@ import { RemoteAppCommand } from './remote-app-command.js';
 const PUSH_CONCURRENCY = 3;
 const WATCH_WINDOW_MS = 100;
 const DEV_SERVER_FALLBACK_PORT = 3000;
+const WRANGLER_CONFIG_FILES = [
+    'wrangler.jsonc',
+    'wrangler.json',
+    'wrangler.toml',
+];
+/**
+ * The `main` entry point of a wrangler config (JSON, JSONC or TOML)
+ * @param {string} frontendPath directory of the wrangler config
+ * @returns {string | undefined} the entry point, relative to frontendPath
+ */
+function readWranglerMain(frontendPath) {
+    for (const name of WRANGLER_CONFIG_FILES) {
+        const configPath = path.join(frontendPath, name);
+        if (fs.existsSync(configPath)) {
+            // "main": "src/index.ts" in JSON, main = "src/index.ts" in TOML
+            return fs
+                .readFileSync(configPath, 'utf8')
+                .match(/^\s*"?main"?\s*[:=]\s*"([^"]+)"/m)?.[1];
+        }
+    }
+}
 export class PushAppCommand extends RemoteAppCommand {
     frontendPath = '';
     hasLoggedLocalPreviewUrl = false;
@@ -466,9 +488,34 @@ export class PushAppCommand extends RemoteAppCommand {
         if (frontendHashes.length > 0) {
             const packageHash = localConfigs.find((config) => config.filePath === 'package.json')?.hash;
             frontendHashes += `|${packageHash}`;
+            // Shared code the worker imports from outside frontend/, e.g. functions/lib
+            for (const input of await this.getFrontendSharedInputs()) {
+                frontendHashes += `|${hashFile(path.join(this.appPath, input), undefined, input)}`;
+            }
         }
         return frontendHashes.length > 0 ? hashString(frontendHashes) : undefined;
     }
+    /**
+     * Files outside frontend/ that the worker's entry point imports, relative to
+     * the app path. Only a local entry point set by `main` in the wrangler
+     * config is followed; frameworks that build their own entry are not.
+     * @returns {Promise<string[]>} paths of the imported files
+     */
+    async getFrontendSharedInputs() {
+        const main = readWranglerMain(path.join(this.appPath, 'frontend'));
+        const entry = main && toPosixPath(path.join('frontend', main));
+        if (!entry || !fs.existsSync(path.join(this.appPath, entry))) {
+            return [];
+        }
+        try {
+            const inputs = await getLocalInputs(entry, this.appPath);
+            return inputs.filter((input) => !input.startsWith('frontend/')).sort();
+        }
+        catch {
+            // Build errors surface when wrangler deploys the worker
+            return [];
+        }
+    }
     async getFrontendProjectType(required = true) {
         this.frontendPath = path.join(this.appPath, 'frontend');
         const frontendExists = await filePathExistsAsync(this.frontendPath);

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,8 @@ export declare abstract class RemoteAppCommand extends AppCommand {
     app: App;
     appCreated: boolean;
     appType: string;
+    failedFiles: string[];
+    protected pendingConflicts?: AppConflict[];
     storefront?: any;
     storefrontLocalUrl?: string;
     themeSyncApp?: boolean;
@@ -26,6 +28,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,11 +1,11 @@
-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';
 import { default as ora } from 'ora';
 import { AppCommand } from './app-command.js';
 import { readRcFile, writeRcFile } from './lib/app-config.js';
-import { AppConfig, ConfigType, FunctionProcessingError, IgnoringFileError, SwellJsonFields, allBaseFilesInDir, allConfigFilesPaths, appConfigFromFile, batchAppFilesByType, deleteFile, hashFile, writeFile, writeJsonFile, PUSH_CONCURRENCY, } from './lib/apps/index.js';
+import { AppConfig, ConfigType, FunctionProcessingError, IgnoringFileError, SwellJsonFields, allBaseFilesInDir, allConfigFilesPaths, appConfigFromFile, batchAppFilesByType, deleteFile, writeFile, writeJsonFile, PUSH_CONCURRENCY, } from './lib/apps/index.js';
 import { default as localConfig } from './lib/config.js';
 import { getAppFrontendHost, getLocalFrontendHost, getLoginHost, getStorefrontFrontendHost, } from './lib/constants.js';
 import { toAppId } from './lib/create/index.js';
@@ -24,6 +24,10 @@ export class RemoteAppCommand extends AppCommand {
     // Indicates the app was created during the command execution
     appCreated = false;
     appType = 'any';
+    // Files skipped because they could not be read or compiled
+    failedFiles = [];
+    // 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 +262,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)) {
@@ -380,11 +500,11 @@ export class RemoteAppCommand extends AppCommand {
                     return true;
                 try {
                     const localConfig = localBatchConfigs.find((config) => config.filePath === batchConfig.filePath);
-                    if (localConfig) {
-                        const hash = hashFile(batchConfig.appPath, localConfig.fileData, batchConfig.filePath);
-                        if (hash === batchConfig.hash) {
-                            return false;
-                        }
+                    // Functions pushed by earlier CLI versions carry the plain file hash
+                    if (localConfig &&
+                        (localConfig.hash === batchConfig.hash ||
+                            localConfig.fileHash === batchConfig.hash)) {
+                        return false;
                     }
                 }
                 catch {
@@ -557,11 +677,13 @@ export class RemoteAppCommand extends AppCommand {
             if (error instanceof IgnoringFileError) {
                 log &&
                     spinner.fail(`Ignoring file: ${error.message} in ${config.filePath}`);
+                this.failedFiles.push(config.filePath);
                 return;
             }
             if (error instanceof FunctionProcessingError) {
                 log &&
                     spinner.fail(`${error.message} ${error.cause?.message?.toLowerCase()}`);
+                this.failedFiles.push(config.filePath);
                 return;
             }
             log && spinner.fail(error.message);

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.20"
+  "version": "2.9.22"
 }

package/package.json

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