motia 0.8.2-beta.140-428722 → 0.8.3-beta.140

package/dist/cjs/cloud/build/builders/archiver.d.ts

@@ -9,6 +9,7 @@ export declare class Archiver {
     private uncompressedSize;
     constructor(filePath: string);
     appendDirectory(sourcePath: string, targetPath: string): void;
-    append(stream: fs.ReadStream | string, filePath: string): void;
+    private calculateDirectorySize;
+    append(stream: fs.ReadStream | string | Buffer, filePath: string): void;
     finalize(): Promise<ArchiveResult>;
 }

package/dist/cjs/cloud/build/builders/archiver.js

@@ -16,39 +16,50 @@ class Archiver {
     }
     appendDirectory(sourcePath, targetPath) {
         try {
-            const items = fs_1.default.readdirSync(sourcePath);
+            const stat = fs_1.default.statSync(sourcePath);
+            if (!stat.isDirectory()) {
+                return;
+            }
+            this.uncompressedSize += this.calculateDirectorySize(sourcePath);
+            this.archive.directory(sourcePath, targetPath === '/' ? false : targetPath);
+        }
+        catch (_error) { }
+    }
+    calculateDirectorySize(dirPath) {
+        let totalSize = 0;
+        try {
+            const items = fs_1.default.readdirSync(dirPath);
             for (const item of items) {
-                const fullPath = path_1.default.join(sourcePath, item);
+                const fullPath = path_1.default.join(dirPath, item);
                 try {
                     const stat = fs_1.default.statSync(fullPath);
                     if (stat.isDirectory()) {
-                        this.appendDirectory(fullPath, path_1.default.join(targetPath, item));
+                        totalSize += this.calculateDirectorySize(fullPath);
                     }
                     else {
-                        this.append(fs_1.default.createReadStream(fullPath), targetPath ? path_1.default.join(targetPath, item) : item);
+                        totalSize += stat.size;
                     }
                 }
-                catch (_error) {
-                    // Ignore individual file errors
-                }
+                catch (_error) { }
             }
         }
-        catch (_error) {
-            // Ignore directory read errors
-        }
+        catch (_error) { }
+        return totalSize;
     }
     append(stream, filePath) {
-        // Track uncompressed size
         if (typeof stream === 'string') {
-            // String content
             this.uncompressedSize += Buffer.byteLength(stream, 'utf8');
+            this.archive.append(stream, { name: filePath });
+        }
+        else if (Buffer.isBuffer(stream)) {
+            this.uncompressedSize += stream.length;
+            this.archive.append(stream, { name: filePath });
         }
         else {
-            // ReadStream - get file stats
             const stats = fs_1.default.statSync(stream.path);
             this.uncompressedSize += stats.size;
+            this.archive.append(stream, { name: filePath });
         }
-        this.archive.append(stream, { name: filePath });
     }
     async finalize() {
         return new Promise((resolve, reject) => {

package/dist/cjs/cloud/build/builders/include-static-files.js

@@ -18,7 +18,8 @@ const includeStaticFiles = (steps, builder, archive) => {
                 const matches = (0, glob_1.globSync)(file, { cwd: path_1.default.dirname(step.filePath), absolute: true });
                 matches.forEach((filePath) => {
                     const relativeFilePath = path_1.default.relative(builder.projectDir, filePath);
-                    archive.append(fs_1.default.createReadStream(filePath), relativeFilePath);
+                    const content = fs_1.default.readFileSync(filePath);
+                    archive.append(content, relativeFilePath);
                 });
             });
         }

package/dist/cjs/cloud/build/builders/node/index.js

@@ -94,8 +94,8 @@ class NodeBuilder {
         const archiver = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
         const routerJs = path_1.default.join(constants_1.distDir, 'router.js');
         const routerMap = path_1.default.join(constants_1.distDir, 'router.js.map');
-        archiver.append(fs_1.default.createReadStream(routerJs), 'router.js');
-        archiver.append(fs_1.default.createReadStream(routerMap), 'router.js.map');
+        archiver.append(fs_1.default.readFileSync(routerJs), 'router.js');
+        archiver.append(fs_1.default.readFileSync(routerMap), 'router.js.map');
         (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archiver);
         const { compressedSize, uncompressedSize } = await archiver.finalize();
         fs_1.default.unlinkSync(tsRouter);
@@ -123,8 +123,8 @@ class NodeBuilder {
             };
             await esbuild.build(userConfig ? { ...defaultConfig, ...userConfig } : defaultConfig);
             const archiver = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, bundlePath));
