@swell/cli 2.9.30 → 2.9.32

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

@@ -0,0 +1,25 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppAction extends RemoteAppCommand {
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        collection: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        ids: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        live: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        record: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        settings: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        source: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        values: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        view: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+    private findAction;
+    private findFunctionId;
+    private getActionParams;
+    private parseValues;
+}

package/dist/commands/app/action.js

@@ -0,0 +1,233 @@
+import { Args, Flags } from '@oclif/core';
+import ora from 'ora';
+import { functionSlug, getContentActions, getModalFieldIds, getSettingsActions, } from '../../lib/apps/actions.js';
+import style from '../../lib/style.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+const UNAVAILABLE_CODES = new Set([
+    'notfound',
+    'connrefused',
+    'proxy_notfound',
+]);
+export default class AppAction extends RemoteAppCommand {
+    static args = {
+        id: Args.string({
+            description: 'id of the action, as declared in content or settings',
+            required: true,
+        }),
+    };
+    static description = `Runs a function action of the app as the logged-in dashboard user, the way a click in the dashboard does. The action is looked up in the app's content and settings as pushed.
+
+A record action or action field needs ${style.command('--record')}, and a bulk action ${style.command('--ids')} or ${style.command('--all')}. Pass the values of the action's modal with ${style.command('--values')}. When the same id is declared in more than one place, pick one with ${style.command('--collection')}, ${style.command('--view')}, ${style.command('--settings')} or ${style.command('--source')}.`;
+    static examples = [
+        'swell app action sync_now',
+        'swell app action ship --record 64e8dfb633c44a0039477251',
+        `swell app action ship --record 64e8dfb633c44a0039477251 --values '{"carrier":"ups"}'`,
+        'swell app action ship-selected --ids 64e8dfb633c44a0039477251,64e8dfb633c44a0039477252',
+        'swell app action ship --collection shipments --view edit --record 64e8dfb633c44a0039477251',
+        'swell app action export --source bulk --all',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            description: 'run a bulk action on all records its view lists with no filters set, as selecting all in the dashboard does',
+            exclusive: ['ids'],
+        }),
+        collection: Flags.string({
+            description: "collection of the content that declares the action, or the model's name for a collection of the app",
+        }),
+        ids: Flags.string({
+            description: 'comma-separated ids of the records a bulk action runs on',
+            exclusive: ['all'],
+        }),
+        live: Flags.boolean({
+            default: false,
+            description: 'run in the live environment instead of test',
+        }),
+        record: Flags.string({
+            description: 'id of the record a record action or action field runs on',
+        }),
+        settings: Flags.string({
+            description: 'name of the settings that declare the action',
+        }),
+        source: Flags.string({
+            description: "where the action is declared: list or record (a view's actions), bulk (a view's bulk actions), field (an action field) or settings (a settings action)",
+            options: ['list', 'record', 'bulk', 'field', 'settings'],
+        }),
+        values: Flags.string({
+            description: "values of the action's modal fields, as JSON",
+        }),
+        view: Flags.string({
+            description: 'id of the content view that declares the action',
+        }),
+    };
+    static summary = 'Run an app action from the command line.';
+    async run() {
+        const { args, flags } = await this.parse(AppAction);
+        const values = flags.values === undefined ? undefined : this.parseValues(flags.values);
+        if (!flags.live) {
+            await this.api.setEnv('test');
+        }
+        this.app = await this.getAppWithConfig();
+        const action = await this.findAction(args.id, flags);
+        const $action = this.getActionParams(action, { ...flags, values });
+        const functionId = await this.findFunctionId(action.function);
+        const name = style.appConfigValue(action.id);
+        const spinner = ora();
+        spinner.start(`Running action ${name}...`);
+        const result = await this.handleRequestErrors(async () => this.api.put({ adminPath: `/data/:functions/${functionId}` }, { body: { $action } }), () => spinner.fail(`Action ${action.id} failed`));
+        if (!(result?.status >= 200 && result.status < 300)) {
+            spinner.fail(`Action ${name} failed`);
+            this.error(getErrorMessage(result, name));
+        }
+        // A workflow runs in the background, so the platform answers with the run
+        // it started
+        const run = result.response?.run;
+        if (result.status === 202 && run?.id && run.workflow_name) {
+            spinner.succeed(`Started run ${style.appConfigValue(run.id)} of workflow ${style.appConfigValue(run.workflow_name)}`);
+            return;
+        }
+        spinner.succeed(`Ran action ${name}`);
+        if (result.response !== undefined) {
+            this.log(JSON.stringify(result.response, null, 2));
+        }
+    }
+    async findAction(id, flags) {
+        const [contents, settings] = await Promise.all([
+            this.api.get({ adminPath: '/data/:content' }, { query: { app_id: this.app.id, limit: 1000 } }),
+            this.api.get({ adminPath: `/data/:settings/${this.app.id}` }),
+        ]);
+        const actions = [
+            ...(contents?.results || []).flatMap((content) => getContentActions(content).map((action) => ({
+                ...action,
+                collection: content.collection,
+                content_id: content.id,
+            }))),
+            ...Object.entries(settings?.content || {}).flatMap(([name, values]) => getSettingsActions(values, name)),
+        ];
+        // Content of the app's own model has the collection apps/<app id>/<model>
+        const appCollection = `apps/${this.app.id}/`;
+        const matches = actions.filter((action) => action.id === id &&
+            (!flags.collection ||
+                action.collection === flags.collection ||
+                action.collection === `${appCollection}${flags.collection}`) &&
+            (!flags.view || action.view === flags.view) &&
+            (!flags.settings || action.settings === flags.settings) &&
+            (!flags.source || action.source === flags.source));
+        if (matches.length === 0) {
+            this.error(`Action ${style.appConfigValue(id)} not found in the app's content or settings. Push the app first if it is new.`);
+        }
+        if (matches.length > 1) {
+            this.error(`Action ${style.appConfigValue(id)} is declared in more than one place:\n${matches
+                .map((action) => `  ${describePlace(action, appCollection)}`)
+                .join('\n')}\nPick one with --collection, --view, --settings or --source.`);
+        }
+        return matches[0];
+    }
+    async findFunctionId(name) {
+        const functions = await this.api.get({ adminPath: '/data/:functions' }, { query: { app_id: this.app.id, fields: 'id, name', limit: 1000 } });
+        const record = (functions?.results || []).find((record) => functionSlug(record.name) === functionSlug(name));
+        if (!record) {
+            this.error(`Function ${style.appConfigValue(name)} of the action is not installed. Push the app first.`);
+        }
+        return record.id;
+    }
+    getActionParams(action, flags) {
+        const name = style.appConfigValue(action.id);
+        const isBulk = action.source === 'bulk';
+        const needsRecord = action.source === 'record' ||
+            (action.source === 'field' && !action.settings);
+        if (needsRecord && !flags.record) {
+            this.error(`Action ${name} runs on a record: pass --record.`);
+        }
+        if (!needsRecord && flags.record) {
+            this.error(isBulk
+                ? `Action ${name} is a bulk action, which runs on --ids or --all: leave out --record.`
+                : `Action ${name} does not run on a record: leave out --record.`);
+        }
+        if (isBulk && !flags.ids && !flags.all) {
+            this.error(`Action ${name} is a bulk action: pass --ids or --all.`);
+        }
+        if (!isBulk && (flags.ids || flags.all)) {
+            this.error(`Action ${name} is not a bulk action: leave out ${flags.ids ? '--ids' : '--all'}.`);
+        }
+        // The platform passes on only the values of the modal's fields
+        if (flags.values) {
+            if (!action.modal) {
+                this.error(`Action ${name} has no modal: leave out --values.`);
+            }
+            const fieldIds = getModalFieldIds(action.modal);
+            const unknownKeys = Object.keys(flags.values).filter((key) => !fieldIds.includes(key));
+            if (unknownKeys.length > 0) {
+                this.error(`--values names fields that the modal of action ${name} does not have: ${unknownKeys.join(', ')}.`);
+            }
+        }
+        return {
+            id: action.id,
+            source: action.source,
+            ...(action.settings
+                ? { settings: action.settings }
+                : { content_id: action.content_id }),
+            ...(action.view ? { view: action.view } : undefined),
+            ...(needsRecord ? { record_id: flags.record } : undefined),
+            ...(isBulk
+                ? { selection: getSelection(flags.ids, action.query) }
+                : undefined),
+            ...(flags.values ? { values: flags.values } : undefined),
+        };
+    }
+    parseValues(values) {
+        let parsed;
+        try {
+            parsed = JSON.parse(values);
+        }
+        catch {
+            // ignore
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            this.error('--values must be a JSON object of the modal field values, like \'{"carrier":"ups"}\'');
+        }
+        return parsed;
+    }
+}
+// The function answers as it likes, so only a string is a message
+function resultMessage(message) {
+    return typeof message === 'string' ? message : '';
+}
+// As the dashboard reads a result that did not succeed
+function getErrorMessage(result, name) {
+    const { code, response } = result || {};
+    if (code === 'timeout') {
+        return `Action ${name} did not finish within the time limit. It may still be running; check before running it again.`;
+    }
+    if (UNAVAILABLE_CODES.has(code)) {
+        return 'The app function is unavailable.';
+    }
+    return (resultMessage(response?.$reject?.message) ||
+        resultMessage(response?.error?.message) ||
+        resultMessage(response?.error) ||
+        `Action ${name} failed`);
+}
+function describePlace(action, appCollection) {
+    const collection = action.collection?.startsWith(appCollection)
+        ? action.collection.slice(appCollection.length)
+        : action.collection;
+    return action.settings
+        ? `settings ${action.settings} (${action.source})`
+        : `content ${collection}${action.view ? `, view ${action.view}` : ''} (${action.source})`;
+}
+// As the dashboard selects records: by their ids, or all of them that the
+// view lists with no filters set
+function getSelection(ids, viewQuery = {}) {
+    if (!ids) {
+        return { all: true, count: null, query: viewQuery };
+    }
+    const list = ids
+        .split(',')
+        .map((id) => id.trim())
+        .filter(Boolean);
+    return {
+        all: false,
+        count: list.length,
+        ids: list,
+        query: { $and: [{ id: { $in: list } }] },
+    };
+}

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

