@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/commands/connect.js

@@ -1,163 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import * as readline from 'node:readline';
-import { DeviceConnection } from '../../agent/device-connection.js';
-import { discoverDeviceHandlers } from '../../marketplace/registry.js';
-function promptYesNo(message) {
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-        rl.question(message, (answer) => {
-            rl.close();
-            const normalized = answer.trim().toLowerCase();
-            resolve(normalized === '' || normalized === 'y' || normalized === 'yes');
-        });
-    });
-}
-export async function loadPackDeviceHandlers(conn, projectDir) {
-    const loadedPacks = [];
-    try {
-        const handlers = await discoverDeviceHandlers(projectDir);
-        for (const handler of handlers) {
-            try {
-                const mod = await import(handler.entrypoint);
-                if (typeof mod.register === 'function') {
-                    await mod.register(conn, { projectDir });
-                    loadedPacks.push(handler.packageName);
-                    process.stderr.write(`  \x1b[2m+ ${handler.packageName} handlers\x1b[0m\n`);
-                }
-            }
-            catch (err) {
-                process.stderr.write(`  \x1b[33m⚠\x1b[0m Failed to load handlers from ${handler.packageName}: ${err instanceof Error ? err.message : err}\n`);
-            }
-        }
-    }
-    catch {
-        // Discovery failed — non-fatal
-    }
-    return loadedPacks;
-}
-export async function handleConnect(projectDir) {
-    // Load credentials
-    const credPath = path.join(os.homedir(), '.fw', 'credentials.json');
-    if (!fs.existsSync(credPath)) {
-        console.error('\n  Not logged in. Run: fw login\n');
-        process.exit(1);
-    }
-    const creds = JSON.parse(fs.readFileSync(credPath, 'utf-8'));
-    if (!creds.token || !creds.platformUrl || creds.expiresAt < Date.now()) {
-        console.error('\n  Credentials expired. Run: fw login\n');
-        process.exit(1);
-    }
-    const conn = new DeviceConnection({
-        platformUrl: creds.platformUrl,
-        token: creds.token,
-        projectDir,
-        deviceName: path.basename(projectDir),
-        logger: (msg) => process.stderr.write(`  \x1b[2m${msg}\x1b[0m\n`),
-    });
-    // Register basic file handlers (any project can use these)
-    conn.addCapability('file_read');
-    conn.addCapability('file_list');
-    conn.onRequest('file:read', async (_method, params) => {
-        const filePath = path.resolve(projectDir, String(params.path ?? ''));
-        if (!filePath.startsWith(projectDir))
-            throw new Error('Path outside project directory');
-        if (!fs.existsSync(filePath))
-            throw new Error('File not found');
-        const stat = fs.statSync(filePath);
-        if (stat.isDirectory())
-            return { type: 'directory', entries: fs.readdirSync(filePath) };
-        if (stat.size > 1_048_576)
-            throw new Error('File too large (>1MB)');
-        return { type: 'file', content: fs.readFileSync(filePath, 'utf-8') };
-    });
-    conn.onRequest('file:list', async (_method, params) => {
-        const dirPath = path.resolve(projectDir, String(params.path ?? '.'));
-        if (!dirPath.startsWith(projectDir))
-            throw new Error('Path outside project directory');
-        if (!fs.existsSync(dirPath))
-            throw new Error('Directory not found');
-        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-        return entries
-            .filter(e => !e.name.startsWith('.') && e.name !== 'node_modules' && e.name !== 'dist')
-            .map(e => ({ name: e.name, type: e.isDirectory() ? 'directory' : 'file', path: path.relative(projectDir, path.join(dirPath, e.name)), hasUnfetchedChildren: e.isDirectory() }));
-    });
-    // Load pack device handlers (if any installed packs provide them)
-    const loadedPacks = await loadPackDeviceHandlers(conn, projectDir);
-    // Tell the platform which packs contributed handlers (for auto-install)
-    if (loadedPacks.length > 0) {
-        conn.setPacks(loadedPacks);
-    }
-    console.log('');
-    console.log('  \x1b[1mflow-weaver connect\x1b[0m');
-    console.log(`  \x1b[2mProject: ${path.basename(projectDir)}\x1b[0m`);
-    console.log(`  \x1b[2mPlatform: ${creds.platformUrl}\x1b[0m`);
-    console.log('');
-    // Check if packs need to be installed in the Studio workspace
-    if (loadedPacks.length > 0) {
-        try {
-            const checkRes = await fetch(`${creds.platformUrl}/devices/check-packs`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${creds.token}` },
-                body: JSON.stringify({ packs: loadedPacks }),
-            });
-            if (checkRes.ok) {
-                const { missing } = await checkRes.json();
-                if (missing.length > 0) {
-                    console.log('  The following packs need to be installed in Studio:');
-                    for (const p of missing) {
-                        console.log(`    \x1b[36m${p}\x1b[0m`);
-                    }
-                    console.log('');
-                    const answer = await promptYesNo('  Install now? (Y/n) ');
-                    if (answer) {
-                        process.stderr.write('  Installing...');
-                        const installRes = await fetch(`${creds.platformUrl}/devices/install-packs`, {
-                            method: 'POST',
-                            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${creds.token}` },
-                            body: JSON.stringify({ packs: missing }),
-                        });
-                        if (installRes.ok) {
-                            const { results } = await installRes.json();
-                            const allOk = results.every(r => r.ok);
-                            if (allOk) {
-                                process.stderr.write(' \x1b[32m✓\x1b[0m\n\n');
-                            }
-                            else {
-                                process.stderr.write(' \x1b[33mpartial\x1b[0m\n');
-                                for (const r of results) {
-                                    if (!r.ok)
-                                        console.log(`    \x1b[31m✗\x1b[0m ${r.pack}: ${r.error}`);
-                                }
-                                console.log('');
-                            }
-                        }
-                        else {
-                            process.stderr.write(' \x1b[31mfailed\x1b[0m\n\n');
-                        }
-                    }
-                    else {
-                        console.log('  \x1b[2mSkipped. Install manually via Studio marketplace.\x1b[0m\n');
-                    }
-                }
-            }
-        }
-        catch {
-            // Check failed — non-fatal, continue connecting
-        }
-    }
-    try {
-        await conn.connect();
-        console.log('  \x1b[2mPress Ctrl+C to disconnect.\x1b[0m\n');
-        await new Promise((resolve) => {
-            process.on('SIGINT', () => { console.log('\n  \x1b[2mDisconnecting...\x1b[0m'); conn.disconnect(); resolve(); });
-            process.on('SIGTERM', () => { conn.disconnect(); resolve(); });
-        });
-    }
-    catch (err) {
-        console.error(`  \x1b[31m✗\x1b[0m Connection failed: ${err instanceof Error ? err.message : err}`);
-        process.exit(1);
-    }
-}
-//# sourceMappingURL=connect.js.map

