pgflow 0.0.0-test-snapshot-releases-8d5d9bc1-20250922101013 → 0.0.0-testsnap-c8dfbf89-20251207204700

package/README.md

@@ -1,4 +1,4 @@
-# @pgflow/cli
+# pgflow CLI
 
 The Command Line Interface for pgflow - a PostgreSQL-native workflow engine.
 
@@ -7,7 +7,7 @@ The Command Line Interface for pgflow - a PostgreSQL-native workflow engine.
 
 ## Overview
 
-`@pgflow/cli` provides essential tools for setting up, managing, and deploying pgflow workflows in your Supabase environment. The CLI handles:
+This package provides essential tools for setting up, managing, and deploying pgflow workflows in your Supabase environment. The CLI handles:
 
 - Installing pgflow in your Supabase project
 - Compiling TypeScript workflow definitions into SQL migrations
@@ -15,8 +15,7 @@ The Command Line Interface for pgflow - a PostgreSQL-native workflow engine.
 
 ## Prerequisites
 
-- Supabase CLI v2.0.2 or higher
-- Deno v1.45.x or higher (for flow compilation)
+- Supabase CLI v2.50.3 or higher
 - 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 with import map
 - `--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

@@ -0,0 +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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,156 @@
+import { Option } from 'commander';
+import chalk from 'chalk';
+import { intro, log, outro } from '@clack/prompts';
+import path from 'path';
+import fs from 'fs';
+/**
+ * Fetch flow SQL from ControlPlane HTTP endpoint
+ */
+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');
+        }
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP ${response.status}: ${errorText}`);
+        }
+        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;
+        }
+        throw new Error(`Unknown error: ${String(error)}`);
+    }
+}
+export default (program) => {
+    program
+        .command('compile')
+        .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')
+        .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 {
+            // Validate Supabase path
+            let supabasePath;
+            if (options.supabasePath) {
+                supabasePath = path.resolve(process.cwd(), options.supabasePath);
+            }
+            else {
+                // Default to ./supabase/ if not provided
+                supabasePath = path.resolve(process.cwd(), 'supabase');
+            }
+            // Check if Supabase path exists
+            if (!fs.existsSync(supabasePath)) {
+                log.error(`Supabase directory not found: ${supabasePath}\n` +
+                    `Please provide a valid Supabase path using --supabase-path option or ensure ./supabase/ directory exists.`);
+                process.exit(1);
+            }
+            // 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 = [
+                now.getUTCFullYear(),
+                String(now.getUTCMonth() + 1).padStart(2, '0'),
+                String(now.getUTCDate()).padStart(2, '0'),
+                String(now.getUTCHours()).padStart(2, '0'),
+                String(now.getUTCMinutes()).padStart(2, '0'),
+                String(now.getUTCSeconds()).padStart(2, '0'),
+            ].join('');
+            // 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);
+            // Show the migration file path relative to the current directory
+            const relativeFilePath = path.relative(process.cwd(), migrationFilePath);
+            log.success(`Migration file created: ${relativeFilePath}`);
+            // Display next steps with outro
+            outro([
+                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/'),
+            ].join('\n'));
+        }
+        catch (error) {
+            log.error(`Compilation failed: ${error instanceof Error ? error.message : String(error)}`);
+            outro([
+                chalk.bold('Compilation failed!'),
+                '',
+                chalk.bold('For troubleshooting help:'),
+                chalk.blue.underline('https://pgflow.dev/getting-started/compile-to-sql/'),
+            ].join('\n'));
+            process.exit(1);
+        }
+    });
+};

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

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

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

@@ -0,0 +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,CAyHnB"}

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

