pgflow 0.8.1 → 0.9.0

package/README.md

@@ -16,7 +16,6 @@ This package provides essential tools for setting up, managing, and deploying pg
 ## Prerequisites
 
 - Supabase CLI v2.50.3 or higher
-- Deno v2.1.x or higher (for flow compilation)
 - Local Supabase project initialized
 
 ## Installation
@@ -65,13 +64,13 @@ The installer will:
 Convert a TypeScript flow definition into a SQL migration:
 
 ```bash
-npx pgflow@latest compile supabase/functions/_flows/my_flow.ts
+npx pgflow@latest compile my_flow
 ```
 
 Options:
 
-- `--deno-json <path>` - Path to custom deno.json configuration file
 - `--supabase-path <path>` - Path to custom Supabase directory
+- `--control-plane-url <url>` - ControlPlane URL (default: `http://127.0.0.1:54321/functions/v1/pgflow`)
 
 The compiler will:
 

package/dist/commands/compile/index.d.ts

@@ -1,4 +1,11 @@
 import { type Command } from 'commander';
+/**
+ * Fetch flow SQL from ControlPlane HTTP endpoint
+ */
+export declare function fetchFlowSQL(flowSlug: string, controlPlaneUrl: string, secretKey: string): Promise<{
+    flowSlug: string;
+    sql: string[];
+}>;
 declare const _default: (program: Command) => void;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/compile/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/compile/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;yBAmDzB,SAAS,OAAO;AAAhC,wBAsJE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/compile/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAMjD;;GAEG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAsE9C;yBAEe,SAAS,OAAO;AAAhC,wBAkIE"}

package/dist/commands/compile/index.js

@@ -1,73 +1,80 @@
+import { Option } from 'commander';
 import chalk from 'chalk';
-import { intro, log, note, outro } from '@clack/prompts';
+import { intro, log, outro } from '@clack/prompts';
 import path from 'path';
 import fs from 'fs';
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-// Get the directory name in ES modules
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
 /**
- * Formats a command and its arguments for display with syntax highlighting
- * Each argument is displayed on a separate line for better readability
+ * Fetch flow SQL from ControlPlane HTTP endpoint
  */
