@motiadev/workbench 0.8.2-beta.140-628177 → 0.8.2-beta.140-111855

package/dist/motia-plugin/index.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = motiaPluginsPlugin;
+const generator_1 = require("./generator");
+const hmr_1 = require("./hmr");
+const resolver_1 = require("./resolver");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const validator_1 = require("./validator");
+/**
+ * Vite plugin for loading and managing Motia workbench plugins.
+ *
+ * Features:
+ * - Hot Module Replacement (HMR) support
+ * - Runtime validation with detailed error messages
+ * - Verbose logging for debugging
+ * - CSS injection for plugin styles
+ *
+ * @param plugins - Array of plugin configurations
+ * @param options - Optional loader configuration
+ * @returns Vite plugin instance
+ *
+ * @example
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [
+ *     motiaPluginsPlugin([
+ *       { packageName: '@my-org/plugin', label: 'My Plugin' }
+ *     ])
+ *   ]
+ * })
+ * ```
+ */
+function motiaPluginsPlugin(plugins) {
+    let devServer = null;
+    try {
+        const validationResult = (0, validator_1.validatePlugins)(plugins, {
+            failFast: false,
+        });
+        if (!validationResult.valid) {
+            console.error('[motia-plugins] Plugin configuration validation failed:');
+            validationResult.errors.forEach((err) => console.error(`[motia-plugins]   ${err}`));
+            throw new Error('Invalid plugin configuration. See errors above.');
+        }
+        if (validationResult.warnings.length > 0) {
+            validationResult.warnings.forEach((warning) => console.warn('[motia-plugins]', warning));
+        }
+    }
+    catch (error) {
+        console.error('[motia-plugins] Failed to validate plugins:', error);
+        throw error;
+    }
+    const alias = (0, resolver_1.createAliasConfig)(plugins);
+    console.log(`[motia-plugins] Initialized with ${plugins.length} plugin(s)`);
+    return {
+        name: 'vite-plugin-motia-plugins',
+        enforce: 'pre',
+        buildStart() {
+            console.log('[motia-plugins] Build started');
+        },
+        config: () => ({
+            resolve: {
+                alias,
+            },
+        }),
+        configureServer(server) {
+            devServer = server;
+            console.log('[motia-plugins] Dev server configured, HMR enabled');
+        },
+        resolveId(id) {
+            if (id === types_1.CONSTANTS.VIRTUAL_MODULE_ID) {
+                return types_1.CONSTANTS.RESOLVED_VIRTUAL_MODULE_ID;
+            }
+        },
+        load(id) {
+            if (id !== types_1.CONSTANTS.RESOLVED_VIRTUAL_MODULE_ID) {
+                return null;
+            }
+            console.log('[motia-plugins] Loading plugins virtual module');
+            console.log('[motia-plugins] Generating plugin code...');
+            const code = (0, generator_1.generatePluginCode)(plugins);
+            if (!(0, generator_1.isValidCode)(code)) {
+                console.error('[motia-plugins] Generated code is invalid or empty');
+                return 'export const plugins = []';
+            }
+            console.log('[motia-plugins] Plugin code generated successfully');
+            return code;
+        },
+        async transform(code, id) {
+            const normalizedId = (0, utils_1.normalizePath)(id);
+            if (!normalizedId.endsWith('/workbench/src/index.css')) {
+                return null;
+            }
+            console.log('[motia-plugins] Injecting plugin CSS imports');
+            const cssImports = (0, generator_1.generateCssImports)(plugins);
+            if (!cssImports) {
+                return null;
+            }
+            return {
+                code: `${cssImports}\n${code}`,
+                map: null,
+            };
+        },
+        handleHotUpdate(ctx) {
+            if (!devServer) {
+                return;
+            }
+            const modulesToUpdate = (0, hmr_1.handlePluginHotUpdate)(ctx, plugins);
+            if (modulesToUpdate) {
+                console.log('[motia-plugins] Hot reloaded plugins');
+                return modulesToUpdate;
+            }
+        },
+        buildEnd() {
+            console.log('[motia-plugins] Build ended');
+        },
+    };
+}

package/dist/motia-plugin/resolver.d.ts

