@veap/plugins 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Damian Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,132 @@
-# Temporary Holding Version
+[![CI](https://github.com/veapjs/veap-plugins/actions/workflows/ci.yml/badge.svg)](https://github.com/veapjs/veap-plugins/actions/workflows/ci.yml)
+[![Release](https://github.com/veapjs/veap-plugins/actions/workflows/release.yml/badge.svg)](https://github.com/veapjs/veap-plugins/actions/workflows/release.yml)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @veap/plugins
+
+Plugin architecture, dynamic extension points, virtual routing, and widget
+customization for Veap applications.
+
+## Overview
+
+`@veap/plugins` provides an enterprise-grade modular plugin system. It enables
+developers to extend Veap applications dynamically with UI slots, custom
+dashboard widgets, virtual routing, navigation items, and event listeners
+without modifying core application code.
+
+## Features
+
+- **Standard plugin lifecycle**: Declarative plugin manifests defining
+  dependencies, configuration schemas (Zod), migrations, and activation hooks.
+- **Extension slots & widgets**: React extension points allowing plugins to
+  inject custom UI components into existing pages, sidebars, and headers.
+- **Drag-and-drop dashboard widgets**: Built-in support for user-customizable
+  widgets with `@dnd-kit` persistence.
+- **Virtual router**: Dynamic route interception and virtual page injection
+  via the integrated router service.
+- **Database persistence**: Storing plugin activation states and user widget
+  layouts in database tables managed by `@veap/database`.
+- **IoC integration**: `PluginServiceProvider` boots and registers plugin
+  capabilities cleanly into the application container.
+
+## Installation
+
+```bash
+# Using bun
+bun add @veap/plugins @veap/kernel @veap/database @veap/auth
+
+# Using pnpm
+pnpm add @veap/plugins @veap/kernel @veap/database @veap/auth
+
+# Using npm
+npm install @veap/plugins @veap/kernel @veap/database @veap/auth
+```
+
+## Usage
+
+### Define a Custom Plugin
+
+Create a plugin definition implementing the Veap plugin contract:
+
+```tsx
+import type { PluginDefinition } from "@veap/plugins";
+
+export const AnalyticsPlugin: PluginDefinition = {
+  id: "com.example.analytics",
+  name: "Analytics Tracker",
+  version: "1.0.0",
+  description: "Injects telemetry script and admin dashboard widgets",
+
+  widgets: [
+    {
+      id: "analytics-overview",
+      title: "Visitor Traffic",
+      component: () => (
+        <div className="p-4 border rounded">
+          <p className="text-sm font-semibold">Active Visitors: 42</p>
+        </div>
+      ),
+    },
+  ],
+
+  async onActivate(container) {
+    console.log("Analytics plugin activated!");
+  },
+};
+```
+
+### Register Plugins in Application Builder
+
+Pass plugins to `Application.configure()`:
+
+```ts
+import { Application } from "@veap/kernel";
+import { PluginServiceProvider } from "@veap/plugins";
+import { AnalyticsPlugin } from "./plugins/analytics";
+
+export const app = Application.configure()
+  .use(PluginServiceProvider)
+  .withPlugins([AnalyticsPlugin])
+  .create();
+```
+
+### Render Extension Points in React
+
+Use extension components from `@veap/plugins/client`:
+
+```tsx
+"use client";
+
+import { ExtensionSlot } from "@veap/plugins/client";
+
+export function DashboardHeader() {
+  return (
+    <header className="flex justify-between items-center p-4">
+      <h1>Admin Dashboard</h1>
+      {/* External plugins can inject actions here */}
+      <ExtensionSlot name="dashboard:header:actions" />
+    </header>
+  );
+}
+```
+
+## Subpath Exports
+
+| Export Path                | Content                                                                    |
+| -------------------------- | -------------------------------------------------------------------------- |
+| `@veap/plugins`            | Core plugin definitions, lifecycle management, and `PluginServiceProvider` |
+| `@veap/plugins/client`     | React extension slots (`ExtensionSlot`) and widget renderers               |
+| `@veap/plugins/router`     | Virtual router infrastructure and route rewriting                          |
+| `@veap/plugins/models`     | Active Record models (`PluginModel`, `UserWidgetModel`)                    |
+| `@veap/plugins/migrations` | Knex migrations for plugin persistence                                     |
+
+## Documentation
+
+For full guides and plugin development patterns, visit:
+
+- **Official Website**: [https://veap.pl](https://veap.pl)
+- **Documentation**: [https://veap.pl/docs](https://veap.pl/docs)
+- **GitHub Repository**: [https://github.com/veapjs/veap-plugins](https://github.com/veapjs/veap-plugins)
+
+## License
+
+MIT

package/dist/actions/index.d.ts

@@ -0,0 +1 @@
+export { getPluginExtensionsAction, getPluginWidgetsAction, getUserWidgetsState, saveUserWidgetsState, } from "./plugin.actions";

package/dist/actions/index.js

@@ -0,0 +1 @@
+export { getPluginExtensionsAction, getPluginWidgetsAction, getUserWidgetsState, saveUserWidgetsState, } from "./plugin.actions";

package/dist/actions/plugin.actions.d.ts

@@ -0,0 +1,6 @@
+export declare function getPluginExtensionsAction(target: string, point: string, includeDisabled?: boolean): Promise<import("..").PluginExtension[]>;
+export declare function getPluginWidgetsAction(area: string): Promise<import("..").PluginWidget[]>;
+export declare function getUserWidgetsState(slot: string): Promise<any>;
+export declare function saveUserWidgetsState(slot: string, state: any): Promise<{
+    success: boolean;
+}>;

package/dist/actions/plugin.actions.js

@@ -0,0 +1,60 @@
+"use server";
+import { getCurrentSession } from "@veap/auth";
+import { AppError } from "@veap/kernel";
+import { pluginsContext } from "../common/context";
+import { SystemUserWidget } from "../models/SystemUserWidget";
+export async function getPluginExtensionsAction(target, point, includeDisabled = false) {
+    const { user } = await getCurrentSession();
+    const userRoles = user?.roles || [];
+    const userPermissions = user?.permissions || [];
+    return pluginsContext().registry.getExtensions(target, point, includeDisabled, {
+        roles: userRoles,
+        permissions: userPermissions,
+    });
+}
+export async function getPluginWidgetsAction(area) {
+    const { user } = await getCurrentSession();
+    const userRoles = user?.roles || [];
+    const userPermissions = user?.permissions || [];
+    return pluginsContext().registry.getWidgets(area, {
+        roles: userRoles,
+        permissions: userPermissions,
+    });
+}
+export async function getUserWidgetsState(slot) {
+    const { user } = await getCurrentSession();
+    if (!user) {
+        return null;
+    }
+    const widget = await SystemUserWidget.where({
+        user_id: user.id,
+        slot: slot,
+    }).first();
+    return widget?.state ?? null;
+}
+export async function saveUserWidgetsState(slot, state) {
+    const { user } = await getCurrentSession();
+    if (!user) {
+        throw AppError.Unauthorized();
+    }
+    const existing = await SystemUserWidget.where({
+        user_id: user.id,
+        slot: slot,
+    }).first();
+    if (existing) {
+        await SystemUserWidget.where({
+            user_id: user.id,
+            slot: slot,
+        }).update({
+            state: state,
+        });
+    }
+    else {
+        await SystemUserWidget.create({
+            userId: user.id,
+            slot: slot,
+            state: state,
+        });
+    }
+    return { success: true };
+}

package/dist/actions.d.ts

@@ -0,0 +1 @@
+export * from "./actions/index";

package/dist/actions.js

@@ -0,0 +1 @@
+export * from "./actions/index";

package/dist/cli/add.d.ts

@@ -0,0 +1,4 @@
+export declare function addPlugin(pluginArg: string, options?: {
+    local?: boolean;
+    skipInstall?: boolean;
+}): Promise<void>;

package/dist/cli/add.js

@@ -0,0 +1,191 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import ora from "ora";
+import { findProjectRoot, regeneratePluginsRegistry } from "./utils.js";
+async function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => rl.question(query, (ans) => {
+        rl.close();
+        resolve(ans);
+    }));
+}
+export async function addPlugin(pluginArg, options) {
+    const rootDir = findProjectRoot(process.cwd());
+    console.log(`\n📦 Adding plugin: ${pluginArg}...`);
+    let pluginDir = "";
+    let pluginPkgJsonPath = "";
+    if (options?.local) {
+        // Local installation from Git URL or npm package
+        let gitUrl = pluginArg;
+        const isGitUrl = /^(git|http|https|github):/.test(pluginArg) || pluginArg.endsWith(".git");
+        if (!isGitUrl) {
+            const spinUrl = ora(`Fetching Git repository URL for package ${pluginArg}...`).start();
+            try {
+                const output = execSync(`npm view ${pluginArg} repository.url`, {
+                    stdio: "pipe",
+                })
+                    .toString()
+                    .trim();
+                if (output) {
+                    gitUrl = output;
+                    spinUrl.succeed(`Found repository URL: ${gitUrl}`);
+                }
+                else {
+                    spinUrl.fail(`Could not find repository URL for ${pluginArg}`);
+                    process.exit(1);
+                }
+            }
+            catch (_err) {
+                spinUrl.fail(`Failed to fetch package details for ${pluginArg}`);
+                process.exit(1);
+            }
+        }
+        // Normalize git URL
+        if (gitUrl.startsWith("git+")) {
+            gitUrl = gitUrl.slice(4);
+        }
+        if (gitUrl.startsWith("git://")) {
+            gitUrl = `https://${gitUrl.slice(6)}`;
+        }
+        const repoName = gitUrl
+            .split("/")
+            .pop()
+            ?.replace(/\.git$/, "") || "custom-plugin";
+        pluginDir = path.join(rootDir, "plugins", repoName);
+        if (fs.existsSync(pluginDir)) {
+            console.error(`Error: Local plugin already exists in ${pluginDir}`);
+            process.exit(1);
+        }
+        const spin = ora(`Cloning repository ${gitUrl} to plugins/${repoName}...`).start();
+        try {
+            execSync(`git clone ${gitUrl} "${pluginDir}"`, { stdio: "ignore" });
+            spin.succeed(`Cloned repository to plugins/${repoName}`);
+        }
+        catch (_err) {
+            spin.fail(`Failed to clone repository ${gitUrl}`);
+            process.exit(1);
+        }
+        pluginPkgJsonPath = path.join(pluginDir, "package.json");
+        if (fs.existsSync(pluginPkgJsonPath)) {
+            try {
+                const pluginPkg = JSON.parse(fs.readFileSync(pluginPkgJsonPath, "utf-8"));
+                const pluginName = pluginPkg.name || repoName;
+                // Add to root package.json as workspace dependency
+                const rootPkgPath = path.join(rootDir, "package.json");
+                if (fs.existsSync(rootPkgPath)) {
+                    const rootPkg = JSON.parse(fs.readFileSync(rootPkgPath, "utf-8"));
+                    rootPkg.dependencies = rootPkg.dependencies || {};
+                    rootPkg.dependencies[pluginName] = "workspace:*";
+                    fs.writeFileSync(rootPkgPath, `${JSON.stringify(rootPkg, null, 2)}\n`, "utf-8");
+                }
+                // Run install to link the workspace package
+                if (!options?.skipInstall) {
+                    const { detectPackageManager } = await import("./package-manager.js");
+                    const pm = detectPackageManager(rootDir);
+                    const installSpin = ora(`Linking local plugin with ${pm} install...`).start();
+                    try {
+                        execSync(`${pm} install`, { cwd: rootDir, stdio: "ignore" });
+                        installSpin.succeed("Plugin linked successfully.");
+                    }
+                    catch (_err) {
+                        installSpin.fail(`Failed to run ${pm} install automatically.`);
+                    }
+                }
+            }
+            catch (_) { }
+        }
+    }
+    else {
+        // NPM installation via package manager
+        if (!options?.skipInstall) {
+            const { detectPackageManager } = await import("./package-manager.js");
+            const pm = detectPackageManager(rootDir);
+            const installCmd = pm === "npm" ? "install" : "add";
+            const workspaceFlag = pm === "npm" ? "" : "-w";
+            const spin = ora(`Installing npm package ${pluginArg}...`).start();
+            try {
+                execSync(`${pm} ${installCmd} ${pluginArg} ${workspaceFlag}`.trim(), {
+                    cwd: rootDir,
+                    stdio: "inherit",
+                });
+                spin.succeed(`Package ${pluginArg} installed.`);
+            }
+            catch (_err) {
+                spin.fail(`Failed to install package ${pluginArg}`);
+                process.exit(1);
+            }
+        }
+        // Resolve where it is installed in node_modules
+        const projectPkgPath = path.join(rootDir, "package.json");
+        let resolvedPkgName = pluginArg;
+        if (fs.existsSync(projectPkgPath)) {
+            const projectPkg = JSON.parse(fs.readFileSync(projectPkgPath, "utf-8"));
+            const deps = {
+                ...(projectPkg.dependencies || {}),
+                ...(projectPkg.devDependencies || {}),
+            };
+            for (const [name, val] of Object.entries(deps)) {
+                if (val === pluginArg ||
+                    (typeof val === "string" && val.includes(pluginArg)) ||
+                    name === pluginArg) {
+                    resolvedPkgName = name;
+                    break;
+                }
+            }
+        }
+        pluginDir = path.join(rootDir, "node_modules", resolvedPkgName);
+        pluginPkgJsonPath = path.join(pluginDir, "package.json");
+    }
+    if (!fs.existsSync(pluginPkgJsonPath)) {
+        console.error(`Error: Cannot find package.json for plugin at ${pluginPkgJsonPath}`);
+        process.exit(1);
+    }
+    const pluginPkg = JSON.parse(fs.readFileSync(pluginPkgJsonPath, "utf-8"));
+    const VeapConfig = pluginPkg.veap || pluginPkg.veap || {};
+    // 1. Configure environment variables (.env)
+    if (VeapConfig.env) {
+        const envPath = path.join(rootDir, ".env");
+        let envContent = "";
+        if (fs.existsSync(envPath)) {
+            envContent = fs.readFileSync(envPath, "utf-8");
+        }
+        console.log(`\n ⚙️  Configuring environment variables for ${pluginPkg.name || pluginArg}:`);
+        // biome-ignore lint/suspicious/noExplicitAny: <ignore>
+        for (const [varName, varConfig] of Object.entries(VeapConfig.env)) {
+            const regex = new RegExp(`^${varName}=`, "m");
+            if (regex.test(envContent)) {
+                console.log(`  - ${varName} is already configured in .env`);
+                continue;
+            }
+            const desc = varConfig.description || "No description provided";
+            const reqStr = varConfig.required ? " (required)" : " (optional)";
+            let value = "";
+            while (true) {
+                value = await askQuestion(`? Enter value for ${varName} - ${desc}${reqStr}: `);
+                if (varConfig.required && !value.trim()) {
+                    console.log(`  Error: ${varName} is required.`);
+                    continue;
+                }
+                break;
+            }
+            envContent += `\n# Added by Veap CLI for ${pluginPkg.name}\n${varName}="${value}"\n`;
+        }
+        fs.writeFileSync(envPath, envContent, "utf-8");
+        console.log(`✅ Environment variables saved to .env`);
+    }
+    // 2. Install dependencies recursively
+    if (VeapConfig.dependencies && Array.isArray(VeapConfig.dependencies)) {
+        console.log(`\n📦 Installing dependencies for ${pluginPkg.name || pluginArg}...`);
+        for (const dep of VeapConfig.dependencies) {
+            await addPlugin(dep, options);
+        }
+    }
+    // 3. Regenerate plugins.gen.ts
+    regeneratePluginsRegistry(rootDir);
+    console.log(`\n✨ Plugin "${pluginPkg.name || pluginArg}" is ready!`);
+}

package/dist/cli/eject.d.ts

@@ -0,0 +1,2 @@
+export declare function ejectPackage(packageName: string): Promise<void>;
+export declare const ejectPlugin: typeof ejectPackage;

package/dist/cli/eject.js

@@ -0,0 +1,136 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import ora from "ora";
+import { findProjectRoot, regeneratePluginsRegistry } from "./utils.js";
+function normalizeGitUrl(url) {
+    if (url.startsWith("git+")) {
+        url = url.slice(4);
+    }
+    if (url.startsWith("git://")) {
+        url = `https://${url.slice(6)}`;
+    }
+    return url;
+}
+export async function ejectPackage(packageName) {
+    const rootDir = findProjectRoot(process.cwd());
+    // Check if root package.json has it
+    const rootPkgPath = path.join(rootDir, "package.json");
+    if (!fs.existsSync(rootPkgPath)) {
+        console.error("Error: Cannot find root package.json.");
+        process.exit(1);
+        return;
+    }
+    const rootPkg = JSON.parse(fs.readFileSync(rootPkgPath, "utf-8"));
+    const deps = {
+        ...(rootPkg.dependencies || {}),
+        ...(rootPkg.devDependencies || {}),
+    };
+    if (!deps[packageName]) {
+        console.error(`Error: Package "${packageName}" is not installed in dependencies.`);
+        process.exit(1);
+        return;
+        return;
+    }
+    // Find installed folder in node_modules
+    const nodeModulesDir = path.join(rootDir, "node_modules", packageName);
+    const pkgJsonPath = path.join(nodeModulesDir, "package.json");
+    if (!fs.existsSync(pkgJsonPath)) {
+        console.error(`Error: Cannot find package.json for installed package at ${pkgJsonPath}`);
+        process.exit(1);
+        return;
+        return;
+    }
+    const installedPkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+    const isTemplate = installedPkg.veap?.type === "template" ||
+        packageName.endsWith("-template") ||
+        packageName.includes("template");
+    const itemType = isTemplate ? "template" : "plugin";
+    const targetSubdir = isTemplate ? "templates" : "plugins";
+    console.log(`\n🚀 Ejecting ${itemType}: ${packageName}...`);
+    const repo = installedPkg.repository;
+    let gitUrl = "";
+    if (typeof repo === "string") {
+        gitUrl = repo;
+    }
+    else if (repo && typeof repo === "object") {
+        gitUrl = repo.url || "";
+    }
+    if (!gitUrl) {
+        // If not found in package.json, try querying registry
+        const spinUrl = ora(`Querying registry for Git repository of ${packageName}...`).start();
+        try {
+            const output = execSync(`npm view ${packageName} repository.url`, {
+                stdio: "pipe",
+            })
+                .toString()
+                .trim();
+            if (output) {
+                gitUrl = output;
+                spinUrl.succeed(`Found repository URL: ${gitUrl}`);
+            }
+            else {
+                spinUrl.fail();
+                console.error(`Error: Package package.json does not specify repository URL, and registry query returned nothing.`);
+                process.exit(1);
+            }
+        }
+        catch (_err) {
+            spinUrl.fail();
+            console.error(`Error: Could not retrieve repository URL from package or registry.`);
+            process.exit(1);
+        }
+    }
+    const normalizedUrl = normalizeGitUrl(gitUrl);
+    const folderName = packageName.replace(/^@.*\//, "");
+    const destDir = path.join(rootDir, targetSubdir, folderName);
+    if (fs.existsSync(destDir)) {
+        console.error(`Error: Local ${itemType} directory already exists at ${destDir}`);
+        process.exit(1);
+        return;
+        return;
+    }
+    // Ensure target parent directory exists (e.g. templates/ or plugins/)
+    const targetBaseDir = path.join(rootDir, targetSubdir);
+    if (!fs.existsSync(targetBaseDir)) {
+        fs.mkdirSync(targetBaseDir, { recursive: true });
+    }
+    const cloneSpin = ora(`Cloning repository ${normalizedUrl} to ${targetSubdir}/${folderName}...`).start();
+    try {
+        execSync(`git clone ${normalizedUrl} "${destDir}"`, { stdio: "ignore" });
+        cloneSpin.succeed(`Cloned repository to ${targetSubdir}/${folderName}`);
+    }
+    catch (_err) {
+        cloneSpin.fail(`Failed to clone repository ${normalizedUrl}`);
+        process.exit(1);
+    }
+    // Ensure workspace pattern exists in root package.json if workspaces array is defined
+    if (Array.isArray(rootPkg.workspaces)) {
+        const workspacePattern = `${targetSubdir}/*`;
+        if (!rootPkg.workspaces.includes(workspacePattern)) {
+            rootPkg.workspaces.push(workspacePattern);
+        }
+    }
+    // Update root package.json dependency to workspace:*
+    rootPkg.dependencies = rootPkg.dependencies || {};
+    rootPkg.dependencies[packageName] = "workspace:*";
+    fs.writeFileSync(rootPkgPath, `${JSON.stringify(rootPkg, null, 2)}\n`, "utf-8");
+    console.log(`✅ Updated root package.json dependencies.`);
+    // Link workspace packages
+    const { detectPackageManager } = await import("./package-manager.js");
+    const pm = detectPackageManager(rootDir);
+    const linkSpin = ora(`Running ${pm} install to link ejected ${itemType}...`).start();
+    try {
+        execSync(`${pm} install`, { cwd: rootDir, stdio: "ignore" });
+        linkSpin.succeed(`${isTemplate ? "Template" : "Plugin"} linked successfully.`);
+    }
+    catch (_err) {
+        linkSpin.fail(`Failed to run ${pm} install automatically.`);
+    }
+    // Regenerate registry only for plugins
+    if (!isTemplate) {
+        regeneratePluginsRegistry(rootDir);
+    }
+    console.log(`\n✨ ${isTemplate ? "Template" : "Plugin"} "${packageName}" ejected successfully to local folder ${targetSubdir}/${folderName}!`);
+}
+export const ejectPlugin = ejectPackage;

package/dist/cli/generate-plugin.d.ts

@@ -0,0 +1,3 @@
+export declare function generatePlugin(name: string, options?: {
+    skipInstall?: boolean;
+}): Promise<void>;

package/dist/cli/generate-plugin.js

@@ -0,0 +1,48 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import ora from "ora";
+import { stubPath } from "./stubs.js";
+import { findProjectRoot, processStubs, } from "./utils.js";
+export async function generatePlugin(name, options) {
+    const rootDir = findProjectRoot(process.cwd());
+    const pluginDir = path.join(rootDir, "plugins", `${name}-plugin`);
+    if (fs.existsSync(pluginDir)) {
+        console.error(`Error: Plugin "${name}" already exists in ${pluginDir}`);
+        process.exit(1);
+    }
+    const rootPluginsDir = path.join(rootDir, "plugins");
+    if (!fs.existsSync(rootPluginsDir)) {
+        fs.mkdirSync(rootPluginsDir, { recursive: true });
+    }
+    console.log(`🚀 Generating a plugin: ${name} in ${pluginDir}...`);
+    try {
+        const titleName = name
+            .split("-")
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(" ");
+        const pascalName = name.replace(/-/g, "");
+        const date = new Date().toDateString();
+        const variables = {
+            name,
+            titleName,
+            pascalName,
+            date,
+        };
+        // Stubs live at the package root of the installed @veap/framework.
+        const stubsDir = stubPath("plugin");
+        const spin = ora("Generating plugin files from stubs...").start();
+        processStubs(stubsDir, pluginDir, variables);
+        spin.succeed("Plugin files generated.");
+        if (!options?.skipInstall) {
+            const spinner = ora("📦 Installing dependencies (pnpm install)...").start();
+            execSync("pnpm install", { cwd: rootDir, stdio: "inherit" });
+            spinner.succeed("Dependencies installed.");
+        }
+        console.log(`\n✨ Plugin "${name}" is ready!`);
+        console.log(`💡 Run "pnpm veap generate:plugins" to register it.`);
+    }
+    catch (err) {
+        console.error("Error generating plugin:", err);
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+export { addPlugin } from "./add";
+export { ejectPackage, ejectPlugin } from "./eject";
+export { generatePlugin } from "./generate-plugin";
+export { applyDockerfileForPackageManager, detectPackageManager, type PackageManager, } from "./package-manager";
+export { findStubsDir, stubPath } from "./stubs";
+export { findProjectRoot, processStubs, regeneratePluginsRegistry, } from "./utils";

package/dist/cli/index.js

@@ -0,0 +1,6 @@
+export { addPlugin } from "./add";
+export { ejectPackage, ejectPlugin } from "./eject";
+export { generatePlugin } from "./generate-plugin";
+export { applyDockerfileForPackageManager, detectPackageManager, } from "./package-manager";
+export { findStubsDir, stubPath } from "./stubs";
+export { findProjectRoot, processStubs, regeneratePluginsRegistry, } from "./utils";

package/dist/cli/package-manager.d.ts

@@ -0,0 +1,14 @@
+export type PackageManager = "pnpm" | "npm" | "yarn" | "bun";
+/**
+ * Detects the package manager used by the project in `dir`.
+ *
+ * Priority: `packageManager` field in package.json > lockfiles > default (pnpm).
+ * On conflicting lockfiles pnpm wins (framework default).
+ */
+export declare function detectPackageManager(dir: string): PackageManager;
+/**
+ * Overwrites the generated pnpm Dockerfile with the variant matching `pm`.
+ * No-op for pnpm (baseline stub), missing variants or missing Dockerfile -
+ * best effort, Docker config is optional.
+ */
+export declare function applyDockerfileForPackageManager(projectDir: string, pm: PackageManager): void;