@synergenius/flow-weaver 0.10.10 → 0.10.12

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

@@ -0,0 +1,123 @@
+/**
+ * Template operation handlers for the tunnel CLI.
+ * Ported from flow-weaver-platform/src/services/ast-helpers.ts template operations.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { parser } from '../../../parser.js';
+import { workflowTemplates, nodeTemplates, getWorkflowTemplate, getNodeTemplate, } from '../../templates/index.js';
+import { resolvePath } from '../path-resolver.js';
+function mapTemplate(t) {
+    return {
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        category: t.category,
+        ...(t.configSchema && { configSchema: t.configSchema }),
+    };
+}
+export const templateHandlers = {
+    listTemplates: async (params) => {
+        const type = params.type || 'workflow';
+        const templates = type === 'node' ? nodeTemplates : workflowTemplates;
+        return { templates: templates.map(mapTemplate) };
+    },
+    getTemplate: async (params) => {
+        const type = params.type || 'workflow';
+        const id = params.id;
+        if (!id)
+            throw new Error('id is required');
+        const template = type === 'node' ? getNodeTemplate(id) : getWorkflowTemplate(id);
+        return template ? mapTemplate(template) : null;
+    },
+    getTemplatePreviewAST: async (params) => {
+        const templateId = params.templateId;
+        if (!templateId)
+            return { ast: null };
+        const template = getWorkflowTemplate(templateId);
+        if (!template)
+            return { ast: null };
+        try {
+            const code = template.generate({ workflowName: 'preview' });
+            const parsed = parser.parseFromString(code);
+            const workflows = parsed.workflows || [];
+            return { ast: workflows[0] || null };
+        }
+        catch {
+            return { ast: null };
+        }
+    },
+    generateWorkflowCode: async (params) => {
+        const templateId = params.templateId;
+        const workflowName = params.workflowName;
+        if (!templateId || !workflowName)
+            throw new Error('templateId and workflowName are required');
+        const template = getWorkflowTemplate(templateId);
+        if (!template)
+            throw new Error(`Template "${templateId}" not found`);
+        const options = { workflowName };
+        if (params.async !== undefined)
+            options.async = params.async;
+        if (params.config)
+            options.config = params.config;
+        const code = template.generate(options);
+        return { code };
+    },
+    generateNodeCode: async (params) => {
+        const templateId = params.templateId;
+        const name = params.name;
+        if (!templateId || !name)
+            throw new Error('templateId and name are required');
+        const template = getNodeTemplate(templateId);
+        if (!template)
+            throw new Error(`Node template "${templateId}" not found`);
+        const code = template.generate(name, params.config);
+        return { code };
+    },
+    getNodeTemplatePreview: async (params) => {
+        const templateId = params.templateId;
+        const name = params.name || 'preview';
+        const template = getNodeTemplate(templateId);
+        if (!template)
+            return null;
+        try {
+            const code = template.generate(name);
+            const parsed = parser.parseFromString(code);
+            const workflows = parsed.workflows || [];
+            const nodeTypes = workflows[0]?.nodeTypes || [];
+            if (nodeTypes.length === 0)
+                return null;
+            const nt = nodeTypes[0];
+            return {
+                name: nt.name,
+                inputs: nt.inputs || nt.ports?.filter((p) => p.direction === 'input') || [],
+                outputs: nt.outputs || nt.ports?.filter((p) => p.direction === 'output') || [],
+            };
+        }
+        catch {
+            return null;
+        }
+    },
+    createWorkflowFromTemplate: async (params, ctx) => {
+        const templateId = params.templateId;
+        const workflowName = params.workflowName;
+        const fileName = params.fileName;
+        if (!templateId || !workflowName)
+            throw new Error('templateId and workflowName are required');
+        const template = getWorkflowTemplate(templateId);
+        if (!template)
+            throw new Error(`Template "${templateId}" not found`);
+        const genOpts = { workflowName };
+        if (params.async !== undefined)
+            genOpts.async = params.async;
+        if (params.config)
+            genOpts.config = params.config;
+        const code = template.generate(genOpts);
+        const targetFileName = fileName || `${workflowName}.ts`;
+        const resolved = resolvePath(ctx.workspaceRoot, targetFileName);
+        await fs.mkdir(path.dirname(resolved), { recursive: true });
+        await fs.writeFile(resolved, code, 'utf-8');
+        return { success: true, filePath: '/' + targetFileName };
+    },
+};
+//# sourceMappingURL=templates.js.map

package/dist/cli/tunnel/path-resolver.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Path resolution with traversal protection for the tunnel CLI.
+ *
+ * Ported from flow-weaver-platform/src/services/workspace.ts:89-125.
+ * Virtual paths from Studio (e.g. `/workflow.ts`) are resolved to absolute
+ * filesystem paths within the workspace root.
+ */
+/**
+ * Resolve a Studio virtual path to an absolute filesystem path.
+ * Blocks null bytes and path traversal.
+ */
+export declare function resolvePath(workspaceRoot: string, studioPath: string): string;
+/**
+ * Convert an absolute filesystem path to a Studio virtual path.
+ */
+export declare function toVirtualPath(workspaceRoot: string, realPath: string): string;
+//# sourceMappingURL=path-resolver.d.ts.map