package/dist/cli/commands/context.js

@@ -1,51 +0,0 @@
-/**
- * Context command - generate LLM context bundles from documentation and grammar
- */
-import { buildContext, PRESETS, PRESET_NAMES } from '../../context/index.js';
-import { logger } from '../utils/logger.js';
-import { safeWriteFile } from '../utils/safe-write.js';
-export async function contextCommand(preset, options) {
-    // --list: show presets and exit
-    if (options.list) {
-        logger.section('Context Presets');
-        logger.newline();
-        const maxName = Math.max(...PRESET_NAMES.map((n) => n.length));
-        for (const name of PRESET_NAMES) {
-            const topics = PRESETS[name];
-            logger.log(`  ${name.padEnd(maxName + 2)} ${topics.join(', ')}`);
-        }
-        logger.newline();
-        logger.log('  Usage: fw context [preset] [options]');
-        logger.newline();
-        return;
-    }
-    // Validate preset
-    const presetName = (preset ?? 'core');
-    if (!PRESET_NAMES.includes(presetName) && !options.topics) {
-        throw new Error(`Unknown preset "${preset}". Available: ${PRESET_NAMES.join(', ')}. Or use --topics to specify topics directly.`);
-    }
-    // Validate profile
-    const profile = options.profile ?? 'standalone';
-    if (profile !== 'standalone' && profile !== 'assistant') {
-        throw new Error(`Unknown profile "${profile}". Use "standalone" or "assistant".`);
-    }
-    const result = buildContext({
-        preset: PRESET_NAMES.includes(presetName) ? presetName : 'core',
-        profile: profile,
-        topics: options.topics ? options.topics.split(',').map((s) => s.trim()) : undefined,
-        addTopics: options.add ? options.add.split(',').map((s) => s.trim()) : undefined,
-        includeGrammar: options.grammar !== false,
-    });
-    // Write output
-    if (options.output) {
-        safeWriteFile(options.output, result.content);
-        logger.success(`Context written to ${options.output}`);
-    }
-    else {
-        process.stdout.write(result.content);
-    }
-    // Stats to stderr (doesn't pollute piped stdout)
-    const stats = `${result.topicCount} topics, ${result.lineCount} lines (${result.profile} profile)`;
-    process.stderr.write(`fw context: ${stats}\n`);
-}
-//# sourceMappingURL=context.js.map