@@ -0,0 +1,212 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { log, confirm } from '@clack/prompts';
+import chalk from 'chalk';
+// Get the directory name in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Create a require function to use require.resolve
+const require = createRequire(import.meta.url);
+// Function to find migrations directory
+function findMigrationsDirectory() {
+    try {
+        // First try: resolve from installed @pgflow/core package
+        const corePackageJsonPath = require.resolve('@pgflow/core/package.json');
+        const corePackageFolder = path.dirname(corePackageJsonPath);
+        const packageMigrationsPath = path.join(corePackageFolder, 'dist', 'supabase', 'migrations');
+        if (fs.existsSync(packageMigrationsPath)) {
+            return packageMigrationsPath;
+        }
+        // If that fails, try development path
+        log.info('Could not find migrations in installed package, trying development paths...');
+    }
+    catch (error) {
+        log.info('Could not resolve @pgflow/core package, trying development paths...');
+    }
+    // Try development paths
+    // 1. Try relative to CLI dist folder (when running built CLI)
+    const distRelativePath = path.resolve(__dirname, '../../../../core/supabase/migrations');
+    if (fs.existsSync(distRelativePath)) {
+        return distRelativePath;
+    }
+    // 2. Try relative to CLI source folder (when running from source)
+    const sourceRelativePath = path.resolve(__dirname, '../../../../../core/supabase/migrations');
+    if (fs.existsSync(sourceRelativePath)) {
+        return sourceRelativePath;
+    }
+    // 3. Try local migrations directory (for backward compatibility)
+    const localMigrationsPath = path.resolve(__dirname, '../../migrations');
+    if (fs.existsSync(localMigrationsPath)) {
+        return localMigrationsPath;
+    }
+    // No migrations found
+    return null;
+}
+// Helper function to get the timestamp part from a migration filename
+function getTimestampFromFilename(filename) {
+    const match = filename.match(/^(\d+)_/);
+    // Return the timestamp only if it exists and has the correct length (14 digits)
+    if (match && match[1] && match[1].length === 14 && /^\d{14}$/.test(match[1])) {
+        return match[1];
+    }
+    return '';
+}
+// Helper function to format a Date object into a migration timestamp string (YYYYMMDDhhmmss) using UTC
+function formatDateToTimestamp(date) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    const hours = String(date.getUTCHours()).padStart(2, '0');
+    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+    const seconds = String(date.getUTCSeconds()).padStart(2, '0');
+    return `${year}${month}${day}${hours}${minutes}${seconds}`;
+}
+// Helper function to parse a timestamp string into a Date object (interpreted as UTC)
+function parseTimestampToDate(timestamp) {
+    // Validate format: YYYYMMDDhhmmss
+    if (!timestamp || timestamp.length !== 14 || !/^\d{14}$/.test(timestamp)) {
+        return null;
+    }
+    const year = parseInt(timestamp.substring(0, 4), 10);
+    const month = parseInt(timestamp.substring(4, 6), 10) - 1; // months are 0-indexed in JS Date
+    const day = parseInt(timestamp.substring(6, 8), 10);
+    const hours = parseInt(timestamp.substring(8, 10), 10);
+    const minutes = parseInt(timestamp.substring(10, 12), 10);
+    const seconds = parseInt(timestamp.substring(12, 14), 10);
+    // Create date in UTC and validate (invalid dates like Feb 31 will be auto-corrected by JS Date)
+    const date = new Date(Date.UTC(year, month, day, hours, minutes, seconds));
+    // Additional validation to ensure the parsed date matches the input
+    // This catches edge cases like month=13 that JS Date would autocorrect
+    if (date.getUTCFullYear() !== year ||
+        date.getUTCMonth() !== month ||
+        date.getUTCDate() !== day ||
+        date.getUTCHours() !== hours ||
+        date.getUTCMinutes() !== minutes ||
+        date.getUTCSeconds() !== seconds) {
+        return null;
+    }
+    return date;
+}
+// Helper function to generate a new timestamp that's higher than the reference timestamp (using UTC)
+function generateNewTimestamp(referenceTimestamp, increment = 1) {
+    // First try to parse the reference timestamp to a Date
+    const parsedDate = parseTimestampToDate(referenceTimestamp);
+    // If we couldn't parse it, use current UTC time
+    if (!parsedDate) {
+        return formatDateToTimestamp(new Date());
+    }
+    // Add the specified number of seconds (default: 1)
+    parsedDate.setUTCSeconds(parsedDate.getUTCSeconds() + increment);
+    // Get current UTC time for comparison
+    const now = new Date();
+    // Return either the incremented timestamp or current time, whichever is later
+    // This ensures we never go backwards in time
+    if (parsedDate > now) {
+        return formatDateToTimestamp(parsedDate);
+    }
+    else {
+        // If we're already at or past current time, add increment to now
+        now.setUTCSeconds(now.getUTCSeconds() + increment);
+        return formatDateToTimestamp(now);
+    }
+}
+// Find the migrations directory
+const sourcePath = findMigrationsDirectory();
+export async function copyMigrations({ supabasePath, autoConfirm = false, }) {
+    const migrationsPath = path.join(supabasePath, 'migrations');
+    if (!fs.existsSync(migrationsPath)) {
+        fs.mkdirSync(migrationsPath);
+    }
+    // Check if pgflow migrations directory exists
+    if (!sourcePath || !fs.existsSync(sourcePath)) {
+        log.error(`Could not find migrations directory`);
+        log.warn('This might happen if @pgflow/core is not properly installed or built.');
+        log.info('Make sure @pgflow/core is installed and contains the migrations.');
+        log.info('If running in development mode, try building the core package first with: nx build core');
+        return false;
+    }
+    // Get all existing migrations in user's directory
+    const existingFiles = fs.existsSync(migrationsPath)
+        ? fs.readdirSync(migrationsPath)
+        : [];
+    // Find the latest migration timestamp in user's directory
+    let latestTimestamp = '00000000000000';
+    for (const file of existingFiles) {
+        if (file.endsWith('.sql')) {
+            const timestamp = getTimestampFromFilename(file);
+            // Only consider timestamps that have been validated by getTimestampFromFilename
+            // to have the correct length and format
+            if (timestamp && timestamp.length === 14) {
+                const parsedDate = parseTimestampToDate(timestamp);
+                // If we have a valid date and this timestamp is newer, update latestTimestamp
+                if (parsedDate && parseInt(timestamp, 10) > parseInt(latestTimestamp, 10)) {
+                    latestTimestamp = timestamp;
+                }
+            }
+        }
+    }
+    // Get all source migrations
+    const sourceFiles = fs
+        .readdirSync(sourcePath)
+        .filter((file) => file.endsWith('.sql'));
+    const filesToCopy = [];
+    const skippedFiles = [];
+    // Check which migrations need to be installed
+    for (const sourceFile of sourceFiles) {
+        // Check if this migration is already installed (by checking if the original filename
+        // appears in any existing migration filename)
+        const isAlreadyInstalled = existingFiles.some((existingFile) => existingFile.includes(sourceFile));
+        if (isAlreadyInstalled) {
+            skippedFiles.push(sourceFile);
+        }
+        else {
+            filesToCopy.push({
+                source: sourceFile,
+                destination: sourceFile, // Will be updated later with new timestamp
+            });
+        }
+    }
+    // If no files to copy, show message and return false (no changes made)
+    if (filesToCopy.length === 0) {
+        log.success('Migrations already up to date');
+        return false;
+    }
+    // Generate new timestamps for migrations to install
+    let baseTimestamp = latestTimestamp;
+    filesToCopy.forEach((file) => {
+        // Generate timestamp with increasing values to maintain order
+        // Each iteration uses the timestamp generated by the previous iteration as the base
+        baseTimestamp = generateNewTimestamp(baseTimestamp);
+        // Create new filename with format: newTimestamp_originalFilename
+        file.destination = `${baseTimestamp}_${file.source}`;
+    });
+    // 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: `Add ${filesToCopy.length} migration${filesToCopy.length !== 1 ? 's' : ''}?`,
+        });
+        if (confirmResult !== true) {
+            log.warn('Migration installation skipped');
+            return false;
+        }
+    }
+    // Install migrations with new filenames
+    for (const file of filesToCopy) {
+        const sourcePath1 = path.join(sourcePath, file.source);
+        const destinationPath = path.join(migrationsPath, file.destination);
+        fs.copyFileSync(sourcePath1, destinationPath);
+    }
+    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"}