@synergenius/flow-weaver 0.20.7 → 0.21.0

package/dist/cli/tunnel/file-lock.js

@@ -1,36 +0,0 @@
-/**
- * File mutation lock — serializes concurrent mutations to the same file.
- *
- * Ported from flow-weaver-platform/src/services/ast-helpers.ts:54-85.
- * Prevents file corruption when rapid Studio mutations (e.g. dragging nodes)
- * trigger concurrent write operations.
- */
-import * as path from 'node:path';
-const fileMutationLocks = new Map();
-export function withFileLock(filePath, operation) {
-    const normalizedPath = path.resolve(filePath);
-    const existingChain = fileMutationLocks.get(normalizedPath) || Promise.resolve();
-    let resolve;
-    let reject;
-    const resultPromise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    const newChain = existingChain.then(async () => {
-        try {
-            const result = await operation();
-            resolve(result);
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-    fileMutationLocks.set(normalizedPath, newChain);
-    newChain.finally(() => {
-        if (fileMutationLocks.get(normalizedPath) === newChain) {
-            fileMutationLocks.delete(normalizedPath);
-        }
-    });
-    return resultPromise;
-}
-//# sourceMappingURL=file-lock.js.map

package/dist/cli/tunnel/handlers/ast-ops.d.ts

@@ -1,10 +0,0 @@
-/**
- * AST read-operation handlers for the tunnel CLI.
- * Ported from flow-weaver-platform/src/routes/studio-rpc.ts + src/services/ast-helpers.ts.
- */
-import type { HandlerFn } from '../dispatch.js';
-declare function prepareMutationResult(ast: Record<string, unknown>, wsPath: string): Record<string, unknown>;
-declare function getWorkflowName(params: Record<string, unknown>): string | undefined;
-export { prepareMutationResult, getWorkflowName };
-export declare const astOpsHandlers: Record<string, HandlerFn>;
-//# sourceMappingURL=ast-ops.d.ts.map

package/dist/cli/tunnel/handlers/ast-ops.js

@@ -1,252 +0,0 @@
-/**
- * AST read-operation handlers for the tunnel CLI.
- * Ported from flow-weaver-platform/src/routes/studio-rpc.ts + src/services/ast-helpers.ts.
- */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { parser, resolveNpmNodeTypes } from '../../../parser.js';
-import { validateWorkflow } from '../../../api/validate.js';
-import { resolvePath, toVirtualPath } from '../path-resolver.js';
-// ---------------------------------------------------------------------------
-// Helpers — ported from studio-rpc.ts lines 98-186
-// ---------------------------------------------------------------------------
-function ensureASTDefaults(ast) {
-    return {
-        ...ast,
-        instances: ast.instances ?? [],
-        connections: ast.connections ?? [],
-        nodeTypes: ast.nodeTypes ?? [],
-    };
-}
-function virtualizeASTPaths(ast, wsPath) {
-    const result = { ...ast };
-    // 1. sourceFile
-    if (typeof result.sourceFile === 'string' && result.sourceFile.startsWith(wsPath)) {
-        result.sourceFile = toVirtualPath(wsPath, result.sourceFile);
-    }
-    // 2. nodeTypes[].sourceLocation.file and nodeTypes[].path
-    if (Array.isArray(result.nodeTypes)) {
-        result.nodeTypes = result.nodeTypes.map((nt) => {
-            const copy = { ...nt };
-            if (copy.sourceLocation?.file?.startsWith(wsPath)) {
-                copy.sourceLocation = { ...copy.sourceLocation, file: toVirtualPath(wsPath, copy.sourceLocation.file) };
-            }
-            if (typeof copy.path === 'string' && copy.path.startsWith(wsPath)) {
-                copy.path = toVirtualPath(wsPath, copy.path);
-            }
-            return copy;
-        });
-    }
-    // 3. instances[].sourceLocation.file
-    if (Array.isArray(result.instances)) {
-        result.instances = result.instances.map((inst) => {
-            if (inst.sourceLocation?.file?.startsWith(wsPath)) {
-                return {
-                    ...inst,
-                    sourceLocation: { ...inst.sourceLocation, file: toVirtualPath(wsPath, inst.sourceLocation.file) },
-                };
-            }
-            return inst;
-        });
-    }
-    return result;
-}
-function prepareMutationResult(ast, wsPath) {
-    return virtualizeASTPaths(ensureASTDefaults(ast), wsPath);
-}
-function getWorkflowName(params) {
-    return (params.functionName || params.workflowName || params.exportName);
-}
-// ---------------------------------------------------------------------------
-// Core AST operations — ported from ast-helpers.ts
-// ---------------------------------------------------------------------------
-async function loadWorkflowAST(filePath, functionName) {
-    const parsed = parser.parse(filePath);
-    const workflows = parsed.workflows || [];
-    if (workflows.length === 0) {
-        throw new Error(`No workflows found in ${filePath}`);
-    }
-    const target = functionName
-        ? workflows.find((w) => w.functionName === functionName)
-        : workflows[0];
-    if (!target) {
-        throw new Error(`Workflow "${functionName}" not found in ${filePath}`);
-    }
-    return resolveNpmNodeTypes(target, path.dirname(filePath));
-}
-async function loadAllWorkflowsAST(wsPath) {
-    const entries = await fs.readdir(wsPath, { withFileTypes: true });
-    const results = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith('.ts'))
-            continue;
-        if (entry.name === 'tsconfig.json' || entry.name === 'package.json')
-            continue;
-        const fullPath = path.join(wsPath, entry.name);
-        try {
-            const parsed = parser.parse(fullPath);
-            const workflows = parsed.workflows || [];
-            for (const wf of workflows) {
-                const resolved = await resolveNpmNodeTypes(wf, wsPath);
-                results.push({ filePath: fullPath, ast: resolved });
-            }
-        }
-        catch {
-            // Skip files that fail to parse
-        }
-    }
-    return results;
-}
-function parseWorkflowFromContent(content) {
-    const parsed = parser.parseFromString(content);
-    const workflows = parsed.workflows || [];
-    return workflows.map((wf) => ({
-        name: wf.name || wf.functionName,
-        ast: wf,
-    }));
-}
-function getDiagnostics(source) {
-    const parsed = parser.parseFromString(source);
-    if ((parsed.errors && parsed.errors.length > 0) || !parsed.workflows?.length) {
-        return {
-            valid: false,
-            errors: (parsed.errors || []).map((e) => ({ message: typeof e === 'string' ? e : e.message || String(e) })),
-            warnings: [],
-        };
-    }
-    const allErrors = [];
-    const allWarnings = [];
-    for (const wf of parsed.workflows) {
-        const result = validateWorkflow(wf);
-        if (result.errors)
-            allErrors.push(...result.errors);
-        if (result.warnings)
-            allWarnings.push(...result.warnings);
-    }
-    return { valid: allErrors.length === 0, errors: allErrors, warnings: allWarnings };
-}
-async function extractAllNodeTypes(wsPath) {
-    const all = await loadAllWorkflowsAST(wsPath);
-    const typeMap = new Map();
-    for (const { ast } of all) {
-        for (const nt of ast.nodeTypes || []) {
-            if (!typeMap.has(nt.name)) {
-                typeMap.set(nt.name, nt);
-            }
-        }
-    }
-    return Array.from(typeMap.values());
-}
-// ---------------------------------------------------------------------------
-// Exported handlers
-// ---------------------------------------------------------------------------
-export { prepareMutationResult, getWorkflowName };
-export const astOpsHandlers = {
-    loadWorkflowAST: async (params, ctx) => {
-        const filePath = params.filePath;
-        if (!filePath)
-            throw new Error('filePath is required');
-        const functionName = getWorkflowName(params);
-        const resolved = resolvePath(ctx.workspaceRoot, filePath);
-        const ast = await loadWorkflowAST(resolved, functionName);
-        return virtualizeASTPaths(ensureASTDefaults(ast), ctx.workspaceRoot);
-    },
-    loadAllWorkflowsAST: async (_params, ctx) => {
-        const all = await loadAllWorkflowsAST(ctx.workspaceRoot);
-        return all.map(({ filePath, ast }) => ({
-            filePath: toVirtualPath(ctx.workspaceRoot, filePath),
-            ast: virtualizeASTPaths(ensureASTDefaults(ast), ctx.workspaceRoot),
-        }));
-    },
-    parseWorkflowASTFromContent: async (params) => {
-        const content = params.content;
-        if (!content)
-            throw new Error('content is required');
-        const functionName = getWorkflowName(params);
-        const results = parseWorkflowFromContent(content);
-        if (functionName) {
-            const match = results.find((r) => r.name === functionName || r.ast?.functionName === functionName);
-            return match ? ensureASTDefaults(match.ast) : null;
-        }
-        return results.length > 0 ? ensureASTDefaults(results[0].ast) : null;
-    },
-    getAvailableWorkflowsInFile: async (params, ctx) => {
-        const filePath = params.filePath;
-        if (!filePath)
-            return { availableWorkflows: [] };
-        try {
-            const resolved = resolvePath(ctx.workspaceRoot, filePath);
-            const source = await fs.readFile(resolved, 'utf-8');
-            const results = parseWorkflowFromContent(source);
-            return {
-                availableWorkflows: results.map((w) => ({
-                    name: w.ast?.name || w.name,
-                    functionName: w.ast?.functionName || w.name,
-                    isExported: true,
-                })),
-            };
-        }
-        catch {
-            return { availableWorkflows: [] };
-        }
-    },
-    getDiagnostics: async (params, ctx) => {
-        // Source resolution priority: openFiles > content > file on disk
-        let source;
-        const openFiles = params.openFiles;
-        const filePath = params.filePath;
-        if (openFiles && filePath && openFiles[filePath]) {
-            source = openFiles[filePath];
-        }
-        else if (typeof params.content === 'string') {
-            source = params.content;
-        }
-        else if (filePath) {
-            const resolved = resolvePath(ctx.workspaceRoot, filePath);
-            source = await fs.readFile(resolved, 'utf-8');
-        }
-        if (!source)
-            throw new Error('No source provided for diagnostics');
-        const { errors, warnings } = getDiagnostics(source);
-        // Transform to flat array for FileEditorPane
-        const result = [];
-        for (const e of errors) {
-            result.push({
-                severity: 'error',
-                message: e.message || String(e),
-                start: e.location ?? { line: 1, column: 0 },
-            });
-        }
-        for (const w of warnings) {
-            result.push({
-                severity: 'warning',
-                message: w.message || String(w),
-                start: w.location ?? { line: 1, column: 0 },
-            });
-        }
-        return result;
-    },
-    getNodeTypes: async (_params, ctx) => {
-        const types = await extractAllNodeTypes(ctx.workspaceRoot);
-        return types.map((t) => ({ name: t.name, label: t.name, nodeType: t }));
-    },
-    getNodeTypesBatch: async (params, ctx) => {
-        const cursor = params.cursor || '0';
-        const limit = params.limit || 50;
-        const offset = parseInt(cursor, 10) || 0;
-        const types = await extractAllNodeTypes(ctx.workspaceRoot);
-        const all = types.map((t) => ({ name: t.name, label: t.name, nodeType: t }));
-        const page = all.slice(offset, offset + limit);
-        const nextCursor = offset + limit < all.length ? String(offset + limit) : null;
-        return { types: page, cursor: nextCursor };
-    },
-    searchNodeTypes: async (params, ctx) => {
-        const query = (params.query || '').toLowerCase();
-        const types = await extractAllNodeTypes(ctx.workspaceRoot);
-        const all = types.map((t) => ({ name: t.name, label: t.name, nodeType: t }));
-        if (!query)
-            return all;
-        return all.filter((t) => t.name.toLowerCase().includes(query) || t.label.toLowerCase().includes(query));
-    },
-};
-//# sourceMappingURL=ast-ops.js.map

package/dist/cli/tunnel/handlers/execution.d.ts

@@ -1,7 +0,0 @@
-/**
- * Execution handlers for the tunnel CLI.
- * executeFile, compileFile, generateDiagram
- */
-import type { HandlerFn } from '../dispatch.js';
-export declare const executionHandlers: Record<string, HandlerFn>;
-//# sourceMappingURL=execution.d.ts.map

package/dist/cli/tunnel/handlers/execution.js

@@ -1,89 +0,0 @@
-/**
- * Execution handlers for the tunnel CLI.
- * executeFile, compileFile, generateDiagram
- */
-import * as fs from 'node:fs/promises';
-import { compileWorkflow } from '../../../api/compile.js';
-import { resolvePath } from '../path-resolver.js';
-let sourceToSVG;
-async function loadDiagram() {
-    if (sourceToSVG)
-        return sourceToSVG;
-    try {
-        const mod = await import('../../../diagram/index.js');
-        sourceToSVG = mod.sourceToSVG;
-        return sourceToSVG;
-    }
-    catch {
-        return undefined;
-    }
-}
-export const executionHandlers = {
-    executeFile: async (params, ctx) => {
-        const filePath = params.filePath;
-        if (!filePath)
-            throw new Error('filePath is required');
-        const resolved = resolvePath(ctx.workspaceRoot, filePath);
-        const inputData = (params.inputData || params.input || {});
-        try {
-            // Dynamic import to avoid bundling issues — uses the MCP workflow executor
-            const { executeWorkflowFromFile } = await import('../../../mcp/workflow-executor.js');
-            const result = await executeWorkflowFromFile(resolved, inputData);
-            return result;
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
-            };
-        }
-    },
-    compileFile: async (params, ctx) => {
-        const filePath = params.filePath;
-        if (!filePath)
-            throw new Error('filePath is required');
-        const resolved = resolvePath(ctx.workspaceRoot, filePath);
-        try {
-            const result = await compileWorkflow(resolved);
-            return result;
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
-            };
-        }
-    },
-    generateDiagram: async (params, ctx) => {
-        const filePath = params.filePath;
-        const content = params.content;
-        let source;
-        if (content) {
-            source = content;
-        }
-        else if (filePath) {
-            const resolved = resolvePath(ctx.workspaceRoot, filePath);
-            source = await fs.readFile(resolved, 'utf-8');
-        }
-        else {
-            throw new Error('filePath or content is required');
-        }
-        const render = await loadDiagram();
-        if (!render) {
-            return { success: false, error: 'Diagram module not available' };
-        }
-        try {
-            const svg = render(source, {
-                workflowName: params.workflowName,
-            });
-            return { success: true, svg };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
-            };
-        }
-    },
-};
-//# sourceMappingURL=execution.js.map