package/dist/cli/commands/create.js

@@ -1,139 +0,0 @@
-/* eslint-disable no-console */
-/**
- * Create command - scaffolds workflows and nodes from templates
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { getWorkflowTemplate, getNodeTemplate, toCamelCase } from '../templates/index.js';
-import { logger } from '../utils/logger.js';
-import { getErrorMessage } from '../../utils/error-utils.js';
-/**
- * Insert content at a specific line or append to end of file
- */
-function insertIntoFile(filePath, content, line) {
-    // Create file if it doesn't exist
-    if (!fs.existsSync(filePath)) {
-        const dir = path.dirname(filePath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        fs.writeFileSync(filePath, content + '\n');
-        return;
-    }
-    const existingContent = fs.readFileSync(filePath, 'utf8');
-    const lines = existingContent.split(/\r?\n/);
-    if (line !== undefined && line > 0) {
-        // Insert AFTER specific line (1-indexed)
-        // Line 3 means insert after line 3, so at index 3
-        const insertIndex = Math.min(line, lines.length);
-        lines.splice(insertIndex, 0, content);
-    }
-    else {
-        // Append to end
-        lines.push('', content);
-    }
-    fs.writeFileSync(filePath, lines.join('\n'));
-}
-/**
- * Create a workflow from a template
- */
-export async function createWorkflowCommand(template, file, options = {}) {
-    const { line, async: isAsync = false, preview = false, provider, model, config: configJson, } = options;
-    const templateDef = getWorkflowTemplate(template);
-    if (!templateDef) {
-        throw new Error(`Unknown workflow template: ${template}. Run 'fw templates' to see available templates`);
-    }
-    // Resolve to absolute path
-    const filePath = path.resolve(file);
-    // Derive workflow name from filename (or use --name override)
-    const baseName = path.basename(filePath, path.extname(filePath));
-    const workflowName = options.name || toCamelCase(baseName);
-    // Build config object from options
-    const config = {};
-    if (provider)
-        config.provider = provider;
-    if (model)
-        config.model = model;
-    if (options.nodes)
-        config.nodes = options.nodes.split(',').map((n) => n.trim());
-    if (options.input)
-        config.input = options.input;
-    if (options.output)
-        config.output = options.output;
-    if (configJson) {
-        try {
-            Object.assign(config, JSON.parse(configJson));
-        }
-        catch {
-            throw new Error('Invalid --config JSON');
-        }
-    }
-    // Generate the template code
-    const code = templateDef.generate({
-        workflowName,
-        async: isAsync,
-        config: Object.keys(config).length > 0 ? config : undefined,
-    });
-    // Preview mode: just output the code
-    if (preview) {
-        console.log(code);
-        return;
-    }
-    try {
-        insertIntoFile(filePath, code, line);
-        logger.success(`Created ${templateDef.name} workflow in ${file}`);
-        if (line) {
-            logger.info(`  Inserted at line ${line}`);
-        }
-        logger.info(`  Workflow function: ${workflowName}`);
-    }
-    catch (error) {
-        throw new Error(`Failed to create workflow: ${getErrorMessage(error)}`);
-    }
-}
-/**
- * Create a node type from a template
- * Uses processor template by default
- */
-export async function createNodeCommand(name, file, options = {}) {
-    const { line, template = 'processor', preview = false, strategy, config: configJson } = options;
-    const templateDef = getNodeTemplate(template);
-    if (!templateDef) {
-        throw new Error(`Unknown node template: ${template}. Run 'fw templates' to see available templates`);
-    }
-    // Resolve to absolute path
-    const filePath = path.resolve(file);
-    // Build config object from options
-    const config = {};
-    if (strategy)
-        config.strategy = strategy;
-    if (configJson) {
-        try {
-            Object.assign(config, JSON.parse(configJson));
-        }
-        catch {
-            throw new Error('Invalid --config JSON');
-        }
-    }
-    // Generate the template code with provided name and optional config
-    const nodeName = toCamelCase(name);
-    const nodeConfig = Object.keys(config).length > 0 ? config : undefined;
-    const code = templateDef.generate(nodeName, nodeConfig);
-    // Preview mode: just output the code
-    if (preview) {
-        console.log(code);
-        return;
-    }
-    try {
-        insertIntoFile(filePath, code, line);
-        logger.success(`Created ${templateDef.name} node in ${file}`);
-        if (line) {
-            logger.info(`  Inserted at line ${line}`);
-        }
-        logger.info(`  Node function: ${nodeName}`);
-    }
-    catch (error) {
-        throw new Error(`Failed to create node: ${getErrorMessage(error)}`);
-    }
-}
-//# sourceMappingURL=create.js.map

package/dist/cli/commands/deploy.d.ts

@@ -1,6 +0,0 @@
-export declare function deployCommand(filePath: string, options?: {
-    name?: string;
-}): Promise<void>;
-export declare function undeployCommand(slug: string): Promise<void>;
-export declare function cloudStatusCommand(): Promise<void>;
-//# sourceMappingURL=deploy.d.ts.map

package/dist/cli/commands/deploy.js

@@ -1,74 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { requireLogin, fmt, exitWithError } from '../utils/cli-helpers.js';
-export async function deployCommand(filePath, options = {}) {
-    const { creds, client } = requireLogin();
-    const absPath = path.resolve(filePath);
-    if (!fs.existsSync(absPath)) {
-        exitWithError(new Error(`File not found: ${filePath}`), 'File not found');
-    }
-    const source = fs.readFileSync(absPath, 'utf-8');
-    const name = options.name ?? path.basename(filePath, path.extname(filePath));
-    console.log('');
-    console.log(`  ${fmt.dim(`Pushing ${name}...`)}`);
-    try {
-        const workflow = await client.pushWorkflow(name, source);
-        console.log(fmt.ok(`Pushed (v${workflow.version})`));
-        console.log(`  ${fmt.dim('Deploying...')}`);
-        const deployment = await client.deploy(workflow.slug);
-        console.log(fmt.ok(`Deployed: ${deployment.slug}`));
-        console.log('');
-        console.log(`  Endpoint: ${creds.platformUrl}/run/${deployment.slug}`);
-        console.log('');
-        console.log('  Test it:');
-        console.log(`    curl -X POST ${creds.platformUrl}/run/${deployment.slug} \\`);
-        console.log(`      -H "X-API-Key: <your-api-key>" \\`);
-        console.log(`      -H "Content-Type: application/json" \\`);
-        console.log(`      -d '{"input": "hello"}'`);
-        console.log('');
-    }
-    catch (err) {
-        exitWithError(err, 'Deploy failed');
-    }
-}
-export async function undeployCommand(slug) {
-    const { client } = requireLogin();
-    try {
-        await client.undeploy(slug);
-        console.log(fmt.ok(`Undeployed: ${slug}`));
-    }
-    catch (err) {
-        exitWithError(err, 'Undeploy failed');
-    }
-}
-export async function cloudStatusCommand() {
-    const { creds, client } = requireLogin();
-    console.log('');
-    console.log(`  ${fmt.bold(creds.email)} ${fmt.dim(`(${creds.plan} plan)`)}`);
-    console.log('');
-    try {
-        const deployments = await client.listDeployments();
-        if (deployments.length === 0) {
-            console.log('  No deployments.');
-        }
-        else {
-            console.log('  Deployments:');
-            for (const d of deployments) {
-                const icon = d.status === 'active' ? '\x1b[32m●\x1b[0m' : '\x1b[33m○\x1b[0m';
-                console.log(`    ${icon} ${d.slug.padEnd(25)} ${d.status}`);
-            }
-        }
-    }
-    catch {
-        console.log(`  ${fmt.yellow('⚠')} Could not fetch deployments`);
-    }
-    try {
-        const usage = await client.getUsage();
-        console.log('');
-        console.log(`  AI Credits: ${usage.aiCalls} calls this month`);
-        console.log(`  Executions: ${usage.executions} this month`);
-    }
-    catch { /* usage not available */ }
-    console.log('');
-}
-//# sourceMappingURL=deploy.js.map

package/dist/cli/commands/dev.js

@@ -1,227 +0,0 @@
-/**
- * Dev command - watch, compile, and run workflow on changes
- */
-import * as path from 'path';
-import * as fs from 'fs';
-import { glob } from 'glob';
-import { compileCommand } from './compile.js';
-import { executeWorkflowFromFile } from '../../mcp/workflow-executor.js';
-import { logger } from '../utils/logger.js';
-import { getErrorMessage } from '../../utils/error-utils.js';
-import { getFriendlyError } from '../../friendly-errors.js';
-import { devModeRegistry } from '../../generator/dev-mode-registry.js';
-function timestamp() {
-    const now = new Date();
-    const h = String(now.getHours()).padStart(2, '0');
-    const m = String(now.getMinutes()).padStart(2, '0');
-    const s = String(now.getSeconds()).padStart(2, '0');
-    return `${h}:${m}:${s}`;
-}
-function cycleSeparator(file) {
-    const ts = timestamp();
-    const pad = '─'.repeat(40);
-    logger.log(`\n  ${logger.dim(`─── ${ts} ${pad}`)}`);
-    if (file) {
-        logger.log(`  ${logger.dim('File changed:')} ${path.basename(file)}`);
-    }
-}
-/**
- * Parse params from --params or --params-file.
- */
-function parseParams(options) {
-    if (options.params) {
-        try {
-            return JSON.parse(options.params);
-        }
-        catch {
-            throw new Error(`Invalid JSON in --params: ${options.params}`);
-        }
-    }
-    if (options.paramsFile) {
-        const paramsFilePath = path.resolve(options.paramsFile);
-        if (!fs.existsSync(paramsFilePath)) {
-            throw new Error(`Params file not found: ${paramsFilePath}`);
-        }
-        try {
-            const content = fs.readFileSync(paramsFilePath, 'utf8');
-            return JSON.parse(content);
-        }
-        catch {
-            throw new Error(`Failed to parse params file: ${options.paramsFile}`);
-        }
-    }
-    return {};
-}
-/**
- * Parse mock config from --mocks or --mocks-file.
- */
-function parseMocks(options) {
-    if (options.mocks) {
-        try {
-            return JSON.parse(options.mocks);
-        }
-        catch {
-            throw new Error(`Invalid JSON in --mocks: ${options.mocks}`);
-        }
-    }
-    if (options.mocksFile) {
-        const mocksFilePath = path.resolve(options.mocksFile);
-        if (!fs.existsSync(mocksFilePath)) {
-            throw new Error(`Mocks file not found: ${mocksFilePath}`);
-        }
-        try {
-            const content = fs.readFileSync(mocksFilePath, 'utf8');
-            return JSON.parse(content);
-        }
-        catch {
-            throw new Error(`Failed to parse mocks file: ${options.mocksFile}`);
-        }
-    }
-    return undefined;
-}
-/**
- * Run a single compile + execute cycle.
- * Returns true if both compile and run succeeded.
- */
-async function compileAndRun(filePath, params, mocks, options) {
-    // Step 1: Compile
-    const compileOpts = {
-        format: options.format,
-        clean: options.clean,
-    };
-    try {
-        const ct = logger.timer();
-        await compileCommand(filePath, compileOpts);
-        if (!options.json) {
-            logger.success(`Compiled in ${ct.elapsed()}`);
-        }
-    }
-    catch (error) {
-        const errorMsg = getErrorMessage(error);
-        const errorObj = error;
-        if (errorObj.errors && Array.isArray(errorObj.errors)) {
-            logger.error('Compile failed:');
-            for (const err of errorObj.errors) {
-                const friendly = getFriendlyError(err);
-                if (friendly) {
-                    logger.error(`  ${friendly.title}: ${friendly.explanation}`);
-                    logger.warn(`    How to fix: ${friendly.fix}`);
-                }
-                else {
-                    logger.error(`  - ${err.message}`);
-                }
-            }
-        }
-        else {
-            logger.error(`Compile failed: ${errorMsg}`);
-        }
-        return false;
-    }
-    // Step 2: Run
-    try {
-        const result = await executeWorkflowFromFile(filePath, params, {
-            workflowName: options.workflow,
-            production: options.production ?? false,
-            includeTrace: !options.production,
-            mocks,
-        });
-        if (options.json) {
-            process.stdout.write(JSON.stringify({
-                success: true,
-                workflow: result.functionName,
-                executionTime: result.executionTime,
-                result: result.result,
-            }, null, 2) + '\n');
-        }
-        else {
-            logger.success(`Workflow "${result.functionName}" completed in ${result.executionTime}ms`);
-            logger.log(JSON.stringify(result.result, null, 2));
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMsg = getErrorMessage(error);
-        if (options.json) {
-            process.stdout.write(JSON.stringify({ success: false, error: errorMsg }, null, 2) + '\n');
-        }
-        else {
-            logger.error(`Run failed: ${errorMsg}`);
-        }
-        return false;
-    }
-}
-// ---------------------------------------------------------------------------
-// Main Command
-// ---------------------------------------------------------------------------
-/**
- * Dev command: watch + compile + run in a single loop.
- */
-export async function devCommand(input, options = {}) {
-    const filePath = path.resolve(input);
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`File not found: ${filePath}`);
-    }
-    // Delegate to a registered dev mode provider if one exists for the target
-    if (options.target) {
-        const provider = devModeRegistry.get(options.target);
-        if (provider) {
-            return provider.run(filePath, options);
-        }
-        const available = devModeRegistry.getNames();
-        throw new Error(`Unknown dev target "${options.target}". ${available.length ? `Available: ${available.join(', ')}` : 'No dev mode providers registered. Install a pack that provides one.'}`);
-    }
-    const params = parseParams(options);
-    const mocks = parseMocks(options);
-    if (!options.json) {
-        logger.section('Dev Mode');
-        logger.info(`File: ${path.basename(filePath)}`);
-        if (Object.keys(params).length > 0) {
-            logger.info(`Params: ${JSON.stringify(params)}`);
-        }
-        if (mocks) {
-            logger.info(`Mocks: ${JSON.stringify(mocks)}`);
-        }
-        logger.newline();
-    }
-    // Initial compile + run
-    await compileAndRun(filePath, params, mocks, options);
-    // If --once, exit after first cycle
-    if (options.once) {
-        return;
-    }
-    if (!options.json) {
-        logger.newline();
-        logger.success('Watching for file changes... (Ctrl+C to stop)');
-    }
-    // Find files to watch
-    const files = await glob(input, { absolute: true });
-    // Use chokidar for reliable cross-platform file watching
-    const chokidar = await import('chokidar');
-    const watcher = chokidar.watch(files, {
-        persistent: true,
-        ignoreInitial: true,
-    });
-    watcher.on('change', async (file) => {
-        if (!options.json) {
-            cycleSeparator(file);
-        }
-        await compileAndRun(filePath, params, mocks, options);
-    });
-    // Handle process termination
-    const cleanup = () => {
-        if (!options.json) {
-            logger.newline();
-            logger.info('Stopping dev mode...');
-        }
-        watcher.close();
-        process.exit(0);
-    };
-    process.on('SIGINT', cleanup);
-    if (process.platform !== 'win32')
-        process.on('SIGTERM', cleanup);
-    // Keep process alive
-    await new Promise(() => {
-        // Never resolves - keeps process running
-    });
-}
-//# sourceMappingURL=dev.js.map