@synergenius/flow-weaver 0.10.10 → 0.10.12

package/dist/cli/index.js

@@ -19,6 +19,7 @@ import { initCommand } from './commands/init.js';
 import { watchCommand } from './commands/watch.js';
 import { devCommand } from './commands/dev.js';
 import { listenCommand } from './commands/listen.js';
+import { tunnelCommand } from './commands/tunnel.js';
 import { mcpServerCommand } from '../mcp/server.js';
 import { uiFocusNode, uiAddNode, uiOpenWorkflow, uiGetState, uiBatch } from './commands/ui.js';
 import { grammarCommand } from './commands/grammar.js';
@@ -269,6 +270,22 @@ program
         process.exit(1);
     }
 });
+// Tunnel command
+program
+    .command('tunnel')
+    .description('Connect cloud Studio to your local project directory')
+    .requiredOption('-k, --key <apiKey>', 'API key for cloud authentication (fw_xxxx)')
+    .option('-c, --cloud <url>', 'Cloud server URL', 'https://flowweaver.dev')
+    .option('-d, --dir <path>', 'Project directory', process.cwd())
+    .action(async (options) => {
+    try {
+        await tunnelCommand(options);
+    }
+    catch (error) {
+        logger.error(`Command failed: ${getErrorMessage(error)}`);
+        process.exit(1);
+    }
+});
 // MCP server command
 program
     .command('mcp-server')

package/dist/cli/tunnel/dispatch.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Method dispatcher for the self-contained tunnel.
+ *
+ * Maps RPC method names to handler functions and wraps them
+ * in a standard try/catch envelope.
+ */
+export interface TunnelContext {
+    workspaceRoot: string;
+}
+export type HandlerFn = (params: Record<string, unknown>, ctx: TunnelContext) => Promise<unknown>;
+export declare function dispatch(method: string, params: Record<string, unknown>, ctx: TunnelContext): Promise<{
+    success: boolean;
+    result?: unknown;
+    error?: {
+        message: string;
+    };
+}>;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/cli/tunnel/dispatch.js

@@ -0,0 +1,36 @@
+/**
+ * Method dispatcher for the self-contained tunnel.
+ *
+ * Maps RPC method names to handler functions and wraps them
+ * in a standard try/catch envelope.
+ */
+import { fileOpsHandlers } from './handlers/file-ops.js';
+import { astOpsHandlers } from './handlers/ast-ops.js';
+import { mutationHandlers } from './handlers/mutations.js';
+import { templateHandlers } from './handlers/templates.js';
+import { executionHandlers } from './handlers/execution.js';
+import { stubHandlers } from './handlers/stubs.js';
+const handlers = {
+    ...stubHandlers,
+    ...fileOpsHandlers,
+    ...astOpsHandlers,
+    ...mutationHandlers,
+    ...templateHandlers,
+    ...executionHandlers,
+};
+export async function dispatch(method, params, ctx) {
+    const handler = handlers[method];
+    if (!handler) {
+        // Unknown methods return undefined — matches platform behaviour
+        return { success: true, result: undefined };
+    }
+    try {
+        const result = await handler(params, ctx);
+        return { success: true, result };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { success: false, error: { message } };
+    }
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/cli/tunnel/file-lock.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+export declare function withFileLock<T>(filePath: string, operation: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=file-lock.d.ts.map

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

@@ -0,0 +1,36 @@
+/**
+ * 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

@@ -0,0 +1,10 @@
+/**
+ * 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

@@ -0,0 +1,252 @@
+/**
+ * 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

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

@@ -0,0 +1,89 @@
+/**
+ * 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

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