next-workflow-builder 0.1.0

package/dist/scripts/discover-plugins.js

@@ -0,0 +1,729 @@
+#!/usr/bin/env tsx
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import ts from "typescript";
+const PLUGINS_DIR = join(process.cwd(), "plugins");
+const OUTPUT_FILE = join(PLUGINS_DIR, "index.ts");
+const TYPES_FILE = join(process.cwd(), "lib", "types", "integration.ts");
+const STEP_REGISTRY_FILE = join(process.cwd(), "lib", "step-registry.ts");
+const OUTPUT_CONFIGS_FILE = join(process.cwd(), "lib", "output-display-configs.ts");
+const CODEGEN_REGISTRY_FILE = join(process.cwd(), "lib", "codegen-registry.ts");
+const ROUTE_REGISTRY_FILE = join(process.cwd(), "lib", "route-registry.ts");
+const README_FILE = join(process.cwd(), "README.md");
+const PLUGINS_MARKER_REGEX = /<!-- PLUGINS:START[^>]*-->[\s\S]*?<!-- PLUGINS:END -->/;
+const SYSTEM_INTEGRATION_TYPES = ["database"];
+const LEADING_WHITESPACE_PATTERN = /^\s*/;
+async function importPackageOrLocal(localRelPath) {
+    const localPath = join(import.meta.dirname, "..", "plugins", localRelPath);
+    if (existsSync(localPath)) {
+        return await import(pathToFileURL(localPath).href);
+    }
+    return await import("next-workflow-builder/plugins");
+}
+function parsePluginImports() {
+    if (!existsSync(OUTPUT_FILE))
+        return [];
+    const content = readFileSync(OUTPUT_FILE, "utf-8");
+    const importRegex = /^\s*import\s+["']([^"']+)["']\s*;/gm;
+    const specifiers = [];
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+        const spec = match[1];
+        if (spec.includes("/client") ||
+            spec.startsWith("../lib/") ||
+            spec.startsWith("../") ||
+            spec === "next-workflow-builder/components" ||
+            spec.startsWith("next-workflow-builder/")) {
+            continue;
+        }
+        specifiers.push(spec);
+    }
+    return specifiers;
+}
+async function importPluginsFromIndex() {
+    const localRegistry = await import("../plugins/registry.js");
+    const specifiers = parsePluginImports();
+    if (specifiers.length === 0) {
+        console.log("No plugin imports found in plugins/index.ts");
+        return;
+    }
+    console.log(`Importing ${specifiers.length} plugin(s) from plugins/index.ts...`);
+    for (const spec of specifiers) {
+        let resolvedPath;
+        if (spec.startsWith(".")) {
+            resolvedPath = pathToFileURL(join(PLUGINS_DIR, spec, "index.ts")).href;
+        }
+        else {
+            try {
+                const { createRequire } = await import("node:module");
+                const require = createRequire(join(process.cwd(), "package.json"));
+                resolvedPath = pathToFileURL(require.resolve(spec)).href;
+            }
+            catch {
+                resolvedPath = spec;
+            }
+        }
+        try {
+            const mod = await import(resolvedPath);
+            if (mod.default) {
+                localRegistry.registerIntegration(mod.default);
+                if (!spec.startsWith(".")) {
+                    npmPluginSpecifiers.set(mod.default.type, spec);
+                }
+            }
+            console.log(`   - ${spec}`);
+        }
+        catch (error) {
+            console.warn(`   Warning: Failed to import plugin "${spec}":`, error);
+        }
+    }
+    console.log(`Registered ${specifiers.length} plugin(s) with local registry`);
+}
+async function formatCode(code) {
+    try {
+        const prettier = await import("prettier");
+        return await prettier.format(code, { parser: "typescript" });
+    }
+    catch (error) {
+        console.warn("   Warning: Failed to format generated code:", error);
+        return code;
+    }
+}
+const generatedCodegenTemplates = new Map();
+const npmPluginSpecifiers = new Map();
+function discoverLocalPluginDirs() {
+    if (!existsSync(PLUGINS_DIR))
+        return [];
+    const entries = readdirSync(PLUGINS_DIR);
+    return entries.filter((entry) => {
+        if (entry.startsWith("_") ||
+            entry.startsWith(".") ||
+            entry === "index.ts" ||
+            entry === "registry.ts" ||
+            entry === "system") {
+            return false;
+        }
+        const fullPath = join(PLUGINS_DIR, entry);
+        try {
+            return statSync(fullPath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }).sort();
+}
+function scaffoldIndexFile() {
+    if (existsSync(OUTPUT_FILE)) {
+        console.log("plugins/index.ts already exists, skipping scaffold");
+        return;
+    }
+    const localPlugins = discoverLocalPluginDirs();
+    const imports = localPlugins.length > 0
+        ? localPlugins.map((plugin) => `import "./${plugin}";`).join("\n")
+        : "// import \"./my-plugin\";";
+    const clientImports = localPlugins
+        .filter((plugin) => existsSync(join(PLUGINS_DIR, plugin, "client.ts")))
+        .map((plugin) => `import "./${plugin}/client";`)
+        .join("\n");
+    const content = `/**
+ * Plugins Index
+ *
+ * This file is managed by you. Add or remove plugin imports as needed.
+ *
+ * To add a local plugin:
+ *   import "./my-plugin";
+ *
+ * To add an npm-installed plugin:
+ *   import "@next-workflow-builder/loop";
+ *
+ * After editing, run: pnpm discover-plugins (or it runs automatically on build)
+ */
+"use client";
+
+// Local plugins (side-effect imports trigger registration)
+${imports}
+
+// Register auto-generated data into the plugin registry
+import "../lib/output-display-configs";
+import "../lib/codegen-registry";
+${clientImports ? `\n// Client-only registrations (managed connections, etc.)\n${clientImports}` : ""}
+
+// Re-export LayoutProvider with plugins pre-registered via side-effect imports above
+export { LayoutProvider } from "next-workflow-builder/components";
+`;
+    writeFileSync(OUTPUT_FILE, content, "utf-8");
+    console.log("Scaffolded plugins/index.ts");
+}
+function ensureGitignore() {
+    const gitignorePath = join(process.cwd(), ".gitignore");
+    const SECTION_HEADER = "# Auto-generated by discover-plugins";
+    const filesToIgnore = [
+        TYPES_FILE,
+        STEP_REGISTRY_FILE,
+        OUTPUT_CONFIGS_FILE,
+        CODEGEN_REGISTRY_FILE,
+        ROUTE_REGISTRY_FILE,
+    ];
+    const relativePaths = filesToIgnore.map((file) => relative(process.cwd(), file));
+    let content = "";
+    if (existsSync(gitignorePath)) {
+        content = readFileSync(gitignorePath, "utf-8");
+    }
+    const existingLines = new Set(content.split("\n").map((line) => line.trim()));
+    const newEntries = relativePaths.filter((entry) => !existingLines.has(entry));
+    if (newEntries.length > 0) {
+        let textToAppend = "";
+        if (content.length > 0 && !content.endsWith("\n")) {
+            textToAppend += "\n";
+        }
+        if (!content.includes(SECTION_HEADER)) {
+            textToAppend += `${SECTION_HEADER}\n`;
+        }
+        textToAppend += newEntries.join("\n") + "\n";
+        writeFileSync(gitignorePath, content + textToAppend, "utf-8");
+        console.log(`Updated .gitignore with ${newEntries.length} new file(s).`);
+    }
+}
+async function updateReadme() {
+    const { getAllIntegrations } = await importPackageOrLocal("registry.ts");
+    const integrations = getAllIntegrations();
+    if (integrations.length === 0) {
+        console.log("No integrations found, skipping README update");
+        return;
+    }
+    const actionsList = integrations
+        .map((integration) => {
+        const actionLabels = integration.actions.map((a) => a.label).join(", ");
+        return `- **${integration.label}**: ${actionLabels}`;
+    })
+        .join("\n");
+    const readme = readFileSync(README_FILE, "utf-8");
+    if (!readme.includes("<!-- PLUGINS:START")) {
+        console.log("README markers not found, skipping README update");
+        return;
+    }
+    const updated = readme.replace(PLUGINS_MARKER_REGEX, `<!-- PLUGINS:START - Do not remove. Auto-generated by discover-plugins -->\n${actionsList}\n<!-- PLUGINS:END -->`);
+    writeFileSync(README_FILE, updated, "utf-8");
+    console.log(`Updated README.md with ${integrations.length} integration(s)`);
+}
+async function generateTypesFile() {
+    const typesDir = dirname(TYPES_FILE);
+    if (!existsSync(typesDir)) {
+        mkdirSync(typesDir, { recursive: true });
+    }
+    const { getIntegrationTypes } = await import("../plugins/registry.js");
+    const pluginTypes = getIntegrationTypes();
+    const allTypes = [...pluginTypes, ...SYSTEM_INTEGRATION_TYPES].sort();
+    const unionType = allTypes.map((t) => `  | "${t}"`).join("\n");
+    const content = `/**
+ * Integration Types (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * To add a new integration type:
+ * 1. Create a plugin in plugins/ directory, OR
+ * 2. Add a system integration to SYSTEM_INTEGRATION_TYPES in discover-plugins.ts
+ * 3. Run: pnpm discover-plugins
+ *
+ * Generated types: ${allTypes.join(", ")}
+ */
+
+// Integration type union - plugins + system integrations
+export type IntegrationType =
+${unionType};
+
+// Generic config type - plugins define their own keys via formFields[].configKey
+export type IntegrationConfig = Record<string, string | undefined>;
+`;
+    writeFileSync(TYPES_FILE, content, "utf-8");
+    console.log(`Generated lib/types/integration.ts with ${allTypes.length} type(s)`);
+}
+function createEmptyAnalysis() {
+    return {
+        hasExportCore: false,
+        integrationType: null,
+        coreFunction: null,
+        inputTypes: [],
+        imports: [],
+    };
+}
+function processExportedVariable(decl, result) {
+    if (!ts.isIdentifier(decl.name)) {
+        return;
+    }
+    const name = decl.name.text;
+    const init = decl.initializer;
+    if (name === "_integrationType" && init && ts.isStringLiteral(init)) {
+        result.integrationType = init.text;
+    }
+}
+function shouldIncludeType(typeName) {
+    return (typeName.endsWith("Result") ||
+        typeName.endsWith("Credentials") ||
+        typeName.endsWith("CoreInput"));
+}
+function shouldIncludeImport(moduleSpec, importText) {
+    if (moduleSpec.startsWith("@/") || moduleSpec.startsWith(".")) {
+        return false;
+    }
+    if (importText.includes("server-only")) {
+        return false;
+    }
+    return true;
+}
+function extractFunctionInfo(node, sourceCode) {
+    if (!(node.name && node.body)) {
+        return null;
+    }
+    const params = node.parameters
+        .map((p) => sourceCode.slice(p.pos, p.end).trim())
+        .join(", ");
+    const returnType = node.type
+        ? sourceCode.slice(node.type.pos, node.type.end).trim()
+        : "Promise<unknown>";
+    const body = sourceCode.slice(node.body.pos, node.body.end).trim();
+    return {
+        name: node.name.text,
+        params,
+        returnType,
+        body,
+    };
+}
+function processVariableStatement(node, result) {
+    const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    if (!isExported) {
+        return;
+    }
+    for (const decl of node.declarationList.declarations) {
+        processExportedVariable(decl, result);
+    }
+}
+function processTypeAlias(node, sourceCode, result) {
+    if (shouldIncludeType(node.name.text)) {
+        result.inputTypes.push(sourceCode.slice(node.pos, node.end).trim());
+    }
+}
+function processImportDeclaration(node, sourceCode, result) {
+    const spec = node.moduleSpecifier;
+    if (!ts.isStringLiteral(spec)) {
+        return;
+    }
+    const importText = sourceCode.slice(node.pos, node.end).trim();
+    if (shouldIncludeImport(spec.text, importText)) {
+        result.imports.push(importText);
+    }
+}
+function processNode(node, sourceCode, result) {
+    if (ts.isVariableStatement(node)) {
+        processVariableStatement(node, result);
+        return;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+        processTypeAlias(node, sourceCode, result);
+        return;
+    }
+    if (ts.isImportDeclaration(node)) {
+        processImportDeclaration(node, sourceCode, result);
+        return;
+    }
+    if (ts.isFunctionDeclaration(node) && node.name?.text === "stepHandler") {
+        result.hasExportCore = true;
+        result.coreFunction = extractFunctionInfo(node, sourceCode);
+    }
+}
+function analyzeStepFile(filePath) {
+    const result = createEmptyAnalysis();
+    if (!existsSync(filePath)) {
+        return result;
+    }
+    const sourceCode = readFileSync(filePath, "utf-8");
+    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
+    ts.forEachChild(sourceFile, (node) => {
+        processNode(node, sourceCode, result);
+    });
+    return result;
+}
+async function generateCodegenTemplate(stepFilePath, stepFunctionName) {
+    const analysis = analyzeStepFile(stepFilePath);
+    if (!(analysis.hasExportCore && analysis.coreFunction)) {
+        return null;
+    }
+    const { coreFunction, integrationType, inputTypes, imports } = analysis;
+    let innerBody = coreFunction.body.trim();
+    if (innerBody.startsWith("{")) {
+        innerBody = innerBody.slice(1);
+    }
+    if (innerBody.endsWith("}")) {
+        innerBody = innerBody.slice(0, -1);
+    }
+    innerBody = innerBody.trim();
+    const inputType = coreFunction.params
+        .split(",")[0]
+        .replace(LEADING_WHITESPACE_PATTERN, "")
+        .split(":")[1]
+        ?.trim() || "unknown";
+    const rawTemplate = `${imports.join("\n")}
+import { fetchCredentials } from './lib/credential-helper.js';
+
+function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+${inputTypes.join("\n\n")}
+
+export async function ${stepFunctionName}(input: ${inputType}): ${coreFunction.returnType} {
+  "use step";
+  const credentials = await fetchCredentials("${integrationType || "unknown"}");
+${innerBody}
+}`;
+    return await formatCode(rawTemplate);
+}
+async function processStepFilesForCodegen() {
+    const { getAllIntegrations, computeActionId } = await import("../plugins/registry.js");
+    const integrations = getAllIntegrations();
+    for (const integration of integrations) {
+        for (const action of integration.actions) {
+            let stepFilePath;
+            const npmSpec = npmPluginSpecifiers.get(integration.type);
+            if (npmSpec) {
+                try {
+                    const { createRequire } = await import("node:module");
+                    const require = createRequire(join(process.cwd(), "package.json"));
+                    const pkgDir = dirname(require.resolve(`${npmSpec}/package.json`));
+                    stepFilePath = join(pkgDir, "steps", `${action.stepImportPath}.ts`);
+                }
+                catch {
+                    continue;
+                }
+            }
+            else {
+                stepFilePath = join(PLUGINS_DIR, integration.type, "steps", `${action.stepImportPath}.ts`);
+            }
+            const template = await generateCodegenTemplate(stepFilePath, action.stepFunction);
+            if (template) {
+                const actionId = computeActionId(integration.type, action.slug);
+                generatedCodegenTemplates.set(actionId, {
+                    template,
+                    integrationType: integration.type,
+                });
+                console.log(`   Generated codegen template for ${actionId}`);
+            }
+        }
+    }
+}
+function generateCodegenRegistry() {
+    const entries = Array.from(generatedCodegenTemplates.entries());
+    if (entries.length === 0) {
+        console.log("No codegen templates generated");
+        return;
+    }
+    const templateEntries = entries
+        .map(([actionId, { template }]) => {
+        const escapedTemplate = template
+            .replace(/\\/g, "\\\\")
+            .replace(/`/g, "\\`")
+            .replace(/\$\{/g, "\\${");
+        return `  "${actionId}": \`${escapedTemplate}\`,`;
+    })
+        .join("\n\n");
+    const content = `/**
+ * Codegen Registry (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * Contains auto-generated codegen templates for steps with stepHandler.
+ * These templates are used when exporting workflows to standalone projects.
+ *
+ * Generated templates: ${entries.length}
+ */
+
+import { registerCodegenTemplates } from "next-workflow-builder/plugins";
+
+/**
+ * Auto-generated codegen templates
+ * Maps action IDs to their generated export code templates
+ */
+export const AUTO_GENERATED_TEMPLATES: Record<string, string> = {
+${templateEntries}
+};
+
+// Register templates into the plugin registry so the package can access them
+registerCodegenTemplates(AUTO_GENERATED_TEMPLATES);
+`;
+    writeFileSync(CODEGEN_REGISTRY_FILE, content, "utf-8");
+    console.log(`Generated lib/codegen-registry.ts with ${entries.length} template(s)`);
+}
+async function generateStepRegistry() {
+    const { getAllIntegrations, computeActionId } = await import("../plugins/registry.js");
+    const { LEGACY_ACTION_MAPPINGS } = await import("../plugins/legacy-mappings.js");
+    const integrations = getAllIntegrations();
+    console.log("Generating step registry for integrations...");
+    const stepEntries = [];
+    for (const integration of integrations) {
+        for (const action of integration.actions) {
+            const fullActionId = computeActionId(integration.type, action.slug);
+            stepEntries.push({
+                actionId: fullActionId,
+                label: action.label,
+                integration: integration.type,
+                stepImportPath: action.stepImportPath,
+                stepFunction: action.stepFunction,
+            });
+        }
+    }
+    const legacyLabelsForAction = {};
+    for (const [legacyLabel, actionId] of Object.entries(LEGACY_ACTION_MAPPINGS)) {
+        if (!legacyLabelsForAction[actionId]) {
+            legacyLabelsForAction[actionId] = [];
+        }
+        legacyLabelsForAction[actionId].push(legacyLabel);
+    }
+    const importerEntries = stepEntries
+        .flatMap(({ actionId, integration, stepImportPath, stepFunction }) => {
+        const npmSpec = npmPluginSpecifiers.get(integration);
+        const importPath = npmSpec
+            ? `${npmSpec}/steps/${stepImportPath}`
+            : `@/plugins/${integration}/steps/${stepImportPath}`;
+        const entries = [
+            `  "${actionId}": {
+    importer: () => import("${importPath}"),
+    stepFunction: "${stepFunction}",
+  },`,
+        ];
+        const legacyLabels = legacyLabelsForAction[actionId] || [];
+        for (const legacyLabel of legacyLabels) {
+            entries.push(`  "${legacyLabel}": {
+    importer: () => import("${importPath}"),
+    stepFunction: "${stepFunction}",
+  },`);
+        }
+        return entries;
+    })
+        .join("\n");
+    const labelEntries = stepEntries
+        .map(({ actionId, label }) => `  "${actionId}": "${label}",`)
+        .join("\n");
+    const legacyLabelEntries = Object.entries(legacyLabelsForAction)
+        .flatMap(([actionId, legacyLabels]) => {
+        const entry = stepEntries.find((e) => e.actionId === actionId);
+        if (!entry) {
+            return [];
+        }
+        return legacyLabels.map((legacyLabel) => `  "${legacyLabel}": "${entry.label}",`);
+    })
+        .join("\n");
+    const content = `/**
+ * Step Registry (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * This registry enables dynamic step imports that are statically analyzable
+ * by the bundler. Each action type maps to its step importer function.
+ *
+ * Generated entries: ${stepEntries.length}
+ */
+
+import "server-only";
+
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic step module types - step functions take any input
+export type StepFunction = (input: any) => Promise<any>;
+
+// Step modules may contain the step function plus other exports (types, constants, etc.)
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic module with mixed exports
+export type StepModule = Record<string, any>;
+
+export type StepImporter = {
+  importer: () => Promise<StepModule>;
+  stepFunction: string;
+};
+
+/**
+ * Plugin step importers - maps action types to their step import functions
+ * These imports are statically analyzable by the bundler
+ */
+export const PLUGIN_STEP_IMPORTERS: Record<string, StepImporter> = {
+${importerEntries}
+};
+
+/**
+ * Action labels - maps action IDs to human-readable labels
+ * Used for displaying friendly names in the UI (e.g., Runs tab)
+ */
+export const ACTION_LABELS: Record<string, string> = {
+${labelEntries}
+${legacyLabelEntries}
+};
+
+/**
+ * Get a step importer for an action type
+ */
+export function getStepImporter(actionType: string): StepImporter | undefined {
+  return PLUGIN_STEP_IMPORTERS[actionType];
+}
+
+/**
+ * Get the human-readable label for an action type
+ */
+export function getActionLabel(actionType: string): string | undefined {
+  return ACTION_LABELS[actionType];
+}
+`;
+    writeFileSync(STEP_REGISTRY_FILE, content, "utf-8");
+    console.log(`Generated lib/step-registry.ts with ${stepEntries.length} step(s)`);
+}
+async function generateOutputDisplayConfigs() {
+    const { getAllIntegrations, computeActionId } = await import("../plugins/registry.js");
+    const integrations = getAllIntegrations();
+    const outputConfigs = [];
+    for (const integration of integrations) {
+        for (const action of integration.actions) {
+            if (action.outputConfig && action.outputConfig.type !== "component") {
+                outputConfigs.push({
+                    actionId: computeActionId(integration.type, action.slug),
+                    type: action.outputConfig.type,
+                    field: action.outputConfig.field,
+                });
+            }
+        }
+    }
+    const outputConfigEntries = outputConfigs
+        .map(({ actionId, type, field }) => `  "${actionId}": { type: "${type}", field: "${field}" },`)
+        .join("\n");
+    const content = `/**
+ * Output Display Configs (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * This file is CLIENT-SAFE and can be imported in client components.
+ * It maps action IDs to their output display configuration.
+ *
+ * Generated configs: ${outputConfigs.length}
+ */
+
+import { registerOutputDisplayConfigs } from "next-workflow-builder/plugins";
+
+export type OutputDisplayConfig = {
+  type: "image" | "video" | "url";
+  field: string;
+};
+
+/**
+ * Output display configs - maps action IDs to their display configuration
+ * Used for rendering outputs in the workflow runs panel
+ */
+export const OUTPUT_DISPLAY_CONFIGS: Record<string, OutputDisplayConfig> = {
+${outputConfigEntries}
+};
+
+// Register configs into the plugin registry so the package can access them
+registerOutputDisplayConfigs(OUTPUT_DISPLAY_CONFIGS);
+`;
+    writeFileSync(OUTPUT_CONFIGS_FILE, content, "utf-8");
+    console.log(`Generated lib/output-display-configs.ts with ${outputConfigs.length} config(s)`);
+}
+async function generateRouteRegistry() {
+    const { getAllIntegrations } = await import("../plugins/registry.js");
+    const integrations = getAllIntegrations();
+    const routeEntries = [];
+    for (const integration of integrations) {
+        if (!integration.routes)
+            continue;
+        for (const route of integration.routes) {
+            routeEntries.push({
+                ...route,
+                pluginType: integration.type,
+            });
+        }
+    }
+    if (routeEntries.length === 0) {
+        const content = `/**
+ * Route Registry (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * No plugin routes found.
+ */
+
+import "server-only";
+import type { RouteDefinition } from "next-workflow-builder";
+
+const PLUGIN_ROUTES: RouteDefinition[] = [];
+
+export default PLUGIN_ROUTES;
+`;
+        writeFileSync(ROUTE_REGISTRY_FILE, content, "utf-8");
+        console.log("Generated lib/route-registry.ts with 0 route(s)");
+        return;
+    }
+    const importLines = [];
+    const routeDefLines = [];
+    for (const entry of routeEntries) {
+        const npmSpec = npmPluginSpecifiers.get(entry.pluginType);
+        const importPath = npmSpec
+            ? `${npmSpec}/${entry.handlerImportPath}`
+            : `@/plugins/${entry.pluginType}/${entry.handlerImportPath}`;
+        const methodsStr = entry.methods.map((m) => `"${m}"`).join(", ");
+        importLines.push(`import { ${entry.handler} } from "${importPath}";`);
+        routeDefLines.push(`  { path: "${entry.path}", handler: ${entry.handler}, methods: [${methodsStr}] },`);
+    }
+    const content = `/**
+ * Route Registry (Auto-Generated)
+ *
+ * This file is automatically generated by scripts/discover-plugins.ts
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ *
+ * This file is SERVER-ONLY. Plugin route handlers are imported statically
+ * so the bundler can tree-shake unused code.
+ *
+ * Generated routes: ${routeEntries.length}
+ */
+
+import "server-only";
+import type { RouteDefinition } from "next-workflow-builder";
+${importLines.join("\n")}
+
+const PLUGIN_ROUTES: RouteDefinition[] = [
+${routeDefLines.join("\n")}
+];
+
+export default PLUGIN_ROUTES;
+`;
+    writeFileSync(ROUTE_REGISTRY_FILE, content, "utf-8");
+    console.log(`Generated lib/route-registry.ts with ${routeEntries.length} route(s)`);
+}
+async function main() {
+    if (!existsSync(PLUGINS_DIR)) {
+        mkdirSync(PLUGINS_DIR, { recursive: true });
+    }
+    console.log("Checking plugins/index.ts...");
+    scaffoldIndexFile();
+    await importPluginsFromIndex();
+    ensureGitignore();
+    console.log("Updating README.md...");
+    await updateReadme();
+    console.log("Generating lib/types/integration.ts...");
+    await generateTypesFile();
+    console.log("Generating lib/step-registry.ts...");
+    await generateStepRegistry();
+    console.log("Generating lib/output-display-configs.ts...");
+    await generateOutputDisplayConfigs();
+    console.log("\nProcessing step files for codegen templates...");
+    await processStepFilesForCodegen();
+    console.log("Generating lib/codegen-registry.ts...");
+    generateCodegenRegistry();
+    console.log("Generating lib/route-registry.ts...");
+    await generateRouteRegistry();
+    console.log("Done! Plugin registry updated.\n");
+}
+main().catch((error) => {
+    console.error("Error:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=discover-plugins.js.map