@@ -0,0 +1,63 @@
+import type { ResolvedPackage, WorkbenchPlugin } from './types';
+/**
+ * Resolves a plugin package to its absolute path and creates an alias.
+ *
+ * @param plugin - The plugin configuration to resolve
+ * @returns Resolved package information including path and alias
+ *
+ * @example
+ * ```ts
+ * // Local plugin
+ * resolvePluginPackage({ packageName: '~/plugins/my-plugin' })
+ * // Returns: {
+ * //   packageName: '~/plugins/my-plugin',
+ * //   resolvedPath: '/Users/project/plugins/my-plugin',
+ * //   isLocal: true,
+ * //   alias: '~/plugins/my-plugin'
+ * // }
+ *
+ * // NPM package
+ * resolvePluginPackage({ packageName: '@org/plugin' })
+ * // Returns: {
+ * //   packageName: '@org/plugin',
+ * //   resolvedPath: '/Users/project/node_modules/@org/plugin',
+ * //   isLocal: false,
+ * //   alias: '@org/plugin'
+ * // }
+ * ```
+ */
+export declare function resolvePluginPackage(plugin: WorkbenchPlugin): ResolvedPackage;
+/**
+ * Resolves all plugin packages and creates a Vite alias configuration.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns Vite alias configuration object
+ *
+ * @example
+ * ```ts
+ * const plugins = [
+ *   { packageName: '~/plugins/local' },
+ *   { packageName: '@org/npm-plugin' }
+ * ]
+ * const aliases = createAliasConfig(plugins)
+ * // Returns: {
+ * //   '~/plugins/local': '/Users/project/plugins/local',
+ * //   '@org/npm-plugin': '/Users/project/node_modules/@org/npm-plugin'
+ * // }
+ * ```
+ */
+export declare function createAliasConfig(plugins: WorkbenchPlugin[]): Record<string, string>;
+/**
+ * Resolves all plugins and returns their resolved package information.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns Array of resolved package information
+ */
+export declare function resolveAllPlugins(plugins: WorkbenchPlugin[]): ResolvedPackage[];
+/**
+ * Gets the unique set of package names from plugins.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns Array of unique package names
+ */
+export declare function getUniquePackageNames(plugins: WorkbenchPlugin[]): string[];

package/dist/motia-plugin/resolver.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePluginPackage = resolvePluginPackage;
+exports.createAliasConfig = createAliasConfig;
+exports.resolveAllPlugins = resolveAllPlugins;
+exports.getUniquePackageNames = getUniquePackageNames;
+const utils_1 = require("./utils");
+/**
+ * Resolves a plugin package to its absolute path and creates an alias.
+ *
+ * @param plugin - The plugin configuration to resolve
+ * @returns Resolved package information including path and alias
+ *
+ * @example
+ * ```ts
+ * // Local plugin
+ * resolvePluginPackage({ packageName: '~/plugins/my-plugin' })
+ * // Returns: {
+ * //   packageName: '~/plugins/my-plugin',
+ * //   resolvedPath: '/Users/project/plugins/my-plugin',
+ * //   isLocal: true,
+ * //   alias: '~/plugins/my-plugin'
+ * // }
+ *
+ * // NPM package
+ * resolvePluginPackage({ packageName: '@org/plugin' })
+ * // Returns: {
+ * //   packageName: '@org/plugin',
+ * //   resolvedPath: '/Users/project/node_modules/@org/plugin',
+ * //   isLocal: false,
+ * //   alias: '@org/plugin'
+ * // }
+ * ```
+ */
+function resolvePluginPackage(plugin) {
+    const { packageName } = plugin;
+    const local = (0, utils_1.isLocalPlugin)(packageName);
+    const resolvedPath = local ? (0, utils_1.resolveLocalPath)(packageName) : (0, utils_1.resolveNpmPath)(packageName);
+    return {
+        packageName,
+        resolvedPath: (0, utils_1.normalizePath)(resolvedPath),
+        isLocal: local,
+        alias: packageName,
+    };
+}
+/**
+ * Resolves all plugin packages and creates a Vite alias configuration.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns Vite alias configuration object
+ *
+ * @example
+ * ```ts
+ * const plugins = [
+ *   { packageName: '~/plugins/local' },
+ *   { packageName: '@org/npm-plugin' }
+ * ]
+ * const aliases = createAliasConfig(plugins)
+ * // Returns: {
+ * //   '~/plugins/local': '/Users/project/plugins/local',
+ * //   '@org/npm-plugin': '/Users/project/node_modules/@org/npm-plugin'
+ * // }
+ * ```
+ */
+function createAliasConfig(plugins) {
+    // Get unique package names to avoid duplicate aliases
+    const uniquePackages = Array.from(new Set(plugins.map((p) => p.packageName)));
+    const aliases = {};
+    for (const packageName of uniquePackages) {
+        const resolved = resolvePluginPackage({ packageName });
+        aliases[packageName] = resolved.resolvedPath;
+    }
+    return aliases;
+}
+/**
+ * Resolves all plugins and returns their resolved package information.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns Array of resolved package information
+ */
+function resolveAllPlugins(plugins) {
+    return plugins.map((plugin) => resolvePluginPackage(plugin));
+}
+/**
+ * Gets the unique set of package names from plugins.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns Array of unique package names
+ */
+function getUniquePackageNames(plugins) {
+    return Array.from(new Set(plugins.map((p) => p.packageName)));
+}