@@ -0,0 +1,33 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppDelete extends RemoteAppCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        confirm: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static orientation: {
+        env: string;
+    };
+    static summary: string;
+    run(): Promise<void>;
+    private deleteRequest;
+    private ensureDeleted;
+    private errorTheme;
+    /**
+     * Remove .swellrc when it holds the deleted app's id, so the next push
+     * creates a new app. Another id is left alone.
+     * @param {string} appId the deleted app
+     * @returns {Promise<boolean>} false when .swellrc names another app
+     */
+    private removeSwellRc;
+    private errorBlocked;
+    /**
+     * The app named by swell.json, with the reasons it can't be deleted.
+     * Only the store that owns it may delete it.
+     * @param {string} privateId app id from swell.json
+     * @param {string} storeId the logged in store
+     * @returns {Promise<any>} the app
+     */
+    private getOwnedApp;
+}

package/dist/commands/app/delete.js

@@ -0,0 +1,179 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import * as fs from 'node:fs/promises';
+import { readRcFile } from '../../lib/app-config.js';
+import config from '../../lib/config.js';
+import style from '../../lib/style.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppDelete extends RemoteAppCommand {
+    static description = `Deletes the app from the store that owns it, to free a slot under the store's app limit.
+
+The app's versions, configs, functions and its development install in the test environment are removed. Records the app created in the store are not deleted.
+
+An app can't be deleted while it is installed anywhere else, if it is linked to a partner, or if it was ever published. The command lists what blocks it.
+
+After deleting, .swellrc is removed, so the next \`swell app push\` creates a new app.`;
+    static examples = [
+        'swell app delete',
+        'swell app delete --confirm',
+        'swell app delete --confirm -y',
+    ];
+    static flags = {
+        confirm: Flags.boolean({
+            description: 'confirm deleting the app, instead of being asked',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'skip all prompts; requires --confirm',
+        }),
+    };
+    static orientation = {
+        env: 'test',
+    };
+    static summary = 'Delete an app your store owns.';
+    async run() {
+        const { flags } = await this.parse(AppDelete);
+        const { confirm: confirmed, yes } = flags;
+        if (yes && !confirmed) {
+            this.error(`Missing --confirm for non-interactive mode.
+
+Deleting an app can't be undone.
+
+Example: ${style.command('swell app delete --confirm -y')}`, { exit: 1 });
+        }
+        if (!confirmed && !process.stdin.isTTY) {
+            this.error(`Missing --confirm: there is no terminal to ask for confirmation.
+
+Example: ${style.command('swell app delete --confirm')}`, { exit: 1 });
+        }
+        if (this.swellConfig.get('type') === 'theme') {
+            this.errorTheme();
+        }
+        const privateId = this.app.private_id;
+        if (!privateId) {
+            this.error(`App ${style.appConfigName('id')} is not defined in swell.json.`, { exit: 1 });
+        }
+        const storeId = config.getDefaultStore();
+        config.ensureLoggedIn(storeId);
+        const app = await this.getOwnedApp(privateId, storeId);
+        const appLabel = `${style.appName(app.name)} (${app.id})`;
+        if (app.type === 'theme') {
+            this.errorTheme();
+        }
+        const blockers = app.delete_blockers || [];
+        if (blockers.length > 0) {
+            this.errorBlocked(appLabel, blockers);
+        }
+        if (!confirmed) {
+            const continueDelete = await confirm({
+                default: false,
+                message: `Delete ${app.name} from store ${storeId}? This can't be undone.`,
+            });
+            if (!continueDelete) {
+                this.log('Delete cancelled.');
+                return;
+            }
+        }
+        // The BFF hands out a key, and deletes only when it is sent back
+        const challenge = await this.deleteRequest(app.id);
+        this.ensureDeleted(appLabel, challenge);
+        if (!challenge?.confirm_delete_key) {
+            this.error(`Unable to delete app ${appLabel}: no confirmation key.`);
+        }
+        const result = await this.deleteRequest(app.id, challenge.confirm_delete_key);
+        this.ensureDeleted(appLabel, result);
+        const swellRcRemoved = await this.removeSwellRc(app.id);
+        this.log(`✓ Deleted app ${appLabel}`);
+        this.log(`  Store: ${style.storeId(storeId)}`);
+        if (!swellRcRemoved) {
+            this.log(`  .swellrc kept: it names another app`);
+        }
+        this.log();
+        this.log(`Run ${style.command('swell app push')} to create it again as a new app.`);
+    }
+    async deleteRequest(id, confirmDeleteKey) {
+        try {
+            return await this.api.delete({ adminPath: `/apps/${id}` }, confirmDeleteKey
+                ? { body: { confirm_delete_key: confirmDeleteKey } }
+                : {});
+        }
+        catch (error) {
+            return this.error(`Unable to delete app: ${errorMessage(error)}`);
+        }
+    }
+    ensureDeleted(appLabel, response) {
+        const error = response?.errors?.app;
+        if (error?.blockers?.length > 0) {
+            this.errorBlocked(appLabel, error.blockers);
+        }
+        if (response?.errors) {
+            const messages = Object.values(response.errors).map((err) => err?.message || String(err));
+            this.error(`Unable to delete app ${appLabel}: ${messages.join(' ')}`);
+        }
+    }
+    errorTheme() {
+        this.error(`Themes can't be deleted with ${style.command('swell app delete')}. Delete an uploaded theme from the store's storefronts in the dashboard.`, { exit: 1 });
+    }
+    /**
+     * Remove .swellrc when it holds the deleted app's id, so the next push
+     * creates a new app. Another id is left alone.
+     * @param {string} appId the deleted app
+     * @returns {Promise<boolean>} false when .swellrc names another app
+     */
+    async removeSwellRc(appId) {
+        let rc;
+        try {
+            rc = await readRcFile(this.swellRcPath());
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return true;
+            }
+            throw error;
+        }
+        if (rc.id && rc.id !== appId) {
+            return false;
+        }
+        await fs.rm(this.swellRcPath(), { force: true });
+        return true;
+    }
+    errorBlocked(appLabel, blockers) {
+        this.error([
+            `App ${appLabel} can't be deleted:`,
+            ...blockers.map((blocker) => `  - ${blocker.message}`),
+        ].join('\n'), { exit: 1 });
+    }
+    /**
+     * The app named by swell.json, with the reasons it can't be deleted.
+     * Only the store that owns it may delete it.
+     * @param {string} privateId app id from swell.json
+     * @param {string} storeId the logged in store
+     * @returns {Promise<any>} the app
+     */
+    async getOwnedApp(privateId, storeId) {
+        let app;
+        try {
+            app = await this.api.get({ adminPath: `/apps/${privateId}` }, { query: { delete_blockers: true } });
+        }
+        catch (error) {
+            const message = errorMessage(error);
+            if (message === 'App not found') {
+                this.error(`App ${style.appConfigValue(privateId)} was not found on store ${style.storeId(storeId)}. Nothing to delete.`, { exit: 1 });
+            }
+            this.error(`Unable to get app: ${message}`);
+        }
+        if (!app?.id || app.client_id !== storeId) {
+            this.error(`App ${style.appConfigValue(privateId)} is not owned by store ${style.storeId(storeId)}. Only the store that owns an app can delete it.`, { exit: 1 });
+        }
+        return app;
+    }
+}
+function errorMessage(error) {
+    try {
+        const json = JSON.parse(error.message);
+        return typeof json.error === 'string' ? json.error : json.error.message;
+    }
+    catch {
+        return error.message;
+    }
+}

