@swell/cli 2.9.0 → 2.9.3

package/dist/commands/app/dev.js

@@ -8,6 +8,7 @@ import * as path from 'node:path';
 import ora from 'ora';
 import { ConfigType, allConfigFilesInDir, appConfigFromFile, } from '../../lib/apps/index.js';
 import { bundleFunction } from '../../lib/bundle.js';
+import { analyzeFunctionSource, hasKindDiagnostic, } from '../../lib/function-source-analysis.js';
 import { detectPackageManager, getExecSpawnArgs, } from '../../lib/package-manager.js';
 import style from '../../lib/style.js';
 import { PushAppCommand } from '../../push-app-command.js';
@@ -223,6 +224,18 @@ ENVIRONMENT = "development"
                 if (this.functionFilter && config.name !== this.functionFilter) {
                     continue;
                 }
+                const fullPath = path.join(this.appPath, config.filePath);
+                // eslint-disable-next-line no-await-in-loop
+                const analysis = await analyzeFunctionSource(fullPath);
+                if (analysis.kind === 'workflow') {
+                    if (this.functionFilter) {
+                        this.log(`Workflow ${style.appConfigValue(config.name)} deploys through ${style.command('swell app push')} and cannot run in local dev.`);
+                    }
+                    continue;
+                }
+                if (hasKindDiagnostic(analysis)) {
+                    this.functionErrors.set(config.name, analysis.diagnostics.join('\n'));
+                }
                 functions.push(config);
             }
         }