package/dist/cli/tunnel/handlers/file-ops.d.ts

@@ -1,7 +0,0 @@
-/**
- * File operation handlers for the tunnel CLI.
- * Ported from flow-weaver-platform/src/routes/studio-rpc.ts file handlers.
- */
-import type { HandlerFn } from '../dispatch.js';
-export declare const fileOpsHandlers: Record<string, HandlerFn>;
-//# sourceMappingURL=file-ops.d.ts.map

package/dist/cli/tunnel/handlers/file-ops.js

@@ -1,204 +0,0 @@
-/**
- * File operation handlers for the tunnel CLI.
- * Ported from flow-weaver-platform/src/routes/studio-rpc.ts file handlers.
- */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { resolvePath, toVirtualPath } from '../path-resolver.js';
-const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', '.next', '.cache', '.claude']);
-const SKIP_FILES = new Set(['package-lock.json']);
-async function collectFileInfos(dir, root) {
-    const results = [];
-    async function walk(currentDir) {
-        let entries;
-        try {
-            entries = await fs.readdir(currentDir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.'))
-                continue;
-            if (SKIP_FILES.has(entry.name))
-                continue;
-            const fullPath = path.join(currentDir, entry.name);
-            const isDir = entry.isDirectory();
-            results.push({
-                path: toVirtualPath(root, fullPath),
-                type: isDir ? 'directory' : 'file',
-            });
-            if (isDir) {
-                await walk(fullPath);
-            }
-        }
-    }
-    await walk(dir);
-    return results;
-}
-export const fileOpsHandlers = {
-    getCWD: async () => '/',
-    findProjectRoot: async () => '/',
-    getFile: async (params, ctx) => {
-        const filePath = params.filePath;
-        if (!filePath)
-            throw new Error('filePath is required');
-        const resolved = resolvePath(ctx.workspaceRoot, filePath);
-        return fs.readFile(resolved, 'utf-8');
-    },
-    writeFile: async (params, ctx) => {
-        const filePath = (params.filePath || params.path);
-        const content = (params.content ?? params.source ?? params.text);
-        if (!filePath)
-            throw new Error('filePath is required');
-        if (content === undefined || content === null)
-            throw new Error('content is required');
-        const resolved = resolvePath(ctx.workspaceRoot, filePath);
-        await fs.mkdir(path.dirname(resolved), { recursive: true });
-        await fs.writeFile(resolved, content, 'utf-8');
-        return { saved: true };
-    },
-    saveFile: async (params, ctx) => {
-        // saveFile is an alias for writeFile
-        return fileOpsHandlers.writeFile(params, ctx);
-    },
-    hasFile: async (params, ctx) => {
-        const filePath = params.filePath;
-        if (!filePath)
-            return false;
-        const resolved = resolvePath(ctx.workspaceRoot, filePath);
-        try {
-            await fs.access(resolved);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    },
-    deleteFile: async (params, ctx) => {
-        const filePath = params.filePath;
-        if (!filePath)
-            throw new Error('filePath is required');
-        const resolved = resolvePath(ctx.workspaceRoot, filePath);
-        await fs.unlink(resolved);
-        return { deleted: true };
-    },
-    getFilesStructure: async (_params, ctx) => {
-        return collectFileInfos(ctx.workspaceRoot, ctx.workspaceRoot);
-    },
-    getFilesStructureRecursive: async (_params, ctx) => {
-        return collectFileInfos(ctx.workspaceRoot, ctx.workspaceRoot);
-    },
-    listDirectory: async (params, ctx) => {
-        let dirPath = (params.dirPath || params.path || params.directory);
-        if (dirPath?.startsWith('/cloud'))
-            dirPath = dirPath.slice('/cloud'.length) || undefined;
-        const resolved = dirPath && dirPath !== '/' && dirPath !== ''
-            ? resolvePath(ctx.workspaceRoot, dirPath)
-            : ctx.workspaceRoot;
-        const entries = await fs.readdir(resolved, { withFileTypes: true });
-        const results = [];
-        for (const entry of entries) {
-            if (entry.name === 'node_modules' || entry.name === 'package-lock.json')
-                continue;
-            const fullPath = path.join(resolved, entry.name);
-            const stat = await fs.stat(fullPath);
-            const isDir = entry.isDirectory();
-            results.push({
-                name: entry.name,
-                path: toVirtualPath(ctx.workspaceRoot, fullPath),
-                type: isDir ? 'directory' : 'file',
-                isDirectory: isDir,
-                size: stat.size,
-                modified: stat.mtime.toISOString(),
-            });
-        }
-        return results;
-    },
-    findWorkflows: async (_params, ctx) => {
-        const entries = await fs.readdir(ctx.workspaceRoot, { withFileTypes: true });
-        const paths = [];
-        for (const entry of entries) {
-            if (entry.isFile() && entry.name.endsWith('.ts')) {
-                paths.push('/' + entry.name);
-            }
-        }
-        return paths;
-    },
-    createFolder: async (params, ctx) => {
-        const dirPath = params.dirPath;
-        if (!dirPath)
-            throw new Error('dirPath is required');
-        const resolved = resolvePath(ctx.workspaceRoot, dirPath);
-        await fs.mkdir(resolved, { recursive: true });
-        return { created: true };
-    },
-    renameFile: async (params, ctx) => {
-        const oldPath = params.oldPath;
-        const newPath = params.newPath;
-        if (!oldPath || !newPath)
-            throw new Error('oldPath and newPath are required');
-        const resolvedOld = resolvePath(ctx.workspaceRoot, oldPath);
-        const resolvedNew = resolvePath(ctx.workspaceRoot, newPath);
-        await fs.rename(resolvedOld, resolvedNew);
-        return { renamed: true };
-    },
-    getFileStats: async (params, ctx) => {
-        const filePath = params.filePath;
-        if (!filePath)
-            throw new Error('filePath is required');
-        const resolved = resolvePath(ctx.workspaceRoot, filePath);
-        const stat = await fs.stat(resolved);
-        return {
-            size: stat.size,
-            created: stat.birthtime.toISOString(),
-            modified: stat.mtime.toISOString(),
-            isFile: stat.isFile(),
-            isDirectory: stat.isDirectory(),
-        };
-    },
-    hasFolder: async () => true,
-    deleteDirectory: async () => ({ success: true }),
-    moveFile: async () => ({ success: true }),
-    copyFile: async () => ({ success: true }),
-    copyDirectory: async () => ({ success: true }),
-    checkLibraryStatus: async (_params, ctx) => {
-        try {
-            const pkgPath = path.join(ctx.workspaceRoot, 'node_modules', '@synergenius', 'flow-weaver', 'package.json');
-            const raw = await fs.readFile(pkgPath, 'utf-8');
-            const pkg = JSON.parse(raw);
-            return {
-                installed: true,
-                compatible: true,
-                corrupt: false,
-                outdated: false,
-                version: pkg.version,
-                issues: [],
-                capabilities: {},
-            };
-        }
-        catch {
-            return {
-                installed: false,
-                compatible: false,
-                corrupt: false,
-                outdated: false,
-                version: null,
-                issues: ['@synergenius/flow-weaver not installed in project'],
-                capabilities: {},
-            };
-        }
-    },
-    getPackages: async (_params, ctx) => {
-        try {
-            const raw = await fs.readFile(path.join(ctx.workspaceRoot, 'package.json'), 'utf-8');
-            const pkg = JSON.parse(raw);
-            const deps = pkg.dependencies || {};
-            return Object.entries(deps).map(([name, version]) => ({ name, version }));
-        }
-        catch {
-            return [];
-        }
-    },
-};
-//# sourceMappingURL=file-ops.js.map

package/dist/cli/tunnel/handlers/mutations.d.ts

@@ -1,7 +0,0 @@
-/**
- * Workflow mutation handlers for the tunnel CLI.
- * Ported from flow-weaver-platform/src/services/ast-helpers.ts mutation wrappers.
- */
-import type { HandlerFn } from '../dispatch.js';
-export declare const mutationHandlers: Record<string, HandlerFn>;
-//# sourceMappingURL=mutations.d.ts.map