@bpmnkit/cli 0.0.15 → 0.0.17

package/README.md

@@ -106,6 +106,11 @@ casen instances list --state active
 | [`@bpmnkit/operate`](https://www.npmjs.com/package/@bpmnkit/operate) | Monitoring & operations frontend for Camunda clusters |
 | [`@bpmnkit/connector-gen`](https://www.npmjs.com/package/@bpmnkit/connector-gen) | Generate connector templates from OpenAPI specs |
 | [`@bpmnkit/proxy`](https://www.npmjs.com/package/@bpmnkit/proxy) | Local AI bridge and Camunda API proxy server |
+| [`@bpmnkit/cli-sdk`](https://www.npmjs.com/package/@bpmnkit/cli-sdk) | Plugin authoring SDK for the casen CLI |
+| [`@bpmnkit/create-casen-plugin`](https://www.npmjs.com/package/@bpmnkit/create-casen-plugin) | Scaffold a new casen CLI plugin in seconds |
+| [`@bpmnkit/casen-report`](https://www.npmjs.com/package/@bpmnkit/casen-report) | HTML reports from Camunda 8 incident and SLA data |
+| [`@bpmnkit/casen-worker-http`](https://www.npmjs.com/package/@bpmnkit/casen-worker-http) | Example HTTP worker plugin — completes jobs with live JSONPlaceholder API data |
+| [`@bpmnkit/casen-worker-ai`](https://www.npmjs.com/package/@bpmnkit/casen-worker-ai) | AI task worker — classify, summarize, extract, and decide using Claude |
 
 ## License
 

package/dist/commands/index.js

@@ -4,9 +4,13 @@ import { askGroup } from "./ask.js";
 import { getDmnReqsXmlCmd, getDmnXmlCmd, getStartFormCmd, getUserTaskFormCmd, getXmlCmd, renderBpmnCmd, } from "./bpmn.js";
 import { completionGroup } from "./completion.js";
 import { connectorGroup } from "./connector.js";
+import { lintGroup } from "./lint.js";
+import { pluginGroup } from "./plugin.js";
 import { profileGroup } from "./profile.js";
 import { computeRelations } from "./relations.js";
 import { settingsGroup } from "./settings.js";
+import { storyGroup } from "./story.js";
+import { testGroup } from "./test.js";
 import { workerCmd } from "./worker.js";
 // Inject custom commands into generated groups without modifying generated files.
 // Also remove the broken generated get-x-m-l commands (return text/xml, not JSON)
@@ -29,7 +33,7 @@ const customisedGroups = generatedCommandGroups.map((g) => {
         return { ...g, commands: [...commands, getUserTaskFormCmd] };
     }
     if (g === jobGroup) {
-        return { ...g, commands: [...g.commands, workerCmd] };
+        return g;
     }
     return g;
 });
@@ -39,12 +43,26 @@ const sortedOtherGroups = [
     ...adminCommandGroups,
     completionGroup,
 ].sort((a, b) => a.name.localeCompare(b.name));
-export const commandGroups = [
+const workerGroup = {
+    name: "worker",
+    description: workerCmd.description,
+    commands: [workerCmd],
+};
+/** Pinned groups shown above the separator in the main TUI menu. */
+export const pinnedGroups = [
     askGroup,
+    lintGroup,
+    storyGroup,
     settingsGroup,
-    profileGroup,
-    ...sortedOtherGroups,
+    testGroup,
+    workerGroup,
 ];
+/** API command groups — shown below the plugin section in the main TUI menu. */
+export const apiGroups = sortedOtherGroups;
+/** All built-in groups — used for CLI routing. */
+export const commandGroups = [...pinnedGroups, ...apiGroups];
+// Exported for CLI routing in run.ts (not shown in main TUI menu)
+export { pluginGroup, profileGroup };
 // Compute follow-up relations between commands based on shared field/arg names
 computeRelations(commandGroups);
 // Manually inject relations on GET commands (they return a single object, not a

package/dist/commands/lint.js

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+import { Bpmn, optimize } from "@bpmnkit/core";
+const SEVERITY_SYMBOL = {
+    error: "✖",
+    warning: "⚠",
+    info: "ℹ",
+};
+const lintCmd = {
+    name: "lint",
+    description: "Lint a BPMN file — run all static analysis and pattern checks",
+    args: [{ name: "file", description: "Path to the .bpmn file", required: true }],
+    flags: [
+        {
+            name: "categories",
+            description: "Comma-separated categories to run (default: all)",
+            type: "string",
+        },
+        {
+            name: "format",
+            description: "Output format: text (default) or json",
+            type: "string",
+        },
+    ],
+    async run(ctx) {
+        const filePath = ctx.positional[0];
+        if (!filePath)
+            throw new Error("Missing required argument: <file>");
+        const xml = await readFile(filePath, "utf-8");
+        const defs = Bpmn.parse(xml);
+        const categoriesFlag = ctx.flags.categories;
+        const categories = typeof categoriesFlag === "string" && categoriesFlag.length > 0
+            ? categoriesFlag.split(",").map((s) => s.trim())
+            : undefined;
+        const report = optimize(defs, categories !== undefined ? { categories } : undefined);
+        const { findings } = report;
+        const formatFlag = ctx.flags.format;
+        if (formatFlag === "json") {
+            ctx.output.print(findings);
+            return;
+        }
+        if (findings.length === 0) {
+            ctx.output.ok("No issues found.");
+            return;
+        }
+        for (const f of findings) {
+            const symbol = SEVERITY_SYMBOL[f.severity] ?? "·";
+            const elIds = f.elementIds.length > 0 ? ` [${f.elementIds.join(", ")}]` : "";
+            ctx.output.info(`${symbol} [${f.category}]${elIds} ${f.message}`);
+        }
+        const { total, bySeverity } = report.summary;
+        const errorCount = bySeverity.error ?? 0;
+        const warnCount = bySeverity.warning ?? 0;
+        const infoCount = bySeverity.info ?? 0;
+        ctx.output.info(`\n${total} finding${total !== 1 ? "s" : ""}: ${errorCount} error${errorCount !== 1 ? "s" : ""}, ${warnCount} warning${warnCount !== 1 ? "s" : ""}, ${infoCount} info`);
+        if (errorCount > 0) {
+            throw new Error(`Lint failed with ${errorCount} error${errorCount !== 1 ? "s" : ""}`);
+        }
+    },
+};
+export const lintGroup = {
+    name: "lint",
+    description: "Lint BPMN files using the static analyzer",
+    commands: [lintCmd],
+};
+//# sourceMappingURL=lint.js.map

package/dist/commands/plugin.js

@@ -0,0 +1,244 @@
+import { spawn } from "node:child_process";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { PLUGINS_DIR, readInstalledPlugins, sanitiseName, } from "../plugin-loader.js";
+// ── npm helper ────────────────────────────────────────────────────────────────
+function runNpm(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+        const child = spawn(npmCmd, ["install", ...args], { cwd, stdio: "inherit" });
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`npm install exited with code ${String(code)}`));
+        });
+        child.on("error", reject);
+    });
+}
+export async function searchNpmRegistry(query) {
+    const text = `keywords:casen-plugin${query ? ` ${query}` : ""}`;
+    const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(text)}&size=50`;
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`npm registry returned HTTP ${res.status}`);
+    const data = (await res.json());
+    return data.objects;
+}
+// ── plugin group ──────────────────────────────────────────────────────────────
+export const pluginGroup = {
+    name: "plugin",
+    description: "Manage casen CLI plugins",
+    commands: [
+        // ── list ──────────────────────────────────────────────────────────────
+        {
+            name: "list",
+            aliases: ["ls"],
+            description: "List installed plugins",
+            async run(ctx) {
+                const plugins = await readInstalledPlugins();
+                if (plugins.length === 0) {
+                    ctx.output.info('No plugins installed. Run "casen plugin search" to discover plugins.');
+                    return;
+                }
+                ctx.output.printList({
+                    items: plugins.map((p) => ({
+                        name: p.package,
+                        version: p.version,
+                        installed: p.installedAt.slice(0, 10),
+                    })),
+                }, [
+                    { key: "name", header: "NAME" },
+                    { key: "version", header: "VERSION" },
+                    { key: "installed", header: "INSTALLED" },
+                ]);
+            },
+        },
+        // ── install ───────────────────────────────────────────────────────────
+        {
+            name: "install",
+            aliases: ["add"],
+            description: "Install a plugin from the npm registry or a local path",
+            args: [{ name: "name", description: "npm package name or ./local-path", required: true }],
+            examples: [
+                { description: "Install from npm", command: "casen plugin install casen-deploy" },
+                {
+                    description: "Install from local path (dev mode)",
+                    command: "casen plugin install ./my-plugin",
+                },
+            ],
+            async run(ctx) {
+                const nameArg = ctx.positional[0];
+                if (!nameArg)
+                    throw new Error("Missing required argument: <name>");
+                // Detect local path vs npm package name
+                const isLocalPath = nameArg.startsWith(".") || nameArg.startsWith("/");
+                let pkgName;
+                if (isLocalPath) {
+                    const localPath = join(homedir(), nameArg.startsWith("/") ? "" : ".", nameArg);
+                    const localPkgText = await readFile(join(isLocalPath ? nameArg : localPath, "package.json"), "utf8");
+                    const localPkg = JSON.parse(localPkgText);
+                    if (!localPkg.name)
+                        throw new Error(`No "name" field found in ${nameArg}/package.json`);
+                    pkgName = localPkg.name;
+                }
+                else {
+                    pkgName = nameArg;
+                }
+                const dirName = sanitiseName(pkgName);
+                const pluginDir = join(PLUGINS_DIR, dirName);
+                ctx.output.info(`Installing ${pkgName}…`);
+                await mkdir(pluginDir, { recursive: true });
+                // Initialise a minimal host package.json so npm has a valid workspace
+                const hostPkg = { name: "_casen-plugin-host", version: "0.0.0", private: true };
+                const hostPkgPath = join(pluginDir, "package.json");
+                try {
+                    await readFile(hostPkgPath, "utf8");
+                }
+                catch {
+                    // Only write if it doesn't already exist
+                    await writeFile(hostPkgPath, `${JSON.stringify(hostPkg, null, 2)}\n`, "utf8");
+                }
+                await runNpm([nameArg], pluginDir);
+                // Read the installed version from the plugin's own package.json
+                const installedPkgText = await readFile(join(pluginDir, "node_modules", pkgName, "package.json"), "utf8");
+                const installedPkg = JSON.parse(installedPkgText);
+                const version = installedPkg.version ?? "unknown";
+                const meta = {
+                    package: pkgName,
+                    version,
+                    installedAt: new Date().toISOString(),
+                };
+                await writeFile(join(pluginDir, ".meta.json"), `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+                ctx.output.ok(`Installed ${pkgName}@${version}`);
+                ctx.output.info("Restart casen to activate the plugin.");
+            },
+        },
+        // ── remove ────────────────────────────────────────────────────────────
+        {
+            name: "remove",
+            aliases: ["uninstall", "rm"],
+            description: "Uninstall a plugin",
+            args: [{ name: "name", description: "Plugin package name", required: true }],
+            async run(ctx) {
+                const pkgName = ctx.positional[0];
+                if (!pkgName)
+                    throw new Error("Missing required argument: <name>");
+                const pluginDir = join(PLUGINS_DIR, sanitiseName(pkgName));
+                try {
+                    await readFile(join(pluginDir, ".meta.json"), "utf8");
+                }
+                catch {
+                    throw new Error(`Plugin "${pkgName}" is not installed.`);
+                }
+                await rm(pluginDir, { recursive: true, force: true });
+                ctx.output.ok(`Removed ${pkgName}`);
+                ctx.output.info("Restart casen for the change to take effect.");
+            },
+        },
+        // ── update ────────────────────────────────────────────────────────────
+        {
+            name: "update",
+            aliases: ["upgrade"],
+            description: "Update one or all plugins to their latest versions",
+            args: [
+                {
+                    name: "name",
+                    description: "Plugin to update (omit to update all installed plugins)",
+                    required: false,
+                },
+            ],
+            async run(ctx) {
+                const target = ctx.positional[0];
+                const plugins = await readInstalledPlugins();
+                if (plugins.length === 0) {
+                    ctx.output.info("No plugins installed.");
+                    return;
+                }
+                const toUpdate = target ? plugins.filter((p) => p.package === target) : plugins;
+                if (toUpdate.length === 0) {
+                    throw new Error(`Plugin "${String(target)}" is not installed.`);
+                }
+                for (const plugin of toUpdate) {
+                    ctx.output.info(`Updating ${plugin.package}…`);
+                    await runNpm([`${plugin.package}@latest`], plugin.dir);
+                    const pkgText = await readFile(join(plugin.dir, "node_modules", plugin.package, "package.json"), "utf8");
+                    const pkg = JSON.parse(pkgText);
+                    const newVersion = pkg.version ?? "unknown";
+                    const meta = {
+                        package: plugin.package,
+                        version: newVersion,
+                        installedAt: plugin.installedAt,
+                    };
+                    await writeFile(join(plugin.dir, ".meta.json"), `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+                    ctx.output.ok(`Updated ${plugin.package} → ${newVersion}`);
+                }
+                ctx.output.info("Restart casen for the changes to take effect.");
+            },
+        },
+        // ── info ──────────────────────────────────────────────────────────────
+        {
+            name: "info",
+            description: "Show details for an installed plugin",
+            args: [{ name: "name", description: "Plugin package name", required: true }],
+            async run(ctx) {
+                const pkgName = ctx.positional[0];
+                if (!pkgName)
+                    throw new Error("Missing required argument: <name>");
+                const pluginDir = join(PLUGINS_DIR, sanitiseName(pkgName));
+                const metaText = await readFile(join(pluginDir, ".meta.json"), "utf8");
+                const meta = JSON.parse(metaText);
+                const pkgText = await readFile(join(pluginDir, "node_modules", pkgName, "package.json"), "utf8");
+                const pkg = JSON.parse(pkgText);
+                const repoUrl = typeof pkg.repository === "string" ? pkg.repository : (pkg.repository?.url ?? "");
+                const author = typeof pkg.author === "string" ? pkg.author : (pkg.author?.name ?? "");
+                ctx.output.printItem({
+                    name: meta.package,
+                    version: meta.version,
+                    installedAt: meta.installedAt,
+                    description: pkg.description ?? "",
+                    homepage: pkg.homepage ?? "",
+                    repository: repoUrl,
+                    author,
+                    directory: pluginDir,
+                });
+            },
+        },
+        // ── search ────────────────────────────────────────────────────────────
+        {
+            name: "search",
+            description: "Search the npm registry for casen plugins",
+            args: [{ name: "query", description: "Search terms (optional)", required: false }],
+            examples: [
+                { description: "Browse all plugins", command: "casen plugin search" },
+                { description: "Search for deploy-related plugins", command: "casen plugin search deploy" },
+            ],
+            async run(ctx) {
+                const query = ctx.positional[0] ?? "";
+                ctx.output.info(`Searching npm for casen plugins${query ? ` matching "${query}"` : ""}…`);
+                const results = await searchNpmRegistry(query);
+                if (results.length === 0) {
+                    ctx.output.info("No plugins found.");
+                    return;
+                }
+                ctx.output.printList({
+                    items: results.map((r) => ({
+                        name: r.package.name,
+                        version: r.package.version,
+                        description: r.package.description ?? "",
+                        publisher: r.package.publisher?.username ?? "",
+                        score: r.score.final.toFixed(2),
+                    })),
+                }, [
+                    { key: "name", header: "NAME" },
+                    { key: "version", header: "VERSION" },
+                    { key: "description", header: "DESCRIPTION", maxWidth: 52 },
+                    { key: "publisher", header: "PUBLISHER" },
+                    { key: "score", header: "SCORE" },
+                ]);
+            },
+        },
+    ],
+};
+//# sourceMappingURL=plugin.js.map

package/dist/commands/story.js

@@ -0,0 +1,42 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { Bpmn, renderStoryHtml } from "@bpmnkit/core";
+const storyCmd = {
+    name: "story",
+    description: "Render a BPMN process as a standalone story-mode HTML file",
+    args: [{ name: "file", description: "Path to the .bpmn file", required: true }],
+    flags: [
+        {
+            name: "output",
+            short: "o",
+            description: "Output path (default: <file>.story.html)",
+            type: "string",
+        },
+        {
+            name: "theme",
+            description: "Color theme: light (default) or dark",
+            type: "string",
+        },
+    ],
+    async run(ctx) {
+        const filePath = ctx.positional[0];
+        if (!filePath)
+            throw new Error("Missing required argument: <file>");
+        const xml = await readFile(filePath, "utf-8");
+        const defs = Bpmn.parse(xml);
+        const themeFlag = ctx.flags.theme;
+        const theme = themeFlag === "dark" ? "dark" : "light";
+        const outputFlag = ctx.flags.output;
+        const outputPath = typeof outputFlag === "string" && outputFlag.length > 0
+            ? outputFlag
+            : `${filePath}.story.html`;
+        const html = renderStoryHtml(defs, { standalone: true, theme });
+        await writeFile(outputPath, html, "utf-8");
+        ctx.output.ok(`Story HTML written to ${outputPath}`);
+    },
+};
+export const storyGroup = {
+    name: "story",
+    description: "Render BPMN processes as narrative HTML",
+    commands: [storyCmd],
+};
+//# sourceMappingURL=story.js.map

package/dist/commands/test.js

@@ -0,0 +1,77 @@
+import { readFile } from "node:fs/promises";
+import { Bpmn } from "@bpmnkit/core";
+import { Engine, runScenario } from "@bpmnkit/engine";
+const testCmd = {
+    name: "test",
+    description: "Run scenario tests for a BPMN process file",
+    args: [
+        {
+            name: "file",
+            description: "Path to the .bpmn file",
+            required: true,
+        },
+    ],
+    flags: [
+        {
+            name: "scenarios",
+            short: "s",
+            description: "Path to the .bpmn.tests.json scenarios file (default: <file>.tests.json)",
+            type: "string",
+        },
+    ],
+    async run(ctx) {
+        const bpmnPath = ctx.positional[0];
+        if (bpmnPath === undefined)
+            throw new Error("Missing required argument: <file>");
+        const scenariosPath = typeof ctx.flags.scenarios === "string" ? ctx.flags.scenarios : `${bpmnPath}.tests.json`;
+        const bpmnXml = await readFile(bpmnPath, "utf8").catch(() => {
+            throw new Error(`Cannot read BPMN file: ${bpmnPath}`);
+        });
+        const scenariosRaw = await readFile(scenariosPath, "utf8").catch(() => {
+            throw new Error(`Cannot read scenarios file: ${scenariosPath}`);
+        });
+        let scenarios;
+        try {
+            scenarios = JSON.parse(scenariosRaw);
+        }
+        catch {
+            throw new Error(`Invalid JSON in scenarios file: ${scenariosPath}`);
+        }
+        if (!Array.isArray(scenarios) || scenarios.length === 0) {
+            ctx.output.info("No scenarios found.");
+            return;
+        }
+        const defs = Bpmn.parse(bpmnXml);
+        const engine = new Engine();
+        let passed = 0;
+        let failed = 0;
+        for (const scenario of scenarios) {
+            const result = await runScenario(engine, defs, scenario);
+            if (result.passed) {
+                passed++;
+                ctx.output.ok(`PASS  ${scenario.name}  (${result.durationMs}ms)`);
+            }
+            else {
+                failed++;
+                ctx.output.info(`FAIL  ${scenario.name}  (${result.durationMs}ms)`);
+                for (const f of result.failures) {
+                    ctx.output.info(`       ${f.field}: expected ${JSON.stringify(f.expected)}, got ${JSON.stringify(f.actual)}`);
+                }
+                for (const e of result.errors) {
+                    ctx.output.info(`       error${e.elementId !== undefined ? ` (${e.elementId})` : ""}: ${e.message}`);
+                }
+            }
+        }
+        const total = passed + failed;
+        ctx.output.info(`\n${passed}/${total} passed`);
+        if (failed > 0) {
+            throw new Error(`${failed} scenario(s) failed`);
+        }
+    },
+};
+export const testGroup = {
+    name: "test",
+    description: "Run scenario-based tests for BPMN processes",
+    commands: [testCmd],
+};
+//# sourceMappingURL=test.js.map

package/dist/commands/worker.js

@@ -11,11 +11,13 @@
 export const workerCmd = {
     name: "worker",
     description: "Run a simple job worker that auto-completes jobs of a given type",
+    _worker: { jobType: "io.camunda.connector.HttpJson:1" },
     args: [
         {
             name: "type",
             description: "Job type to subscribe to (matches the task definition type in BPMN)",
             required: true,
+            default: "io.camunda.connector.HttpJson:1",
         },
     ],
     flags: [
@@ -46,11 +48,11 @@ export const workerCmd = {
     examples: [
         {
             description: "Subscribe to jobs of type 'payment-service'",
-            command: "casen job worker payment-service",
+            command: "casen worker payment-service",
         },
         {
             description: "Return custom variables on completion",
-            command: 'casen job worker payment-service --variables \'{"status":"ok","amount":100}\'',
+            command: 'casen worker payment-service --variables \'{"status":"ok","amount":100}\'',
         },
     ],
     async run(ctx) {

package/dist/plugin-loader.js

@@ -0,0 +1,89 @@
+import { readFile, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+// ── Paths ─────────────────────────────────────────────────────────────────────
+export const PLUGINS_DIR = join(homedir(), ".casen", "plugins");
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/**
+ * Converts an npm package name to a safe directory name.
+ * "@acme/casen-deploy" → "acme__casen-deploy"
+ */
+export function sanitiseName(pkg) {
+    return pkg.replace(/^@/, "").replace(/\//g, "__");
+}
+// ── Plugin loader ─────────────────────────────────────────────────────────────
+/**
+ * Loads all installed plugins from `~/.casen/plugins/` and returns their
+ * combined command groups. Failures are isolated — a broken plugin logs a
+ * warning to stderr and is skipped; it cannot crash the CLI.
+ */
+export async function loadPlugins() {
+    let entries;
+    try {
+        entries = await readdir(PLUGINS_DIR);
+    }
+    catch {
+        return [];
+    }
+    const groups = [];
+    for (const entry of entries) {
+        if (entry.startsWith("."))
+            continue;
+        const pluginDir = join(PLUGINS_DIR, entry);
+        try {
+            // Read metadata to get the actual npm package name
+            const metaText = await readFile(join(pluginDir, ".meta.json"), "utf8");
+            const meta = JSON.parse(metaText);
+            const pkgName = meta.package;
+            // Resolve entry point via the plugin's own package.json
+            const pkgText = await readFile(join(pluginDir, "node_modules", pkgName, "package.json"), "utf8");
+            const pkg = JSON.parse(pkgText);
+            const main = pkg.main ?? "dist/index.js";
+            const entryPath = join(pluginDir, "node_modules", pkgName, main);
+            // Dynamic import — use file URL for cross-platform compatibility
+            const mod = (await import(pathToFileURL(entryPath).href));
+            const plugin = (mod.default ?? mod);
+            if (!Array.isArray(plugin.groups)) {
+                process.stderr.write(`[plugin] ${pkgName}: no groups exported, skipping\n`);
+                continue;
+            }
+            groups.push(...plugin.groups);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[plugin] ${entry}: failed to load — ${msg}\n`);
+        }
+    }
+    return groups;
+}
+// ── Management helpers ────────────────────────────────────────────────────────
+/**
+ * Returns metadata for all installed plugins.
+ * Directories without a `.meta.json` are silently ignored.
+ */
+export async function readInstalledPlugins() {
+    let entries;
+    try {
+        entries = await readdir(PLUGINS_DIR);
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    for (const entry of entries) {
+        if (entry.startsWith("."))
+            continue;
+        const dir = join(PLUGINS_DIR, entry);
+        try {
+            const metaText = await readFile(join(dir, ".meta.json"), "utf8");
+            const meta = JSON.parse(metaText);
+            result.push({ ...meta, dir });
+        }
+        catch {
+            // Directory without .meta.json — not a managed plugin, skip
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=plugin-loader.js.map