package/dist/motia-plugin/types.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Configuration for a single workbench plugin.
+ * This interface defines how plugins are registered and configured in the Motia workbench.
+ */
+export interface WorkbenchPlugin {
+    /**
+     * The package name or local path to the plugin.
+     * - For npm packages: use the package name (e.g., '@my-org/my-plugin')
+     * - For local plugins: use the tilde prefix (e.g., '~/plugins/my-plugin')
+     */
+    packageName: string;
+    /**
+     * Optional named export to use from the plugin package.
+     * If not specified, the default export will be used.
+     * Can be overridden by the plugin's own config.
+     */
+    componentName?: string;
+    /**
+     * Position where the plugin tab should appear in the workbench.
+     * - 'top': Display in the top tab bar
+     * - 'bottom': Display in the bottom tab bar
+     * @default 'top'
+     */
+    position?: 'top' | 'bottom';
+    /**
+     * Display label for the plugin tab.
+     * Can be overridden by the plugin's own config.
+     */
+    label?: string;
+    /**
+     * Icon name from lucide-react to display next to the label.
+     * Can be overridden by the plugin's own config.
+     * @default 'toy-brick'
+     */
+    labelIcon?: string;
+    /**
+     * Array of CSS package imports to inject into the workbench.
+     * These will be added to the main index.css file.
+     * Example: ['@my-org/my-plugin/styles.css']
+     */
+    cssImports?: string[];
+    /**
+     * Props to pass to the plugin component when it's rendered.
+     * Can be overridden by the plugin's own config.
+     */
+    props?: Record<string, any>;
+}
+/**
+ * Result of validating a plugin configuration.
+ */
+export interface ValidationResult {
+    /**
+     * Whether the validation passed
+     */
+    valid: boolean;
+    /**
+     * Array of error messages if validation failed
+     */
+    errors: string[];
+    /**
+     * Array of warning messages for non-critical issues
+     */
+    warnings: string[];
+    /**
+     * The validated and normalized plugin configuration (if valid)
+     */
+    plugin?: WorkbenchPlugin;
+}
+/**
+ * Context object passed to various plugin internals functions.
+ * Contains shared state and configuration.
+ */
+export interface PluginContext {
+    /**
+     * Array of plugin configurations
+     */
+    plugins: WorkbenchPlugin[];
+    /**
+     * Vite dev server instance (only available in dev mode)
+     */
+    server?: any;
+}
+/**
+ * Package resolution result.
+ */
+export interface ResolvedPackage {
+    /**
+     * The original package name from the configuration
+     */
+    packageName: string;
+    /**
+     * Resolved absolute path to the package
+     */
+    resolvedPath: string;
+    /**
+     * Whether this is a local plugin (starts with ~/)
+     */
+    isLocal: boolean;
+    /**
+     * Alias to use for imports
+     */
+    alias: string;
+}
+/**
+ * Generated virtual module exports interface.
+ * This is what consumers will import from 'virtual:motia-plugins'.
+ */
+export interface VirtualModuleExports {
+    /**
+     * Array of processed plugin configurations ready to be registered
+     */
+    plugins: ProcessedPlugin[];
+}
+/**
+ * A plugin configuration after processing and normalization.
+ * This is the format used by the workbench to register tabs.
+ */
+export interface ProcessedPlugin {
+    /**
+     * Display label for the plugin tab
+     */
+    label: string;
+    /**
+     * Icon name from lucide-react
+     */
+    labelIcon: string;
+    /**
+     * Position in the workbench ('top' or 'bottom')
+     */
+    position: 'top' | 'bottom';
+    /**
+     * Props to pass to the component
+     */
+    props: Record<string, any>;
+    /**
+     * The React component to render
+     */
+    component: any;
+}
+/**
+ * Type guard to check if position is valid.
+ */
+export declare function isValidPosition(position: any): position is 'top' | 'bottom';
+/**
+ * Constants used throughout the plugin system.
+ */
+export declare const CONSTANTS: {
+    /**
+     * Virtual module ID for importing plugins
+     */
+    readonly VIRTUAL_MODULE_ID: "virtual:motia-plugins";
+    /**
+     * Resolved virtual module ID (with null byte prefix for Vite)
+     */
+    readonly RESOLVED_VIRTUAL_MODULE_ID: "\0virtual:motia-plugins";
+    /**
+     * Log prefix for all plugin messages
+     */
+    readonly LOG_PREFIX: "[motia-plugins]";
+    /**
+     * Default values for optional plugin fields
+     */
+    readonly DEFAULTS: {
+        readonly POSITION: "top";
+        readonly LABEL: "Plugin label";
+        readonly ICON: "toy-brick";
+        readonly PROPS: {};
+    };
+};