-            archiver.append(fs_1.default.createReadStream(outputJsFile), entrypointPath);
-            archiver.append(fs_1.default.createReadStream(outputMapFile), entrypointMapPath);
+            archiver.append(fs_1.default.readFileSync(outputJsFile), entrypointPath);
+            archiver.append(fs_1.default.readFileSync(outputMapFile), entrypointMapPath);
             (0, include_static_files_1.includeStaticFiles)([step], this.builder, archiver);
             const { compressedSize, uncompressedSize } = await archiver.finalize();
             fs_1.default.unlinkSync(outputJsFile);

package/dist/cjs/cloud/build/builders/python/index.js

@@ -123,7 +123,7 @@ class PythonBuilder {
     }
     getModuleName(step) {
         // return step path
-        return step.filePath.replace(this.builder.projectDir, '').substring(1).replace(/\.py$/, '').replace(/\//g, '.');
+        return step.filePath.replace(this.builder.projectDir, '').substring(1).replace(/\.py$/, '').replace(/[\\/]/g, '.');
     }
 }
 exports.PythonBuilder = PythonBuilder;

package/dist/cjs/create/index.js

@@ -8,7 +8,9 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const generate_types_1 = require("../generate-types");
 const install_1 = require("../install");
+const plugin_dependencies_1 = require("../plugins/plugin-dependencies");
 const execute_command_1 = require("../utils/execute-command");
+const get_package_manager_1 = require("../utils/get-package-manager");
 const version_1 = require("../version");
 const pull_rules_1 = require("./pull-rules");
 const setup_template_1 = require("./setup-template");
@@ -17,20 +19,6 @@ require('ts-node').register({
     transpileOnly: true,
     compilerOptions: { module: 'commonjs' },
 });
