@sw-tsdk/plugin-connector 3.13.1 → 3.13.2-next.3dfd44a

package/lib/transformers/connector-generator.js

@@ -4,19 +4,261 @@ exports.ConnectorGenerator = void 0;
 const tslib_1 = require("tslib");
 const connector_interfaces_1 = require("@swimlane/connector-interfaces");
 const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
 const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
 const adm_zip_1 = tslib_1.__importDefault(require("adm-zip"));
+/**
+ * Map asset.json inputParameter type (numeric) to JSON Schema type.
+ * 1: text, 2: text area, 3: code, 4: password, 5: list, 6: number, 7: boolean
+ */
+function assetInputTypeToSchemaType(typeCode) {
+    switch (typeCode) {
+        case 5: {
+            return 'array';
+        }
+        case 6: {
+            return 'number';
+        }
+        case 7: {
+            return 'boolean';
+        }
+        default: {
+            return 'string';
+        }
+    }
+}
+/**
+ * Map applicationInfo field type (and selectionType for valuesList) to JSON Schema type.
+ * reference, attachment, list, multi-select, checkbox -> array
+ * text, single select -> string
+ * numeric -> number
+ */
+function applicationFieldTypeToSchemaType(field) {
+    const ft = (field.fieldType || '').toLowerCase();
+    if (ft === 'numeric')
+        return 'number';
+    if (ft === 'reference' || ft === 'attachment' || ft === 'list')
+        return 'array';
+    if (ft === 'valueslist') {
+        const st = (field.selectionType || '').toLowerCase();
+        return st === 'multi' ? 'array' : 'string';
+    }
+    if (ft === 'checkbox')
+        return 'array';
+    return 'string';
+}
+/**
+ * Packages that should be excluded from requirements.txt
+ * - Provided by the runtime (requests, swimlane)
+ * - Installed via other means (swimbundle_utils via compile.sh)
+ */
+const EXCLUDED_PACKAGES = new Set([
+    'requests',
+    'swimlane',
+    'swimbundle_utils',
+    'dominions',
+    'ssdeep',
+    'pymongo',
+    'poplib', // No viable package
+]);
+/** Packages that when excluded from requirements.txt should be installed via runner.sh (apt/pip). */
+const RUNNER_EXCLUDED_PACKAGES = new Set(['ssdeep']);
+/**
+ * Common import-module to PyPI package mapping.
+ * Import names do not always match the installable package name.
+ */
+const IMPORT_TO_PYPI_PACKAGE = new Map([
+    ['bs4', 'beautifulsoup4'],
+    ['cv2', 'opencv-python'],
+    ['crypto', 'pycryptodome'],
+    ['cryptodome', 'pycryptodome'],
+    ['dateutil', 'python_dateutil'],
+    ['dns', 'dnspython'],
+    ['fitz', 'pymupdf'],
+    ['googleapiclient', 'google-api-python-client'],
+    ['jwt', 'pyjwt'],
+    ['pil', 'pillow'],
+    ['sklearn', 'scikit-learn'],
+    ['yaml', 'pyyaml'],
+    ['magic', 'python_magic'],
+    ['mailparser', 'mail-parser'],
+    ['dateutil', 'python-dateutil'],
+    ['falconpy', 'crowdstrike-falconpy'],
+    ['azure', 'azure-storage-blob'],
+]);
+function resolvePypiPackageFromImport(importName) {
+    const normalizedImport = importName.trim().toLowerCase();
+    if (!normalizedImport)
+        return '';
+    return IMPORT_TO_PYPI_PACKAGE.get(normalizedImport) ?? normalizedImport;
+}
+/**
+ * Packages that should have their version constraints stripped.
+ * These packages commonly have compatibility issues when migrating from Python 3.7 to 3.11+
+ * because older pinned versions don't have wheels for newer Python versions.
+ * By stripping the version, pip can resolve a compatible version automatically.
+ *
+ * IMPORTANT: All package names MUST be lowercase since deduplicateRequirements()
+ * converts package names to lowercase before checking against this set.
+ */
+const PACKAGES_TO_STRIP_VERSION = new Set([
+    // Core scientific/data packages with C extensions
+    'numpy',
+    'scipy',
+    'pandas',
+    // Cryptography packages with C/Rust extensions
+    'cryptography',
+    'cffi',
+    'pycryptodome',
+    'pycryptodomex',
+    // NLP/ML packages (spacy ecosystem)
+    'spacy',
+    'thinc',
+    'blis',
+    'cymem',
+    'preshed',
+    'murmurhash',
+    'srsly',
+    // Other packages with C extensions or version-specific wheels
+    'regex',
+    'lxml',
+    'pillow',
+    'psycopg2',
+    'psycopg2-binary',
+    'grpcio',
+    'protobuf',
+    'pyzmq',
+    'greenlet',
+    'gevent',
+    'markupsafe',
+    'pyyaml',
+    'ruamel.yaml',
+    'msgpack',
+    'ujson',
+    'orjson',
+    // Packages that may have compatibility issues
+    'typed-ast',
+    'dataclasses',
+    'importlib-metadata',
+    'importlib_metadata',
+    'zipp',
+    'typing-extensions',
+    'typing_extensions',
+    'python_magic',
+    'pgpy',
+    'aiohttp',
+    'yarl',
+    'frozenlist',
+    'geoip2',
+    'extract_msg',
+    'click',
+    'ioc_finder',
+    'tzlocal',
+    'pydantic',
+    // Swimlane packages
+    'datetime_parser',
+    'email_master',
+    'sw_aqueduct',
+]);
 class ConnectorGenerator {
+    static truncateActionDescription(description) {
+        if (description.length <= this.ACTION_DESCRIPTION_MAX_LENGTH)
+            return description;
+        return description.slice(0, this.ACTION_DESCRIPTION_MAX_LENGTH);
+    }
+    /**
+     * For inputs with Type "record", resolve ValueType from applicationInfo.fields (field id = input.Value).
+     * Call after transform() so action YAML and temp_inputs get correct types.
+     */
+    static patchRecordInputTypes(transformationResult, applicationInfo) {
+        if (!applicationInfo?.fields?.length)
+            return;
+        const fieldById = new Map(applicationInfo.fields.filter(f => f.id).map(f => [f.id, f]));
+        for (const input of transformationResult.inputs) {
+            const typeRaw = input.Type ?? input.type;
+            if (String(typeRaw).toLowerCase() !== 'record')
+                continue;
+            const fieldId = input.Value ?? input.value;
+            if (typeof fieldId !== 'string')
+                continue;
+            const field = fieldById.get(fieldId);
+            if (field) {
+                input.ValueType = applicationFieldTypeToSchemaType(field);
+                if (input.ValueType === 'array') {
+                    input.arrayItemType = (field.fieldType || '').toLowerCase();
+                    input.arrayItemValueType = (field.inputType || '').toLowerCase();
+                }
+            }
+        }
+    }
+    /**
+     * For outputs that map to date fields (by Value = field id in applicationInfo), compute which keys need
+     * conversion to ISO8601 and the timetype/format for each. Sets transformationResult.outputDateConversions.
+     * Uses the application denoted by each output block's ApplicationId (same level as Mappings) when present,
+     * otherwise the current application (taskApplicationId).
+     * - DataFormat "Standard" -> no conversion.
+     * - DataFormat "Unix EPOCH" -> timetype = UnixEpochUnit (seconds or milliseconds).
+     * - DataFormat "custom" -> timetype = customDataFormat.
+     * - Otherwise -> timetype = DataFormat (treat as custom format string).
+     */
+    static patchOutputDateConversions(transformationResult, applicationInfoMap, currentApplicationId) {
+        transformationResult.outputDateConversions = [];
+        if (!applicationInfoMap || !transformationResult.outputs?.length)
+            return;
+        const keyToTimetype = new Map();
+        for (const output of transformationResult.outputs) {
+            const outputBlockAppId = output.ApplicationId ?? output.applicationId;
+            const appId = typeof outputBlockAppId === 'string' ? outputBlockAppId : transformationResult.taskApplicationId ?? currentApplicationId;
+            if (typeof appId !== 'string')
+                continue;
+            const applicationInfo = applicationInfoMap[appId];
+            if (!applicationInfo?.fields?.length)
+                continue;
+            const fieldById = new Map(applicationInfo.fields.filter((f) => f.id).map((f) => [f.id, f]));
+            const fieldId = output.Value ?? output.value;
+            if (typeof fieldId !== 'string')
+                continue;
+            const field = fieldById.get(fieldId);
+            const fieldType = (field?.fieldType ?? '').toLowerCase();
+            if (fieldType !== 'date')
+                continue;
+            const dataFormat = String(output.DataFormat ?? output.dataFormat ?? '').trim();
+            if (dataFormat === '' || dataFormat.toLowerCase() === 'standard')
+                continue;
+            let timetype;
+            if (dataFormat.toLowerCase() === 'unix epoch') {
+                timetype = String(output.UnixEpochUnit ?? output.unixEpochUnit ?? 'seconds').toLowerCase();
+            }
+            else if (dataFormat.toLowerCase() === 'custom') {
+                timetype = String(output.customDataFormat ?? output.CustomDataFormat ?? '').trim();
+                if (!timetype)
+                    continue;
+            }
+            else {
+                timetype = dataFormat;
+            }
+            const key = output.Key;
+            if (!keyToTimetype.has(key))
+                keyToTimetype.set(key, timetype);
+        }
+        transformationResult.outputDateConversions = [...keyToTimetype.entries()].map(([key, timetype]) => ({ key, timetype }));
+    }
+    /**
+     * Initializes a forked plugin (copy base code, requirements, asset).
+     * Returns the set of runner-excluded package names that were skipped (e.g. ssdeep) so runner.sh can be updated.
+     */
     static async initializeForkedPlugin(transformedExport, fromDirectory, toDirectory) {
         const { forkedName } = transformedExport;
         console.log(`Initializing forked plugin: ${forkedName}`);
+        const excludedRunnerPackages = await this.generateRequirements(fromDirectory, toDirectory, forkedName);
         await Promise.all([
             this.createBaseCode(fromDirectory, toDirectory, forkedName),
-            this.generateRequirements(fromDirectory, toDirectory, forkedName),
             this.generateAsset(fromDirectory, toDirectory, forkedName),
         ]);
         console.log(`Forked plugin initialized: ${forkedName}`);
+        return excludedRunnerPackages;
     }
     static async generateLogo(toDirectory) {
         const templatePath = (0, node_path_1.join)(__dirname, '../templates/migrator-runners/image.png');
@@ -26,13 +268,37 @@ class ConnectorGenerator {
     }
     static async generateBaseStructure(toDirectory) {
         await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'connector', 'config', 'actions'), { recursive: true });
-        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'image'));
-        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'docs'));
-        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'data'));
-        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'doc_images'));
-        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'connector', 'config', 'assets'));
-        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'connector', 'src'));
-        await this.createFile((0, node_path_1.join)(toDirectory, 'requirements.txt'), '');
+        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'image'), { recursive: true });
+        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'docs'), { recursive: true });
+        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'data'), { recursive: true });
+        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'doc_images'), { recursive: true });
+        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'connector', 'config', 'assets'), { recursive: true });
+        await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'connector', 'src'), { recursive: true });
+        // Write default requirements
+        const defaultRequirements = [
+            'cachetools>=4.2.4',
+            'certifi==2024.7.4',
+            'pendulum==3.0.0',
+            'pyjwt>=2.4.0',
+            'pyuri>=0.3,<0.4',
+            // 'requests[security]>=2,<3',
+            'six>=1.12.0',
+            'sortedcontainers==2.4.0',
+            'shortid==0.1.2',
+            'beautifulsoup4',
+            'pandas',
+        ].join('\n') + '\n';
+        await this.createFile((0, node_path_1.join)(toDirectory, 'requirements.txt'), defaultRequirements);
+        // Copy swimlane template to connector/swimlane
+        try {
+            const swimlaneTemplatePath = (0, node_path_1.join)(__dirname, '../templates/swimlane');
+            const swimlaneDestinationPath = (0, node_path_1.join)(toDirectory, 'connector', 'swimlane');
+            await this.copyDirectoryRecursive(swimlaneTemplatePath, swimlaneDestinationPath);
+        }
+        catch (error) {
+            console.error(`Error copying swimlane template: ${error}`);
+            // Continue even if swimlane template copy fails
+        }
         await this.createFile((0, node_path_1.join)(toDirectory, 'docs', 'CHANGELOG.md'), '');
         await this.createFile((0, node_path_1.join)(toDirectory, 'docs', 'README.md'), '# Example Readme');
         await this.createFile((0, node_path_1.join)(toDirectory, 'docs', 'EXTERNAL_README.md'), '# Example External Readme');
