@synergenius/flow-weaver 0.20.7 → 0.21.0

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

@@ -1,285 +0,0 @@
-/**
- * Workflow mutation handlers for the tunnel CLI.
- * Ported from flow-weaver-platform/src/services/ast-helpers.ts mutation wrappers.
- */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { parser, resolveNpmNodeTypes } from '../../../parser.js';
-import { generateInPlace } from '../../../api/generate-in-place.js';
-import { addNode, removeNode, updateNode, renameNode, setNodePosition, setNodeMinimized, setNodeSize, } from '../../../api/manipulation/nodes.js';
-import { addConnection, removeConnection } from '../../../api/manipulation/connections.js';
-import { addNodeType, removeNodeType, renameNodeType, updateNodeType, } from '../../../api/manipulation/node-types.js';
-import { setStartExitPorts, setInstancePortConfigs } from '../../../api/manipulation/ports.js';
-import { resolvePath } from '../path-resolver.js';
-import { withFileLock } from '../file-lock.js';
-import { prepareMutationResult, getWorkflowName } from './ast-ops.js';
-// ---------------------------------------------------------------------------
-// Core mutation engine — ported from ast-helpers.ts:95-159
-// ---------------------------------------------------------------------------
-async function mutateWorkflowFile({ filePath, functionName, mutator, }) {
-    return withFileLock(filePath, async () => {
-        const sourceCode = await fs.readFile(filePath, 'utf-8');
-        const parsed = parser.parse(filePath);
-        const workflows = parsed.workflows || [];
-        if (workflows.length === 0) {
-            throw new Error(`No workflows found in ${filePath}`);
-        }
-        const targetIndex = functionName
-            ? workflows.findIndex((w) => w.functionName === functionName)
-            : 0;
-        if (targetIndex < 0) {
-            throw new Error(`Workflow "${functionName}" not found in ${filePath}`);
-        }
-        const original = workflows[targetIndex];
-        const updated = mutator(original);
-        // Preserve importSource for node types through mutation
-        const importSourceMap = new Map();
-        for (const nt of original.nodeTypes || []) {
-            if (nt.importSource) {
-                importSourceMap.set(nt.name, nt.importSource);
-            }
-        }
-        const updatedNodeTypes = (updated.nodeTypes || []).map((nt) => {
-            if (!nt.importSource && importSourceMap.has(nt.name)) {
-                return { ...nt, importSource: importSourceMap.get(nt.name) };
-            }
-            return nt;
-        });
-        // Re-append node types that existed in original but are missing after mutation
-        const updatedTypeNames = new Set(updatedNodeTypes.map((nt) => nt.name));
-        const missingTypes = [];
-        for (const nt of original.nodeTypes || []) {
-            if (!updatedTypeNames.has(nt.name)) {
-                missingTypes.push(nt);
-            }
-        }
-        const workflowForGeneration = {
-            ...updated,
-            nodeTypes: [...updatedNodeTypes, ...missingTypes],
-        };
-        const result = generateInPlace(sourceCode, workflowForGeneration);
-        await fs.writeFile(filePath, result.code, 'utf-8');
-        return resolveNpmNodeTypes(updated, path.dirname(filePath));
-    });
-}
-// ---------------------------------------------------------------------------
-// Handler factory — reduces boilerplate for simple mutations
-// ---------------------------------------------------------------------------
-function makeMutationHandler(extractMutator) {
-    return 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 result = await mutateWorkflowFile({
-            filePath: resolved,
-            functionName,
-            mutator: extractMutator(params),
-        });
-        return prepareMutationResult(result, ctx.workspaceRoot);
-    };
-}
-// ---------------------------------------------------------------------------
-// Exported handlers
-// ---------------------------------------------------------------------------
-export const mutationHandlers = {
-    addNode: makeMutationHandler((params) => {
-        let node = params.node;
-        if (!node) {
-            const nodeType = params.nodeType;
-            const nodeName = params.nodeName;
-            const position = params.position;
-            node = { type: 'NodeInstance', id: nodeName, nodeType, ...(position && { position }) };
-        }
-        return (wf) => addNode(wf, node);
-    }),
-    removeNode: makeMutationHandler((params) => {
-        const nodeId = (params.nodeName || params.nodeId);
-        if (!nodeId)
-            throw new Error('nodeId is required');
-        return (wf) => removeNode(wf, nodeId, { removeConnections: true });
-    }),
-    updateNode: makeMutationHandler((params) => {
-        const nodeId = (params.nodeId || params.nodeName);
-        const updates = params.updates;
-        if (!nodeId)
-            throw new Error('nodeId is required');
-        return (wf) => updateNode(wf, nodeId, updates);
-    }),
-    renameNode: makeMutationHandler((params) => {
-        const oldId = params.oldId;
-        const newId = params.newId;
-        if (!oldId || !newId)
-            throw new Error('oldId and newId are required');
-        return (wf) => renameNode(wf, oldId, newId);
-    }),
-    setNodePosition: makeMutationHandler((params) => {
-        const nodeId = params.nodeId;
-        const x = params.x;
-        const y = params.y;
-        return (wf) => setNodePosition(wf, nodeId, x, y);
-    }),
-    setNodePositions: makeMutationHandler((params) => {
-        const positions = params.positions;
-        if (!positions)
-            throw new Error('positions are required');
-        return (wf) => {
-            let result = wf;
-            for (const { nodeId, x, y } of positions) {
-                result = setNodePosition(result, nodeId, x, y);
-            }
-            return result;
-        };
-    }),
-    setNodeMinimized: makeMutationHandler((params) => {
-        const nodeId = params.nodeId;
-        const minimized = params.minimized;
-        return (wf) => setNodeMinimized(wf, nodeId, minimized);
-    }),
-    setNodeSize: makeMutationHandler((params) => {
-        const nodeId = params.nodeId;
-        const width = params.width;
-        const height = params.height;
-        return (wf) => setNodeSize(wf, nodeId, width, height);
-    }),
-    setNodeLabel: makeMutationHandler((params) => {
-        const nodeId = params.nodeId;
-        const label = params.label;
-        return (wf) => updateNode(wf, nodeId, { label });
-    }),
-    addNodes: makeMutationHandler((params) => {
-        const nodes = params.nodes;
-        if (!nodes)
-            throw new Error('nodes are required');
-        return (wf) => {
-            let result = wf;
-            for (const node of nodes) {
-                result = addNode(result, node);
-            }
-            return result;
-        };
-    }),
-    removeNodes: makeMutationHandler((params) => {
-        const nodeIds = params.nodeIds;
-        if (!nodeIds)
-            throw new Error('nodeIds are required');
-        return (wf) => {
-            let result = wf;
-            for (const nodeId of nodeIds) {
-                result = removeNode(result, nodeId, { removeConnections: true });
-            }
-            return result;
-        };
-    }),
-    addConnection: makeMutationHandler((params) => {
-        const from = params.from || { node: params.fromNode, port: params.fromPort };
-        const to = params.to || { node: params.toNode, port: params.toPort };
-        return (wf) => addConnection(wf, from, to);
-    }),
-    removeConnection: makeMutationHandler((params) => {
-        const from = params.from || { node: params.fromNode, port: params.fromPort };
-        const to = params.to || { node: params.toNode, port: params.toPort };
-        return (wf) => removeConnection(wf, from, to);
-    }),
-    setConnections: makeMutationHandler((params) => {
-        const connections = params.connections;
-        return (wf) => ({ ...wf, connections });
-    }),
-    addConnections: makeMutationHandler((params) => {
-        const connections = params.connections;
-        return (wf) => ({ ...wf, connections: [...wf.connections, ...connections] });
-    }),
-    updateNodePortConfig: makeMutationHandler((params) => {
-        const nodeId = params.nodeId;
-        const portName = params.portName;
-        const portConfig = params.portConfig;
-        return (wf) => {
-            const node = wf.instances?.find((n) => n.id === nodeId);
-            if (!node)
-                throw new Error(`Node "${nodeId}" not found`);
-            const existing = node.config?.portConfigs || [];
-            const idx = existing.findIndex((pc) => pc.portName === portName);
-            const updated = [...existing];
-            if (idx >= 0) {
-                updated[idx] = { ...updated[idx], ...portConfig };
-            }
-            else {
-                updated.push({ portName, ...portConfig });
-            }
-            return updateNode(wf, nodeId, { config: { ...node.config, portConfigs: updated } });
-        };
-    }),
-    resetNodePortConfig: makeMutationHandler((params) => {
-        const nodeId = params.nodeId;
-        const portName = params.portName;
-        return (wf) => {
-            const node = wf.instances?.find((n) => n.id === nodeId);
-            if (!node)
-                throw new Error(`Node "${nodeId}" not found`);
-            const existing = node.config?.portConfigs || [];
-            const filtered = existing.filter((pc) => pc.portName !== portName);
-            return updateNode(wf, nodeId, { config: { ...node.config, portConfigs: filtered } });
-        };
-    }),
-    updateInstancePortConfigs: makeMutationHandler((params) => {
-        const instanceId = params.instanceId;
-        const portConfigs = params.portConfigs;
-        return (wf) => setInstancePortConfigs(wf, instanceId, portConfigs);
-    }),
-    updateWorkflowPorts: makeMutationHandler((params) => {
-        const nodeType = params.nodeType;
-        const ports = params.ports;
-        return (wf) => setStartExitPorts(wf, nodeType, ports);
-    }),
-    addNodeType: makeMutationHandler((params) => {
-        const nodeType = params.nodeType;
-        return (wf) => addNodeType(wf, nodeType);
-    }),
-    removeNodeType: makeMutationHandler((params) => {
-        const typeName = params.typeName;
-        if (!typeName)
-            throw new Error('typeName is required');
-        return (wf) => removeNodeType(wf, typeName);
-    }),
-    renameNodeType: makeMutationHandler((params) => {
-        const oldTypeName = params.oldTypeName;
-        const newTypeName = params.newTypeName;
-        return (wf) => renameNodeType(wf, oldTypeName, newTypeName);
-    }),
-    updateNodeType: makeMutationHandler((params) => {
-        const typeName = params.typeName;
-        const updates = params.updates;
-        return (wf) => updateNodeType(wf, typeName, updates);
-    }),
-    setNodeTypes: makeMutationHandler((params) => {
-        const nodeTypes = params.nodeTypes;
-        return (wf) => ({ ...wf, nodeTypes });
-    }),
-    saveWorkflowState: makeMutationHandler((params) => {
-        const workflow = params.workflow;
-        return () => workflow;
-    }),
-    setNodeParent: makeMutationHandler((params) => {
-        const nodeId = params.nodeId;
-        const parentId = params.parentId;
-        return (wf) => updateNode(wf, nodeId, { parent: parentId });
-    }),
-    setNodesParent: makeMutationHandler((params) => {
-        const nodeIds = params.nodeIds;
-        const parentId = params.parentId;
-        return (wf) => {
-            let result = wf;
-            for (const nodeId of nodeIds) {
-                result = updateNode(result, nodeId, { parent: parentId });
-            }
-            return result;
-        };
-    }),
-    setCurrentWorkflow: async () => ({ success: true }),
-    setWorkflowForceAsync: makeMutationHandler((params) => {
-        const forceAsync = params.forceAsync;
-        return (wf) => ({ ...wf, forceAsync });
-    }),
-};
-//# sourceMappingURL=mutations.js.map

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