package/dist/motia-plugin/types.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONSTANTS = void 0;
+exports.isValidPosition = isValidPosition;
+/**
+ * Type guard to check if position is valid.
+ */
+function isValidPosition(position) {
+    return position === 'top' || position === 'bottom';
+}
+/**
+ * Constants used throughout the plugin system.
+ */
+exports.CONSTANTS = {
+    /**
+     * Virtual module ID for importing plugins
+     */
+    VIRTUAL_MODULE_ID: 'virtual:motia-plugins',
+    /**
+     * Resolved virtual module ID (with null byte prefix for Vite)
+     */
+    RESOLVED_VIRTUAL_MODULE_ID: '\0virtual:motia-plugins',
+    /**
+     * Log prefix for all plugin messages
+     */
+    LOG_PREFIX: '[motia-plugins]',
+    /**
+     * Default values for optional plugin fields
+     */
+    DEFAULTS: {
+        POSITION: 'top',
+        LABEL: 'Plugin label',
+        ICON: 'toy-brick',
+        PROPS: {},
+    },
+};

package/dist/motia-plugin/utils.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Normalizes a file path by replacing backslashes with forward slashes.
+ * This is useful for consistent path comparisons across different operating systems.
+ *
+ * @param filePath - The file path to normalize
+ * @returns The normalized file path with forward slashes
+ *
+ * @example
+ * ```ts
+ * normalizePath('C:\\Users\\file.ts') // Returns: 'C:/Users/file.ts'
+ * normalizePath('/Users/file.ts')     // Returns: '/Users/file.ts'
+ * ```
+ */
+export declare function normalizePath(filePath: string): string;
+/**
+ * Checks if a package name represents a local plugin (starts with ~/).
+ *
+ * @param packageName - The package name to check
+ * @returns True if the package is a local plugin
+ *
+ * @example
+ * ```ts
+ * isLocalPlugin('~/plugins/my-plugin')     // Returns: true
+ * isLocalPlugin('@my-org/my-plugin')       // Returns: false
+ * isLocalPlugin('my-plugin')               // Returns: false
+ * ```
+ */
+export declare function isLocalPlugin(packageName: string): boolean;
+/**
+ * Resolves a local plugin path to an absolute path.
+ * Strips the ~/ prefix and joins with the current working directory.
+ *
+ * @param packageName - The local plugin package name (must start with ~/)
+ * @returns The absolute path to the local plugin
+ *
+ * @example
+ * ```ts
+ * // If cwd is /Users/project
+ * resolveLocalPath('~/plugins/my-plugin')
+ * // Returns: '/Users/project/plugins/my-plugin'
+ * ```
+ */
+export declare function resolveLocalPath(packageName: string): string;
+/**
+ * Resolves an npm package path to the node_modules directory.
+ *
+ * @param packageName - The npm package name
+ * @returns The absolute path to the package in node_modules
+ *
+ * @example
+ * ```ts
+ * // If cwd is /Users/project
+ * resolveNpmPath('@my-org/my-plugin')
+ * // Returns: '/Users/project/node_modules/@my-org/my-plugin'
+ * ```
+ */
+export declare function resolveNpmPath(packageName: string): string;