@@ -52,18 +318,25 @@ class ConnectorGenerator {
     }
     static async generateAction(transformedExport, toDirectory) {
         let content;
+        const outputDateConversions = transformedExport.outputDateConversions;
         if (transformedExport.type === 'script') {
-            content = transformedExport.error ? `Error: ${transformedExport.error}` : await this.getActionContentScript(transformedExport.script);
+            content = transformedExport.error ? `Error: ${transformedExport.error}` : await this.getActionContentScript(transformedExport.script, transformedExport.inputs, outputDateConversions);
         }
         else {
-            content = transformedExport.error ? `Error: ${transformedExport.error}` : await this.getActionContentFork(transformedExport.script);
+            content = transformedExport.error ? `Error: ${transformedExport.error}` : await this.getActionContentFork(transformedExport.script, transformedExport.inputs, outputDateConversions);
         }
+        content = this.replaceTaskExecuteRequestCall(content);
         const outputPath = (0, node_path_1.join)(toDirectory, 'connector', 'src', `${transformedExport.exportUid}.py`);
         await this.createFile(outputPath, content);
     }
     static async generateAsset(fromDirectory, toDirectory, packageName) {
         const assetPath = (0, node_path_1.join)(fromDirectory, 'packages', packageName, 'imports', 'asset.json');
-        const destinationPath = (0, node_path_1.join)(toDirectory, 'connector', 'config', 'assets', 'asset.yaml');
+        // Generate unique asset filename and name based on package name to avoid overwrites
+        // e.g., sw_google_gsuite -> google_gsuite_asset.yaml with name: google_gsuite_asset
+        const assetNameBase = packageName.replace(/^sw_/, '').toLowerCase();
+        const assetFileName = `${assetNameBase}_asset.yaml`;
+        const assetName = `${assetNameBase}_asset`;
+        const destinationPath = (0, node_path_1.join)(toDirectory, 'connector', 'config', 'assets', assetFileName);
         try {
             await node_fs_1.promises.access(assetPath);
             const assetContent = await node_fs_1.promises.readFile(assetPath, 'utf8');
@@ -72,17 +345,15 @@ class ConnectorGenerator {
             const requiredInputs = [];
             for (const [key, rawValue] of Object.entries(assetJson.inputParameters || {})) {
                 const value = rawValue;
+                const schemaType = assetInputTypeToSchemaType(value.type);
                 inputProperties[key] = {
                     title: value.name || key,
                     description: value.description || '',
-                    type: 'string',
+                    type: schemaType,
                 };
                 if (value.type === 4) {
                     inputProperties[key].format = 'password';
                 }
-                if (value.example !== undefined) {
-                    inputProperties[key].example = value.example;
-                }
                 if (value.default !== undefined) {
                     inputProperties[key].default = value.default;
                 }
@@ -90,22 +361,163 @@ class ConnectorGenerator {
                     requiredInputs.push(key);
                 }
             }
-            const assetYaml = js_yaml_1.default.dump({
+            const assetData = {
                 schema: 'asset/1',
-                name: 'asset',
-                title: assetJson.name,
-                description: assetJson.description,
+                name: assetName,
+                title: assetJson.name || 'Asset',
+                description: assetJson.description || '',
                 inputs: {
                     type: 'object',
                     properties: inputProperties,
                     required: requiredInputs.length > 0 ? requiredInputs : undefined,
                 },
                 meta: {},
-            });
-            await node_fs_1.promises.writeFile(destinationPath, assetYaml, 'utf8');
+            };
+            // Ensure title is always a non-empty string and truncate to 50 characters
+            if (!assetData.title || typeof assetData.title !== 'string' || assetData.title.trim() === '') {
+                assetData.title = 'Asset';
+            }
+            else {
+                assetData.title = assetData.title.trim();
+                if (assetData.title.length > 50) {
+                    assetData.title = assetData.title.slice(0, 50);
+                }
+            }
+            const assetYaml = js_yaml_1.default.dump(assetData, { lineWidth: -1, noRefs: true });
+            // Validate the YAML can be parsed back and has required fields
+            let parsed;
+            try {
+                parsed = js_yaml_1.default.load(assetYaml);
+                if (!parsed || !parsed.title) {
+                    throw new Error('Generated asset YAML is missing required title field');
+                }
+            }
+            catch (parseError) {
+                console.error(`Generated invalid asset YAML for ${packageName}:`, parseError);
+                console.error('Asset data:', JSON.stringify(assetData, null, 2));
+                throw new Error(`Failed to generate valid asset YAML for ${packageName}: ${parseError}`);
+            }
+            // Write atomically using a temporary file to prevent corruption
+            const dir = (0, node_path_1.join)(destinationPath, '..');
+            await node_fs_1.promises.mkdir(dir, { recursive: true });
+            // Write to a temporary file first, then rename (atomic operation)
+            const tempFile = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `${assetName}-${Date.now()}-${Math.random().toString(36).slice(7)}.yaml`);
+            try {
+                await node_fs_1.promises.writeFile(tempFile, assetYaml, 'utf8');
+                // Atomically move the temp file to the final location
+                await node_fs_1.promises.rename(tempFile, destinationPath);
+                console.log(`Generated asset file: ${assetFileName} (name: ${assetName}) for package: ${packageName}`);
+            }
+            catch (writeError) {
+                // Clean up temp file if it exists
+                await node_fs_1.promises.unlink(tempFile).catch(() => { });
+                throw writeError;
+            }
+        }
+        catch (error) {
+            console.error(`Error generating asset ${assetFileName} for ${packageName}:`, error);
+        }
+    }
+    /**
+     * Adds asset parameters from task input mappings to a separate input asset file.
+     * Creates input_asset.yaml to avoid overwriting existing asset.yaml from forked plugins.
+     */
+    static async addAssetParameters(toDirectory, assetParameters, applicationName) {
+        if (assetParameters.length === 0) {
+            return;
+        }
+        const destinationPath = (0, node_path_1.join)(toDirectory, 'connector', 'config', 'assets', 'input_asset.yaml');
+        try {
+            // Create title and truncate to 50 characters
+            const fullTitle = applicationName ? `${applicationName} Key Store` : 'Input Asset';
+            const assetTitle = fullTitle.length > 50 ? fullTitle.slice(0, 50) : fullTitle;
+            let assetData = {
+                schema: 'asset/1',
+                name: 'input_asset',
+                title: assetTitle,
+                description: '',
+                inputs: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+                meta: {},
+            };
+            // Try to read existing input_asset.yaml (in case we're adding more parameters)
+            try {
+                const existingContent = await node_fs_1.promises.readFile(destinationPath, 'utf8');
+                assetData = js_yaml_1.default.load(existingContent);
+                // Update title if application name is provided and truncate to 50 characters
+                if (applicationName) {
+                    assetData.title = assetTitle;
+                }
+                else if (!assetData.title || assetData.title.trim() === '') {
+                    assetData.title = 'Input Asset';
+                }
+                else {
+                    // Ensure existing title is also truncated
+                    assetData.title = assetData.title.trim();
+                    if (assetData.title.length > 50) {
+                        assetData.title = assetData.title.slice(0, 50);
+                    }
+                }
+                // Ensure structure exists
+                if (!assetData.inputs) {
+                    assetData.inputs = { type: 'object', properties: {}, required: [] };
+                }
+                if (!assetData.inputs.properties) {
+                    assetData.inputs.properties = {};
+                }
+                if (!assetData.inputs.required) {
+                    assetData.inputs.required = [];
+                }
+            }
+            catch {
+                // Asset doesn't exist, use default structure
+                // Ensure directory exists
+                await node_fs_1.promises.mkdir((0, node_path_1.join)(toDirectory, 'connector', 'config', 'assets'), { recursive: true });
+            }
+            // Add asset parameters from tasks
+            for (const param of assetParameters) {
+                const key = param.Key;
+                if (!assetData.inputs.properties[key]) {
+                    assetData.inputs.properties[key] = {
+                        title: key,
+                        type: 'string',
+                    };
+                    // If it's a credentials type, mark as password format
+                    if (param.Type === 'credentials' || param.Type === 'asset') {
+                        assetData.inputs.properties[key].format = 'password';
+                    }
+                    // Add example if provided
+                    if (param.Example !== undefined && param.Example !== null) {
+                        assetData.inputs.properties[key].examples = Array.isArray(param.Example) ? param.Example : [param.Example];
+                    }
+                }
+            }
+            // Title is already set above, just ensure it's truncated if needed
+            if (assetData.title && assetData.title.length > 50) {
+                assetData.title = assetData.title.slice(0, 50);
+            }
+            // Write atomically using a temporary file to prevent corruption
+            const dir = (0, node_path_1.join)(destinationPath, '..');
+            await node_fs_1.promises.mkdir(dir, { recursive: true });
+            const assetYaml = js_yaml_1.default.dump(assetData, { lineWidth: -1, noRefs: true });
+            // Write to a temporary file first, then rename (atomic operation)
+            const tempFile = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `input_asset-${Date.now()}-${Math.random().toString(36).slice(7)}.yaml`);
+            try {
+                await node_fs_1.promises.writeFile(tempFile, assetYaml, 'utf8');
+                // Atomically move the temp file to the final location
+                await node_fs_1.promises.rename(tempFile, destinationPath);
+            }
+            catch (writeError) {
+                // Clean up temp file if it exists
+                await node_fs_1.promises.unlink(tempFile).catch(() => { });
+                throw writeError;
+            }
         }
         catch (error) {
-            console.error(`Error generating asset for ${packageName}:`, error);
+            console.error('Error adding asset parameters:', error);
         }
     }
     static async extractZip(fromDirectory, packageName) {
@@ -124,7 +536,254 @@ class ConnectorGenerator {
             return null;
         }
     }