@@ -1,7 +0,0 @@
-/**
- * Stub handlers — methods that return sensible defaults.
- * Matches the no-op return values from flow-weaver-platform/src/routes/studio-rpc.ts.
- */
-import type { HandlerFn } from '../dispatch.js';
-export declare const stubHandlers: Record<string, HandlerFn>;
-//# sourceMappingURL=stubs.d.ts.map

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

@@ -1,143 +0,0 @@
-/**
- * Stub handlers — methods that return sensible defaults.
- * Matches the no-op return values from flow-weaver-platform/src/routes/studio-rpc.ts.
- */
-import * as os from 'node:os';
-const stub = (value) => () => Promise.resolve(value);
-const lazyStub = (fn) => () => Promise.resolve(fn());
-export const stubHandlers = {
-    // --- Completions / Quick Info ---
-    getCompletions: stub([]),
-    getQuickInfo: stub(undefined),
-    // --- Snapshots (undo/redo state is client-side) ---
-    takeWorkflowSnapshot: stub({ success: true }),
-    deleteWorkflowSnapshot: stub({ success: true }),
-    deleteAllWorkflowSnapshots: stub({ success: true }),
-    cleanupOldWorkflowSnapshots: stub({ success: true }),
-    loadWorkflowSnapshot: stub(null),
-    getLatestWorkflowSnapshot: stub(null),
-    getWorkflowSnapshotAtIndex: stub(null),
-    findCommonBaseSnapshot: stub(null),
-    listWorkflowSnapshots: stub([]),
-    // --- Backups ---
-    createBackup: stub({ success: true }),
-    listBackups: stub([]),
-    restoreBackup: stub({ success: true }),
-    deleteBackup: stub({ success: true }),
-    cleanupOldBackups: stub({ success: true }),
-    // --- Deployment profiles / project config ---
-    listDeploymentProfiles: stub([]),
-    readDeploymentProfile: stub(null),
-    readProjectConfig: stub(null),
-    writeDeploymentProfile: stub({ success: true }),
-    deleteDeploymentProfile: stub({ success: true }),
-    setActiveDeploymentProfile: stub({ success: true }),
-    writeProjectConfig: stub({ success: true }),
-    // --- Export ---
-    exportWorkflow: stub({ success: true }),
-    exportMultiWorkflow: stub({ success: true }),
-    exportNodeTypes: stub({ success: true }),
-    exportBundle: stub({ success: true }),
-    // --- Misc ---
-    getUserDataPath: lazyStub(() => os.tmpdir()),
-    getTempDirectory: lazyStub(() => os.tmpdir()),
-    openDirectoryInExplorer: stub({ success: true }),
-    checkDeployPrerequisites: stub({ success: true }),
-    appendToLog: stub(undefined),
-    getMatchingFileList: stub([]),
-    generateAnnotationSuggestion: stub(null),
-    addWorkflowToFile: stub({ success: true }),
-    removeWorkflowFromFile: stub({ success: true }),
-    toggleWorkflowExportInFile: stub({ success: true }),
-    getAvailableNodeTypesInFile: stub([]),
-    scanProjectBundleItems: stub([]),
-    getAvailableItemsInWorkdir: stub([]),
-    getAvailableItemsInFiles: stub([]),
-    getWorkflowEndpointInfo: stub(null),
-    callTool: stub(undefined),
-    getTypedPackages: stub([]),
-    getPackageExports: stub([]),
-    warmUpWorkflowCache: stub(undefined),
-    preBundleWorkflow: stub(undefined),
-    getLocalFunctionCode: stub(null),
-    evaluateExpression: stub(undefined),
-    interruptExecution: stub({ success: false }),
-    setWatcher: stub({ success: true }),
-    stopWatcher: stub({ success: true }),
-    // --- Marketplace ---
-    marketplaceSearch: stub({ results: [] }),
-    marketplaceListInstalled: stub([]),
-    marketplaceInstall: stub({ success: true }),
-    // --- Patterns ---
-    getPatterns: stub([]),
-    applyPatternToWorkflow: stub({ success: true }),
-    extractPatternFromWorkflow: stub({ success: true }),
-    // --- Plugins ---
-    initializePlugins: stub(undefined),
-    cleanupPlugins: stub(undefined),
-    getPlugins: stub([]),
-    getPluginSystemStatus: stub({ status: 'ready' }),
-    callPlugin: stub(undefined),
-    // --- Git ---
-    getRepository: stub({}),
-    gitInit: stub({}),
-    gitClone: stub({}),
-    gitStatus: stub({
-        files: [],
-        modified: [],
-        not_added: [],
-        created: [],
-        deleted: [],
-        renamed: [],
-        conflicted: [],
-        ignored: [],
-        current: 'main',
-    }),
-    gitCommit: stub({ success: true }),
-    gitPush: stub({ success: true }),
-    gitPull: stub({ success: true }),
-    gitFetch: stub({ success: true }),
-    gitStageFiles: stub({ success: true }),
-    gitGetWorkingDiff: stub({ success: true }),
-    gitHistory: stub({ success: true }),
-    gitGetCommitFiles: stub({ success: true }),
-    gitGetCommitDiff: stub({ success: true }),
-    gitGetFileAtCommit: stub({ success: true }),
-    gitBranchList: stub({ success: true, branches: ['main'], current: 'main' }),
-    gitBranchCreate: stub({ success: true }),
-    gitBranchCheckout: stub({ success: true }),
-    gitTagCreate: stub({ success: true }),
-    gitTagDelete: stub({ success: true }),
-    gitStashSave: stub({ success: true }),
-    gitStashApply: stub({ success: true }),
-    gitRemoteAdd: stub({ success: true }),
-    gitRemoteFetch: stub({ success: true }),
-    gitMerge: stub({ success: true }),
-    gitReset: stub({ success: true }),
-    gitTagList: stub({ success: true, tags: [] }),
-    gitStashList: stub({ success: true, stashes: [] }),
-    gitRemoteList: stub({ success: true, remotes: [] }),
-    gitRepoList: stub([]),
-    // --- Terminal (stub for now — requires node-pty) ---
-    createTerminal: stub({ success: false, error: 'Terminal not supported in tunnel mode' }),
-    writeToTerminal: stub({ success: false }),
-    resizeTerminal: stub({ success: false }),
-    closeTerminal: stub({ success: false }),
-    pauseTerminal: stub({ success: false }),
-    resumeTerminal: stub({ success: false }),
-    listTerminals: stub([]),
-    // --- Debug ---
-    debugCreateSession: stub(undefined),
-    debugEndSession: stub(undefined),
-    debugSetBreakpoints: stub(undefined),
-    debugResume: stub(undefined),
-    debugStepOver: stub(undefined),
-    debugStepInto: stub(undefined),
-    debugStepOut: stub(undefined),
-    debugEvaluateExpression: stub(undefined),
-    debugInspectVariable: stub(undefined),
-    // --- Doctor ---
-    runDoctor: stub({ status: 'healthy', checks: [], summary: { passed: 0, failed: 0, warnings: 0 } }),
-    runDoctorChecks: stub({ status: 'healthy', checks: [], summary: { passed: 0, failed: 0, warnings: 0 } }),
-};
-//# sourceMappingURL=stubs.js.map

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

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

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

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

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

@@ -1,54 +0,0 @@
-/**
- * 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;
-    }
-    // Normalize backslashes to forward slashes (Windows clients may send them)
-    let normalized = studioPath.replace(/\\/g, '/');
-    // Strip /cloud prefix if present
-    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);
-    }
-    // Always use forward slashes in virtual paths (Windows path.relative uses backslashes)
-    return '/' + rel.replace(/\\/g, '/');
-}
-//# sourceMappingURL=path-resolver.js.map

package/dist/defaults.d.ts

@@ -1,3 +0,0 @@
-export declare const DEFAULT_PORT: number;
-export declare const DEFAULT_SERVER_URL: string;
-//# sourceMappingURL=defaults.d.ts.map

package/dist/defaults.js

@@ -1,3 +0,0 @@
-export const DEFAULT_PORT = parseInt(process.env.FW_PORT || '6546', 10);
-export const DEFAULT_SERVER_URL = `http://localhost:${DEFAULT_PORT}`;
-//# sourceMappingURL=defaults.js.map