package/dist/cli/tunnel/path-resolver.js

@@ -0,0 +1,52 @@
+/**
+ * Path resolution with traversal protection for the tunnel CLI.
+ *
+ * Ported from flow-weaver-platform/src/services/workspace.ts:89-125.
+ * Virtual paths from Studio (e.g. `/workflow.ts`) are resolved to absolute
+ * filesystem paths within the workspace root.
+ */
+import * as path from 'node:path';
+/**
+ * Resolve a Studio virtual path to an absolute filesystem path.
+ * Blocks null bytes and path traversal.
+ */
+export function resolvePath(workspaceRoot, studioPath) {
+    if (studioPath.includes('\0')) {
+        throw new Error('Path traversal blocked');
+    }
+    // If the path is already absolute and within the workspace, allow it
+    if (studioPath.startsWith(workspaceRoot + path.sep) || studioPath === workspaceRoot) {
+        const resolved = path.resolve(studioPath);
+        if (!resolved.startsWith(workspaceRoot + path.sep) && resolved !== workspaceRoot) {
+            throw new Error('Path traversal blocked');
+        }
+        return resolved;
+    }
+    // Strip /cloud prefix if present
+    let normalized = studioPath;
+    if (normalized.startsWith('/cloud')) {
+        normalized = normalized.slice('/cloud'.length);
+    }
+    // Strip leading slashes
+    normalized = normalized.replace(/^\/+/, '');
+    if (!normalized) {
+        return workspaceRoot;
+    }
+    const resolved = path.resolve(workspaceRoot, normalized);
+    // Block path traversal — resolved must be within workspace
+    if (!resolved.startsWith(workspaceRoot + path.sep) && resolved !== workspaceRoot) {
+        throw new Error('Path traversal blocked');
+    }
+    return resolved;
+}
+/**
+ * Convert an absolute filesystem path to a Studio virtual path.
+ */
+export function toVirtualPath(workspaceRoot, realPath) {
+    const rel = path.relative(workspaceRoot, realPath);
+    if (rel.startsWith('..')) {
+        return '/' + path.basename(realPath);
+    }
+    return '/' + rel;
+}
+//# sourceMappingURL=path-resolver.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flow-weaver",
-  "version": "0.10.10",
+  "version": "0.10.12",
   "description": "Deterministic workflow compiler for AI agents. Compiles to standalone TypeScript, no runtime dependencies.",
   "private": false,
   "type": "module",
@@ -139,12 +139,14 @@
     "socket.io-client": "^4.8.0",
     "source-map": "^0.7.6",
     "ts-morph": "^21.0.1",
+    "ws": "^8.19.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.11.0",
     "@types/react": "^19.0.0",
+    "@types/ws": "^8.18.1",
     "@vitest/coverage-v8": "^4.0.18",
     "esbuild": "^0.27.2",
     "prettier": "^3.1.1",