@codemcp/workflows-opencode 6.5.0

package/README.md

@@ -0,0 +1,85 @@
+# @codemcp/workflows-opencode
+
+An [OpenCode](https://github.com/opencode-ai/opencode) plugin that enforces structured development workflows for AI coding agents.
+
+## Why?
+
+Small and mid-sized LLMs tend to skip process steps, edit code during exploration phases, and lose track of decisions after context compaction. This plugin addresses these problems:
+
+| Problem                | Solution                                                            |
+| ---------------------- | ------------------------------------------------------------------- |
+| **Phase discipline**   | Hard-blocks file edits that violate current phase restrictions      |
+| **Lost context**       | Automatically injects phase instructions on every turn              |
+| **Context compaction** | Guides summary to preserve decisions and include phase continuation |
+
+## How it works
+
+The plugin hooks into OpenCode's message pipeline:
+
+- **`chat.message`** — Injects phase instructions after each user message
+- **`tool.execute.before`** — Blocks disallowed file edits with a clear error (hard enforcement)
+- **`experimental.session.compacting`** — Guides compaction to preserve key info and end with phase continuation
+
+This replaces the need for the agent to call `whats_next()` — guidance is injected automatically.
+
+## Architecture: Synthetic Message Injection
+
+Unlike the MCP server approach where agents must explicitly call `whats_next()`, this plugin uses **synthetic message injection**:
+
+```
+User Message (as seen by LLM)
+├── Part 1: User's actual text
+│   └── id: "prt_abc123..."
+│
+└── Part 2: Workflow guidance (INJECTED)
+    └── id: "prt_workflows_{timestamp}"
+```
+
+The plugin intercepts each user message, fetches phase-specific instructions from the workflow engine, and appends them as an additional message part. The LLM sees both parts as coming from the user.
+
+### Principles
+
+1. **Zero tool overhead** — No LLM reasoning tokens spent on "should I call whats_next?"
+2. **Guaranteed execution** — Every user message triggers guidance injection
+3. **Invisible to the agent** — Instructions appear naturally in the conversation
+4. **Consistent task management** — `bd` CLI commands with `--parent` flags are always included
+
+### Efficiency Comparison
+
+Measured from real sessions building a todo app:
+
+| Metric                   | Plugin (synthetic) | MCP (tool calls) |
+| ------------------------ | ------------------ | ---------------- |
+| `whats_next` tool calls  | 0                  | 7                |
+| Synthetic parts injected | 2                  | 3                |
+| Total tool calls         | 82                 | 106              |
+| Files created            | 36                 | 0 (incomplete)   |
+| Task completion          | ✅ Full app        | ❌ Interrupted   |
+
+The plugin approach reduces tool call overhead by ~23% while maintaining full workflow compliance. Agents correctly use hierarchical task management (`bd create --parent <phase-id>`) without explicit tool invocations.
+
+## Installation
+
+```json
+// opencode.json
+{
+  "plugin": ["@codemcp/workflows-opencode"]
+}
+```
+
+Or for local development:
+
+```json
+{
+  "plugin": ["/path/to/responsible-vibe/packages/opencode-plugin"]
+}
+```
+
+## Status
+
+Integrated with `@codemcp/workflows-core` for real state management and phase-based file restrictions.
+
+## Related
+
+- [`@codemcp/workflows-core`](../core) — The workflow engine (shared with MCP server)
+- [`@codemcp/workflows-server`](../mcp-server) — MCP server for non-OpenCode hosts (Claude Code, Cline, etc.)

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * OpenCode Workflows Plugin
+ *
+ * Structured development workflows for OpenCode.
+ * Replaces the MCP server with native OpenCode integration.
+ */
+export { WorkflowsPlugin } from './plugin.js';
+export * from './types.js';
+export { default } from './plugin.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * OpenCode Workflows Plugin
+ *
+ * Structured development workflows for OpenCode.
+ * Replaces the MCP server with native OpenCode integration.
+ */
+export { WorkflowsPlugin } from './plugin.js';
+export * from './types.js';
+// Default export for opencode plugin loader
+export { default } from './plugin.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,cAAc,YAAY,CAAC;AAE3B,4CAA4C;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC"}

package/dist/opencode-logger.d.ts

@@ -0,0 +1,21 @@
+import { type LoggerFactory } from '@codemcp/workflows-core';
+import type { PluginInput } from './types.js';
+/**
+ * Logger interface for structured logging
+ */
+export interface Logger {
+    debug: (message: string, extra?: Record<string, unknown>) => void;
+    info: (message: string, extra?: Record<string, unknown>) => void;
+    warn: (message: string, extra?: Record<string, unknown>) => void;
+    error: (message: string, extra?: Record<string, unknown>) => void;
+}
+/**
+ * Create a logger factory that creates loggers which send output to OpenCode SDK.
+ * This factory can be passed to ServerContext so handlers use OpenCode logging.
+ */
+export declare function createOpenCodeLoggerFactory(client: PluginInput['client']): LoggerFactory;
+/**
+ * Create a logger backed by core's createLogger + a LogSink that delegates
+ * log output to the OpenCode SDK client.app.log() API.
+ */
+export declare function createOpenCodeLogger(client: PluginInput['client']): Logger;

package/dist/opencode-logger.js

@@ -0,0 +1,104 @@
+import { createLogger as coreCreateLogger, registerLogSink, } from '@codemcp/workflows-core';
+/**
+ * Create a logger factory that creates loggers which send output to OpenCode SDK.
+ * This factory can be passed to ServerContext so handlers use OpenCode logging.
+ */
+export function createOpenCodeLoggerFactory(client) {
+    const openCodeClient = client;
+    return (component) => {
+        return {
+            debug: (message, context) => {
+                openCodeClient.app
+                    .log({
+                    body: {
+                        service: component,
+                        level: 'debug',
+                        message,
+                        extra: context,
+                    },
+                })
+                    .catch(() => { });
+            },
+            info: (message, context) => {
+                openCodeClient.app
+                    .log({
+                    body: {
+                        service: component,
+                        level: 'info',
+                        message,
+                        extra: context,
+                    },
+                })
+                    .catch(() => { });
+            },
+            warn: (message, context) => {
+                openCodeClient.app
+                    .log({
+                    body: {
+                        service: component,
+                        level: 'warn',
+                        message,
+                        extra: context,
+                    },
+                })
+                    .catch(() => { });
+            },
+            error: (message, error, context) => {
+                const errorContext = error
+                    ? { ...context, error: error.message, stack: error.stack }
+                    : context;
+                openCodeClient.app
+                    .log({
+                    body: {
+                        service: component,
+                        level: 'error',
+                        message,
+                        extra: errorContext,
+                    },
+                })
+                    .catch(() => { });
+            },
+        };
+    };
+}
+/**
+ * Create a logger backed by core's createLogger + a LogSink that delegates
+ * log output to the OpenCode SDK client.app.log() API.
+ */
+export function createOpenCodeLogger(client) {
+    const openCodeClient = client;
+    const service = 'plugin.workflows';
+    // Register a LogSink that forwards core log events to the OpenCode SDK.
+    // The core LogSink interface uses 'warning' for warn-level; we map that
+    // back to 'warn' for the OpenCode SDK which expects the shorter form.
+    const sink = {
+        log: (level, _logger, message, context) => {
+            const sdkLevel = level === 'warning' ? 'warn' : level;
+            try {
+                return openCodeClient.app.log({
+                    body: {
+                        service,
+                        level: sdkLevel,
+                        message,
+                        extra: context,
+                    },
+                });
+            }
+            catch {
+                return Promise.resolve();
+            }
+        },
+    };
+    registerLogSink(sink);
+    // Return a Logger that delegates to the core logger.
+    // The core error() method has signature (message, error?, context?) so we
+    // wrap it to match our simpler (message, extra?) interface.
+    const coreLogger = coreCreateLogger('plugin.workflows');
+    return {
+        debug: (message, extra) => coreLogger.debug(message, extra),
+        info: (message, extra) => coreLogger.info(message, extra),
+        warn: (message, extra) => coreLogger.warn(message, extra),
+        error: (message, extra) => coreLogger.error(message, undefined, extra),
+    };
+}
+//# sourceMappingURL=opencode-logger.js.map

package/dist/opencode-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-logger.js","sourceRoot":"","sources":["../src/opencode-logger.ts"],"names":[],"mappings":"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"}

package/dist/plugin.d.ts

@@ -0,0 +1,23 @@
+/**
+ * OpenCode Workflows Plugin
+ *
+ * Integrates workflows-core state management with OpenCode hooks to provide
+ * phase-aware development guidance and file edit restrictions.
+ *
+ * Hooks implemented:
+ * 1. chat.message - Add synthetic part with phase instructions after each user message
+ * 2. tool.execute.before - Block editing of certain files based on phase
+ * 3. experimental.session.compacting - Inject workflow state into compaction context
+ *
+ * Logs are sent via OpenCode SDK's client.app.log() API
+ */
+import type { Plugin } from './types.js';
+/**
+ * Main plugin export
+ */
+export declare const WorkflowsPlugin: Plugin;
+declare const _default: {
+    id: string;
+    server: Plugin;
+};
+export default _default;

package/dist/plugin.js

@@ -0,0 +1,395 @@
+/**
+ * OpenCode Workflows Plugin
+ *
+ * Integrates workflows-core state management with OpenCode hooks to provide
+ * phase-aware development guidance and file edit restrictions.
+ *
+ * Hooks implemented:
+ * 1. chat.message - Add synthetic part with phase instructions after each user message
+ * 2. tool.execute.before - Block editing of certain files based on phase
+ * 3. experimental.session.compacting - Inject workflow state into compaction context
+ *
+ * Logs are sent via OpenCode SDK's client.app.log() API
+ */
+import { createProceedToPhaseTool } from './tool-handlers/proceed-to-phase.js';
+import { createConductReviewTool } from './tool-handlers/conduct-review.js';
+import { createResetDevelopmentTool } from './tool-handlers/reset-development.js';
+import { createStartDevelopmentTool } from './tool-handlers/start-development.js';
+import { createSetupProjectDocsTool } from './tool-handlers/setup-project-docs.js';
+import { createOpenCodeLogger, createOpenCodeLoggerFactory, } from './opencode-logger.js';
+import { PlanManager, InstructionGenerator } from '@codemcp/workflows-core';
+import { WhatsNextHandler, } from '@codemcp/workflows-server';
+import { createServerContext, initializeServerContext, } from './server-context.js';
+import { stripWhatsNextReferences } from './utils.js';
+/**
+ * Match a file path against a glob pattern.
+ * Supports patterns like:
+ *   - `**\/*`       → matches everything
+ *   - `**\/*.md`    → matches any .md file in any directory
+ *   - `**\/*.test.ts` → matches test files
+ */
+function matchGlobPattern(filePath, pattern) {
+    // Normalise to forward slashes
+    const normalised = filePath.replace(/\\/g, '/');
+    const baseName = normalised.split('/').pop() ?? '';
+    // `**/*` means "allow everything"
+    if (pattern === '**/*' || pattern === '*') {
+        return true;
+    }
+    // Convert glob pattern to a regex:
+    //   - Escape regex metacharacters except * and .
+    //   - `**/` at the start → match any path prefix (or empty)
+    //   - `**`  elsewhere    → match any sequence of characters incl. /
+    //   - `*`               → match any sequence of characters excl. /
+    //   - `.`               → literal dot
+    const regexSource = pattern
+        .replace(/\\/g, '/')
+        // Escape regex special chars (except * which we handle separately)
+        .replace(/[+?^${}()|[\]]/g, '\\$&')
+        // Literal dot
+        .replace(/\./g, '\\.')
+        // `**/` at the start → optional path prefix
+        .replace(/^\*\*\//, '(?:.+\\/)?')
+        // remaining `**` → any chars including /
+        .replace(/\*\*/g, '.*')
+        // remaining `*` → any chars except /
+        .replace(/\*/g, '[^/]*');
+    const regex = new RegExp(`^${regexSource}$`);
+    // Try matching against full normalised path and against basename
+    return regex.test(normalised) || regex.test(baseName);
+}
+/**
+ * Check if a file edit is allowed based on glob patterns
+ */
+function isFileAllowed(filePath, patterns) {
+    // If allowed patterns includes '**/*' or '*', all files are allowed
+    if (patterns.includes('**/*') || patterns.includes('*')) {
+        return true;
+    }
+    // Check if the file path matches any allowed glob pattern
+    return patterns.some(pattern => matchGlobPattern(filePath, pattern));
+}
+/**
+ * Main plugin export
+ */
+export const WorkflowsPlugin = async (input) => {
+    // Initialize logger using OpenCode SDK
+    const logger = createOpenCodeLogger(input.client);
+    const loggerFactory = createOpenCodeLoggerFactory(input.client);
+    logger.info('Plugin initializing', {
+        directory: input.directory,
+        worktree: input.worktree,
+    });
+    // Initialize workflows enabled state from environment variable
+    const envWorkflows = process.env.WORKFLOWS?.toLowerCase();
+    let workflowsEnabled = envWorkflows === 'off' ? false : true; // default: enabled
+    logger.info('Workflows state initialized', { workflowsEnabled });
+    // Initialize instruction generator
+    const planManager = new PlanManager();
+    const instructionGenerator = new InstructionGenerator();
+    // Cached ServerContext - created once, reused for all requests
+    // This avoids creating new WorkflowManager/PluginRegistry instances per request
+    let cachedServerContext = null;
+    let serverContextInitialized = false;
+    // Buffered instructions from tools (proceed_to_phase, start_development).
+    // Consumed and cleared by the next chat.message hook call.
+    let bufferedInstructions = null;
+    /**
+     * Set buffered instructions from a tool result.
+     * The next chat.message hook will use these instead of calling WhatsNextHandler.
+     */
+    function setBufferedInstructions(result) {
+        bufferedInstructions = {
+            phase: result.phase,
+            instructions: result.instructions,
+            planFilePath: result.plan_file_path,
+            allowedFilePatterns: result.allowed_file_patterns,
+        };
+    }
+    // Helper to get an initialized ServerContext for handler delegation
+    // Creates once, reuses for all subsequent calls
+    async function getServerContext() {
+        if (!cachedServerContext) {
+            cachedServerContext = createServerContext({
+                projectDir: input.directory,
+                planManager,
+                instructionGenerator,
+                loggerFactory,
+            });
+        }
+        if (!serverContextInitialized) {
+            await initializeServerContext(cachedServerContext);
+            serverContextInitialized = true;
+        }
+        return cachedServerContext;
+    }
+    // Log registered plugins at startup (once)
+    getServerContext()
+        .then(context => {
+        const pluginNames = context.pluginRegistry?.getPluginNames() ?? [];
+        if (pluginNames.length > 0) {
+            logger.info('Registered plugins', { plugins: pluginNames });
+        }
+        else {
+            logger.debug('No plugins registered');
+        }
+    })
+        .catch(() => {
+        // Ignore errors during startup plugin check
+    });
+    /**
+     * Read current workflow state from ConversationManager via shared ServerContext.
+     * Returns null if no active conversation exists.
+     */
+    async function getWorkflowState() {
+        try {
+            const serverContext = await getServerContext();
+            const context = await serverContext.conversationManager.getConversationContext();
+            const stateMachine = serverContext.workflowManager.loadWorkflowForProject(context.projectPath, context.workflowName);
+            const phaseState = stateMachine.states[context.currentPhase];
+            return {
+                phase: context.currentPhase,
+                phaseDescription: phaseState?.description ?? null,
+                allowedFilePatterns: phaseState?.allowed_file_patterns ?? ['**/*'],
+                workflowName: context.workflowName,
+            };
+        }
+        catch (_error) {
+            return null;
+        }
+    }
+    return {
+        /**
+         * Hook 1: chat.message
+         * Fires after user message is created but before LLM processes it.
+         * We add a synthetic part with phase instructions.
+         */
+        'chat.message': async (hookInput, output) => {
+            // Skip if workflows are disabled
+            if (!workflowsEnabled) {
+                logger.debug('chat.message: Workflows disabled, skipping hook');
+                return;
+            }
+            let result = null;
+            // If a tool (proceed_to_phase / start_development) buffered instructions,
+            // use those — they are authoritative and avoid potential staleness from
+            // re-querying WhatsNextHandler.
+            if (bufferedInstructions) {
+                logger.debug('chat.message: Using buffered instructions from tool call', { phase: bufferedInstructions.phase });
+                result = {
+                    phase: bufferedInstructions.phase,
+                    instructions: bufferedInstructions.instructions,
+                    plan_file_path: bufferedInstructions.planFilePath,
+                    allowed_file_patterns: bufferedInstructions.allowedFilePatterns,
+                };
+                // Consume the buffer — next call will fall through to WhatsNextHandler
+                bufferedInstructions = null;
+            }
+            else {
+                // No buffered instructions — query WhatsNextHandler (reads from disk)
+                try {
+                    const serverContext = await getServerContext();
+                    const handler = new WhatsNextHandler();
+                    const handlerResult = await handler.handle({}, serverContext);
+                    if (!handlerResult.success || !handlerResult.data) {
+                        logger.info('chat.message: No active workflow, injecting start prompt');
+                        output.parts.push({
+                            id: `prt_workflows_${Date.now()}`,
+                            sessionID: hookInput.sessionID,
+                            messageID: hookInput.messageID || output.message.id,
+                            type: 'text',
+                            text: `No Active Workflow Use the \`start_development\` tool to begin.`,
+                        });
+                        return;
+                    }
+                    result = handlerResult.data;
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    if (errorMessage.includes('CONVERSATION_NOT_FOUND')) {
+                        logger.info('chat.message: No active workflow, injecting start prompt');
+                        output.parts.push({
+                            id: `prt_workflows_${Date.now()}`,
+                            sessionID: hookInput.sessionID,
+                            messageID: hookInput.messageID || output.message.id,
+                            type: 'text',
+                            text: `No Active Workflow Use the \`start_development\` tool to begin.`,
+                        });
+                        return;
+                    }
+                    logger.error('chat.message: Error delegating to WhatsNextHandler', {
+                        error: errorMessage,
+                    });
+                    return;
+                }
+            }
+            logger.info('chat.message hook fired', {
+                sessionID: hookInput.sessionID,
+                phase: result.phase,
+            });
+            // Strip whats_next() references — plugin auto-injects instructions
+            const instructionText = stripWhatsNextReferences(result.instructions);
+            if (!instructionText.trim()) {
+                logger.info('chat.message: No instructions to inject');
+                return;
+            }
+            output.parts.push({
+                id: `prt_workflows_${Date.now()}`,
+                sessionID: hookInput.sessionID,
+                messageID: hookInput.messageID || output.message.id,
+                type: 'text',
+                text: instructionText,
+            });
+            logger.info('chat.message: injected phase instructions', {
+                phase: result.phase,
+                length: instructionText.length,
+                preview: instructionText.slice(0, 300),
+            });
+        },
+        /**
+         * Hook 2: tool.execute.before
+         * Fires before each tool execution. We block disallowed file edits based on phase.
+         */
+        'tool.execute.before': async (hookInput, output) => {
+            // Skip if workflows are disabled
+            if (!workflowsEnabled) {
+                logger.debug('tool.execute.before: Workflows disabled, skipping hook');
+                return;
+            }
+            const editTools = ['edit', 'write', 'patch', 'apply_patch', 'multiedit'];
+            if (!editTools.includes(hookInput.tool)) {
+                return;
+            }
+            // Read current workflow state from ConversationManager
+            const state = await getWorkflowState();
+            if (!state) {
+                // No active workflow — allow all edits
+                return;
+            }
+            logger.debug('tool.execute.before', {
+                tool: hookInput.tool,
+                phase: state.phase,
+            });
+            // Extract file path from tool args
+            const args = output.args;
+            const filePath = String(args?.filePath || args?.path || '');
+            if (!filePath) {
+                logger.warn('Edit tool called without filePath', {
+                    tool: hookInput.tool,
+                });
+                return;
+            }
+            if (!isFileAllowed(filePath, state.allowedFilePatterns)) {
+                const allowedList = state.allowedFilePatterns
+                    .map(p => `  • ${p}`)
+                    .join('\n');
+                const error = `BLOCKED: Cannot edit "${filePath}" in ${state.phase} phase.
+
+Current phase "${state.phase}" only allows editing:
+${allowedList}
+
+ACTION REQUIRED: Use transition_phase tool to move to a phase that allows editing this file type, OR focus on files matching the allowed patterns above.`;
+                logger.error('BLOCKING edit', {
+                    filePath,
+                    phase: state.phase,
+                    allowedPatterns: state.allowedFilePatterns,
+                });
+                throw new Error(error);
+            }
+        },
+        /**
+         * Hook 3: experimental.session.compacting
+         * Fires when session is being compacted. We provide minimal guidance on what
+         * to preserve and instruct the summary to end with phase continuation.
+         */
+        'experimental.session.compacting': async (hookInput, output) => {
+            // Skip if workflows are disabled
+            if (!workflowsEnabled) {
+                logger.debug('experimental.session.compacting: Workflows disabled, skipping hook');
+                return;
+            }
+            logger.debug('experimental.session.compacting hook fired', {
+                sessionID: hookInput.sessionID,
+            });
+            const state = await getWorkflowState();
+            if (!state) {
+                logger.debug('No active workflow - skipping compaction guidance');
+                return;
+            }
+            output.context.push('Preserve: user intents, key decisions, significant changes and the reasoning why they were made. Remove tool calls, intermediate thoughts, and minor details.');
+            output.context.push(`End summary with: "Continue ${state.phase} phase. ${state.phaseDescription || ''}"`);
+            logger.info('Injected compaction guidance', { phase: state.phase });
+        },
+        /**
+         * Hook 4: command.execute.before
+         * Intercept /workflow and /wf commands to toggle workflows enabled state
+         */
+        'command.execute.before': async (hookInput, output) => {
+            const cmd = hookInput.command.toLowerCase();
+            const args = (hookInput.arguments || '').toLowerCase().trim();
+            if (cmd === 'workflow' || cmd === 'wf') {
+                if (args === 'on') {
+                    workflowsEnabled = true;
+                    output.parts.push({
+                        id: `prt_workflows_toggle_${Date.now()}`,
+                        type: 'text',
+                        text: 'Workflows enabled for this session.',
+                    });
+                    logger.info('Workflows toggled via command', { workflowsEnabled });
+                }
+                else if (args === 'off') {
+                    workflowsEnabled = false;
+                    output.parts.push({
+                        id: `prt_workflows_toggle_${Date.now()}`,
+                        type: 'text',
+                        text: 'Workflows disabled for this session. Plugin will not inject instructions or enforce file restrictions.',
+                    });
+                    logger.info('Workflows toggled via command', { workflowsEnabled });
+                }
+                else {
+                    output.parts.push({
+                        id: `prt_workflows_toggle_${Date.now()}`,
+                        type: 'text',
+                        text: `Usage: /workflow on|off or /wf on|off\nCurrent state: ${workflowsEnabled ? 'enabled' : 'disabled'}`,
+                    });
+                }
+            }
+        },
+        /**
+         * Custom tools - matching MCP server tool names for consistency
+         */
+        tool: {
+            /**
+             * Tool: start_development
+             * Starts a new development workflow in the current project
+             */
+            start_development: createStartDevelopmentTool(input.directory, getServerContext, setBufferedInstructions),
+            /**
+             * Tool: proceed_to_phase
+             * Transitions to a new workflow phase
+             */
+            proceed_to_phase: createProceedToPhaseTool(getServerContext, setBufferedInstructions),
+            /**
+             * Tool: conduct_review
+             * Conducts a review before phase transition
+             */
+            conduct_review: createConductReviewTool(getServerContext),
+            /**
+             * Tool: reset_development
+             * Resets the current workflow and starts fresh
+             */
+            reset_development: createResetDevelopmentTool(input.directory, getServerContext),
+            /**
+             * Tool: setup_project_docs
+             * Creates project documentation artifacts
+             */
+            setup_project_docs: await createSetupProjectDocsTool(input.directory, getServerContext),
+        },
+    };
+};
+// Default export for opencode plugin loader
+export default {
+    id: 'workflows',
+    server: WorkflowsPlugin,
+};
+//# sourceMappingURL=plugin.js.map