-function formatCommand(command, args) {
-    const cmd = chalk.cyan(command);
-    const formattedArgs = args.map((arg) => {
-        // Highlight config and file paths differently
-        if (arg.startsWith('--config=')) {
-            const [flag, value] = arg.split('=');
-            return `  ${chalk.yellow(flag)}=${chalk.green(value)}`;
+export async function fetchFlowSQL(flowSlug, controlPlaneUrl, secretKey) {
+    const url = `${controlPlaneUrl}/flows/${flowSlug}`;
+    try {
+        const response = await fetch(url, {
+            headers: {
+                'Authorization': `Bearer ${secretKey}`,
+                'apikey': secretKey,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (response.status === 404) {
+            let errorData = {};
+            try {
+                errorData = await response.json();
+            }
+            catch {
+                // JSON parse failed - likely Supabase gateway error (HTML or plain text)
+            }
+            // Check if this is our ControlPlane's 404 (has 'Flow Not Found' error)
+            // vs Supabase gateway's 404 (function doesn't exist)
+            if (errorData.error === 'Flow Not Found') {
+                throw new Error(`Flow '${flowSlug}' not found.\n\n` +
+                    `${errorData.message || 'Did you add it to supabase/functions/pgflow/index.ts?'}\n\n` +
+                    `Fix:\n` +
+                    `1. Add your flow to supabase/functions/pgflow/index.ts\n` +
+                    `2. Restart edge functions: supabase functions serve`);
+            }
+            // ControlPlane edge function itself doesn't exist
+            throw new Error('ControlPlane edge function not found.\n\n' +
+                'The pgflow edge function is not installed or not running.\n\n' +
+                'Fix:\n' +
+                '1. Run: npx pgflow install\n' +
+                '2. Start edge functions: supabase functions serve\n\n' +
+                'Or use previous version: npx pgflow@0.8.0 compile path/to/flow.ts');
         }
-        else if (arg.startsWith('--')) {
-            return `  ${chalk.yellow(arg)}`;
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP ${response.status}: ${errorText}`);
         }
-        else if (arg.endsWith('.ts') || arg.endsWith('.json')) {
-            return `  ${chalk.green(arg)}`;
+        return await response.json();
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            // Check for connection refused errors
+            if (error.message.includes('ECONNREFUSED') ||
+                error.message.includes('fetch failed')) {
+                throw new Error('Could not connect to ControlPlane.\n\n' +
+                    'Fix options:\n' +
+                    '1. Start Supabase: supabase start\n' +
+                    '2. Start edge functions: supabase functions serve\n\n' +
+                    'Or use previous version: npx pgflow@0.8.0 compile path/to/flow.ts');
+            }
+            throw error;
         }
-        return `  ${chalk.white(arg)}`;
-    });
-    return `$ ${cmd}\n${formattedArgs.join('\n')}`;
-}
-/**
- * Creates a task log entry with a command and its output
- */
-function createTaskLog(command, args, output) {
-    return [
-        chalk.bold('Command:'),
-        formatCommand(command, args),
-        '',
-        chalk.bold('Output:'),
-        output.trim() ? output.trim() : '(no output)',
-    ].join('\n');
+        throw new Error(`Unknown error: ${String(error)}`);
+    }
 }
 export default (program) => {
     program
         .command('compile')
-        .description('Compiles a TypeScript-defined flow into SQL migration')
-        .argument('<flowPath>', 'Path to the flow TypeScript file')
-        .option('--deno-json <denoJsonPath>', 'Path to deno.json configuration file')
+        .description('Compiles a flow into SQL migration via ControlPlane HTTP')
+        .argument('<flowSlug>', 'Flow slug to compile (e.g., my_flow)')
         .option('--supabase-path <supabasePath>', 'Path to the Supabase folder')
-        .action(async (flowPath, options) => {
+        .option('--control-plane-url <url>', 'Control plane URL', 'http://127.0.0.1:54321/functions/v1/pgflow')
+        .addOption(new Option('--secret-key [key]', 'Supabase anon/service_role key')
+        .hideHelp())
+        .action(async (flowSlug, options) => {
         intro('pgflow - Compile Flow to SQL');
         try {
-            // Resolve paths
-            const resolvedFlowPath = path.resolve(process.cwd(), flowPath);
-            // Only resolve denoJsonPath if it's provided
-            let resolvedDenoJsonPath;
-            if (options.denoJson) {
-                resolvedDenoJsonPath = path.resolve(process.cwd(), options.denoJson);
-                // Validate deno.json path if provided
-                if (!fs.existsSync(resolvedDenoJsonPath)) {
-                    log.error(`deno.json file not found: ${resolvedDenoJsonPath}`);
-                    process.exit(1);
-                }
-            }
-            // Validate flow path
-            if (!fs.existsSync(resolvedFlowPath)) {
-                log.error(`Flow file not found: ${resolvedFlowPath}`);
-                process.exit(1);
-            }
             // Validate Supabase path
             let supabasePath;
             if (options.supabasePath) {
@@ -83,14 +90,30 @@ export default (program) => {
                     `Please provide a valid Supabase path using --supabase-path option or ensure ./supabase/ directory exists.`);
                 process.exit(1);
             }
-            // Find the internal_compile.js script
-            const internalCompileScript = path.resolve(__dirname, '../../deno/internal_compile.js');
             // Create migrations directory if it doesn't exist
             const migrationsDir = path.resolve(supabasePath, 'migrations');
             if (!fs.existsSync(migrationsDir)) {
                 fs.mkdirSync(migrationsDir, { recursive: true });
                 log.success(`Created migrations directory: ${migrationsDir}`);
             }
+            // Check for existing migrations
+            const existingMigrations = fs
+                .readdirSync(migrationsDir)
+                .filter((file) => file.endsWith(`_create_${flowSlug}_flow.sql`));
+            if (existingMigrations.length > 0) {
+                log.warn(`Found existing migration(s) for '${flowSlug}':\n` +
+                    existingMigrations.map((f) => `  ${f}`).join('\n') +
+                    '\nCreating new migration anyway...');
+            }
+            // Fetch flow SQL from ControlPlane
+            log.info(`Compiling flow: ${flowSlug}`);
+            const result = await fetchFlowSQL(flowSlug, options.controlPlaneUrl, options.secretKey);
+            // Validate result
+            if (!result.sql || result.sql.length === 0) {
+                throw new Error('ControlPlane returned empty SQL');
+            }
+            // Join SQL statements
+            const compiledSql = result.sql.join('\n') + '\n';
             // Generate timestamp for migration file in format YYYYMMDDHHMMSS using UTC
             const now = new Date();
             const timestamp = [
@@ -101,25 +124,8 @@ export default (program) => {
                 String(now.getUTCMinutes()).padStart(2, '0'),
                 String(now.getUTCSeconds()).padStart(2, '0'),
             ].join('');
-            // Run the compilation
-            log.info(`Compiling flow: ${path.basename(resolvedFlowPath)}`);
-            const compiledSql = await runDenoCompilation(internalCompileScript, resolvedFlowPath, resolvedDenoJsonPath);
-            // Extract flow name from the first line of the SQL output using regex
-            // Looking for pattern: SELECT pgflow.create_flow('flow_name', ...);
-            const flowNameMatch = compiledSql.match(/SELECT\s+pgflow\.create_flow\s*\(\s*'([^']+)'/i);
-            // Use extracted flow name or fallback to the file basename if extraction fails
-            let flowName;
-            if (flowNameMatch && flowNameMatch[1]) {
-                flowName = flowNameMatch[1];
-                log.info(`Extracted flow name: ${flowName}`);
-            }
-            else {
-                // Fallback to file basename if regex doesn't match
-                flowName = path.basename(resolvedFlowPath, path.extname(resolvedFlowPath));
-                log.warn(`Could not extract flow name from SQL, using file basename: ${flowName}`);
-            }
-            // Create migration filename in the format: <timestamp>_create_<flow_name>_flow.sql
-            const migrationFileName = `${timestamp}_create_${flowName}_flow.sql`;
+            // Create migration filename in the format: <timestamp>_create_<flow_slug>_flow.sql
+            const migrationFileName = `${timestamp}_create_${flowSlug}_flow.sql`;
             const migrationFilePath = path.join(migrationsDir, migrationFileName);
             // Write the SQL to a migration file
             fs.writeFileSync(migrationFilePath, compiledSql);
@@ -128,12 +134,12 @@ export default (program) => {
             log.success(`Migration file created: ${relativeFilePath}`);
             // Display next steps with outro
             outro([
-                chalk.bold('Flow compilation completed successfully!'),
+                chalk.green.bold('✓ Flow compilation completed successfully!'),
                 '',
                 `- Run ${chalk.cyan('supabase migration up')} to apply the migration`,
                 '',
                 chalk.bold('Continue the setup:'),
-                chalk.blue.underline('https://pgflow.dev/getting-started/run-flow/')
+                chalk.blue.underline('https://pgflow.dev/getting-started/run-flow/'),
             ].join('\n'));
         }
         catch (error) {
@@ -142,60 +148,9 @@ export default (program) => {
                 chalk.bold('Compilation failed!'),
                 '',
                 chalk.bold('For troubleshooting help:'),
-                chalk.blue.underline('https://pgflow.dev/getting-started/compile-to-sql/')
+                chalk.blue.underline('https://pgflow.dev/getting-started/compile-to-sql/'),
             ].join('\n'));
             process.exit(1);
         }
     });
 };
-/**
- * Runs the Deno compilation script and returns the compiled SQL
- */
-async function runDenoCompilation(scriptPath, flowPath, denoJsonPath) {
-    return new Promise((resolve, reject) => {
-        // Validate input paths
-        if (!scriptPath) {
-            return reject(new Error('Internal script path is required'));
-        }
-        if (!flowPath) {
-            return reject(new Error('Flow path is required'));
-        }
-        // Build the command arguments array
-        const args = ['run', '--allow-read', '--allow-net', '--allow-env'];
-        // Only add the config argument if denoJsonPath is provided and valid
-        if (denoJsonPath && typeof denoJsonPath === 'string') {
-            args.push(`--config=${denoJsonPath}`);
-        }
-        // Add the script path and flow path
-        args.push(scriptPath, flowPath);
-        // Log the command for debugging with colored output
-        log.info('Running Deno compiler');
-        const deno = spawn('deno', args);
-        let stdout = '';
-        let stderr = '';
-        deno.stdout.on('data', (data) => {
-            stdout += data.toString();
-        });
-        deno.stderr.on('data', (data) => {
-            stderr += data.toString();
-        });
-        deno.on('close', (code) => {
-            // Always display the task log with command and output
-            note(createTaskLog('deno', args, stdout));
-            if (code === 0) {
-                if (stdout.trim().length === 0) {
-                    reject(new Error('Compilation produced no output'));
-                }
-                else {
-                    resolve(stdout);
-                }
-            }
-            else {
-                reject(new Error(`Deno process exited with code ${code}${stderr ? `\n${stderr}` : ''}`));
-            }
-        });
-        deno.on('error', (err) => {
-            reject(new Error(`Failed to start Deno process: ${err.message}. Make sure Deno is installed.`));
-        });
-    });
-}

package/dist/commands/install/copy-migrations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copy-migrations.d.ts","sourceRoot":"","sources":["../../../src/commands/install/copy-migrations.ts"],"names":[],"mappings":"AA6JA,wBAAsB,cAAc,CAAC,EACnC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CA6LnB"}
+{"version":3,"file":"copy-migrations.d.ts","sourceRoot":"","sources":["../../../src/commands/install/copy-migrations.ts"],"names":[],"mappings":"AA6JA,wBAAsB,cAAc,CAAC,EACnC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CAyHnB"}

package/dist/commands/install/copy-migrations.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
-import { log, confirm, note } from '@clack/prompts';
+import { log, confirm } from '@clack/prompts';
 import chalk from 'chalk';
 // Get the directory name in ES modules
 const __filename = fileURLToPath(import.meta.url);
@@ -168,30 +168,9 @@ export async function copyMigrations({ supabasePath, autoConfirm = false, }) {
             });
         }
     }
-    // If no files to copy, show message with details and return false (no changes made)
+    // If no files to copy, show message and return false (no changes made)
     if (filesToCopy.length === 0) {
-        // Show success message
-        log.success('All pgflow migrations are already in place');
-        // Show details of already installed migrations
-        if (skippedFiles.length > 0) {
-            const detailedMsg = [
-                'Already installed migrations:',
-                ...skippedFiles.map((file) => {
-                    // Find the matching existing file to show how it was installed
-                    const matchingFile = existingFiles.find((existingFile) => existingFile.includes(file));
-                    if (matchingFile === file) {
-                        // Installed with old direct method
-                        return `  ${chalk.dim('•')} ${chalk.bold(file)}`;
-                    }
-                    else {
-                        // Installed with new timestamped method
-                        const timestampPart = matchingFile?.substring(0, matchingFile.indexOf(file) - 1) || '';
-                        return `  ${chalk.dim('•')} ${chalk.dim(timestampPart + '_')}${chalk.bold(file)}`;
-                    }
-                }),
-            ].join('\n');
-            note(detailedMsg, 'Existing pgflow Migrations');
-        }
+        log.success('Migrations already up to date');
         return false;
     }
     // Generate new timestamps for migrations to install
@@ -203,36 +182,24 @@ export async function copyMigrations({ supabasePath, autoConfirm = false, }) {
         // Create new filename with format: newTimestamp_originalFilename
         file.destination = `${baseTimestamp}_${file.source}`;
     });
-    log.info(`Found ${filesToCopy.length} migration${filesToCopy.length !== 1 ? 's' : ''} to install`);
-    // Prepare summary message with colored output
-    const summaryParts = [];
-    if (filesToCopy.length > 0) {
-        summaryParts.push(`${chalk.green('New migrations to install:')}\n${filesToCopy
-            .map((file) => {
-            // Extract the timestamp part from the new filename
-            const newTimestamp = file.destination.substring(0, 14);
-            // Format: dim timestamp + bright original name
-            return `${chalk.green('+')} ${file.source} → ${chalk.dim(newTimestamp + '_')}${chalk.bold(file.source)}`;
-        })
-            .join('\n')}`);
-    }
-    if (skippedFiles.length > 0) {
-        summaryParts.push(`${chalk.yellow('Already installed:')}\n${skippedFiles
-            .map((file) => `${chalk.yellow('•')} ${file}`)
-            .join('\n')}`);
-    }
-    // Show summary and ask for confirmation if not auto-confirming
-    note(summaryParts.join('\n\n'), 'pgflow Migrations');
-    let shouldContinue = autoConfirm;
+    // Show preview and ask for confirmation only when not auto-confirming
     if (!autoConfirm) {
+        const migrationLines = filesToCopy.map((file) => {
+            return `    ${chalk.bold(file.source)}`;
+        });
+        const summaryMsg = [
+            `Add to ${chalk.cyan('migrations/')} ${chalk.dim('(database schema for workflow engine)')}:`,
+            '',
+            ...migrationLines,
+        ].join('\n');
+        log.info(summaryMsg);
         const confirmResult = await confirm({
-            message: `Install ${filesToCopy.length} new migration${filesToCopy.length !== 1 ? 's' : ''}?`,
+            message: `Add ${filesToCopy.length} migration${filesToCopy.length !== 1 ? 's' : ''}?`,
         });
-        shouldContinue = confirmResult === true;
-    }
-    if (!shouldContinue) {
-        log.warn('Migration installation skipped');
-        return false;
+        if (confirmResult !== true) {
+            log.warn('Migration installation skipped');
+            return false;
+        }
     }
     // Install migrations with new filenames
     for (const file of filesToCopy) {
@@ -240,14 +207,6 @@ export async function copyMigrations({ supabasePath, autoConfirm = false, }) {
         const destinationPath = path.join(migrationsPath, file.destination);
         fs.copyFileSync(sourcePath1, destinationPath);
     }
-    // Show detailed success message with styled filenames
-    const detailedSuccessMsg = [
-        `Installed ${filesToCopy.length} migration${filesToCopy.length !== 1 ? 's' : ''} to your Supabase project:`,
-        ...filesToCopy.map((file) => {
-            const newTimestamp = file.destination.substring(0, 14);
-            return `  ${chalk.dim(newTimestamp + '_')}${chalk.bold(file.source)}`;
-        }),
-    ].join('\n');
-    log.success(detailedSuccessMsg);
+    log.success(`Installed ${filesToCopy.length} migration${filesToCopy.length !== 1 ? 's' : ''}`);
     return true; // Return true to indicate migrations were copied
 }

package/dist/commands/install/create-edge-function.d.ts

@@ -0,0 +1,5 @@
+export declare function createEdgeFunction({ supabasePath, autoConfirm, }: {
+    supabasePath: string;
+    autoConfirm?: boolean;
+}): Promise<boolean>;
+//# sourceMappingURL=create-edge-function.d.ts.map

package/dist/commands/install/create-edge-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-edge-function.d.ts","sourceRoot":"","sources":["../../../src/commands/install/create-edge-function.ts"],"names":[],"mappings":"AA0BA,wBAAsB,kBAAkB,CAAC,EACvC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CAkEnB"}

package/dist/commands/install/create-edge-function.js

@@ -0,0 +1,75 @@
+import fs from 'fs';
+import path from 'path';
+import { log, confirm } from '@clack/prompts';
+import chalk from 'chalk';
+import { getVersion } from '../../utils/get-version.js';
+const INDEX_TS_TEMPLATE = `import { ControlPlane } from '@pgflow/edge-worker';
+import * as flows from '../../flows/index.ts';
+
+ControlPlane.serve(flows);
+`;
+const DENO_JSON_TEMPLATE = (version) => `{
+  "imports": {
+    "@pgflow/core": "npm:@pgflow/core@${version}",
+    "@pgflow/core/": "npm:@pgflow/core@${version}/",
+    "@pgflow/dsl": "npm:@pgflow/dsl@${version}",
+    "@pgflow/dsl/": "npm:@pgflow/dsl@${version}/",
+    "@pgflow/dsl/supabase": "npm:@pgflow/dsl@${version}/supabase",
+    "@pgflow/edge-worker": "jsr:@pgflow/edge-worker@${version}",
+    "@pgflow/edge-worker/": "jsr:@pgflow/edge-worker@${version}/",
+    "@pgflow/edge-worker/_internal": "jsr:@pgflow/edge-worker@${version}/_internal"
+  }
+}
+`;
+export async function createEdgeFunction({ supabasePath, autoConfirm = false, }) {
+    const functionsDir = path.join(supabasePath, 'functions');
+    const pgflowFunctionDir = path.join(functionsDir, 'pgflow');
+    const indexPath = path.join(pgflowFunctionDir, 'index.ts');
+    const denoJsonPath = path.join(pgflowFunctionDir, 'deno.json');
+    // Relative paths for display
+    const relativeFunctionDir = 'supabase/functions/pgflow';
+    const relativeIndexPath = `${relativeFunctionDir}/index.ts`;
+    const relativeDenoJsonPath = `${relativeFunctionDir}/deno.json`;
+    // Check what needs to be created
+    const filesToCreate = [];
+    if (!fs.existsSync(indexPath)) {
+        filesToCreate.push({ path: indexPath, relativePath: relativeIndexPath });
+    }
+    if (!fs.existsSync(denoJsonPath)) {
+        filesToCreate.push({ path: denoJsonPath, relativePath: relativeDenoJsonPath });
+    }
+    // If all files exist, return success
+    if (filesToCreate.length === 0) {
+        log.success('Control Plane already up to date');
+        return false;
+    }
+    // Show preview and ask for confirmation only when not auto-confirming
+    if (!autoConfirm) {
+        const summaryMsg = [
+            `Create ${chalk.cyan('functions/pgflow/')} ${chalk.dim('(Control Plane for flow registration and compilation)')}:`,
+            '',
+            ...filesToCreate.map((file) => `    ${chalk.bold(path.basename(file.relativePath))}`),
+        ].join('\n');
+        log.info(summaryMsg);
+        const confirmResult = await confirm({
+            message: `Create functions/pgflow/?`,
+        });
+        if (confirmResult !== true) {
+            log.warn('Control Plane installation skipped');
+            return false;
+        }
+    }
+    // Create the directory if it doesn't exist
+    if (!fs.existsSync(pgflowFunctionDir)) {
+        fs.mkdirSync(pgflowFunctionDir, { recursive: true });
+    }
+    // Create files
+    if (filesToCreate.some((f) => f.path === indexPath)) {
+        fs.writeFileSync(indexPath, INDEX_TS_TEMPLATE);
+    }
+    if (filesToCreate.some((f) => f.path === denoJsonPath)) {
+        fs.writeFileSync(denoJsonPath, DENO_JSON_TEMPLATE(getVersion()));
+    }
+    log.success('Control Plane installed');
+    return true;
+}

package/dist/commands/install/create-example-worker.d.ts

@@ -0,0 +1,5 @@
+export declare function createExampleWorker({ supabasePath, autoConfirm, }: {
+    supabasePath: string;
+    autoConfirm?: boolean;
+}): Promise<boolean>;
+//# sourceMappingURL=create-example-worker.d.ts.map

package/dist/commands/install/create-example-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-example-worker.d.ts","sourceRoot":"","sources":["../../../src/commands/install/create-example-worker.ts"],"names":[],"mappings":"AA0BA,wBAAsB,mBAAmB,CAAC,EACxC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CAkEnB"}

package/dist/commands/install/create-example-worker.js

@@ -0,0 +1,75 @@
+import fs from 'fs';
+import path from 'path';
+import { log, confirm } from '@clack/prompts';
+import chalk from 'chalk';
+import { getVersion } from '../../utils/get-version.js';
+const INDEX_TS_TEMPLATE = `import { EdgeWorker } from '@pgflow/edge-worker';
+import { GreetUser } from '../../flows/greet-user.ts';
+
+EdgeWorker.start(GreetUser);
+`;
+const DENO_JSON_TEMPLATE = (version) => `{
+  "imports": {
+    "@pgflow/core": "npm:@pgflow/core@${version}",
+    "@pgflow/core/": "npm:@pgflow/core@${version}/",
+    "@pgflow/dsl": "npm:@pgflow/dsl@${version}",
+    "@pgflow/dsl/": "npm:@pgflow/dsl@${version}/",
+    "@pgflow/dsl/supabase": "npm:@pgflow/dsl@${version}/supabase",
+    "@pgflow/edge-worker": "jsr:@pgflow/edge-worker@${version}",
+    "@pgflow/edge-worker/": "jsr:@pgflow/edge-worker@${version}/",
+    "@pgflow/edge-worker/_internal": "jsr:@pgflow/edge-worker@${version}/_internal"
+  }
+}
+`;
+export async function createExampleWorker({ supabasePath, autoConfirm = false, }) {
+    const functionsDir = path.join(supabasePath, 'functions');
+    const workerDir = path.join(functionsDir, 'greet-user-worker');
+    const indexPath = path.join(workerDir, 'index.ts');
+    const denoJsonPath = path.join(workerDir, 'deno.json');
+    // Relative paths for display
+    const relativeWorkerDir = 'supabase/functions/greet-user-worker';
+    const relativeIndexPath = `${relativeWorkerDir}/index.ts`;
+    const relativeDenoJsonPath = `${relativeWorkerDir}/deno.json`;
+    // Check what needs to be created
+    const filesToCreate = [];
+    if (!fs.existsSync(indexPath)) {
+        filesToCreate.push({ path: indexPath, relativePath: relativeIndexPath });
+    }
+    if (!fs.existsSync(denoJsonPath)) {
+        filesToCreate.push({ path: denoJsonPath, relativePath: relativeDenoJsonPath });
+    }
+    // If all files exist, return success
+    if (filesToCreate.length === 0) {
+        log.success('Example worker already up to date');
+        return false;
+    }
+    // Show preview and ask for confirmation only when not auto-confirming
+    if (!autoConfirm) {
+        const summaryMsg = [
+            `Create ${chalk.cyan('functions/greet-user-worker/')} ${chalk.dim('(example worker for GreetUser flow)')}:`,
+            '',
+            ...filesToCreate.map((file) => `    ${chalk.bold(path.basename(file.relativePath))}`),
+        ].join('\n');
+        log.info(summaryMsg);
+        const confirmResult = await confirm({
+            message: `Create functions/greet-user-worker/?`,
+        });
+        if (confirmResult !== true) {
+            log.warn('Example worker installation skipped');
+            return false;
+        }
+    }
+    // Create the directory if it doesn't exist
+    if (!fs.existsSync(workerDir)) {
+        fs.mkdirSync(workerDir, { recursive: true });
+    }
+    // Create files
+    if (filesToCreate.some((f) => f.path === indexPath)) {
+        fs.writeFileSync(indexPath, INDEX_TS_TEMPLATE);
+    }
+    if (filesToCreate.some((f) => f.path === denoJsonPath)) {
+        fs.writeFileSync(denoJsonPath, DENO_JSON_TEMPLATE(getVersion()));
+    }
+    log.success('Example worker created');
+    return true;
+}

package/dist/commands/install/create-flows-directory.d.ts

@@ -0,0 +1,5 @@
+export declare function createFlowsDirectory({ supabasePath, autoConfirm, }: {
+    supabasePath: string;
+    autoConfirm?: boolean;
+}): Promise<boolean>;
+//# sourceMappingURL=create-flows-directory.d.ts.map

package/dist/commands/install/create-flows-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-flows-directory.d.ts","sourceRoot":"","sources":["../../../src/commands/install/create-flows-directory.ts"],"names":[],"mappings":"AA+BA,wBAAsB,oBAAoB,CAAC,EACzC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CAiEnB"}

package/dist/commands/install/create-flows-directory.js

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import path from 'path';
+import { log, confirm } from '@clack/prompts';
+import chalk from 'chalk';
+const INDEX_TS_TEMPLATE = `// Re-export all flows from this directory
+// Example: export { MyFlow } from './my-flow.ts';
+
+export { GreetUser } from './greet-user.ts';
+`;
+const GREET_USER_TEMPLATE = `import { Flow } from '@pgflow/dsl';
+
+type Input = {
+  firstName: string;
+  lastName: string;
+};
+
+export const GreetUser = new Flow<Input>({
+  slug: 'greetUser',
+})
+  .step(
+    { slug: 'fullName' },
+    (input) => \`\${input.run.firstName} \${input.run.lastName}\`
+  )
+  .step(
+    { slug: 'greeting', dependsOn: ['fullName'] },
+    (input) => \`Hello, \${input.fullName}!\`
+  );
+`;
+export async function createFlowsDirectory({ supabasePath, autoConfirm = false, }) {
+    const flowsDir = path.join(supabasePath, 'flows');
+    const indexPath = path.join(flowsDir, 'index.ts');
+    const greetUserPath = path.join(flowsDir, 'greet-user.ts');
+    // Relative paths for display
+    const relativeFlowsDir = 'supabase/flows';
+    const relativeIndexPath = `${relativeFlowsDir}/index.ts`;
+    const relativeGreetUserPath = `${relativeFlowsDir}/greet-user.ts`;
+    // Check what needs to be created
+    const filesToCreate = [];
+    if (!fs.existsSync(indexPath)) {
+        filesToCreate.push({ path: indexPath, relativePath: relativeIndexPath });
+    }
+    if (!fs.existsSync(greetUserPath)) {
+        filesToCreate.push({ path: greetUserPath, relativePath: relativeGreetUserPath });
+    }
+    // If all files exist, return success
+    if (filesToCreate.length === 0) {
+        log.success('Flows directory already up to date');
+        return false;
+    }
+    // Show preview and ask for confirmation only when not auto-confirming
+    if (!autoConfirm) {
+        const summaryMsg = [
+            `Create ${chalk.cyan('flows/')} ${chalk.dim('(flow definitions directory)')}:`,
+            '',
+            ...filesToCreate.map((file) => `    ${chalk.bold(path.basename(file.relativePath))}`),
+        ].join('\n');
+        log.info(summaryMsg);
+        const confirmResult = await confirm({
+            message: `Create flows/?`,
+        });
+        if (confirmResult !== true) {
+            log.warn('Flows directory installation skipped');
+            return false;
+        }
+    }
+    // Create the directory if it doesn't exist
+    if (!fs.existsSync(flowsDir)) {
+        fs.mkdirSync(flowsDir, { recursive: true });
+    }
+    // Create files
+    if (filesToCreate.some((f) => f.path === indexPath)) {
+        fs.writeFileSync(indexPath, INDEX_TS_TEMPLATE);
+    }
+    if (filesToCreate.some((f) => f.path === greetUserPath)) {
+        fs.writeFileSync(greetUserPath, GREET_USER_TEMPLATE);
+    }
+    log.success('Flows directory created');
+    return true;
+}

package/dist/commands/install/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/install/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;yBAQzB,SAAS,OAAO;AAAhC,wBAiHE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/install/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;yBAWzB,SAAS,OAAO;AAAhC,wBA6HE"}

package/dist/commands/install/index.js

@@ -1,8 +1,11 @@
-import { intro, group, cancel, outro } from '@clack/prompts';
+import { intro, log, confirm, cancel, outro } from '@clack/prompts';
 import chalk from 'chalk';
 import { copyMigrations } from './copy-migrations.js';
 import { updateConfigToml } from './update-config-toml.js';
 import { updateEnvFile } from './update-env-file.js';
+import { createEdgeFunction } from './create-edge-function.js';
+import { createFlowsDirectory } from './create-flows-directory.js';
+import { createExampleWorker } from './create-example-worker.js';
 import { supabasePathPrompt } from './supabase-path-prompt.js';
 export default (program) => {
     program
@@ -12,79 +15,90 @@ export default (program) => {
         .option('-y, --yes', 'Automatically confirm all prompts', false)
         .action(async (options) => {
         intro('Installing pgflow in your Supabase project');
-        // Use the group feature to organize installation steps
-        const results = await group({
-            // Step 1: Determine Supabase path
-            supabasePath: () => supabasePathPrompt({ supabasePath: options.supabasePath }),
-            // Step 2: Update config.toml
-            configUpdate: async ({ results: { supabasePath } }) => {
-                if (!supabasePath)
-                    return false;
-                return await updateConfigToml({
-                    supabasePath,
-                    autoConfirm: options.yes,
-                });
-            },
-            // Step 3: Copy migrations
-            migrations: async ({ results: { supabasePath } }) => {
-                if (!supabasePath)
-                    return false;
-                return await copyMigrations({
-                    supabasePath,
-                    autoConfirm: options.yes,
-                });
-            },
-            // Step 4: Update environment variables
-            envFile: async ({ results: { supabasePath } }) => {
-                if (!supabasePath)
-                    return false;
-                return await updateEnvFile({
-                    supabasePath,
-                    autoConfirm: options.yes,
-                });
-            },
-        }, {
-            // Handle cancellation
-            onCancel: () => {
-                cancel('Installation cancelled');
-                process.exit(1);
-            },
+        // Step 1: Get supabase path
+        const supabasePathResult = await supabasePathPrompt({
+            supabasePath: options.supabasePath,
         });
-        // Extract the results from the group operation
-        const supabasePath = results.supabasePath;
-        const configUpdate = results.configUpdate;
-        const migrations = results.migrations;
-        const envFile = results.envFile;
-        // Exit if supabasePath is null (validation failed or user cancelled)
-        if (!supabasePath) {
+        if (!supabasePathResult || typeof supabasePathResult === 'symbol') {
             cancel('Installation cancelled - valid Supabase path is required');
             process.exit(1);
         }
-        // Show completion message
+        const supabasePath = supabasePathResult;
+        // Step 2: Show summary and get single confirmation
+        const summaryMsg = [
+            'This will:',
+            '',
+            `  • Update ${chalk.cyan('supabase/config.toml')} ${chalk.dim('(enable pooler, per_worker runtime)')}`,
+            `  • Add pgflow migrations to ${chalk.cyan('supabase/migrations/')}`,
+            `  • Create ${chalk.cyan('supabase/flows/')} ${chalk.dim('(flow definitions with GreetUser example)')}`,
+            `  • Create Control Plane in ${chalk.cyan('supabase/functions/pgflow/')}`,
+            `  • Create ${chalk.cyan('supabase/functions/greet-user-worker/')} ${chalk.dim('(example worker)')}`,
+            `  • Configure ${chalk.cyan('supabase/functions/.env')}`,
+            '',
+            `  ${chalk.green('✓ Safe to re-run - completed steps will be skipped')}`,
+        ].join('\n');
+        log.info(summaryMsg);
+        let shouldProceed = options.yes;
+        if (!options.yes) {
+            const confirmResult = await confirm({
+                message: 'Proceed?',
+            });
+            if (confirmResult !== true) {
+                cancel('Installation cancelled');
+                process.exit(1);
+            }
+            shouldProceed = true;
+        }
+        if (!shouldProceed) {
+            cancel('Installation cancelled');
+            process.exit(1);
+        }
+        // Step 3: Run all installation steps with autoConfirm
+        const configUpdate = await updateConfigToml({
+            supabasePath,
+            autoConfirm: true,
+        });
+        const migrations = await copyMigrations({
+            supabasePath,
+            autoConfirm: true,
+        });
+        const flowsDirectory = await createFlowsDirectory({
+            supabasePath,
+            autoConfirm: true,
+        });
+        const edgeFunction = await createEdgeFunction({
+            supabasePath,
+            autoConfirm: true,
+        });
+        const exampleWorker = await createExampleWorker({
+            supabasePath,
+            autoConfirm: true,
+        });
+        const envFile = await updateEnvFile({
+            supabasePath,
+            autoConfirm: true,
+        });
+        // Step 4: Show completion message
         const outroMessages = [];
-        // Always start with a bolded acknowledgement
-        if (migrations || configUpdate || envFile) {
-            outroMessages.push(chalk.bold('pgflow setup completed successfully!'));
+        if (migrations || configUpdate || flowsDirectory || edgeFunction || exampleWorker || envFile) {
+            outroMessages.push(chalk.green.bold('✓ Installation complete!'));
         }
         else {
-            outroMessages.push(chalk.bold('pgflow is already properly configured - no changes needed!'));
+            outroMessages.push(chalk.green.bold('✓ pgflow is already installed - no changes needed!'));
         }
-        // Add a newline after the acknowledgement
+        // Add numbered next steps
         outroMessages.push('');
-        // Add specific next steps if changes were made
+        outroMessages.push('Next steps:');
+        let stepNumber = 1;
         if (configUpdate || envFile) {
-            outroMessages.push(`- Restart your Supabase instance for configuration changes to take effect`);
+            outroMessages.push(`  ${stepNumber}. Restart Supabase: ${chalk.cyan('supabase stop && supabase start')}`);
+            stepNumber++;
         }
         if (migrations) {
-            outroMessages.push(`- Apply the migrations with: ${chalk.cyan('supabase migrations up')}`);
-        }
-        // Always add documentation link with consistent formatting
-        if (outroMessages.length > 2) {
-            // If we have specific steps, add another newline
-            outroMessages.push('');
+            outroMessages.push(`  ${stepNumber}. Apply migrations: ${chalk.cyan('supabase migrations up')}`);
+            stepNumber++;
         }
-        outroMessages.push(chalk.bold('Continue the setup:'), chalk.blue.underline('https://pgflow.dev/getting-started/create-first-flow/'));
-        // Single outro for all paths
+        outroMessages.push(`  ${stepNumber}. Run the example: ${chalk.blue.underline('https://pgflow.dev/get-started/flows/quickstart/')}`);
         outro(outroMessages.join('\n'));
     });
 };

package/dist/commands/install/supabase-path-prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"supabase-path-prompt.d.ts","sourceRoot":"","sources":["../../../src/commands/install/supabase-path-prompt.ts"],"names":[],"mappings":"AAIA,wBAAsB,kBAAkB,CAAC,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,4BA6C3E"}
+{"version":3,"file":"supabase-path-prompt.d.ts","sourceRoot":"","sources":["../../../src/commands/install/supabase-path-prompt.ts"],"names":[],"mappings":"AAIA,wBAAsB,kBAAkB,CAAC,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,4BAwC3E"}

package/dist/commands/install/supabase-path-prompt.js

@@ -22,10 +22,6 @@ export async function supabasePathPrompt(options) {
             break;
         }
     }
-    // Always prompt for detected paths - don't skip
-    if (detectedPath) {
-        log.info(`Found Supabase project at: ${detectedPath}`);
-    }
     const promptMessage = 'Where is your Supabase project located?';
     const supabasePath = await text({
         message: promptMessage,

package/dist/commands/install/update-config-toml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-config-toml.d.ts","sourceRoot":"","sources":["../../../src/commands/install/update-config-toml.ts"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CAwHnB"}
+{"version":3,"file":"update-config-toml.d.ts","sourceRoot":"","sources":["../../../src/commands/install/update-config-toml.ts"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CA4HnB"}

package/dist/commands/install/update-config-toml.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { log, confirm, note } from '@clack/prompts';
+import { log, confirm } from '@clack/prompts';
 import * as TOML from '@decimalturn/toml-patch';
 import chalk from 'chalk';
 /**
@@ -45,36 +45,42 @@ export async function updateConfigToml({ supabasePath, autoConfirm = false, }) {
             currentSettings.poolMode !== 'transaction' ||
             currentSettings.edgeRuntimePolicy !== 'per_worker';
         if (!needsChanges) {
-            log.success('Supabase configuration is already set up for pgflow');
+            log.success('Configuration already up to date');
             return false;
         }
-        const changes = [];
-        if (currentSettings.poolerEnabled !== true) {
-            changes.push(`${chalk.bold('Enable connection pooler:')}
-${chalk.red(`- enabled = ${currentSettings.poolerEnabled}`)}
-${chalk.green('+ enabled = true')}`);
-        }
-        if (currentSettings.poolMode !== 'transaction') {
-            changes.push(`${chalk.bold('Set pool mode to transaction:')}
-${chalk.red(`- pool_mode = "${currentSettings.poolMode}"`)}
-${chalk.green('+ pool_mode = "transaction"')}`);
-        }
-        if (currentSettings.edgeRuntimePolicy !== 'per_worker') {
-            changes.push(`${chalk.bold('Set edge runtime policy:')}
-${chalk.red(`- policy = "${currentSettings.edgeRuntimePolicy}"`)}
-${chalk.green('+ policy = "per_worker"')}`);
-        }
-        note(changes.join('\n\n'), 'Required Configuration Changes');
-        let shouldContinue = autoConfirm;
+        // Show preview and ask for confirmation only when not auto-confirming
         if (!autoConfirm) {
+            const changes = [];
+            // Connection pooler changes
+            const poolerChanges = [];
+            if (currentSettings.poolerEnabled !== true) {
+                poolerChanges.push(`enabled = ${currentSettings.poolerEnabled} ${chalk.dim('->')} ${chalk.green('true')}`);
+            }
+            if (currentSettings.poolMode !== 'transaction') {
+                poolerChanges.push(`pool_mode = "${currentSettings.poolMode}" ${chalk.dim('->')} ${chalk.green('"transaction"')}`);
+            }
+            if (poolerChanges.length > 0) {
+                changes.push(`  ${chalk.bold('[db.pooler]')} ${chalk.dim('(required for pgflow worker)')}`);
+                poolerChanges.forEach(change => changes.push(`    ${change}`));
+            }
+            // Edge runtime changes
+            if (currentSettings.edgeRuntimePolicy !== 'per_worker') {
+                changes.push(`  ${chalk.bold('[edge_runtime]')} ${chalk.dim('(required for long-running tasks)')}`);
+                changes.push(`    policy = "${currentSettings.edgeRuntimePolicy}" ${chalk.dim('->')} ${chalk.green('"per_worker"')}`);
+            }
+            const summaryMsg = [
+                `Update ${chalk.cyan('config.toml')}:`,
+                '',
+                ...changes,
+            ].join('\n');
+            log.info(summaryMsg);
             const confirmResult = await confirm({
-                message: `Update Supabase configuration? (a backup will be created)`,
+                message: `Update config.toml? (backup will be created)`,
             });
-            shouldContinue = confirmResult === true;
-        }
-        if (!shouldContinue) {
-            log.warn('Configuration update skipped');
-            return false;
+            if (confirmResult !== true) {
+                log.warn('Configuration update skipped');
+                return false;
+            }
         }
         // Update Supabase configuration
         // Create backup
@@ -109,7 +115,7 @@ ${chalk.green('+ policy = "per_worker"')}`);
             log.error(`Failed to write ${configPath}: ${errorMsg}`);
             throw new Error(`Failed to write ${configPath}: ${errorMsg}`);
         }
-        log.success('Supabase configuration updated successfully');
+        log.success('Configuration updated');
         return true;
     }
     catch (error) {

package/dist/commands/install/update-env-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-env-file.d.ts","sourceRoot":"","sources":["../../../src/commands/install/update-env-file.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,EAClC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CAqHnB"}
+{"version":3,"file":"update-env-file.d.ts","sourceRoot":"","sources":["../../../src/commands/install/update-env-file.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,EAClC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CA2FnB"}

package/dist/commands/install/update-env-file.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { log, note, confirm } from '@clack/prompts';
+import { log, confirm } from '@clack/prompts';
 import chalk from 'chalk';
 /**
  * Updates the functions/.env file with required environment variables for pgflow
@@ -33,57 +33,35 @@ export async function updateEnvFile({ supabasePath, autoConfirm = false, }) {
     }
     // Prepare new content
     let newContent = currentContent;
-    // Build diff preview
-    const missingVars = [];
-    const existingVars = [];
     // Check which variables need to be added
+    const missingVars = [];
     for (const [key, value] of Object.entries(envVars)) {
         if (!newContent.includes(`${key}=`)) {
             missingVars.push({ key, value });
         }
-        else {
-            existingVars.push(key);
-        }
     }
     // If no changes needed, return early
     if (missingVars.length === 0) {
-        log.success('Environment variables are already set');
+        log.success('Environment variables already configured');
         return false;
     }
-    log.info(`Found ${missingVars.length} variable${missingVars.length !== 1 ? 's' : ''} to add`);
-    // Build diff preview
-    const diffPreview = [];
-    if (isNewFile) {
-        diffPreview.push(`${chalk.green('Creating new .env file with:')}`);
-    }
-    else {
-        diffPreview.push(`${chalk.green('Adding to existing .env file:')}`);
-    }
-    // Show variables to be added
-    for (const { key, value } of missingVars) {
-        diffPreview.push(`${chalk.green('+')} ${key}="${value}"`);
-    }
-    // Show existing variables if any
-    if (existingVars.length > 0) {
-        diffPreview.push('');
-        diffPreview.push(`${chalk.yellow('Already present:')}`);
-        for (const key of existingVars) {
-            diffPreview.push(`${chalk.yellow('•')} ${key}`);
-        }
-    }
-    // Show the diff preview
-    note(diffPreview.join('\n'), 'Environment Variables');
-    // Ask for confirmation if not auto-confirming
-    let shouldContinue = autoConfirm;
+    // Show preview and ask for confirmation only when not auto-confirming
     if (!autoConfirm) {
+        const summaryParts = [
+            isNewFile
+                ? `Create ${chalk.cyan('functions/.env')} ${chalk.dim('(worker configuration)')}:`
+                : `Update ${chalk.cyan('functions/.env')} ${chalk.dim('(worker configuration)')}:`,
+            '',
+            ...missingVars.map(({ key, value }) => `    ${chalk.bold(key)}="${value}"`),
+        ];
+        log.info(summaryParts.join('\n'));
         const confirmResult = await confirm({
-            message: `Update environment variables?`,
+            message: isNewFile ? `Create functions/.env?` : `Update functions/.env?`,
         });
-        shouldContinue = confirmResult === true;
-    }
-    if (!shouldContinue) {
-        log.warn('Environment variable update skipped');
-        return false;
+        if (confirmResult !== true) {
+            log.warn('Environment variable update skipped');
+            return false;
+        }
     }
     // Update environment variables
     // Apply changes if confirmed
@@ -98,7 +76,7 @@ export async function updateEnvFile({ supabasePath, autoConfirm = false, }) {
     // Write the file if changes were made
     try {
         fs.writeFileSync(envFilePath, newContent);
-        log.success('Environment variables updated successfully');
+        log.success('Environment variables configured');
         return true;
     }
     catch (error) {

package/dist/index.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { fileURLToPath } from 'url';
-import { readFileSync } from 'fs';
-import { dirname, join } from 'path';
 import installCommand from './commands/install/index.js';
 import compileCommand from './commands/compile/index.js';
+import { getVersion } from './utils/get-version.js';
 // Create a function to handle errors
 const errorHandler = (error) => {
     console.error('Error:', error instanceof Error ? error.message : String(error));
@@ -12,21 +10,6 @@ const errorHandler = (error) => {
 };
 // Set up process-wide unhandled rejection handler
 process.on('unhandledRejection', errorHandler);
-// Function to get version from package.json
-function getVersion() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const packageJsonPath = join(__dirname, '..', 'package.json');
-    try {
-        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-        return packageJson.version || 'unknown';
-    }
-    catch (error) {
-        // Log error but don't display it to the user when showing version
-        console.error('Error reading package.json:', error);
-        return 'unknown';
-    }
-}
 const program = new Command();
 program
     .name('npx pgflow')
@@ -50,18 +33,19 @@ const g = chalk.hex('#9ece6a'); // vibrant green
 const l = chalk.hex('#2ac3de'); // bright teal/cyan
 // const o = chalk.hex('#ff9e64'); // orange
 // const w = chalk.hex('#f7768e'); // magenta/pink
+const d = chalk.dim; // dim for secondary text
 const banner = [
-    `                ${l('__ _')}                 `,
-    `   ${g('_ __   __ _')} ${l('/ _| | _____      __')}  `,
-    `  ${g("| '_ \\ / _'")} ${l('| |_| |/ _ \\ \\ /\\ / /')}  `,
-    `  ${g('| |_) | (_|')} ${l('|  _| | (_) \\ V  V /')}   `,
-    `  ${g('| .__/ \\__,')} ${l('|_| |_|\\___/ \\_/\\_/')}    `,
-    `  ${g('|_|    |___/')}`,
+    `                    ${l('__ _')}`,
+    `       ${g('_ __   __ _')} ${l('/ _| | _____      __')}`,
+    `      ${g("| '_ \\ / _'")} ${l('| |_| |/ _ \\ \\ /\\ / /')}`,
+    `      ${g('| |_) | (_|')} ${l('|  _| | (_) \\ V  V /')}`,
+    `      ${g('| .__/ \\__,')} ${l('|_| |_|\\___/ \\_/\\_/')}`,
+    `      ${g('|_|    |___/')}                ${d('v' + getVersion())}`,
+    ``,
+    `      ${l('Workflows in Supabase')} ${d('|')} ${g.underline('pgflow.dev')}`,
 ].join('\n');
 console.log(banner);
 console.log();
-console.log();
-console.log();
 // Use a promise-aware approach to parse arguments
 async function main() {
     try {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgflow",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",

package/dist/utils/get-version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get the version from package.json
+ * Reads the version from the package.json file located one directory up from the compiled dist/ folder
+ */
+export declare function getVersion(): string;
+//# sourceMappingURL=get-version.d.ts.map

package/dist/utils/get-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-version.d.ts","sourceRoot":"","sources":["../../src/utils/get-version.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAanC"}

package/dist/utils/get-version.js

@@ -0,0 +1,21 @@
+import { fileURLToPath } from 'url';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+/**
+ * Get the version from package.json
+ * Reads the version from the package.json file located one directory up from the compiled dist/ folder
+ */
+export function getVersion() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packageJsonPath = join(__dirname, '..', '..', 'package.json');
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return packageJson.version || 'unknown';
+    }
+    catch (error) {
+        // Log error but don't display it to the user when showing version
+        console.error('Error reading package.json:', error);
+        return 'unknown';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgflow",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "@decimalturn/toml-patch": "0.3.7",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
-    "@pgflow/core": "0.8.1"
+    "@pgflow/core": "0.9.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/deno/internal_compile.js

@@ -1,55 +0,0 @@
-/**
- * internal_compile.js
- *
- * This script is executed by Deno to compile a Flow into SQL statements.
- * It takes a path to a flow file as an argument, imports the default export,
- * and passes it to compileFlow() from the DSL package.
- */
-
-// Import the compileFlow function directly from @pgflow/dsl
-// The import map in deno.json will resolve this import
-import { compileFlow } from '@pgflow/dsl';
-
-// Get the flow file path from command line arguments
-const flowFilePath = Deno.args[0];
-
-if (!flowFilePath) {
-  console.error('Error: No flow file path provided');
-  Deno.exit(1);
-}
-
-try {
-  // Dynamically import the flow file
-  const flowModule = await import(`file://${flowFilePath}`);
-
-  // Check if there's a default export
-  if (!flowModule.default) {
-    console.error(`Error: No default export found in ${flowFilePath}`);
-    Deno.exit(1);
-  }
-
-  // Get the flow instance
-  const flow = flowModule.default;
-
-  // Compile the flow to SQL
-  const sqlStatements = compileFlow(flow);
-
-  // Output the SQL statements to stdout
-  console.log(sqlStatements.join('\n'));
-} catch (error) {
-  console.error(`Error compiling flow: ${error.message}`);
-
-  // If the error is related to importing compileFlow, provide more detailed error
-  if (error.message.includes('@pgflow/dsl')) {
-    console.error(
-      'Failed to import compileFlow from @pgflow/dsl. This might be due to:'
-    );
-    console.error(
-      '1. The function not being exported correctly from the package'
-    );
-    console.error('2. A version mismatch between the CLI and DSL packages');
-    console.error('3. Issues with the Deno import map configuration');
-  }
-
-  Deno.exit(1);
-}