@swell/cli 2.9.32 → 2.9.33

package/dist/commands/app/dev.js

@@ -105,7 +105,8 @@ export default class AppDev extends PushAppCommand {
         this.jsonEvents = flags['json-events'];
         this.setStoreUser(flags['store-user']);
         this.functionFilter = flags.function ?? null;
-        if (!(await this.ensureAppExists(undefined, false))) {
+        // A pushing dev run updates the app from swell.json first, as a push does
+        if (!(await this.ensureAppExists(undefined, !noPush))) {
             return;
         }
         if (!noPush) {

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

@@ -42,10 +42,12 @@ export default class AppFrontendDev extends PushAppCommand {
         const { port, 'proxy-port': proxyPort, 'app-dev': isAppDev } = flags;
         const noPush = flags['no-push'];
         this.setStoreUser(flags['store-user']);
-        if (!(await this.ensureAppExists(undefined, false))) {
+        const isPushing = !noPush && !isAppDev;
+        // A pushing dev run updates the app from swell.json first, as a push does
+        if (!(await this.ensureAppExists(undefined, isPushing))) {
             return;
         }
-        if (!noPush && !isAppDev) {
+        if (isPushing) {
             await this.pushAppConfigs();
         }
         if (this.app.type === 'storefront') {

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

@@ -30,5 +30,6 @@ export default class AppPush extends PushAppCommand {
     run(): Promise<void>;
     protected pushesSwellJson(file?: string): boolean;
     private checkActionFunctions;
+    private enableAutoDisabledFunctions;
     private exitIfFilesFailed;
 }

package/dist/commands/app/push.js

@@ -2,7 +2,8 @@ import { Args, Flags } from '@oclif/core';
 import * as path from 'node:path';
 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 { affectsFrontendDeployment, AllConfigPaths, filePathExistsAsync, getNameFromFilePath, isPathDirectory, sameIntegrations, toPosixPath, } from '../../lib/apps/index.js';
+import { isCredentialFile } from '../../lib/apps/paths.js';
 import { default as localConfig } from '../../lib/config.js';
 import style from '../../lib/style.js';
 import { PushAppCommand } from '../../push-app-command.js';
@@ -149,11 +150,17 @@ ${Object.values(AllConfigPaths)
                     ? this.pushFilePath(relativePath, force)
                     : this.pushFile(relativePath));
                 // Uploading frontend sources doesn't change what the Worker serves,
-                // so scoped pushes need the same pipeline as an unscoped one
-                if (!noDeploy && affectsFrontendDeployment(relativePath)) {
+                // so scoped pushes need the same pipeline as an unscoped one. A
+                // credential file named on its own is refused and deploys nothing
+                if (!noDeploy &&
+                    affectsFrontendDeployment(relativePath) &&
+                    !isCredentialFile(relativePath)) {
                     await this.deployAppFrontend(force);
                 }
                 await this.checkActionFunctions(toPosixPath(relativePath));
+                if (toPosixPath(relativePath).split('/')[0] === 'functions') {
+                    await this.enableAutoDisabledFunctions();
+                }
                 this.log();
                 this.logDashboardUrl(flags);
                 this.exitIfFilesFailed();
@@ -162,6 +169,7 @@ ${Object.values(AllConfigPaths)
         }
         await this.pushAppConfigs(force);
         await this.checkActionFunctions();
+        await this.enableAutoDisabledFunctions();
         if (!noDeploy) {
             await this.deployAppFrontend(force);
             this.log();
@@ -226,6 +234,33 @@ ${Object.values(AllConfigPaths)
             }
         }
     }
+    // The platform switches off a function that keeps failing, and only an
+    // install of its config switches it on again, which a push skips for an
+    // unchanged file. Switching it on also resends the events it missed.
+    async enableAutoDisabledFunctions() {
+        try {
+            const { results } = await this.api.getAll({ adminPath: '/data/:functions' }, {
+                query: {
+                    app_id: this.app.id,
+                    auto_disabled: true,
+                    fields: 'id, name',
+                },
+            });
+            // A function whose push just failed stays off, as it would fail again
+            const failedNames = new Set(this.failedFiles
+                .filter((filePath) => path.posix.dirname(filePath) === AllConfigPaths.FUNCTION)
+                .map((filePath) => getNameFromFilePath(filePath)));
+            const disabled = (results || []).filter((fn) => !failedNames.has(fn.name));
+            if (disabled.length === 0) {
+                return;
+            }
+            await Promise.all(disabled.map((fn) => this.api.put({ adminPath: `/data/:functions/${fn.id}` }, { body: { enabled: true } })));
+            ora().succeed(`Re-enabled ${disabled.length} auto-disabled function${disabled.length === 1 ? '' : 's'}: ${disabled.map((fn) => fn.name).join(', ')}`);
+        }
+        catch (error) {
+            ora().warn(`Skipped re-enabling auto-disabled functions: ${error.message}`);
+        }
+    }
     // A skipped file is a failed push, for scripts and CI too
     exitIfFilesFailed() {
         if (this.failedFiles.length > 0) {

package/dist/commands/app/version.js

@@ -121,6 +121,9 @@ behavior by using the --no-git-tag option.`;
             return;
         }
         nextVersion = await this.validateAndComputeVersion(nextVersion, localVersion);
+        // The app takes its details from swell.json before any upload, as a push
+        // does, so that details the app refuses fail first
+        this.app = await this.getCreateUpdateApp(this.app);
         await this.pushAppConfigs();
         await this.deployAppFrontend(false, false);
         if (!message) {

package/dist/commands/create/function.js

@@ -4,7 +4,7 @@ import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
 import { getFunctionTemplate, } from '../../lib/create/function.js';
 import { toFunctionFileName } from '../../lib/create/index.js';
-const PERMITTED_TRIGGERS = ['cron', 'model', 'route'];
+const PERMITTED_TRIGGERS = ['cron', 'model', 'route', 'action'];
 const PERMITTED_MODES = [...PERMITTED_TRIGGERS, 'workflow'];
 export default class CreateFunction extends CreateConfigCommand {
     static args = {
@@ -14,7 +14,7 @@ export default class CreateFunction extends CreateConfigCommand {
         }),
         trigger: Args.string({
             default: '',
-            description: 'cron | model | route | workflow',
+            description: 'cron | model | route | action | workflow',
             options: PERMITTED_MODES,
         }),
     };
@@ -23,6 +23,7 @@ export default class CreateFunction extends CreateConfigCommand {
         '$ swell create function order-handler.ts model -e order.created,order.updated -y',
         '$ swell create function cleanup.ts cron -s "0 0 * * *" -y',
         '$ swell create function api-endpoint.ts route -r public -y',
+        '$ swell create function mark-shipped.ts action -y',
         '$ swell create function run-import.ts --type workflow -y',
         '$ swell create function run-import.ts workflow -y',
     ];
@@ -46,6 +47,11 @@ export default class CreateFunction extends CreateConfigCommand {
                     flag: '-r, --route=<option>',
                     description: 'Access: public (default) | private',
                 },
+                {
+                    name: 'action',
+                    flag: '',
+                    description: 'Runs from a dashboard action',
+                },
                 {
                     name: 'workflow',
                     flag: '--type=workflow',
@@ -104,7 +110,7 @@ export default class CreateFunction extends CreateConfigCommand {
             }
             // Validate trigger argument
             if (!trigger) {
-                this.error('Missing required argument for non-interactive mode: TRIGGER or --type workflow\n\nValid modes: cron, model, route, workflow\n\nExample: swell create function my-func.ts model -e order.created -y\nExample: swell create function run-import.ts --type workflow -y', { exit: 1 });
+                this.error('Missing required argument for non-interactive mode: TRIGGER or --type workflow\n\nValid modes: cron, model, route, action, workflow\n\nExample: swell create function my-func.ts model -e order.created -y\nExample: swell create function run-import.ts --type workflow -y', { exit: 1 });
             }
             // Validate filename has extension
             const language = args.name.endsWith('.ts')
@@ -212,6 +218,10 @@ export default class CreateFunction extends CreateConfigCommand {
                         name: 'HTTP (route)',
                         value: 'route',
                     },
+                    {
+                        name: 'Dashboard action (action)',
+                        value: 'action',
+                    },
                 ],
                 message: 'How will your function be triggered?',
             });
@@ -290,7 +300,7 @@ export default class CreateFunction extends CreateConfigCommand {
         if (typeFlag === 'workflow') {
             if (positionalTrigger &&
                 PERMITTED_TRIGGERS.includes(positionalTrigger)) {
-                this.error('--type workflow cannot be combined with a positional cron, model, or route trigger.', { exit: 1 });
+                this.error('--type workflow cannot be combined with a positional cron, model, route, or action trigger.', { exit: 1 });
             }
             return 'workflow';
         }

package/dist/commands/create/model.js

@@ -3,7 +3,7 @@ import { Args, Flags } from '@oclif/core';
 import { CreateCollectionCommand } from '../../create-collection-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
 import { toCollectionLabel, toCollectionName, toFileName, } from '../../lib/create/index.js';
-import { parseEvents, parseFields, } from '../../lib/create/model.js';
+import { FIELD_TYPES, fieldPairProblem, parseEvents, parseFields, } from '../../lib/create/model.js';
 import { SCHEMAS } from '../../lib/create/schemas.js';
 export default class CreateModel extends CreateCollectionCommand {
     static args = {
@@ -16,7 +16,8 @@ export default class CreateModel extends CreateCollectionCommand {
     static examples = [
         '$ swell create model',
         '$ swell create model products -y',
-        '$ swell create model visitors -f title:string,photo:string -l "Visitors" -y',
+        '$ swell create model visitors -f title:string,photo:file -l "Visitors" -y',
+        '$ swell create model reviews -f owner:link:accounts,tags:array:string -y',
     ];
     static helpMeta = {
         usageDirect: '<collection> [...] -y',
@@ -35,7 +36,7 @@ export default class CreateModel extends CreateCollectionCommand {
         fields: Flags.string({
             char: 'f',
             default: '',
-            description: 'Fields as id:type pairs (e.g., title:string,price:currency)',
+            description: 'Fields as id:type pairs, id:link:<model> or id:array:<type> (e.g., title:string,owner:link:accounts)',
         }),
         events: Flags.string({
             char: 'e',
@@ -58,14 +59,6 @@ export default class CreateModel extends CreateCollectionCommand {
         const confirmYes = Boolean(flags.yes);
         // Helper validators
         const validEventValues = ['created', 'updated', 'deleted'];
-        const validFieldTypes = [
-            'collection',
-            'currency',
-            'image',
-            'int',
-            'link',
-            'string',
-        ];
         const validateEvents = (values) => {
             const invalid = values.filter((v) => !validEventValues.includes(v));
             if (invalid.length > 0) {
@@ -73,19 +66,11 @@ export default class CreateModel extends CreateCollectionCommand {
             }
         };
         const validateFields = (pairs) => {
-            const invalid = [];
-            for (const pair of pairs) {
-                if (!pair.includes(':')) {
-                    invalid.push(pair);
-                    continue;
-                }
-                const type = pair.split(':')[1]?.trim();
-                if (!validFieldTypes.includes(type)) {
-                    invalid.push(pair);
-                }
-            }
-            if (invalid.length > 0) {
-                this.error(`Invalid field(s): ${invalid.join(', ')}\n\nValid types: ${validFieldTypes.join(', ')}\n\nExample: swell create model visitors -f title:string,price:currency -y`, { exit: 1 });
+            const problems = pairs
+                .map((pair) => fieldPairProblem(pair))
+                .filter(Boolean);
+            if (problems.length > 0) {
+                this.error(`Invalid field(s):\n  ${problems.join('\n  ')}\n\nValid types: ${FIELD_TYPES.filter((type) => type !== 'collection').join(', ')}\n\nExample: swell create model visitors -f title:string,owner:link:accounts,tags:array:string -y`, { exit: 1 });
             }
         };
         if (confirmYes) {

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

@@ -0,0 +1,31 @@
+import { InspectResourceCommand, InspectResourceCommandParsed } from '../../inspect-resource-command.js';
+import { InspectScope } from '../../lib/apps/inspect-scope.js';
+import { ComponentRecord } from '../../lib/inspect/extensions.js';
+interface InspectedComponent extends ComponentRecord {
+    app_id: string;
+    build_file?: unknown;
+}
+export default class Components 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 getListResults(scope: InspectScope): Promise<any[]>;
+    protected metaFor(record: InspectedComponent): string | undefined;
+    protected showDetail(identifier: string, scope: InspectScope, flags: InspectResourceCommandParsed['flags']): Promise<void>;
+    private getComponents;
+}
+export {};

package/dist/commands/inspect/components.js

@@ -0,0 +1,110 @@
+import { InspectResourceCommand, inspectResourceBaseArgs, inspectResourceBaseFlags, } from '../../inspect-resource-command.js';
+import { classifyIdentifier, } from '../../lib/apps/inspect-scope.js';
+import { HEX24 } from '../../lib/apps/object-id.js';
+import { resolveAppId } from '../../lib/apps/resolve.js';
+import { componentExtensionId, } from '../../lib/inspect/extensions.js';
+const COMPONENT_FIELDS = 'id, name, file_path, values, build_file, version, date_created, date_updated';
+export default class Components extends InspectResourceCommand {
+    static summary = 'Components with their targets.';
+    static description = `Lists the components of installed apps, grouped by app. Pass --app=<slug> or --app=. (current swell.json) to scope.
+
+List output: paste-back key + the targets the component renders in and the extension it belongs to.
+
+Pass an identifier to view a single component config as JSON.
+
+Identifier forms:
+  app.<app>.<name>    — full paste-back key (list column 1)
+  <name>              — requires --app= scope
+  <24-char id>        — any scope
+`;
+    static args = { ...inspectResourceBaseArgs };
+    static flags = { ...inspectResourceBaseFlags };
+    static examples = [
+        'swell inspect components',
+        'swell inspect components --app=my-app',
+        'swell inspect components app.my-app.card',
+        'swell inspect components card --app=my-app',
+        'swell inspect components --live',
+    ];
+    resourceLabel = 'Components';
+    resourceLabelSingular = 'component';
+    adminPath = '/apps/:id/configs';
+    commandName = 'components';
+    async run() {
+        const { args, flags } = await this.parse(Components);
+        await this.runInspect({ args, flags });
+    }
+    async getListResults(scope) {
+        return this.getComponents(scope.appId);
+    }
+    metaFor(record) {
+        const parts = [];
+        const targets = record.values?.targets;
+        const targetIds = Array.isArray(targets)
+            ? targets
+                .map((target) => target?.id)
+                .filter(Boolean)
+            : [];
+        if (targetIds.length > 0) {
+            parts.push(targetIds.join(','));
+        }
+        const extension = componentExtensionId(record.values);
+        if (extension) {
+            parts.push(`extension ${extension}`);
+        }
+        return parts.length > 0 ? parts.join(' · ') : undefined;
+    }
+    async showDetail(identifier, scope, flags) {
+        const kind = classifyIdentifier(identifier);
+        if (kind.kind === 'invalid') {
+            this.error(`Invalid component identifier '${identifier}'. ` +
+                `Expected bare name, full slug (app.<app>.<name>), or 24-char id.`, { exit: 1 });
+        }
+        if (kind.kind === 'name' && !scope.appId) {
+            this.error(`Bare component name '${identifier}' requires --app=<slug> or --app=. to scope. ` +
+                `Alternatively, pass a full slug (app.<app>.<name>) or 24-char id.`, { exit: 1 });
+        }
+        let { appId } = scope;
+        if (kind.kind === 'slug') {
+            appId = HEX24.test(kind.appPart)
+                ? kind.appPart
+                : await resolveAppId(this.api, kind.appPart);
+        }
+        const components = await this.getComponents(appId);
+        const record = components.find((component) => kind.kind === 'id'
+            ? component.id === kind.id
+            : component.name === (kind.kind === 'slug' ? kind.name : identifier));
+        if (!record) {
+            this.throwNotFound(identifier);
+        }
+        this.emitDetail(record, flags);
+    }
+    // Components are configs of the app at its installed version; a
+    // development install has no version
+    async getComponents(appId) {
+        const installed = await this.api.get({ adminPath: '/client/apps' });
+        const apps = (installed?.results ?? []).filter((app) => !appId || app.app_id === appId);
+        const lists = await Promise.all(apps.map(async (app) => {
+            // An app whose configs the store cannot read is left out
+            let results;
+            try {
+                ({ results } = await this.api.getAll({ adminPath: `/apps/${app.app_id}/configs` }, {
+                    query: {
+                        type: 'component',
+                        fields: COMPONENT_FIELDS,
+                        ...(app.version ? { version: app.version } : undefined),
+                    },
+                }));
+            }
+            catch (error) {
+                this.warn(`Components of ${app.app_public_id ?? app.app_id} could not be read: ${error.message}`);
+                return [];
+            }
+            // Shared source under components/ is pushed without a build
+            return (results ?? [])
+                .filter((component) => component.build_file)
+                .map((component) => ({ ...component, app_id: app.app_id }));
+        }));
+        return lists.flat();
+    }
+}

package/dist/commands/inspect/extensions.js

@@ -75,11 +75,12 @@ Identifier forms:
         if (scope.appId) {
             fnQuery.app_id = scope.appId;
         }
+        const unavailableSettings = {};
         const [installedAppsResp, payments, shipments, taxes, functionsResp] = await Promise.all([
             this.api.get({ adminPath: '/client/apps' }),
-            this.fetchSafe('/data/settings/payments'),
-            this.fetchSafe('/data/settings/shipments'),
-            this.fetchSafe('/data/settings/taxes'),
+            this.fetchSafe('payments', unavailableSettings),
+            this.fetchSafe('shipments', unavailableSettings),
+            this.fetchSafe('taxes', unavailableSettings),
             this.api.getAll({ adminPath: '/data/:functions' }, { query: fnQuery }),
         ]);
         const installed = (installedAppsResp?.results ??
@@ -209,6 +210,7 @@ Identifier forms:
                 payments,
                 shipments,
                 taxes,
+                unavailableSettings,
                 functions: state.functions,
                 components: state.components,
             });
@@ -276,11 +278,12 @@ Identifier forms:
                     `Expected bare id or app.<slug>.<extId>.`, { exit: 1 });
             }
         }
+        const unavailableSettings = {};
         const [installedAppsResp, payments, shipments, taxes, functionsResp] = await Promise.all([
             this.api.get({ adminPath: '/client/apps' }, { query: {} }),
-            this.fetchSafe('/data/settings/payments'),
-            this.fetchSafe('/data/settings/shipments'),
-            this.fetchSafe('/data/settings/taxes'),
+            this.fetchSafe('payments', unavailableSettings),
+            this.fetchSafe('shipments', unavailableSettings),
+            this.fetchSafe('taxes', unavailableSettings),
             this.api.getAll({ adminPath: '/data/:functions' }, { query: { app_id: appId, extension: extId } }),
         ]);
         const installed = (installedAppsResp?.results ??
@@ -321,6 +324,7 @@ Identifier forms:
                 payments,
                 shipments,
                 taxes,
+                unavailableSettings,
                 functions: fnsForExtension,
                 components: compsForExtension,
                 localDiff,
@@ -393,12 +397,17 @@ Identifier forms:
         }
         this.log();
     }
-    async fetchSafe(adminPath) {
+    // A settings record that cannot be read is noted, so that its extensions
+    // show the reason rather than look not activated
+    async fetchSafe(record, unavailableSettings) {
         try {
-            const result = await this.api.get({ adminPath });
+            const result = await this.api.get({
+                adminPath: `/data/settings/${record}`,
+            });
             return (result ?? null);
         }
-        catch {
+        catch (error) {
+            unavailableSettings[record] = error.message;
             return null;
         }
     }

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

@@ -0,0 +1,37 @@
+import { InspectResourceCommand, InspectResourceCommandParsed } from '../../inspect-resource-command.js';
+import { InspectScope } from '../../lib/apps/inspect-scope.js';
+interface InspectedFrontend {
+    [key: string]: unknown;
+    address: string;
+    app_id: string;
+    framework?: string;
+    hosting?: string;
+    installation_id: string;
+}
+export default class Frontend 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 getListResults(scope: InspectScope): Promise<any[]>;
+    protected keyFor(record: InspectedFrontend, appSlugById: Record<string, string>): string;
+    protected metaFor(record: InspectedFrontend): string | undefined;
+    protected showDetail(identifier: string, _scope: InspectScope, flags: InspectResourceCommandParsed['flags']): Promise<void>;
+    private getFrontends;
+    private getInstalledApps;
+    private frontendsOf;
+}
+export {};

package/dist/commands/inspect/frontend.js

@@ -0,0 +1,75 @@
+import { InspectResourceCommand, inspectResourceBaseArgs, inspectResourceBaseFlags, } from '../../inspect-resource-command.js';
+import { slugFromInstalledApp } from '../../lib/apps/slug.js';
+import { default as localConfig } from '../../lib/config.js';
+import { getAppFrontendHost } from '../../lib/constants.js';
+export default class Frontend extends InspectResourceCommand {
+    static summary = 'App frontends with hosting and address.';
+    static description = `Lists the frontends of installed apps. Pass --app=<slug> or --app=. (current swell.json) to scope.
+
+List output: paste-back key + hosting (managed or self-hosted), framework, and the address the store serves the frontend at.
+
+Pass an identifier to view an app's frontend as JSON: the app's frontend selection (package or self-hosted URL) with its installation and address.
+
+Identifier forms:
+  app.<app>        — full paste-back key (list column 1)
+  <app>            — the app's slug
+  <24-char id>     — the app's id
+`;
+    static args = { ...inspectResourceBaseArgs };
+    static flags = { ...inspectResourceBaseFlags };
+    static examples = [
+        'swell inspect frontend',
+        'swell inspect frontend --app=.',
+        'swell inspect frontend app.my-app',
+        'swell inspect frontend --live',
+    ];
+    resourceLabel = 'Frontends';
+    resourceLabelSingular = 'frontend';
+    adminPath = '/client/apps';
+    commandName = 'frontend';
+    async run() {
+        const { args, flags } = await this.parse(Frontend);
+        await this.runInspect({ args, flags });
+    }
+    async getListResults(scope) {
+        return this.getFrontends(scope.appId);
+    }
+    keyFor(record, appSlugById) {
+        return `app.${appSlugById[record.app_id] ?? record.app_id}`;
+    }
+    metaFor(record) {
+        // A frontend without hosting is self-hosted
+        return [record.hosting || 'self-hosted', record.framework, record.address]
+            .filter(Boolean)
+            .join(' · ');
+    }
+    async showDetail(identifier, _scope, flags) {
+        const app = identifier.replace(/^app\./, '');
+        const installed = await this.getInstalledApps();
+        const match = installed.find((record) => record.app_id === app || slugFromInstalledApp(record) === app);
+        const [frontend] = match ? this.frontendsOf([match]) : [];
+        if (!frontend) {
+            this.throwNotFound(identifier);
+        }
+        this.emitDetail(frontend, flags);
+    }
+    async getFrontends(appId) {
+        const installed = await this.getInstalledApps();
+        return this.frontendsOf(installed.filter((record) => !appId || record.app_id === appId));
+    }
+    async getInstalledApps() {
+        const response = await this.api.get({ adminPath: '/client/apps' });
+        return (response?.results ?? []);
+    }
+    frontendsOf(installed) {
+        const store = localConfig.getDefaultStore();
+        return installed
+            .filter((record) => Object.keys(record.app?.frontend ?? {}).length > 0)
+            .map((record) => ({
+            ...record.app?.frontend,
+            address: getAppFrontendHost(store, record.id),
+            app_id: record.app_id,
+            installation_id: record.id,
+        }));
+    }
+}

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

@@ -1,9 +1,13 @@
 import { InspectResourceCommand, InspectResourceCommandParsed } from '../../inspect-resource-command.js';
+import { InspectScope } from '../../lib/apps/inspect-scope.js';
 interface FunctionRecord {
     id?: string;
     kind?: string;
     name?: string;
     enabled?: boolean;
+    auto_disabled?: boolean;
+    attempts_failed?: number;
+    date_first_failed?: string;
     cron?: {
         schedule?: string;
     };
@@ -18,6 +22,7 @@ interface FunctionRecord {
     };
     date_cron_scheduled?: string;
     date_final_attempt?: string;
+    timeout?: number;
     app_id?: string;
 }
 export default class Functions extends InspectResourceCommand {
@@ -37,10 +42,15 @@ export default class Functions extends InspectResourceCommand {
     protected resourceLabelSingular: string;
     protected adminPath: string;
     protected commandName: string;
+    private inactiveApps;
     run(): Promise<void>;
+    protected getListResults(scope: InspectScope, flags: InspectResourceCommandParsed['flags']): Promise<any[]>;
     protected metaFor(r: FunctionRecord): string | undefined;
     protected filterListResults<T>(results: T[]): T[];
-    protected emitDetail(record: FunctionRecord, flags: InspectResourceCommandParsed['flags']): void;
+    protected emitDetail(record: FunctionRecord, flags: InspectResourceCommandParsed['flags']): Promise<void>;
+    private detailNotes;
+    private lastFailedDelivery;
+    private getInactiveApps;
     /**
      * Model-triggered functions emit `/events:webhooks` rows on each invocation.
      * Route and cron functions do not — pointing the agent at an empty query