+    static async addExtractedImportsToRequirements(toDirectory, taskImports) {
+        const requirementsPath = (0, node_path_1.join)(toDirectory, 'requirements.txt');
+        if (taskImports.size === 0) {
+            return;
+        }
+        try {
+            // Filter out standard library modules that don't need to be in requirements.txt
+            const standardLibraryModules = new Set([
+                'smtplib',
+                'textwrap',
+                'mimetypes',
+                'hmac',
+                'hashlib',
+                'json',
+                'os',
+                'sys',
+                'time',
+                'datetime',
+                're',
+                'math',
+                'random',
+                'string',
+                'collections',
+                'itertools',
+                'functools',
+                'operator',
+                'copy',
+                'pickle',
+                'base64',
+                'hashlib',
+                'urllib',
+                'http',
+                'email',
+                'csv',
+                'xml',
+                'html',
+                'logging',
+                'threading',
+                'multiprocessing',
+                'subprocess',
+                'socket',
+                'ssl',
+                'pathlib',
+                'shutil',
+                'tempfile',
+                'io',
+                'codecs',
+                'unicodedata',
+                'struct',
+                'array',
+                'queue',
+                'heapq',
+                'bisect',
+                'weakref',
+                'types',
+                'inspect',
+                'traceback',
+                'warnings',
+                'contextlib',
+                'abc',
+                'atexit',
+                'gc',
+                'locale',
+                'gettext',
+                'argparse',
+                'configparser',
+                'fileinput',
+                'glob',
+                'fnmatch',
+                'linecache',
+                'stat',
+                'errno',
+                'ctypes',
+                'mmap',
+                'select',
+                'signal',
+                'pwd',
+                'grp',
+                'termios',
+                'tty',
+                'pty',
+                'fcntl',
+                'resource',
+                'syslog',
+                'platform',
+                'pipes',
+                'sched',
+                'asyncio',
+                'concurrent',
+                'dbm',
+                'sqlite3',
+                'zlib',
+                'gzip',
+                'bz2',
+                'lzma',
+                'zipfile',
+                'tarfile',
+                'shlex',
+                'readline',
+                'rlcompleter',
+                'cmd',
+                'doctest',
+                'unittest',
+                'pdb',
+                'profile',
+                'pstats',
+                'timeit',
+                'trace',
+                'cgitb',
+                'pydoc',
+                'dis',
+                'pickletools',
+                'formatter',
+                'msilib',
+                'msvcrt',
+                'nt',
+                'ntpath',
+                'nturl2path',
+                'winreg',
+                'winsound',
+                'posix',
+                'posixpath',
+                'pwd',
+                'spwd',
+                'grp',
+                'crypt',
+                'termios',
+                'tty',
+                'pty',
+                'fcntl',
+                'pipes',
+                'resource',
+                'nis',
+                'syslog',
+                'optparse',
+                'imp',
+                'importlib',
+                'keyword',
+                'parser',
+                'ast',
+                'symtable',
+                'symbol',
+                'token',
+                'tokenize',
+                'tabnanny',
+                'py_compile',
+                'compileall',
+                'pyclbr',
+                'bdb',
+                'pdb',
+                'profile',
+                'pstats',
+                'timeit',
+                'trace',
+                'cgitb',
+                'pydoc',
+                'doctest',
+                'unittest',
+                'test',
+                'lib2to3',
+                'distutils',
+                'ensurepip',
+                'venv',
+                'wsgiref',
+                'html',
+                'http',
+                'urllib',
+                'xmlrpc',
+                'ipaddress',
+                'secrets',
+                'statistics',
+                'pathlib',
+                'enum',
+                'numbers',
+                'fractions',
+                'decimal',
+                'cmath',
+                'array',
+                'memoryview',
+                'collections',
+                'heapq',
+                'bisect',
+                'array',
+                'weakref',
+                'types',
+                'copy',
+                'pprint',
+                'reprlib',
+                'dataclasses',
+                'dataclasses_json',
+                'typing',
+                'typing_extensions',
+                'backports',
+                'builtins',
+                '__builtin__',
+                '__future__',
+            ]);
+            // Filter out standard library, excluded packages, and already included packages
+            const importsToAdd = [...new Set([...taskImports]
+                    .map(importName => resolvePypiPackageFromImport(importName)))]
+                .filter(packageName => {
+                if (!packageName)
+                    return false;
+                // Skip standard library modules
+                if (standardLibraryModules.has(packageName)) {
+                    return false;
+                }
+                // Skip excluded packages (provided by runtime or installed via other means)
+                if (EXCLUDED_PACKAGES.has(packageName)) {
+                    return false;
+                }
+                // Skip if it's already in requirements (we'll check this by reading the file)
+                return true;
+            })
+                .filter(Boolean);
+            if (importsToAdd.length === 0) {
+                return;
+            }
+            // Read existing requirements to avoid duplicates
+            let existingRequirements = '';
+            try {
+                existingRequirements = await node_fs_1.promises.readFile(requirementsPath, 'utf8');
+            }
+            catch {
+                // File might not exist yet, that's okay
+            }
+            const existingPackages = new Set(existingRequirements
+                .split('\n')
+                .map(line => line.trim().split(/[!<=>]/)[0].toLowerCase())
+                .filter(Boolean));
+            // Add imports that aren't already in requirements.txt
+            const newPackages = importsToAdd
+                .filter(packageName => !existingPackages.has(packageName));
+            if (newPackages.length > 0) {
+                await node_fs_1.promises.appendFile(requirementsPath, newPackages.join('\n') + '\n');
+                console.log(`Added ${newPackages.length} extracted import(s) to requirements.txt`);
+            }
+        }
+        catch (error) {
+            console.error('Error adding extracted imports to requirements.txt:', error);
+        }
+    }
+    /**
+     * Appends forked plugin dependencies to requirements.txt.
+     * Returns the set of package names that were excluded but need runner.sh (e.g. ssdeep).
+     */
     static async generateRequirements(fromDirectory, toDirectory, packageName) {
+        const excludedRunner = new Set();
         const packageExtractedDir = (0, node_path_1.join)(fromDirectory, 'packages', packageName);
         const requirementsPath = (0, node_path_1.join)(toDirectory, 'requirements.txt');
         try {
@@ -132,7 +791,7 @@ class ConnectorGenerator {
             const whlFiles = files.filter(file => file.endsWith('.whl'));
             if (whlFiles.length === 0) {
                 console.warn(`No .whl files found in ${packageExtractedDir}`);
-                return;
+                return excludedRunner;
             }
             const dependencies = whlFiles
                 .map(whlFile => {
@@ -145,14 +804,253 @@ class ConnectorGenerator {
                 if (packageNameFromWhl === packageName) {
                     return null;
                 }
+                // Skip excluded packages (provided by runtime or installed via other means)
+                if (EXCLUDED_PACKAGES.has(packageNameFromWhl.toLowerCase())) {
+                    if (RUNNER_EXCLUDED_PACKAGES.has(packageNameFromWhl.toLowerCase())) {
+                        excludedRunner.add(packageNameFromWhl.toLowerCase());
+                    }
+                    return null;
+                }
                 return `${packageNameFromWhl}==${packageVersion}`;
             })
                 .filter(Boolean);
             await node_fs_1.promises.appendFile(requirementsPath, dependencies.join('\n') + '\n');
             console.log(`requirements.txt generated at: ${requirementsPath}`);
+            return excludedRunner;
         }
         catch (error) {
             console.error('Error generating requirements.txt:', error);
+            return excludedRunner;
+        }
+    }
+    /**
+     * Resolves version conflicts by taking the highest version requirement.
+     * Handles common cases like ==, >=, <=, >, < constraints.
+     */
+    static resolveVersionConflict(packageName, requirements) {
+        if (requirements.length === 1) {
+            return requirements[0];
+        }
+        const versionInfo = requirements.map(req => {
+            // Match version specifiers: ==2.0, >=2.0, <=2.0, >2.0, <2.0, ~=2.0
+            const match = req.match(/([!<=>~]+)\s*([\d.]+(?:[\dA-Za-z]*)?)/);
+            if (!match) {
+                return { req, operator: null, version: null, versionParts: null };
+            }
+            const operator = match[1];
+            const versionStr = match[2];
+            // Parse version into parts for comparison
+            const versionParts = versionStr.split('.').map(part => {
+                const numMatch = part.match(/^(\d+)/);
+                return numMatch ? Number.parseInt(numMatch[1], 10) : 0;
+            });
+            return { req, operator, version: versionStr, versionParts };
+        });
+        // Filter out requirements without version info
+        const withVersions = versionInfo.filter((v) => v.version !== null && v.operator !== null && v.versionParts !== null);
+        if (withVersions.length === 0) {
+            // No version info, return first
+            console.warn(`Multiple requirements for ${packageName} without version info: ${requirements.join(', ')}. Using: ${requirements[0]}`);
+            return requirements[0];
+        }
+        // Find the highest version
+        let highest = withVersions[0];
+        for (let i = 1; i < withVersions.length; i++) {
+            const current = withVersions[i];
+            // Compare versions
+            const comparison = this.compareVersions(current.versionParts, highest.versionParts);
+            if (comparison > 0) {
+                // Current is higher
+                highest = current;
+            }
+            else if (comparison === 0) {
+                // Same version, prefer == over >= or other operators
+                if (current.operator === '==' && highest.operator !== '==') {
+                    highest = current;
+                }
+                else if (current.operator === '>=' && highest.operator === '>=') {
+                    // Both are >= with same version, keep current (they're equivalent)
+                    // No change needed
+                }
+            }
+        }
+        // Log if we're resolving a conflict
+        if (withVersions.length > 1) {
+            const allReqs = requirements.join(', ');
+            console.log(`Resolved version conflict for ${packageName}: ${allReqs} -> ${highest.req}`);
+        }
+        return highest.req;
+    }
+    /**
+     * Compares two version arrays (e.g., [2, 5, 0] vs [2, 4, 1]).
+     * Returns: positive if v1 > v2, negative if v1 < v2, 0 if equal.
+     */
+    static compareVersions(v1, v2) {
+        const maxLength = Math.max(v1.length, v2.length);
+        for (let i = 0; i < maxLength; i++) {
+            const part1 = v1[i] || 0;
+            const part2 = v2[i] || 0;
+            if (part1 > part2)
+                return 1;
+            if (part1 < part2)
+                return -1;
+        }
+        return 0;
+    }
+    /**
+     * Deduplicates requirements.txt and resolves version conflicts.
+     * When multiple versions of the same package are specified, keeps the highest version.
+     */
+    static async deduplicateRequirements(toDirectory) {
+        const requirementsPath = (0, node_path_1.join)(toDirectory, 'requirements.txt');
+        try {
+            let content = '';
+            try {
+                content = await node_fs_1.promises.readFile(requirementsPath, 'utf8');
+            }
+            catch {
+                // File might not exist, nothing to deduplicate
+                return;
+            }
+            const lines = content
+                .split('\n')
+                .map(line => line.trim())
+                .filter(line => line && !line.startsWith('#'));
+            if (lines.length === 0) {
+                return;
+            }
+            // Parse requirements into a map: packageName -> requirements[]
+            const requirementsMap = new Map();
+            for (const line of lines) {
+                // Extract package name (everything before version specifiers like ==, >=, <=, >, <, !=)
+                // Handle packages with extras like requests[security]>=2.0
+                const packageMatch = line.match(/^([\w[\]-]+?)(?:\s*[!<=>]|$)/);
+                if (!packageMatch)
+                    continue;
+                // Extract base package name (remove extras like [security])
+                const fullPackageName = packageMatch[1];
+                const basePackageName = fullPackageName.split('[')[0].toLowerCase();
+                const requirement = line.trim();
+                if (!requirementsMap.has(basePackageName)) {
+                    requirementsMap.set(basePackageName, []);
+                }
+                requirementsMap.get(basePackageName).push(requirement);
+            }
+            // Deduplicate and resolve conflicts
+            const deduplicated = [];
+            const strippedPackages = [];
+            for (const [packageName, reqs] of requirementsMap.entries()) {
+                // Skip excluded packages (provided by runtime or installed via other means)
+                if (EXCLUDED_PACKAGES.has(packageName)) {
+                    continue;
+                }
+                // Strip version for packages known to have Python 3.11+ compatibility issues
+                if (PACKAGES_TO_STRIP_VERSION.has(packageName)) {
+                    // Extract the package name with extras (e.g., requests[security] -> requests[security])
+                    const reqWithExtras = reqs[0].match(/^([\w-]+(?:\[[^\]]+])?)/);
+                    const packageWithExtras = reqWithExtras ? reqWithExtras[1] : packageName;
+                    deduplicated.push(packageWithExtras);
+                    strippedPackages.push(packageName);
+                    continue;
+                }
+                if (reqs.length === 1) {
+                    // Single requirement, use it as-is
+                    deduplicated.push(reqs[0]);
+                }
+                else {
+                    // Multiple requirements for same package - need to resolve
+                    const uniqueReqs = [...new Set(reqs)];
+                    if (uniqueReqs.length === 1) {
+                        // All are identical, use one
+                        deduplicated.push(uniqueReqs[0]);
+                    }
+                    else {
+                        // Different versions/constraints - resolve by taking the higher version
+                        const resolved = this.resolveVersionConflict(packageName, uniqueReqs);
+                        deduplicated.push(resolved);
+                    }
+                }
+            }
+            // Log stripped packages
+            if (strippedPackages.length > 0) {
+                console.log(`Stripped version constraints for Python 3.11+ compatibility: ${strippedPackages.join(', ')}`);
+            }
+            // Ensure datetime_parser is set to version 1.1.0 if present
+            const datetimeParserIndex = deduplicated.findIndex(req => {
+                const packageName = req.trim().split(/[!<=>]/)[0].toLowerCase();
+                return packageName === 'datetime_parser';
+            });
+            if (datetimeParserIndex !== -1) {
+                deduplicated[datetimeParserIndex] = 'datetime_parser==1.1.0';
+            }
+            // Ensure pyflattener is set to version 1.1.0 if present
+            const pyflattenerIndex = deduplicated.findIndex(req => {
+                const packageName = req.trim().split(/[!<=>]/)[0].toLowerCase();
+                return packageName === 'pyflattener';
+            });
+            if (pyflattenerIndex !== -1) {
+                deduplicated[pyflattenerIndex] = 'pyflattener==1.1.0';
+            }
+            // Sort alphabetically for consistency
+            deduplicated.sort();
+            // Write back the deduplicated requirements
+            const deduplicatedContent = deduplicated.join('\n') + '\n';
+            await node_fs_1.promises.writeFile(requirementsPath, deduplicatedContent, 'utf8');
+            const removedCount = lines.length - deduplicated.length;
+            if (removedCount > 0) {
+                console.log(`Deduplicated requirements.txt: removed ${removedCount} duplicate(s)`);
+            }
+        }
+        catch (error) {
+            console.error('Error deduplicating requirements.txt:', error);
+        }
+    }
+    /**
+     * Creates compile.sh in the connector root if swimbundle_utils was found in requirements.
+     * This handles the special case where swimbundle_utils needs to be installed separately.
+     */
+    static async generateCompileScript(toDirectory) {
+        const compileScriptPath = (0, node_path_1.join)(toDirectory, 'compile.sh');
+        try {
+            // Always create compile.sh (it's safe to have even if swimbundle_utils wasn't in requirements)
+            const compileScriptContent = 'pip install --user swimbundle_utils==4.8.0 dominions --no-deps\n';
+            await node_fs_1.promises.writeFile(compileScriptPath, compileScriptContent, 'utf8');
+            // Make it executable
+            await node_fs_1.promises.chmod(compileScriptPath, 0o755);
+        }
+        catch (error) {
+            console.error('Error generating compile.sh:', error);
+        }
+    }
+    /**
+     * Creates runner.sh in the connector root with apt/pip installs for optional system deps:
+     * - wkhtmltopdf when connector uses sw_swimlane_email
+     * - ssdeep (apt + pip install --user) when needsSsdeep (e.g. from task imports; ssdeep is excluded from requirements.txt)
+     */
+    static async generateRunnerScript(toDirectory, usesSwimlaneEmail, needsSsdeep) {
+        const runnerPath = (0, node_path_1.join)(toDirectory, 'runner.sh');
+        const parts = [];
+        if (usesSwimlaneEmail || needsSsdeep) {
+            parts.push('apt update -y\n');
+            const installs = [];
+            if (usesSwimlaneEmail)
+                installs.push('wkhtmltopdf');
+            if (needsSsdeep)
+                installs.push('ssdeep', 'libfuzzy-dev', 'gcc');
+            if (installs.length > 0)
+                parts.push(`apt install -y ${installs.join(' ')}\n`);
+        }
+        if (needsSsdeep)
+            parts.push('pip install ssdeep --user\n');
+        if (parts.length === 0)
+            return;
+        try {
+            const scriptContent = parts.join('');
+            await node_fs_1.promises.writeFile(runnerPath, scriptContent, 'utf8');
+            await node_fs_1.promises.chmod(runnerPath, 0o755);
+        }
+        catch (error) {
+            console.error('Error generating runner.sh:', error);
         }
     }
     static async createBaseCode(fromDirectory, toDirectory, packageName) {
@@ -173,17 +1071,67 @@ class ConnectorGenerator {
                 console.error(`Could not find base package folder inside: ${whlPath}`);
                 return;
             }
-            const destinationPath = (0, node_path_1.join)(toDirectory, 'connector', 'src', packageName);
+            const destinationPath = (0, node_path_1.join)(toDirectory, 'connector', packageName);
             await node_fs_1.promises.mkdir(destinationPath, { recursive: true });
             const baseCodePath = (0, node_path_1.join)(tempExtractDir, basePackageDir);
             const baseFiles = await node_fs_1.promises.readdir(baseCodePath);
-            await Promise.all(baseFiles.map(file => node_fs_1.promises.rename((0, node_path_1.join)(baseCodePath, file), (0, node_path_1.join)(destinationPath, file))));
-            console.log(`Base code for ${packageName} moved successfully.`);
+            await Promise.all(baseFiles.map(async (file) => {
+                const sourcePath = (0, node_path_1.join)(baseCodePath, file);
+                const destPath = (0, node_path_1.join)(destinationPath, file);
+                const stat = await node_fs_1.promises.stat(sourcePath);
+                // Copy directory recursively or copy file
+                await (stat.isDirectory() ?
+                    this.copyDirectoryRecursive(sourcePath, destPath) :
+                    (0, promises_1.copyFile)(sourcePath, destPath));
+            }));
+            if (packageName === 'sw_swimlane_email') {
+                await this.patchSwimlaneEmailInit((0, node_path_1.join)(destinationPath, '__init__.py'));
+            }
+            console.log(`Base code for ${packageName} copied successfully.`);
+        }
+        catch (error) {
+            console.error(`Error extracting and copying base code for ${packageName}:`, error);
+        }
+    }
+    /**
+     * Patch sw_swimlane_email __init__.py execute() to use system wkhtmltoimage and Config instead of pkg_resources/chmod.
+     * Matches the block after "def execute(self):" containing:
+     *   f = pkg_resources.resource_filename(__name__, "__packages/wkhtmltoimage")  # ...
+     *   c = Config(f)
+     *   st = os.stat(f)
+     *   os.chmod(f, st.st_mode | stat.S_IEXEC)  # ...
+     */
+    static async patchSwimlaneEmailInit(initPath) {
+        try {
+            await node_fs_1.promises.access(initPath);
+            const content = await node_fs_1.promises.readFile(initPath, 'utf8');
+            const oldPattern = /(\s+def execute\(self\):)\s*\n\s+f = pkg_resources\.resource_filename\(__name__, ["']__packages\/wkhtmltoimage["']\)[^\n]*\n\s+c = Config\(f\)\s*\n\s+st = os\.stat\(f\)\s*\n\s+os\.chmod\(f, st\.st_mode \| stat\.S_IEXEC\)[^\n]*/m;
+            const newBody = `$1
+        path_wkhtmltoimage = '/usr/bin/wkhtmltoimage'
+        c = Config(wkhtmltoimage=path_wkhtmltoimage)`;
+            const newContent = content.replace(oldPattern, newBody);
+            if (newContent !== content) {
+                await node_fs_1.promises.writeFile(initPath, newContent, 'utf8');
+                console.log('Patched sw_swimlane_email __init__.py execute() for wkhtmltoimage/Config');
+            }
         }
         catch (error) {
-            console.error(`Error extracting and moving base code for ${packageName}:`, error);
+            console.error(`Error patching sw_swimlane_email __init__.py: ${initPath}`, error);
         }
     }
+    static async copyDirectoryRecursive(sourceDir, destDir) {
+        await node_fs_1.promises.mkdir(destDir, { recursive: true });
+        const entries = await node_fs_1.promises.readdir(sourceDir, { withFileTypes: true });
+        await Promise.all(entries.map(async (entry) => {
+            // Skip __pycache__ directories
+            if (entry.name === '__pycache__') {
+                return;
+            }
+            const sourcePath = (0, node_path_1.join)(sourceDir, entry.name);
+            const destPath = (0, node_path_1.join)(destDir, entry.name);
+            await (entry.isDirectory() ? this.copyDirectoryRecursive(sourcePath, destPath) : (0, promises_1.copyFile)(sourcePath, destPath));
+        }));
+    }
     static async getBaseCodePath(fromDirectory, packageName) {
         const packageDir = (0, node_path_1.join)(fromDirectory, 'packages', packageName);
         try {
@@ -200,23 +1148,111 @@ class ConnectorGenerator {
             return null;
         }
     }
-    static async getActionContentFork(script) {
+    /**
+     * Build Python snippet to rebuild inputs from YAML-defined keys (empty per type) then merge asset then inputs.
+     * Only includes keys where the task InputMapping has an associated Type and Value.
+     * Placeholder # INPUTS_MERGE_HERE in templates is replaced with this.
+     * @param includeAttachmentBlock - when true (script_override only), include attachment conversion and dict handling; when false (plugin_override), only temp_inputs merge.
+     */
+    static defaultPyValue(valueType) {
+        switch (valueType) {
+            case 'number':
+            case 'integer': {
+                return 'None';
+            }
+            case 'boolean': {
+                return 'False';
+            }
+            case 'array': {
+                return '[]';
+            }
+            default: {
+                return "''";
+            }
+        }
+    }
+    static buildInputsMergeSnippet(inputs, includeAttachmentBlock) {
+        const withTypeAndValue = inputs.filter(inp => inp.Type !== null && inp.Type !== undefined &&
+            inp.Value !== null && inp.Value !== undefined);
+        const entries = [];
+        for (const inp of withTypeAndValue) {
+            entries.push(`${JSON.stringify(inp.Key)}: ${this.defaultPyValue(inp.ValueType)}`);
+        }
+        const dictLiteral = entries.length > 0 ? `{${entries.join(', ')}}` : '{}';
+        const i = '        ';
+        // First line has no leading indent: template already has 8 spaces before # INPUTS_MERGE_HERE
+        const baseMerge = includeAttachmentBlock ?
+            `temp_inputs = ${dictLiteral}\n${i}temp_inputs.update(self.asset)\n` :
+            `temp_inputs = ${dictLiteral}\n`;
+        // if (!includeAttachmentBlock) {
+        //  return `${baseMerge}${i}temp_inputs.update(inputs)\n${i}inputs = temp_inputs`
+        // }
+        const i2 = '            ';
+        const i3 = '                ';
+        const i4 = '                    ';
+        const attachmentBlock = [
+            `${i}attachments = {}`,
+            `${i}files = inputs.pop('files', [])`,
+            `${i}import base64`,
+            `${i}def find_and_convert_attachments(filename, files):`,
+            `${i2}for file in files:`,
+            `${i3}if isinstance(file, (list, tuple)):`,
+            `${i3}    current_filename, file_obj = file`,
+            `${i3}    if current_filename == filename:`,
+            `${i3}        files.remove(file)`,
+            `${i3}        return {'filename': current_filename, 'base64': base64.b64encode(file_obj.read()).decode()}`,
+            `${i}for field in inputs:`,
+            `${i2}if type(inputs[field]) is list:`,
+            `${i3}updated_value = [find_and_convert_attachments(i['file_name'], files) for i in inputs[field] if 'file' in i and 'file_name' in i]`,
+            `${i3}if updated_value:`,
+            `${i4}attachments[field] = updated_value`,
+            `${i2}if type(inputs[field]) is dict:`,
+            `${i3}# this is actually a conversion for user inputs, but we'll take the oppt to fix it here`,
+            `${i3}if 'id' in inputs[field] and 'name' in inputs[field]:`,
+            `${i4}attachments[field] = inputs[field]['name']`,
+            `${i}inputs.update(attachments)`,
+            '',
+            `${i}temp_inputs.update(inputs)`,
+            `${i}inputs = temp_inputs`,
+        ].join('\n');
+        return `${baseMerge}\n${attachmentBlock}`;
+    }
+    static replaceTaskExecuteRequestCall(content) {
+        return content.replaceAll(this.TASK_EXECUTE_REQUEST_CALL, this.TASK_EXECUTE_WEBHOOK_CALL);
+    }
+    /** Build Python dict literal for OUTPUT_DATE_CONVERSIONS (key -> timetype/format). */
+    static buildOutputDateConversionsDict(conversions) {
+        if (!conversions?.length)
+            return '{}';
+        const obj = {};
+        for (const { key, timetype } of conversions)
+            obj[key] = timetype;
+        return JSON.stringify(obj);
+    }
+    static async getActionContentFork(script, inputs, outputDateConversions) {
         try {
-            const templateContent = await node_fs_1.promises.readFile((0, node_path_1.join)(__dirname, '../templates/migrator-runners/plugin_override.txt'), 'utf8');
+            let templateContent = await node_fs_1.promises.readFile((0, node_path_1.join)(__dirname, '../templates/migrator-runners/plugin_override.txt'), 'utf8');
             // Remove any carriage returns to avoid CRLF issues
             const scriptNoCR = script.replaceAll('\r', '');
-            return templateContent.replace('# HERE', scriptNoCR);
+            const inputsMergeSnippet = this.buildInputsMergeSnippet(inputs, false);
+            templateContent = templateContent.replace(this.INPUTS_MERGE_PLACEHOLDER, inputsMergeSnippet);
+            templateContent = templateContent.replace(this.OUTPUT_DATE_CONVERSIONS_PLACEHOLDER, this.buildOutputDateConversionsDict(outputDateConversions));
+            // Use function replacer so `$` sequences in Python code stay literal.
+            return templateContent.replace('# HERE', () => scriptNoCR);
         }
         catch (error) {
             console.error('Failed to load action forked template', error);
             return `Error during forked plugin generation: ${error}`;
         }
     }
-    static async getActionContentScript(script) {
+    static async getActionContentScript(script, inputs, outputDateConversions) {
         try {
-            const templateContent = await node_fs_1.promises.readFile((0, node_path_1.join)(__dirname, '../templates/migrator-runners/script_override.txt'), 'utf8');
+            let templateContent = await node_fs_1.promises.readFile((0, node_path_1.join)(__dirname, '../templates/migrator-runners/script_override.txt'), 'utf8');
             // Remove any carriage returns to avoid CRLF issues
             const scriptNoCR = script.replaceAll('\r', '');
+            const inputsMergeSnippet = this.buildInputsMergeSnippet(inputs, true);
+            templateContent = templateContent.replace(this.INPUTS_MERGE_PLACEHOLDER, inputsMergeSnippet);
+            templateContent = templateContent.replace(this.OUTPUT_DATE_CONVERSIONS_PLACEHOLDER, this.buildOutputDateConversionsDict(outputDateConversions));
             const lines = scriptNoCR.split('\n');
             if (lines.length === 0) {
                 return templateContent.replace('# HERE', '');
@@ -228,7 +1264,8 @@ class ConnectorGenerator {
             const combinedScript = subsequentIndented ?
                 `${firstLine}\n${subsequentIndented}` :
                 firstLine;
-            return templateContent.replace('# HERE', combinedScript);
+            // Use function replacer so `$` sequences in Python code stay literal.
+            return templateContent.replace('# HERE', () => combinedScript);
         }
         catch (error) {
             console.error('Failed to load action script template', error);
@@ -238,20 +1275,59 @@ class ConnectorGenerator {
     static async generateActionConfig(transformationResult, toDirectory) {
         const exportUid = transformationResult.exportUid;
         const outputPath = (0, node_path_1.join)(toDirectory, 'connector', 'config', 'actions', `${exportUid}.yaml`);
+        // Format description with task ID prepended if available
+        const description = transformationResult.taskId ?
+            `${transformationResult.taskId} - ${transformationResult.description || ''}` :
+            transformationResult.description || '';
+        const truncatedDescription = this.truncateActionDescription(description);
         const yamlData = {
             schema: 'action/1',
             title: transformationResult.exportName,
             name: transformationResult.exportUid,
-            description: transformationResult.description,
+            description: truncatedDescription,
             inputs: {
                 type: 'object',
-                properties: {},
+                properties: {
+                    ApplicationId: {
+                        title: 'Application ID',
+                        type: 'string',
+                    },
+                    RecordId: {
+                        title: 'Record ID',
+                        type: 'string',
+                    },
+                    SwimlaneUrl: {
+                        title: 'Swimlane URL',
+                        type: 'string',
+                    },
+                    TurbineAccountId: {
+                        title: 'Turbine Account ID',
+                        type: 'string',
+                    },
+                    TurbineTenantId: {
+                        title: 'Turbine Tenant ID',
+                        type: 'string',
+                    },
+                    ExecuteTaskWebhookUrl: {
+                        title: 'Execute Task Webhook URL',
+                        type: 'string',
+                    },
+                },
                 required: [],
                 additionalProperties: true,
             },
             output: {
                 type: 'object',
-                properties: {},
+                properties: {
+                    output: {
+                        title: 'Output',
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {},
+                        },
+                    },
+                },
                 required: [],
                 additionalProperties: true,
             },
@@ -260,39 +1336,141 @@ class ConnectorGenerator {
                 method: '',
             },
         };
+        // Only add regular inputs (exclude credentials and asset types which go to asset.yaml)
         for (const input of transformationResult.inputs) {
-            yamlData.inputs.properties[input.Key] = {
+            const inputType = input.ValueType || 'string';
+            const inputProperty = {
                 title: input.Title || input.Key,
-                type: input.ValueType || 'string',
-                examples: input.Example,
+                type: inputType,
             };
+            if (inputType === 'array') {
+                const arrayItemType = input.arrayItemType;
+                const arrayItemValueType = input.arrayItemValueType;
+                switch (arrayItemType) {
+                    case 'attachment': {
+                        inputProperty.items = {
+                            contentDisposition: 'attachment',
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                file: {
+                                    type: 'string',
+                                    format: 'binary',
+                                },
+                                // eslint-disable-next-line camelcase
+                                file_name: {
+                                    type: 'string',
+                                },
+                            },
+                        };
+                        break;
+                    }
+                    case 'reference': {
+                        inputProperty.items = {
+                            type: 'object',
+                            required: [],
+                        };
+                        break;
+                    }
+                    case 'list': {
+                        inputProperty.items = {
+                            type: arrayItemValueType === 'numeric' ? 'number' : 'string',
+                        };
+                        break;
+                    }
+                    default: {
+                        // valueslist (multi-select, check list) or default: string items
+                        inputProperty.items = {
+                            type: 'string',
+                        };
+                    }
+                }
+            }
+            if (input.Example !== undefined && input.Example !== null) {
+                inputProperty.examples = Array.isArray(input.Example) ? input.Example : [input.Example];
+            }
+            yamlData.inputs.properties[input.Key] = inputProperty;
             if (input.Creds) {
                 yamlData.inputs.properties[input.Key].format = 'password';
             }
         }
         for (const output of transformationResult.outputs) {
-            yamlData.output.properties[output.Key] = {
+            const outputProperty = {
                 title: output.Title,
                 type: output.ValueType,
-                examples: output.Example,
             };
+            if (output.Example !== undefined && output.Example !== null) {
+                outputProperty.examples = Array.isArray(output.Example) ? output.Example : [output.Example];
+            }
+            // Ensure the key is valid and doesn't cause YAML issues
+            const safeKey = output.Key || 'unnamed_output';
+            yamlData.output.properties.output.items.properties[safeKey] = outputProperty;
+        }
+        try {
+            // Ensure the output properties object is properly initialized
+            if (!yamlData.output.properties.output.items.properties) {
+                yamlData.output.properties.output.items.properties = {};
+            }
+            const yamlString = js_yaml_1.default.dump(yamlData, { indent: 2, noRefs: true, lineWidth: -1 });
+            // Validate the YAML can be parsed back (catches structural issues)
+            let parsed;
+            try {
+                parsed = js_yaml_1.default.load(yamlString);
+            }
+            catch (parseError) {
+                console.error(`Generated invalid YAML for ${exportUid}:`, parseError);
+                console.error('YAML content:', yamlString.slice(0, 500));
+                throw new Error(`Failed to generate valid YAML for action ${exportUid}: ${parseError}`);
+            }
+            // Double-check the structure is correct
+            if (!parsed?.output?.properties?.output?.items?.properties) {
+                console.error(`YAML structure issue for ${exportUid}: output properties not properly nested`);
+                console.error('Parsed structure:', JSON.stringify(parsed?.output, null, 2));
+            }
+            // Write atomically using a temporary file to prevent corruption
+            const dir = (0, node_path_1.join)(outputPath, '..');
+            await node_fs_1.promises.mkdir(dir, { recursive: true });
+            // Write to a temporary file first, then rename (atomic operation)
+            const tempFile = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `${exportUid}-${Date.now()}-${Math.random().toString(36).slice(7)}.yaml`);
+            try {
+                await node_fs_1.promises.writeFile(tempFile, yamlString, 'utf8');
+                // Atomically move the temp file to the final location
+                await node_fs_1.promises.rename(tempFile, outputPath);
+            }
+            catch (writeError) {
+                // Clean up temp file if it exists
+                await node_fs_1.promises.unlink(tempFile).catch(() => { });
+                throw writeError;
+            }
+            return true;
+        }
+        catch (error) {
+            console.error(`Error generating action config for ${exportUid}:`, error);
+            throw error;
         }
-        const yamlString = js_yaml_1.default.dump(yamlData, { indent: 2 });
-        await this.createFile(outputPath, yamlString);
-        return true;
     }
     static async createFile(dir, data) {
-        await node_fs_1.promises.writeFile(dir, data);
+        await node_fs_1.promises.writeFile(dir, data, 'utf8');
     }
     static async generateConnectorManifest(connectorConfig, group, toDir) {
-        const connectorNameUid = `${connectorConfig.author || connectorConfig.vendor}_${group.connectorName}`
-            .replaceAll(/[^\w -]/g, '')
-            .replaceAll(/\s+/g, '_')
+        let connectorNameUid = `${connectorConfig.author || connectorConfig.vendor}_${group.connectorName}`
+            .replaceAll(/\W/g, '_') // Replace all non-word characters (including dashes, spaces, colons, etc.) with underscores
+            .replaceAll(/_+/g, '_') // Replace multiple consecutive underscores with a single underscore
+            .replaceAll(/^_|_$/g, '') // Remove leading and trailing underscores
             .toLowerCase();
+        // Truncate connector name to 50 characters
+        if (connectorNameUid.length > 50) {
+            connectorNameUid = connectorNameUid.slice(0, 50);
+        }
+        // Truncate title to 50 characters
+        let connectorTitle = group.connectorName;
+        if (connectorTitle.length > 50) {
+            connectorTitle = connectorTitle.slice(0, 50);
+        }
         const data = {
             author: connectorConfig.author || connectorConfig.vendor,
             bugs: '',
-            description: connectorConfig.description,
+            description: connectorConfig.description || group.connectorName,
             homepage: connectorConfig.homepage,
             iconImage: '../image/logo.png',
             keywords: ['Custom', 'User created'],
@@ -308,10 +1486,10 @@ class ConnectorGenerator {
                 },
             },
             name: connectorNameUid,
-            product: connectorConfig.product || 'Unknown Product',
+            product: connectorConfig.product || group.connectorName,
             repository: `https://github.com/swimlane-prosrv/t_${connectorNameUid}`,
             schema: 'connector/1',
-            title: group.connectorName,
+            title: connectorTitle,
             vendor: connectorConfig.vendor || 'Unknown Vendor',
             version: '1.0.0',
             runConfig: {
@@ -324,4 +1502,9 @@ class ConnectorGenerator {
     }
 }
 exports.ConnectorGenerator = ConnectorGenerator;
+ConnectorGenerator.ACTION_DESCRIPTION_MAX_LENGTH = 254;
+ConnectorGenerator.INPUTS_MERGE_PLACEHOLDER = '# INPUTS_MERGE_HERE';
+ConnectorGenerator.OUTPUT_DATE_CONVERSIONS_PLACEHOLDER = '__OUTPUT_DATE_CONVERSIONS__';
+ConnectorGenerator.TASK_EXECUTE_REQUEST_CALL = "swimlane.request('post', 'task/execute/record', json=data)";
+ConnectorGenerator.TASK_EXECUTE_WEBHOOK_CALL = 'swimlane._session.post(swimlane._execute_task_webhook_url, json=data)';
 //# sourceMappingURL=connector-generator.js.map