-const getPackageManager = (dir) => {
-    if ((0, utils_1.checkIfFileExists)(dir, 'yarn.lock')) {
-        return 'yarn';
-    }
-    else if ((0, utils_1.checkIfFileExists)(dir, 'pnpm-lock.yaml')) {
-        return 'pnpm';
-    }
-    else if ((0, utils_1.checkIfFileExists)(dir, 'package-lock.json')) {
-        return 'npm';
-    }
-    else {
-        return 'unknown';
-    }
-};
 const installRequiredDependencies = async (packageManager, rootDir, context) => {
     context.log('installing-dependencies', (message) => message.tag('info').append('Installing dependencies...'));
     const installCommand = {
@@ -47,11 +35,7 @@ const installRequiredDependencies = async (packageManager, rootDir, context) =>
         '@types/jest@^29.5.14',
         'jest@^29.7.0',
         'ts-jest@^29.2.5',
-        `@motiadev/core@${version_1.version}`,
-        `@motiadev/plugin-logs@${version_1.version}`,
-        `@motiadev/plugin-states@${version_1.version}`,
-        `@motiadev/plugin-endpoint@${version_1.version}`,
-        `@motiadev/plugin-observability@${version_1.version}`,
+        ...plugin_dependencies_1.pluginDependencies.map((dep) => `${dep}@${version_1.version}`),
     ].join(' ');
     try {
         await (0, execute_command_1.executeCommand)(`${installCommand} ${dependencies}`, rootDir);
@@ -64,7 +48,7 @@ const installRequiredDependencies = async (packageManager, rootDir, context) =>
 };
 const preparePackageManager = async (rootDir, context) => {
     let packageManager = 'npm';
-    const detectedPackageManager = getPackageManager(rootDir);
+    const detectedPackageManager = (0, get_package_manager_1.getPackageManager)(rootDir);
     if (detectedPackageManager !== 'unknown') {
         context.log('package-manager-detected', (message) => message.tag('info').append('Detected package manager').append(detectedPackageManager, 'gray'));
         packageManager = detectedPackageManager;
@@ -82,9 +66,14 @@ const installNodeDependencies = async (rootDir, context) => {
     });
     return packageManager;
 };
-const wrapUp = async (context, packageManager) => {
+const wrapUp = async (context, packageManager, isPlugin = false) => {
     context.log('project-setup-completed', (message) => message.tag('success').append('Project setup completed, happy coding!'));
-    context.log('package-manager-used', (message) => message.tag('info').append('To start the development server, run').append(`${packageManager} run dev`, 'gray'));
+    if (isPlugin) {
+        context.log('package-manager-used', (message) => message.tag('info').append('To build the plugin, run').append(`${packageManager} run build`, 'gray'));
+    }
+    else {
+        context.log('package-manager-used', (message) => message.tag('info').append('To start the development server, run').append(`${packageManager} run dev`, 'gray'));
+    }
 };
 const create = async ({ projectName, template, cursorEnabled, context }) => {
     console.log('\n\n' +
@@ -100,6 +89,7 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         '\n\n');
     const isCurrentDir = projectName === '.' || projectName === './' || projectName === '.\\';
     const rootDir = isCurrentDir ? process.cwd() : path_1.default.join(process.cwd(), projectName);
+    const isPluginTemplate = template === 'plugin';
     if (!isCurrentDir && !(0, utils_1.checkIfDirectoryExists)(rootDir)) {
         fs_1.default.mkdirSync(path_1.default.join(rootDir));
         context.log('directory-created', (message) => message.tag('success').append('Directory created ').append(projectName, 'gray'));
@@ -107,7 +97,8 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
     else {
         context.log('directory-using', (message) => message.tag('info').append('Using current directory'));
     }
-    if (!(0, utils_1.checkIfFileExists)(rootDir, 'package.json')) {
+    // Plugin template handles package.json differently (via template)
+    if (!isPluginTemplate && !(0, utils_1.checkIfFileExists)(rootDir, 'package.json')) {
         const finalProjectName = !projectName || projectName === '.' || projectName === './' || projectName === '.\\'
             ? path_1.default.basename(process.cwd())
             : projectName.trim();
@@ -127,7 +118,7 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         fs_1.default.writeFileSync(path_1.default.join(rootDir, 'package.json'), JSON.stringify(packageJsonContent, null, 2));
         context.log('package-json-created', (message) => message.tag('success').append('File').append('package.json', 'cyan').append('has been created.'));
     }
-    else {
+    else if (!isPluginTemplate) {
         const packageJsonPath = path_1.default.join(rootDir, 'package.json');
         const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
         if (!packageJson.scripts) {
@@ -149,7 +140,8 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
             .append('command to')
             .append('package.json', 'gray'));
     }
-    if (!(0, utils_1.checkIfFileExists)(rootDir, 'tsconfig.json')) {
+    // Plugin template handles tsconfig.json via template
+    if (!isPluginTemplate && !(0, utils_1.checkIfFileExists)(rootDir, 'tsconfig.json')) {
         const tsconfigContent = {
             compilerOptions: {
                 target: 'ES2020',
@@ -172,7 +164,8 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         fs_1.default.writeFileSync(path_1.default.join(rootDir, 'tsconfig.json'), JSON.stringify(tsconfigContent, null, 2));
         context.log('tsconfig-json-created', (message) => message.tag('success').append('File').append('tsconfig.json', 'cyan').append('has been created.'));
     }
-    if (!(0, utils_1.checkIfFileExists)(rootDir, '.gitignore')) {
+    // Plugin template handles .gitignore via template
+    if (!isPluginTemplate && !(0, utils_1.checkIfFileExists)(rootDir, '.gitignore')) {
         const gitignoreContent = [
             'node_modules',
             'python_modules',
@@ -186,18 +179,26 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         fs_1.default.writeFileSync(path_1.default.join(rootDir, '.gitignore'), gitignoreContent);
         context.log('gitignore-created', (message) => message.tag('success').append('File').append('.gitignore', 'cyan').append('has been created.'));
     }
-    if (cursorEnabled) {
+    // Skip cursor rules for plugin template
+    if (!isPluginTemplate && cursorEnabled) {
         await (0, pull_rules_1.pullRules)({ force: true, rootDir }, context);
     }
     if (template) {
         await (0, setup_template_1.setupTemplate)(template, rootDir, context);
     }
-    const packageManager = await installNodeDependencies(rootDir, context);
-    if (template === 'python') {
-        await (0, install_1.pythonInstall)({ baseDir: rootDir });
+    let packageManager;
+    if (!isPluginTemplate) {
+        packageManager = await installNodeDependencies(rootDir, context);
+        if (template === 'python') {
+            await (0, install_1.pythonInstall)({ baseDir: rootDir });
+        }
+        await (0, generate_types_1.generateTypes)(rootDir);
+    }
+    else {
+        // For plugin template, just detect the package manager
+        packageManager = await preparePackageManager(rootDir, context);
     }
-    await (0, generate_types_1.generateTypes)(rootDir);
-    await wrapUp(context, packageManager);
+    await wrapUp(context, packageManager, isPluginTemplate);
     return;
 };
 exports.create = create;

package/dist/cjs/create/interactive.js

@@ -10,6 +10,7 @@ const index_1 = require("./index");
 const choices = {
     nodejs: 'Base (TypeScript)',
     python: 'Base (Python)',
+    plugin: 'Plugin (TypeScript)',
 };
 const createInteractive = async (args, context) => {
     context.log('welcome', (message) => message.append('\n🚀 ' + colors_1.default.bold('Welcome to Motia Project Creator!')));

package/dist/cjs/create/templates/generate.d.ts

@@ -1,3 +1,4 @@
 import type { CliContext } from '../../cloud/config-utils';
 export type Generator = (rootDir: string, context: CliContext) => Promise<void>;
 export declare const generateTemplateSteps: (templateFolder: string) => Generator;
+export declare const generatePluginTemplate: (templateFolder: string) => Generator;

package/dist/cjs/create/templates/generate.js

@@ -33,10 +33,28 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTemplateSteps = void 0;
+exports.generatePluginTemplate = exports.generateTemplateSteps = void 0;
 const fs_1 = require("fs");
 const glob_1 = require("glob");
 const path = __importStar(require("path"));
+const replaceTemplateVariables = (content, projectName) => {
+    const replacements = {
+        '{{PROJECT_NAME}}': projectName,
+        '{{PLUGIN_NAME}}': toPascalCase(projectName),
+        '{{CSS_FILE_NAME}}': projectName.replace(/^@[^/]+\//, ''),
+    };
+    return Object.entries(replacements).reduce((result, [key, value]) => {
+        return result.replace(new RegExp(key, 'g'), value);
+    }, content);
+};
+const toPascalCase = (str) => {
+    // Remove @ and scope if present
+    const name = str.replace(/^@[^/]+\//, '');
+    return name
+        .split(/[-_]/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+};
 const generateTemplateSteps = (templateFolder) => {
     return async (rootDir, context) => {
         const templatePath = path.join(__dirname, templateFolder);
@@ -46,13 +64,7 @@ const generateTemplateSteps = (templateFolder) => {
                 const filePath = path.join(templatePath, fileName);
                 const targetFilePath = path.join(rootDir, fileName);
                 const targetDir = path.dirname(targetFilePath);
-                try {
-                    // Check if it's a directory in the template
-                    (0, fs_1.statSync)(targetDir);
-                }
-                catch {
-                    (0, fs_1.mkdirSync)(targetDir, { recursive: true });
-                }
+                (0, fs_1.mkdirSync)(targetDir, { recursive: true });
                 if ((0, fs_1.statSync)(filePath).isDirectory()) {
                     const folderPath = filePath.replace(templatePath, '');
                     (0, fs_1.mkdirSync)(path.join(rootDir, folderPath), { recursive: true });
@@ -62,19 +74,37 @@ const generateTemplateSteps = (templateFolder) => {
                 const isWorkbenchConfig = fileName.match('motia-workbench.json');
                 const generateFilePath = path.join(rootDir, sanitizedFileName);
                 let content = await fs_1.promises.readFile(filePath, 'utf8');
-                // Make sure statSync doesn't break the execution if the file doesn't exist
-                try {
-                    if (isWorkbenchConfig && (0, fs_1.statSync)(generateFilePath).isFile()) {
-                        const existingWorkbenchConfig = await fs_1.promises.readFile(generateFilePath, 'utf8');
-                        const workbenchContent = JSON.parse(content);
-                        content = JSON.stringify([...JSON.parse(existingWorkbenchConfig), ...workbenchContent], null, 2);
-                        context.log('workbench-config-updated', (message) => message.tag('success').append('Workbench config').append('has been updated.'));
+                if (isWorkbenchConfig) {
+                    try {
+                        // Use file descriptor to avoid TOCTOU vulnerability
+                        let fd = null;
+                        try {
+                            // Try to open existing file for reading
+                            fd = await fs_1.promises.open(generateFilePath, fs_1.constants.O_RDONLY);
+                            const existingWorkbenchConfig = await fd.readFile('utf8');
+                            const workbenchContent = JSON.parse(content);
+                            content = JSON.stringify([...JSON.parse(existingWorkbenchConfig), ...workbenchContent], null, 2);
+                            context.log('workbench-config-updated', (message) => message.tag('success').append('Workbench config').append('has been updated.'));
+                        }
+                        finally {
+                            if (fd)
+                                await fd.close();
+                        }
+                    }
+                    catch {
+                        void 0;
                     }
                 }
-                catch {
-                    void 0;
+                // Use file descriptor for atomic write operation
+                let fd = null;
+                try {
+                    fd = await fs_1.promises.open(generateFilePath, fs_1.constants.O_CREAT | fs_1.constants.O_WRONLY | fs_1.constants.O_TRUNC, 0o644);
+                    await fd.writeFile(content, 'utf8');
+                }
+                finally {
+                    if (fd)
+                        await fd.close();
                 }
-                await fs_1.promises.writeFile(generateFilePath, content, 'utf8');
                 context.log(sanitizedFileName, (message) => {
                     message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.');
                 });
@@ -86,3 +116,44 @@ const generateTemplateSteps = (templateFolder) => {
     };
 };
 exports.generateTemplateSteps = generateTemplateSteps;
+const generatePluginTemplate = (templateFolder) => {
+    return async (rootDir, context) => {
+        const templatePath = path.join(__dirname, templateFolder);
+        const files = (0, glob_1.globSync)('**/*', { absolute: false, cwd: templatePath, dot: true });
+        const projectName = path.basename(rootDir);
+        try {
+            for (const fileName of files) {
+                const filePath = path.join(templatePath, fileName);
+                const targetFilePath = path.join(rootDir, fileName);
+                const targetDir = path.dirname(targetFilePath);
+                (0, fs_1.mkdirSync)(targetDir, { recursive: true });
+                if ((0, fs_1.statSync)(filePath).isDirectory()) {
+                    const folderPath = filePath.replace(templatePath, '');
+                    (0, fs_1.mkdirSync)(path.join(rootDir, folderPath), { recursive: true });
+                    continue;
+                }
+                const sanitizedFileName = fileName.replace('.txt', '');
+                const generateFilePath = path.join(rootDir, sanitizedFileName);
+                let content = await fs_1.promises.readFile(filePath, 'utf8');
+                content = replaceTemplateVariables(content, projectName);
+                // Use file descriptor for atomic write operation
+                let fd = null;
+                try {
+                    fd = await fs_1.promises.open(generateFilePath, fs_1.constants.O_CREAT | fs_1.constants.O_WRONLY | fs_1.constants.O_TRUNC, 0o644);
+                    await fd.writeFile(content, 'utf8');
+                }
+                finally {
+                    if (fd)
+                        await fd.close();
+                }
+                context.log(sanitizedFileName, (message) => {
+                    message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.');
+                });
+            }
+        }
+        catch (error) {
+            console.error('Error generating template files:', error);
+        }
+    };
+};
+exports.generatePluginTemplate = generatePluginTemplate;

package/dist/cjs/create/templates/generate.ts

@@ -1,10 +1,31 @@
-import { promises as fs, mkdirSync, statSync } from 'fs'
+import { constants, promises as fs, mkdirSync, statSync } from 'fs'
 import { globSync } from 'glob'
 import * as path from 'path'
 import type { CliContext } from '../../cloud/config-utils'
 
 export type Generator = (rootDir: string, context: CliContext) => Promise<void>
 
+const replaceTemplateVariables = (content: string, projectName: string): string => {
+  const replacements: Record<string, string> = {
+    '{{PROJECT_NAME}}': projectName,
+    '{{PLUGIN_NAME}}': toPascalCase(projectName),
+    '{{CSS_FILE_NAME}}': projectName.replace(/^@[^/]+\//, ''),
+  }
+
+  return Object.entries(replacements).reduce((result, [key, value]) => {
+    return result.replace(new RegExp(key, 'g'), value)
+  }, content)
+}
+
+const toPascalCase = (str: string): string => {
+  // Remove @ and scope if present
+  const name = str.replace(/^@[^/]+\//, '')
+  return name
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('')
+}
+
 export const generateTemplateSteps = (templateFolder: string): Generator => {
   return async (rootDir: string, context: CliContext): Promise<void> => {
     const templatePath = path.join(__dirname, templateFolder)
@@ -16,12 +37,7 @@ export const generateTemplateSteps = (templateFolder: string): Generator => {
         const targetFilePath = path.join(rootDir, fileName)
         const targetDir = path.dirname(targetFilePath)
 
-        try {
-          // Check if it's a directory in the template
-          statSync(targetDir)
-        } catch {
-          mkdirSync(targetDir, { recursive: true })
-        }
+        mkdirSync(targetDir, { recursive: true })
 
         if (statSync(filePath).isDirectory()) {
           const folderPath = filePath.replace(templatePath, '')
@@ -34,23 +50,81 @@ export const generateTemplateSteps = (templateFolder: string): Generator => {
         const generateFilePath = path.join(rootDir, sanitizedFileName)
         let content = await fs.readFile(filePath, 'utf8')
 
-        // Make sure statSync doesn't break the execution if the file doesn't exist
-        try {
-          if (isWorkbenchConfig && statSync(generateFilePath).isFile()) {
-            const existingWorkbenchConfig = await fs.readFile(generateFilePath, 'utf8')
-            const workbenchContent = JSON.parse(content)
+        if (isWorkbenchConfig) {
+          try {
+            // Use file descriptor to avoid TOCTOU vulnerability
+            let fd: fs.FileHandle | null = null
+            try {
+              // Try to open existing file for reading
+              fd = await fs.open(generateFilePath, constants.O_RDONLY)
+              const existingWorkbenchConfig = await fd.readFile('utf8')
+              const workbenchContent = JSON.parse(content)
 
-            content = JSON.stringify([...JSON.parse(existingWorkbenchConfig), ...workbenchContent], null, 2)
+              content = JSON.stringify([...JSON.parse(existingWorkbenchConfig), ...workbenchContent], null, 2)
 
-            context.log('workbench-config-updated', (message) =>
-              message.tag('success').append('Workbench config').append('has been updated.'),
-            )
+              context.log('workbench-config-updated', (message) =>
+                message.tag('success').append('Workbench config').append('has been updated.'),
+              )
+            } finally {
+              if (fd) await fd.close()
+            }
+          } catch {
+            void 0
           }
-        } catch {
-          void 0
         }
 
-        await fs.writeFile(generateFilePath, content, 'utf8')
+        // Use file descriptor for atomic write operation
+        let fd: fs.FileHandle | null = null
+        try {
+          fd = await fs.open(generateFilePath, constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC, 0o644)
+          await fd.writeFile(content, 'utf8')
+        } finally {
+          if (fd) await fd.close()
+        }
+        context.log(sanitizedFileName, (message) => {
+          message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.')
+        })
+      }
+    } catch (error) {
+      console.error('Error generating template files:', error)
+    }
+  }
+}
+
+export const generatePluginTemplate = (templateFolder: string): Generator => {
+  return async (rootDir: string, context: CliContext): Promise<void> => {
+    const templatePath = path.join(__dirname, templateFolder)
+    const files = globSync('**/*', { absolute: false, cwd: templatePath, dot: true })
+    const projectName = path.basename(rootDir)
+
+    try {
+      for (const fileName of files) {
+        const filePath = path.join(templatePath, fileName)
+        const targetFilePath = path.join(rootDir, fileName)
+        const targetDir = path.dirname(targetFilePath)
+
+        mkdirSync(targetDir, { recursive: true })
+
+        if (statSync(filePath).isDirectory()) {
+          const folderPath = filePath.replace(templatePath, '')
+          mkdirSync(path.join(rootDir, folderPath), { recursive: true })
+          continue
+        }
+
+        const sanitizedFileName = fileName.replace('.txt', '')
+        const generateFilePath = path.join(rootDir, sanitizedFileName)
+        let content = await fs.readFile(filePath, 'utf8')
+
+        content = replaceTemplateVariables(content, projectName)
+
+        // Use file descriptor for atomic write operation
+        let fd: fs.FileHandle | null = null
+        try {
+          fd = await fs.open(generateFilePath, constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC, 0o644)
+          await fd.writeFile(content, 'utf8')
+        } finally {
+          if (fd) await fd.close()
+        }
         context.log(sanitizedFileName, (message) => {
           message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.')
         })

package/dist/cjs/create/templates/index.js

@@ -5,4 +5,5 @@ const generate_1 = require("./generate");
 exports.templates = {
     nodejs: (0, generate_1.generateTemplateSteps)('nodejs'),
     python: (0, generate_1.generateTemplateSteps)('python'),
+    plugin: (0, generate_1.generatePluginTemplate)('plugin'),
 };

package/dist/cjs/create/templates/index.ts

@@ -1,6 +1,7 @@
-import { type Generator, generateTemplateSteps } from './generate'
+import { type Generator, generatePluginTemplate, generateTemplateSteps } from './generate'
 
 export const templates: Record<string, Generator> = {
   nodejs: generateTemplateSteps('nodejs'),
   python: generateTemplateSteps('python'),
+  plugin: generatePluginTemplate('plugin'),
 }

package/dist/cjs/create/templates/nodejs/tutorial.tsx.txt

@@ -653,7 +653,7 @@ export const steps: TutorialStep[] = [
         <br />
         <br />
         We recommend you give our{' '}
-        <a href="https://www.motia.dev/docs/concepts" target="_blank">
+        <a href="https://www.motia.dev/docs/concepts/overview" target="_blank">
           core concepts
         </a>{' '}
         a read if you wish to learn further about Motia's fundamentals.

package/dist/cjs/create/templates/plugin/.gitignore.txt

@@ -0,0 +1,3 @@
+node_modules
+dist
+

package/dist/cjs/create/templates/plugin/README.md.txt

@@ -0,0 +1,64 @@
+# {{PROJECT_NAME}}
+
+A minimal plugin demonstrating the Motia plugin system.
+
+## Overview
+
+This plugin serves as a reference implementation showing how to create custom workbench plugins for Motia. It demonstrates:
+
+- Basic plugin structure and configuration
+- Creating custom workbench tabs
+- Using Motia's UI component library
+- Building with Vite and TypeScript
+
+## Installation
+
+```bash
+pnpm install
+```
+
+## Development
+
+```bash
+# Build the plugin
+pnpm run build
+
+# Watch mode for development
+pnpm run dev
+
+# Clean build artifacts
+pnpm run clean
+```
+
+## Usage
+
+To use this plugin in your Motia project, import it in your `motia.config.ts`:
+
+```typescript
+import examplePlugin from '{{PROJECT_NAME}}/plugin'
+
+export default {
+  plugins: [examplePlugin],
+}
+```
+
+## Structure
+
+```
+{{PROJECT_NAME}}/
+├── src/
+│   ├── components/
+│   │   └── example-page.tsx    # Main UI component
+│   ├── index.ts                # Package entry point
+│   ├── plugin.ts               # Plugin definition
+│   └── styles.css              # Tailwind styles
+├── package.json
+├── tsconfig.json
+├── vite.config.ts
+└── README.md
+```
+
+## Learn More
+
+For detailed documentation on creating plugins, see the [Motia Plugins Guide](https://motia.dev/docs/development-guide/plugins).
+