package/dist/motia-plugin/utils.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = normalizePath;
+exports.isLocalPlugin = isLocalPlugin;
+exports.resolveLocalPath = resolveLocalPath;
+exports.resolveNpmPath = resolveNpmPath;
+const path_1 = __importDefault(require("path"));
+/**
+ * Normalizes a file path by replacing backslashes with forward slashes.
+ * This is useful for consistent path comparisons across different operating systems.
+ *
+ * @param filePath - The file path to normalize
+ * @returns The normalized file path with forward slashes
+ *
+ * @example
+ * ```ts
+ * normalizePath('C:\\Users\\file.ts') // Returns: 'C:/Users/file.ts'
+ * normalizePath('/Users/file.ts')     // Returns: '/Users/file.ts'
+ * ```
+ */
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+/**
+ * Checks if a package name represents a local plugin (starts with ~/).
+ *
+ * @param packageName - The package name to check
+ * @returns True if the package is a local plugin
+ *
+ * @example
+ * ```ts
+ * isLocalPlugin('~/plugins/my-plugin')     // Returns: true
+ * isLocalPlugin('@my-org/my-plugin')       // Returns: false
+ * isLocalPlugin('my-plugin')               // Returns: false
+ * ```
+ */
+function isLocalPlugin(packageName) {
+    return packageName.startsWith('~/');
+}
+/**
+ * Resolves a local plugin path to an absolute path.
+ * Strips the ~/ prefix and joins with the current working directory.
+ *
+ * @param packageName - The local plugin package name (must start with ~/)
+ * @returns The absolute path to the local plugin
+ *
+ * @example
+ * ```ts
+ * // If cwd is /Users/project
+ * resolveLocalPath('~/plugins/my-plugin')
+ * // Returns: '/Users/project/plugins/my-plugin'
+ * ```
+ */
+function resolveLocalPath(packageName) {
+    return path_1.default.join(process.cwd(), packageName.replace('~/', ''));
+}
+/**
+ * Resolves an npm package path to the node_modules directory.
+ *
+ * @param packageName - The npm package name
+ * @returns The absolute path to the package in node_modules
+ *
+ * @example
+ * ```ts
+ * // If cwd is /Users/project
+ * resolveNpmPath('@my-org/my-plugin')
+ * // Returns: '/Users/project/node_modules/@my-org/my-plugin'
+ * ```
+ */
+function resolveNpmPath(packageName) {
+    return path_1.default.join(process.cwd(), 'node_modules', packageName);
+}

package/dist/motia-plugin/validator.d.ts

@@ -0,0 +1,19 @@
+import type { ValidationResult } from './types';
+/**
+ * Validates a single plugin configuration.
+ *
+ * @param plugin - The plugin configuration to validate
+ * @param index - The index of the plugin in the array (for error messages)
+ * @returns A validation result with errors, warnings, and normalized plugin
+ */
+export declare function validatePluginConfig(plugin: any, index: number): ValidationResult;
+/**
+ * Validates an array of plugin configurations.
+ *
+ * @param plugins - Array of plugin configurations to validate
+ * @param options - Validation options
+ * @returns Combined validation result for all plugins
+ */
+export declare function validatePlugins(plugins: any[], options?: {
+    failFast?: boolean;
+}): ValidationResult;