@swell/cli 2.6.0 → 2.7.0

package/dist/commands/inspect/models.js

@@ -1,15 +1,16 @@
 import { Args, Flags } from '@oclif/core';
 import { FetchError } from 'node-fetch';
 import { getCurrentAppSlugId } from '../../lib/apps/index.js';
+import { resolveInspectScope, } from '../../lib/apps/inspect-scope.js';
+import { resolveAppId } from '../../lib/apps/resolve.js';
+import { slugFromApp } from '../../lib/apps/slug.js';
 import { default as localConfig } from '../../lib/config.js';
 import { SwellCommand } from '../../swell-command.js';
 export default class Models extends SwellCommand {
-    static summary = 'Inspect models for collections deployed in your store.';
-    static description = `
-View models for collections available in your Swell store.
+    static summary = 'Collection models and fields (hierarchical).';
+    static description = `Lists all collections grouped by type. Pass --app=<slug> or --app=. (current swell.json) to filter to one app's models.
 
-Without a collection path, this command lists all available collections grouped by type.
-With a collection path, it retrieves the model for that specific collection in JSON format.
+Pass a collection path to view a single model as JSON. Paths are fully qualified, so --app is ignored in detail mode.
 `;
     static args = {
         'collection-path': Args.string({
@@ -18,41 +19,58 @@ With a collection path, it retrieves the model for that specific collection in J
         }),
     };
     static flags = {
+        app: Flags.string({
+            description: 'Filter by app slug, or "." for current swell.json.',
+        }),
         live: Flags.boolean({
-            description: 'Use the live environment instead of test (default: test).',
+            description: 'Use live environment (default: test).',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Emit pure JSON without the "Next steps" footer. Detail mode only.',
             default: false,
         }),
         yes: Flags.boolean({
             char: 'y',
-            description: 'Accept all prompts automatically (for agent compatibility; no functional effect).',
+            description: 'No-op; accepted for agent compatibility.',
             default: false,
+            hidden: true,
         }),
     };
     static examples = [
         'swell inspect models',
+        'swell inspect models --app=my-app',
+        'swell inspect models --live',
         'swell inspect models /products',
         'swell inspect models /content/blogs',
         'swell inspect models /apps/myapp/orders',
-        'swell inspect models /orders --live',
+        'swell inspect models /products --json',
     ];
     async run() {
         const { args, flags } = await this.parse(Models);
         const { 'collection-path': path } = args;
-        const { live } = flags;
+        const { app, json, live } = flags;
+        if (json && !path) {
+            this.error('--json is only valid in detail mode. Pass a collection path to inspect a single model, or drop --json for the list view.', { exit: 1 });
+        }
         if (!live) {
             await this.api.setEnv('test');
         }
-        // Detail mode: show schema for a specific model
+        // Detail mode: show schema for a specific model. Paths are fully
+        // qualified, so --app is ignored here and we skip scope resolution.
         if (path) {
             if (!path.startsWith('/')) {
                 throw new Error(`Collection path must start with '/'. Did you mean '/${path}'?`);
             }
-            await this.showModelDetail(path);
+            await this.showModelDetail(path, json);
             return;
         }
+        const scope = await resolveInspectScope({
+            resolveAppId: (slug) => resolveAppId(this.api, slug),
+            readCurrentAppSlug: () => getCurrentAppSlugId(),
+        }, { app });
         const store = localConfig.getDefaultStore();
-        // List mode: show all models
-        await this.listModels(store, live);
+        await this.listModels(store, live, scope);
     }
     async catch(error) {
         if (error instanceof FetchError) {
@@ -61,25 +79,32 @@ With a collection path, it retrieves the model for that specific collection in J
         }
         return this.error(error.message, { exit: 1 });
     }
-    async listModels(store, live) {
+    async listModels(store, live, scope) {
         const { results: apps } = await this.api.get({
             adminPath: '/apps',
         });
-        const appsById = Object.fromEntries(apps.map((app) => [app.id, app]));
-        const { results: models } = await this.api.getAll({
-            adminPath: '/data/:models',
-        }, {
-            query: {
-                deprecated: { $ne: true },
-                development: { $ne: true },
-                abstract: { $ne: true },
-                reserved: { $ne: true },
+        const allAppsById = Object.fromEntries(apps.map((app) => [app.id, app]));
+        const appsById = scope.appId
+            ? allAppsById[scope.appId]
+                ? { [scope.appId]: allAppsById[scope.appId] }
+                : {}
+            : allAppsById;
+        const baseModelsQuery = {
+            deprecated: { $ne: true },
+            development: { $ne: true },
+            abstract: { $ne: true },
+            reserved: { $ne: true },
+        };
+        const modelsQuery = scope.appId
+            ? { ...baseModelsQuery, app_id: scope.appId }
+            : {
+                ...baseModelsQuery,
                 $or: [
                     { app_id: { $exists: false } },
-                    { app_id: { $in: Object.keys(appsById) } },
+                    { app_id: { $in: Object.keys(allAppsById) } },
                 ],
-            },
-        });
+            };
+        const { results: models } = await this.api.getAll({ adminPath: '/data/:models' }, { query: modelsQuery });
         const standardModels = [];
         const modelsByAppId = {};
         for (const model of models) {
@@ -91,31 +116,27 @@ With a collection path, it retrieves the model for that specific collection in J
                 standardModels.push(model);
             }
         }
-        this.log(`Collections available in '${store}' ${live ? '[live]' : '[test]'}:`);
-        this.log();
-        this.showStandardModels(standardModels);
+        this.log(`Collections in '${store}' ${live ? '[live]' : '[test]'}`);
+        if (!scope.appId) {
+            this.log();
+            this.showStandardModels(standardModels);
+        }
         await this.showAppModels(appsById, modelsByAppId);
-        // Show next step hint
         this.log();
-        this.log('View collection model');
-        this.log('  swell inspect models <collection-path>');
+        this.log('Run "swell inspect models <path>" to view a collection model.');
         this.log();
-        this.log('Examples:');
-        this.log('  swell inspect models /products');
-        this.log('  swell inspect models /content/blogs');
-        this.log('  swell inspect models /apps/myapp/orders');
     }
     showStandardModels(models) {
-        this.showModels(models, 'Standard');
+        this.showModels(models, '── standard');
     }
     async showAppModels(appsById, modelsByAppId) {
         const currentAppSlugId = await getCurrentAppSlugId();
         for (const [appId, app] of Object.entries(appsById)) {
             const models = modelsByAppId[appId];
             if (models) {
-                const appSlugId = this.getAppSlugId(app);
+                const appSlugId = slugFromApp(app);
                 const pathPrefix = `/apps/${appSlugId}`;
-                const label = `${app.name} App ${currentAppSlugId === appSlugId ? '(current app)' : ''}`;
+                const label = `── ${appSlugId}${currentAppSlugId === appSlugId ? ' (current app)' : ''}`;
                 this.log();
                 this.showModels(models, label, { pathPrefix });
             }
@@ -123,7 +144,6 @@ With a collection path, it retrieves the model for that specific collection in J
     }
     showModels(models, label, options) {
         this.log(label);
-        this.log();
         const sortedModels = [...models].sort((a, b) => {
             const pathA = this.getModelPath(a, options?.pathPrefix);
             const pathB = this.getModelPath(b, options?.pathPrefix);
@@ -153,10 +173,7 @@ With a collection path, it retrieves the model for that specific collection in J
         }
         return `/${model.name}`;
     }
-    getAppSlugId(app) {
-        return app.public_id || app.private_id.replace(/^_/, '');
-    }
-    async showModelDetail(path) {
+    async showModelDetail(path, json) {
         const [modelPath, subModelKey, namespace] = await this.resolveModelPath(path);
         let model = null;
         if (namespace) {
@@ -181,14 +198,15 @@ With a collection path, it retrieves the model for that specific collection in J
             this.throwModelNotFound(path);
         }
         if (!subModelKey) {
-            this.showModel(model);
+            this.emitModel(model, json);
             return;
         }
         const subModel = model.fields[subModelKey];
         if (!subModel) {
             this.throwModelNotFound(path);
         }
-        this.showModel(subModel);
+        // Sub-model fields have no runtime address of their own; emit JSON only.
+        this.log(JSON.stringify(subModel, null, 2));
     }
     async resolveModelPath(path) {
         if (path.startsWith('/apps/')) {
@@ -217,7 +235,56 @@ With a collection path, it retrieves the model for that specific collection in J
     throwModelNotFound(path) {
         throw new Error(`No model found for collection '${path}'.\nList available collections: swell inspect models`);
     }
-    showModel(model) {
+    emitModel(model, json) {
         this.log(JSON.stringify(model, null, 2));
+        if (json) {
+            return;
+        }
+        const lines = this.modelHints(model);
+        if (lines.length === 0) {
+            return;
+        }
+        this.log();
+        this.log('Next steps:');
+        for (const line of lines) {
+            this.log(`  ${line}`);
+        }
+        this.log();
+    }
+    /**
+     * Detail-mode hints for a model record. Mirrors `InspectResourceCommand.hints`
+     * but lives here because `models` doesn't extend that base.
+     *
+     * Two hints: the records collection at the model's runtime address, and the
+     * mutation event stream filtered by canonical model string. Both interpolate
+     * from the record's own fields — `app_id`, `namespace`, `name` — so we stay
+     * consistent with column 1 if the platform renames anything.
+     *
+     * Canonical model string: `accounts` (system), `content/blogs` (namespaced
+     * system), `apps/<hex>/<col>` (app). The records path mirrors that with a
+     * leading slash.
+     */
+    modelHints(model) {
+        if (!model.name) {
+            return [];
+        }
+        let apiPath;
+        let canonical;
+        if (model.app_id) {
+            apiPath = `/apps/${model.app_id}/${model.name}`;
+            canonical = `apps/${model.app_id}/${model.name}`;
+        }
+        else if (model.namespace) {
+            apiPath = `/${model.namespace}/${model.name}`;
+            canonical = `${model.namespace}/${model.name}`;
+        }
+        else {
+            apiPath = `/${model.name}`;
+            canonical = model.name;
+        }
+        return [
+            `swell api get '${apiPath}?limit=10'`,
+            `swell api get '/events?where[model]=${canonical}&limit=10'`,
+        ];
     }
 }

package/dist/commands/inspect/notifications.d.ts

@@ -0,0 +1,31 @@
+import { InspectResourceCommand, InspectResourceCommandParsed } from '../../inspect-resource-command.js';
+import { InspectScope } from '../../lib/apps/inspect-scope.js';
+import { NotificationRecord } from '../../lib/inspect/notifications.js';
+import { GroupInfo } from '../../lib/inspect/table.js';
+export default class Notifications extends InspectResourceCommand {
+    static summary: string;
+    static description: string;
+    static args: {
+        identifier: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        app: 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>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    protected resourceLabel: string;
+    protected resourceLabelSingular: string;
+    protected adminPath: string;
+    protected commandName: string;
+    run(): Promise<void>;
+    protected keyFor(record: NotificationRecord, appSlugById: Record<string, string>): string;
+    protected groupForRecord(record: NotificationRecord, appSlugById: Record<string, string>): GroupInfo;
+    protected metaFor(r: NotificationRecord): string | undefined;
+    protected hints(record: NotificationRecord): string[];
+    protected showDetail(identifier: string, scope: InspectScope, flags: InspectResourceCommandParsed['flags']): Promise<void>;
+    private resolveSlugOrHex;
+    private lookupTriplet;
+    private lookupAndDisambiguate;
+}

package/dist/commands/inspect/notifications.js

@@ -0,0 +1,125 @@
+import { InspectResourceCommand, inspectResourceBaseArgs, inspectResourceBaseFlags, } from '../../inspect-resource-command.js';
+import { isObjectId } from '../../lib/apps/object-id.js';
+import { buildAppSlugMap, resolveAppId } from '../../lib/apps/resolve.js';
+import { buildNotificationTemplate, expandModelCandidates, formatDisambiguationError, formatNotificationKey, groupNotificationRecord, parseNotificationKey, } from '../../lib/inspect/notifications.js';
+export default class Notifications extends InspectResourceCommand {
+    static summary = 'Notifications across apps and platform.';
+    static description = `Lists notifications across all apps plus platform 'com.*' system records, grouped by owner. Pass --app=<slug> or --app=. (current swell.json) to scope.
+
+App keys include the model (app.<slug>.<model>.<name>) since identity is (api, model, name, app_id?) — two notifications in one app can share a name on different models. Own-app prefix apps/<own>/... is stripped in display.
+
+Pass an identifier to view a single record as JSON.
+
+Identifier forms:
+  com.<model>.<name>          — platform record
+  app.<app>.<model>.<name>    — app record (full key)
+  app.<app>.<name>            — legacy; ambiguous → errors with candidates
+  <name>                      — requires --app= scope
+  <24-char id>                — any scope
+`;
+    static args = { ...inspectResourceBaseArgs };
+    static flags = { ...inspectResourceBaseFlags };
+    static examples = [
+        'swell inspect notifications',
+        'swell inspect notifications --app=my-app',
+        'swell inspect notifications com.orders.receipt.v2',
+        'swell inspect notifications app.notify_me.subscriptions.back-in-stock',
+        'swell inspect notifications back-in-stock --app=notify_me',
+        'swell inspect notifications --live',
+    ];
+    resourceLabel = 'Notifications';
+    resourceLabelSingular = 'notification';
+    adminPath = '/data/:notifications';
+    commandName = 'notifications';
+    async run() {
+        const { args, flags } = await this.parse(Notifications);
+        await this.runInspect({ args, flags });
+    }
+    keyFor(record, appSlugById) {
+        return formatNotificationKey(record, appSlugById);
+    }
+    groupForRecord(record, appSlugById) {
+        return groupNotificationRecord(record, appSlugById);
+    }
+    metaFor(r) {
+        return r.enabled === false ? 'disabled' : undefined;
+    }
+    hints(record) {
+        const template = buildNotificationTemplate(record);
+        if (!template) {
+            return [];
+        }
+        return [
+            `swell api get '/notifications?where[template]=${template}&limit=10'`,
+        ];
+    }
+    async showDetail(identifier, scope, flags) {
+        const parsed = parseNotificationKey(identifier);
+        let record = null;
+        switch (parsed.kind) {
+            case 'hex':
+            case 'system_id': {
+                record = await this.api.get({
+                    adminPath: `${this.adminPath}/${parsed.id}`,
+                });
+                break;
+            }
+            case 'app_full': {
+                const appId = await this.resolveSlugOrHex(parsed.slug);
+                const candidates = await expandModelCandidates(parsed.model, appId, (s) => resolveAppId(this.api, s));
+                record = await this.lookupTriplet(appId, candidates, parsed.name);
+                break;
+            }
+            case 'app_short': {
+                const appId = await this.resolveSlugOrHex(parsed.slug);
+                record = await this.lookupAndDisambiguate(appId, parsed.name, identifier);
+                break;
+            }
+            case 'bare': {
+                if (!scope.appId) {
+                    this.error(`Bare ${this.resourceLabelSingular} name '${identifier}' requires --app=<slug> or --app=. to scope. ` +
+                        `Alternatively, pass a full key (app.<app>.<model>.<name> or com.<model>.<name>).`, { exit: 1 });
+                }
+                record = await this.lookupAndDisambiguate(scope.appId, parsed.name, identifier);
+                break;
+            }
+            case 'invalid': {
+                this.error(`Invalid ${this.resourceLabelSingular} identifier '${identifier}'. ` +
+                    `Expected bare name, app.<app>.<model>.<name>, com.<model>.<name>, or 24-char id.`, { exit: 1 });
+            }
+        }
+        if (!record) {
+            this.throwNotFound(identifier);
+        }
+        this.emitDetail(record, flags);
+    }
+    async resolveSlugOrHex(slugOrHex) {
+        return isObjectId(slugOrHex)
+            ? slugOrHex
+            : resolveAppId(this.api, slugOrHex);
+    }
+    async lookupTriplet(appId, modelCandidates, name) {
+        const response = await this.api.get({ adminPath: this.adminPath }, {
+            query: {
+                app_id: appId,
+                model: { $in: modelCandidates },
+                name,
+                limit: 1,
+            },
+        });
+        return response?.results?.[0] ?? null;
+    }
+    async lookupAndDisambiguate(appId, name, identifier) {
+        // Fetch one past the display cap so the formatter can distinguish
+        // "exactly 10 candidates" from "10+ candidates and we're truncating".
+        const response = await this.api.get({ adminPath: this.adminPath }, { query: { app_id: appId, name, limit: 11 } });
+        const results = response?.results ?? [];
+        if (results.length <= 1) {
+            return results[0] ?? null;
+        }
+        const appSlugById = await buildAppSlugMap(this.api);
+        this.error(formatDisambiguationError(results, appSlugById, identifier), {
+            exit: 1,
+        });
+    }
+}

package/dist/commands/inspect/settings.d.ts

@@ -0,0 +1,28 @@
+import { InspectResourceCommand, InspectResourceCommandParsed } from '../../inspect-resource-command.js';
+import { InspectScope } from '../../lib/apps/inspect-scope.js';
+import { SettingRecord } from '../../lib/inspect/settings.js';
+import { GroupInfo } from '../../lib/inspect/table.js';
+export default class Settings extends InspectResourceCommand {
+    static summary: string;
+    static description: string;
+    static args: {
+        identifier: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        app: 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>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    protected resourceLabel: string;
+    protected resourceLabelSingular: string;
+    protected adminPath: string;
+    protected commandName: string;
+    run(): Promise<void>;
+    protected keyFor(record: SettingRecord, appSlugById: Record<string, string>): string;
+    protected groupForRecord(record: SettingRecord, appSlugById: Record<string, string>): GroupInfo;
+    protected filterListResults<T>(results: T[]): T[];
+    protected hints(record: SettingRecord): string[];
+    protected showDetail(identifier: string, _scope: InspectScope, flags: InspectResourceCommandParsed['flags']): Promise<void>;
+}

package/dist/commands/inspect/settings.js

@@ -0,0 +1,82 @@
+import { InspectResourceCommand, inspectResourceBaseArgs, inspectResourceBaseFlags, } from '../../inspect-resource-command.js';
+import { isObjectId } from '../../lib/apps/object-id.js';
+import { resolveAppId } from '../../lib/apps/resolve.js';
+import { formatSettingsKey, groupSettingsRecord, isDeprecatedRecord, parseSettingsKey, } from '../../lib/inspect/settings.js';
+export default class Settings extends InspectResourceCommand {
+    static summary = 'App and platform settings records.';
+    static description = `Lists app settings records plus platform 'com.*' system records, grouped by owner. Pass --app=<slug> or --app=. (current swell.json) to scope.
+
+Each app collapses to one settings record at push time, so the list shows one row per app.
+
+Pass an identifier to view a single record as JSON.
+
+Identifier forms:
+  <name>          — system record (e.g. taxes, payments)
+  app.<slug>      — app record
+  com.<name>      — full system id
+  <24-char id>    — direct fetch
+
+Deprecated records (general, admin) are filtered from the list but remain reachable by name.
+`;
+    static args = { ...inspectResourceBaseArgs };
+    static flags = { ...inspectResourceBaseFlags };
+    static examples = [
+        'swell inspect settings',
+        'swell inspect settings --app=my-app',
+        'swell inspect settings taxes',
+        'swell inspect settings app.notify_me',
+        'swell inspect settings com.payments',
+        'swell inspect settings --live',
+        'swell inspect settings taxes --json',
+    ];
+    resourceLabel = 'Settings';
+    resourceLabelSingular = 'settings record';
+    adminPath = '/data/:settings';
+    commandName = 'settings';
+    async run() {
+        const { args, flags } = await this.parse(Settings);
+        await this.runInspect({ args, flags });
+    }
+    keyFor(record, appSlugById) {
+        return formatSettingsKey(record, appSlugById);
+    }
+    groupForRecord(record, appSlugById) {
+        return groupSettingsRecord(record, appSlugById);
+    }
+    filterListResults(results) {
+        return results.filter((r) => !isDeprecatedRecord(r));
+    }
+    hints(record) {
+        if (!record.name) {
+            return [];
+        }
+        return [`swell api get '/settings/${record.name}'`];
+    }
+    async showDetail(identifier, _scope, flags) {
+        const parsed = parseSettingsKey(identifier);
+        let segment;
+        switch (parsed.kind) {
+            case 'app': {
+                segment = isObjectId(parsed.ref)
+                    ? parsed.ref
+                    : await resolveAppId(this.api, parsed.ref);
+                break;
+            }
+            case 'path': {
+                segment = parsed.segment;
+                break;
+            }
+            case 'invalid': {
+                this.error(`Invalid ${this.resourceLabelSingular} identifier '${identifier}'. ` +
+                    `Expected bare name (e.g. taxes), app.<slug>, full id (e.g. com.taxes), or 24-char id.`, { exit: 1 });
+            }
+        }
+        const record = await this.api.get({
+            adminPath: `${this.adminPath}/${segment}`,
+        });
+        if (!record) {
+            this.throwNotFound(identifier);
+        }
+        this.emitDetail(record, flags);
+    }
+}

package/dist/commands/inspect/webhooks.d.ts

@@ -0,0 +1,34 @@
+import { InspectResourceCommand } from '../../inspect-resource-command.js';
+interface WebhookRecord {
+    id?: string;
+    alias?: string | null;
+    enabled?: boolean;
+    auto_disabled?: boolean;
+    events?: string[];
+    attempts_failed?: number;
+    date_final_attempt?: string;
+    app_id?: string;
+}
+export default class Webhooks extends InspectResourceCommand {
+    static summary: string;
+    static description: string;
+    static args: {
+        identifier: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        app: 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>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    protected resourceLabel: string;
+    protected resourceLabelSingular: string;
+    protected adminPath: string;
+    protected commandName: string;
+    protected nameField: string;
+    run(): Promise<void>;
+    protected metaFor(r: WebhookRecord): string | undefined;
+    protected hints(record: WebhookRecord): string[];
+}
+export {};

package/dist/commands/inspect/webhooks.js

@@ -0,0 +1,61 @@
+import { InspectResourceCommand, inspectResourceBaseArgs, inspectResourceBaseFlags, } from '../../inspect-resource-command.js';
+export default class Webhooks extends InspectResourceCommand {
+    static summary = 'Webhooks with delivery state.';
+    static description = `Lists webhooks across all apps, grouped by app. Pass --app=<slug> or --app=. (current swell.json) to scope.
+
+List output: paste-back key + status (disabled, events, failures since date).
+
+Pass an identifier to view a single record as JSON.
+
+Identifier forms:
+  app.<app>.<alias>    — full paste-back key (list column 1)
+  <alias>              — requires --app= scope
+  <24-char id>         — any scope
+`;
+    static args = { ...inspectResourceBaseArgs };
+    static flags = { ...inspectResourceBaseFlags };
+    static examples = [
+        'swell inspect webhooks',
+        'swell inspect webhooks --app=my-app',
+        'swell inspect webhooks app.my-app.order-sync',
+        'swell inspect webhooks order-sync --app=my-app',
+        'swell inspect webhooks --live',
+    ];
+    resourceLabel = 'Webhooks';
+    resourceLabelSingular = 'webhook';
+    adminPath = '/data/:webhooks';
+    commandName = 'webhooks';
+    nameField = 'alias';
+    async run() {
+        const { args, flags } = await this.parse(Webhooks);
+        await this.runInspect({ args, flags });
+    }
+    metaFor(r) {
+        const parts = [];
+        if (r.auto_disabled) {
+            parts.push('auto-disabled');
+        }
+        else if (!r.enabled) {
+            parts.push('disabled');
+        }
+        if (r.events?.length) {
+            parts.push(r.events.join(','));
+        }
+        const failed = r.attempts_failed ?? 0;
+        if (failed > 0) {
+            const suffix = r.date_final_attempt
+                ? ` since ${r.date_final_attempt}`
+                : '';
+            parts.push(`${failed} fails${suffix}`);
+        }
+        return parts.length > 0 ? parts.join(' · ') : undefined;
+    }
+    hints(record) {
+        if (!record.id) {
+            return [];
+        }
+        return [
+            `swell api get '/events:webhooks?where[webhook_id]=${record.id}&limit=10'`,
+        ];
+    }
+}

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

@@ -14,6 +14,11 @@ export declare abstract class CreateAppCommand extends SwellCommand {
     addAllowedHostsToAngular(configPath: string): Promise<void>;
     addAllowedHostsToAstro(configPath: string): Promise<void>;
     addAllowedHostsToNuxt(configPath: string): Promise<void>;
+    /**
+     * For frameworks whose dev server is Vite directly. Astro/Nuxt nest the
+     * vite block inside their own defineConfig — see addViteAllowedHosts.
+     */
+    addAllowedHostsToVite(configPath: string): Promise<void>;
     /**
      * Add vite allowedHosts configuration to a framework config file.
      * Supports config files that use a defineX({}) pattern (Astro, Nuxt, etc.)
@@ -29,8 +34,10 @@ export declare abstract class CreateAppCommand extends SwellCommand {
     getInstalledStorefrontApps(): Promise<any[] | boolean>;
     getProjectType(frameworkType: string): {
         installCommand: string;
+        appTypes?: string[] | undefined;
         buildCommand?: string | undefined;
         devCommand: string;
+        displayOrder?: number | undefined;
         mainPackage: string;
         name: string;
         slug: string;