@@ -251,6 +264,15 @@ ENVIRONMENT = "development"
         try {
             // Bundle the function to get its config
             const fullPath = path.join(this.appPath, func.filePath);
+            const analysis = await analyzeFunctionSource(fullPath);
+            if (hasKindDiagnostic(analysis)) {
+                this.log(`    ${style.error('Error loading config:', analysis.diagnostics.join('\n'))}`);
+                return;
+            }
+            if (analysis.kind === 'workflow') {
+                this.log(`    Workflow: deploys through ${style.command('swell app push')}`);
+                return;
+            }
             const { config } = await bundleFunction(fullPath);
             if (config?.model?.events) {
                 const events = Array.isArray(config.model.events)
@@ -311,6 +333,17 @@ ENVIRONMENT = "development"
         }
         try {
             const fullPath = path.join(this.appPath, appConfig.filePath);
+            const analysis = await analyzeFunctionSource(fullPath);
+            if (hasKindDiagnostic(analysis)) {
+                this.functionErrors.set(appConfig.name, analysis.diagnostics.join('\n'));
+                this.log(`${style.error('Error loading config')} ${appConfig.name}: ${analysis.diagnostics.join('\n')}`);
+                return;
+            }
+            if (analysis.kind === 'workflow') {
+                this.functionPorts.delete(appConfig.name);
+                this.log(`\nWorkflow ${style.appConfigValue(appConfig.name)} deploys through ${style.command('swell app push')} and cannot run in local dev.`);
+                return;
+            }
             // Re-bundle the function
             const { code } = await bundleFunction(fullPath);
             // Update the bundled file (wrangler dev will auto-reload)
@@ -380,6 +413,10 @@ ENVIRONMENT = "development"
         /* eslint-disable no-await-in-loop */
         for (const func of functions) {
             const functionName = func.name;
+            if (this.functionErrors.has(functionName)) {
+                functionStatus.set(functionName, 'error');
+                continue;
+            }
             if (this.functionPorts.has(functionName)) {
                 // Function server already running
                 continue;
@@ -397,6 +434,17 @@ ENVIRONMENT = "development"
             try {
                 // Bundle the function
                 const fullPath = path.join(this.appPath, func.filePath);
+                const analysis = await analyzeFunctionSource(fullPath);
+                if (hasKindDiagnostic(analysis)) {
+                    functionStatus.set(functionName, 'error');
+                    this.functionErrors.set(functionName, analysis.diagnostics.join('\n'));
+                    continue;
+                }
+                if (analysis.kind === 'workflow') {
+                    functionStatus.set(functionName, 'error');
+                    this.functionErrors.set(functionName, 'Workflows deploy through swell app push and cannot run in local dev.');
+                    continue;
+                }
                 const { code } = await bundleFunction(fullPath);
                 // Each function gets its own directory to avoid wrangler state conflicts
                 const functionDir = path.join(this.tmpDir, functionName);

package/dist/commands/create/function.d.ts

@@ -14,11 +14,14 @@ export default class CreateFunction extends CreateConfigCommand {
         overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         route: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         schedule: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     static summary: string;
     createType: ConfigType;
     run(): Promise<void>;
     private gatherInput;
+    private resolveTrigger;
+    private validateWorkflowFlags;
     private writeFunctionFile;
 }

package/dist/commands/create/function.js

@@ -5,6 +5,7 @@ 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_MODES = [...PERMITTED_TRIGGERS, 'workflow'];
 export default class CreateFunction extends CreateConfigCommand {
     static args = {
         name: Args.string({
@@ -13,8 +14,8 @@ export default class CreateFunction extends CreateConfigCommand {
         }),
         trigger: Args.string({
             default: '',
-            description: 'cron | model | route',
-            options: PERMITTED_TRIGGERS,
+            description: 'cron | model | route | workflow',
+            options: PERMITTED_MODES,
         }),
     };
     static examples = [
@@ -22,11 +23,13 @@ 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 run-import.ts --type workflow -y',
+        '$ swell create function run-import.ts workflow -y',
     ];
     static helpMeta = {
-        usageDirect: '<name> <trigger> [...] -y',
+        usageDirect: '<name> [<trigger>|workflow] [...] -y',
         variantSection: {
-            title: 'TRIGGER OPTIONS',
+            title: 'FUNCTION MODES',
             variants: [
                 {
                     name: 'model',
@@ -43,6 +46,11 @@ export default class CreateFunction extends CreateConfigCommand {
                     flag: '-r, --route=<option>',
                     description: 'Access: public (default) | private',
                 },
+                {
+                    name: 'workflow',
+                    flag: '--type=workflow',
+                    description: 'Durable explicit-create workflow',
+                },
             ],
         },
         variantFlags: ['events', 'schedule', 'route'],
@@ -73,6 +81,10 @@ export default class CreateFunction extends CreateConfigCommand {
             default: '',
             description: 'Cron expression (e.g., "0 0 * * *")',
         }),
+        type: Flags.string({
+            description: 'Create a workflow function',
+            options: ['workflow'],
+        }),
         yes: Flags.boolean({
             char: 'y',
             description: 'Skip prompts, require all arguments',
@@ -83,6 +95,7 @@ export default class CreateFunction extends CreateConfigCommand {
     async run() {
         const { args, flags } = await this.parse(CreateFunction);
         const confirmYes = Boolean(flags.yes);
+        const trigger = this.resolveTrigger(args.trigger, flags.type);
         // NON-INTERACTIVE PATH
         if (confirmYes) {
             // Validate name argument
@@ -90,8 +103,8 @@ export default class CreateFunction extends CreateConfigCommand {
                 this.error('Missing required argument for non-interactive mode: NAME\n\nExample: swell create function my-func.ts model -e order.created -y', { exit: 1 });
             }
             // Validate trigger argument
-            if (!args.trigger) {
-                this.error('Missing required argument for non-interactive mode: TRIGGER\n\nValid triggers: cron, model, route\n\nExample: swell create function my-func.ts model -e order.created -y', { exit: 1 });
+            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 });
             }
             // Validate filename has extension
             const language = args.name.endsWith('.ts')
@@ -102,7 +115,6 @@ export default class CreateFunction extends CreateConfigCommand {
             if (!language) {
                 this.error('Function name must end with .ts or .js extension\n\nExample: swell create function my-func.ts model -e order.created -y', { exit: 1 });
             }
-            const trigger = args.trigger;
             // Validate trigger-specific requirements
             if (trigger === 'model' && !flags.events) {
                 this.error('Missing required flag for model trigger: --events\n\nExample: swell create function my-func.ts model -e order.created,order.updated -y', { exit: 1 });
@@ -110,6 +122,7 @@ export default class CreateFunction extends CreateConfigCommand {
             if (trigger === 'cron' && !flags.schedule) {
                 this.error('Missing required flag for cron trigger: --schedule\n\nExample: swell create function my-func.ts cron -s "0 0 * * *" -y', { exit: 1 });
             }
+            this.validateWorkflowFlags(trigger, flags);
             // Build params with defaults
             const writeFunctionFileParams = {
                 description: flags.description || '',
@@ -127,7 +140,7 @@ export default class CreateFunction extends CreateConfigCommand {
             return;
         }
         // INTERACTIVE PATH
-        const { name: functionName, trigger } = args;
+        const { name: functionName } = args;
         const { description, events, overwrite, route, schedule } = flags;
         let writeFunctionFileParams = {
             description,
@@ -147,27 +160,11 @@ export default class CreateFunction extends CreateConfigCommand {
             ...writeFunctionFileParams,
             ...(await this.gatherInput(writeFunctionFileParams)),
         };
+        this.validateWorkflowFlags(writeFunctionFileParams.trigger, flags);
         await this.writeFunctionFile(writeFunctionFileParams, overwrite, 
         /* shouldConfirm */ true);
     }
     async gatherInput(params) {
-        // Check if there are any extensions in the app configuration
-        const extensions = this.swellConfig.get('extensions') || [];
-        let { extension } = params;
-        const extensionsWithId = extensions.filter((ext) => ext.id);
-        if (extensionsWithId.length > 0 && !extension) {
-            const extensionChoices = [
-                { name: 'Not for an extension', value: '' },
-                ...extensionsWithId.map((ext) => ({
-                    name: ext.id,
-                    value: ext.id,
-                })),
-            ];
-            extension = await select({
-                choices: extensionChoices,
-                message: 'Is this function for an app extension?',
-            });
-        }
         let { language } = params;
         if (!language) {
             language = await select({
@@ -184,8 +181,23 @@ export default class CreateFunction extends CreateConfigCommand {
                 message: 'What language are you using?',
             });
         }
-        let { trigger } = params;
+        let trigger = params.trigger;
         if (!trigger) {
+            trigger = await select({
+                choices: [
+                    {
+                        name: 'Function',
+                        value: 'function',
+                    },
+                    {
+                        name: 'Workflow',
+                        value: 'workflow',
+                    },
+                ],
+                message: 'What are you creating?',
+            });
+        }
+        if (trigger === 'function') {
             trigger = await select({
                 choices: [
                     {
@@ -204,6 +216,24 @@ export default class CreateFunction extends CreateConfigCommand {
                 message: 'How will your function be triggered?',
             });
         }
+        let { extension } = params;
+        if (trigger !== 'workflow') {
+            const extensions = this.swellConfig.get('extensions') || [];
+            const extensionsWithId = extensions.filter((ext) => ext.id);
+            if (extensionsWithId.length > 0 && !extension) {
+                const extensionChoices = [
+                    { name: 'Not for an extension', value: '' },
+                    ...extensionsWithId.map((ext) => ({
+                        name: ext.id,
+                        value: ext.id,
+                    })),
+                ];
+                extension = await select({
+                    choices: extensionChoices,
+                    message: 'Is this function for an app extension?',
+                });
+            }
+        }
         let { events } = params;
         if (trigger === 'model' && !events) {
             events = await input({
@@ -253,9 +283,32 @@ export default class CreateFunction extends CreateConfigCommand {
             language,
             route: route || '',
             schedule: schedule || '',
-            trigger,
+            trigger: trigger,
         };
     }
+    resolveTrigger(positionalTrigger, typeFlag) {
+        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 });
+            }
+            return 'workflow';
+        }
+        return positionalTrigger ? positionalTrigger : undefined;
+    }
+    validateWorkflowFlags(trigger, flags) {
+        if (trigger !== 'workflow') {
+            return;
+        }
+        const invalidFlags = [
+            flags.events ? '--events' : '',
+            flags.schedule ? '--schedule' : '',
+            flags.route ? '--route' : '',
+        ].filter(Boolean);
+        if (invalidFlags.length > 0) {
+            this.error(`Workflow functions do not support ordinary trigger flags: ${invalidFlags.join(', ')}.`, { exit: 1 });
+        }
+    }
     async writeFunctionFile({ description, events, extension, functionName, language, route, schedule, trigger, }, overwrite, shouldConfirm = true) {
         const fileName = toFunctionFileName(functionName);
         await this.createFile({

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

@@ -1,6 +1,7 @@
-import { InspectResourceCommand } from '../../inspect-resource-command.js';
+import { InspectResourceCommand, InspectResourceCommandParsed } from '../../inspect-resource-command.js';
 interface FunctionRecord {
     id?: string;
+    kind?: string;
     name?: string;
     enabled?: boolean;
     cron?: {
@@ -37,6 +38,8 @@ export default class Functions extends InspectResourceCommand {
     protected commandName: string;
     run(): Promise<void>;
     protected metaFor(r: FunctionRecord): string | undefined;
+    protected filterListResults<T>(results: T[]): T[];
+    protected emitDetail(record: FunctionRecord, flags: InspectResourceCommandParsed['flags']): void;
     /**
      * Model-triggered functions emit `/events:webhooks` rows on each invocation.
      * Route and cron functions do not — pointing the agent at an empty query

package/dist/commands/inspect/functions.js

@@ -64,6 +64,17 @@ Identifier forms:
         }
         return parts.length > 0 ? parts.join(' · ') : undefined;
     }
+    filterListResults(results) {
+        return results.filter((record) => record.kind !== 'workflow');
+    }
+    emitDetail(record, flags) {
+        if (record.kind === 'workflow') {
+            const workflowName = record.name || record.id;
+            const workflowRef = record.id || record.name;
+            throw new Error(`Function '${workflowName}' is a workflow. Use "swell inspect workflows ${workflowRef}" instead.`);
+        }
+        super.emitDetail(record, flags);
+    }
     /**
      * Model-triggered functions emit `/events:webhooks` rows on each invocation.
      * Route and cron functions do not — pointing the agent at an empty query

package/dist/commands/inspect/index.js

@@ -8,6 +8,7 @@ export default class Inspect extends Command {
         'swell inspect content app.honest_reviews.reviews',
         'swell inspect webhooks --app=my-app',
         'swell inspect functions app.my-app.payment-sync',
+        'swell inspect workflow-runs --workflow app.my-app.run-import --status active',
         'swell inspect notifications com.orders.receipt.v2',
         'swell inspect settings app.my-app',
     ];

package/dist/commands/inspect/workflow-runs.d.ts

@@ -0,0 +1,34 @@
+import { InspectResourceCommand } from '../../inspect-resource-command.js';
+export default class WorkflowRuns 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: {
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        workflow: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        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;
+    private detailContext?;
+    run(): Promise<void>;
+    protected hints(): string[];
+    private showRecentRunList;
+    private showRunDetail;
+    private getRunDetail;
+    private resolveWorkflowRunScope;
+    private getRunDetailForApp;
+    private getRecentRunsForScopedApp;
+    private getRecentRunsForInstalledApps;
+    private resolveRunListTargets;
+    private getRunListForApp;
+}