package/dist/commands/app/frontend/deploy.d.ts

@@ -12,5 +12,6 @@ export default class AppFrontendDeploy extends PushAppCommand {
         env: string;
     };
     static summary: string;
+    protected pushesSwellJson(): boolean;
     run(): Promise<void>;
 }

package/dist/commands/app/frontend/deploy.js

@@ -31,6 +31,10 @@ If deployment fails, correct any reported errors and run this command again.`;
         env: 'test',
     };
     static summary = `Push frontend files to your Swell app.`;
+    // A deploy pushes no app files, so it applies nothing of the listing
+    pushesSwellJson() {
+        return false;
+    }
     async run() {
         const { flags } = await this.parse(AppFrontendDeploy);
         const { force } = flags;

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

@@ -28,5 +28,7 @@ export default class AppPush extends PushAppCommand {
      */
     confirmPushConflicts(conflictsFlag?: string, file?: string): Promise<boolean>;
     run(): Promise<void>;
+    protected pushesSwellJson(file?: string): boolean;
+    private checkActionFunctions;
     private exitIfFilesFailed;
 }

package/dist/commands/app/push.js

@@ -1,6 +1,8 @@
 import { Args, Flags } from '@oclif/core';
 import * as path from 'node:path';
-import { affectsFrontendDeployment, AllConfigPaths, filePathExistsAsync, isPathDirectory, sameIntegrations, } from '../../lib/apps/index.js';
+import ora from 'ora';
+import { functionSlug, getContentActions, getSettingsActions, } from '../../lib/apps/actions.js';
+import { affectsFrontendDeployment, AllConfigPaths, filePathExistsAsync, isPathDirectory, sameIntegrations, toPosixPath, } 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';
@@ -19,7 +21,7 @@ If the app does not exist, it will be created and its global ID saved to a .swel
 
 - If no file is specified, all configuration files will be pushed to the store.
   This includes the app icon (assets/icon.png), screenshots (assets/screenshots/),
-  README.md, and swell.json.
+  DESCRIPTION.md, and swell.json.
 - If a file is specified, only that file will be pushed to the store.
 - If a directory is specified, only files in that directory will be pushed.
 
@@ -151,6 +153,7 @@ ${Object.values(AllConfigPaths)
                 if (!noDeploy && affectsFrontendDeployment(relativePath)) {
                     await this.deployAppFrontend(force);
                 }
+                await this.checkActionFunctions(toPosixPath(relativePath));
                 this.log();
                 this.logDashboardUrl(flags);
                 this.exitIfFilesFailed();
@@ -158,6 +161,7 @@ ${Object.values(AllConfigPaths)
             }
         }
         await this.pushAppConfigs(force);
+        await this.checkActionFunctions();
         if (!noDeploy) {
             await this.deployAppFrontend(force);
             this.log();
@@ -165,6 +169,63 @@ ${Object.values(AllConfigPaths)
         this.logDashboardUrl(flags);
         this.exitIfFilesFailed();
     }
+    // The app path is the working directory unless --app-path names it, so a
+    // scoped push's file resolves here as in resolvePushPaths
+    pushesSwellJson(file) {
+        if (!file) {
+            return true;
+        }
+        const relativePath = path.relative(this.appPath, path.resolve(this.appPath, file));
+        return relativePath === '' || relativePath === 'swell.json';
+    }
+    // Content and settings are installed before functions, so their actions
+    // are checked against the app's functions once the push is done. A scoped
+    // push fails only for the files it pushed, and for the files whose action
+    // function it pushed or removed.
+    async checkActionFunctions(scope) {
+        const configs = await this.api
+            .getAll({ adminPath: `/apps/${this.app.id}/configs` }, { query: { type: { $in: ['function', 'content', 'setting'] } } })
+            .catch((error) => {
+            ora().warn(`Skipped checking the actions against the app functions: ${error.message}`);
+            return null;
+        });
+        if (!configs) {
+            return;
+        }
+        const { results } = configs;
+        const actionFunctions = new Set(results
+            .filter((config) => config.type === 'function' && config.values?.action)
+            .map((config) => functionSlug(config.name)));
+        const inScope = (filePath) => !scope || filePath === scope || filePath?.startsWith(`${scope}/`);
+        // The app's configs from before the push still name the functions it
+        // removed
+        const pushedFunctions = new Set([...results, ...(this.app.configs || [])]
+            .filter((config) => config.type === 'function' && inScope(config.file_path))
+            .map((config) => functionSlug(config.name)));
+        for (const config of results) {
+            const actions = config.type === 'content'
+                ? getContentActions(config.values)
+                : config.type === 'setting'
+                    ? getSettingsActions(config.values, config.name)
+                    : [];
+            const missing = actions.filter((action) => !actionFunctions.has(functionSlug(action.function)));
+            let failed = false;
+            for (const action of missing) {
+                const message = `${config.file_path}: action "${action.id}" runs function "${action.function}", which the app does not have as an action function`;
+                if (inScope(config.file_path) ||
+                    pushedFunctions.has(functionSlug(action.function))) {
+                    ora().fail(message);
+                    failed = true;
+                }
+                else {
+                    ora().warn(message);
+                }
+            }
+            if (failed && !this.failedFiles.includes(config.file_path)) {
+                this.failedFiles.push(config.file_path);
+            }
+        }
+    }
     // A skipped file is a failed push, for scripts and CI too
     exitIfFilesFailed() {
         if (this.failedFiles.length > 0) {

package/dist/commands/create/webhook.js

@@ -1,4 +1,4 @@
-import { confirm, input } from '@inquirer/prompts';
+import { input } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
 import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
@@ -16,7 +16,7 @@ export default class CreateWebhook extends CreateConfigCommand {
     static examples = [
         '$ swell create webhook',
         '$ swell create webhook order-sync -u https://example.com/hook -e order.created -y',
-        '$ swell create webhook payment-handler -u https://api.example.com/payments -e payment.succeeded,payment.failed --enabled -y',
+        '$ swell create webhook payment-handler -u https://api.example.com/payments -e payment.succeeded,payment.failed --no-enabled -y',
     ];
     static helpMeta = {
         usageDirect: '<name> -u <url> -e <events> [...] -y',
@@ -38,8 +38,9 @@ export default class CreateWebhook extends CreateConfigCommand {
             description: 'Description',
         }),
         enabled: Flags.boolean({
-            default: false,
-            description: 'Enable webhook (default: false)',
+            allowNo: true,
+            default: true,
+            description: 'Enable webhook (default: true)',
         }),
         overwrite: Flags.boolean({
             default: false,
@@ -148,21 +149,14 @@ export default class CreateWebhook extends CreateConfigCommand {
             events = parseEvents(eventsInput);
         }
         // Description prompt (optional)
-        let { description, enabled } = flags;
-        const { overwrite } = flags;
+        let { description } = flags;
+        const { enabled, overwrite } = flags;
         if (!description) {
             description = await input({
                 default: '',
                 message: 'Describe what this webhook does',
             });
         }
-        // Enabled prompt (optional)
-        if (!enabled) {
-            enabled = await confirm({
-                default: false,
-                message: 'Enable webhook now?',
-            });
-        }
         const fileName = toFileName(name);
         const fileBody = {
             $schema: SCHEMAS.WEBHOOK,

package/dist/commands/schema.js

@@ -6,6 +6,7 @@ import * as fs from 'node:fs/promises';
 import parseJson from 'parse-json';
 import { bundleFunction } from '../lib/bundle.js';
 import { SCHEMAS_BASE_URL } from '../lib/constants.js';
+import { getFunctionDeclarations } from '../lib/function-declarations.js';
 import { analyzeFunctionSource, getFunctionTriggers, hasKindDiagnostic, workflowStaticConfigError, } from '../lib/function-source-analysis.js';
 import { SwellCommand } from '../swell-command.js';
 const SCHEMA_DEFINITIONS = Object.freeze({
@@ -164,6 +165,10 @@ export default class Schema extends SwellCommand {
                 break;
             }
             case 'dts': {
+                if (type === 'function') {
+                    output = await getFunctionDeclarations(process.cwd());
+                    break;
+                }
                 const dtsUrl = this.getTypeScriptDeclarationsUrl(type);
                 const response = await fetch(dtsUrl);
                 if (!response.ok) {